@apocaliss92/nodelink-js 0.1.7

package/dist/index.js

@@ -0,0 +1,4752 @@
+import {
+  BaichuanClient,
+  BaichuanEventEmitter,
+  BaichuanFrameParser,
+  BaichuanRtspServer,
+  BcUdpStream,
+  DUAL_LENS_DUAL_MOTION_MODELS,
+  DUAL_LENS_MODELS,
+  DUAL_LENS_SINGLE_MOTION_MODELS,
+  Intercom,
+  NVR_HUB_EXACT_TYPES,
+  NVR_HUB_MODEL_PATTERNS,
+  ReolinkBaichuanApi,
+  abilitiesHasAny,
+  asLogger,
+  autoDetectDeviceType,
+  computeDeviceCapabilities,
+  createDebugGateLogger,
+  createLogger,
+  createNativeStream,
+  createNullLogger,
+  createTaggedLogger,
+  decodeHeader,
+  discoverReolinkDevices,
+  discoverViaHttpScan,
+  discoverViaUdpBroadcast,
+  discoverViaUdpDirect,
+  encodeHeader,
+  flattenAbilitiesForChannel,
+  getConstructedVideoStreamOptions,
+  getGlobalLogger,
+  getVideoStream,
+  isDualLenseModel,
+  isNvrHubModel,
+  isTcpFailureThatShouldFallbackToUdp,
+  maskUid,
+  normalizeUid,
+  parseSupportXml,
+  setGlobalLogger
+} from "./chunk-JMT75JNG.js";
+import {
+  AesStreamDecryptor,
+  BC_AES_IV,
+  BC_CLASS_FILE_DOWNLOAD,
+  BC_CLASS_LEGACY,
+  BC_CLASS_MODERN_20,
+  BC_CLASS_MODERN_24,
+  BC_CLASS_MODERN_24_ALT,
+  BC_CMD_ID_ABILITY_INFO,
+  BC_CMD_ID_ALARM_EVENT_LIST,
+  BC_CMD_ID_AUDIO_ALARM_PLAY,
+  BC_CMD_ID_CHANNEL_INFO_ALL,
+  BC_CMD_ID_CMD_123,
+  BC_CMD_ID_CMD_209,
+  BC_CMD_ID_CMD_265,
+  BC_CMD_ID_CMD_440,
+  BC_CMD_ID_COVER_PREVIEW,
+  BC_CMD_ID_COVER_RESPONSE,
+  BC_CMD_ID_COVER_STANDALONE_458,
+  BC_CMD_ID_COVER_STANDALONE_459,
+  BC_CMD_ID_COVER_STANDALONE_460,
+  BC_CMD_ID_COVER_STANDALONE_461,
+  BC_CMD_ID_COVER_STANDALONE_462,
+  BC_CMD_ID_FILE_INFO_LIST_CLOSE,
+  BC_CMD_ID_FILE_INFO_LIST_DL_VIDEO,
+  BC_CMD_ID_FILE_INFO_LIST_DOWNLOAD,
+  BC_CMD_ID_FILE_INFO_LIST_GET,
+  BC_CMD_ID_FILE_INFO_LIST_OPEN,
+  BC_CMD_ID_FILE_INFO_LIST_REPLAY,
+  BC_CMD_ID_FILE_INFO_LIST_STOP,
+  BC_CMD_ID_FIND_REC_VIDEO_CLOSE,
+  BC_CMD_ID_FIND_REC_VIDEO_GET,
+  BC_CMD_ID_FIND_REC_VIDEO_OPEN,
+  BC_CMD_ID_FLOODLIGHT_STATUS_LIST,
+  BC_CMD_ID_GET_ABILITY_SUPPORT,
+  BC_CMD_ID_GET_ACCESS_USER_LIST,
+  BC_CMD_ID_GET_AI_ALARM,
+  BC_CMD_ID_GET_AI_CFG,
+  BC_CMD_ID_GET_AI_DENOISE,
+  BC_CMD_ID_GET_AUDIO_ALARM,
+  BC_CMD_ID_GET_AUDIO_CFG,
+  BC_CMD_ID_GET_AUDIO_TASK,
+  BC_CMD_ID_GET_BATTERY_INFO,
+  BC_CMD_ID_GET_BATTERY_INFO_LIST,
+  BC_CMD_ID_GET_DAY_NIGHT_THRESHOLD,
+  BC_CMD_ID_GET_DAY_RECORDS,
+  BC_CMD_ID_GET_EMAIL_TASK,
+  BC_CMD_ID_GET_FTP_TASK,
+  BC_CMD_ID_GET_HDD_INFO_LIST,
+  BC_CMD_ID_GET_KIT_AP_CFG,
+  BC_CMD_ID_GET_LED_STATE,
+  BC_CMD_ID_GET_MOTION_ALARM,
+  BC_CMD_ID_GET_ONLINE_USER_LIST,
+  BC_CMD_ID_GET_OSD_DATETIME,
+  BC_CMD_ID_GET_PIR_INFO,
+  BC_CMD_ID_GET_PTZ_POSITION,
+  BC_CMD_ID_GET_PTZ_PRESET,
+  BC_CMD_ID_GET_RECORD,
+  BC_CMD_ID_GET_RECORD_CFG,
+  BC_CMD_ID_GET_REC_ENC_CFG,
+  BC_CMD_ID_GET_SIREN_STATUS,
+  BC_CMD_ID_GET_SLEEP_STATE,
+  BC_CMD_ID_GET_STREAM_INFO_LIST,
+  BC_CMD_ID_GET_SUPPORT,
+  BC_CMD_ID_GET_SYSTEM_GENERAL,
+  BC_CMD_ID_GET_TIMELAPSE_CFG,
+  BC_CMD_ID_GET_VIDEO_INPUT,
+  BC_CMD_ID_GET_WHITE_LED,
+  BC_CMD_ID_GET_WIFI,
+  BC_CMD_ID_GET_WIFI_SIGNAL,
+  BC_CMD_ID_GET_ZOOM_FOCUS,
+  BC_CMD_ID_PING,
+  BC_CMD_ID_PTZ_CONTROL,
+  BC_CMD_ID_PTZ_CONTROL_PRESET,
+  BC_CMD_ID_PUSH_COORDINATE_POINT_LIST,
+  BC_CMD_ID_PUSH_DINGDONG_LIST,
+  BC_CMD_ID_PUSH_NET_INFO,
+  BC_CMD_ID_PUSH_SERIAL,
+  BC_CMD_ID_PUSH_SLEEP_STATUS,
+  BC_CMD_ID_PUSH_VIDEO_INPUT,
+  BC_CMD_ID_SET_AI_ALARM,
+  BC_CMD_ID_SET_AI_CFG,
+  BC_CMD_ID_SET_AUDIO_TASK,
+  BC_CMD_ID_SET_MOTION_ALARM,
+  BC_CMD_ID_SET_PIR_INFO,
+  BC_CMD_ID_SET_WHITE_LED_STATE,
+  BC_CMD_ID_SET_WHITE_LED_TASK,
+  BC_CMD_ID_SET_ZOOM_FOCUS,
+  BC_CMD_ID_SUPPORT,
+  BC_CMD_ID_TALK,
+  BC_CMD_ID_TALK_ABILITY,
+  BC_CMD_ID_TALK_CONFIG,
+  BC_CMD_ID_TALK_RESET,
+  BC_CMD_ID_UDP_KEEP_ALIVE,
+  BC_CMD_ID_VIDEO,
+  BC_CMD_ID_VIDEO_STOP,
+  BC_MAGIC,
+  BC_MAGIC_REV,
+  BC_TCP_DEFAULT_PORT,
+  BC_XML_KEY,
+  BaichuanVideoStream,
+  BcMediaAnnexBDecoder,
+  BcMediaCodec,
+  H264RtpDepacketizer,
+  H265RtpDepacketizer,
+  ReolinkCgiApi,
+  ReolinkHttpClient,
+  aesDecrypt,
+  aesEncrypt,
+  bcDecrypt,
+  bcEncrypt,
+  bcHeaderHasPayloadOffset,
+  buildAbilityInfoExtensionXml,
+  buildBinaryExtensionXml,
+  buildChannelExtensionXml,
+  buildFloodlightManualXml,
+  buildLoginXml,
+  buildPreviewStopXml,
+  buildPreviewStopXmlV11,
+  buildPreviewXml,
+  buildPreviewXmlV11,
+  buildPtzControlXml,
+  buildPtzPresetXml,
+  buildPtzPresetXmlV2,
+  buildRtspPath,
+  buildRtspUrl,
+  buildSirenManualXml,
+  buildSirenTimesXml,
+  buildStartZoomFocusXml,
+  buildWhiteLedStateXml,
+  collectCgiDiagnostics,
+  collectMultifocalDiagnostics,
+  collectNativeDiagnostics,
+  collectNvrDiagnostics,
+  convertToAnnexB,
+  convertToAnnexB2,
+  convertToLengthPrefixed,
+  createDiagnosticsBundle,
+  deriveAesKey,
+  detectVideoCodecFromNal,
+  extractPpsFromAnnexB,
+  extractSpsFromAnnexB,
+  extractVpsFromAnnexB,
+  getH265NalType,
+  getXmlText,
+  hasStartCodes,
+  hasStartCodes2,
+  isH264KeyframeAnnexB,
+  isH265Irap,
+  isH265KeyframeAnnexB,
+  isValidH264AnnexBAccessUnit,
+  isValidH265AnnexBAccessUnit,
+  md5HexUpper,
+  md5StrModern,
+  parseBcMedia,
+  parseRecordingFileName,
+  printNvrDiagnostics,
+  runAllDiagnosticsConsecutively,
+  runMultifocalDiagnosticsConsecutively,
+  sampleStreams,
+  splitAnnexBToNalPayloads,
+  splitAnnexBToNalPayloads2,
+  testChannelStreams,
+  xmlEscape,
+  zipDirectory
+} from "./chunk-MC2BRLLE.js";
+
+// src/reolink/AutodiscoveryClient.ts
+var AutodiscoveryClient = class {
+  options;
+  discoveredDevices = /* @__PURE__ */ new Map();
+  scanTimer = null;
+  isRunning = false;
+  currentScanPromise = null;
+  /**
+   * Costruttore del client di autodiscovery.
+   * 
+   * @param options - Opzioni di configurazione per il discovery
+   */
+  constructor(options = {}) {
+    this.options = {
+      scanIntervalMs: options.scanIntervalMs ?? 6e4,
+      // Default: 60 secondi
+      autoStart: options.autoStart ?? false
+    };
+    if (options.networkCidr !== void 0) {
+      this.options.networkCidr = options.networkCidr;
+    }
+    if (options.username !== void 0) {
+      this.options.username = options.username;
+    }
+    if (options.password !== void 0) {
+      this.options.password = options.password;
+    }
+    if (options.httpProbeTimeoutMs !== void 0) {
+      this.options.httpProbeTimeoutMs = options.httpProbeTimeoutMs;
+    }
+    if (options.maxConcurrentProbes !== void 0) {
+      this.options.maxConcurrentProbes = options.maxConcurrentProbes;
+    }
+    if (options.logger !== void 0) {
+      this.options.logger = options.logger;
+    }
+    if (options.httpPorts !== void 0) {
+      this.options.httpPorts = options.httpPorts;
+    }
+    if (options.discoveryMethod !== void 0) {
+      this.options.discoveryMethod = options.discoveryMethod;
+    }
+    if (options.udpBroadcastTimeoutMs !== void 0) {
+      this.options.udpBroadcastTimeoutMs = options.udpBroadcastTimeoutMs;
+    }
+    if (this.options.autoStart) {
+      this.start();
+    }
+  }
+  /**
+   * Avvia il discovery continuato.
+   * Se già in esecuzione, non fa nulla.
+   */
+  start() {
+    if (this.isRunning) {
+      this.options.logger?.warn?.("[Autodiscovery] Discovery already running");
+      return;
+    }
+    this.isRunning = true;
+    this.options.logger?.log?.(
+      `[Autodiscovery] Starting continuous discovery (interval: ${this.options.scanIntervalMs}ms)`
+    );
+    this.performScan();
+    this.scheduleNextScan();
+  }
+  /**
+   * Ferma il discovery continuato.
+   * Se non è in esecuzione, non fa nulla.
+   */
+  stop() {
+    if (!this.isRunning) {
+      this.options.logger?.warn?.("[Autodiscovery] Discovery not running");
+      return;
+    }
+    this.isRunning = false;
+    if (this.scanTimer) {
+      clearTimeout(this.scanTimer);
+      this.scanTimer = null;
+    }
+    this.options.logger?.log?.("[Autodiscovery] Discovery stopped");
+  }
+  /**
+   * Restituisce la lista corrente delle telecamere discoverate.
+   * 
+   * @returns Array di dispositivi discoverati, ordinati per host
+   */
+  getDiscoveredDevices() {
+    return Array.from(this.discoveredDevices.values()).sort((a, b) => {
+      return a.host.localeCompare(b.host);
+    });
+  }
+  /**
+   * Restituisce il numero di telecamere attualmente discoverate.
+   * 
+   * @returns Numero di dispositivi discoverati
+   */
+  getDeviceCount() {
+    return this.discoveredDevices.size;
+  }
+  /**
+   * Verifica se il discovery è attualmente in esecuzione.
+   * 
+   * @returns `true` se il discovery è in esecuzione, `false` altrimenti
+   */
+  isActive() {
+    return this.isRunning;
+  }
+  /**
+   * Forza un scan immediato (non aspetta l'intervallo programmato).
+   * Se uno scan è già in corso, attende il completamento prima di avviarne uno nuovo.
+   * 
+   * @returns Promise che si risolve quando lo scan è completato
+   */
+  async scanNow() {
+    if (this.currentScanPromise) {
+      this.options.logger?.log?.("[Autodiscovery] Scan already in progress, waiting for completion...");
+      await this.currentScanPromise;
+      return;
+    }
+    await this.performScan();
+  }
+  /**
+   * Rimuove un dispositivo dalla lista (utile se si sa che non è più disponibile).
+   * 
+   * @param host - Indirizzo IP del dispositivo da rimuovere
+   * @returns `true` se il dispositivo è stato rimosso, `false` se non era presente
+   */
+  removeDevice(host) {
+    const removed = this.discoveredDevices.delete(host);
+    if (removed) {
+      this.options.logger?.log?.(`[Autodiscovery] Device removed: ${host}`);
+    }
+    return removed;
+  }
+  /**
+   * Pulisce tutte le telecamere discoverate dalla lista.
+   */
+  clearDevices() {
+    const count = this.discoveredDevices.size;
+    this.discoveredDevices.clear();
+    this.options.logger?.log?.(`[Autodiscovery] Removed ${count} device(s) from list`);
+  }
+  /**
+   * Esegue un singolo scan della rete.
+   */
+  async performScan() {
+    const scanPromise = (async () => {
+      try {
+        this.options.logger?.log?.("[Autodiscovery] Starting scan...");
+        const discoveryMethod = this.options.discoveryMethod ?? "http";
+        const discoveryOptions = {
+          enableHttpScanning: discoveryMethod === "http" || discoveryMethod === "both",
+          enableUdpDiscovery: discoveryMethod === "udp" || discoveryMethod === "both"
+        };
+        if (this.options.networkCidr !== void 0) {
+          discoveryOptions.networkCidr = this.options.networkCidr;
+        }
+        if (this.options.username !== void 0) {
+          discoveryOptions.username = this.options.username;
+        }
+        if (this.options.password !== void 0) {
+          discoveryOptions.password = this.options.password;
+        }
+        if (this.options.httpProbeTimeoutMs !== void 0) {
+          discoveryOptions.httpProbeTimeoutMs = this.options.httpProbeTimeoutMs;
+        }
+        if (this.options.maxConcurrentProbes !== void 0) {
+          discoveryOptions.maxConcurrentProbes = this.options.maxConcurrentProbes;
+        }
+        if (this.options.logger !== void 0) {
+          discoveryOptions.logger = this.options.logger;
+        }
+        if (this.options.httpPorts !== void 0) {
+          discoveryOptions.httpPorts = this.options.httpPorts;
+        }
+        if (this.options.udpBroadcastTimeoutMs !== void 0) {
+          discoveryOptions.udpBroadcastTimeoutMs = this.options.udpBroadcastTimeoutMs;
+        }
+        let discovered = [];
+        if (discoveryMethod === "http" || discoveryMethod === "both") {
+          const httpDevices = await discoverViaHttpScan(discoveryOptions);
+          discovered.push(...httpDevices);
+        }
+        if (discoveryMethod === "udp" || discoveryMethod === "both") {
+          const udpDevices = await discoverViaUdpBroadcast(discoveryOptions);
+          discovered.push(...udpDevices);
+        }
+        const beforeCount = this.discoveredDevices.size;
+        const newDevices = [];
+        const updatedDevices = [];
+        for (const device of discovered) {
+          const existing = this.discoveredDevices.get(device.host);
+          if (existing) {
+            const updated = this.mergeDeviceInfo(existing, device);
+            if (updated) {
+              updatedDevices.push(updated);
+            }
+          } else {
+            this.discoveredDevices.set(device.host, { ...device });
+            newDevices.push(device);
+          }
+        }
+        const afterCount = this.discoveredDevices.size;
+        this.options.logger?.log?.(
+          `[Autodiscovery] Scan completed: ${newDevices.length} new, ${updatedDevices.length} updated, total: ${afterCount}`
+        );
+        for (const device of newDevices) {
+          const details = [];
+          if (device.model) details.push(`Model: ${device.model}`);
+          if (device.name) details.push(`Name: ${device.name}`);
+          if (device.uid) details.push(`UID: ${device.uid}`);
+          if (device.firmwareVersion) details.push(`Firmware: ${device.firmwareVersion}`);
+          if (device.httpPort) details.push(`HTTP Port: ${device.httpPort}`);
+          if (device.httpsPort) details.push(`HTTPS Port: ${device.httpsPort}`);
+          details.push(`Discovery Method: ${device.discoveryMethod}`);
+          if (device.supportsHttps !== void 0) details.push(`HTTPS: ${device.supportsHttps}`);
+          if (device.httpAccessible !== void 0) details.push(`HTTP Accessible: ${device.httpAccessible}`);
+          this.options.logger?.log?.(
+            `[Autodiscovery] \u{1F195} NEW DEVICE DISCOVERED - Host: ${device.host}${details.length > 0 ? ` | ${details.join(" | ")}` : ""}`
+          );
+        }
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        this.options.logger?.error?.(`[Autodiscovery] Error during scan: ${msg}`);
+      }
+    })();
+    this.currentScanPromise = scanPromise;
+    await scanPromise;
+    this.currentScanPromise = null;
+  }
+  /**
+   * Unisce le informazioni di un dispositivo esistente con quelle di un nuovo scan.
+   * Restituisce il dispositivo aggiornato se ci sono state modifiche, altrimenti `null`.
+   */
+  mergeDeviceInfo(existing, updated) {
+    let hasChanges = false;
+    if (!existing.model && updated.model) {
+      existing.model = updated.model;
+      hasChanges = true;
+    }
+    if (!existing.uid && updated.uid) {
+      existing.uid = updated.uid;
+      hasChanges = true;
+    }
+    if (!existing.name && updated.name) {
+      existing.name = updated.name;
+      hasChanges = true;
+    }
+    if (!existing.firmwareVersion && updated.firmwareVersion) {
+      existing.firmwareVersion = updated.firmwareVersion;
+      hasChanges = true;
+    }
+    if (updated.httpPort && !existing.httpPort) {
+      existing.httpPort = updated.httpPort;
+      hasChanges = true;
+    }
+    if (updated.httpsPort && !existing.httpsPort) {
+      existing.httpsPort = updated.httpsPort;
+      hasChanges = true;
+    }
+    if (updated.supportsHttps !== void 0 && existing.supportsHttps !== updated.supportsHttps) {
+      existing.supportsHttps = updated.supportsHttps;
+      hasChanges = true;
+    }
+    if (updated.httpAccessible !== void 0 && existing.httpAccessible !== updated.httpAccessible) {
+      existing.httpAccessible = updated.httpAccessible;
+      hasChanges = true;
+    }
+    return hasChanges ? existing : null;
+  }
+  /**
+   * Programma il prossimo scan.
+   */
+  scheduleNextScan() {
+    if (!this.isRunning) {
+      return;
+    }
+    this.scanTimer = setTimeout(() => {
+      this.scanTimer = null;
+      if (this.isRunning) {
+        this.performScan().finally(() => {
+          if (this.isRunning) {
+            this.scheduleNextScan();
+          }
+        });
+      }
+    }, this.options.scanIntervalMs);
+  }
+};
+
+// src/reolink/baichuan/endpoints-server.ts
+import http from "http";
+import { spawn } from "child_process";
+function parseIntParam(v, def) {
+  if (v == null) return def;
+  const n = Number.parseInt(v, 10);
+  return Number.isFinite(n) ? n : def;
+}
+function parseProfile(v) {
+  const p = (v ?? "sub").trim();
+  if (p === "main" || p === "sub" || p === "ext") return p;
+  throw new Error("Invalid profile (must be main, sub, or ext)");
+}
+function parseNativeVariant(v) {
+  const s = (v ?? "default").trim().toLowerCase();
+  if (s === "" || s === "default") return "default";
+  if (s === "autotrack") return "autotrack";
+  if (s === "telephoto") return "telephoto";
+  throw new Error("Invalid variant (must be default, autotrack, or telephoto)");
+}
+function parseDateParam(v) {
+  if (!v) throw new Error("Missing time");
+  const d = new Date(v);
+  if (Number.isNaN(d.getTime()))
+    throw new Error("Invalid time (expected ISO string)");
+  return d;
+}
+function parseDateParamNamed(name, v) {
+  if (!v) throw new Error(`Missing ${name}`);
+  const d = new Date(v);
+  if (Number.isNaN(d.getTime()))
+    throw new Error(`Invalid ${name} (expected ISO string)`);
+  return d;
+}
+function createBaichuanEndpointsServer(opts) {
+  const api = new ReolinkBaichuanApi({
+    ...opts.baichuan
+  });
+  const listenHost = opts.listenHost ?? "127.0.0.1";
+  const rtspListenHost = opts.rtspListenHost ?? "127.0.0.1";
+  const rtspServers = /* @__PURE__ */ new Map();
+  const server = http.createServer(async (req, res) => {
+    try {
+      if (!req.url) {
+        res.statusCode = 400;
+        res.end("Bad Request");
+        return;
+      }
+      const u = new URL(req.url, `http://${listenHost}:${opts.listenPort}`);
+      if (req.method !== "GET") {
+        res.statusCode = 405;
+        res.setHeader("Allow", "GET");
+        res.end("Method Not Allowed");
+        return;
+      }
+      if (u.pathname === "/stream") {
+        const channel = parseIntParam(u.searchParams.get("channel"), 0);
+        const profile = parseProfile(u.searchParams.get("profile"));
+        const variant = parseNativeVariant(u.searchParams.get("variant"));
+        if (!Number.isFinite(channel) || channel < 0) {
+          res.statusCode = 400;
+          res.end("Invalid channel");
+          return;
+        }
+        const key = `${channel}:${profile}:${variant}`;
+        const cached = rtspServers.get(key);
+        if (cached) {
+          res.setHeader("Content-Type", "application/json");
+          res.end(JSON.stringify({ rtspUrl: cached.url }));
+          return;
+        }
+        const rtsp = await api.createRtspStream(channel, profile, {
+          listenHost: rtspListenHost,
+          listenPort: 0,
+          path: `/stream/${channel}/${profile}${variant === "default" ? "" : `/${variant}`}`,
+          ...variant === "default" ? {} : { variant }
+        });
+        const rtspUrl = rtsp.getRtspUrl();
+        rtspServers.set(key, { url: rtspUrl });
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ rtspUrl }));
+        return;
+      }
+      if (u.pathname === "/download") {
+        const channel = parseIntParam(u.searchParams.get("channel"), 0);
+        const uid = (u.searchParams.get("uid") ?? "").trim();
+        const fileName = (u.searchParams.get("fileName") ?? "").trim();
+        const timeoutMs = parseIntParam(
+          u.searchParams.get("timeoutMs"),
+          12e4
+        );
+        if (!uid) {
+          res.statusCode = 400;
+          res.end("Missing uid");
+          return;
+        }
+        if (!fileName) {
+          res.statusCode = 400;
+          res.end("Missing fileName");
+          return;
+        }
+        const buf = await api.downloadRecording({
+          channel,
+          uid,
+          fileName,
+          timeoutMs
+        });
+        const outName = fileName.split("/").filter(Boolean).at(-1) ?? "recording.bin";
+        res.statusCode = 200;
+        res.setHeader("Content-Type", "application/octet-stream");
+        res.setHeader(
+          "Content-Disposition",
+          `attachment; filename="${outName}"`
+        );
+        res.setHeader("Content-Length", String(buf.length));
+        res.end(buf);
+        return;
+      }
+      if (u.pathname === "/recordings") {
+        const channel = parseIntParam(u.searchParams.get("channel"), 0);
+        const streamType = (u.searchParams.get("streamType") ?? "subStream").trim();
+        const start = parseDateParamNamed("start", u.searchParams.get("start"));
+        const end = parseDateParamNamed("end", u.searchParams.get("end"));
+        const recordType = (u.searchParams.get("recordType") ?? "").trim();
+        const count = parseIntParam(u.searchParams.get("count"), 0);
+        const timeoutMs = parseIntParam(
+          u.searchParams.get("timeoutMs"),
+          3e4
+        );
+        if (streamType !== "mainStream" && streamType !== "subStream") {
+          res.statusCode = 400;
+          res.end("Invalid streamType (must be mainStream or subStream)");
+          return;
+        }
+        let recordings = await api.getVideoclips({
+          channel,
+          start,
+          end,
+          streamType,
+          ...recordType ? { recordType } : {},
+          timeoutMs
+        });
+        if (count > 0) recordings = recordings.slice(-count);
+        res.statusCode = 200;
+        res.setHeader("Content-Type", "application/json");
+        res.end(
+          JSON.stringify({
+            channel,
+            streamType,
+            start: start.toISOString(),
+            end: end.toISOString(),
+            recordings
+          })
+        );
+        return;
+      }
+      if (u.pathname === "/vod/stream" || u.pathname === "/vod/download") {
+        const channel = parseIntParam(u.searchParams.get("channel"), 0);
+        const fileName = (u.searchParams.get("fileName") ?? "").trim();
+        const streamType = (u.searchParams.get("streamType") ?? "mainStream").trim();
+        const rtspTransport = (u.searchParams.get("rtmpTransport") ?? "tcp").trim();
+        if (!fileName) {
+          res.statusCode = 400;
+          res.end("Missing fileName");
+          return;
+        }
+        if (streamType !== "mainStream" && streamType !== "subStream") {
+          res.statusCode = 400;
+          res.end("Invalid streamType (must be mainStream or subStream)");
+          return;
+        }
+        if (rtspTransport !== "tcp" && rtspTransport !== "udp") {
+          res.statusCode = 400;
+          res.end("Invalid rtmpTransport (must be tcp or udp)");
+          return;
+        }
+        const rtmpUrl = await api.getVodRtmpUrl({
+          channel,
+          fileName,
+          streamType,
+          ensureEnabled: true
+        });
+        const outName = fileName.split("/").filter(Boolean).at(-1) ?? "recording.mp4";
+        if (u.pathname === "/vod/stream") {
+          res.writeHead(200, {
+            "Content-Type": "video/mp2t",
+            "Cache-Control": "no-cache",
+            Connection: "close"
+          });
+          const ff2 = spawn("ffmpeg", [
+            "-hide_banner",
+            "-loglevel",
+            "error",
+            "-rtmp_live",
+            "live",
+            "-i",
+            rtmpUrl,
+            "-c",
+            "copy",
+            "-f",
+            "mpegts",
+            "pipe:1"
+          ]);
+          ff2.stdout.pipe(res);
+          const cleanup2 = () => {
+            ff2.kill("SIGKILL");
+          };
+          req.on("close", cleanup2);
+          res.on("close", cleanup2);
+          ff2.on("close", () => {
+            res.end();
+          });
+          return;
+        }
+        res.statusCode = 200;
+        res.setHeader("Content-Type", "video/mp4");
+        res.setHeader(
+          "Content-Disposition",
+          `attachment; filename="${outName}"`
+        );
+        res.setHeader("Cache-Control", "no-cache");
+        res.setHeader("Connection", "close");
+        const ff = spawn("ffmpeg", [
+          "-hide_banner",
+          "-loglevel",
+          "error",
+          "-rtmp_live",
+          "live",
+          "-i",
+          rtmpUrl,
+          "-c",
+          "copy",
+          "-movflags",
+          "frag_keyframe+empty_moov",
+          "-f",
+          "mp4",
+          "pipe:1"
+        ]);
+        ff.stdout.pipe(res);
+        const cleanup = () => {
+          ff.kill("SIGKILL");
+        };
+        req.on("close", cleanup);
+        res.on("close", cleanup);
+        ff.on("close", () => {
+          res.end();
+        });
+        return;
+      }
+      if (u.pathname === "/replay/cover.jpg") {
+        const channel = parseIntParam(u.searchParams.get("channel"), 0);
+        const time = parseDateParam(u.searchParams.get("time"));
+        const snapType = (u.searchParams.get("snapType") ?? "sub").trim();
+        const timeoutMs = parseIntParam(
+          u.searchParams.get("timeoutMs"),
+          3e4
+        );
+        const jpegQuality = parseIntParam(u.searchParams.get("jpegQuality"), 2);
+        if (snapType !== "main" && snapType !== "sub") {
+          res.statusCode = 400;
+          res.end("Invalid snapType (must be main or sub)");
+          return;
+        }
+        const { jpeg, snapshot } = await api.getVideoclipThumbnailJpegRaw({
+          channel,
+          time,
+          snapType,
+          timeoutMs,
+          jpegQuality
+        });
+        res.statusCode = 200;
+        res.setHeader("Content-Type", "image/jpeg");
+        res.setHeader("Cache-Control", "no-cache");
+        res.setHeader("X-Reolink-Encoding", snapshot.encoding);
+        res.setHeader("X-Reolink-Frame-Length", String(snapshot.frameLength));
+        res.setHeader("Content-Length", String(jpeg.length));
+        res.end(jpeg);
+        return;
+      }
+      if (u.pathname === "/replay/stream.mp4") {
+        const channel = parseIntParam(u.searchParams.get("channel"), 0);
+        const fileName = (u.searchParams.get("fileName") ?? "").trim();
+        if (!fileName) {
+          res.statusCode = 400;
+          res.end("Missing fileName");
+          return;
+        }
+        const { mp4, stop } = await api.createRecordingReplayMp4Stream({
+          channel,
+          fileName
+        });
+        res.writeHead(200, {
+          "Content-Type": "video/mp4",
+          "Cache-Control": "no-cache",
+          Connection: "close"
+        });
+        mp4.pipe(res);
+        const cleanup = () => {
+          void stop();
+          try {
+            mp4.destroy();
+          } catch {
+          }
+        };
+        req.on("close", cleanup);
+        res.on("close", cleanup);
+        mp4.on("end", () => {
+          res.end();
+        });
+        mp4.on("error", () => {
+          res.end();
+        });
+        return;
+      }
+      res.statusCode = 404;
+      res.end("Not Found");
+    } catch (e) {
+      res.statusCode = 500;
+      res.setHeader("Content-Type", "text/plain");
+      res.end(e instanceof Error ? e.message : String(e));
+    }
+  });
+  server.on("close", () => {
+    void api.close().catch(() => void 0);
+  });
+  return server;
+}
+
+// src/rtsp/server.ts
+import http2 from "http";
+import { spawn as spawn2 } from "child_process";
+function createRtspProxyServer(opts) {
+  return http2.createServer((req, res) => {
+    if (!req.url) {
+      res.statusCode = 400;
+      res.end("Bad Request");
+      return;
+    }
+    const u = new URL(req.url, `http://127.0.0.1:${opts.listenPort}`);
+    if (u.pathname !== "/stream") {
+      res.statusCode = 404;
+      res.end("Not Found");
+      return;
+    }
+    const channel = Number(u.searchParams.get("channel") ?? "0");
+    const profile = u.searchParams.get("profile") ?? "sub";
+    if (!Number.isFinite(channel) || channel < 0) {
+      res.statusCode = 400;
+      res.end("Invalid channel");
+      return;
+    }
+    if (profile !== "main" && profile !== "sub" && profile !== "ext") {
+      res.statusCode = 400;
+      res.end("Invalid profile (must be main, sub, or ext)");
+      return;
+    }
+    const rtspUrl = buildRtspUrl({
+      host: opts.host,
+      username: opts.username,
+      password: opts.password,
+      channel,
+      stream: profile,
+      ...opts.rtspPort === void 0 ? {} : { port: opts.rtspPort }
+    });
+    res.writeHead(200, {
+      "Content-Type": "video/mp2t",
+      "Cache-Control": "no-cache",
+      Connection: "close"
+    });
+    const rtspTransport = opts.rtspTransport ?? "tcp";
+    const ff = spawn2("ffmpeg", [
+      "-hide_banner",
+      "-loglevel",
+      "error",
+      "-rtsp_transport",
+      rtspTransport,
+      "-i",
+      rtspUrl,
+      "-an",
+      "-c:v",
+      "copy",
+      "-f",
+      "mpegts",
+      "pipe:1"
+    ]);
+    ff.stdout.pipe(res);
+    ff.stderr.on("data", () => {
+    });
+    const cleanup = () => {
+      ff.kill("SIGKILL");
+    };
+    req.on("close", cleanup);
+    res.on("close", cleanup);
+    ff.on("close", () => {
+      res.end();
+    });
+  });
+}
+
+// src/rfc/rfc4571.ts
+import crypto from "crypto";
+function buildRfc4571Sdp(video, audio) {
+  let out = "v=0\r\n";
+  out += "o=- 0 0 IN IP4 0.0.0.0\r\n";
+  out += "s=No Name\r\n";
+  out += "t=0 0\r\n";
+  out += `m=video 0 RTP/AVP ${video.payloadType}\r
+`;
+  out += "c=IN IP4 0.0.0.0\r\n";
+  out += `a=rtpmap:${video.payloadType} ${video.videoType}/90000\r
+`;
+  if (video.videoType === "H264" && video.h264) {
+    const spsB64 = video.h264.sps.toString("base64");
+    const ppsB64 = video.h264.pps.toString("base64");
+    const pli = video.h264.profileLevelId ? `profile-level-id=${video.h264.profileLevelId};` : "";
+    out += `a=fmtp:${video.payloadType} packetization-mode=1;${pli}sprop-parameter-sets=${spsB64},${ppsB64}\r
+`;
+  }
+  if (video.videoType === "H265" && video.h265) {
+    const vpsB64 = video.h265.vps.toString("base64");
+    const spsB64 = video.h265.sps.toString("base64");
+    const ppsB64 = video.h265.pps.toString("base64");
+    out += `a=fmtp:${video.payloadType} sprop-vps=${vpsB64};sprop-sps=${spsB64};sprop-pps=${ppsB64}\r
+`;
+  }
+  if (audio?.codec === "aac") {
+    out += `m=audio 0 RTP/AVP ${audio.payloadType}\r
+`;
+    out += "c=IN IP4 0.0.0.0\r\n";
+    out += "b=AS:128\r\n";
+    out += `a=rtpmap:${audio.payloadType} MPEG4-GENERIC/${audio.sampleRate}/${audio.channels}\r
+`;
+    out += `a=fmtp:${audio.payloadType} profile-level-id=1; mode=AAC-hbr; sizelength=13; indexlength=3; indexdeltalength=3; config=${audio.configHex}\r
+`;
+  }
+  if (audio?.codec === "opus") {
+    out += `m=audio 0 RTP/AVP ${audio.payloadType}\r
+`;
+    out += "c=IN IP4 0.0.0.0\r\n";
+    out += "b=AS:128\r\n";
+    out += `a=rtpmap:${audio.payloadType} opus/${audio.sampleRate}/${audio.channels}\r
+`;
+  }
+  return out;
+}
+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 findAnnexBStartCodeOffset(data, maxScan = 64) {
+  if (!data?.length) return -1;
+  const len = Math.min(data.length, Math.max(0, maxScan));
+  for (let i = 0; i + 3 < len; i++) {
+    if (data[i] !== 0 || data[i + 1] !== 0) continue;
+    if (data[i + 2] === 1) return i;
+    if (data[i + 2] === 0 && data[i + 3] === 1) return i;
+  }
+  return -1;
+}
+function stripLeadingAnnexBStartCode(data) {
+  if (data.length >= 4 && data[0] === 0 && data[1] === 0) {
+    if (data[2] === 1) return data.subarray(3);
+    if (data[2] === 0 && data[3] === 1) return data.subarray(4);
+  }
+  return data;
+}
+function splitLengthPrefixedToNals(data, lengthSize, endian) {
+  const nals = [];
+  let offset = 0;
+  const readLen = (buf, at) => {
+    if (lengthSize === 4)
+      return endian === "be" ? buf.readUInt32BE(at) : buf.readUInt32LE(at);
+    if (lengthSize === 2)
+      return endian === "be" ? buf.readUInt16BE(at) : buf.readUInt16LE(at);
+    if (lengthSize === 3) {
+      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;
+    }
+    return buf.readUInt8(at);
+  };
+  while (offset + lengthSize <= data.length) {
+    const nalLen = readLen(data, offset);
+    offset += lengthSize;
+    if (!nalLen) return [];
+    if (offset + nalLen > data.length) return [];
+    const nal = data.subarray(offset, offset + nalLen);
+    offset += nalLen;
+    if (nal.length) nals.push(nal);
+  }
+  if (offset !== data.length) return [];
+  return nals;
+}
+function scoreNals(videoType, nals) {
+  if (!nals.length) return Number.POSITIVE_INFINITY;
+  let invalid = 0;
+  for (const nal of nals) {
+    if (!nal.length) {
+      invalid++;
+      continue;
+    }
+    if ((nal[0] & 128) !== 0) {
+      invalid += 10;
+      continue;
+    }
+    if (videoType === "H264") {
+      const t = nal[0] & 31;
+      if (t < 1 || t > 23) invalid++;
+    } else if (videoType === "H265") {
+      if (nal.length < 2) {
+        invalid++;
+        continue;
+      }
+      const t = nal[0] >> 1 & 63;
+      const isValid = t >= 0 && t <= 29 || t >= 32 && t <= 40 || t >= 48 && t <= 50;
+      if (!isValid) invalid++;
+    }
+  }
+  return invalid;
+}
+function splitAccessUnitToNalsBestEffort(accessUnit, videoType) {
+  if (!accessUnit?.length) return [];
+  const candidates = [];
+  const scOffset = findAnnexBStartCodeOffset(accessUnit, 64);
+  if (scOffset >= 0) {
+    const annex = scOffset === 0 ? accessUnit : accessUnit.subarray(scOffset);
+    const nals = splitAnnexBToNals(annex);
+    if (nals.length) candidates.push(nals);
+  }
+  candidates.push(splitLengthPrefixedToNals(accessUnit, 4, "be"));
+  candidates.push(splitLengthPrefixedToNals(accessUnit, 4, "le"));
+  candidates.push(splitLengthPrefixedToNals(accessUnit, 3, "be"));
+  candidates.push(splitLengthPrefixedToNals(accessUnit, 3, "le"));
+  candidates.push(splitLengthPrefixedToNals(accessUnit, 2, "be"));
+  candidates.push(splitLengthPrefixedToNals(accessUnit, 2, "le"));
+  candidates.push(splitLengthPrefixedToNals(accessUnit, 1, "be"));
+  const stripped = stripLeadingAnnexBStartCode(accessUnit);
+  if (stripped.length) candidates.push([stripped]);
+  let best = [];
+  let bestScore = Number.POSITIVE_INFINITY;
+  for (const cand of candidates) {
+    if (!cand.length) continue;
+    const s = scoreNals(videoType, cand);
+    if (s < bestScore) {
+      bestScore = s;
+      best = cand;
+      if (bestScore === 0) break;
+    }
+  }
+  return best;
+}
+function extractH264ParamSetsFromAccessUnit(annexB) {
+  const nals = splitAccessUnitToNalsBestEffort(annexB, "H264");
+  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) {
+        const hex = Buffer.from([nal[1], nal[2], nal[3]]).toString("hex");
+        profileLevelId = 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;
+}
+function extractH265ParamSetsFromAccessUnit(annexB) {
+  const nals = splitAccessUnitToNalsBestEffort(annexB, "H265");
+  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 aacSampleRates = [
+  96e3,
+  88200,
+  64e3,
+  48e3,
+  44100,
+  32e3,
+  24e3,
+  22050,
+  16e3,
+  12e3,
+  11025,
+  8e3,
+  7350
+];
+function buildAacAudioSpecificConfigHex(params) {
+  const { sampleRate, channels } = params;
+  const audioObjectType = params.audioObjectType ?? 2;
+  const samplingFreqIndex = aacSampleRates.indexOf(sampleRate);
+  if (samplingFreqIndex < 0) return;
+  if (!Number.isFinite(channels) || channels <= 0 || channels > 15) return;
+  if (!Number.isFinite(audioObjectType) || audioObjectType <= 0 || audioObjectType > 31)
+    return;
+  const asc = (audioObjectType & 31) << 11 | (samplingFreqIndex & 15) << 7 | (channels & 15) << 3;
+  return asc.toString(16).padStart(4, "0");
+}
+function parseAdtsHeader(adtsFrame) {
+  if (adtsFrame.length < 7) return null;
+  if (adtsFrame[0] !== 255 || (adtsFrame[1] & 240) !== 240) return null;
+  const protectionAbsent = (adtsFrame[1] & 1) === 1;
+  const profile = (adtsFrame[2] & 192) >> 6;
+  const audioObjectType = profile + 1;
+  const samplingFreqIndex = (adtsFrame[2] & 60) >> 2;
+  const sampleRate = aacSampleRates[samplingFreqIndex] ?? 0;
+  const channels = (adtsFrame[2] & 1) << 2 | (adtsFrame[3] & 192) >> 6;
+  if (!sampleRate || !channels) return null;
+  const headerLength = protectionAbsent ? 7 : 9;
+  if (adtsFrame.length < headerLength) return null;
+  const asc = (audioObjectType & 31) << 11 | (samplingFreqIndex & 15) << 7 | (channels & 15) << 3;
+  const configHex = asc.toString(16).padStart(4, "0");
+  return { headerLength, sampleRate, channels, configHex };
+}
+var RtpWriter = class {
+  constructor(payloadType) {
+    this.payloadType = payloadType;
+    this.seq = crypto.randomBytes(2).readUInt16BE(0);
+    this.timestamp = crypto.randomBytes(4).readUInt32BE(0);
+  }
+  seq = 0;
+  timestamp = 0;
+  ssrc = crypto.randomBytes(4).readUInt32BE(0);
+  setTimestamp(ts) {
+    this.timestamp = ts >>> 0;
+  }
+  getTimestamp() {
+    return this.timestamp >>> 0;
+  }
+  advanceTimestamp(delta) {
+    this.timestamp = this.timestamp + (delta >>> 0) >>> 0;
+  }
+  writePacket(payload, marker) {
+    const header = Buffer.alloc(12);
+    header[0] = 128;
+    header[1] = (marker ? 128 : 0) | this.payloadType & 127;
+    header.writeUInt16BE(this.seq & 65535, 2);
+    header.writeUInt32BE(this.timestamp >>> 0, 4);
+    header.writeUInt32BE(this.ssrc >>> 0, 8);
+    this.seq = this.seq + 1 & 65535;
+    return Buffer.concat([header, payload]);
+  }
+};
+function packetizeH264(nal, rtp, opts, markerOnLast, isLastNal) {
+  const max = opts.maxRtpPayload;
+  const out = [];
+  if (nal.length <= max) {
+    out.push(rtp.writePacket(nal, markerOnLast && isLastNal));
+    return out;
+  }
+  const nal0 = nal[0];
+  const f = nal0 & 128;
+  const nri = nal0 & 96;
+  const type = nal0 & 31;
+  const fuIndicator = f | nri | 28;
+  const data = nal.subarray(1);
+  let offset = 0;
+  while (offset < data.length) {
+    const remaining = data.length - offset;
+    const chunkLen = Math.min(remaining, max - 2);
+    const start = offset === 0;
+    const end = offset + chunkLen >= data.length;
+    const fuHeader = (start ? 128 : 0) | (end ? 64 : 0) | type & 31;
+    const payload = Buffer.concat([
+      Buffer.from([fuIndicator, fuHeader]),
+      data.subarray(offset, offset + chunkLen)
+    ]);
+    out.push(rtp.writePacket(payload, markerOnLast && isLastNal && end));
+    offset += chunkLen;
+  }
+  return out;
+}
+function packetizeH265(nal, rtp, opts, markerOnLast, isLastNal) {
+  const max = opts.maxRtpPayload;
+  const out = [];
+  if (nal.length <= max) {
+    out.push(rtp.writePacket(nal, markerOnLast && isLastNal));
+    return out;
+  }
+  if (nal.length < 3) return out;
+  const nalHeader0 = nal[0];
+  const nalHeader1 = nal[1];
+  const nalType = nalHeader0 >> 1 & 63;
+  const fuIndicator0 = nalHeader0 & 129 | 49 << 1;
+  const fuIndicator1 = nalHeader1;
+  const data = nal.subarray(2);
+  let offset = 0;
+  while (offset < data.length) {
+    const remaining = data.length - offset;
+    const chunkLen = Math.min(remaining, max - 3);
+    const start = offset === 0;
+    const end = offset + chunkLen >= data.length;
+    const fuHeader = (start ? 128 : 0) | (end ? 64 : 0) | nalType & 63;
+    const payload = Buffer.concat([
+      Buffer.from([fuIndicator0, fuIndicator1, fuHeader]),
+      data.subarray(offset, offset + chunkLen)
+    ]);
+    out.push(rtp.writePacket(payload, markerOnLast && isLastNal && end));
+    offset += chunkLen;
+  }
+  return out;
+}
+function packetizeAacAdtsFrame(adts, rtp) {
+  const parsed = parseAdtsHeader(adts);
+  if (!parsed) return { packets: [] };
+  const raw = adts.subarray(parsed.headerLength);
+  if (!raw.length) return { packets: [] };
+  const auHeadersLength = Buffer.from([0, 16]);
+  const auSize = raw.length & 8191;
+  const auHeader = Buffer.alloc(2);
+  auHeader[0] = auSize >> 5 & 255;
+  auHeader[1] = (auSize & 31) << 3;
+  const payload = Buffer.concat([auHeadersLength, auHeader, raw]);
+  return {
+    packets: [rtp.writePacket(payload, true)],
+    config: {
+      sampleRate: parsed.sampleRate,
+      channels: parsed.channels,
+      configHex: parsed.configHex
+    }
+  };
+}
+function packetizeAacRawFrame(raw, rtp) {
+  if (!raw?.length) return { packets: [] };
+  const auHeadersLength = Buffer.from([0, 16]);
+  const auSize = raw.length & 8191;
+  const auHeader = Buffer.alloc(2);
+  auHeader[0] = auSize >> 5 & 255;
+  auHeader[1] = (auSize & 31) << 3;
+  const payload = Buffer.concat([auHeadersLength, auHeader, raw]);
+  return {
+    packets: [rtp.writePacket(payload, true)]
+  };
+}
+var Rfc4571Muxer = class _Rfc4571Muxer {
+  constructor(logger, videoPayloadType, audioPayloadType, videoFpsFallback = 25, maxRtpPayload = 1200) {
+    this.logger = logger;
+    this.videoPayloadType = videoPayloadType;
+    this.maxRtpPayload = maxRtpPayload;
+    this.videoRtp = new RtpWriter(videoPayloadType);
+    if (audioPayloadType !== void 0) {
+      this.audioRtp = new RtpWriter(audioPayloadType);
+    }
+    this.fallbackVideoIncrement = Math.max(
+      1,
+      Math.round(this.videoClockRate / Math.max(1, videoFpsFallback))
+    );
+    this.fallbackVideoDeltaUs = Math.max(
+      1,
+      Math.round(
+        this.fallbackVideoIncrement * 1e6 / this.videoClockRate
+      )
+    );
+  }
+  clients = /* @__PURE__ */ new Set();
+  closed = false;
+  videoRtp;
+  audioRtp;
+  // Timestamp tracking
+  // bcmedia microseconds is a u32 clock that may wrap (2^32) and may reset on stream restarts.
+  // Additionally, it may jump forward unexpectedly. Since we do not buffer, large forward jumps
+  // cause downstream schedulers to detect discontinuities.
+  //
+  // Strategy:
+  // - unwrap u32 wraps when likely
+  // - treat backwards jumps as restarts
+  // - use microseconds deltas only when "reasonable"; otherwise advance using a smoothed/fallback delta
+  videoLastUsRaw;
+  videoUsWrapOffset = 0;
+  videoLastAbsUs;
+  videoAvgDeltaUs;
+  videoClockRate = 9e4;
+  fallbackVideoIncrement;
+  fallbackVideoDeltaUs;
+  maxTrustedDeltaUs = 5e5;
+  // 0.5s
+  emaAlpha = 0.1;
+  // Throttled logging to avoid spamming in hot paths.
+  videoTimingLogState = {
+    lastUntrustedDeltaLogMs: 0,
+    lastWrapLogMs: 0,
+    lastResetLogMs: 0,
+    untrustedDeltaCount: 0,
+    wrapCount: 0,
+    resetCount: 0
+  };
+  cachedH264ParamSetsAnnexB;
+  cachedH265ParamSetsAnnexB;
+  addClient(socket) {
+    if (this.closed) {
+      socket.destroy();
+      return;
+    }
+    const client = {
+      socket,
+      needsKeyframe: true,
+      sentVideoConfig: false
+    };
+    this.clients.add(client);
+    const cleanup = () => {
+      this.clients.delete(client);
+      try {
+        socket.destroy();
+      } catch {
+      }
+    };
+    socket.on("error", cleanup);
+    socket.on("close", cleanup);
+  }
+  static ANNEXB_START_CODE = Buffer.from([
+    0,
+    0,
+    0,
+    1
+  ]);
+  static joinAnnexBNals(...nals) {
+    const present = nals.filter((n) => !!n && n.length > 0);
+    if (!present.length) return;
+    const parts = [];
+    for (const nal of present) {
+      parts.push(_Rfc4571Muxer.ANNEXB_START_CODE, nal);
+    }
+    return Buffer.concat(parts);
+  }
+  updateVideoParamSetsFromAccessUnit(videoType, accessUnit) {
+    if (!accessUnit?.length) return;
+    if (videoType === "H264") {
+      const { sps: sps2, pps: pps2 } = extractH264ParamSetsFromAccessUnit(accessUnit);
+      if (sps2 && pps2) {
+        this.cachedH264ParamSetsAnnexB = _Rfc4571Muxer.joinAnnexBNals(sps2, pps2);
+      }
+      return;
+    }
+    const { vps, sps, pps } = extractH265ParamSetsFromAccessUnit(accessUnit);
+    if (vps && sps && pps) {
+      this.cachedH265ParamSetsAnnexB = _Rfc4571Muxer.joinAnnexBNals(
+        vps,
+        sps,
+        pps
+      );
+    }
+  }
+  sendCachedVideoConfigToClient(videoType, client) {
+    if (this.closed) return;
+    if (client.sentVideoConfig) return;
+    const paramSetsAnnexB = videoType === "H265" ? this.cachedH265ParamSetsAnnexB : this.cachedH264ParamSetsAnnexB;
+    if (!paramSetsAnnexB?.length) return;
+    const nals = splitAccessUnitToNalsBestEffort(paramSetsAnnexB, videoType);
+    if (!nals.length) return;
+    const opts = { maxRtpPayload: this.maxRtpPayload };
+    for (let i = 0; i < nals.length; i++) {
+      const nal = nals[i];
+      const isLastNal = i === nals.length - 1;
+      const packets = videoType === "H265" ? packetizeH265(nal, this.videoRtp, opts, false, isLastNal) : packetizeH264(nal, this.videoRtp, opts, false, isLastNal);
+      for (const pkt of packets) {
+        this.writeRtpPacketToClient(client, pkt);
+      }
+    }
+    client.sentVideoConfig = true;
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    for (const c of Array.from(this.clients)) {
+      try {
+        c.socket.destroy();
+      } catch {
+      }
+    }
+    this.clients.clear();
+  }
+  writeRtpPacketToClient(client, pkt) {
+    if (client.socket.destroyed || !client.socket.writable) return;
+    const header = Buffer.alloc(2);
+    header.writeUInt16BE(pkt.length & 65535, 0);
+    const framed = Buffer.concat([header, pkt]);
+    try {
+      client.socket.write(framed);
+    } catch {
+      try {
+        client.socket.destroy();
+      } catch {
+      }
+    }
+  }
+  writeRtpPacketToClients(pkt, predicate) {
+    for (const c of this.clients) {
+      if (!predicate(c)) continue;
+      this.writeRtpPacketToClient(c, pkt);
+    }
+  }
+  resetVideoTimestampMapping() {
+    this.videoLastUsRaw = void 0;
+    this.videoUsWrapOffset = 0;
+    this.videoLastAbsUs = void 0;
+    this.videoAvgDeltaUs = void 0;
+  }
+  logVideoTiming(kind, message) {
+    const now = Date.now();
+    const intervalMs = 5e3;
+    const state = this.videoTimingLogState;
+    if (kind === "untrusted-delta") {
+      state.untrustedDeltaCount++;
+      if (now - state.lastUntrustedDeltaLogMs < intervalMs) return;
+      state.lastUntrustedDeltaLogMs = now;
+      this.logger.warn(
+        `[rfc4571] video timing: ${message} (untrustedDeltaCount=${state.untrustedDeltaCount})`
+      );
+      return;
+    }
+    if (kind === "wrap") {
+      state.wrapCount++;
+      if (now - state.lastWrapLogMs < intervalMs) return;
+      state.lastWrapLogMs = now;
+      this.logger.warn(
+        `[rfc4571] video timing: ${message} (wrapCount=${state.wrapCount})`
+      );
+      return;
+    }
+    state.resetCount++;
+    if (now - state.lastResetLogMs < intervalMs) return;
+    state.lastResetLogMs = now;
+    this.logger.warn(
+      `[rfc4571] video timing: ${message} (resetCount=${state.resetCount})`
+    );
+  }
+  advanceVideoTimestampFallback() {
+    this.videoRtp.advanceTimestamp(this.fallbackVideoIncrement);
+  }
+  setVideoTimestampFromMicroseconds(frameMicroseconds) {
+    if (frameMicroseconds === null || frameMicroseconds === void 0) {
+      this.advanceVideoTimestampFallback();
+      return;
+    }
+    if (!Number.isFinite(frameMicroseconds)) {
+      this.advanceVideoTimestampFallback();
+      return;
+    }
+    const curUsRaw = frameMicroseconds >>> 0;
+    if (this.videoLastUsRaw !== void 0) {
+      const lastUsRaw = this.videoLastUsRaw;
+      if (curUsRaw < lastUsRaw) {
+        const wrapLikely = lastUsRaw > 4026531840 && curUsRaw < 268435455;
+        if (wrapLikely) {
+          this.videoUsWrapOffset += 4294967296;
+          this.logVideoTiming(
+            "wrap",
+            `detected u32 wrap (lastUsRaw=${lastUsRaw} curUsRaw=${curUsRaw} wrapOffset=${this.videoUsWrapOffset})`
+          );
+        } else {
+          this.logVideoTiming(
+            "reset",
+            `detected backwards jump; resetting mapping (lastUsRaw=${lastUsRaw} curUsRaw=${curUsRaw})`
+          );
+          this.resetVideoTimestampMapping();
+        }
+      }
+    }
+    this.videoLastUsRaw = curUsRaw;
+    const absUs = this.videoUsWrapOffset + curUsRaw;
+    if (this.videoLastAbsUs === void 0) {
+      this.videoLastAbsUs = absUs;
+      if (this.videoAvgDeltaUs === void 0)
+        this.videoAvgDeltaUs = this.fallbackVideoDeltaUs;
+      return;
+    }
+    const deltaUs = absUs - this.videoLastAbsUs;
+    this.videoLastAbsUs = absUs;
+    const trusted = Number.isFinite(deltaUs) && deltaUs > 0 && deltaUs <= this.maxTrustedDeltaUs;
+    let effectiveDeltaUs;
+    if (trusted) {
+      const prevAvg = this.videoAvgDeltaUs ?? deltaUs;
+      this.videoAvgDeltaUs = prevAvg + (deltaUs - prevAvg) * this.emaAlpha;
+      effectiveDeltaUs = deltaUs;
+    } else {
+      this.logVideoTiming(
+        "untrusted-delta",
+        `discarded deltaUs=${deltaUs} (absUs=${absUs} lastAbsUs=${this.videoLastAbsUs} avgDeltaUs=${this.videoAvgDeltaUs ?? "n/a"}); using fallback`
+      );
+      effectiveDeltaUs = this.videoAvgDeltaUs ?? this.fallbackVideoDeltaUs;
+    }
+    const inc = Math.max(
+      1,
+      Math.round(effectiveDeltaUs * this.videoClockRate / 1e6)
+    );
+    this.videoRtp.advanceTimestamp(inc);
+  }
+  sendVideoAccessUnit(videoType, accessUnitAnnexB, isKeyframe, microseconds) {
+    if (this.closed) return;
+    this.updateVideoParamSetsFromAccessUnit(videoType, accessUnitAnnexB);
+    const nals = splitAccessUnitToNalsBestEffort(accessUnitAnnexB, videoType);
+    if (!nals.length) return;
+    let derivedKeyframe = false;
+    if (videoType === "H264") {
+      for (const nal of nals) {
+        const t = nal[0] & 31;
+        if (t === 5) {
+          derivedKeyframe = true;
+          break;
+        }
+      }
+    } else {
+      for (const nal of nals) {
+        if (nal.length < 2) continue;
+        const t = nal[0] >> 1 & 63;
+        if (t >= 16 && t <= 23) {
+          derivedKeyframe = true;
+          break;
+        }
+      }
+    }
+    const effectiveKeyframe = isKeyframe || derivedKeyframe;
+    const shouldSendTo = (c) => effectiveKeyframe ? true : !c.needsKeyframe;
+    let hasAnyTarget = false;
+    for (const c of this.clients) {
+      if (shouldSendTo(c)) {
+        hasAnyTarget = true;
+        break;
+      }
+    }
+    if (!hasAnyTarget) {
+      for (const c of this.clients) {
+        if (!c.needsKeyframe) continue;
+        this.sendCachedVideoConfigToClient(videoType, c);
+      }
+      return;
+    }
+    this.setVideoTimestampFromMicroseconds(microseconds);
+    for (const c of this.clients) {
+      if (!c.needsKeyframe) continue;
+      this.sendCachedVideoConfigToClient(videoType, c);
+    }
+    const opts = { maxRtpPayload: this.maxRtpPayload };
+    for (let i = 0; i < nals.length; i++) {
+      const nal = nals[i];
+      const isLastNal = i === nals.length - 1;
+      const packets = videoType === "H265" ? packetizeH265(nal, this.videoRtp, opts, true, isLastNal) : packetizeH264(nal, this.videoRtp, opts, true, isLastNal);
+      for (const pkt of packets)
+        this.writeRtpPacketToClients(pkt, shouldSendTo);
+    }
+    if (effectiveKeyframe) {
+      for (const c of this.clients) c.needsKeyframe = false;
+    }
+  }
+  sendAudioAdtsFrame(adts) {
+    if (this.closed) return {};
+    if (!this.audioRtp) return {};
+    const { packets, config } = packetizeAacAdtsFrame(adts, this.audioRtp);
+    for (const pkt of packets)
+      this.writeRtpPacketToClients(pkt, (c) => !c.needsKeyframe);
+    if (packets.length) this.audioRtp.advanceTimestamp(1024);
+    return config ? { parsed: config } : {};
+  }
+  sendAudioAacRawFrame(raw) {
+    if (this.closed) return;
+    if (!this.audioRtp) return;
+    const { packets } = packetizeAacRawFrame(raw, this.audioRtp);
+    for (const pkt of packets)
+      this.writeRtpPacketToClients(pkt, (c) => !c.needsKeyframe);
+    if (packets.length) this.audioRtp.advanceTimestamp(1024);
+  }
+  sendAudioRtpPacket(rtpPacket) {
+    if (this.closed) return;
+    if (!rtpPacket || rtpPacket.length < 12) return;
+    const version = rtpPacket[0] >> 6 & 3;
+    if (version !== 2) return;
+    this.writeRtpPacketToClients(rtpPacket, (c) => !c.needsKeyframe);
+  }
+  static parseRtpPayload(packet) {
+    if (!packet || packet.length < 12) return;
+    const version = packet[0] >> 6 & 3;
+    if (version !== 2) return;
+    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;
+    if (extension) {
+      if (offset + 4 > packet.length) return;
+      const extLenWords = packet.readUInt16BE(offset + 2);
+      offset += 4 + extLenWords * 4;
+      if (offset > packet.length) return;
+    }
+    let end = packet.length;
+    if (padding) {
+      const padLen = packet[packet.length - 1];
+      if (padLen <= 0 || padLen > packet.length) return;
+      end = packet.length - padLen;
+      if (end < offset) return;
+    }
+    if (end <= offset) return;
+    return packet.subarray(offset, end);
+  }
+  static isH264KeyframeLikeRtpPacket(packet) {
+    const payload = _Rfc4571Muxer.parseRtpPayload(packet);
+    if (!payload || payload.length < 1) return false;
+    const nalType = payload[0] & 31;
+    if (nalType >= 1 && nalType <= 23) {
+      return nalType === 5 || nalType === 7 || nalType === 8;
+    }
+    if (nalType === 24) {
+      let offset = 1;
+      while (offset + 2 <= payload.length) {
+        const size = payload.readUInt16BE(offset);
+        offset += 2;
+        if (!size || offset + size > payload.length) break;
+        const t = payload[offset] & 31;
+        if (t === 5 || t === 7 || t === 8) return true;
+        offset += size;
+      }
+      return false;
+    }
+    if (nalType === 28 && payload.length >= 2) {
+      const fuHeader = payload[1];
+      const start = (fuHeader & 128) !== 0;
+      const origType = fuHeader & 31;
+      if (!start) return false;
+      return origType === 5 || origType === 7 || origType === 8;
+    }
+    return false;
+  }
+  static isH265KeyframeLikeRtpPacket(packet) {
+    const payload = _Rfc4571Muxer.parseRtpPayload(packet);
+    if (!payload || payload.length < 2) return false;
+    const nalType = payload[0] >> 1 & 63;
+    const isKeyNalType = (t) => {
+      if (t >= 16 && t <= 21) return true;
+      if (t === 32 || t === 33 || t === 34) return true;
+      return false;
+    };
+    if (nalType === 49 && payload.length >= 3) {
+      const fuHeader = payload[2];
+      const start = (fuHeader & 128) !== 0;
+      const origType = fuHeader & 63;
+      if (!start) return false;
+      return isKeyNalType(origType);
+    }
+    return isKeyNalType(nalType);
+  }
+  sendVideoRtpPacket(videoType, rtpPacket) {
+    if (this.closed) return;
+    if (!rtpPacket || rtpPacket.length < 12) return;
+    const version = rtpPacket[0] >> 6 & 3;
+    if (version !== 2) return;
+    const isKeyframeLike = videoType === "H265" ? _Rfc4571Muxer.isH265KeyframeLikeRtpPacket(rtpPacket) : _Rfc4571Muxer.isH264KeyframeLikeRtpPacket(rtpPacket);
+    const shouldSendTo = (c) => isKeyframeLike ? true : !c.needsKeyframe;
+    this.writeRtpPacketToClients(rtpPacket, shouldSendTo);
+    if (isKeyframeLike) {
+      for (const c of this.clients) c.needsKeyframe = false;
+    }
+  }
+};
+
+// src/rfc/rfc4571-server.ts
+import netImpl from "net";
+
+// src/multifocal/compositeStream.ts
+import { spawn as spawn3 } from "child_process";
+import { createHash } from "crypto";
+import { EventEmitter } from "events";
+function calculateOverlayPosition(position, mainWidth, mainHeight, pipWidth, pipHeight, margin) {
+  const pipW = Math.floor(pipWidth);
+  const pipH = Math.floor(pipHeight);
+  const m = margin;
+  switch (position) {
+    case "top-left":
+      return { x: m, y: m };
+    case "top-right":
+      return { x: mainWidth - pipW - m, y: m };
+    case "bottom-left":
+      return { x: m, y: mainHeight - pipH - m };
+    case "bottom-right":
+      return { x: mainWidth - pipW - m, y: mainHeight - pipH - m };
+    case "center":
+      return { x: Math.floor((mainWidth - pipW) / 2), y: Math.floor((mainHeight - pipH) / 2) };
+    case "top-center":
+      return { x: Math.floor((mainWidth - pipW) / 2), y: m };
+    case "bottom-center":
+      return { x: Math.floor((mainWidth - pipW) / 2), y: mainHeight - pipH - m };
+    case "left-center":
+      return { x: m, y: Math.floor((mainHeight - pipH) / 2) };
+    case "right-center":
+      return { x: mainWidth - pipW - m, y: Math.floor((mainHeight - pipH) / 2) };
+    default:
+      return { x: m, y: m };
+  }
+}
+var CompositeStream = class extends EventEmitter {
+  options;
+  widerStream = null;
+  teleStream = null;
+  ffmpegProcess = null;
+  active = false;
+  logger;
+  inputMode = "native";
+  // ffmpeg stdout is an H.264 Annex-B byte stream; chunk boundaries are arbitrary.
+  // We need to reassemble access units (frames) for RFC4571 packetization and keyframe priming.
+  ffmpegOutBuf = Buffer.alloc(0);
+  // Prime frames read before ffmpeg starts (used to infer codec + seed decoder).
+  widerPrimeFrame;
+  telePrimeFrame;
+  ffmpegInputOffsetSec;
+  ffmpegStderrLastLogAtMs = 0;
+  ffmpegStderrLogBurst = 0;
+  audioSource;
+  effectiveWiderProfile;
+  effectiveTeleProfile;
+  pickH264Profile(metadata, preferred) {
+    try {
+      const isH264 = (enc) => (enc ?? "").toLowerCase().includes("264");
+      const streams = Array.isArray(metadata?.streams) ? metadata.streams : [];
+      const byProfile = /* @__PURE__ */ new Map();
+      for (const s of streams) byProfile.set(s.profile, s);
+      if (isH264(byProfile.get(preferred)?.videoEncType)) return preferred;
+      const preferredOrder = ["sub", "main", "ext"];
+      for (const p of preferredOrder) {
+        const si = byProfile.get(p);
+        if (si && isH264(si.videoEncType)) return p;
+      }
+    } catch {
+    }
+    return preferred;
+  }
+  closeGenerator(gen) {
+    if (!gen) return Promise.resolve();
+    const r = gen.return;
+    if (typeof r !== "function") return Promise.resolve();
+    try {
+      return Promise.resolve(r.call(gen)).then(() => void 0).catch(() => void 0);
+    } catch {
+      return Promise.resolve();
+    }
+  }
+  constructor(options) {
+    super();
+    this.options = {
+      pipPosition: "bottom-right",
+      pipSize: 0.25,
+      pipMargin: 10,
+      ...options
+    };
+    this.logger = options.logger ?? console;
+  }
+  resolvePipMarginPx(mainWidth, mainHeight) {
+    const raw = this.options.pipMargin;
+    if (raw === void 0 || raw === null) return 10;
+    const v = Number(raw);
+    if (!Number.isFinite(v) || v < 0) return 10;
+    if (v > 1) return Math.floor(v);
+    const base = Math.min(mainWidth, mainHeight);
+    return Math.max(0, Math.floor(base * v));
+  }
+  describeApiClient(api) {
+    const c = api ? api.client : void 0;
+    if (!c) return {};
+    try {
+      const transport = typeof c.getTransport === "function" ? c.getTransport() : void 0;
+      const host = typeof c.getHost === "function" ? c.getHost() : void 0;
+      const sid = typeof c.getSocketSessionId === "function" ? c.getSocketSessionId() : void 0;
+      const uid = typeof c.getUidShort === "function" ? c.getUidShort() : void 0;
+      return { transport, host, sid, uid };
+    } catch {
+      return {};
+    }
+  }
+  fingerprintFrame(buf) {
+    if (!buf?.length) return;
+    const head = buf.subarray(0, Math.min(12, buf.length)).toString("hex");
+    const slice = buf.subarray(0, Math.min(256, buf.length));
+    const sha1 = createHash("sha1").update(slice).digest("hex");
+    return { len: buf.length, headHex: head, sha1_256: sha1 };
+  }
+  async primeForFfmpeg(gen, timeoutMs, requireKeyframe) {
+    const start = Date.now();
+    let first;
+    while (Date.now() - start < timeoutMs) {
+      const r = await Promise.race([
+        gen.next(),
+        new Promise((resolve) => setTimeout(() => resolve({ value: void 0, done: false }), 250))
+      ]);
+      if (!r || r.done) return first;
+      const v = r.value;
+      if (!v || v.audio) continue;
+      if (!first) first = { data: v.data, videoType: v.videoType, isKeyframe: v.isKeyframe, microseconds: v.microseconds };
+      if (v.isKeyframe) return { data: v.data, videoType: v.videoType, isKeyframe: v.isKeyframe, microseconds: v.microseconds };
+    }
+    return requireKeyframe ? void 0 : first;
+  }
+  /**
+   * Start the composite stream
+   */
+  async start() {
+    if (this.active) {
+      throw new Error("Composite stream already active");
+    }
+    this.active = true;
+    this.audioSource = void 0;
+    this.ffmpegInputOffsetSec = void 0;
+    this.logger.log?.("[CompositeStream] Starting composite stream...");
+    try {
+      const widerApi = this.options.widerApi ?? this.options.api;
+      const teleApi = this.options.teleApi ?? this.options.api;
+      const widerClientInfo = this.describeApiClient(widerApi);
+      const teleClientInfo = this.describeApiClient(teleApi);
+      const sameClient = widerApi?.client && teleApi?.client ? widerApi.client === teleApi.client : false;
+      this.logger.log?.(
+        `[CompositeStream] Inputs: wider(ch=${this.options.widerChannel}, profile=${this.options.widerProfile}) tele(ch=${this.options.teleChannel}, profile=${this.options.teleProfile}) onNvr=${Boolean(this.options.onNvr)} forceH264=${Boolean(this.options.forceH264)} sameClient=${sameClient} widerClient=${JSON.stringify(widerClientInfo)} teleClient=${JSON.stringify(teleClientInfo)}`
+      );
+      const widerMetadata = await widerApi.getStreamMetadata(this.options.widerChannel);
+      const teleMetadata = await teleApi.getStreamMetadata(this.options.teleChannel);
+      const forceH264 = this.options.forceH264 === true;
+      const widerProfile = forceH264 ? this.pickH264Profile(widerMetadata, this.options.widerProfile) : this.options.widerProfile;
+      const teleProfile = forceH264 ? this.pickH264Profile(teleMetadata, this.options.teleProfile) : this.options.teleProfile;
+      this.effectiveWiderProfile = widerProfile;
+      this.effectiveTeleProfile = teleProfile;
+      const widerStreamInfo = widerMetadata.streams.find((s) => s.profile === widerProfile);
+      const teleStreamInfo = teleMetadata.streams.find((s) => s.profile === teleProfile);
+      if (!widerStreamInfo || !teleStreamInfo) {
+        throw new Error("Stream metadata not found");
+      }
+      const mainWidth = widerStreamInfo.width;
+      const mainHeight = widerStreamInfo.height;
+      const requestedPipSizeRaw = this.options.pipSize ?? 0.25;
+      const pipSize = Math.min(0.9, Math.max(0.05, Number(requestedPipSizeRaw)));
+      const teleAspect = teleStreamInfo.width > 0 && teleStreamInfo.height > 0 ? teleStreamInfo.width / teleStreamInfo.height : 16 / 9;
+      let pipWidth = Math.floor(mainWidth * pipSize);
+      let pipHeight = Math.floor(pipWidth / teleAspect);
+      const maxPipHeight = Math.floor(mainHeight * pipSize);
+      if (pipHeight > maxPipHeight) {
+        pipHeight = maxPipHeight;
+        pipWidth = Math.floor(pipHeight * teleAspect);
+      }
+      pipWidth = Math.max(2, pipWidth - pipWidth % 2);
+      pipHeight = Math.max(2, pipHeight - pipHeight % 2);
+      const position = calculateOverlayPosition(
+        this.options.pipPosition ?? "bottom-right",
+        mainWidth,
+        mainHeight,
+        pipWidth,
+        pipHeight,
+        this.resolvePipMarginPx(mainWidth, mainHeight)
+      );
+      this.logger.log?.(
+        `[CompositeStream] Main: ${mainWidth}x${mainHeight}, PIP: ${pipWidth}x${pipHeight} (pipSize=${pipSize}, position=${this.options.pipPosition ?? "bottom-right"}, margin=${this.options.pipMargin ?? 10}) at (${position.x}, ${position.y})`
+      );
+      const widerRtspUrl = this.options.widerRtspUrl;
+      const teleRtspUrl = this.options.teleRtspUrl;
+      if (widerRtspUrl && teleRtspUrl) {
+        this.inputMode = "rtsp";
+        if (!this.options.assumeH264Inputs) {
+          const isH264 = (enc) => (enc ?? "").toLowerCase().includes("264");
+          const widerEnc = widerStreamInfo?.videoEncType;
+          const teleEnc = teleStreamInfo?.videoEncType;
+          if (!isH264(widerEnc) || !isH264(teleEnc)) {
+            throw new Error(
+              `[CompositeStream] RTSP pair requires H.264 inputs. Detected wider=${widerEnc ?? "unknown"} tele=${teleEnc ?? "unknown"}. Provide RTSP URLs that are H.264 (often the substream), or set assumeH264Inputs=true if you know they are H.264.`
+            );
+          }
+        }
+        await this.startFfmpegCompositionFromRtspUrls(
+          mainWidth,
+          mainHeight,
+          pipWidth,
+          pipHeight,
+          position,
+          widerRtspUrl,
+          teleRtspUrl,
+          this.options.rtspTransport ?? "tcp"
+        );
+        this.logger.log?.("[CompositeStream] Composite stream started (rtsp inputs)");
+        return;
+      }
+      this.inputMode = "native";
+      const teleIsVariantOnSameChannel = !!this.options.onNvr || this.options.teleChannel === this.options.widerChannel;
+      this.widerStream = createNativeStream(widerApi, this.options.widerChannel, widerProfile);
+      this.teleStream = teleIsVariantOnSameChannel ? createNativeStream(teleApi, this.options.teleChannel, teleProfile, { variant: "telephoto" }) : createNativeStream(teleApi, this.options.teleChannel, teleProfile);
+      const inputStartupTimeoutMs = Math.max(1e3, this.options.inputStartupTimeoutMs ?? 2e4);
+      const requireKeyframeOnStartup = this.options.assumeH264Inputs ? false : this.options.requireKeyframeOnStartup ?? true;
+      const primeKeyframeMs = inputStartupTimeoutMs;
+      const primeAnyFrameMs = Math.min(5e3, Math.max(1e3, Math.floor(inputStartupTimeoutMs / 3)));
+      if (requireKeyframeOnStartup) {
+        const [widerPrime, telePrime] = await Promise.all([
+          this.primeForFfmpeg(this.widerStream, primeKeyframeMs, true),
+          this.primeForFfmpeg(this.teleStream, primeKeyframeMs, true)
+        ]);
+        this.widerPrimeFrame = widerPrime;
+        this.telePrimeFrame = telePrime;
+      } else {
+        const [widerPrime, telePrime] = await Promise.all([
+          this.primeForFfmpeg(this.widerStream, primeAnyFrameMs, false),
+          this.primeForFfmpeg(this.teleStream, primeAnyFrameMs, false)
+        ]);
+        this.widerPrimeFrame = widerPrime;
+        this.telePrimeFrame = telePrime;
+      }
+      const widerFp = this.fingerprintFrame(this.widerPrimeFrame?.data);
+      const teleFp = this.fingerprintFrame(this.telePrimeFrame?.data);
+      if (widerFp && teleFp) {
+        const same = widerFp.sha1_256 === teleFp.sha1_256;
+        this.logger.log?.(
+          `[CompositeStream] Prime fingerprints: wider=${JSON.stringify(widerFp)} tele=${JSON.stringify(teleFp)} same=${same}`
+        );
+        if (same) {
+          this.logger.warn?.(
+            `[CompositeStream] WARNING: wider+tele prime frames look identical. This usually means the same underlying stream is feeding both inputs (shared socket mixup, wrong channels, or device mapping).`
+          );
+        }
+      }
+      this.logger.log?.(
+        `[CompositeStream] Prime: wider=${this.widerPrimeFrame?.isKeyframe ? "keyframe" : this.widerPrimeFrame ? "frame" : "none"}, tele=${this.telePrimeFrame?.isKeyframe ? "keyframe" : this.telePrimeFrame ? "frame" : "none"}`
+      );
+      if (!this.widerPrimeFrame || !this.telePrimeFrame) {
+        const missing = [
+          !this.widerPrimeFrame ? "wider" : null,
+          !this.telePrimeFrame ? "tele" : null
+        ].filter(Boolean).join(", ");
+        throw new Error(
+          `[CompositeStream] Missing input frames (${missing}) within ${inputStartupTimeoutMs}ms. If your camera has a very long GOP/keyframe interval, startup will be slow. Consider increasing inputStartupTimeoutMs or enabling forceH264 (often shorter GOP on substream).`
+        );
+      }
+      if (!this.options.assumeH264Inputs) {
+        try {
+          const wUs = this.widerPrimeFrame.microseconds;
+          const tUs = this.telePrimeFrame.microseconds;
+          if (typeof wUs === "number" && typeof tUs === "number" && Number.isFinite(wUs) && Number.isFinite(tUs)) {
+            const deltaSec = (tUs - wUs) / 1e6;
+            const abs = Math.abs(deltaSec);
+            if (abs >= 0.2 && abs <= 60) {
+              if (deltaSec > 0) {
+                this.ffmpegInputOffsetSec = { wider: abs };
+              } else {
+                this.ffmpegInputOffsetSec = { tele: abs };
+              }
+              this.logger.log?.(
+                `[CompositeStream] Input timestamp delta: widerUs=${wUs} teleUs=${tUs} deltaSec=${deltaSec.toFixed(3)} applying itoffset=${abs.toFixed(3)}s to ${deltaSec > 0 ? "wider" : "tele"}`
+              );
+            }
+          }
+        } catch {
+        }
+      } else {
+        this.ffmpegInputOffsetSec = void 0;
+      }
+      const widerCodecFromFrames = this.widerPrimeFrame?.videoType === "H265" ? "hevc" : this.widerPrimeFrame?.videoType === "H264" ? "h264" : void 0;
+      const teleCodecFromFrames = this.telePrimeFrame?.videoType === "H265" ? "hevc" : this.telePrimeFrame?.videoType === "H264" ? "h264" : void 0;
+      await this.startFfmpegComposition(mainWidth, mainHeight, pipWidth, pipHeight, position, widerCodecFromFrames, teleCodecFromFrames, this.ffmpegInputOffsetSec);
+      this.logger.log?.("[CompositeStream] Composite stream started");
+    } catch (error) {
+      this.active = false;
+      this.emit("error", error);
+      throw error;
+    }
+  }
+  async startFfmpegCompositionFromRtspUrls(mainWidth, mainHeight, pipWidth, pipHeight, position, widerRtspUrl, teleRtspUrl, rtspTransport) {
+    const ffmpegArgs = [
+      "-hide_banner",
+      "-loglevel",
+      "error",
+      "-fflags",
+      "+genpts",
+      // Input 0: wider
+      "-rtsp_transport",
+      rtspTransport,
+      "-i",
+      widerRtspUrl,
+      // Input 1: tele
+      "-rtsp_transport",
+      rtspTransport,
+      "-i",
+      teleRtspUrl,
+      // Filter to scale and position PIP
+      "-filter_complex",
+      `[0:v]scale=${mainWidth}:${mainHeight}[main];[1:v]scale=${pipWidth}:${pipHeight}[pip];[main][pip]overlay=${position.x}:${position.y}[out]`,
+      "-map",
+      "[out]",
+      // Output: always H.264 Annex-B
+      "-an",
+      "-c:v",
+      "libx264",
+      "-g",
+      "30",
+      "-keyint_min",
+      "30",
+      "-sc_threshold",
+      "0",
+      "-x264-params",
+      "aud=1:repeat-headers=1:keyint=30:min-keyint=30:scenecut=0",
+      "-preset",
+      "ultrafast",
+      "-tune",
+      "zerolatency",
+      "-crf",
+      "23",
+      "-f",
+      "h264",
+      "pipe:1"
+    ];
+    this.logger.log?.(`[CompositeStream] Starting ffmpeg (rtsp inputs): ${ffmpegArgs.join(" ")}`);
+    this.ffmpegProcess = spawn3("ffmpeg", ffmpegArgs, {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    this.ffmpegProcess.on("error", (error) => {
+      this.logger.error?.("[CompositeStream] FFmpeg error:", error);
+      this.emit("error", error);
+    });
+    this.ffmpegProcess.on("close", (code) => {
+      if (code !== 0 && code !== null) {
+        this.logger.warn?.(`[CompositeStream] FFmpeg exited with code ${code}`);
+      }
+      this.emit("close");
+    });
+    this.ffmpegProcess.stdout?.on("data", (data) => {
+      this.onFfmpegStdoutData(data);
+    });
+    this.ffmpegProcess.stderr?.on("data", (data) => {
+      const output = data.toString();
+      if (output.includes("error") || output.includes("Error")) {
+        const now = Date.now();
+        if (now - this.ffmpegStderrLastLogAtMs > 2e3) {
+          this.ffmpegStderrLastLogAtMs = now;
+          this.ffmpegStderrLogBurst = 0;
+        }
+        if (this.ffmpegStderrLogBurst++ < 3) {
+          this.logger.error?.("[CompositeStream] FFmpeg stderr:", output);
+        }
+      }
+    });
+  }
+  /**
+   * Start ffmpeg for composition with overlay
+   */
+  async startFfmpegComposition(mainWidth, mainHeight, pipWidth, pipHeight, position, widerCodecOverride, teleCodecOverride, inputOffsetSec) {
+    const widerApi = this.options.widerApi ?? this.options.api;
+    const teleApi = this.options.teleApi ?? this.options.api;
+    const widerMetadata = await widerApi.getStreamMetadata(this.options.widerChannel);
+    const teleMetadata = await teleApi.getStreamMetadata(this.options.teleChannel);
+    const widerProfile = this.effectiveWiderProfile ?? this.options.widerProfile;
+    const teleProfile = this.effectiveTeleProfile ?? this.options.teleProfile;
+    const widerStreamInfo = widerMetadata.streams.find((s) => s.profile === widerProfile);
+    const teleStreamInfo = teleMetadata.streams.find((s) => s.profile === teleProfile);
+    const assumeH264Inputs = this.options.assumeH264Inputs === true;
+    const widerCodec = assumeH264Inputs ? "h264" : widerCodecOverride ?? (widerStreamInfo?.videoEncType?.toLowerCase().includes("265") ? "hevc" : "h264");
+    const teleCodec = assumeH264Inputs ? "h264" : teleCodecOverride ?? (teleStreamInfo?.videoEncType?.toLowerCase().includes("265") ? "hevc" : "h264");
+    this.logger.log?.(
+      `[CompositeStream] Codec detection: wider=${widerCodec} (from metadata: ${widerStreamInfo?.videoEncType || "unknown"}), tele=${teleCodec} (from metadata: ${teleStreamInfo?.videoEncType || "unknown"})`
+    );
+    if (this.options.disableTranscode) {
+      this.logger.warn?.(
+        `[CompositeStream] disableTranscode requested, but overlay requires re-encode in ffmpeg; proceeding with libx264 output.`
+      );
+    }
+    const widerInputArgs = [
+      ...inputOffsetSec?.wider ? ["-itsoffset", String(inputOffsetSec.wider)] : [],
+      "-f",
+      widerCodec,
+      "-i",
+      "pipe:0"
+    ];
+    const teleInputArgs = [
+      ...inputOffsetSec?.tele ? ["-itsoffset", String(inputOffsetSec.tele)] : [],
+      "-f",
+      teleCodec,
+      "-i",
+      "pipe:3"
+    ];
+    const ffmpegArgs = [
+      "-hide_banner",
+      "-loglevel",
+      "error",
+      "-fflags",
+      "+genpts",
+      "-probesize",
+      "32",
+      // Small probe size for faster detection
+      "-analyzeduration",
+      "500000",
+      // 0.5 seconds to analyze stream
+      // Input 0: wider stream (main)
+      ...widerInputArgs,
+      // Input 1: tele stream (PIP)
+      ...teleInputArgs,
+      // Filter to scale and position PIP
+      "-filter_complex",
+      `[0:v]scale=${mainWidth}:${mainHeight}[main];[1:v]scale=${pipWidth}:${pipHeight}[pip];[main][pip]overlay=${position.x}:${position.y}[out]`,
+      "-map",
+      "[out]",
+      "-c:v",
+      "libx264",
+      // Re-encode for compatibility
+      // Make the stream easy to join mid-flight: frequent IDRs + in-band headers + AUD.
+      // Without this, a new client may wait many seconds for the next keyframe.
+      "-g",
+      "30",
+      "-keyint_min",
+      "30",
+      "-sc_threshold",
+      "0",
+      "-x264-params",
+      "aud=1:repeat-headers=1:keyint=30:min-keyint=30:scenecut=0",
+      "-preset",
+      "ultrafast",
+      "-tune",
+      "zerolatency",
+      "-crf",
+      "23",
+      "-f",
+      "h264",
+      "pipe:1"
+      // Output (stdout)
+    ];
+    this.logger.log?.(
+      `[CompositeStream] Starting ffmpeg: ${ffmpegArgs.join(" ")}`
+    );
+    this.ffmpegProcess = spawn3("ffmpeg", ffmpegArgs, {
+      stdio: ["pipe", "pipe", "pipe", "pipe"]
+    });
+    this.ffmpegProcess.on("error", (error) => {
+      this.logger.error?.("[CompositeStream] FFmpeg error:", error);
+      this.emit("error", error);
+    });
+    this.ffmpegProcess.on("close", (code) => {
+      if (code !== 0 && code !== null) {
+        this.logger.warn?.(`[CompositeStream] FFmpeg exited with code ${code}`);
+      }
+      this.emit("close");
+    });
+    this.ffmpegProcess.stdout?.on("data", (data) => {
+      this.onFfmpegStdoutData(data);
+    });
+    this.ffmpegProcess.stderr?.on("data", (data) => {
+      const output = data.toString();
+      if (output.includes("error") || output.includes("Error")) {
+        const now = Date.now();
+        if (now - this.ffmpegStderrLastLogAtMs > 2e3) {
+          this.ffmpegStderrLastLogAtMs = now;
+          this.ffmpegStderrLogBurst = 0;
+        }
+        if (this.ffmpegStderrLogBurst++ < 3) {
+          this.logger.error?.("[CompositeStream] FFmpeg stderr:", output);
+        }
+      }
+    });
+    this.feedFramesToFfmpeg();
+  }
+  onFfmpegStdoutData(data) {
+    if (!data?.length) return;
+    this.ffmpegOutBuf = this.ffmpegOutBuf.length ? Buffer.concat([this.ffmpegOutBuf, data], this.ffmpegOutBuf.length + data.length) : data;
+    const MAX_BUF = 8 * 1024 * 1024;
+    if (this.ffmpegOutBuf.length > MAX_BUF) {
+      this.logger.warn?.(`[CompositeStream] ffmpeg stdout buffer grew too large (${this.ffmpegOutBuf.length} bytes); resyncing`);
+      this.ffmpegOutBuf = this.ffmpegOutBuf.subarray(this.ffmpegOutBuf.length - 1024 * 1024);
+    }
+    const emittedUpTo = this.emitH264AccessUnitsFromBuffer();
+    if (emittedUpTo > 0) {
+      this.ffmpegOutBuf = this.ffmpegOutBuf.subarray(emittedUpTo);
+    }
+  }
+  emitH264AccessUnitsFromBuffer() {
+    const buf = this.ffmpegOutBuf;
+    if (!buf?.length) return 0;
+    const len = buf.length;
+    if (len < 5) return 0;
+    const startCodeLenAt = (i) => {
+      if (i + 3 <= len && buf[i] === 0 && buf[i + 1] === 0) {
+        if (buf[i + 2] === 1) return 3;
+        if (i + 4 <= len && buf[i + 2] === 0 && buf[i + 3] === 1) return 4;
+      }
+      return 0;
+    };
+    let firstSc = -1;
+    for (let i = 0; i < Math.min(len - 3, 64); i++) {
+      if (startCodeLenAt(i)) {
+        firstSc = i;
+        break;
+      }
+    }
+    if (firstSc < 0) return 0;
+    if (firstSc > 0) {
+      this.ffmpegOutBuf = buf.subarray(firstSc);
+      return 0;
+    }
+    const startCodes = [];
+    for (let i = 0; i < len - 3; i++) {
+      if (startCodeLenAt(i)) startCodes.push(i);
+    }
+    if (startCodes.length < 2) return 0;
+    const removeEmulationPrevention = (rbsp) => {
+      const out = [];
+      for (let i = 0; i < rbsp.length; i++) {
+        const b = rbsp[i];
+        if (i >= 2 && rbsp[i - 1] === 0 && rbsp[i - 2] === 0 && b === 3) {
+          continue;
+        }
+        out.push(b);
+      }
+      return Buffer.from(out);
+    };
+    const readUE = (rbsp, bitOffset) => {
+      const totalBits = rbsp.length * 8;
+      let i = bitOffset;
+      let zeros = 0;
+      while (i < totalBits) {
+        const byte = rbsp[i >> 3];
+        const bit = byte >> 7 - (i & 7) & 1;
+        if (bit === 0) {
+          zeros++;
+          i++;
+          continue;
+        }
+        break;
+      }
+      if (i >= totalBits) return;
+      i++;
+      if (zeros === 0) return { value: 0, next: i };
+      if (i + zeros > totalBits) return;
+      let info = 0;
+      for (let k = 0; k < zeros; k++, i++) {
+        const byte = rbsp[i >> 3];
+        const bit = byte >> 7 - (i & 7) & 1;
+        info = info << 1 | bit;
+      }
+      const value = (1 << zeros) - 1 + info;
+      return { value, next: i };
+    };
+    const isFirstSliceOfPicture = (nal) => {
+      if (nal.length < 2) return false;
+      const nalType = nal[0] & 31;
+      if (nalType !== 1 && nalType !== 5) return false;
+      const rbsp = removeEmulationPrevention(nal.subarray(1));
+      const ue = readUE(rbsp, 0);
+      if (!ue) return false;
+      return ue.value === 0;
+    };
+    let currentAuStart = 0;
+    let sawVcl = false;
+    let emittedThrough = 0;
+    for (let idx = 0; idx < startCodes.length - 1; idx++) {
+      const scPos = startCodes[idx];
+      const scLen = startCodeLenAt(scPos);
+      if (!scLen) continue;
+      const nalStart = scPos + scLen;
+      const nalEnd = startCodes[idx + 1];
+      if (nalStart >= nalEnd || nalStart >= len) continue;
+      const nal = buf.subarray(nalStart, nalEnd);
+      if (!nal.length) continue;
+      const nalType = nal[0] & 31;
+      const isAud = nalType === 9;
+      const isVcl = nalType === 1 || nalType === 5;
+      if (isAud) {
+        if (sawVcl && scPos > currentAuStart) {
+          const au = buf.subarray(currentAuStart, scPos);
+          if (au.length) this.emit("videoFrame", au);
+          emittedThrough = scPos;
+        }
+        currentAuStart = scPos;
+        sawVcl = false;
+        continue;
+      }
+      if (isVcl) {
+        const firstSlice = isFirstSliceOfPicture(nal);
+        if (firstSlice) {
+          if (sawVcl && scPos > currentAuStart) {
+            const au = buf.subarray(currentAuStart, scPos);
+            if (au.length) this.emit("videoFrame", au);
+            emittedThrough = scPos;
+            currentAuStart = scPos;
+          }
+          sawVcl = true;
+        } else {
+          sawVcl = true;
+        }
+      }
+    }
+    return Math.max(0, emittedThrough);
+  }
+  /**
+   * Feed frames from native streams to ffmpeg
+   * Uses two separate loops to write frames continuously
+   */
+  async feedFramesToFfmpeg() {
+    if (!this.ffmpegProcess || !this.widerStream || !this.teleStream) {
+      return;
+    }
+    const requireKeyframeOnStartup = this.options.assumeH264Inputs ? false : this.options.requireKeyframeOnStartup ?? true;
+    const widerStdin = this.ffmpegProcess.stdio[0];
+    const teleStdin = this.ffmpegProcess.stdio[3];
+    if (!widerStdin || !teleStdin) {
+      this.logger.error?.("[CompositeStream] FFmpeg stdin not available");
+      return;
+    }
+    const feedWider = async () => {
+      try {
+        let widerSynced = !requireKeyframeOnStartup;
+        if (this.widerPrimeFrame?.data) {
+          try {
+            if (!requireKeyframeOnStartup || this.widerPrimeFrame.isKeyframe) {
+              const written = widerStdin.write(this.toAnnexB(this.widerPrimeFrame.data));
+              widerSynced = widerSynced || Boolean(this.widerPrimeFrame.isKeyframe);
+              if (!written) {
+                await new Promise((resolve) => {
+                  widerStdin.once("drain", () => resolve());
+                });
+              }
+            }
+            this.widerPrimeFrame = void 0;
+          } catch {
+          }
+        }
+        for await (const frame of this.widerStream) {
+          if (!this.active) break;
+          if (frame.audio) {
+            if (!this.audioSource) this.audioSource = "wider";
+            if (this.audioSource === "wider") this.emit("audioFrame", frame.data);
+            continue;
+          }
+          if (!widerSynced) {
+            if (!frame.isKeyframe) continue;
+            widerSynced = true;
+          }
+          try {
+            const written = widerStdin.write(this.toAnnexB(frame.data));
+            if (!written) {
+              await new Promise((resolve) => {
+                widerStdin.once("drain", () => resolve());
+              });
+            }
+          } catch (error) {
+            const code = error?.code;
+            if (code === "EPIPE" || code === "ERR_STREAM_WRITE_AFTER_END") {
+              this.logger.log?.("[CompositeStream] FFmpeg wider stdin closed");
+              break;
+            }
+            this.logger.error?.("[CompositeStream] Error writing wider frame:", error);
+          }
+        }
+      } catch (error) {
+        if (this.active) {
+          this.logger.error?.("[CompositeStream] Error in wider stream:", error);
+        }
+      } finally {
+        try {
+          widerStdin.end();
+        } catch {
+        }
+      }
+    };
+    const feedTele = async () => {
+      try {
+        let teleSynced = !requireKeyframeOnStartup;
+        if (this.telePrimeFrame?.data) {
+          try {
+            if (!requireKeyframeOnStartup || this.telePrimeFrame.isKeyframe) {
+              const written = teleStdin.write(this.toAnnexB(this.telePrimeFrame.data));
+              teleSynced = teleSynced || Boolean(this.telePrimeFrame.isKeyframe);
+              if (!written) {
+                await new Promise((resolve) => {
+                  teleStdin.once("drain", () => resolve());
+                });
+              }
+            }
+            this.telePrimeFrame = void 0;
+          } catch {
+          }
+        }
+        for await (const frame of this.teleStream) {
+          if (!this.active) break;
+          if (frame.audio) {
+            if (!this.audioSource) this.audioSource = "tele";
+            if (this.audioSource === "tele") this.emit("audioFrame", frame.data);
+            continue;
+          }
+          if (!teleSynced) {
+            if (!frame.isKeyframe) continue;
+            teleSynced = true;
+          }
+          try {
+            const written = teleStdin.write(this.toAnnexB(frame.data));
+            if (!written) {
+              await new Promise((resolve) => {
+                teleStdin.once("drain", () => resolve());
+              });
+            }
+          } catch (error) {
+            const code = error?.code;
+            if (code === "EPIPE" || code === "ERR_STREAM_WRITE_AFTER_END") {
+              this.logger.log?.("[CompositeStream] FFmpeg tele stdin closed");
+              break;
+            }
+            this.logger.error?.("[CompositeStream] Error writing tele frame:", error);
+          }
+        }
+      } catch (error) {
+        if (this.active) {
+          this.logger.error?.("[CompositeStream] Error in tele stream:", error);
+        }
+      } finally {
+        try {
+          teleStdin.end();
+        } catch {
+        }
+      }
+    };
+    Promise.all([feedWider(), feedTele()]).catch((error) => {
+      if (this.active) {
+        this.logger.error?.("[CompositeStream] Error in frame processing:", error);
+        this.emit("error", error);
+      }
+    });
+  }
+  toAnnexB(accessUnit) {
+    if (!accessUnit?.length) return accessUnit;
+    if (accessUnit.length >= 3 && accessUnit[0] === 0 && accessUnit[1] === 0) {
+      if (accessUnit[2] === 1) return accessUnit;
+      if (accessUnit.length >= 4 && accessUnit[2] === 0 && accessUnit[3] === 1) return accessUnit;
+    }
+    try {
+      let off = 0;
+      const parts = [];
+      while (off + 4 <= accessUnit.length) {
+        const n = accessUnit.readUInt32BE(off);
+        off += 4;
+        if (!n || off + n > accessUnit.length) {
+          return accessUnit;
+        }
+        parts.push(Buffer.from([0, 0, 0, 1]));
+        parts.push(accessUnit.subarray(off, off + n));
+        off += n;
+      }
+      if (!parts.length) return accessUnit;
+      return Buffer.concat(parts);
+    } catch {
+      return accessUnit;
+    }
+  }
+  /**
+   * Stop the composite stream
+   */
+  async stop() {
+    if (!this.active) {
+      return;
+    }
+    this.active = false;
+    this.logger.log?.("[CompositeStream] Stopping composite stream...");
+    if (this.ffmpegProcess) {
+      try {
+        this.ffmpegProcess.stdin?.end();
+        this.ffmpegProcess.kill("SIGTERM");
+        setTimeout(() => {
+          try {
+            this.ffmpegProcess?.kill("SIGKILL");
+          } catch {
+          }
+        }, 1e3);
+      } catch {
+      }
+      this.ffmpegProcess = null;
+    }
+    if (this.inputMode === "native") {
+      await Promise.all([
+        this.closeGenerator(this.widerStream),
+        this.closeGenerator(this.teleStream)
+      ]);
+      this.widerStream = null;
+      this.teleStream = null;
+    } else {
+      this.widerStream = null;
+      this.teleStream = null;
+    }
+    this.logger.log?.("[CompositeStream] Composite stream stopped");
+  }
+  /**
+   * Check if stream is active
+   */
+  isActive() {
+    return this.active;
+  }
+};
+
+// src/rfc/rfc4571-server.ts
+async function createRfc4571TcpServer(options) {
+  const isComposite = options.channel === void 0;
+  const parseCompositeFromRequestedId = (requestedId2) => {
+    if (!requestedId2) return;
+    const id = String(requestedId2);
+    const asProfile = (v) => v === "main" || v === "sub" || v === "ext" ? v : void 0;
+    if (id.startsWith("composite-native-") || id.startsWith("composite-rtsp-")) {
+      const source = id.startsWith("composite-rtsp-") ? "rtsp" : "native";
+      const parts = id.split("-").filter(Boolean);
+      if (parts.length >= 4) {
+        const wider = parts.length >= 5 ? parts[3] : parts[2];
+        const tele = parts.length >= 5 ? parts[4] : parts[3];
+        const widerProfile = asProfile(wider);
+        const teleProfile = asProfile(tele);
+        return {
+          source,
+          ...widerProfile ? { widerProfile } : {},
+          ...teleProfile ? { teleProfile } : {}
+        };
+      }
+      return { source };
+    }
+    return;
+  };
+  const apiFactoryCtx = {
+    profile: options.profile,
+    composite: isComposite,
+    ...options.channel !== void 0 ? { channel: options.channel } : {},
+    ...options.variant !== void 0 ? { variant: options.variant } : {}
+  };
+  const baseApi = options.api ?? await options.getApi?.(apiFactoryCtx);
+  if (!baseApi) {
+    throw new Error("createRfc4571TcpServer: missing api/getApi");
+  }
+  const resolvedCompositeApis = options.compositeApis ?? await options.getCompositeApis?.();
+  const {
+    channel,
+    profile,
+    variant,
+    logger,
+    expectedVideoType,
+    host = "127.0.0.1",
+    videoPayloadType = 96,
+    audioPayloadType = 97,
+    keyframeTimeoutMs = 5e3,
+    uptimeRestartMs: uptimeRestartMsOpt,
+    idleTeardownMs = 2500,
+    closeApiOnTeardown = true,
+    username,
+    password,
+    requireAuth = false,
+    compositeOptions,
+    requestedId,
+    aacAudioHint
+  } = options;
+  let dedicatedSession;
+  const apisToClose = /* @__PURE__ */ new Set();
+  apisToClose.add(baseApi);
+  if (resolvedCompositeApis?.widerApi)
+    apisToClose.add(resolvedCompositeApis.widerApi);
+  if (resolvedCompositeApis?.teleApi)
+    apisToClose.add(resolvedCompositeApis.teleApi);
+  const uptimeRestartMs = uptimeRestartMsOpt ?? (isComposite ? 6e4 : 1e4);
+  const variantSuffix = variant && variant !== "default" ? ` variant=${variant}` : "";
+  const logPrefix = isComposite ? `[native-rfc4571 composite profile=${profile}${variantSuffix}${requestedId ? ` id=${requestedId}` : ""}]` : `[native-rfc4571 ch=${channel} profile=${profile}${variantSuffix}]`;
+  const log = (message) => {
+    try {
+      if (logger?.info) {
+        logger.info(`${logPrefix} ${message}`);
+      } else if (logger?.log) {
+        logger.log(`${logPrefix} ${message}`);
+      }
+    } catch {
+    }
+  };
+  const logSessionsSummary = (action) => {
+    const summary = baseApi.getDedicatedSessionsSummary();
+    log(
+      `${action} [sessions: ${summary.count} active${summary.count > 0 ? ` (${summary.keys.join(", ")})` : ""}]`
+    );
+  };
+  log(
+    `starting (host=${host} videoPT=${videoPayloadType} audioPT=${audioPayloadType} expectedVideoType=${expectedVideoType ?? "n/a"} keyframeTimeoutMs=${keyframeTimeoutMs} uptimeRestartMs=${uptimeRestartMs} idleTeardownMs=${idleTeardownMs} composite=${isComposite})`
+  );
+  let videoStream;
+  let isCompositeStream = false;
+  if (isComposite) {
+    const widerChannel = compositeOptions?.widerChannel ?? 0;
+    const teleChannel = compositeOptions?.teleChannel ?? 1;
+    const requested = parseCompositeFromRequestedId(requestedId);
+    const outputProfile = profile;
+    let teleInputProfile = requested?.teleProfile ?? outputProfile;
+    let widerMainIsH264 = false;
+    try {
+      const widerApiForProbe = resolvedCompositeApis?.widerApi ?? baseApi;
+      const metadata = await widerApiForProbe.getStreamMetadata(widerChannel);
+      const streams = Array.isArray(metadata) ? metadata : Array.isArray(metadata?.streams) ? metadata.streams : [];
+      const main = streams.find((s) => s?.profile === "main");
+      const enc = typeof main?.videoEncType === "string" ? main.videoEncType.toLowerCase() : "";
+      widerMainIsH264 = enc.includes("264");
+    } catch {
+    }
+    let widerInputProfile = requested?.widerProfile ?? (outputProfile === "ext" ? "ext" : outputProfile === "main" && widerMainIsH264 ? "main" : "sub");
+    if (requested?.teleProfile && requested.teleProfile !== outputProfile) {
+      log(
+        `requestedId overrides tele INPUT profile (requested=${requested.teleProfile} output=${outputProfile})`
+      );
+    }
+    log(
+      `creating composite stream: outputProfile=${outputProfile} wider(ch=${widerChannel}, profile=${widerInputProfile}), tele(ch=${teleChannel}, profile=${teleInputProfile}) source=${requested?.source ?? "native"} widerMainIsH264=${widerMainIsH264}`
+    );
+    const widerApi = resolvedCompositeApis?.widerApi ?? baseApi;
+    const teleApi = resolvedCompositeApis?.teleApi ?? baseApi;
+    const forceH264 = compositeOptions?.forceH264;
+    const defaultForceH264 = outputProfile === "sub";
+    let widerRtspUrl;
+    let teleRtspUrl;
+    if (requested?.source === "rtsp") {
+      const onNvr = Boolean(compositeOptions?.onNvr);
+      const resolveLensRtspUrl = async (params) => {
+        const { rtspStreams } = await baseApi.buildVideoStreamOptions({
+          channel: params.channel,
+          onNvr,
+          compositeOnly: false,
+          lens: params.lens
+        });
+        const candidates = rtspStreams.filter(
+          (s) => s.container === "rtsp" && s.lens === params.desiredLens && Boolean(s.urlWithAuth)
+        );
+        const exact = candidates.find((s) => s.profile === params.profile);
+        if (exact?.urlWithAuth) {
+          return {
+            urlWithAuth: exact.urlWithAuth,
+            actualProfile: exact.profile
+          };
+        }
+        if (params.profile === "sub") {
+          const fallbackMain = candidates.find((s) => s.profile === "main");
+          if (fallbackMain?.urlWithAuth) {
+            return {
+              urlWithAuth: fallbackMain.urlWithAuth,
+              actualProfile: fallbackMain.profile
+            };
+          }
+        }
+        const available = rtspStreams.filter(
+          (s) => s.container === "rtsp" && s.lens === params.desiredLens
+        ).map((s) => `${s.profile}:${s.id}`).join(", ");
+        throw new Error(
+          `Requested composite RTSP inputs, but no RTSP ${params.desiredLens} stream found for channel=${params.channel} profile=${params.profile} (onNvr=${onNvr}). Available: [${available || "none"}]. Use composite-native-... or choose a different profile.`
+        );
+      };
+      const widerResolved = await resolveLensRtspUrl({
+        channel: widerChannel,
+        lens: "default",
+        desiredLens: "wide",
+        profile: widerInputProfile
+      });
+      widerRtspUrl = widerResolved.urlWithAuth;
+      widerInputProfile = widerResolved.actualProfile;
+      const teleResolved = await resolveLensRtspUrl({
+        channel: teleChannel,
+        lens: "telephoto",
+        desiredLens: "telephoto",
+        profile: teleInputProfile
+      });
+      teleRtspUrl = teleResolved.urlWithAuth;
+      if (teleResolved.actualProfile !== teleInputProfile) {
+        log(
+          `tele RTSP profile fallback applied (requested=${teleInputProfile} actual=${teleResolved.actualProfile})`
+        );
+      }
+      teleInputProfile = teleResolved.actualProfile;
+    }
+    videoStream = new CompositeStream({
+      api: baseApi,
+      widerApi,
+      teleApi,
+      widerChannel,
+      teleChannel,
+      widerProfile: widerInputProfile,
+      teleProfile: teleInputProfile,
+      ...widerRtspUrl && teleRtspUrl ? { widerRtspUrl, teleRtspUrl } : {},
+      ...compositeOptions?.rtspTransport ? { rtspTransport: compositeOptions.rtspTransport } : {},
+      pipPosition: compositeOptions?.pipPosition ?? "bottom-right",
+      pipSize: compositeOptions?.pipSize ?? 0.25,
+      // New default is percent-friendly (1%). Values > 1 are still treated as pixels.
+      pipMargin: compositeOptions?.pipMargin ?? 0.01,
+      ...compositeOptions?.onNvr !== void 0 ? { onNvr: compositeOptions.onNvr } : {},
+      ...forceH264 !== void 0 ? { forceH264 } : defaultForceH264 ? { forceH264: true } : {},
+      ...compositeOptions?.assumeH264Inputs !== void 0 ? { assumeH264Inputs: compositeOptions.assumeH264Inputs } : {},
+      ...compositeOptions?.disableTranscode !== void 0 ? { disableTranscode: compositeOptions.disableTranscode } : {},
+      logger
+    });
+    isCompositeStream = true;
+    await videoStream.start();
+    log(
+      "composite stream started; waiting for keyframe to extract parameter sets"
+    );
+  } else {
+    const ch = channel;
+    const deviceId = options.deviceId;
+    let streamClient;
+    if (deviceId) {
+      const sessionKey = `live:${deviceId}:ch${ch}:${profile}${variant && variant !== "default" ? `:${variant}` : ""}`;
+      dedicatedSession = await baseApi.createDedicatedSession(
+        sessionKey,
+        logger
+      );
+      streamClient = dedicatedSession.client;
+      logSessionsSummary(`dedicated session created: ${sessionKey}`);
+    } else {
+      streamClient = baseApi.client;
+    }
+    videoStream = new BaichuanVideoStream({
+      client: streamClient,
+      api: baseApi,
+      channel: ch,
+      profile,
+      variant,
+      logger
+    });
+    await videoStream.start();
+    log(
+      `stream started (ch=${ch} profile=${profile}${deviceId ? ` dedicated=${deviceId}` : ""})`
+    );
+  }
+  const waitForKeyframe = async () => {
+    if (isCompositeStream) {
+      return await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          cleanup();
+          reject(
+            new Error(
+              `Timeout waiting for keyframe on composite stream profile=${profile}`
+            )
+          );
+        }, keyframeTimeoutMs);
+        const onError = (e) => {
+          cleanup();
+          reject(e instanceof Error ? e : new Error(String(e)));
+        };
+        const onFrame = (frame) => {
+          const videoType = "H264";
+          try {
+            const { sps, pps, profileLevelId } = extractH264ParamSetsFromAccessUnit(frame);
+            if (!sps || !pps) {
+              return;
+            }
+            cleanup();
+            resolve({
+              videoType,
+              accessUnit: frame,
+              ...profileLevelId ? { profileLevelId } : {},
+              h264: { sps, pps }
+            });
+          } catch (e) {
+            return;
+          }
+        };
+        const onClose = () => {
+          cleanup();
+          reject(
+            new Error(
+              `Composite stream closed before keyframe (profile=${profile})`
+            )
+          );
+        };
+        const cleanup = () => {
+          clearTimeout(timeout);
+          videoStream.removeListener(
+            "error",
+            onError
+          );
+          videoStream.removeListener(
+            "videoFrame",
+            onFrame
+          );
+          videoStream.removeListener(
+            "close",
+            onClose
+          );
+        };
+        videoStream.on("error", onError);
+        videoStream.on(
+          "videoFrame",
+          onFrame
+        );
+        videoStream.on("close", onClose);
+      });
+    } else {
+      return await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          cleanup();
+          reject(
+            new Error(
+              `Timeout waiting for keyframe on native stream channel=${channel} profile=${profile}`
+            )
+          );
+        }, keyframeTimeoutMs);
+        const onError = (e) => {
+          cleanup();
+          reject(e instanceof Error ? e : new Error(String(e)));
+        };
+        const onAu = (au) => {
+          if (!au?.isKeyframe) return;
+          const videoType = au.videoType;
+          const accessUnit = au.data;
+          if (videoType === "H264") {
+            const { sps: sps2, pps: pps2, profileLevelId } = extractH264ParamSetsFromAccessUnit(accessUnit);
+            if (!sps2 || !pps2) return;
+            cleanup();
+            resolve({
+              videoType,
+              accessUnit,
+              ...profileLevelId ? { profileLevelId } : {},
+              h264: { sps: sps2, pps: pps2 }
+            });
+            return;
+          }
+          const { vps, sps, pps } = extractH265ParamSetsFromAccessUnit(accessUnit);
+          if (!vps || !sps || !pps) return;
+          cleanup();
+          resolve({ videoType, accessUnit, h265: { vps, sps, pps } });
+        };
+        const cleanup = () => {
+          clearTimeout(timeout);
+          videoStream.removeListener(
+            "error",
+            onError
+          );
+          videoStream.removeListener(
+            "videoAccessUnit",
+            onAu
+          );
+        };
+        videoStream.on("error", onError);
+        videoStream.on(
+          "videoAccessUnit",
+          onAu
+        );
+      });
+    }
+  };
+  let keyframe;
+  try {
+    keyframe = await waitForKeyframe();
+  } catch (e) {
+    try {
+      await videoStream.stop();
+    } catch {
+    }
+    if (closeApiOnTeardown) {
+      await Promise.allSettled(
+        Array.from(apisToClose).map(async (a) => {
+          try {
+            await a.close();
+          } catch {
+          }
+        })
+      );
+    } else {
+      const graceMs = isComposite ? 5e3 : 0;
+      for (const a of Array.from(apisToClose)) {
+        try {
+          a?.client?.requestIdleDisconnectSoon?.(
+            "rfc4571_teardown",
+            graceMs
+          );
+        } catch {
+        }
+      }
+    }
+    throw e;
+  }
+  if (expectedVideoType && keyframe.videoType !== expectedVideoType) {
+    log(
+      `expectedVideoType mismatch (expected=${expectedVideoType} actual=${keyframe.videoType})`
+    );
+  }
+  let fps = 25;
+  try {
+    if (isComposite) {
+      const widerChannel = compositeOptions?.widerChannel ?? 0;
+      const widerApi = resolvedCompositeApis?.widerApi ?? baseApi;
+      const metadata = await widerApi.getStreamMetadata(widerChannel);
+      const streams = Array.isArray(metadata) ? metadata : Array.isArray(metadata?.streams) ? metadata.streams : [];
+      const requested = parseCompositeFromRequestedId(requestedId);
+      const effectiveTeleProfile = requested?.teleProfile ?? profile;
+      let widerMainIsH264 = false;
+      try {
+        const main = streams.find((s) => s?.profile === "main");
+        const enc = typeof main?.videoEncType === "string" ? main.videoEncType.toLowerCase() : "";
+        widerMainIsH264 = enc.includes("264");
+      } catch {
+      }
+      const widerProfile = requested?.widerProfile ?? (effectiveTeleProfile === "ext" ? "ext" : effectiveTeleProfile === "main" && widerMainIsH264 ? "main" : "sub");
+      const stream = streams.find((s) => s?.profile === widerProfile);
+      const fr = Number(stream?.frameRate);
+      if (Number.isFinite(fr) && fr > 0) fps = fr;
+    } else {
+      const metadata = await baseApi.getStreamMetadata(channel);
+      const streams = Array.isArray(metadata) ? metadata : Array.isArray(metadata?.streams) ? metadata.streams : [];
+      const stream = streams.find((s) => s?.profile === profile);
+      const fr = Number(stream?.frameRate);
+      if (Number.isFinite(fr) && fr > 0) fps = fr;
+    }
+  } catch {
+  }
+  let audio;
+  const tryPrimeAudio = async () => {
+    return await new Promise((resolve) => {
+      let sawAnyAudio = false;
+      let debugLogsLeft = 3;
+      const audioPrimeTimeoutMs = isCompositeStream ? Math.min(1e4, keyframeTimeoutMs) : 5e3;
+      const timeout = setTimeout(() => {
+        cleanup();
+        if (!sawAnyAudio) {
+          resolve(void 0);
+          return;
+        }
+        const hint = aacAudioHint ?? { sampleRate: 8e3, channels: 1 };
+        const configHex = buildAacAudioSpecificConfigHex({
+          sampleRate: hint.sampleRate,
+          channels: hint.channels
+        });
+        if (!configHex) {
+          logger.warn(
+            `Native audio frames seen but could not derive AAC config (hint sampleRate=${hint.sampleRate} channels=${hint.channels}); cannot advertise audio track.`
+          );
+          resolve(void 0);
+          return;
+        }
+        logger.warn(
+          `Native audio frames appear to be raw AAC (no ADTS); advertising AAC using hint sampleRate=${hint.sampleRate} channels=${hint.channels}.`
+        );
+        resolve({
+          sampleRate: hint.sampleRate,
+          channels: hint.channels,
+          configHex,
+          mode: "raw"
+        });
+      }, audioPrimeTimeoutMs);
+      const onAudio = (frame) => {
+        sawAnyAudio = true;
+        const parsed = parseAdtsHeader(frame);
+        if (!parsed) {
+          if (debugLogsLeft-- > 0) {
+            const head = frame.subarray(0, Math.min(16, frame.length)).toString("hex");
+            logger.warn(
+              `Native audioFrame not ADTS: len=${frame.length} head=${head}`
+            );
+          }
+          return;
+        }
+        cleanup();
+        resolve({
+          sampleRate: parsed.sampleRate,
+          channels: parsed.channels,
+          configHex: parsed.configHex,
+          mode: "adts"
+        });
+      };
+      const cleanup = () => {
+        clearTimeout(timeout);
+        videoStream?.removeListener?.(
+          "audioFrame",
+          onAudio
+        );
+      };
+      videoStream?.on?.("audioFrame", onAudio);
+    });
+  };
+  audio = await tryPrimeAudio();
+  const video = {
+    videoType: keyframe.videoType,
+    payloadType: videoPayloadType,
+    ...keyframe.videoType === "H264" ? {
+      h264: {
+        sps: keyframe.h264.sps,
+        pps: keyframe.h264.pps,
+        ...keyframe.profileLevelId ? { profileLevelId: keyframe.profileLevelId } : {}
+      }
+    } : {
+      h265: {
+        vps: keyframe.h265.vps,
+        sps: keyframe.h265.sps,
+        pps: keyframe.h265.pps
+      }
+    }
+  };
+  const aacAudio = audio ? {
+    codec: "aac",
+    payloadType: audioPayloadType,
+    sampleRate: audio.sampleRate,
+    channels: audio.channels,
+    configHex: audio.configHex
+  } : void 0;
+  const sdp = buildRfc4571Sdp(video, aacAudio);
+  const makeMuxer = () => new Rfc4571Muxer(
+    logger,
+    videoPayloadType,
+    aacAudio ? audioPayloadType : void 0,
+    fps
+  );
+  let muxer = makeMuxer();
+  log(
+    `ready (video=${keyframe.videoType} fps=${fps}${aacAudio ? ` audio=aac/${aacAudio.sampleRate}/${aacAudio.channels}` : " audio=none"})`
+  );
+  let rfcClients = 0;
+  const sockets = /* @__PURE__ */ new Set();
+  let idleTeardownTimer;
+  let tearingDown = false;
+  let restarting = false;
+  let lastActivityMs = Date.now();
+  const touchActivity = () => {
+    lastActivityMs = Date.now();
+  };
+  const cancelIdleTeardown = () => {
+    if (!idleTeardownTimer) return;
+    clearTimeout(idleTeardownTimer);
+    idleTeardownTimer = void 0;
+  };
+  let uptimeTimer;
+  const stopUptimeMonitor = () => {
+    if (!uptimeTimer) return;
+    clearInterval(uptimeTimer);
+    uptimeTimer = void 0;
+  };
+  const startUptimeMonitor = () => {
+    if (!uptimeRestartMs || uptimeRestartMs <= 0) return;
+    if (uptimeTimer) return;
+    const tickMs = Math.max(
+      250,
+      Math.min(1e3, Math.floor(uptimeRestartMs / 2))
+    );
+    uptimeTimer = setInterval(() => {
+      if (tearingDown || restarting) return;
+      const idleFor = Date.now() - lastActivityMs;
+      if (idleFor < uptimeRestartMs) return;
+      restart(
+        new Error(
+          `No stream activity for ${idleFor}ms (threshold=${uptimeRestartMs}ms)`
+        )
+      ).catch(() => {
+      });
+    }, tickMs);
+  };
+  const scheduleIdleTeardown = (closeFn) => {
+    if (!idleTeardownMs) return;
+    if (idleTeardownTimer) return;
+    idleTeardownTimer = setTimeout(() => {
+      idleTeardownTimer = void 0;
+      if (rfcClients === 0)
+        closeFn(new Error("No RFC4571 clients (idle)")).catch(() => {
+        });
+    }, idleTeardownMs);
+  };
+  const server = netImpl.createServer();
+  const restart = async (reason) => {
+    if (tearingDown) return;
+    if (restarting) return;
+    restarting = true;
+    touchActivity();
+    cancelIdleTeardown();
+    const message = reason?.message || reason?.toString?.() || reason;
+    const address2 = server.address();
+    const addrStr = address2 && typeof address2 !== "string" ? `${address2.address}:${address2.port}` : "unbound";
+    if (message)
+      log(
+        `uptime watchdog: restarting (addr=${addrStr} clients=${rfcClients} reason=${message})`
+      );
+    else
+      log(
+        `uptime watchdog: restarting (addr=${addrStr} clients=${rfcClients})`
+      );
+    for (const s of Array.from(sockets)) {
+      try {
+        s.destroy();
+      } catch {
+      }
+    }
+    sockets.clear();
+    try {
+      muxer.close();
+    } catch {
+    }
+    muxer = makeMuxer();
+    try {
+      await videoStream.stop();
+    } catch {
+    }
+    try {
+      await videoStream.start();
+    } catch (e) {
+      restarting = false;
+      close(e).catch(() => {
+      });
+      return;
+    }
+    if (isCompositeStream) {
+    }
+    restarting = false;
+    touchActivity();
+    log("uptime watchdog: restart complete");
+    if (rfcClients === 0) scheduleIdleTeardown(close);
+  };
+  const close = async (reason) => {
+    if (tearingDown) return;
+    tearingDown = true;
+    stopUptimeMonitor();
+    cancelIdleTeardown();
+    const reasonStr = reason?.message || reason?.toString?.() || reason || "requested";
+    muxer.close();
+    try {
+      await videoStream.stop();
+    } catch {
+    }
+    if (dedicatedSession) {
+      try {
+        await dedicatedSession.release();
+        logSessionsSummary("dedicated session released");
+      } catch {
+      }
+    }
+    if (closeApiOnTeardown) {
+      await Promise.allSettled(
+        Array.from(apisToClose).map(async (a) => {
+          try {
+            await a.close();
+          } catch {
+          }
+        })
+      );
+    }
+    try {
+      server.close();
+    } catch {
+    }
+    log(`teardown (${reasonStr})`);
+  };
+  server.on("connection", (socket) => {
+    touchActivity();
+    const remote = `${socket.remoteAddress ?? "unknown"}:${socket.remotePort ?? "unknown"}`;
+    const setupClient = () => {
+      rfcClients++;
+      cancelIdleTeardown();
+      sockets.add(socket);
+      socket.on("data", () => touchActivity());
+      try {
+        const origWrite = socket.write.bind(socket);
+        socket.write = (...args) => {
+          touchActivity();
+          return origWrite(...args);
+        };
+      } catch {
+      }
+      muxer.addClient(socket);
+      log(`client connected (${remote} total=${rfcClients})`);
+    };
+    if (!requireAuth) {
+      setupClient();
+    } else {
+      let authenticated = false;
+      let authBuffer = Buffer.alloc(0);
+      const authTimeout = setTimeout(() => {
+        if (!authenticated) {
+          log(`client authentication timeout (remote=${remote})`);
+          socket.destroy();
+        }
+      }, 5e3);
+      const onData = (data) => {
+        touchActivity();
+        if (!authenticated) {
+          authBuffer = Buffer.concat([authBuffer, data]);
+          const authString = authBuffer.toString("utf8");
+          const authMatch = authString.match(/^([^:]+):([^\n]+)\n/);
+          if (authMatch) {
+            const [, clientUsername, clientPassword] = authMatch;
+            if (clientUsername === username && clientPassword === password) {
+              authenticated = true;
+              clearTimeout(authTimeout);
+              setupClient();
+              const authLineLength = authMatch[0].length;
+              const remainingData = authBuffer.subarray(authLineLength);
+              socket.removeListener("data", onData);
+              socket.on("data", () => touchActivity());
+              if (remainingData.length > 0) {
+                socket.emit("data", remainingData);
+              }
+            } else {
+              log(`client authentication failed (remote=${remote})`);
+              socket.destroy();
+              return;
+            }
+          } else if (authBuffer.length > 1024) {
+            log(`client authentication buffer overflow (remote=${remote})`);
+            socket.destroy();
+            return;
+          }
+        }
+      };
+      socket.on("data", onData);
+    }
+    let counted = true;
+    const dec = () => {
+      if (!counted) return;
+      counted = false;
+      rfcClients = Math.max(0, rfcClients - 1);
+      sockets.delete(socket);
+      log(`client disconnected (${remote} total=${rfcClients})`);
+      if (rfcClients === 0) scheduleIdleTeardown(close);
+    };
+    socket.once("close", dec);
+    socket.once("error", dec);
+  });
+  if (isCompositeStream) {
+    videoStream.on(
+      "videoFrame",
+      (frame) => {
+        touchActivity();
+        try {
+          let isKeyframe = false;
+          try {
+            for (let i = 0; i < frame.length - 4; i++) {
+              if (frame[i] === 0 && frame[i + 1] === 0) {
+                let nalStart = -1;
+                if (frame[i + 2] === 1) {
+                  nalStart = i + 3;
+                } else if (frame[i + 2] === 0 && frame[i + 3] === 1) {
+                  nalStart = i + 4;
+                }
+                if (nalStart >= 0 && nalStart < frame.length) {
+                  const nalType = (frame[nalStart] ?? 0) & 31;
+                  if (nalType === 5) {
+                    isKeyframe = true;
+                    break;
+                  }
+                }
+              }
+            }
+          } catch {
+          }
+          muxer.sendVideoAccessUnit("H264", frame, isKeyframe, void 0);
+        } catch (e) {
+          close(e).catch(() => {
+          });
+        }
+      }
+    );
+    if (aacAudio) {
+      videoStream.on(
+        "audioFrame",
+        (frame) => {
+          touchActivity();
+          try {
+            if (audio?.mode === "adts") {
+              muxer.sendAudioAdtsFrame(frame);
+            } else {
+              muxer.sendAudioAacRawFrame(frame);
+            }
+          } catch (e) {
+            close(e).catch(() => {
+            });
+          }
+        }
+      );
+    }
+  } else {
+    videoStream.on(
+      "videoAccessUnit",
+      (au) => {
+        touchActivity();
+        try {
+          muxer.sendVideoAccessUnit(
+            au.videoType,
+            au.data,
+            au.isKeyframe,
+            au.microseconds
+          );
+        } catch (e) {
+          close(e).catch(() => {
+          });
+        }
+      }
+    );
+    if (aacAudio) {
+      videoStream.on(
+        "audioFrame",
+        (frame) => {
+          touchActivity();
+          try {
+            if (audio?.mode === "adts") {
+              muxer.sendAudioAdtsFrame(frame);
+            } else {
+              muxer.sendAudioAacRawFrame(frame);
+            }
+          } catch (e) {
+            close(e).catch(() => {
+            });
+          }
+        }
+      );
+    }
+  }
+  videoStream.on("error", (e) => {
+    if (restarting) return;
+    close(e).catch(() => {
+    });
+  });
+  videoStream.on("close", (e) => {
+    if (restarting) return;
+    close(e).catch(() => {
+    });
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, host, () => resolve());
+  });
+  const address = server.address();
+  if (!address || typeof address === "string") {
+    throw new Error("Failed to bind RFC TCP server");
+  }
+  const port = address.port;
+  if (!port) throw new Error("Failed to bind RFC TCP server");
+  log(`listening (addr=${host}:${port})`);
+  const audioInfo = aacAudio ? {
+    codec: "aac",
+    sampleRate: aacAudio.sampleRate,
+    channels: aacAudio.channels
+  } : void 0;
+  scheduleIdleTeardown(close);
+  startUptimeMonitor();
+  return {
+    host,
+    port,
+    sdp,
+    videoType: keyframe.videoType,
+    ...audioInfo ? { audio: audioInfo } : {},
+    username,
+    password,
+    server,
+    videoStream,
+    close
+  };
+}
+async function createRfc4571TcpServerForReplay(options) {
+  const {
+    api,
+    channel = 0,
+    fileName,
+    logger,
+    host = "127.0.0.1",
+    videoPayloadType = 96,
+    audioPayloadType = 97,
+    keyframeTimeoutMs = 15e3,
+    closeApiOnTeardown = false,
+    username,
+    password,
+    requireAuth = false,
+    aacAudioHint,
+    isNvr
+  } = options;
+  const streamType = options.streamType ?? (fileName.includes("RecS03_") ? "subStream" : "mainStream");
+  const deviceId = options.deviceId;
+  const log = (msg, ...args) => logger.log(
+    `[RFC4571-Replay ch=${channel} file=${fileName}] ${msg}`,
+    ...args
+  );
+  const warn = (msg, ...args) => logger.warn(
+    `[RFC4571-Replay ch=${channel} file=${fileName}] ${msg}`,
+    ...args
+  );
+  log(
+    `starting replay: streamType=${streamType}${deviceId ? ` deviceId=${deviceId}` : ""}`
+  );
+  const replayParams = {
+    channel,
+    fileName,
+    streamType,
+    timeoutMs: keyframeTimeoutMs,
+    logger
+  };
+  if (isNvr !== void 0) {
+    replayParams.isNvr = isNvr;
+  }
+  if (deviceId !== void 0) {
+    replayParams.deviceId = deviceId;
+  }
+  const { stream: videoStream, stop: stopReplay } = await api.startRecordingReplayStream(replayParams);
+  let audio;
+  const waitForKeyframe = async () => {
+    return await new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        cleanup();
+        reject(
+          new Error(
+            `Timeout waiting for keyframe in replay (file=${fileName})`
+          )
+        );
+      }, keyframeTimeoutMs);
+      const onError = (e) => {
+        cleanup();
+        reject(e instanceof Error ? e : new Error(String(e)));
+      };
+      const onAu = (au) => {
+        if (!au?.isKeyframe) return;
+        const videoType = au.videoType;
+        const accessUnit = au.data;
+        if (videoType === "H264") {
+          const { sps: sps2, pps: pps2, profileLevelId } = extractH264ParamSetsFromAccessUnit(accessUnit);
+          if (!sps2 || !pps2) return;
+          cleanup();
+          resolve({
+            videoType,
+            accessUnit,
+            ...profileLevelId ? { profileLevelId } : {},
+            h264: { sps: sps2, pps: pps2 }
+          });
+          return;
+        }
+        const { vps, sps, pps } = extractH265ParamSetsFromAccessUnit(accessUnit);
+        if (!vps || !sps || !pps) return;
+        cleanup();
+        resolve({ videoType, accessUnit, h265: { vps, sps, pps } });
+      };
+      const onAudioFrame = (frame) => {
+        if (audio) return;
+        try {
+          const adts = parseAdtsHeader(frame);
+          if (adts) {
+            audio = {
+              sampleRate: adts.sampleRate,
+              channels: adts.channels,
+              configHex: adts.configHex,
+              mode: "adts"
+            };
+            log(
+              `detected audio via ADTS: sr=${audio.sampleRate} ch=${audio.channels}`
+            );
+          }
+        } catch {
+          if (aacAudioHint) {
+            const configHex = buildAacAudioSpecificConfigHex({
+              sampleRate: aacAudioHint.sampleRate,
+              channels: aacAudioHint.channels
+            });
+            if (configHex) {
+              audio = {
+                sampleRate: aacAudioHint.sampleRate,
+                channels: aacAudioHint.channels,
+                configHex,
+                mode: "raw"
+              };
+              log(
+                `using AAC hint: sr=${audio.sampleRate} ch=${audio.channels}`
+              );
+            }
+          }
+        }
+      };
+      const cleanup = () => {
+        clearTimeout(timeout);
+        videoStream.removeListener("error", onError);
+        videoStream.removeListener("videoAccessUnit", onAu);
+        videoStream.removeListener("audioFrame", onAudioFrame);
+      };
+      videoStream.on("error", onError);
+      videoStream.on("videoAccessUnit", onAu);
+      videoStream.on("audioFrame", onAudioFrame);
+    });
+  };
+  let keyframe;
+  try {
+    keyframe = await waitForKeyframe();
+  } catch (e) {
+    try {
+      await stopReplay();
+    } catch {
+    }
+    if (closeApiOnTeardown) {
+      try {
+        await api.close();
+      } catch {
+      }
+    }
+    throw e;
+  }
+  log(`video detected: codec=${keyframe.videoType}`);
+  const video = {
+    videoType: keyframe.videoType,
+    payloadType: videoPayloadType,
+    ...keyframe.videoType === "H264" ? {
+      h264: {
+        sps: keyframe.h264.sps,
+        pps: keyframe.h264.pps,
+        ...keyframe.profileLevelId ? { profileLevelId: keyframe.profileLevelId } : {}
+      }
+    } : {
+      h265: {
+        vps: keyframe.h265.vps,
+        sps: keyframe.h265.sps,
+        pps: keyframe.h265.pps
+      }
+    }
+  };
+  const aacAudio = audio ? {
+    codec: "aac",
+    payloadType: audioPayloadType,
+    sampleRate: audio.sampleRate,
+    channels: audio.channels,
+    configHex: audio.configHex
+  } : void 0;
+  const sdp = buildRfc4571Sdp(video, aacAudio);
+  const fps = 25;
+  const muxer = new Rfc4571Muxer(
+    logger,
+    videoPayloadType,
+    aacAudio ? audioPayloadType : void 0,
+    fps
+  );
+  log(
+    `SDP ready (video=${keyframe.videoType}/90000 pt=${videoPayloadType}${aacAudio ? `, audio=aac/${aacAudio.sampleRate}/${aacAudio.channels} pt=${audioPayloadType}` : ", audio=none"})`
+  );
+  let rfcClients = 0;
+  const sockets = /* @__PURE__ */ new Set();
+  let tearingDown = false;
+  let replayEnded = false;
+  let onReplayEndCallback;
+  const close = async (reason) => {
+    if (tearingDown) return;
+    tearingDown = true;
+    const message = reason?.message || reason?.toString?.() || reason;
+    if (message) log(`closing: ${message}`);
+    else log("closing");
+    try {
+      await stopReplay();
+    } catch {
+    }
+    for (const s of sockets) {
+      try {
+        s.destroy();
+      } catch {
+      }
+    }
+    sockets.clear();
+    try {
+      server.close();
+    } catch {
+    }
+    if (closeApiOnTeardown) {
+      try {
+        await api.close();
+      } catch {
+      }
+    }
+  };
+  const server = netImpl.createServer();
+  server.on("connection", (socket) => {
+    const remote = `${socket.remoteAddress}:${socket.remotePort}`;
+    log(`client connected: ${remote}`);
+    sockets.add(socket);
+    rfcClients++;
+    const setupClient = () => {
+      muxer.addClient(socket);
+    };
+    if (!requireAuth) {
+      setupClient();
+    } else {
+      let authenticated = false;
+      let authBuffer = Buffer.alloc(0);
+      const authTimeout = setTimeout(() => {
+        if (!authenticated) {
+          log(`client authentication timeout (remote=${remote})`);
+          socket.destroy();
+        }
+      }, 5e3);
+      const onData = (data) => {
+        if (!authenticated) {
+          authBuffer = Buffer.concat([authBuffer, data]);
+          const authString = authBuffer.toString("utf8");
+          const authMatch = authString.match(/^([^:]+):([^\n]+)\n/);
+          if (authMatch) {
+            const [, clientUsername, clientPassword] = authMatch;
+            if (clientUsername === username && clientPassword === password) {
+              authenticated = true;
+              clearTimeout(authTimeout);
+              setupClient();
+              socket.removeListener("data", onData);
+            } else {
+              log(`client authentication failed (remote=${remote})`);
+              socket.destroy();
+              return;
+            }
+          } else if (authBuffer.length > 1024) {
+            log(`client authentication buffer overflow (remote=${remote})`);
+            socket.destroy();
+            return;
+          }
+        }
+      };
+      socket.on("data", onData);
+    }
+    let counted = true;
+    const dec = () => {
+      if (!counted) return;
+      counted = false;
+      rfcClients = Math.max(0, rfcClients - 1);
+      sockets.delete(socket);
+      log(`client disconnected (remote=${remote} clients=${rfcClients})`);
+      if (rfcClients === 0 && replayEnded) {
+        close("replay ended and no clients").catch(() => {
+        });
+      }
+    };
+    socket.once("close", dec);
+    socket.once("error", (e) => {
+      warn(`client socket error: ${remote}`, e?.message || String(e));
+      dec();
+    });
+  });
+  server.on("error", (e) => {
+    warn("server error", e?.message || String(e));
+    close(e).catch(() => {
+    });
+  });
+  videoStream.on("videoAccessUnit", (au) => {
+    if (tearingDown) return;
+    try {
+      muxer.sendVideoAccessUnit(
+        au.videoType,
+        au.data,
+        au.isKeyframe,
+        au.microseconds
+      );
+    } catch (e) {
+      close(e).catch(() => {
+      });
+    }
+  });
+  if (aacAudio) {
+    videoStream.on("audioFrame", (frame) => {
+      if (tearingDown) return;
+      try {
+        if (audio?.mode === "adts") {
+          muxer.sendAudioAdtsFrame(frame);
+        } else {
+          muxer.sendAudioAacRawFrame(frame);
+        }
+      } catch (e) {
+        close(e).catch(() => {
+        });
+      }
+    });
+  }
+  videoStream.on("end", () => {
+    log("replay ended naturally");
+    replayEnded = true;
+    onReplayEndCallback?.();
+    if (rfcClients === 0) {
+      close("replay ended").catch(() => {
+      });
+    }
+  });
+  videoStream.on("error", (e) => {
+    close(e).catch(() => {
+    });
+  });
+  videoStream.on("close", (e) => {
+    if (!replayEnded) {
+      close(e).catch(() => {
+      });
+    }
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, host, () => resolve());
+  });
+  const address = server.address();
+  if (!address || typeof address === "string") {
+    throw new Error("Failed to bind RFC TCP server for replay");
+  }
+  const port = address.port;
+  if (!port) throw new Error("Failed to bind RFC TCP server for replay");
+  log(`listening (addr=${host}:${port})`);
+  const audioInfo = aacAudio ? {
+    codec: "aac",
+    sampleRate: aacAudio.sampleRate,
+    channels: aacAudio.channels
+  } : void 0;
+  const result = {
+    host,
+    port,
+    sdp,
+    videoType: keyframe.videoType,
+    ...audioInfo ? { audio: audioInfo } : {},
+    username,
+    password,
+    server,
+    videoStream,
+    close
+  };
+  Object.defineProperty(result, "onReplayEnd", {
+    get: () => onReplayEndCallback,
+    set: (fn) => {
+      onReplayEndCallback = fn;
+    }
+  });
+  return result;
+}
+
+// src/rfc/replay-http-server.ts
+import http3 from "http";
+import { spawn as spawn4 } from "child_process";
+import { PassThrough } from "stream";
+async function createReplayHttpServer(options) {
+  const {
+    api,
+    channel = 0,
+    fileName,
+    logger,
+    ffmpegPath = "ffmpeg",
+    host = "127.0.0.1",
+    isNvr
+  } = options;
+  const streamType = options.streamType ?? (fileName.includes("RecS03_") ? "subStream" : "mainStream");
+  const log = (msg) => logger.log(`[ReplayHTTP ch=${channel} file=${fileName.slice(-30)}] ${msg}`);
+  const warn = (msg) => logger.warn(
+    `[ReplayHTTP ch=${channel} file=${fileName.slice(-30)}] ${msg}`
+  );
+  log(`starting replay: streamType=${streamType}`);
+  const frameCache = [];
+  let replayEnded = false;
+  let videoCodec = "h264";
+  let hasAudio = false;
+  let firstKeyframeReceived = false;
+  const replayParams = {
+    channel,
+    fileName,
+    streamType,
+    timeoutMs: 3e4,
+    logger
+  };
+  if (isNvr !== void 0) {
+    replayParams.isNvr = isNvr;
+  }
+  const { stream: videoStream, stop: stopReplay } = await api.startRecordingReplayStream(replayParams);
+  const onVideoFrame = (au) => {
+    if (!au?.data) return;
+    const frame = {
+      type: "video",
+      data: au.data,
+      isKeyframe: au.isKeyframe,
+      videoType: au.videoType,
+      timestamp: au.microseconds
+    };
+    frameCache.push(frame);
+    if (au.videoType === "H265") {
+      videoCodec = "h265";
+    }
+    if (au.isKeyframe && !firstKeyframeReceived) {
+      firstKeyframeReceived = true;
+      log(
+        `first keyframe received, codec=${videoCodec}, cached=${frameCache.length} frames`
+      );
+    }
+  };
+  const onAudioFrame = (frame) => {
+    if (!frame?.length) return;
+    hasAudio = true;
+    frameCache.push({
+      type: "audio",
+      data: frame
+    });
+  };
+  const onReplayEnd = () => {
+    log(`replay ended, total frames cached: ${frameCache.length}`);
+    replayEnded = true;
+  };
+  videoStream.on("videoAccessUnit", onVideoFrame);
+  videoStream.on("audioFrame", onAudioFrame);
+  videoStream.on("end", onReplayEnd);
+  videoStream.on("close", () => {
+    if (!replayEnded) {
+      replayEnded = true;
+    }
+  });
+  await new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      reject(new Error("Timeout waiting for first keyframe"));
+    }, 3e4);
+    const check = () => {
+      if (firstKeyframeReceived) {
+        clearTimeout(timeout);
+        resolve();
+      } else if (replayEnded) {
+        clearTimeout(timeout);
+        reject(new Error("Replay ended before first keyframe"));
+      } else {
+        setTimeout(check, 50);
+      }
+    };
+    check();
+  });
+  log(
+    `ready to serve: codec=${videoCodec}, hasAudio=${hasAudio}, cached=${frameCache.length} frames`
+  );
+  let httpServer = null;
+  let ffmpegProcess = null;
+  let closed = false;
+  const close = async () => {
+    if (closed) return;
+    closed = true;
+    log("closing...");
+    videoStream.removeListener("videoAccessUnit", onVideoFrame);
+    videoStream.removeListener("audioFrame", onAudioFrame);
+    videoStream.removeListener("end", onReplayEnd);
+    try {
+      await stopReplay();
+    } catch {
+    }
+    if (ffmpegProcess) {
+      try {
+        ffmpegProcess.kill("SIGKILL");
+      } catch {
+      }
+      ffmpegProcess = null;
+    }
+    if (httpServer) {
+      httpServer.close();
+      httpServer = null;
+    }
+  };
+  httpServer = http3.createServer((req, res) => {
+    if (closed) {
+      res.writeHead(503);
+      res.end("Server closed");
+      return;
+    }
+    log(`HTTP request: ${req.method} ${req.url}`);
+    res.writeHead(200, {
+      "Content-Type": "video/mp4",
+      "Transfer-Encoding": "chunked",
+      "Cache-Control": "no-cache, no-store",
+      Connection: "keep-alive"
+    });
+    const outputStream = new PassThrough();
+    const inputCodec = videoCodec === "h265" ? "hevc" : "h264";
+    const ffmpegArgs = [
+      "-hide_banner",
+      "-loglevel",
+      "error",
+      // Video input
+      "-f",
+      inputCodec,
+      "-i",
+      "pipe:0",
+      // Output settings - fragmented MP4 for streaming
+      "-c:v",
+      "copy",
+      "-movflags",
+      "frag_keyframe+empty_moov+default_base_moof",
+      "-f",
+      "mp4",
+      "pipe:1"
+    ];
+    log(`spawning ffmpeg: ${ffmpegPath} ${ffmpegArgs.join(" ")}`);
+    ffmpegProcess = spawn4(ffmpegPath, ffmpegArgs, {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    ffmpegProcess.stdout?.pipe(outputStream).pipe(res);
+    ffmpegProcess.stderr?.on("data", (data) => {
+      const msg = data.toString().trim();
+      if (msg) {
+        warn(`ffmpeg: ${msg}`);
+      }
+    });
+    ffmpegProcess.on("error", (err) => {
+      warn(`ffmpeg error: ${err.message}`);
+      res.end();
+    });
+    ffmpegProcess.on("close", (code) => {
+      log(`ffmpeg exited with code ${code}`);
+      res.end();
+    });
+    req.on("close", () => {
+      log("client disconnected");
+      if (ffmpegProcess) {
+        try {
+          ffmpegProcess.stdin?.end();
+          ffmpegProcess.kill("SIGTERM");
+        } catch {
+        }
+      }
+    });
+    const feedFrames = async () => {
+      const stdin = ffmpegProcess?.stdin;
+      if (!stdin) return;
+      let frameIndex = 0;
+      for (const frame of frameCache) {
+        if (frame.type === "video" && frame.data) {
+          try {
+            const canWrite = stdin.write(frame.data);
+            if (!canWrite) {
+              await new Promise(
+                (resolve) => stdin.once("drain", resolve)
+              );
+            }
+          } catch (e) {
+            warn(`error writing cached frame ${frameIndex}: ${e}`);
+            break;
+          }
+        }
+        frameIndex++;
+      }
+      log(`fed ${frameIndex} cached frames to ffmpeg`);
+      const liveFrameHandler = (au) => {
+        if (!au?.data || !stdin.writable) return;
+        try {
+          stdin.write(au.data);
+        } catch {
+        }
+      };
+      videoStream.on("videoAccessUnit", liveFrameHandler);
+      const endHandler = () => {
+        log("replay finished, closing ffmpeg stdin");
+        videoStream.removeListener("videoAccessUnit", liveFrameHandler);
+        try {
+          stdin.end();
+        } catch {
+        }
+      };
+      if (replayEnded) {
+        endHandler();
+      } else {
+        videoStream.once("end", endHandler);
+        videoStream.once("close", endHandler);
+      }
+    };
+    feedFrames().catch((e) => {
+      warn(`error feeding frames: ${e}`);
+    });
+  });
+  await new Promise((resolve, reject) => {
+    httpServer.once("error", reject);
+    httpServer.listen(0, host, () => resolve());
+  });
+  const address = httpServer.address();
+  if (!address || typeof address === "string") {
+    throw new Error("Failed to bind HTTP server");
+  }
+  const port = address.port;
+  const url = `http://${host}:${port}/replay.mp4`;
+  log(`HTTP server listening: ${url}`);
+  return {
+    url,
+    host,
+    port,
+    videoCodec,
+    hasAudio,
+    close
+  };
+}
+
+// src/baichuan/stream/BaichuanHttpStreamServer.ts
+import { EventEmitter as EventEmitter2 } from "events";
+import { spawn as spawn5 } from "child_process";
+import * as http4 from "http";
+var NAL_START_CODE_4B = Buffer.from([0, 0, 0, 1]);
+var NAL_START_CODE_3B = Buffer.from([0, 0, 1]);
+function hasAnnexBStart(data) {
+  if (data.length < 4) return false;
+  return data.subarray(0, 4).equals(NAL_START_CODE_4B) || data.subarray(0, 3).equals(NAL_START_CODE_3B);
+}
+function splitAnnexBNals(annexB) {
+  const starts = [];
+  for (let i = 0; i < annexB.length - 3; i++) {
+    if (annexB[i] === 0 && annexB[i + 1] === 0) {
+      if (annexB[i + 2] === 1) {
+        starts.push({ idx: i, len: 3 });
+        i += 2;
+      } else if (annexB[i + 2] === 0 && annexB[i + 3] === 1) {
+        starts.push({ idx: i, len: 4 });
+        i += 3;
+      }
+    }
+  }
+  if (starts.length === 0) return [];
+  const out = [];
+  for (let s = 0; s < starts.length; s++) {
+    const start = starts[s];
+    const payloadStart = start.idx + start.len;
+    const next = starts[s + 1];
+    const payloadEnd = next ? next.idx : annexB.length;
+    if (payloadEnd > payloadStart) out.push(annexB.subarray(payloadStart, payloadEnd));
+  }
+  return out;
+}
+function h264NalType(nalPayload) {
+  if (nalPayload.length < 1) return null;
+  const b0 = nalPayload[0];
+  if (b0 === void 0) return null;
+  return b0 & 31;
+}
+function isH264KeyframeFromAnnexB(annexB) {
+  const nals = splitAnnexBNals(annexB);
+  for (const nal of nals) {
+    const t = h264NalType(nal);
+    if (t === 5) return true;
+  }
+  return false;
+}
+var BaichuanHttpStreamServer = class extends EventEmitter2 {
+  videoStream;
+  listenPort;
+  path;
+  logger;
+  inputFps;
+  httpServer;
+  ffmpegProcess;
+  active = false;
+  clients = /* @__PURE__ */ new Set();
+  videoListener;
+  usingAccessUnit = false;
+  seenKeyframe = false;
+  cachedSps = null;
+  // payload without start code
+  cachedPps = null;
+  // payload without start code
+  constructor(options) {
+    super();
+    this.videoStream = options.videoStream;
+    this.listenPort = options.listenPort ?? 8080;
+    this.path = options.path ?? "/stream";
+    this.inputFps = options.inputFps ?? 25;
+    this.logger = options.logger ?? console;
+  }
+  /**
+   * Start HTTP stream server.
+   * Starts an HTTP server that serves an MPEG-TS stream.
+   */
+  async start() {
+    if (this.active) {
+      throw new Error("HTTP stream server already active");
+    }
+    this.logger.info(`[BaichuanHttpStreamServer] Starting Baichuan video stream...`);
+    await this.videoStream.start();
+    this.logger.info(`[BaichuanHttpStreamServer] Baichuan video stream started`);
+    this.httpServer = http4.createServer((req, res) => {
+      if (req.url === this.path || req.url === `${this.path}.ts`) {
+        this.logger.info(`[BaichuanHttpStreamServer] New client connected: ${req.socket.remoteAddress}`);
+        this.clients.add(res);
+        this.emit("client", req.socket.remoteAddress || "unknown");
+        res.writeHead(200, {
+          "Content-Type": "video/mp2t",
+          "Cache-Control": "no-cache",
+          "Connection": "keep-alive",
+          "Access-Control-Allow-Origin": "*"
+        });
+        req.on("close", () => {
+          this.clients.delete(res);
+          this.logger.info(`[BaichuanHttpStreamServer] Client disconnected`);
+        });
+      } else {
+        res.writeHead(404);
+        res.end("Not Found");
+      }
+    });
+    await new Promise((resolve, reject) => {
+      this.httpServer.listen(this.listenPort, "127.0.0.1", () => {
+        this.logger.info(`[BaichuanHttpStreamServer] HTTP server listening on port ${this.listenPort}`);
+        resolve();
+      });
+      this.httpServer.on("error", reject);
+    });
+    this.logger.info(`[BaichuanHttpStreamServer] Starting ffmpeg for H.264 -> MPEG-TS conversion...`);
+    const ffmpeg = spawn5("ffmpeg", [
+      "-hide_banner",
+      // ffmpeg warnings often include non-fatal decode messages (e.g. decode_slice_header),
+      // which we don't want to treat as application errors.
+      "-loglevel",
+      "error",
+      // Force a known frame rate on raw H.264 input so the muxer gets valid PTS/DTS.
+      "-r",
+      String(this.inputFps),
+      "-fflags",
+      "+genpts",
+      "-use_wallclock_as_timestamps",
+      "1",
+      "-f",
+      "h264",
+      // Input format (H.264 Annex-B)
+      "-i",
+      "pipe:0",
+      // Read from stdin
+      "-c:v",
+      "copy",
+      // Copy video codec (no re-encoding)
+      "-muxpreload",
+      "0",
+      "-muxdelay",
+      "0",
+      "-f",
+      "mpegts",
+      // Output format MPEG-TS
+      "pipe:1"
+      // Write to stdout
+    ], {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.ffmpegProcess = ffmpeg;
+    this.logger.info(`[BaichuanHttpStreamServer] FFmpeg process started (PID: ${ffmpeg.pid})`);
+    let frameCount = 0;
+    const writeToFfmpeg = (videoData) => {
+      if (!hasAnnexBStart(videoData)) {
+        return;
+      }
+      frameCount++;
+      if (frameCount === 1) {
+        this.logger.info(`[BaichuanHttpStreamServer] First video frame received (${videoData.length} bytes)`);
+      }
+      if (ffmpeg.stdin && !ffmpeg.stdin.destroyed) {
+        try {
+          ffmpeg.stdin.write(videoData);
+        } catch (error) {
+          this.logger.error(`[BaichuanHttpStreamServer] Error writing frame: ${error}`);
+          this.emit("error", error instanceof Error ? error : new Error(String(error)));
+        }
+      }
+    };
+    this.seenKeyframe = false;
+    this.usingAccessUnit = false;
+    this.cachedSps = null;
+    this.cachedPps = null;
+    this.videoListener = (unit) => {
+      const data = Buffer.isBuffer(unit) ? unit : unit?.data;
+      const isKeyframe = Buffer.isBuffer(unit) ? isH264KeyframeFromAnnexB(data) : Boolean(unit?.isKeyframe);
+      if (!Buffer.isBuffer(data)) return;
+      if (!Buffer.isBuffer(unit)) {
+        this.usingAccessUnit = true;
+      } else if (this.usingAccessUnit) {
+        return;
+      }
+      const nals = splitAnnexBNals(data);
+      for (const nal of nals) {
+        const t = h264NalType(nal);
+        if (t === 7) this.cachedSps = nal;
+        if (t === 8) this.cachedPps = nal;
+      }
+      if (!this.seenKeyframe) {
+        if (!isKeyframe) return;
+        this.seenKeyframe = true;
+        this.logger.info(`[BaichuanHttpStreamServer] First keyframe received: starting ffmpeg feed`);
+      }
+      if (isKeyframe && this.cachedSps && this.cachedPps) {
+        let hasSps = false;
+        let hasPps = false;
+        for (const nal of nals) {
+          const t = h264NalType(nal);
+          if (t === 7) hasSps = true;
+          if (t === 8) hasPps = true;
+        }
+        if (!hasSps || !hasPps) {
+          const patched = Buffer.concat([
+            NAL_START_CODE_4B,
+            this.cachedSps,
+            NAL_START_CODE_4B,
+            this.cachedPps,
+            data
+          ]);
+          writeToFfmpeg(patched);
+          return;
+        }
+      }
+      writeToFfmpeg(data);
+    };
+    this.videoStream.on("videoAccessUnit", this.videoListener);
+    this.videoStream.on("videoFrame", this.videoListener);
+    ffmpeg.stdout.on("data", (data) => {
+      for (const client of this.clients) {
+        if (!client.destroyed) {
+          try {
+            client.write(data);
+          } catch (error) {
+            this.clients.delete(client);
+          }
+        }
+      }
+    });
+    let ffmpegOutput = "";
+    ffmpeg.stderr.on("data", (data) => {
+      const output = data.toString();
+      ffmpegOutput += output;
+      const isKnownNonFatal = output.includes("top block unavailable") || output.includes("error while decoding") || output.includes("decode_slice_header error") || output.includes("no frame") || output.includes("concealing") || output.includes("left block unavailable") || output.includes("bottom block unavailable");
+      if (isKnownNonFatal) {
+        this.logger.warn(`[BaichuanHttpStreamServer] FFmpeg decode warning: ${output.trim()}`);
+        return;
+      }
+      const isCriticalError = output.includes("Invalid data found") || output.includes("Error opening") || output.includes("Could not write header") || output.includes("Broken pipe") || output.includes("Connection refused") || output.includes("Immediate exit") || output.includes("Conversion failed");
+      if (isCriticalError) {
+        this.logger.error(`[BaichuanHttpStreamServer] FFmpeg critical error: ${output.trim()}`);
+        this.emit("error", new Error(`FFmpeg error: ${output}`));
+      } else {
+        this.logger.warn(`[BaichuanHttpStreamServer] FFmpeg stderr: ${output.trim()}`);
+      }
+    });
+    ffmpeg.on("close", (code) => {
+      if (code !== 0) {
+        this.logger.error(`[BaichuanHttpStreamServer] FFmpeg exited with code ${code}`);
+        this.emit("error", new Error(`FFmpeg exited with code ${code}`));
+      }
+      this.active = false;
+      this.emit("close");
+    });
+    this.active = true;
+  }
+  /**
+   * Get HTTP URL for this stream.
+   */
+  getStreamUrl() {
+    return `http://127.0.0.1:${this.listenPort}${this.path}.ts`;
+  }
+  /**
+   * Stop HTTP stream server.
+   */
+  async stop() {
+    for (const client of this.clients) {
+      if (!client.destroyed) {
+        client.end();
+      }
+    }
+    this.clients.clear();
+    try {
+      await this.videoStream.stop();
+    } catch {
+    }
+    if (this.videoListener) {
+      this.videoStream.removeListener("videoAccessUnit", this.videoListener);
+      this.videoStream.removeListener("videoFrame", this.videoListener);
+    }
+    this.videoListener = void 0;
+    if (this.ffmpegProcess) {
+      const proc = this.ffmpegProcess;
+      try {
+        proc.kill("SIGTERM");
+      } catch {
+      }
+      await new Promise((resolve) => {
+        const t = setTimeout(() => {
+          try {
+            proc.kill("SIGKILL");
+          } catch {
+          }
+          resolve();
+        }, 1500);
+        t?.unref?.();
+        proc.once("close", () => {
+          clearTimeout(t);
+          resolve();
+        });
+      });
+    }
+    this.ffmpegProcess = void 0;
+    if (this.httpServer) {
+      await new Promise((resolve) => {
+        this.httpServer?.closeAllConnections?.();
+        this.httpServer?.closeIdleConnections?.();
+        this.httpServer.close(() => resolve());
+      });
+      this.httpServer = void 0;
+    }
+    this.active = false;
+  }
+  isActive() {
+    return this.active;
+  }
+};
+
+// src/multifocal/compositeRtspServer.ts
+import { EventEmitter as EventEmitter3 } from "events";
+import { spawn as spawn6 } from "child_process";
+import * as net from "net";
+var CompositeRtspServer = class extends EventEmitter3 {
+  options;
+  compositeStream = null;
+  rtspServer = null;
+  ffmpegProcess = null;
+  active = false;
+  logger;
+  connectedClients = /* @__PURE__ */ new Set();
+  constructor(options) {
+    super();
+    this.options = {
+      listenHost: "127.0.0.1",
+      listenPort: 8554,
+      path: "/composite",
+      ...options
+    };
+    this.logger = options.logger ?? console;
+  }
+  /**
+   * Avvia il server RTSP composito
+   */
+  async start() {
+    if (this.active) {
+      throw new Error("Composite RTSP server already active");
+    }
+    this.active = true;
+    this.logger.log?.("[CompositeRtspServer] Starting composite RTSP server...");
+    try {
+      this.compositeStream = new CompositeStream({
+        api: this.options.api,
+        widerChannel: this.options.widerChannel,
+        teleChannel: this.options.teleChannel,
+        widerProfile: this.options.widerProfile,
+        teleProfile: this.options.teleProfile,
+        ...this.options.pipPosition ? { pipPosition: this.options.pipPosition } : {},
+        ...this.options.pipSize !== void 0 ? { pipSize: this.options.pipSize } : {},
+        ...this.options.pipMargin !== void 0 ? { pipMargin: this.options.pipMargin } : {},
+        logger: this.logger
+      });
+      this.compositeStream.on("error", (error) => {
+        this.logger.error?.("[CompositeRtspServer] Composite stream error:", error);
+        this.emit("error", error);
+      });
+      this.compositeStream.on("close", () => {
+        this.logger.log?.("[CompositeRtspServer] Composite stream closed");
+      });
+      await this.compositeStream.start();
+      await this.startRtspServer();
+      this.logger.log?.(
+        `[CompositeRtspServer] Server started on ${this.options.listenHost}:${this.options.listenPort}${this.options.path}`
+      );
+    } catch (error) {
+      this.active = false;
+      this.emit("error", error);
+      throw error;
+    }
+  }
+  /**
+   * Avvia server RTSP usando ffmpeg
+   */
+  async startRtspServer() {
+    const widerMetadata = await this.options.api.getStreamMetadata(this.options.widerChannel);
+    const widerStreamInfo = widerMetadata.streams.find((s) => s.profile === this.options.widerProfile);
+    const width = widerStreamInfo?.width ?? 1920;
+    const height = widerStreamInfo?.height ?? 1080;
+    const fps = widerStreamInfo?.frameRate ?? 25;
+    this.rtspServer = net.createServer((socket) => {
+      this.handleRtspConnection(socket);
+    });
+    await new Promise((resolve, reject) => {
+      this.rtspServer.listen(this.options.listenPort, this.options.listenHost, () => {
+        const address = this.rtspServer.address();
+        if (address && typeof address === "object" && "port" in address) {
+          this.options.listenPort = address.port;
+        }
+        resolve();
+      });
+      this.rtspServer.on("error", reject);
+    });
+    this.startFfmpegRtspServer(width, height, fps);
+  }
+  /**
+   * Avvia ffmpeg come server RTSP che legge dallo stream composito
+   */
+  startFfmpegRtspServer(width, height, fps) {
+    const rtspUrl = `rtsp://${this.options.listenHost}:${this.options.listenPort}${this.options.path}`;
+    const ffmpegArgs = [
+      "-hide_banner",
+      "-loglevel",
+      "error",
+      "-f",
+      "h264",
+      "-i",
+      "pipe:0",
+      "-c:v",
+      "copy",
+      "-f",
+      "rtsp",
+      "-rtsp_flags",
+      "listen",
+      rtspUrl
+    ];
+    this.logger.log?.(
+      `[CompositeRtspServer] Starting ffmpeg RTSP server: ${ffmpegArgs.join(" ")}`
+    );
+    this.ffmpegProcess = spawn6("ffmpeg", ffmpegArgs, {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.ffmpegProcess.on("error", (error) => {
+      this.logger.error?.("[CompositeRtspServer] FFmpeg error:", error);
+      this.emit("error", error);
+    });
+    this.ffmpegProcess.on("close", (code) => {
+      if (code !== 0 && code !== null) {
+        this.logger.warn?.(`[CompositeRtspServer] FFmpeg exited with code ${code}`);
+      }
+    });
+    this.compositeStream.on("videoFrame", (frame) => {
+      if (this.ffmpegProcess?.stdin && !this.ffmpegProcess.stdin.destroyed) {
+        try {
+          const written = this.ffmpegProcess.stdin.write(frame);
+          if (!written) {
+            this.ffmpegProcess.stdin.once("drain", () => {
+            });
+          }
+        } catch (error) {
+          const code = error?.code;
+          if (code !== "EPIPE" && code !== "ERR_STREAM_WRITE_AFTER_END") {
+            this.logger.error?.("[CompositeRtspServer] Error writing to ffmpeg:", error);
+          }
+        }
+      }
+    });
+    this.ffmpegProcess.stderr?.on("data", (data) => {
+      const output = data.toString();
+      if (output.includes("error") || output.includes("Error")) {
+        this.logger.error?.("[CompositeRtspServer] FFmpeg stderr:", output);
+      }
+    });
+  }
+  /**
+   * Gestisce connessioni RTSP (semplificato - delega a ffmpeg)
+   */
+  handleRtspConnection(socket) {
+    const clientId = `${socket.remoteAddress}:${socket.remotePort}`;
+    this.logger.log?.(`[CompositeRtspServer] RTSP client connected: ${clientId}`);
+    this.connectedClients.add(clientId);
+    this.emit("client", clientId);
+    socket.on("close", () => {
+      this.connectedClients.delete(clientId);
+      this.emit("clientDisconnected", clientId);
+      this.logger.log?.(`[CompositeRtspServer] RTSP client disconnected: ${clientId}`);
+    });
+    socket.on("error", (error) => {
+      this.logger.error?.(`[CompositeRtspServer] RTSP client error:`, error);
+    });
+  }
+  /**
+   * Ferma il server RTSP composito
+   */
+  async stop() {
+    if (!this.active) {
+      return;
+    }
+    this.active = false;
+    this.logger.log?.("[CompositeRtspServer] Stopping server...");
+    if (this.compositeStream) {
+      await this.compositeStream.stop();
+      this.compositeStream = null;
+    }
+    if (this.ffmpegProcess) {
+      try {
+        this.ffmpegProcess.stdin?.end();
+        this.ffmpegProcess.kill("SIGTERM");
+        setTimeout(() => {
+          try {
+            this.ffmpegProcess?.kill("SIGKILL");
+          } catch {
+          }
+        }, 1e3);
+      } catch {
+      }
+      this.ffmpegProcess = null;
+    }
+    if (this.rtspServer) {
+      await new Promise((resolve) => {
+        this.rtspServer?.close(() => resolve());
+      });
+      this.rtspServer = null;
+    }
+    this.connectedClients.clear();
+    this.emit("close");
+    this.logger.log?.("[CompositeRtspServer] Server stopped");
+  }
+  /**
+   * Ottieni URL RTSP
+   */
+  getRtspUrl() {
+    return `rtsp://${this.options.listenHost}:${this.options.listenPort}${this.options.path}`;
+  }
+  /**
+   * Verifica se il server è attivo
+   */
+  isActive() {
+    return this.active;
+  }
+  /**
+   * Numero di client connessi
+   */
+  getClientCount() {
+    return this.connectedClients.size;
+  }
+};
+export {
+  AesStreamDecryptor,
+  AutodiscoveryClient,
+  BC_AES_IV,
+  BC_CLASS_FILE_DOWNLOAD,
+  BC_CLASS_LEGACY,
+  BC_CLASS_MODERN_20,
+  BC_CLASS_MODERN_24,
+  BC_CLASS_MODERN_24_ALT,
+  BC_CMD_ID_ABILITY_INFO,
+  BC_CMD_ID_ALARM_EVENT_LIST,
+  BC_CMD_ID_AUDIO_ALARM_PLAY,
+  BC_CMD_ID_CHANNEL_INFO_ALL,
+  BC_CMD_ID_CMD_123,
+  BC_CMD_ID_CMD_209,
+  BC_CMD_ID_CMD_265,
+  BC_CMD_ID_CMD_440,
+  BC_CMD_ID_COVER_PREVIEW,
+  BC_CMD_ID_COVER_RESPONSE,
+  BC_CMD_ID_COVER_STANDALONE_458,
+  BC_CMD_ID_COVER_STANDALONE_459,
+  BC_CMD_ID_COVER_STANDALONE_460,
+  BC_CMD_ID_COVER_STANDALONE_461,
+  BC_CMD_ID_COVER_STANDALONE_462,
+  BC_CMD_ID_FILE_INFO_LIST_CLOSE,
+  BC_CMD_ID_FILE_INFO_LIST_DL_VIDEO,
+  BC_CMD_ID_FILE_INFO_LIST_DOWNLOAD,
+  BC_CMD_ID_FILE_INFO_LIST_GET,
+  BC_CMD_ID_FILE_INFO_LIST_OPEN,
+  BC_CMD_ID_FILE_INFO_LIST_REPLAY,
+  BC_CMD_ID_FILE_INFO_LIST_STOP,
+  BC_CMD_ID_FIND_REC_VIDEO_CLOSE,
+  BC_CMD_ID_FIND_REC_VIDEO_GET,
+  BC_CMD_ID_FIND_REC_VIDEO_OPEN,
+  BC_CMD_ID_FLOODLIGHT_STATUS_LIST,
+  BC_CMD_ID_GET_ABILITY_SUPPORT,
+  BC_CMD_ID_GET_ACCESS_USER_LIST,
+  BC_CMD_ID_GET_AI_ALARM,
+  BC_CMD_ID_GET_AI_CFG,
+  BC_CMD_ID_GET_AI_DENOISE,
+  BC_CMD_ID_GET_AUDIO_ALARM,
+  BC_CMD_ID_GET_AUDIO_CFG,
+  BC_CMD_ID_GET_AUDIO_TASK,
+  BC_CMD_ID_GET_BATTERY_INFO,
+  BC_CMD_ID_GET_BATTERY_INFO_LIST,
+  BC_CMD_ID_GET_DAY_NIGHT_THRESHOLD,
+  BC_CMD_ID_GET_DAY_RECORDS,
+  BC_CMD_ID_GET_EMAIL_TASK,
+  BC_CMD_ID_GET_FTP_TASK,
+  BC_CMD_ID_GET_HDD_INFO_LIST,
+  BC_CMD_ID_GET_KIT_AP_CFG,
+  BC_CMD_ID_GET_LED_STATE,
+  BC_CMD_ID_GET_MOTION_ALARM,
+  BC_CMD_ID_GET_ONLINE_USER_LIST,
+  BC_CMD_ID_GET_OSD_DATETIME,
+  BC_CMD_ID_GET_PIR_INFO,
+  BC_CMD_ID_GET_PTZ_POSITION,
+  BC_CMD_ID_GET_PTZ_PRESET,
+  BC_CMD_ID_GET_RECORD,
+  BC_CMD_ID_GET_RECORD_CFG,
+  BC_CMD_ID_GET_REC_ENC_CFG,
+  BC_CMD_ID_GET_SIREN_STATUS,
+  BC_CMD_ID_GET_SLEEP_STATE,
+  BC_CMD_ID_GET_STREAM_INFO_LIST,
+  BC_CMD_ID_GET_SUPPORT,
+  BC_CMD_ID_GET_SYSTEM_GENERAL,
+  BC_CMD_ID_GET_TIMELAPSE_CFG,
+  BC_CMD_ID_GET_VIDEO_INPUT,
+  BC_CMD_ID_GET_WHITE_LED,
+  BC_CMD_ID_GET_WIFI,
+  BC_CMD_ID_GET_WIFI_SIGNAL,
+  BC_CMD_ID_GET_ZOOM_FOCUS,
+  BC_CMD_ID_PING,
+  BC_CMD_ID_PTZ_CONTROL,
+  BC_CMD_ID_PTZ_CONTROL_PRESET,
+  BC_CMD_ID_PUSH_COORDINATE_POINT_LIST,
+  BC_CMD_ID_PUSH_DINGDONG_LIST,
+  BC_CMD_ID_PUSH_NET_INFO,
+  BC_CMD_ID_PUSH_SERIAL,
+  BC_CMD_ID_PUSH_SLEEP_STATUS,
+  BC_CMD_ID_PUSH_VIDEO_INPUT,
+  BC_CMD_ID_SET_AI_ALARM,
+  BC_CMD_ID_SET_AI_CFG,
+  BC_CMD_ID_SET_AUDIO_TASK,
+  BC_CMD_ID_SET_MOTION_ALARM,
+  BC_CMD_ID_SET_PIR_INFO,
+  BC_CMD_ID_SET_WHITE_LED_STATE,
+  BC_CMD_ID_SET_WHITE_LED_TASK,
+  BC_CMD_ID_SET_ZOOM_FOCUS,
+  BC_CMD_ID_SUPPORT,
+  BC_CMD_ID_TALK,
+  BC_CMD_ID_TALK_ABILITY,
+  BC_CMD_ID_TALK_CONFIG,
+  BC_CMD_ID_TALK_RESET,
+  BC_CMD_ID_UDP_KEEP_ALIVE,
+  BC_CMD_ID_VIDEO,
+  BC_CMD_ID_VIDEO_STOP,
+  BC_MAGIC,
+  BC_MAGIC_REV,
+  BC_TCP_DEFAULT_PORT,
+  BC_XML_KEY,
+  BaichuanClient,
+  BaichuanEventEmitter,
+  BaichuanFrameParser,
+  BaichuanHttpStreamServer,
+  BaichuanRtspServer,
+  BaichuanVideoStream,
+  BcMediaAnnexBDecoder,
+  BcMediaCodec,
+  BcUdpStream,
+  CompositeRtspServer,
+  CompositeStream,
+  DUAL_LENS_DUAL_MOTION_MODELS,
+  DUAL_LENS_MODELS,
+  DUAL_LENS_SINGLE_MOTION_MODELS,
+  H264RtpDepacketizer,
+  H265RtpDepacketizer,
+  Intercom,
+  NVR_HUB_EXACT_TYPES,
+  NVR_HUB_MODEL_PATTERNS,
+  ReolinkBaichuanApi,
+  ReolinkCgiApi,
+  ReolinkHttpClient,
+  Rfc4571Muxer,
+  abilitiesHasAny,
+  aesDecrypt,
+  aesEncrypt,
+  asLogger,
+  autoDetectDeviceType,
+  bcDecrypt,
+  bcEncrypt,
+  bcHeaderHasPayloadOffset,
+  buildAacAudioSpecificConfigHex,
+  buildAbilityInfoExtensionXml,
+  buildBinaryExtensionXml,
+  buildChannelExtensionXml,
+  buildFloodlightManualXml,
+  buildLoginXml,
+  buildPreviewStopXml,
+  buildPreviewStopXmlV11,
+  buildPreviewXml,
+  buildPreviewXmlV11,
+  buildPtzControlXml,
+  buildPtzPresetXml,
+  buildPtzPresetXmlV2,
+  buildRfc4571Sdp,
+  buildRtspPath,
+  buildRtspUrl,
+  buildSirenManualXml,
+  buildSirenTimesXml,
+  buildStartZoomFocusXml,
+  buildWhiteLedStateXml,
+  collectCgiDiagnostics,
+  collectMultifocalDiagnostics,
+  collectNativeDiagnostics,
+  collectNvrDiagnostics,
+  computeDeviceCapabilities,
+  convertToAnnexB2 as convertH265ToAnnexB,
+  convertToAnnexB,
+  convertToLengthPrefixed,
+  createBaichuanEndpointsServer,
+  createDebugGateLogger,
+  createDiagnosticsBundle,
+  createLogger,
+  createNativeStream,
+  createNullLogger,
+  createReplayHttpServer,
+  createRfc4571TcpServer,
+  createRfc4571TcpServerForReplay,
+  createRtspProxyServer,
+  createTaggedLogger,
+  decodeHeader,
+  deriveAesKey,
+  detectVideoCodecFromNal,
+  discoverReolinkDevices,
+  discoverViaHttpScan,
+  discoverViaUdpBroadcast,
+  discoverViaUdpDirect,
+  encodeHeader,
+  extractH264ParamSetsFromAccessUnit,
+  extractH265ParamSetsFromAccessUnit,
+  extractPpsFromAnnexB,
+  extractSpsFromAnnexB,
+  extractVpsFromAnnexB,
+  flattenAbilitiesForChannel,
+  getConstructedVideoStreamOptions,
+  getGlobalLogger,
+  getH265NalType,
+  getVideoStream,
+  getXmlText,
+  hasStartCodes2 as hasH265StartCodes,
+  hasStartCodes,
+  isDualLenseModel,
+  isH264KeyframeAnnexB,
+  isH265Irap,
+  isH265KeyframeAnnexB,
+  isNvrHubModel,
+  isTcpFailureThatShouldFallbackToUdp,
+  isValidH264AnnexBAccessUnit,
+  isValidH265AnnexBAccessUnit,
+  maskUid,
+  md5HexUpper,
+  md5StrModern,
+  normalizeUid,
+  packetizeAacAdtsFrame,
+  packetizeAacRawFrame,
+  packetizeH264,
+  packetizeH265,
+  parseAdtsHeader,
+  parseBcMedia,
+  parseRecordingFileName,
+  parseSupportXml,
+  printNvrDiagnostics,
+  runAllDiagnosticsConsecutively,
+  runMultifocalDiagnosticsConsecutively,
+  sampleStreams,
+  setGlobalLogger,
+  splitAnnexBToNalPayloads,
+  splitAnnexBToNals,
+  splitAnnexBToNalPayloads2 as splitH265AnnexBToNalPayloads,
+  testChannelStreams,
+  xmlEscape,
+  zipDirectory
+};
+//# sourceMappingURL=index.js.map