@apocaliss92/nodelink-js 0.1.8 → 0.1.9

package/dist/index.js

@@ -37,7 +37,7 @@ import {
   normalizeUid,
   parseSupportXml,
   setGlobalLogger
-} from "./chunk-AFUYHWWQ.js";
+} from "./chunk-YUBYINJF.js";
 import {
   AesStreamDecryptor,
   BC_AES_IV,
@@ -203,7 +203,365 @@ import {
   testChannelStreams,
   xmlEscape,
   zipDirectory
-} from "./chunk-MC2BRLLE.js";
+} from "./chunk-TZFZ5WJX.js";
+
+// src/reolink/baichuan/HlsSessionManager.ts
+var withTimeout = async (p, ms, label) => {
+  let t;
+  try {
+    return await Promise.race([
+      p,
+      new Promise((_, reject) => {
+        t = setTimeout(
+          () => reject(new Error(`${label} timed out after ${ms}ms`)),
+          ms
+        );
+      })
+    ]);
+  } finally {
+    if (t) clearTimeout(t);
+  }
+};
+var HlsSessionManager = class {
+  constructor(api, options) {
+    this.api = api;
+    this.logger = options?.logger;
+    this.sessionTtlMs = options?.sessionTtlMs ?? 5 * 60 * 1e3;
+    const cleanupIntervalMs = options?.cleanupIntervalMs ?? 3e4;
+    this.cleanupTimer = setInterval(() => {
+      void this.cleanupExpiredSessions();
+    }, cleanupIntervalMs);
+  }
+  sessions = /* @__PURE__ */ new Map();
+  logger;
+  sessionTtlMs;
+  cleanupTimer;
+  creationLocks = /* @__PURE__ */ new Map();
+  /**
+   * Handle an HLS request and return the HTTP response.
+   *
+   * @param params - Request parameters
+   * @returns HTTP response ready to be sent
+   */
+  async handleRequest(params) {
+    const {
+      sessionKey,
+      hlsPath,
+      requestUrl,
+      createSession,
+      exclusiveKeyPrefix
+    } = params;
+    try {
+      let entry = this.sessions.get(sessionKey);
+      const isPlaylist = hlsPath === "playlist.m3u8" || hlsPath === "";
+      const isSegment = hlsPath.endsWith(".ts");
+      if (!entry && isSegment) {
+        this.logger?.debug?.(
+          `[HlsSessionManager] Segment request without session (likely stale after clip switch): ${sessionKey} ${hlsPath}`
+        );
+        return {
+          statusCode: 404,
+          headers: {
+            "Content-Type": "text/plain",
+            "Cache-Control": "no-store, no-cache, must-revalidate, max-age=0",
+            Pragma: "no-cache",
+            "Retry-After": "1"
+          },
+          body: "Segment not found"
+        };
+      }
+      if (!entry) {
+        if (!isPlaylist) {
+          return {
+            statusCode: 400,
+            headers: { "Content-Type": "text/plain" },
+            body: "Invalid HLS path"
+          };
+        }
+        const lockKey = exclusiveKeyPrefix ?? sessionKey;
+        await this.withCreationLock(lockKey, async () => {
+          entry = this.sessions.get(sessionKey);
+          if (entry) return;
+          if (exclusiveKeyPrefix) {
+            await this.stopOtherSessionsWithPrefix(
+              exclusiveKeyPrefix,
+              sessionKey
+            );
+          }
+          this.logger?.log?.(
+            `[HlsSessionManager] Creating new session: ${sessionKey}`
+          );
+          this.logger?.debug?.(
+            `[HlsSessionManager] createSession(): ${sessionKey}`
+          );
+          const sessionParams = await createSession();
+          this.logger?.debug?.(
+            `[HlsSessionManager] Starting createRecordingReplayHlsSession: ${sessionKey}`
+          );
+          const session = await withTimeout(
+            this.api.createRecordingReplayHlsSession({
+              channel: sessionParams.channel,
+              fileName: sessionParams.fileName,
+              ...sessionParams.isNvr !== void 0 && {
+                isNvr: sessionParams.isNvr
+              },
+              ...this.logger && { logger: this.logger },
+              ...sessionParams.deviceId && {
+                deviceId: sessionParams.deviceId
+              },
+              transcodeH265ToH264: sessionParams.transcodeH265ToH264 ?? true,
+              hlsSegmentDuration: sessionParams.hlsSegmentDuration ?? 4
+            }),
+            2e4,
+            "createRecordingReplayHlsSession"
+          );
+          try {
+            await withTimeout(
+              session.waitForReady(),
+              12e3,
+              "hls waitForReady"
+            );
+          } catch (e) {
+            this.logger?.warn?.(
+              `[HlsSessionManager] waitForReady did not complete in time for ${sessionKey}: ${e instanceof Error ? e.message : String(e)}`
+            );
+          }
+          entry = {
+            session,
+            createdAt: Date.now(),
+            lastAccessAt: Date.now()
+          };
+          this.sessions.set(sessionKey, entry);
+          this.logger?.log?.(
+            `[HlsSessionManager] Session ready: ${sessionKey}`
+          );
+        });
+        entry = this.sessions.get(sessionKey);
+        if (!entry) {
+          return {
+            statusCode: 500,
+            headers: {
+              "Content-Type": "text/plain",
+              "Cache-Control": "no-store, no-cache, must-revalidate, max-age=0",
+              Pragma: "no-cache"
+            },
+            body: "HLS session was not created"
+          };
+        }
+      }
+      entry.lastAccessAt = Date.now();
+      if (isPlaylist) {
+        return this.servePlaylist(entry.session, requestUrl, sessionKey);
+      }
+      if (isSegment) {
+        return this.serveSegment(entry.session, hlsPath, sessionKey);
+      }
+      return {
+        statusCode: 400,
+        headers: { "Content-Type": "text/plain" },
+        body: "Invalid HLS path"
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger?.error?.(
+        `[HlsSessionManager] Error handling request: ${message}`
+      );
+      return {
+        statusCode: 500,
+        headers: { "Content-Type": "text/plain" },
+        body: `HLS error: ${message}`
+      };
+    }
+  }
+  async withCreationLock(lockKey, fn) {
+    const prev = this.creationLocks.get(lockKey) ?? Promise.resolve();
+    let release;
+    const current = new Promise((resolve) => {
+      release = resolve;
+    });
+    const chained = prev.then(
+      () => current,
+      () => current
+    );
+    this.creationLocks.set(lockKey, chained);
+    await prev.catch(() => {
+    });
+    try {
+      await fn();
+    } finally {
+      release();
+      if (this.creationLocks.get(lockKey) === chained) {
+        this.creationLocks.delete(lockKey);
+      }
+    }
+  }
+  /**
+   * Check if a session exists for the given key.
+   */
+  hasSession(sessionKey) {
+    return this.sessions.has(sessionKey);
+  }
+  /**
+   * Stop a specific session.
+   */
+  async stopSession(sessionKey) {
+    const entry = this.sessions.get(sessionKey);
+    if (entry) {
+      this.logger?.debug?.(
+        `[HlsSessionManager] Stopping session: ${sessionKey}`
+      );
+      this.sessions.delete(sessionKey);
+      await entry.session.stop().catch(() => {
+      });
+    }
+  }
+  /**
+   * Stop all sessions and cleanup.
+   */
+  async stopAll() {
+    this.logger?.debug?.(`[HlsSessionManager] Stopping all sessions`);
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = void 0;
+    }
+    const stopPromises = Array.from(this.sessions.values()).map(
+      (entry) => entry.session.stop().catch(() => {
+      })
+    );
+    this.sessions.clear();
+    await Promise.all(stopPromises);
+  }
+  /**
+   * Get the number of active sessions.
+   */
+  get sessionCount() {
+    return this.sessions.size;
+  }
+  /**
+   * Serve the HLS playlist with rewritten segment URLs.
+   */
+  servePlaylist(session, requestUrl, sessionKey) {
+    let playlist = session.getPlaylist();
+    try {
+      const url = new URL(requestUrl, "http://localhost");
+      const basePath = url.pathname;
+      const baseParams = new URLSearchParams(url.searchParams);
+      baseParams.delete("hls");
+      playlist = playlist.replace(/^(segment_\d+\.ts)$/gm, (match) => {
+        const params = new URLSearchParams(baseParams);
+        params.set("hls", match);
+        return `${basePath}?${params.toString()}`;
+      });
+    } catch {
+    }
+    this.logger?.debug?.(
+      `[HlsSessionManager] Serving playlist: ${sessionKey}, length=${playlist.length}`
+    );
+    return {
+      statusCode: 200,
+      headers: {
+        "Content-Type": "application/vnd.apple.mpegurl",
+        "Cache-Control": "no-store, no-cache, must-revalidate, max-age=0",
+        Pragma: "no-cache"
+      },
+      body: playlist
+    };
+  }
+  /**
+   * Serve an HLS segment.
+   */
+  serveSegment(session, segmentName, sessionKey) {
+    const segment = session.getSegment(segmentName);
+    if (!segment) {
+      this.logger?.warn?.(
+        `[HlsSessionManager] Segment not found: ${segmentName}`
+      );
+      return {
+        statusCode: 404,
+        headers: {
+          "Content-Type": "text/plain",
+          "Cache-Control": "no-store, no-cache, must-revalidate, max-age=0",
+          Pragma: "no-cache",
+          "Retry-After": "1"
+        },
+        body: "Segment not found"
+      };
+    }
+    this.logger?.debug?.(
+      `[HlsSessionManager] Serving segment: ${segmentName} for ${sessionKey}, size=${segment.length}`
+    );
+    return {
+      statusCode: 200,
+      headers: {
+        "Content-Type": "video/mp2t",
+        "Cache-Control": "no-store, no-cache, must-revalidate, max-age=0",
+        Pragma: "no-cache",
+        "Content-Length": String(segment.length)
+      },
+      body: segment
+    };
+  }
+  /**
+   * Cleanup expired sessions.
+   */
+  async cleanupExpiredSessions() {
+    const now = Date.now();
+    const expiredKeys = [];
+    for (const [key, entry] of this.sessions) {
+      if (now - entry.lastAccessAt > this.sessionTtlMs) {
+        expiredKeys.push(key);
+      }
+    }
+    if (!expiredKeys.length) return;
+    await Promise.allSettled(
+      expiredKeys.map(async (key) => {
+        const entry = this.sessions.get(key);
+        if (!entry) return;
+        this.logger?.log?.(
+          `[HlsSessionManager] TTL expired: stopping session ${key}`
+        );
+        this.sessions.delete(key);
+        try {
+          await entry.session.stop();
+        } catch {
+        }
+      })
+    );
+  }
+  async stopOtherSessionsWithPrefix(prefix, exceptKey) {
+    const toStop = [];
+    for (const key of this.sessions.keys()) {
+      if (key !== exceptKey && key.startsWith(prefix)) toStop.push(key);
+    }
+    if (!toStop.length) return;
+    this.logger?.log?.(
+      `[HlsSessionManager] Switch: stopping ${toStop.length} session(s) for prefix=${prefix}`
+    );
+    await Promise.all(
+      toStop.map(async (key) => {
+        const entry = this.sessions.get(key);
+        if (!entry) return;
+        this.sessions.delete(key);
+        await entry.session.stop().catch(() => {
+        });
+      })
+    );
+  }
+};
+function detectIosClient(userAgent) {
+  const ua = (userAgent ?? "").toLowerCase();
+  const isIos = /iphone|ipad|ipod/.test(ua);
+  const isIosInstalledApp = ua.includes("installedapp");
+  return {
+    isIos,
+    isIosInstalledApp,
+    // iOS InstalledApp needs HLS for video playback
+    needsHls: isIos && isIosInstalledApp
+  };
+}
+function buildHlsRedirectUrl(originalUrl) {
+  return `${originalUrl}${originalUrl.includes("?") ? "&" : "?"}hls=playlist.m3u8`;
+}
 
 // src/reolink/AutodiscoveryClient.ts
 var AutodiscoveryClient = class {
@@ -576,6 +934,13 @@ function parseIntParam(v, def) {
   const n = Number.parseInt(v, 10);
   return Number.isFinite(n) ? n : def;
 }
+function parseBoolParam(v, def) {
+  if (v == null) return def;
+  const s = v.trim().toLowerCase();
+  if (s === "1" || s === "true" || s === "yes" || s === "y") return true;
+  if (s === "0" || s === "false" || s === "no" || s === "n") return false;
+  return def;
+}
 function parseProfile(v) {
   const p = (v ?? "sub").trim();
   if (p === "main" || p === "sub" || p === "ext") return p;
@@ -606,6 +971,11 @@ function createBaichuanEndpointsServer(opts) {
   const api = new ReolinkBaichuanApi({
     ...opts.baichuan
   });
+  const hlsManager = new HlsSessionManager(api, {
+    logger: console,
+    sessionTtlMs: 6e4,
+    cleanupIntervalMs: 5e3
+  });
   const listenHost = opts.listenHost ?? "127.0.0.1";
   const rtspListenHost = opts.rtspListenHost ?? "127.0.0.1";
   const rtspServers = /* @__PURE__ */ new Map();
@@ -651,6 +1021,46 @@ function createBaichuanEndpointsServer(opts) {
         res.end(JSON.stringify({ rtspUrl }));
         return;
       }
+      if (u.pathname === "/hls") {
+        const channel = parseIntParam(u.searchParams.get("channel"), 0);
+        const fileName = (u.searchParams.get("fileName") ?? "").trim();
+        const deviceId = (u.searchParams.get("deviceId") ?? "anon").trim();
+        const isNvr = parseBoolParam(u.searchParams.get("isNvr"), false);
+        const transcode = parseBoolParam(u.searchParams.get("transcode"), true);
+        const hlsSegmentDuration = parseIntParam(
+          u.searchParams.get("hlsSegmentDuration"),
+          2
+        );
+        const hlsPath = (u.searchParams.get("hls") ?? "playlist.m3u8").trim();
+        if (!fileName) {
+          res.statusCode = 400;
+          res.end("Missing fileName");
+          return;
+        }
+        const sessionKey = `hls:${deviceId}:ch${channel}:${fileName}`;
+        const exclusiveKeyPrefix = `hls:${deviceId}:ch${channel}:`;
+        const requestUrl = `http://${listenHost}:${opts.listenPort}${u.pathname}${u.search}`;
+        const result = await hlsManager.handleRequest({
+          sessionKey,
+          hlsPath,
+          requestUrl,
+          exclusiveKeyPrefix,
+          createSession: () => ({
+            channel,
+            fileName,
+            isNvr,
+            deviceId,
+            transcodeH265ToH264: transcode,
+            hlsSegmentDuration
+          })
+        });
+        res.statusCode = result.statusCode;
+        for (const [k, v] of Object.entries(result.headers)) {
+          res.setHeader(k, v);
+        }
+        res.end(result.body);
+        return;
+      }
       if (u.pathname === "/download") {
         const channel = parseIntParam(u.searchParams.get("channel"), 0);
         const uid = (u.searchParams.get("uid") ?? "").trim();
@@ -4609,9 +5019,9 @@ var BaichuanMjpegServer = class extends EventEmitter4 {
     this.started = true;
     const port = this.options.port ?? 8080;
     const host = this.options.host ?? "0.0.0.0";
-    const path = this.options.path ?? "/mjpeg";
+    const path2 = this.options.path ?? "/mjpeg";
     this.httpServer = http5.createServer((req, res) => {
-      this.handleRequest(req, res, path);
+      this.handleRequest(req, res, path2);
     });
     return new Promise((resolve, reject) => {
       this.httpServer.on("error", (err) => {
@@ -4621,9 +5031,9 @@ var BaichuanMjpegServer = class extends EventEmitter4 {
       this.httpServer.listen(port, host, () => {
         this.log(
           "info",
-          `MJPEG server started on http://${host}:${port}${path}`
+          `MJPEG server started on http://${host}:${port}${path2}`
         );
-        this.emit("started", { host, port, path });
+        this.emit("started", { host, port, path: path2 });
         resolve();
       });
     });
@@ -4990,10 +5400,16 @@ Error: ${err}`
       }
     };
     this.sessions.set(sessionId, session);
-    const videoTrack = new MediaStreamTrack({ kind: "video" });
-    peerConnection.addTrack(videoTrack);
+    const videoSsrc = Math.random() * 4294967295 >>> 0;
+    const videoTrack = new MediaStreamTrack({ kind: "video", ssrc: videoSsrc });
+    const videoSender = peerConnection.addTrack(videoTrack);
     session.videoTrack = videoTrack;
-    const audioTrack = new MediaStreamTrack({ kind: "audio" });
+    this.log(
+      "info",
+      `Video track created: ssrc=${videoTrack.ssrc}, sender params=${JSON.stringify(videoSender?.getParameters?.() ?? {})}`
+    );
+    const audioSsrc = Math.random() * 4294967295 >>> 0;
+    const audioTrack = new MediaStreamTrack({ kind: "audio", ssrc: audioSsrc });
     peerConnection.addTrack(audioTrack);
     session.audioTrack = audioTrack;
     const videoDataChannel = peerConnection.createDataChannel("video", {
@@ -5037,11 +5453,11 @@ Error: ${err}`
       };
     }
     peerConnection.iceConnectionStateChange.subscribe((state) => {
-      this.log("debug", `ICE connection state for ${sessionId}: ${state}`);
+      this.log("info", `ICE connection state for ${sessionId}: ${state}`);
       if (state === "connected") {
         session.state = "connected";
         this.emit("session-connected", { sessionId });
-      } else if (state === "disconnected" || state === "failed") {
+      } else if (state === "failed") {
         session.state = state;
         this.closeSession(sessionId).catch((err) => {
           this.log("error", `Error closing session on ICE ${state}: ${err}`);
@@ -5261,7 +5677,8 @@ Error: ${err}`
         } else {
           if (frame.data) {
             if (!session.videoCodec && frame.videoType) {
-              session.videoCodec = frame.videoType;
+              const detected = detectVideoCodecFromNal(frame.data);
+              session.videoCodec = detected ?? frame.videoType;
               this.log("info", `Detected video codec: ${session.videoCodec}`);
               if (session.videoDataChannel && session.videoDataChannel.readyState === "open") {
                 const codecInfo = JSON.stringify({
@@ -5284,22 +5701,45 @@ Error: ${err}`
             }
             lastTimeMicros = frame.microseconds || 0;
             if (session.videoCodec === "H264") {
-              await this.sendH264Frame(
+              const connState = session.peerConnection.connectionState;
+              const iceState = session.peerConnection.iceConnectionState;
+              const isConnected = connState === "connected" || iceState === "connected" || iceState === "completed";
+              if (!isConnected) {
+                if (frameNumber < 10) {
+                  this.log(
+                    "debug",
+                    `Waiting for connection, dropping H.264 frame ${frameNumber}`
+                  );
+                }
+                frameNumber++;
+                continue;
+              }
+              const packetsSent = await this.sendH264Frame(
                 session,
                 werift,
                 frame.data,
                 sequenceNumber,
                 timestamp
               );
-              sequenceNumber = sequenceNumber + Math.ceil(frame.data.length / 1200) & 65535;
-              packetsSentSinceLastLog++;
+              sequenceNumber = sequenceNumber + packetsSent & 65535;
+              packetsSentSinceLastLog += packetsSent;
+              frameNumber++;
+              session.stats.videoFrames++;
+              session.stats.bytesSent += frame.data.length;
             } else if (session.videoCodec === "H265") {
-              await this.sendH265Frame(session, frame, frameNumber);
-              packetsSentSinceLastLog++;
+              const sent = await this.sendVideoFrameViaDataChannel(
+                session,
+                frame,
+                frameNumber,
+                "H265"
+              );
+              if (sent) {
+                packetsSentSinceLastLog++;
+                frameNumber++;
+                session.stats.videoFrames++;
+                session.stats.bytesSent += frame.data.length;
+              }
             }
-            frameNumber++;
-            session.stats.videoFrames++;
-            session.stats.bytesSent += frame.data.length;
             const now = Date.now();
             if (now - lastLogTime >= 5e3) {
               this.log(
@@ -5322,27 +5762,312 @@ Error: ${err}`
   }
   /**
    * Send H.264 frame via RTP media track
+   * Returns the number of RTP packets sent
    */
   async sendH264Frame(session, werift, frameData, sequenceNumber, timestamp) {
-    const nalUnits = parseAnnexBNalUnits(frameData);
-    for (let i = 0; i < nalUnits.length; i++) {
-      const nalUnit = nalUnits[i];
+    const annexB = convertToAnnexB(frameData);
+    const nalUnits = splitAnnexBToNalPayloads(annexB);
+    let hasSps = false;
+    let hasPps = false;
+    let hasIdr = false;
+    const nalTypes = [];
+    for (const nal of nalUnits) {
+      const t = (nal[0] ?? 0) & 31;
+      nalTypes.push(t);
+      if (t === 7) {
+        hasSps = true;
+        session.lastH264Sps = nal;
+      }
+      if (t === 8) {
+        hasPps = true;
+        session.lastH264Pps = nal;
+      }
+      if (t === 5) hasIdr = true;
+    }
+    if (session.stats.videoFrames < 10) {
+      this.log(
+        "debug",
+        `H.264 frame NAL types: [${nalTypes.join(",")}] (5=IDR, 7=SPS, 8=PPS, 1=P-slice)`
+      );
+    }
+    const isKeyframe = hasIdr;
+    let nalList = nalUnits;
+    if (hasIdr && (!hasSps || !hasPps)) {
+      const prepend = [];
+      if (!hasSps && session.lastH264Sps) {
+        prepend.push(session.lastH264Sps);
+        this.log("debug", `Prepending cached SPS to IDR frame`);
+      }
+      if (!hasPps && session.lastH264Pps) {
+        prepend.push(session.lastH264Pps);
+        this.log("debug", `Prepending cached PPS to IDR frame`);
+      }
+      if (prepend.length > 0) {
+        nalList = [...prepend, ...nalUnits];
+      } else if (!session.lastH264Sps || !session.lastH264Pps) {
+        this.log(
+          "warn",
+          `IDR frame without SPS/PPS and no cached parameters - frame may not decode`
+        );
+      }
+    }
+    if (!session.hasReceivedKeyframe) {
+      if (hasIdr && session.lastH264Sps && session.lastH264Pps) {
+        session.hasReceivedKeyframe = true;
+        this.log(
+          "info",
+          `First H.264 keyframe received with SPS/PPS - starting video stream`
+        );
+      } else if (hasIdr) {
+        this.log(
+          "debug",
+          `IDR received but waiting for SPS/PPS before starting stream`
+        );
+        return 0;
+      } else {
+        if (session.stats.videoFrames < 5) {
+          this.log(
+            "debug",
+            `Dropping P-frame ${session.stats.videoFrames} while waiting for keyframe`
+          );
+        }
+        return 0;
+      }
+    }
+    let totalPacketsSent = 0;
+    let currentSeqNum = sequenceNumber;
+    const ssrc = session.videoTrack.ssrc || 0;
+    for (let i = 0; i < nalList.length; i++) {
+      const nalUnit = nalList[i];
       if (nalUnit.length === 0) continue;
-      const isLastNalu = i === nalUnits.length - 1;
+      const isLastNalu = i === nalList.length - 1;
       const nalType = getH264NalType(nalUnit);
       if (nalType === 9) continue;
       const rtpPackets = this.createH264RtpPackets(
         werift,
         nalUnit,
-        sequenceNumber,
+        currentSeqNum,
         timestamp,
-        isLastNalu
+        isLastNalu,
+        ssrc
       );
+      if (session.stats.videoFrames < 3) {
+        this.log(
+          "info",
+          `NAL ${i}: type=${nalType}, size=${nalUnit.length}, rtpPackets=${rtpPackets.length}`
+        );
+      }
       for (const rtpPacket of rtpPackets) {
-        session.videoTrack.writeRtp(rtpPacket);
-        sequenceNumber = sequenceNumber + 1 & 65535;
+        try {
+          session.videoTrack.writeRtp(rtpPacket);
+          currentSeqNum = currentSeqNum + 1 & 65535;
+          totalPacketsSent++;
+        } catch (err) {
+          this.log(
+            "error",
+            `Error writing RTP packet for session ${session.id}: ${err}`
+          );
+        }
       }
     }
+    if (session.stats.videoFrames < 3) {
+      this.log(
+        "info",
+        `H.264 frame sent: nalCount=${nalList.length} packets=${totalPacketsSent} seq=${sequenceNumber}->${currentSeqNum} ts=${timestamp} keyframe=${isKeyframe}`
+      );
+    }
+    return totalPacketsSent;
+  }
+  /**
+   * Send video frame via DataChannel (works for both H.264 and H.265)
+   * Format: 12-byte header + Annex-B data
+   * Header: [frameNum (4)] [timestamp (4)] [flags (1)] [keyframe (1)] [reserved (2)]
+   * Flags: 0x01 = H.265, 0x02 = H.264
+   */
+  async sendVideoFrameViaDataChannel(session, frame, frameNumber, codec) {
+    if (!session.videoDataChannel) {
+      if (frameNumber === 0) {
+        this.log("warn", `No video data channel for session ${session.id}`);
+      }
+      return false;
+    }
+    if (session.videoDataChannel.readyState !== "open") {
+      if (frameNumber === 0) {
+        this.log(
+          "warn",
+          `Video data channel not open for session ${session.id}: ${session.videoDataChannel.readyState}`
+        );
+      }
+      return false;
+    }
+    const nalUnits = parseAnnexBNalUnits(frame.data);
+    let isKeyframe = frame.isKeyframe === true;
+    let hasIdr = false;
+    let hasSps = false;
+    let hasPps = false;
+    let hasVps = false;
+    const nalTypes = [];
+    for (const nalUnit of nalUnits) {
+      if (nalUnit.length === 0) continue;
+      if (codec === "H265") {
+        const nalType = getH265NalType2(nalUnit);
+        nalTypes.push(nalType);
+        if (nalType === 32) {
+          hasVps = true;
+          session.lastH265Vps = nalUnit;
+        }
+        if (nalType === 33) {
+          hasSps = true;
+          session.lastH265Sps = nalUnit;
+        }
+        if (nalType === 34) {
+          hasPps = true;
+          session.lastH265Pps = nalUnit;
+        }
+        if (nalType === 19 || nalType === 20) {
+          hasIdr = true;
+          isKeyframe = true;
+        }
+      } else {
+        const nalType = getH264NalType(nalUnit);
+        nalTypes.push(nalType);
+        if (nalType === 7) {
+          hasSps = true;
+          session.lastH264Sps = nalUnit;
+        }
+        if (nalType === 8) {
+          hasPps = true;
+          session.lastH264Pps = nalUnit;
+        }
+        if (nalType === 5) {
+          hasIdr = true;
+          isKeyframe = true;
+        }
+      }
+    }
+    if (frameNumber < 5) {
+      this.log(
+        "debug",
+        `${codec} frame ${frameNumber} NAL types: [${nalTypes.join(",")}] hasIdr=${hasIdr} hasSps=${hasSps} hasPps=${hasPps}`
+      );
+    }
+    if (!session.hasReceivedKeyframe) {
+      if (codec === "H264") {
+        if (hasIdr && session.lastH264Sps && session.lastH264Pps) {
+          session.hasReceivedKeyframe = true;
+          this.log(
+            "info",
+            `First H.264 keyframe received with SPS/PPS - starting video stream`
+          );
+        } else if (hasSps || hasPps) {
+          this.log("debug", `Received H.264 parameter sets, waiting for IDR`);
+          return false;
+        } else if (hasIdr) {
+          this.log("debug", `IDR received but waiting for SPS/PPS`);
+          return false;
+        } else {
+          if (frameNumber < 10) {
+            this.log(
+              "debug",
+              `Dropping H.264 P-frame ${frameNumber} while waiting for keyframe`
+            );
+          }
+          return false;
+        }
+      } else {
+        if (hasIdr && session.lastH265Vps && session.lastH265Sps && session.lastH265Pps) {
+          session.hasReceivedKeyframe = true;
+          this.log(
+            "info",
+            `First H.265 keyframe received with VPS/SPS/PPS - starting video stream`
+          );
+        } else if (hasVps || hasSps || hasPps) {
+          this.log("debug", `Received H.265 parameter sets, waiting for IDR`);
+          return false;
+        } else if (hasIdr) {
+          this.log("debug", `H.265 IDR received but waiting for VPS/SPS/PPS`);
+          return false;
+        } else {
+          if (frameNumber < 10) {
+            this.log(
+              "debug",
+              `Dropping H.265 P-frame ${frameNumber} while waiting for keyframe`
+            );
+          }
+          return false;
+        }
+      }
+    }
+    let frameData = frame.data;
+    if (hasIdr) {
+      if (codec === "H264" && (!hasSps || !hasPps)) {
+        const parts = [];
+        if (!hasSps && session.lastH264Sps) {
+          parts.push(Buffer.from([0, 0, 0, 1]));
+          parts.push(session.lastH264Sps);
+        }
+        if (!hasPps && session.lastH264Pps) {
+          parts.push(Buffer.from([0, 0, 0, 1]));
+          parts.push(session.lastH264Pps);
+        }
+        if (parts.length > 0) {
+          frameData = Buffer.concat([...parts, frame.data]);
+          this.log("debug", `Prepended cached SPS/PPS to H.264 IDR frame`);
+        }
+      } else if (codec === "H265" && (!hasVps || !hasSps || !hasPps)) {
+        const parts = [];
+        if (!hasVps && session.lastH265Vps) {
+          parts.push(Buffer.from([0, 0, 0, 1]));
+          parts.push(session.lastH265Vps);
+        }
+        if (!hasSps && session.lastH265Sps) {
+          parts.push(Buffer.from([0, 0, 0, 1]));
+          parts.push(session.lastH265Sps);
+        }
+        if (!hasPps && session.lastH265Pps) {
+          parts.push(Buffer.from([0, 0, 0, 1]));
+          parts.push(session.lastH265Pps);
+        }
+        if (parts.length > 0) {
+          frameData = Buffer.concat([...parts, frame.data]);
+          this.log("debug", `Prepended cached VPS/SPS/PPS to H.265 IDR frame`);
+        }
+      }
+    }
+    const header = Buffer.alloc(12);
+    header.writeUInt32BE(frameNumber, 0);
+    header.writeUInt32BE(frame.microseconds ? frame.microseconds / 1e3 : 0, 4);
+    header.writeUInt8(codec === "H265" ? 1 : 2, 8);
+    header.writeUInt8(isKeyframe ? 1 : 0, 9);
+    header.writeUInt16BE(0, 10);
+    const packet = Buffer.concat([header, frameData]);
+    if (frameNumber < 3) {
+      this.log(
+        "info",
+        `Sending ${codec} frame ${frameNumber}: ${packet.length} bytes, keyframe=${isKeyframe}`
+      );
+    }
+    const MAX_CHUNK_SIZE = 16e3;
+    try {
+      if (packet.length <= MAX_CHUNK_SIZE) {
+        session.videoDataChannel.send(packet);
+      } else {
+        const totalChunks = Math.ceil(packet.length / MAX_CHUNK_SIZE);
+        for (let i = 0; i < totalChunks; i++) {
+          const start = i * MAX_CHUNK_SIZE;
+          const end = Math.min(start + MAX_CHUNK_SIZE, packet.length);
+          const chunk = packet.subarray(start, end);
+          const chunkHeader = Buffer.alloc(2);
+          chunkHeader.writeUInt8(i, 0);
+          chunkHeader.writeUInt8(totalChunks, 1);
+          session.videoDataChannel.send(Buffer.concat([chunkHeader, chunk]));
+        }
+      }
+      return true;
+    } catch (err) {
+      this.log("error", `Error sending ${codec} frame ${frameNumber}: ${err}`);
+      return false;
+    }
   }
   /**
    * Send H.265 frame via DataChannel
@@ -5414,7 +6139,7 @@ Error: ${err}`
    * Create RTP packets for H.264 NAL unit
    * Handles single NAL, STAP-A aggregation, and FU-A fragmentation
    */
-  createH264RtpPackets(werift, nalUnit, sequenceNumber, timestamp, marker) {
+  createH264RtpPackets(werift, nalUnit, sequenceNumber, timestamp, marker, ssrc) {
     const { RtpPacket, RtpHeader } = werift;
     const MTU = 1200;
     const packets = [];
@@ -5424,6 +6149,7 @@ Error: ${err}`
       header.sequenceNumber = sequenceNumber;
       header.timestamp = timestamp;
       header.marker = marker;
+      header.ssrc = ssrc;
       packets.push(new RtpPacket(header, nalUnit));
     } else {
       const nalHeader = nalUnit[0];
@@ -5448,6 +6174,7 @@ Error: ${err}`
         header.sequenceNumber = sequenceNumber + packets.length & 65535;
         header.timestamp = timestamp;
         header.marker = isLast && marker;
+        header.ssrc = ssrc;
         packets.push(new RtpPacket(header, fuPayload));
         offset += chunkSize;
         isFirst = false;
@@ -5484,11 +6211,450 @@ Error: ${err}`
   }
 };
 
-// src/multifocal/compositeRtspServer.ts
+// src/baichuan/stream/BaichuanHlsServer.ts
 import { EventEmitter as EventEmitter6 } from "events";
+import fs from "fs";
+import fsp from "fs/promises";
+import os from "os";
+import path from "path";
 import { spawn as spawn7 } from "child_process";
+function parseAnnexBNalUnits2(data) {
+  const units = [];
+  const len = data.length;
+  const findStart = (from) => {
+    for (let i = from; i + 3 < len; i++) {
+      if (data[i] === 0 && data[i + 1] === 0) {
+        if (data[i + 2] === 1) return i;
+        if (i + 4 < len && data[i + 2] === 0 && data[i + 3] === 1)
+          return i;
+      }
+    }
+    return -1;
+  };
+  const startCodeLenAt = (i) => {
+    if (i + 3 < len && data[i] === 0 && data[i + 1] === 0) {
+      if (data[i + 2] === 1) return 3;
+      if (i + 4 < len && data[i + 2] === 0 && data[i + 3] === 1) return 4;
+    }
+    return 0;
+  };
+  let start = findStart(0);
+  if (start < 0) return units;
+  while (start >= 0) {
+    const scLen = startCodeLenAt(start);
+    if (!scLen) break;
+    const nalStart = start + scLen;
+    let next = findStart(nalStart);
+    if (next < 0) next = len;
+    if (nalStart < next) units.push(data.subarray(nalStart, next));
+    start = next < len ? next : -1;
+  }
+  return units;
+}
+function isKeyframeAnnexB(codec, annexB) {
+  const nals = parseAnnexBNalUnits2(annexB);
+  for (const nal of nals) {
+    if (!nal || nal.length === 0) continue;
+    if (codec === "h264") {
+      const nalType = nal[0] & 31;
+      if (nalType === 5) return true;
+    } else {
+      const nalType = nal[0] >> 1 & 63;
+      if (nalType >= 16 && nalType <= 21) return true;
+    }
+  }
+  return false;
+}
+function hasParamSets(codec, annexB) {
+  const nals = parseAnnexBNalUnits2(annexB);
+  for (const nal of nals) {
+    if (!nal || nal.length === 0) continue;
+    if (codec === "h264") {
+      const nalType = nal[0] & 31;
+      if (nalType === 7 || nalType === 8) return true;
+    } else {
+      const nalType = nal[0] >> 1 & 63;
+      if (nalType === 32 || nalType === 33 || nalType === 34) return true;
+    }
+  }
+  return false;
+}
+function getNalTypes(codec, annexB) {
+  const nals = parseAnnexBNalUnits2(annexB);
+  return nals.map((nal) => {
+    if (codec === "h265") {
+      return nal[0] >> 1 & 63;
+    } else {
+      return nal[0] & 31;
+    }
+  });
+}
+var BaichuanHlsServer = class extends EventEmitter6 {
+  api;
+  channel;
+  profile;
+  variant;
+  segmentDuration;
+  playlistSize;
+  ffmpegPath;
+  log;
+  outputDir = null;
+  createdTempDir = false;
+  playlistPath = null;
+  segmentPattern = null;
+  state = "idle";
+  codec = null;
+  framesReceived = 0;
+  ffmpeg = null;
+  nativeStream = null;
+  pumpPromise = null;
+  startedAt = null;
+  lastError = null;
+  constructor(options) {
+    super();
+    this.api = options.api;
+    this.channel = options.channel;
+    this.profile = options.profile;
+    this.variant = options.variant ?? void 0;
+    this.segmentDuration = options.segmentDuration ?? 2;
+    this.playlistSize = options.playlistSize ?? 5;
+    this.ffmpegPath = options.ffmpegPath ?? "ffmpeg";
+    if (options.outputDir) {
+      this.outputDir = options.outputDir;
+      this.createdTempDir = false;
+    }
+    this.log = options.logger ?? (() => {
+    });
+  }
+  /**
+   * Start HLS streaming
+   */
+  async start() {
+    if (this.state === "running" || this.state === "starting") {
+      return;
+    }
+    this.state = "starting";
+    this.lastError = null;
+    try {
+      if (!this.outputDir) {
+        this.outputDir = await fsp.mkdtemp(
+          path.join(os.tmpdir(), `nodelink-hls-${this.profile}-`)
+        );
+        this.createdTempDir = true;
+      } else {
+        await fsp.mkdir(this.outputDir, { recursive: true });
+      }
+      this.playlistPath = path.join(this.outputDir, "playlist.m3u8");
+      this.segmentPattern = path.join(this.outputDir, "segment_%05d.ts");
+      this.log("info", `Starting HLS stream to ${this.outputDir}`);
+      this.nativeStream = createNativeStream(
+        this.api,
+        this.channel,
+        this.profile,
+        this.variant ? { variant: this.variant } : void 0
+      );
+      this.pumpPromise = this.pumpNativeToFfmpeg();
+      this.startedAt = /* @__PURE__ */ new Date();
+      this.state = "running";
+      this.emit("started", { outputDir: this.outputDir });
+    } catch (err) {
+      this.state = "error";
+      this.lastError = String(err);
+      this.log("error", `Failed to start HLS: ${err}`);
+      throw err;
+    }
+  }
+  /**
+   * Stop HLS streaming
+   */
+  async stop() {
+    if (this.state === "idle" || this.state === "stopped") {
+      return;
+    }
+    this.state = "stopping";
+    this.log("info", "Stopping HLS stream");
+    try {
+      this.ffmpeg?.stdin?.end();
+    } catch {
+    }
+    try {
+      this.ffmpeg?.kill("SIGKILL");
+    } catch {
+    }
+    this.ffmpeg = null;
+    if (this.nativeStream) {
+      try {
+        await this.nativeStream.return(void 0);
+      } catch {
+      }
+      this.nativeStream = null;
+    }
+    if (this.pumpPromise) {
+      try {
+        await this.pumpPromise;
+      } catch {
+      }
+      this.pumpPromise = null;
+    }
+    if (this.createdTempDir && this.outputDir) {
+      try {
+        await fsp.rm(this.outputDir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+    this.state = "stopped";
+    this.emit("stopped");
+  }
+  /**
+   * Get current status
+   */
+  getStatus() {
+    return {
+      state: this.state,
+      codec: this.codec,
+      framesReceived: this.framesReceived,
+      ffmpegRunning: this.ffmpeg !== null && !this.ffmpeg.killed,
+      playlistPath: this.playlistPath,
+      outputDir: this.outputDir,
+      startedAt: this.startedAt,
+      error: this.lastError
+    };
+  }
+  /**
+   * Get playlist file path
+   */
+  getPlaylistPath() {
+    return this.playlistPath;
+  }
+  /**
+   * Get output directory
+   */
+  getOutputDir() {
+    return this.outputDir;
+  }
+  /**
+   * Check if playlist file exists
+   */
+  async waitForPlaylist(timeoutMs = 2e4) {
+    if (!this.playlistPath) return false;
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      if (fs.existsSync(this.playlistPath)) {
+        return true;
+      }
+      await new Promise((r) => setTimeout(r, 150));
+    }
+    return false;
+  }
+  /**
+   * Read an HLS asset (playlist or segment)
+   */
+  async readAsset(assetName) {
+    if (!this.outputDir) return null;
+    const safe = assetName.replace(/^\/+/, "");
+    if (safe.includes("..") || safe.includes("/")) {
+      return null;
+    }
+    const filePath = path.join(this.outputDir, safe);
+    if (!fs.existsSync(filePath)) {
+      return null;
+    }
+    const data = await fsp.readFile(filePath);
+    let contentType = "application/octet-stream";
+    if (safe.endsWith(".m3u8")) {
+      contentType = "application/vnd.apple.mpegurl";
+    } else if (safe.endsWith(".ts")) {
+      contentType = "video/mp2t";
+    }
+    return { data, contentType };
+  }
+  // ============================================================================
+  // Private Methods
+  // ============================================================================
+  async pumpNativeToFfmpeg() {
+    if (!this.nativeStream || !this.playlistPath || !this.segmentPattern) {
+      return;
+    }
+    let startedFfmpeg = false;
+    let pendingParamSets = [];
+    const MAX_FRAMES_WAIT_FOR_KEYFRAME = 180;
+    const collectParamSets = (codec, annexB) => {
+      const nals = parseAnnexBNalUnits2(annexB);
+      for (const nal of nals) {
+        if (!nal || nal.length === 0) continue;
+        if (codec === "h264") {
+          const t = nal[0] & 31;
+          if (t === 7 || t === 8) {
+            pendingParamSets.push(
+              Buffer.concat([Buffer.from([0, 0, 0, 1]), nal])
+            );
+          }
+        } else {
+          const t = nal[0] >> 1 & 63;
+          if (t === 32 || t === 33 || t === 34) {
+            pendingParamSets.push(
+              Buffer.concat([Buffer.from([0, 0, 0, 1]), nal])
+            );
+          }
+        }
+      }
+      if (pendingParamSets.length > 12) {
+        pendingParamSets = pendingParamSets.slice(-12);
+      }
+    };
+    try {
+      for await (const frame of this.nativeStream) {
+        if (this.state !== "running") break;
+        if (frame.audio) continue;
+        if (!frame.data || frame.data.length === 0) continue;
+        if (!this.codec) {
+          const detected = detectVideoCodecFromNal(frame.data);
+          const fromMeta = frame.videoType === "H265" ? "h265" : "h264";
+          this.codec = detected ? detected.toLowerCase() : fromMeta;
+          this.log(
+            "info",
+            `HLS codec detected: meta=${fromMeta} detected=${detected} (using ${this.codec})`
+          );
+          this.emit("codec-detected", { codec: this.codec });
+        }
+        const annexB = this.codec === "h265" ? convertToAnnexB2(frame.data) : convertToAnnexB(frame.data);
+        this.framesReceived++;
+        const shouldLog = this.framesReceived <= 5 || this.framesReceived <= 60 && this.framesReceived % 10 === 0;
+        if (shouldLog) {
+          const nalTypes = getNalTypes(this.codec, annexB);
+          const hasIdr = isKeyframeAnnexB(this.codec, annexB);
+          const hasParams = hasParamSets(this.codec, annexB);
+          this.log(
+            "debug",
+            `HLS frame#${this.framesReceived}: bytes=${annexB.length} nalTypes=[${nalTypes.join(",")}] hasIDR=${hasIdr} hasParams=${hasParams}`
+          );
+        }
+        collectParamSets(this.codec, annexB);
+        const isKeyframe = isKeyframeAnnexB(this.codec, annexB);
+        if (!isKeyframe && !startedFfmpeg) {
+          if (this.framesReceived < MAX_FRAMES_WAIT_FOR_KEYFRAME) {
+            continue;
+          }
+          this.log(
+            "warn",
+            `No keyframe after ${this.framesReceived} frames, starting ffmpeg anyway`
+          );
+        }
+        if (!startedFfmpeg) {
+          this.log(
+            "info",
+            `Starting ffmpeg: codec=${this.codec} framesSeen=${this.framesReceived} isKeyframe=${isKeyframe} paramSets=${pendingParamSets.length}`
+          );
+          this.ffmpeg = this.spawnFfmpeg();
+          startedFfmpeg = true;
+          this.emit("ffmpeg-started");
+          try {
+            if (this.ffmpeg?.stdin && !this.ffmpeg.stdin.destroyed) {
+              for (const ps of pendingParamSets) {
+                this.ffmpeg.stdin.write(ps);
+              }
+            }
+          } catch {
+          }
+        }
+        if (!this.ffmpeg || !this.ffmpeg.stdin || this.ffmpeg.stdin.destroyed) {
+          this.log("warn", "ffmpeg stdin not available, stopping pump");
+          break;
+        }
+        try {
+          this.ffmpeg.stdin.write(annexB);
+          if (this.framesReceived % 100 === 0 || this.framesReceived <= 5 || this.framesReceived <= 50 && this.framesReceived % 10 === 0) {
+            this.log(
+              "debug",
+              `HLS fed frame #${this.framesReceived} to ffmpeg (${annexB.length} bytes)`
+            );
+          }
+        } catch (err) {
+          this.log("error", `Failed to write to ffmpeg: ${err}`);
+          break;
+        }
+      }
+    } catch (e) {
+      this.log("error", `HLS pump error: ${e}`);
+      this.lastError = String(e);
+      this.state = "error";
+      this.emit("error", e);
+    }
+  }
+  spawnFfmpeg() {
+    if (!this.playlistPath || !this.segmentPattern) {
+      throw new Error("Playlist path not set");
+    }
+    const codec = this.codec ?? "h264";
+    const args = [
+      "-hide_banner",
+      "-loglevel",
+      "warning",
+      "-fflags",
+      "+genpts",
+      "-use_wallclock_as_timestamps",
+      "1",
+      "-r",
+      "25",
+      "-f",
+      codec === "h265" ? "hevc" : "h264",
+      "-i",
+      "pipe:0"
+    ];
+    if (codec === "h265") {
+      args.push(
+        "-c:v",
+        "libx264",
+        "-preset",
+        "veryfast",
+        "-tune",
+        "zerolatency",
+        "-pix_fmt",
+        "yuv420p"
+      );
+    } else {
+      args.push("-c:v", "copy");
+    }
+    args.push(
+      "-f",
+      "hls",
+      "-hls_time",
+      String(this.segmentDuration),
+      "-hls_list_size",
+      String(this.playlistSize),
+      "-hls_flags",
+      "delete_segments+append_list+omit_endlist",
+      "-hls_segment_filename",
+      this.segmentPattern,
+      this.playlistPath
+    );
+    const p = spawn7(this.ffmpegPath, args, {
+      stdio: ["pipe", "ignore", "pipe"]
+    });
+    p.on("error", (err) => {
+      this.log("error", `ffmpeg spawn error: ${err}`);
+      this.emit("ffmpeg-error", err);
+    });
+    p.stderr?.on("data", (d) => {
+      const s = String(d ?? "").trim();
+      if (s) this.log("warn", `[ffmpeg] ${s}`);
+    });
+    p.on("exit", (code, signal) => {
+      this.log(
+        "warn",
+        `ffmpeg exited (code=${code ?? "?"} signal=${signal ?? "?"})`
+      );
+      this.emit("ffmpeg-exited", { code, signal });
+    });
+    return p;
+  }
+};
+
+// src/multifocal/compositeRtspServer.ts
+import { EventEmitter as EventEmitter7 } from "events";
+import { spawn as spawn8 } from "child_process";
 import * as net from "net";
-var CompositeRtspServer = class extends EventEmitter6 {
+var CompositeRtspServer = class extends EventEmitter7 {
   options;
   compositeStream = null;
   rtspServer = null;
@@ -5593,7 +6759,7 @@ var CompositeRtspServer = class extends EventEmitter6 {
     this.logger.log?.(
       `[CompositeRtspServer] Starting ffmpeg RTSP server: ${ffmpegArgs.join(" ")}`
     );
-    this.ffmpegProcess = spawn7("ffmpeg", ffmpegArgs, {
+    this.ffmpegProcess = spawn8("ffmpeg", ffmpegArgs, {
       stdio: ["pipe", "pipe", "pipe"]
     });
     this.ffmpegProcess.on("error", (error) => {
@@ -5805,6 +6971,7 @@ export {
   BaichuanClient,
   BaichuanEventEmitter,
   BaichuanFrameParser,
+  BaichuanHlsServer,
   BaichuanHttpStreamServer,
   BaichuanMjpegServer,
   BaichuanRtspServer,
@@ -5820,6 +6987,7 @@ export {
   DUAL_LENS_SINGLE_MOTION_MODELS,
   H264RtpDepacketizer,
   H265RtpDepacketizer,
+  HlsSessionManager,
   Intercom,
   MjpegTransformer,
   NVR_HUB_EXACT_TYPES,
@@ -5841,6 +7009,7 @@ export {
   buildBinaryExtensionXml,
   buildChannelExtensionXml,
   buildFloodlightManualXml,
+  buildHlsRedirectUrl,
   buildLoginXml,
   buildPreviewStopXml,
   buildPreviewStopXmlV11,
@@ -5879,6 +7048,7 @@ export {
   decideVideoclipTranscodeMode,
   decodeHeader,
   deriveAesKey,
+  detectIosClient,
   detectVideoCodecFromNal,
   discoverReolinkDevices,
   discoverViaHttpScan,