@apocaliss92/nodelink-js 0.1.7 → 0.1.9

package/dist/index.cjs

@@ -2468,13 +2468,31 @@ var init_BaichuanVideoStream = __esm({
               searchStart = bodyEnd + Buffer.from("</body>").length;
             dataToParse = rawCandidate.subarray(searchStart);
           }
+          let encryptLen;
+          if (frame.extension && frame.extension.length > 0) {
+            try {
+              const extDec = this.client.tryDecryptXml(
+                frame.extension,
+                frame.header.channelId,
+                enc
+              );
+              const encryptLenMatch = extDec.match(
+                /<encryptLen>(\d+)<\/encryptLen>/i
+              );
+              if (encryptLenMatch && encryptLenMatch[1]) {
+                encryptLen = parseInt(encryptLenMatch[1], 10);
+              }
+            } catch {
+            }
+          }
           const dataAfterXml = this.chooseDecryptedOrRawCandidate({
             raw: dataToParse,
             enc,
             channelId: frame.header.channelId,
             // Some NVR/Hub streams appear to include non-media bytes even when payloadOffset is present.
             // Allow a one-time resync at startup to avoid delaying the first keyframe.
-            allowResync: frame.payload.length === 0 || totalFramesReceived <= 10 && totalMediaPackets === 0
+            allowResync: frame.payload.length === 0 || totalFramesReceived <= 10 && totalMediaPackets === 0,
+            ...encryptLen !== void 0 ? { encryptLen } : {}
           });
           if (this.bcMediaCodec.getRemainingBuffer().length === 0 && dataAfterXml.length <= 600) {
             const s = _BaichuanVideoStream.scoreBcMediaLike(dataAfterXml);
@@ -2587,15 +2605,38 @@ var init_BaichuanVideoStream = __esm({
                 }
               }
             };
-            const prependParamSetsIfNeeded = (annexB, videoType) => {
+            const prependParamSetsIfNeeded = (annexB, videoType, isPframe = false) => {
               if (videoType === "H264") {
                 const nals = splitAnnexBToNalPayloads(annexB);
                 if (nals.length === 0) return annexB;
                 const types = nals.map((n) => (n[0] ?? 0) & 31);
-                if (types.includes(7) && types.includes(8)) return annexB;
                 const hasVcl = types.some(
                   (t) => t === 1 || t === 5 || t === 19 || t === 20
                 );
+                if (isPframe && !hasVcl) {
+                  if (dbg.traceNativeStream) {
+                    this.logger?.warn(
+                      `[BaichuanVideoStream] Dropping P-frame without VCL (only param sets): types=${types.join(",")}`
+                    );
+                  }
+                  return Buffer.alloc(0);
+                }
+                if (types.includes(7) && types.includes(8)) {
+                  let ppsIdFromSlice = null;
+                  for (const nal of nals) {
+                    const t = (nal[0] ?? 0) & 31;
+                    if (t === 1 || t === 5) {
+                      ppsIdFromSlice = parseSlicePpsIdFromNal(nal);
+                      break;
+                    }
+                  }
+                  if (ppsIdFromSlice != null && ppsIdFromSlice <= 255) {
+                    this.lastPrependedPpsId = ppsIdFromSlice;
+                  } else {
+                    this.lastPrependedPpsId = -1;
+                  }
+                  return annexB;
+                }
                 if (!hasVcl) return annexB;
                 let ppsId = null;
                 for (const nal of nals) {
@@ -2642,11 +2683,19 @@ var init_BaichuanVideoStream = __esm({
                 const nals = splitAnnexBToNalPayloads2(annexB);
                 if (nals.length === 0) return annexB;
                 const types = nals.map((n) => getH265NalType(n)).filter((t) => t !== null);
-                if (types.includes(32) && types.includes(33) && types.includes(34))
-                  return annexB;
                 const hasVcl = types.some(
                   (t) => t >= 0 && t <= 9 || t >= 16 && t <= 23
                 );
+                if (isPframe && !hasVcl) {
+                  if (dbg.traceNativeStream) {
+                    this.logger?.warn(
+                      `[BaichuanVideoStream] Dropping H.265 P-frame without VCL (only param sets): types=${types.join(",")}`
+                    );
+                  }
+                  return Buffer.alloc(0);
+                }
+                if (types.includes(32) && types.includes(33) && types.includes(34))
+                  return annexB;
                 if (!hasVcl) return annexB;
                 if (this.lastPrependedParamSetsH265) return annexB;
                 if (!this.lastVps || !this.lastSpsH265 || !this.lastPpsH265)
@@ -2828,7 +2877,7 @@ var init_BaichuanVideoStream = __esm({
               }
               for (const p of parts) {
                 maybeCacheParamSets(p, "Pframe", videoType);
-                const outP0 = prependParamSetsIfNeeded(p, videoType);
+                const outP0 = prependParamSetsIfNeeded(p, videoType, true);
                 if (outP0.length === 0) continue;
                 const outP = outP0;
                 dumpNalSummary(outP, "Pframe", media.microseconds);
@@ -2997,10 +3046,10 @@ function buildRtspPath(channel, stream) {
 }
 function buildRtspUrl(params) {
   const port = params.port ?? 554;
-  const path5 = buildRtspPath(params.channel, params.stream);
+  const path6 = buildRtspPath(params.channel, params.stream);
   const user = encodeURIComponent(params.username);
   const pass = encodeURIComponent(params.password);
-  return `rtsp://${user}:${pass}@${params.host}:${port}${path5}`;
+  return `rtsp://${user}:${pass}@${params.host}:${port}${path6}`;
 }
 var init_urls = __esm({
   "src/rtsp/urls.ts"() {
@@ -3162,7 +3211,7 @@ async function createDiagnosticsBundle(params) {
 }
 function sanitizeFfmpegError(error) {
   return error.replace(
-    /([a-z]+:\/\/)([^:@\/\s]+):([^@\/\s]+)@/gi,
+    /([a-z]+:\/\/)([^:@/\s]+):([^@/\s]+)@/gi,
     (match, protocol, username, password) => {
       return `${protocol}***:***@`;
     }
@@ -4542,8 +4591,8 @@ async function runMultifocalDiagnosticsConsecutively(params) {
     for (const app of rtmpApps) {
       for (const streamName of streams) {
         const streamType = streamName.includes("sub") || streamName === "sub" || streamName === "mobile" ? 1 : 0;
-        const path5 = `/${app}/channel${params.channel}_${streamName}.bcs`;
-        const u = new URL(`rtmp://${params.host}:1935${path5}`);
+        const path6 = `/${app}/channel${params.channel}_${streamName}.bcs`;
+        const u = new URL(`rtmp://${params.host}:1935${path6}`);
         u.searchParams.set("channel", params.channel.toString());
         u.searchParams.set("stream", streamType.toString());
         u.searchParams.set("user", params.username);
@@ -5453,17 +5502,20 @@ function parseRecordingFileName(fileName) {
   let widthRaw;
   let heightRaw;
   let hexValue = "";
+  let sizeHex;
   if (parts.length === 6) {
     startDate = parts[1] ?? "";
     startTime = parts[2] ?? "";
     endTime = parts[3] ?? "";
     hexValue = parts[4] ?? "";
+    sizeHex = parts[5];
   } else if (parts.length === 7) {
     startDate = parts[1] ?? "";
     startTime = parts[2] ?? "";
     endTime = parts[3] ?? "";
     animalTypeRaw = parts[4];
     hexValue = parts[5] ?? "";
+    sizeHex = parts[6];
   } else if (parts.length === 9) {
     devType = "hub";
     startDate = parts[1] ?? "";
@@ -5473,6 +5525,7 @@ function parseRecordingFileName(fileName) {
     widthRaw = parts[5];
     heightRaw = parts[6];
     hexValue = parts[7] ?? "";
+    sizeHex = parts[8];
   } else {
     return void 0;
   }
@@ -5503,6 +5556,12 @@ function parseRecordingFileName(fileName) {
   if (animalTypeRaw != null) parsed.animalTypeRaw = animalTypeRaw;
   if (widthRaw != null) parsed.widthRaw = widthRaw;
   if (heightRaw != null) parsed.heightRaw = heightRaw;
+  if (sizeHex && /^[0-9a-fA-F]+$/.test(sizeHex)) {
+    const sizeBytes = parseInt(sizeHex, 16);
+    if (Number.isFinite(sizeBytes) && sizeBytes > 0) {
+      parsed.sizeBytes = sizeBytes;
+    }
+  }
   return parsed;
 }
 var FLAGS_CAM_V2, FLAGS_HUB_V0, FLAGS_HUB_V1, FLAGS_HUB_V2, FLAGS_MAPPING;
@@ -6627,12 +6686,12 @@ var init_ReolinkCgiApi = __esm({
           "getVideoclipThumbnailJpeg",
           `Extracting thumbnail from VOD URL (FLV): ${vodUrl.substring(0, 100)}... (seek=${seekSeconds}s)`
         );
-        const { spawn: spawn10 } = await import("child_process");
+        const { spawn: spawn12 } = await import("child_process");
         return new Promise((resolve, reject) => {
           const chunks = [];
           let stderr = "";
           let timedOut = false;
-          const ffmpeg = spawn10(ffmpegPath, [
+          const ffmpeg = spawn12(ffmpegPath, [
             "-y",
             "-analyzeduration",
             "10000000",
@@ -7191,15 +7250,18 @@ var init_ReolinkCgiApi = __esm({
         if (detectionClasses.length === 0) {
           detectionClasses.push("motion");
         }
+        const sizeBytes = typeof vodFile.size === "string" ? parseInt(vodFile.size, 10) : vodFile.size;
         const result = {
           fileName: vodFile.name,
           id: vodFile.name,
-          sizeBytes: vodFile.size,
           startTime,
           endTime,
           recordType: vodFile.type,
           detectionClasses
         };
+        if (Number.isFinite(sizeBytes)) {
+          result.sizeBytes = sizeBytes;
+        }
         if (parsed) {
           result.parsedFileName = parsed;
         }
@@ -7315,9 +7377,12 @@ __export(index_exports, {
   BaichuanClient: () => BaichuanClient,
   BaichuanEventEmitter: () => BaichuanEventEmitter,
   BaichuanFrameParser: () => BaichuanFrameParser,
+  BaichuanHlsServer: () => BaichuanHlsServer,
   BaichuanHttpStreamServer: () => BaichuanHttpStreamServer,
+  BaichuanMjpegServer: () => BaichuanMjpegServer,
   BaichuanRtspServer: () => BaichuanRtspServer,
   BaichuanVideoStream: () => BaichuanVideoStream,
+  BaichuanWebRTCServer: () => BaichuanWebRTCServer,
   BcMediaAnnexBDecoder: () => BcMediaAnnexBDecoder,
   BcMediaCodec: () => BcMediaCodec,
   BcUdpStream: () => BcUdpStream,
@@ -7328,7 +7393,9 @@ __export(index_exports, {
   DUAL_LENS_SINGLE_MOTION_MODELS: () => DUAL_LENS_SINGLE_MOTION_MODELS,
   H264RtpDepacketizer: () => H264RtpDepacketizer,
   H265RtpDepacketizer: () => H265RtpDepacketizer,
+  HlsSessionManager: () => HlsSessionManager,
   Intercom: () => Intercom,
+  MjpegTransformer: () => MjpegTransformer,
   NVR_HUB_EXACT_TYPES: () => NVR_HUB_EXACT_TYPES,
   NVR_HUB_MODEL_PATTERNS: () => NVR_HUB_MODEL_PATTERNS,
   ReolinkBaichuanApi: () => ReolinkBaichuanApi,
@@ -7348,6 +7415,7 @@ __export(index_exports, {
   buildBinaryExtensionXml: () => buildBinaryExtensionXml,
   buildChannelExtensionXml: () => buildChannelExtensionXml,
   buildFloodlightManualXml: () => buildFloodlightManualXml,
+  buildHlsRedirectUrl: () => buildHlsRedirectUrl,
   buildLoginXml: () => buildLoginXml,
   buildPreviewStopXml: () => buildPreviewStopXml,
   buildPreviewStopXmlV11: () => buildPreviewStopXmlV11,
@@ -7375,6 +7443,7 @@ __export(index_exports, {
   createDebugGateLogger: () => createDebugGateLogger,
   createDiagnosticsBundle: () => createDiagnosticsBundle,
   createLogger: () => createLogger,
+  createMjpegBoundary: () => createMjpegBoundary,
   createNativeStream: () => createNativeStream,
   createNullLogger: () => createNullLogger,
   createReplayHttpServer: () => createReplayHttpServer,
@@ -7382,8 +7451,10 @@ __export(index_exports, {
   createRfc4571TcpServerForReplay: () => createRfc4571TcpServerForReplay,
   createRtspProxyServer: () => createRtspProxyServer,
   createTaggedLogger: () => createTaggedLogger,
+  decideVideoclipTranscodeMode: () => decideVideoclipTranscodeMode,
   decodeHeader: () => decodeHeader,
   deriveAesKey: () => deriveAesKey,
+  detectIosClient: () => detectIosClient,
   detectVideoCodecFromNal: () => detectVideoCodecFromNal,
   discoverReolinkDevices: () => discoverReolinkDevices,
   discoverViaHttpScan: () => discoverViaHttpScan,
@@ -7396,10 +7467,13 @@ __export(index_exports, {
   extractSpsFromAnnexB: () => extractSpsFromAnnexB,
   extractVpsFromAnnexB: () => extractVpsFromAnnexB,
   flattenAbilitiesForChannel: () => flattenAbilitiesForChannel,
+  formatMjpegFrame: () => formatMjpegFrame,
   getConstructedVideoStreamOptions: () => getConstructedVideoStreamOptions,
   getGlobalLogger: () => getGlobalLogger,
   getH265NalType: () => getH265NalType,
+  getMjpegContentType: () => getMjpegContentType,
   getVideoStream: () => getVideoStream,
+  getVideoclipClientInfo: () => getVideoclipClientInfo,
   getXmlText: () => getXmlText,
   hasH265StartCodes: () => hasStartCodes2,
   hasStartCodes: () => hasStartCodes,
@@ -7711,9 +7785,9 @@ function buildC2dS(params) {
   return buildP2pXml(`<C2D_S><to><port>${params.clientPort}</port></to></C2D_S>`);
 }
 function buildC2mQ(params) {
-  const os = params.os ?? "MAC";
+  const os2 = params.os ?? "MAC";
   return buildP2pXml(
-    `<C2M_Q><uid>${xmlEscape(params.uid)}</uid><p>${xmlEscape(os)}</p></C2M_Q>`
+    `<C2M_Q><uid>${xmlEscape(params.uid)}</uid><p>${xmlEscape(os2)}</p></C2M_Q>`
   );
 }
 function parseIpPortBlock(tag, body) {
@@ -7739,11 +7813,11 @@ function parseM2cQr(xml) {
   return { ...reg ? { reg } : {}, ...relay ? { relay } : {}, ...log ? { log } : {}, ...t ? { t } : {} };
 }
 function buildC2rC(params) {
-  const os = params.os ?? "MAC";
+  const os2 = params.os ?? "MAC";
   const debug = params.debug ?? false;
   const rev = params.revision != null ? `<r>${params.revision}</r>` : "";
   return buildP2pXml(
-    `<C2R_C><uid>${xmlEscape(params.uid)}</uid><cli><ip>${xmlEscape(params.cli.ip)}</ip><port>${params.cli.port}</port></cli><relay><ip>${xmlEscape(params.relay.ip)}</ip><port>${params.relay.port}</port></relay><cid>${params.cid}</cid><debug>${debug ? "true" : "false"}</debug><family>${params.family}</family><p>${xmlEscape(os)}</p>` + rev + `</C2R_C>`
+    `<C2R_C><uid>${xmlEscape(params.uid)}</uid><cli><ip>${xmlEscape(params.cli.ip)}</ip><port>${params.cli.port}</port></cli><relay><ip>${xmlEscape(params.relay.ip)}</ip><port>${params.relay.port}</port></relay><cid>${params.cid}</cid><debug>${debug ? "true" : "false"}</debug><family>${params.family}</family><p>${xmlEscape(os2)}</p>` + rev + `</C2R_C>`
   );
 }
 function parseR2cCr(xml) {
@@ -7787,9 +7861,9 @@ function buildC2rCfm(params) {
   );
 }
 function buildC2dC(params) {
-  const os = params.os ?? "MAC";
+  const os2 = params.os ?? "MAC";
   return buildP2pXml(
-    `<C2D_C><uid>${xmlEscape(params.uid)}</uid><cli><port>${params.clientPort}</port></cli><cid>${params.cid}</cid><mtu>${params.mtu}</mtu><debug>false</debug><p>${xmlEscape(os)}</p></C2D_C>`
+    `<C2D_C><uid>${xmlEscape(params.uid)}</uid><cli><port>${params.clientPort}</port></cli><cid>${params.cid}</cid><mtu>${params.mtu}</mtu><debug>false</debug><p>${xmlEscape(os2)}</p></C2D_C>`
   );
 }
 function buildC2dHb(params) {
@@ -12712,8 +12786,8 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.E
                 `[BaichuanRtspServer] Failed to start native stream for SDP priming: ${error}`
               );
             }
-            const { hasParamSets } = this.flow.getFmtp();
-            if (!hasParamSets) {
+            const { hasParamSets: hasParamSets2 } = this.flow.getFmtp();
+            if (!hasParamSets2) {
               const primingMs = this.api.client.getTransport() === "udp" ? 4e3 : 1500;
               try {
                 await Promise.race([
@@ -12725,12 +12799,12 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.E
             }
           }
           {
-            const { fmtp, hasParamSets } = this.flow.getFmtp();
+            const { fmtp, hasParamSets: hasParamSets2 } = this.flow.getFmtp();
             const fmtpPreview = fmtp.length > 160 ? `${fmtp.slice(0, 160)}...` : fmtp;
             this.logger.info(
-              `[BaichuanRtspServer] DESCRIBE SDP for ${clientId} path=${this.path} codec=${this.flow.sdpCodec} hasParamSets=${hasParamSets} fmtp=${fmtpPreview}`
+              `[BaichuanRtspServer] DESCRIBE SDP for ${clientId} path=${this.path} codec=${this.flow.sdpCodec} hasParamSets=${hasParamSets2} fmtp=${fmtpPreview}`
             );
-            if (!hasParamSets) {
+            if (!hasParamSets2) {
               this.rtspDebugLog(
                 `DESCRIBE responding without parameter sets yet (client=${clientId}, path=${this.path}, flow=${this.flow.key})`
               );
@@ -12906,8 +12980,8 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.E
     }
     sdp += `a=control:track0\r
 `;
-    const { fmtp, hasParamSets } = this.flow.getFmtp();
-    if (!hasParamSets) {
+    const { fmtp, hasParamSets: hasParamSets2 } = this.flow.getFmtp();
+    if (!hasParamSets2) {
       this.logger.warn(
         `[BaichuanRtspServer] SDP missing parameter sets for flow ${this.flow.key}`
       );
@@ -13563,8 +13637,8 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.E
             const normalizedVideoData = videoType === "H264" ? convertToAnnexB(frame.data) : convertToAnnexB2(frame.data);
             if (!resources?.seenFirstVideoKeyframe) {
               if (videoType === "H265") {
-                const { hasParamSets } = this.flow.getFmtp();
-                if (!hasParamSets) {
+                const { hasParamSets: hasParamSets2 } = this.flow.getFmtp();
+                if (!hasParamSets2) {
                   if (rtspDebug && !h265WaitParamSetsLogged) {
                     h265WaitParamSetsLogged = true;
                     rtspDebugLog(
@@ -13595,8 +13669,8 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.E
                 }
                 resources.seenFirstVideoKeyframe = true;
               } else {
-                const { hasParamSets } = this.flow.getFmtp();
-                if (!hasParamSets) {
+                const { hasParamSets: hasParamSets2 } = this.flow.getFmtp();
+                if (!hasParamSets2) {
                   if (rtspDebug && !h265WaitParamSetsLogged) {
                     h265WaitParamSetsLogged = true;
                     rtspDebugLog(
@@ -13756,8 +13830,8 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.E
           this.setFlowVideoType(frame.videoType, "native stream");
         }
         this.flow.extractParameterSets(frame.data);
-        const { hasParamSets } = this.flow.getFmtp();
-        if (hasParamSets) {
+        const { hasParamSets: hasParamSets2 } = this.flow.getFmtp();
+        if (hasParamSets2) {
           this.markFirstFrameReceived();
         }
       },
@@ -15051,10 +15125,15 @@ var parseRecordingFilesFromXml = (xml) => {
     if (startDt) item.startTime = startDt;
     if (endDt) item.endTime = endDt;
     const parsed = parseRecordingFileName(item.name ?? item.fileName);
-    if (parsed) {
-      item.parsedFileName = parsed;
-      if (!item.startTime) item.startTime = parsed.start;
-      if (!item.endTime) item.endTime = parsed.end;
+    const parsedFromPath = item.fileName !== item.name ? parseRecordingFileName(item.fileName) : void 0;
+    const bestParsed = parsedFromPath?.sizeBytes != null ? parsedFromPath : parsed;
+    if (bestParsed) {
+      item.parsedFileName = bestParsed;
+      if (!item.startTime) item.startTime = bestParsed.start;
+      if (!item.endTime) item.endTime = bestParsed.end;
+      if (item.sizeBytes == null && bestParsed.sizeBytes != null) {
+        item.sizeBytes = bestParsed.sizeBytes;
+      }
     }
     item.detectionClasses = buildDetectionClasses(parsed, item.recordType);
     out.push(item);
@@ -15081,6 +15160,9 @@ var parseRecordingFilesFromXml = (xml) => {
       item.parsedFileName = parsed;
       if (!item.startTime) item.startTime = parsed.start;
       if (!item.endTime) item.endTime = parsed.end;
+      if (item.sizeBytes == null && parsed.sizeBytes != null) {
+        item.sizeBytes = parsed.sizeBytes;
+      }
     }
     item.detectionClasses = buildDetectionClasses(parsed, item.recordType);
     out.push(item);
@@ -16395,6 +16477,10 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
    * Value: client, refCount, createdAt
    */
   dedicatedClients = /* @__PURE__ */ new Map();
+  /** Keep replay dedicated sockets warm briefly to reduce clip switch latency. */
+  // Keep replay sockets warm briefly for fast clip switches, but tear down quickly
+  // when clients stop requesting HLS segments (avoids looking like a stuck session).
+  static REPLAY_DEDICATED_KEEPALIVE_MS = 1e4;
   /**
    * Get a summary of currently active dedicated sessions.
    * Useful for debugging/logging to see how many sockets are open.
@@ -16504,22 +16590,35 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
    * Process the replay queue - executes operations one at a time.
    */
   async processReplayQueue() {
-    if (this.replayQueueProcessing) return;
+    if (this.replayQueueProcessing) {
+      this.logger?.debug?.(
+        `[ReplayQueue] Already processing, queue length: ${this.replayQueue.length}`
+      );
+      return;
+    }
     this.replayQueueProcessing = true;
+    this.logger?.debug?.(
+      `[ReplayQueue] Starting queue processing, items: ${this.replayQueue.length}`
+    );
     while (this.replayQueue.length > 0) {
       const item = this.replayQueue.shift();
       if (item) {
         const timeSinceLastReplay = Date.now() - this.lastReplayEndTime;
         if (timeSinceLastReplay < this.REPLAY_COOLDOWN_MS) {
-          await new Promise(
-            (r) => setTimeout(r, this.REPLAY_COOLDOWN_MS - timeSinceLastReplay)
-          );
+          const waitTime = this.REPLAY_COOLDOWN_MS - timeSinceLastReplay;
+          this.logger?.debug?.(`[ReplayQueue] Waiting ${waitTime}ms cooldown`);
+          await new Promise((r) => setTimeout(r, waitTime));
         }
+        this.logger?.debug?.(
+          `[ReplayQueue] Executing item, remaining: ${this.replayQueue.length}`
+        );
         await item.execute();
         this.lastReplayEndTime = Date.now();
+        this.logger?.debug?.(`[ReplayQueue] Item completed`);
       }
     }
     this.replayQueueProcessing = false;
+    this.logger?.debug?.(`[ReplayQueue] Queue processing complete`);
   }
   /**
    * Enqueue a replay operation with optional de-duplication.
@@ -16582,14 +16681,35 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
     this.replayQueue.push({
       execute: () => {
         return new Promise((releaseSlot) => {
+          let released = false;
+          const safeRelease = () => {
+            if (released) return;
+            released = true;
+            releaseSlot();
+          };
+          const safetyTimeout = setTimeout(
+            () => {
+              if (!released) {
+                this.logger?.warn?.(
+                  "[ReplayQueue] Safety timeout: releasing queue slot after 10 minutes"
+                );
+                safeRelease();
+              }
+            },
+            10 * 60 * 1e3
+          );
           setup().then((result) => {
             resolvePromise({
               result,
-              release: () => releaseSlot()
+              release: () => {
+                clearTimeout(safetyTimeout);
+                safeRelease();
+              }
             });
           }).catch((e) => {
+            clearTimeout(safetyTimeout);
             rejectPromise(e);
-            releaseSlot();
+            safeRelease();
           });
         });
       }
@@ -16659,30 +16779,68 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
    * immediately and create a new one. This ensures clean state for each clip.
    */
   async acquireDedicatedClient(sessionKey, logger) {
+    const log = logger ?? this.logger;
+    const isReplayKey = sessionKey.startsWith("replay:");
     const existing = this.dedicatedClients.get(sessionKey);
     if (existing) {
-      logger?.debug?.(
-        `[DedicatedClient] Closing existing client for ${sessionKey} (new stream requested)`
+      if (existing.idleCloseTimer) {
+        clearTimeout(existing.idleCloseTimer);
+        existing.idleCloseTimer = void 0;
+      }
+      if (existing.refCount === 0) {
+        existing.refCount = 1;
+        existing.lastUsedAt = Date.now();
+        log?.debug?.(
+          `[DedicatedClient] Reusing existing dedicated socket for sessionKey=${sessionKey}`
+        );
+        try {
+          if (!existing.client.loggedIn) {
+            await existing.client.login();
+          }
+        } catch {
+        }
+        if (existing.client.loggedIn) {
+          return {
+            client: existing.client,
+            release: () => this.releaseDedicatedClient(sessionKey, logger)
+          };
+        }
+      }
+      log?.log?.(
+        `[DedicatedClient] Closing existing socket for sessionKey=${sessionKey} (preempting active session)`
       );
       this.dedicatedClients.delete(sessionKey);
-      existing.client.close({ reason: "new stream for same device" }).catch((e) => {
-        logger?.debug?.(`[DedicatedClient] Error closing old socket: ${e}`);
-      });
+      try {
+        await existing.client.close({ reason: "preempted by new session" });
+        log?.log?.(
+          `[DedicatedClient] Old socket closed successfully for sessionKey=${sessionKey}`
+        );
+      } catch (e) {
+        log?.warn?.(
+          `[DedicatedClient] Error closing old socket for sessionKey=${sessionKey}: ${e}`
+        );
+      }
     }
-    logger?.debug?.(`[DedicatedClient] Creating new client for ${sessionKey}`);
+    log?.log?.(
+      `[DedicatedClient] Opening new dedicated socket for sessionKey=${sessionKey}`
+    );
     const dedicatedClient = new BaichuanClient({
       host: this.host,
       username: this.username,
       password: this.password,
-      logger: logger ?? this.logger,
+      logger: log,
       debugOptions: this.client.getDebugConfig?.()
     });
     await dedicatedClient.login();
+    log?.log?.(
+      `[DedicatedClient] Dedicated socket logged in for sessionKey=${sessionKey}`
+    );
     this.dedicatedClients.set(sessionKey, {
       client: dedicatedClient,
       refCount: 1,
-      // Keep for compatibility, but not used for reuse logic
-      createdAt: Date.now()
+      createdAt: Date.now(),
+      lastUsedAt: Date.now(),
+      idleCloseTimer: void 0
     });
     return {
       client: dedicatedClient,
@@ -16694,15 +16852,81 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
    * This ensures clean teardown at the end of each clip.
    */
   async releaseDedicatedClient(sessionKey, logger) {
+    const log = logger ?? this.logger;
     const entry = this.dedicatedClients.get(sessionKey);
     if (!entry) return;
+    entry.refCount = Math.max(0, entry.refCount - 1);
+    entry.lastUsedAt = Date.now();
+    if (entry.refCount > 0) return;
+    const isReplayKey = sessionKey.startsWith("replay:");
+    const allowReplayKeepAlive = /^replay:[^:]+$/.test(sessionKey);
+    if (isReplayKey && allowReplayKeepAlive) {
+      if (entry.idleCloseTimer) return;
+      entry.idleCloseTimer = setTimeout(async () => {
+        const current = this.dedicatedClients.get(sessionKey);
+        if (!current) return;
+        if (current.refCount > 0) return;
+        this.dedicatedClients.delete(sessionKey);
+        log?.debug?.(
+          `[DedicatedClient] Closing idle replay socket for sessionKey=${sessionKey} (keepalive expired)`
+        );
+        try {
+          await current.client.close({
+            reason: "replay idle keepalive expired"
+          });
+        } catch {
+        }
+      }, _ReolinkBaichuanApi.REPLAY_DEDICATED_KEEPALIVE_MS);
+      return;
+    }
     this.dedicatedClients.delete(sessionKey);
-    logger?.debug?.(`[DedicatedClient] Releasing and closing ${sessionKey}`);
+    log?.log?.(
+      `[DedicatedClient] Closing socket for sessionKey=${sessionKey} (session ended)`
+    );
     try {
       await entry.client.close({ reason: "dedicated session ended" });
+      log?.log?.(
+        `[DedicatedClient] Socket closed successfully for sessionKey=${sessionKey}`
+      );
+    } catch (e) {
+      log?.warn?.(
+        `[DedicatedClient] Error closing socket for sessionKey=${sessionKey}: ${e}`
+      );
+    }
+  }
+  /**
+   * Force-close a dedicated client if it exists.
+   * This is called BEFORE entering the queue to immediately terminate any existing stream
+   * for the same sessionKey. The existing stream will receive an error, release its queue slot,
+   * and the new request can then proceed.
+   *
+   * @param sessionKey - The session key to force-close (e.g., `replay:${deviceId}`)
+   * @param logger - Optional logger
+   * @returns true if a client was closed, false if no client existed
+   */
+  async forceCloseDedicatedClient(sessionKey, logger) {
+    const log = logger ?? this.logger;
+    const entry = this.dedicatedClients.get(sessionKey);
+    if (!entry) return false;
+    if (entry.idleCloseTimer) {
+      clearTimeout(entry.idleCloseTimer);
+      entry.idleCloseTimer = void 0;
+    }
+    log?.log?.(
+      `[DedicatedClient] Force-closing existing socket for sessionKey=${sessionKey} (new request preempting)`
+    );
+    this.dedicatedClients.delete(sessionKey);
+    try {
+      await entry.client.close({ reason: "preempted by new request" });
+      log?.log?.(
+        `[DedicatedClient] Force-close complete for sessionKey=${sessionKey}`
+      );
     } catch (e) {
-      logger?.debug?.(`[DedicatedClient] Error closing socket: ${e}`);
+      log?.warn?.(
+        `[DedicatedClient] Error during force-close for sessionKey=${sessionKey}: ${e}`
+      );
     }
+    return true;
   }
   /**
    * Create a dedicated Baichuan client session for streaming.
@@ -16739,6 +16963,9 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
     await Promise.allSettled(
       entries.map(async ([key, entry]) => {
         try {
+          if (entry.idleCloseTimer) {
+            clearTimeout(entry.idleCloseTimer);
+          }
           this.logger?.debug?.(`[DedicatedClient] Cleanup: closing ${key}`);
           await entry.client.close({ reason: "API cleanup" });
         } catch {
@@ -18594,7 +18821,8 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
             channel,
             payloadXml: stopXml,
             messageClass: BC_CLASS_MODERN_24,
-            timeoutMs: 1e4,
+            timeoutMs: 2e3,
+            // Short timeout - if socket is closed, fail fast
             internal: true
           });
         } catch {
@@ -18730,7 +18958,8 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
             channel,
             payloadXml: stopXml,
             messageClass: BC_CLASS_MODERN_24,
-            timeoutMs: 1e4,
+            timeoutMs: 2e3,
+            // Short timeout - if socket is closed, fail fast
             internal: true
           });
         } catch {
@@ -19777,11 +20006,20 @@ ${stderr}`)
     }
   }
   async downloadRecording(params) {
+    this.logger?.debug?.(
+      `[downloadRecording] Queuing download for: ${params.fileName}, channel=${params.channel}`
+    );
     return this.enqueueReplayOperation(async () => {
+      this.logger?.debug?.(
+        `[downloadRecording] Starting download for: ${params.fileName}`
+      );
       await this.client.login();
       const channel = this.normalizeChannel(params.channel);
       const uid = await this.ensureUidForRecordings(channel, params.uid);
       const fileName = params.fileName;
+      this.logger?.debug?.(
+        `[downloadRecording] Trying fileInfoListReplayBinaryDownload for: ${fileName}`
+      );
       let replayErr;
       try {
         return await this.fileInfoListReplayBinaryDownload({
@@ -19792,7 +20030,13 @@ ${stderr}`)
         });
       } catch (e) {
         replayErr = e;
+        this.logger?.debug?.(
+          `[downloadRecording] fileInfoListReplayBinaryDownload failed: ${e instanceof Error ? e.message : String(e)}`
+        );
       }
+      this.logger?.debug?.(
+        `[downloadRecording] Trying fileInfoListDownload for: ${fileName}`
+      );
       let downloadErr;
       try {
         return await this.fileInfoListDownload({
@@ -19803,7 +20047,13 @@ ${stderr}`)
         });
       } catch (e) {
         downloadErr = e;
+        this.logger?.debug?.(
+          `[downloadRecording] fileInfoListDownload failed: ${e instanceof Error ? e.message : String(e)}`
+        );
       }
+      this.logger?.debug?.(
+        `[downloadRecording] Trying fileInfoListPagedDownload for: ${fileName}`
+      );
       try {
         const result = await this.fileInfoListPagedDownload({
           channel,
@@ -19815,6 +20065,9 @@ ${stderr}`)
           return result;
         }
       } catch (e) {
+        this.logger?.debug?.(
+          `[downloadRecording] fileInfoListPagedDownload failed: ${e instanceof Error ? e.message : String(e)}`
+        );
       }
       const replayMsg = replayErr instanceof Error ? replayErr.message : replayErr != null ? String(replayErr) : "";
       const dlMsg = downloadErr instanceof Error ? downloadErr.message : downloadErr != null ? String(downloadErr) : "";
@@ -20110,7 +20363,7 @@ ${stderr}`)
    * Convert a raw video keyframe to JPEG using ffmpeg.
    */
   async convertFrameToJpeg(params) {
-    const { spawn: spawn10 } = await import("child_process");
+    const { spawn: spawn12 } = await import("child_process");
     const ffmpeg = params.ffmpegPath ?? "ffmpeg";
     const inputFormat = params.videoCodec === "H265" ? "hevc" : "h264";
     return new Promise((resolve, reject) => {
@@ -20132,7 +20385,7 @@ ${stderr}`)
         "2",
         "pipe:1"
       ];
-      const proc = spawn10(ffmpeg, args, {
+      const proc = spawn12(ffmpeg, args, {
         stdio: ["pipe", "pipe", "pipe"]
       });
       const chunks = [];
@@ -20275,26 +20528,26 @@ ${stderr}`)
    * Internal helper to mux video+audio into MP4 using ffmpeg.
    */
   async muxToMp4(params) {
-    const { spawn: spawn10 } = await import("child_process");
+    const { spawn: spawn12 } = await import("child_process");
     const { randomUUID: randomUUID2 } = await import("crypto");
-    const fs5 = await import("fs/promises");
-    const os = await import("os");
-    const path5 = await import("path");
+    const fs6 = await import("fs/promises");
+    const os2 = await import("os");
+    const path6 = await import("path");
     const ffmpeg = params.ffmpegPath ?? "ffmpeg";
-    const tmpDir = os.tmpdir();
+    const tmpDir = os2.tmpdir();
     const id = randomUUID2();
     const videoFormat = params.videoCodec === "H265" ? "hevc" : "h264";
-    const videoPath = path5.join(tmpDir, `reolink-${id}.${videoFormat}`);
-    const outputPath = path5.join(tmpDir, `reolink-${id}.mp4`);
+    const videoPath = path6.join(tmpDir, `reolink-${id}.${videoFormat}`);
+    const outputPath = path6.join(tmpDir, `reolink-${id}.mp4`);
     let audioPath = null;
     if (params.audioData && params.audioData.length > 0 && params.audioCodec) {
       const audioExt = params.audioCodec === "Aac" ? "aac" : "raw";
-      audioPath = path5.join(tmpDir, `reolink-${id}.${audioExt}`);
+      audioPath = path6.join(tmpDir, `reolink-${id}.${audioExt}`);
     }
     try {
-      await fs5.writeFile(videoPath, params.videoData);
+      await fs6.writeFile(videoPath, params.videoData);
       if (audioPath && params.audioData) {
-        await fs5.writeFile(audioPath, params.audioData);
+        await fs6.writeFile(audioPath, params.audioData);
       }
       const args = ["-hide_banner", "-loglevel", "error", "-y"];
       if (params.fps > 0) {
@@ -20327,7 +20580,7 @@ ${stderr}`)
         outputPath
       );
       await new Promise((resolve, reject) => {
-        const p = spawn10(ffmpeg, args, { stdio: ["ignore", "ignore", "pipe"] });
+        const p = spawn12(ffmpeg, args, { stdio: ["ignore", "ignore", "pipe"] });
         let stderr = "";
         p.stderr.on("data", (d) => {
           stderr += d.toString();
@@ -20347,13 +20600,13 @@ ${stderr}`)
           }
         });
       });
-      return await fs5.readFile(outputPath);
+      return await fs6.readFile(outputPath);
     } finally {
-      await fs5.unlink(videoPath).catch(() => {
+      await fs6.unlink(videoPath).catch(() => {
       });
-      if (audioPath) await fs5.unlink(audioPath).catch(() => {
+      if (audioPath) await fs6.unlink(audioPath).catch(() => {
       });
-      await fs5.unlink(outputPath).catch(() => {
+      await fs6.unlink(outputPath).catch(() => {
       });
     }
   }
@@ -21887,11 +22140,13 @@ ${stderr}`)
    * @param settings - Floodlight settings to apply
    *
    * @example
+   * ```typescript
    * await api.setFloodlightSettings(0, {
    *   duration: 300, // 5 minutes
    *   detectType: 'people,vehicle',
    *   brightness: 80,
    * });
+   * ```
    */
   async setFloodlightSettings(channel, settings) {
     const ch = this.normalizeChannel(channel);
@@ -24033,11 +24288,13 @@ ${scheduleItems}
    */
   async createRecordingReplayMp4Stream(params) {
     const logger = params.logger ?? this.logger;
+    const useMpegTsMuxer = params.useMpegTsMuxer ?? true;
     const parsed = parseRecordingFileName(params.fileName);
     const durationMs = parsed?.durationMs ?? 3e5;
+    const fps = parsed?.framerate && parsed.framerate > 0 ? parsed.framerate : 15;
     const seconds = Math.ceil(durationMs / 1e3 * 1.1);
     logger?.debug?.(
-      `[createRecordingReplayMp4Stream] Starting: channel=${params.channel}, fileName=${params.fileName}, durationMs=${durationMs}, timeoutSec=${seconds}, deviceId=${params.deviceId ?? "auto"}`
+      `[createRecordingReplayMp4Stream] Starting: channel=${params.channel}, fileName=${params.fileName}, durationMs=${durationMs}, fps=${fps}, timeoutSec=${seconds}, deviceId=${params.deviceId ?? "auto"}, useMpegTsMuxer=${useMpegTsMuxer}`
     );
     const startParams = {
       channel: params.channel,
@@ -24046,39 +24303,84 @@ ${scheduleItems}
       ...params.isNvr != null ? { isNvr: params.isNvr } : {},
       ...params.deviceId != null ? { deviceId: params.deviceId } : {}
     };
-    const { result: replayResult, release: releaseQueueSlot } = await this.enqueueStreamingReplayOperation(
-      () => this.startRecordingReplayStream(startParams)
-    );
+    const { result: replayResult, release: releaseQueueSlot } = await this.enqueueStreamingReplayOperation(async () => {
+      try {
+        return await this.startRecordingReplayStream(startParams);
+      } catch (e) {
+        if (!params.deviceId) throw e;
+        const sessionKey = `replay:${params.deviceId}`;
+        logger?.debug?.(
+          `[createRecordingReplayMp4Stream] startRecordingReplayStream failed; force-closing dedicated client and retrying once`
+        );
+        await this.forceCloseDedicatedClient(sessionKey, logger);
+        return await this.startRecordingReplayStream(startParams);
+      }
+    });
     const { stream, stop: stopReplay } = replayResult;
     const input = new import_node_stream.PassThrough();
     const output = new import_node_stream.PassThrough();
+    const H264_AUD = Buffer.from([0, 0, 0, 1, 9, 240]);
     let tsMuxer = null;
     let ff = null;
     let ended = false;
     let frameCount = 0;
     const startFfmpeg = (videoType) => {
       if (ff) return;
+      const needsTranscode = videoType === "H265" && params.transcodeH265ToH264 === true;
       logger?.debug?.(
-        `[createRecordingReplayMp4Stream] Starting ffmpeg with videoType=${videoType}`
+        `[createRecordingReplayMp4Stream] Starting ffmpeg with videoType=${videoType}, transcode=${needsTranscode}, useMpegTsMuxer=${useMpegTsMuxer}, fps=${fps}`
       );
-      MpegTsMuxer.resetCounters();
-      tsMuxer = new MpegTsMuxer({ videoType });
-      const args = [
-        "-hide_banner",
-        "-loglevel",
-        "error",
-        "-f",
-        "mpegts",
-        "-i",
-        "pipe:0",
-        "-c",
-        "copy",
-        "-movflags",
-        "frag_keyframe+empty_moov",
-        "-f",
-        "mp4",
-        "pipe:1"
-      ];
+      let args;
+      if (useMpegTsMuxer) {
+        MpegTsMuxer.resetCounters();
+        tsMuxer = new MpegTsMuxer({ videoType });
+        args = [
+          "-hide_banner",
+          "-loglevel",
+          "error",
+          "-f",
+          "mpegts",
+          "-i",
+          "pipe:0",
+          // Video codec: transcode H.265→H.264 if requested, otherwise copy
+          ...needsTranscode ? ["-c:v", "libx264", "-preset", "ultrafast", "-crf", "23"] : ["-c", "copy"],
+          // frag_keyframe: create new fragment at each keyframe
+          // empty_moov: write ftyp/moov immediately (required for streaming)
+          // default_base_moof: required for iOS Media Source Extensions
+          // negative_cts_offsets: fixes some iOS playback issues
+          "-movflags",
+          "frag_keyframe+empty_moov+default_base_moof+negative_cts_offsets",
+          "-f",
+          "mp4",
+          "pipe:1"
+        ];
+      } else {
+        const inputFormat = videoType === "H265" ? "hevc" : "h264";
+        args = [
+          "-hide_banner",
+          "-loglevel",
+          "error",
+          "-fflags",
+          "+genpts",
+          "-r",
+          String(fps),
+          "-f",
+          inputFormat,
+          "-i",
+          "pipe:0",
+          // Video codec: transcode H.265→H.264 if requested, otherwise copy
+          ...needsTranscode ? ["-c:v", "libx264", "-preset", "ultrafast", "-crf", "23"] : ["-c", "copy"],
+          // frag_keyframe: create new fragment at each keyframe
+          // empty_moov: write ftyp/moov immediately (required for streaming)
+          // default_base_moof: required for iOS Media Source Extensions
+          // negative_cts_offsets: fixes some iOS playback issues
+          "-movflags",
+          "frag_keyframe+empty_moov+default_base_moof+negative_cts_offsets",
+          "-f",
+          "mp4",
+          "pipe:1"
+        ];
+      }
       ff = (0, import_node_child_process3.spawn)("ffmpeg", args, { stdio: ["pipe", "pipe", "pipe"] });
       if (!ff.stdin || !ff.stdout || !ff.stderr) {
         throw new Error("ffmpeg stdio streams not available");
@@ -24116,17 +24418,19 @@ ${scheduleItems}
     const stopAll = async () => {
       if (ended) return;
       ended = true;
+      releaseQueueSlot();
       logger?.debug?.(
         `[createRecordingReplayMp4Stream] Stopping stream, frames=${frameCount}`
       );
-      try {
-        await stopReplay();
-      } catch {
-      }
-      try {
-        await stream.stop();
-      } catch {
-      }
+      const cleanupPromises = [];
+      cleanupPromises.push(
+        stopReplay().catch(() => {
+        })
+      );
+      cleanupPromises.push(
+        stream.stop().catch(() => {
+        })
+      );
       try {
         input.end();
       } catch {
@@ -24139,7 +24443,11 @@ ${scheduleItems}
         output.end();
       } catch {
       }
-      releaseQueueSlot();
+      await Promise.race([
+        Promise.all(cleanupPromises),
+        new Promise((resolve) => setTimeout(resolve, 2e3))
+        // Max 2s for cleanup
+      ]);
     };
     const timer = setTimeout(
       () => {
@@ -24161,15 +24469,25 @@ ${scheduleItems}
       output.destroy(e);
       void stopAll();
     });
+    stream.on("close", () => {
+      logger?.debug?.(
+        `[createRecordingReplayMp4Stream] Stream closed, frames=${frameCount}`
+      );
+      clearTimeout(timer);
+      void stopAll();
+    });
     stream.on(
       "videoAccessUnit",
       ({ data, videoType, isKeyframe, microseconds }) => {
         if (ended) return;
         startFfmpeg(videoType);
         frameCount++;
-        if (tsMuxer) {
+        if (useMpegTsMuxer && tsMuxer) {
           const tsData = tsMuxer.mux(data, microseconds, isKeyframe);
           input.write(tsData);
+        } else {
+          if (videoType === "H264") input.write(H264_AUD);
+          input.write(data);
         }
       }
     );
@@ -24208,19 +24526,53 @@ ${scheduleItems}
    */
   async createRecordingDownloadMp4Stream(params) {
     const timeoutMs = params.timeoutMs ?? 12e4;
-    const parsed = parseRecordingFileName(params.fileName);
-    const fps = parsed?.framerate && parsed.framerate > 0 ? parsed.framerate : 15;
     const channel = this.normalizeChannel(params.channel);
     const uid = await this.ensureUidForRecordings(channel);
-    const { annexB, videoType } = await this.downloadRecordingDemuxed({
+    const raw = await this.downloadRecording({
       channel,
       uid,
       fileName: params.fileName,
       timeoutMs
     });
-    if (annexB.length === 0) {
+    if (raw.length === 0) {
       throw new Error("Downloaded recording is empty");
     }
+    const videoFrames = [];
+    let videoType = null;
+    const decoder = new BcMediaAnnexBDecoder({
+      strict: false,
+      logger: this.logger,
+      onVideoAccessUnit: ({ annexB: annexB2, microseconds }) => {
+        videoFrames.push({ annexB: annexB2, microseconds });
+      }
+    });
+    decoder.push(raw);
+    const stats = decoder.getStats();
+    videoType = stats.videoType;
+    if (videoFrames.length === 0) {
+      throw new Error("Downloaded recording has no video frames");
+    }
+    let fps;
+    if (videoFrames.length >= 2) {
+      const firstTs = videoFrames[0].microseconds;
+      const lastTs = videoFrames[videoFrames.length - 1].microseconds;
+      const durationUs = lastTs - firstTs;
+      if (durationUs > 0) {
+        const durationSeconds = durationUs / 1e6;
+        fps = (videoFrames.length - 1) / durationSeconds;
+      } else {
+        const infoFps = stats.infos[0]?.fps;
+        fps = infoFps && infoFps > 0 ? infoFps : 15;
+      }
+    } else {
+      const infoFps = stats.infos[0]?.fps;
+      fps = infoFps && infoFps > 0 ? infoFps : 15;
+    }
+    if (fps > 14 && fps < 16) fps = 15;
+    else if (fps > 23 && fps < 26) fps = 25;
+    else if (fps > 29 && fps < 31) fps = 30;
+    else fps = Math.round(fps * 100) / 100;
+    const annexB = Buffer.concat(videoFrames.map((f) => f.annexB));
     const input = new import_node_stream.PassThrough();
     const output = new import_node_stream.PassThrough();
     let ff = null;
@@ -24292,48 +24644,380 @@ ${scheduleItems}
       stop: stopAll
     };
   }
-  // ============================================================
-  // STANDALONE CAMERA METHODS
-  // ============================================================
-  // These methods are specifically designed for standalone cameras
-  // (non-NVR) connected via TCP. They provide a simplified interface
-  // for common operations like listing recordings, streaming playback,
-  // downloading clips, and getting thumbnails.
-  // ============================================================
   /**
-   * List recordings from a standalone camera.
+   * Create an HLS (HTTP Live Streaming) session for a recording.
    *
-   * This method is optimized for standalone cameras (non-NVR) and uses
-   * the native Baichuan protocol to list recorded files.
+   * This method creates HLS segments on-the-fly from a recording replay stream.
+   * HLS is required for iOS devices (Safari, Home app) which don't support
+   * fragmented MP4 streaming well and require Range request support.
+   *
+   * The session writes HLS segments (.ts files) and playlist (.m3u8) to a
+   * temporary directory. You must serve these files via HTTP to the client.
    *
    * @example
    * ```ts
-   * const api = new ReolinkBaichuanApi({ host: '192.168.1.100', ... });
-   * await api.login();
+   * const session = await api.createRecordingReplayHlsSession({
+   *   channel: 0,
+   *   fileName: "/mnt/sda/Mp4Record/2026-01-25/RecS03.mp4",
+   * });
    *
-   * const recordings = await api.standaloneListRecordings({
-   *   start: new Date('2024-01-20T00:00:00'),
-   *   end: new Date('2024-01-21T23:59:59'),
+   * // Serve playlist
+   * app.get('/clip.m3u8', (req, res) => {
+   *   res.type('application/vnd.apple.mpegurl');
+   *   res.send(session.getPlaylist());
    * });
    *
-   * for (const file of recordings) {
-   *   console.log(file.fileName, file.startTime, file.endTime);
-   * }
+   * // Serve segments
+   * app.get('/segment/:name', (req, res) => {
+   *   const data = session.getSegment(req.params.name);
+   *   if (data) {
+   *     res.type('video/mp2t');
+   *     res.send(data);
+   *   } else {
+   *     res.status(404).end();
+   *   }
+   * });
+   *
+   * // Cleanup when done
+   * await session.stop();
    * ```
    */
-  async standaloneListRecordings(params) {
-    const channel = 0;
-    const streamType = params.streamType === "mainStream" ? "mainStream" : "subStream";
-    const timeoutMs = params.timeoutMs ?? 15e3;
-    return await this.getVideoclips({
-      channel,
-      start: params.start,
-      end: params.end,
-      streamType,
-      timeoutMs
-    });
-  }
-  /**
+  async createRecordingReplayHlsSession(params) {
+    const logger = params.logger ?? this.logger;
+    const hlsSegmentDuration = params.hlsSegmentDuration ?? 4;
+    const os2 = await import("os");
+    const path6 = await import("path");
+    const fs6 = await import("fs/promises");
+    const crypto3 = await import("crypto");
+    const tempDir = path6.join(
+      os2.tmpdir(),
+      `reolink-hls-${crypto3.randomBytes(8).toString("hex")}`
+    );
+    await fs6.mkdir(tempDir, { recursive: true });
+    const playlistPath = path6.join(tempDir, "playlist.m3u8");
+    const segmentPattern = path6.join(tempDir, "segment_%03d.ts");
+    const parsed = parseRecordingFileName(params.fileName);
+    const durationMs = parsed?.durationMs ?? 3e5;
+    const fps = parsed?.framerate && parsed.framerate > 0 ? parsed.framerate : 15;
+    const seconds = Math.ceil(durationMs / 1e3 * 1.1);
+    logger?.debug?.(
+      `[createRecordingReplayHlsSession] Starting: channel=${params.channel}, fileName=${params.fileName}, durationMs=${durationMs}, hlsSegmentDuration=${hlsSegmentDuration}`
+    );
+    const startParams = {
+      channel: params.channel,
+      fileName: params.fileName,
+      logger,
+      ...params.isNvr != null ? { isNvr: params.isNvr } : {},
+      ...params.deviceId != null ? { deviceId: params.deviceId } : {}
+    };
+    const { result: replayResult, release: releaseQueueSlot } = await this.enqueueStreamingReplayOperation(async () => {
+      try {
+        return await this.startRecordingReplayStream(startParams);
+      } catch (e) {
+        if (!params.deviceId) throw e;
+        const sessionKey = `replay:${params.deviceId}`;
+        logger?.debug?.(
+          `[createRecordingReplayHlsSession] startRecordingReplayStream failed; force-closing dedicated client and retrying once`
+        );
+        await this.forceCloseDedicatedClient(sessionKey, logger);
+        return await this.startRecordingReplayStream(startParams);
+      }
+    });
+    const { stream, stop: stopReplay } = replayResult;
+    const input = new import_node_stream.PassThrough();
+    const H264_AUD = Buffer.from([0, 0, 0, 1, 9, 240]);
+    let tsMuxer = null;
+    let ff = null;
+    let ended = false;
+    let frameCount = 0;
+    let readyResolve = null;
+    let segmentWatcher = null;
+    const readyPromise = new Promise((resolve) => {
+      readyResolve = resolve;
+    });
+    const segments = /* @__PURE__ */ new Map();
+    const startSegmentWatcher = () => {
+      if (segmentWatcher || !readyResolve) return;
+      const firstSegmentPath = path6.join(tempDir, "segment_000.ts");
+      let checkCount = 0;
+      const maxChecks = Math.ceil((hlsSegmentDuration + 2) * 10);
+      segmentWatcher = setInterval(async () => {
+        checkCount++;
+        try {
+          const stats = await fs6.stat(firstSegmentPath);
+          if (stats.size > 256) {
+            if (segmentWatcher) {
+              clearInterval(segmentWatcher);
+              segmentWatcher = null;
+            }
+            logger?.debug?.(
+              `[createRecordingReplayHlsSession] First segment ready after ${checkCount * 100}ms, size=${stats.size}`
+            );
+            readyResolve?.();
+            readyResolve = null;
+          }
+        } catch {
+        }
+        if (checkCount >= maxChecks && readyResolve) {
+          if (segmentWatcher) {
+            clearInterval(segmentWatcher);
+            segmentWatcher = null;
+          }
+          logger?.debug?.(
+            `[createRecordingReplayHlsSession] Segment watcher timeout, resolving anyway`
+          );
+          readyResolve?.();
+          readyResolve = null;
+        }
+      }, 100);
+    };
+    const startFfmpeg = (videoType) => {
+      if (ff) return;
+      const needsTranscode = videoType === "H265" && params.transcodeH265ToH264 === true;
+      const gop = Math.max(1, Math.round(fps * hlsSegmentDuration));
+      logger?.log?.(
+        `[createRecordingReplayHlsSession] Starting ffmpeg HLS with videoType=${videoType}, transcode=${needsTranscode}, hlsTime=${hlsSegmentDuration}s, fileName=${params.fileName}`
+      );
+      MpegTsMuxer.resetCounters();
+      tsMuxer = new MpegTsMuxer({ videoType });
+      const args = [
+        "-hide_banner",
+        "-loglevel",
+        "error",
+        "-f",
+        "mpegts",
+        "-i",
+        "pipe:0",
+        // Video codec
+        ...needsTranscode ? [
+          "-c:v",
+          "libx264",
+          "-preset",
+          "ultrafast",
+          "-tune",
+          "zerolatency",
+          "-crf",
+          "23",
+          "-pix_fmt",
+          "yuv420p",
+          // Ensure regular GOP for consistent HLS cutting.
+          "-g",
+          String(gop),
+          "-keyint_min",
+          String(gop),
+          "-sc_threshold",
+          "0",
+          // Force frequent keyframes so HLS can cut segments reliably.
+          // Without this, ffmpeg will only cut on keyframes and segments can become huge.
+          "-force_key_frames",
+          `expr:gte(t,n_forced*${hlsSegmentDuration})`
+        ] : ["-c", "copy"],
+        // HLS output options
+        "-f",
+        "hls",
+        "-hls_time",
+        String(hlsSegmentDuration),
+        "-hls_list_size",
+        "0",
+        // Keep all segments in playlist
+        "-hls_playlist_type",
+        "event",
+        // Growing playlist (not VOD until end)
+        "-hls_segment_filename",
+        segmentPattern,
+        "-hls_flags",
+        "independent_segments+temp_file",
+        playlistPath
+      ];
+      ff = (0, import_node_child_process3.spawn)("ffmpeg", args, { stdio: ["pipe", "pipe", "pipe"] });
+      if (!ff.stdin || !ff.stderr) {
+        throw new Error("ffmpeg stdio streams not available");
+      }
+      input.pipe(ff.stdin);
+      ff.stdin.on("error", () => {
+      });
+      ff.stderr.on("error", () => {
+      });
+      input.on("error", () => {
+      });
+      let stderr = "";
+      ff.stderr.on("data", (d) => stderr += String(d));
+      ff.on("close", (code) => {
+        if (ended) return;
+        ended = true;
+        if ((code ?? 0) !== 0 && stderr.trim()) {
+          logger?.error?.(
+            `[createRecordingReplayHlsSession] ffmpeg exited with code ${code}: ${stderr}`
+          );
+        } else {
+          logger?.debug?.(
+            `[createRecordingReplayHlsSession] ffmpeg closed normally, frames=${frameCount}`
+          );
+        }
+      });
+    };
+    const stopAll = async () => {
+      if (ended) return;
+      ended = true;
+      releaseQueueSlot();
+      if (segmentWatcher) {
+        clearInterval(segmentWatcher);
+        segmentWatcher = null;
+      }
+      logger?.debug?.(
+        `[createRecordingReplayHlsSession] Stopping, frames=${frameCount}`
+      );
+      const cleanupPromises = [];
+      cleanupPromises.push(stopReplay().catch(() => {
+      }));
+      cleanupPromises.push(stream.stop().catch(() => {
+      }));
+      try {
+        input.end();
+      } catch {
+      }
+      try {
+        ff?.kill("SIGKILL");
+      } catch {
+      }
+      await Promise.race([
+        Promise.all(cleanupPromises),
+        new Promise((resolve) => setTimeout(resolve, 2e3))
+      ]);
+      setTimeout(async () => {
+        try {
+          const files = await fs6.readdir(tempDir);
+          for (const file of files) {
+            await fs6.unlink(path6.join(tempDir, file)).catch(() => {
+            });
+          }
+          await fs6.rmdir(tempDir).catch(() => {
+          });
+        } catch {
+        }
+      }, 6e4);
+    };
+    const timer = setTimeout(
+      () => {
+        logger?.debug?.(
+          `[createRecordingReplayHlsSession] Timeout reached (${seconds}s), stopping`
+        );
+        void stopAll();
+      },
+      Math.max(1, seconds) * 1e3
+    );
+    stream.on("error", (e) => {
+      logger?.error?.(
+        `[createRecordingReplayHlsSession] Stream error: ${e.message}`
+      );
+      clearTimeout(timer);
+      void stopAll();
+    });
+    stream.on("close", () => {
+      logger?.debug?.(
+        `[createRecordingReplayHlsSession] Stream closed, frames=${frameCount}`
+      );
+      clearTimeout(timer);
+      try {
+        input.end();
+      } catch {
+      }
+    });
+    stream.on(
+      "videoAccessUnit",
+      ({ data, videoType, isKeyframe, microseconds }) => {
+        if (ended) return;
+        startFfmpeg(videoType);
+        frameCount++;
+        if (tsMuxer) {
+          const tsData = tsMuxer.mux(data, microseconds, isKeyframe);
+          input.write(tsData);
+        }
+        if (frameCount === 1) {
+          startSegmentWatcher();
+        }
+      }
+    );
+    return {
+      getPlaylist: () => {
+        try {
+          const { readFileSync } = require("fs");
+          return readFileSync(playlistPath, "utf8");
+        } catch {
+          return "#EXTM3U\n#EXT-X-VERSION:3\n#EXT-X-TARGETDURATION:4\n";
+        }
+      },
+      getSegment: (name) => {
+        if (segments.has(name)) {
+          return segments.get(name);
+        }
+        try {
+          const { readFileSync } = require("fs");
+          const segmentPath = path6.join(tempDir, name);
+          const data = readFileSync(segmentPath);
+          segments.set(name, data);
+          return data;
+        } catch {
+          return void 0;
+        }
+      },
+      listSegments: () => {
+        try {
+          const { readdirSync } = require("fs");
+          return readdirSync(tempDir).filter(
+            (f) => f.endsWith(".ts")
+          );
+        } catch {
+          return [];
+        }
+      },
+      waitForReady: () => readyPromise,
+      stop: stopAll,
+      tempDir
+    };
+  }
+  // ============================================================
+  // STANDALONE CAMERA METHODS
+  // ============================================================
+  // These methods are specifically designed for standalone cameras
+  // (non-NVR) connected via TCP. They provide a simplified interface
+  // for common operations like listing recordings, streaming playback,
+  // downloading clips, and getting thumbnails.
+  // ============================================================
+  /**
+   * List recordings from a standalone camera.
+   *
+   * This method is optimized for standalone cameras (non-NVR) and uses
+   * the native Baichuan protocol to list recorded files.
+   *
+   * @example
+   * ```ts
+   * const api = new ReolinkBaichuanApi({ host: '192.168.1.100', ... });
+   * await api.login();
+   *
+   * const recordings = await api.standaloneListRecordings({
+   *   start: new Date('2024-01-20T00:00:00'),
+   *   end: new Date('2024-01-21T23:59:59'),
+   * });
+   *
+   * for (const file of recordings) {
+   *   console.log(file.fileName, file.startTime, file.endTime);
+   * }
+   * ```
+   */
+  async standaloneListRecordings(params) {
+    const channel = 0;
+    const streamType = params.streamType === "mainStream" ? "mainStream" : "subStream";
+    const timeoutMs = params.timeoutMs ?? 15e3;
+    return await this.getVideoclips({
+      channel,
+      start: params.start,
+      end: params.end,
+      streamType,
+      timeoutMs
+    });
+  }
+  /**
    * Start a streaming replay of a recorded file from a standalone camera.
    *
    * Returns a video stream that emits frames in real-time. The stream can be
@@ -24530,46 +25214,404 @@ ${scheduleItems}
   }
 };
 
-// src/reolink/discovery.ts
-var import_node_dgram2 = __toESM(require("dgram"), 1);
-var import_node_os2 = require("os");
-init_ReolinkCgiApi();
-async function discoverViaUdpDirect(host, options) {
-  if (!options.enableUdpDiscovery) return [];
-  const logger = options.logger;
-  const timeoutMs = options.udpBroadcastTimeoutMs ?? 1500;
-  const discovered = [];
-  const targetHost = host?.trim();
-  if (!targetHost) return [];
-  logger?.log?.(`[Discovery] Starting UDP direct discovery to ${targetHost} on ports ${BCUDP_DISCOVERY_PORT_LOCAL_ANY} and ${BCUDP_DISCOVERY_PORT_LOCAL_UID}...`);
-  return new Promise((resolve) => {
-    const socket = import_node_dgram2.default.createSocket("udp4");
-    let timeout;
-    socket.on("message", (msg, rinfo) => {
-      try {
-        if (rinfo.address !== targetHost) return;
-        const packet = decodeBcUdpPacket(msg);
-        if (packet.kind !== "discovery") return;
-        const cr = parseD2cCr(packet.xml);
-        const disc = cr ? void 0 : parseD2cDisc(packet.xml);
-        if (!cr && !disc) return;
-        const uidMatch = /<uid>([^<]+)<\/uid>/i.exec(packet.xml);
-        const modelMatch = /<model>([^<]+)<\/model>/i.exec(packet.xml);
-        const nameMatch = /<name>([^<]+)<\/name>/i.exec(packet.xml);
-        const deviceIdMatch = /<deviceId>([^<]+)<\/deviceId>/i.exec(packet.xml);
-        const uid = (uidMatch?.[1] ?? deviceIdMatch?.[1])?.trim();
-        const model = modelMatch?.[1]?.trim();
-        const name = nameMatch?.[1]?.trim();
-        const result = {
-          host: rinfo.address,
-          discoveryMethod: "udp_direct",
-          ...uid ? { uid } : {},
-          ...model ? { model } : {},
-          ...name ? { name } : {}
+// 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"
         };
-        discovered.push(result);
-        try {
-          socket.close();
+      }
+      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/discovery.ts
+var import_node_dgram2 = __toESM(require("dgram"), 1);
+var import_node_os2 = require("os");
+init_ReolinkCgiApi();
+async function discoverViaUdpDirect(host, options) {
+  if (!options.enableUdpDiscovery) return [];
+  const logger = options.logger;
+  const timeoutMs = options.udpBroadcastTimeoutMs ?? 1500;
+  const discovered = [];
+  const targetHost = host?.trim();
+  if (!targetHost) return [];
+  logger?.log?.(`[Discovery] Starting UDP direct discovery to ${targetHost} on ports ${BCUDP_DISCOVERY_PORT_LOCAL_ANY} and ${BCUDP_DISCOVERY_PORT_LOCAL_UID}...`);
+  return new Promise((resolve) => {
+    const socket = import_node_dgram2.default.createSocket("udp4");
+    let timeout;
+    socket.on("message", (msg, rinfo) => {
+      try {
+        if (rinfo.address !== targetHost) return;
+        const packet = decodeBcUdpPacket(msg);
+        if (packet.kind !== "discovery") return;
+        const cr = parseD2cCr(packet.xml);
+        const disc = cr ? void 0 : parseD2cDisc(packet.xml);
+        if (!cr && !disc) return;
+        const uidMatch = /<uid>([^<]+)<\/uid>/i.exec(packet.xml);
+        const modelMatch = /<model>([^<]+)<\/model>/i.exec(packet.xml);
+        const nameMatch = /<name>([^<]+)<\/name>/i.exec(packet.xml);
+        const deviceIdMatch = /<deviceId>([^<]+)<\/deviceId>/i.exec(packet.xml);
+        const uid = (uidMatch?.[1] ?? deviceIdMatch?.[1])?.trim();
+        const model = modelMatch?.[1]?.trim();
+        const name = nameMatch?.[1]?.trim();
+        const result = {
+          host: rinfo.address,
+          discoveryMethod: "udp_direct",
+          ...uid ? { uid } : {},
+          ...model ? { model } : {},
+          ...name ? { name } : {}
+        };
+        discovered.push(result);
+        try {
+          socket.close();
         } catch {
         }
       } catch {
@@ -25221,6 +26263,79 @@ var AutodiscoveryClient = class {
   }
 };
 
+// src/reolink/baichuan/types.ts
+function getVideoclipClientInfo(headers) {
+  const getHeader = (key) => {
+    const val = headers[key] ?? headers[key.toLowerCase()] ?? headers[key.toUpperCase()];
+    return Array.isArray(val) ? val[0] : val;
+  };
+  return {
+    userAgent: getHeader("user-agent") ?? getHeader("User-Agent"),
+    accept: getHeader("accept") ?? getHeader("Accept"),
+    range: getHeader("range") ?? getHeader("Range"),
+    secChUa: getHeader("sec-ch-ua") ?? getHeader("Sec-CH-UA"),
+    secChUaMobile: getHeader("sec-ch-ua-mobile") ?? getHeader("Sec-CH-UA-Mobile"),
+    secChUaPlatform: getHeader("sec-ch-ua-platform") ?? getHeader("Sec-CH-UA-Platform")
+  };
+}
+function decideVideoclipTranscodeMode(headers, forceMode) {
+  const clientInfo = getVideoclipClientInfo(headers);
+  if (forceMode) {
+    return {
+      mode: forceMode,
+      reason: `forced: ${forceMode}`,
+      clientInfo
+    };
+  }
+  const ua = (clientInfo.userAgent ?? "").toLowerCase();
+  const platform = (clientInfo.secChUaPlatform ?? "").toLowerCase().replace(/"/g, "");
+  const isIos = /iphone|ipad|ipod/.test(ua);
+  if (isIos) {
+    return {
+      mode: "transcode-h264",
+      reason: "iOS device detected - no native H.265 support in <video>",
+      clientInfo
+    };
+  }
+  const isFirefox = ua.includes("firefox");
+  if (isFirefox) {
+    return {
+      mode: "transcode-h264",
+      reason: "Firefox detected - no H.265 support",
+      clientInfo
+    };
+  }
+  const isAndroid = ua.includes("android") || platform === "android";
+  if (isAndroid) {
+    return {
+      mode: "transcode-h264",
+      reason: "Android device detected - variable H.265 support",
+      clientInfo
+    };
+  }
+  const isChromium = ua.includes("chrome") || ua.includes("edg");
+  const isMac = ua.includes("mac os") || platform === "macos";
+  if (isChromium && !isMac) {
+    return {
+      mode: "transcode-h264",
+      reason: "Chrome/Edge on non-Mac detected - limited H.265 support",
+      clientInfo
+    };
+  }
+  if (isMac) {
+    return {
+      mode: "passthrough",
+      reason: "macOS detected - native H.265 hardware decoding available",
+      clientInfo
+    };
+  }
+  return {
+    mode: "transcode-h264",
+    reason: "Unknown client - transcoding for compatibility",
+    clientInfo
+  };
+}
+
 // src/index.ts
 init_recordingFileName();
 
@@ -25232,6 +26347,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;
@@ -25262,6 +26384,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();
@@ -25307,6 +26434,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();
@@ -28955,93 +30122,1959 @@ var BaichuanHttpStreamServer = class extends import_node_events6.EventEmitter {
           }
         }
       }
-    });
-    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}`));
+    });
+    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/baichuan/stream/BaichuanMjpegServer.ts
+var import_node_events8 = require("events");
+var http5 = __toESM(require("http"), 1);
+
+// src/baichuan/stream/MjpegTransformer.ts
+var import_node_events7 = require("events");
+var import_node_child_process9 = require("child_process");
+var JPEG_SOI = Buffer.from([255, 216]);
+var JPEG_EOI = Buffer.from([255, 217]);
+var MjpegTransformer = class extends import_node_events7.EventEmitter {
+  options;
+  ffmpeg = null;
+  started = false;
+  closed = false;
+  jpegBuffer = Buffer.alloc(0);
+  frameCount = 0;
+  lastTimestamp = 0;
+  constructor(options) {
+    super();
+    this.options = {
+      codec: options.codec,
+      quality: options.quality ?? 5,
+      width: options.width,
+      height: options.height,
+      maxFps: options.maxFps,
+      logger: options.logger
+    };
+  }
+  /**
+   * Start the transformer (spawns FFmpeg process)
+   */
+  start() {
+    if (this.started || this.closed) return;
+    this.started = true;
+    const { codec, quality, width, height, maxFps } = this.options;
+    const args = [
+      "-hide_banner",
+      "-loglevel",
+      "error",
+      // Input: raw video from stdin
+      "-f",
+      codec === "h265" ? "hevc" : "h264",
+      "-i",
+      "pipe:0"
+    ];
+    const filters = [];
+    if (width || height) {
+      const w = width ?? -1;
+      const h = height ?? -1;
+      filters.push(`scale=${w}:${h}`);
+    }
+    if (maxFps) {
+      filters.push(`fps=${maxFps}`);
+    }
+    if (filters.length > 0) {
+      args.push("-vf", filters.join(","));
+    }
+    args.push(
+      "-c:v",
+      "mjpeg",
+      "-q:v",
+      String(quality),
+      "-f",
+      "mjpeg",
+      "pipe:1"
+    );
+    this.log("debug", `Starting FFmpeg with args: ${args.join(" ")}`);
+    this.ffmpeg = (0, import_node_child_process9.spawn)("ffmpeg", args, {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.ffmpeg.stdout.on("data", (data) => {
+      this.handleJpegData(data);
+    });
+    this.ffmpeg.stderr.on("data", (data) => {
+      const msg = data.toString().trim();
+      if (msg) {
+        this.log("debug", `FFmpeg: ${msg}`);
+      }
+    });
+    this.ffmpeg.on("close", (code) => {
+      this.log("debug", `FFmpeg closed with code ${code}`);
+      this.ffmpeg = null;
+      if (!this.closed) {
+        this.emit("close", code);
+      }
+    });
+    this.ffmpeg.on("error", (err) => {
+      this.log("error", `FFmpeg error: ${err.message}`);
+      this.emit("error", err);
+    });
+  }
+  /**
+   * Push an H.264/H.265 access unit (Annex-B format with start codes)
+   */
+  push(accessUnit, timestamp) {
+    if (!this.started || this.closed || !this.ffmpeg) {
+      return;
+    }
+    this.lastTimestamp = timestamp ?? Date.now() * 1e3;
+    try {
+      this.ffmpeg.stdin.write(accessUnit);
+    } catch (err) {
+      this.log("error", `Failed to write to FFmpeg: ${err}`);
+    }
+  }
+  /**
+   * Handle JPEG data from FFmpeg stdout
+   * FFmpeg outputs complete JPEG images, each starting with SOI (0xFFD8)
+   * and ending with EOI (0xFFD9)
+   */
+  handleJpegData(data) {
+    this.jpegBuffer = Buffer.concat([this.jpegBuffer, data]);
+    while (true) {
+      const soiIndex = this.jpegBuffer.indexOf(JPEG_SOI);
+      if (soiIndex < 0) {
+        this.jpegBuffer = Buffer.alloc(0);
+        break;
+      }
+      if (soiIndex > 0) {
+        this.jpegBuffer = this.jpegBuffer.subarray(soiIndex);
+      }
+      const eoiIndex = this.jpegBuffer.indexOf(JPEG_EOI, 2);
+      if (eoiIndex < 0) {
+        break;
+      }
+      const frameEnd = eoiIndex + 2;
+      const jpegFrame = this.jpegBuffer.subarray(0, frameEnd);
+      this.jpegBuffer = this.jpegBuffer.subarray(frameEnd);
+      this.frameCount++;
+      const frame = {
+        data: jpegFrame,
+        timestamp: this.lastTimestamp
+      };
+      this.emit("frame", frame);
+    }
+  }
+  /**
+   * Stop the transformer
+   */
+  async stop() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.ffmpeg) {
+      try {
+        this.ffmpeg.stdin.end();
+      } catch {
+      }
+      await new Promise((resolve) => {
+        const ff = this.ffmpeg;
+        if (!ff) {
+          resolve();
+          return;
+        }
+        const timeout = setTimeout(() => {
+          ff.kill("SIGKILL");
+          resolve();
+        }, 1e3);
+        ff.once("close", () => {
+          clearTimeout(timeout);
+          resolve();
+        });
+        try {
+          ff.kill("SIGTERM");
+        } catch {
+          clearTimeout(timeout);
+          resolve();
+        }
+      });
+      this.ffmpeg = null;
+    }
+    this.emit("close", 0);
+  }
+  /**
+   * Get frame count
+   */
+  getFrameCount() {
+    return this.frameCount;
+  }
+  /**
+   * Check if running
+   */
+  isRunning() {
+    return this.started && !this.closed && this.ffmpeg !== null;
+  }
+  log(level, message) {
+    this.options.logger?.(level, `[MjpegTransformer] ${message}`);
+  }
+};
+function createMjpegBoundary() {
+  return `mjpegboundary${Date.now()}`;
+}
+function getMjpegContentType(boundary) {
+  return `multipart/x-mixed-replace; boundary=${boundary}`;
+}
+function formatMjpegFrame(frame, boundary) {
+  const header = Buffer.from(
+    `--${boundary}\r
+Content-Type: image/jpeg\r
+Content-Length: ${frame.length}\r
+\r
+`
+  );
+  return Buffer.concat([header, frame, Buffer.from("\r\n")]);
+}
+
+// src/baichuan/stream/BaichuanMjpegServer.ts
+init_H264Converter();
+init_H265Converter();
+var BaichuanMjpegServer = class extends import_node_events8.EventEmitter {
+  options;
+  clients = /* @__PURE__ */ new Map();
+  httpServer = null;
+  transformer = null;
+  nativeStream = null;
+  streamPump = null;
+  detectedCodec = null;
+  started = false;
+  clientIdCounter = 0;
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+  /**
+   * Start the MJPEG server
+   */
+  async start() {
+    if (this.started) return;
+    this.started = true;
+    const port = this.options.port ?? 8080;
+    const host = this.options.host ?? "0.0.0.0";
+    const path6 = this.options.path ?? "/mjpeg";
+    this.httpServer = http5.createServer((req, res) => {
+      this.handleRequest(req, res, path6);
+    });
+    return new Promise((resolve, reject) => {
+      this.httpServer.on("error", (err) => {
+        this.log("error", `HTTP server error: ${err.message}`);
+        reject(err);
+      });
+      this.httpServer.listen(port, host, () => {
+        this.log(
+          "info",
+          `MJPEG server started on http://${host}:${port}${path6}`
+        );
+        this.emit("started", { host, port, path: path6 });
+        resolve();
+      });
+    });
+  }
+  /**
+   * Stop the MJPEG server
+   */
+  async stop() {
+    if (!this.started) return;
+    this.started = false;
+    for (const [id, client] of this.clients) {
+      try {
+        client.response.end();
+      } catch {
+      }
+      this.clients.delete(id);
+    }
+    await this.stopStream();
+    if (this.httpServer) {
+      await new Promise((resolve) => {
+        this.httpServer.close(() => resolve());
+      });
+      this.httpServer = null;
+    }
+    this.log("info", "MJPEG server stopped");
+    this.emit("stopped");
+  }
+  /**
+   * Handle HTTP request
+   */
+  handleRequest(req, res, expectedPath) {
+    const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+    if (url.pathname !== expectedPath) {
+      res.statusCode = 404;
+      res.end("Not Found");
+      return;
+    }
+    if (req.method !== "GET") {
+      res.statusCode = 405;
+      res.end("Method Not Allowed");
+      return;
+    }
+    this.handleMjpegClient(req, res);
+  }
+  /**
+   * Handle new MJPEG client
+   */
+  handleMjpegClient(req, res) {
+    const clientId = `client-${++this.clientIdCounter}`;
+    const boundary = createMjpegBoundary();
+    const client = {
+      id: clientId,
+      response: res,
+      boundary,
+      connectedAt: Date.now()
+    };
+    this.clients.set(clientId, client);
+    this.log(
+      "info",
+      `MJPEG client connected: ${clientId} (total: ${this.clients.size})`
+    );
+    this.emit("client-connected", { id: clientId, total: this.clients.size });
+    res.writeHead(200, {
+      "Content-Type": getMjpegContentType(boundary),
+      "Cache-Control": "no-cache, no-store, must-revalidate",
+      Pragma: "no-cache",
+      Expires: "0",
+      Connection: "close"
+    });
+    const cleanup = () => {
+      this.clients.delete(clientId);
+      this.log(
+        "info",
+        `MJPEG client disconnected: ${clientId} (remaining: ${this.clients.size})`
+      );
+      this.emit("client-disconnected", {
+        id: clientId,
+        total: this.clients.size
+      });
+      if (this.clients.size === 0) {
+        this.stopStream();
+      }
+    };
+    req.on("close", cleanup);
+    res.on("close", cleanup);
+    res.on("error", cleanup);
+    if (!this.transformer) {
+      this.startStream();
+    }
+  }
+  /**
+   * Start the native video stream and MJPEG transformer
+   */
+  async startStream() {
+    if (this.transformer) return;
+    this.log("info", "Starting native video stream...");
+    const { api, channel, profile, variant, quality, width, height, maxFps } = this.options;
+    try {
+      this.nativeStream = createNativeStream(
+        api,
+        channel,
+        profile,
+        variant ? { variant } : void 0
+      );
+      this.streamPump = this.pumpStream();
+    } catch (err) {
+      this.log("error", `Failed to start stream: ${err}`);
+      this.emit("error", err);
+    }
+  }
+  /**
+   * Pump native stream and feed to transformer
+   */
+  async pumpStream() {
+    if (!this.nativeStream) return;
+    let frameBuffer = [];
+    let waitingForKeyframe = true;
+    try {
+      for await (const frame of this.nativeStream) {
+        if (!this.started || this.clients.size === 0) break;
+        const { type, data, microseconds, videoType } = frame;
+        if (type !== "Iframe" && type !== "Pframe") continue;
+        if (!data || data.length === 0) continue;
+        let annexB;
+        if (videoType === "H265") {
+          annexB = convertToAnnexB2(data);
+          if (!this.detectedCodec) {
+            this.detectedCodec = "h265";
+            this.initTransformer();
+          }
+        } else {
+          annexB = convertToAnnexB(data);
+          if (!this.detectedCodec) {
+            this.detectedCodec = "h264";
+            this.initTransformer();
+          }
+        }
+        if (waitingForKeyframe) {
+          if (type === "Iframe") {
+            waitingForKeyframe = false;
+          } else {
+            continue;
+          }
+        }
+        if (this.transformer) {
+          this.transformer.push(annexB, microseconds);
+        }
+      }
+    } catch (err) {
+      if (this.started) {
+        this.log("error", `Stream error: ${err}`);
+        this.emit("error", err);
+      }
+    }
+  }
+  /**
+   * Initialize MJPEG transformer once codec is detected
+   */
+  initTransformer() {
+    if (this.transformer || !this.detectedCodec) return;
+    const { quality, width, height, maxFps } = this.options;
+    this.transformer = new MjpegTransformer({
+      codec: this.detectedCodec,
+      quality,
+      width,
+      height,
+      maxFps,
+      logger: this.options.logger
+    });
+    this.transformer.on("frame", (frame) => {
+      this.broadcastFrame(frame);
+    });
+    this.transformer.on("error", (err) => {
+      this.log("error", `Transformer error: ${err}`);
+    });
+    this.transformer.on("close", () => {
+      this.log("debug", "Transformer closed");
+    });
+    this.transformer.start();
+    this.log(
+      "info",
+      `MJPEG transformer started (codec: ${this.detectedCodec})`
+    );
+  }
+  /**
+   * Broadcast JPEG frame to all connected clients
+   */
+  broadcastFrame(frame) {
+    for (const client of this.clients.values()) {
+      try {
+        const mjpegData = formatMjpegFrame(frame.data, client.boundary);
+        client.response.write(mjpegData);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Stop the stream and transformer
+   */
+  async stopStream() {
+    if (this.transformer) {
+      await this.transformer.stop();
+      this.transformer = null;
+    }
+    if (this.nativeStream) {
+      try {
+        await this.nativeStream.return(void 0);
+      } catch {
+      }
+      this.nativeStream = null;
+    }
+    if (this.streamPump) {
+      try {
+        await this.streamPump;
+      } catch {
+      }
+      this.streamPump = null;
+    }
+    this.detectedCodec = null;
+    this.log("debug", "Stream stopped");
+  }
+  /**
+   * Get current number of connected clients
+   */
+  getClientCount() {
+    return this.clients.size;
+  }
+  /**
+   * Get server status
+   */
+  getStatus() {
+    return {
+      running: this.started,
+      clients: this.clients.size,
+      codec: this.detectedCodec,
+      frames: this.transformer?.getFrameCount() ?? 0
+    };
+  }
+  log(level, message) {
+    this.options.logger?.(level, `[BaichuanMjpegServer] ${message}`);
+  }
+};
+
+// src/baichuan/stream/BaichuanWebRTCServer.ts
+var import_node_events9 = require("events");
+init_BcMediaAnnexBDecoder();
+init_H264Converter();
+function parseAnnexBNalUnits(annexB) {
+  const nalUnits = [];
+  let offset = 0;
+  while (offset < annexB.length) {
+    let startCodeLen = 0;
+    if (offset + 4 <= annexB.length && annexB[offset] === 0 && annexB[offset + 1] === 0 && annexB[offset + 2] === 0 && annexB[offset + 3] === 1) {
+      startCodeLen = 4;
+    } else if (offset + 3 <= annexB.length && annexB[offset] === 0 && annexB[offset + 1] === 0 && annexB[offset + 2] === 1) {
+      startCodeLen = 3;
+    } else {
+      offset++;
+      continue;
+    }
+    const naluStart = offset + startCodeLen;
+    let naluEnd = annexB.length;
+    for (let i = naluStart; i < annexB.length - 2; i++) {
+      if (annexB[i] === 0 && annexB[i + 1] === 0 && (annexB[i + 2] === 1 || i + 3 < annexB.length && annexB[i + 2] === 0 && annexB[i + 3] === 1)) {
+        naluEnd = i;
+        break;
+      }
+    }
+    if (naluEnd > naluStart) {
+      nalUnits.push(annexB.subarray(naluStart, naluEnd));
+    }
+    offset = naluEnd;
+  }
+  return nalUnits;
+}
+function getH264NalType(nalUnit) {
+  return nalUnit[0] & 31;
+}
+function getH265NalType2(nalUnit) {
+  return nalUnit[0] >> 1 & 63;
+}
+var BaichuanWebRTCServer = class extends import_node_events9.EventEmitter {
+  options;
+  sessions = /* @__PURE__ */ new Map();
+  sessionIdCounter = 0;
+  weriftModule = null;
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+  /**
+   * Initialize werift module (lazy load to avoid requiring it if not used)
+   */
+  async loadWerift() {
+    if (this.weriftModule) return this.weriftModule;
+    try {
+      this.weriftModule = await import("werift");
+      return this.weriftModule;
+    } catch (err) {
+      throw new Error(
+        `Failed to load werift module. Make sure it's installed: npm install werift
+Error: ${err}`
+      );
+    }
+  }
+  /**
+   * Create a new WebRTC session
+   * Returns a session ID and SDP offer to send to the browser
+   */
+  async createSession() {
+    const werift = await this.loadWerift();
+    const { RTCPeerConnection, MediaStreamTrack, RTCRtpCodecParameters } = werift;
+    const sessionId = `webrtc-${++this.sessionIdCounter}-${Date.now()}`;
+    this.log("info", `Creating WebRTC session ${sessionId}`);
+    const iceServers = [];
+    const stunServers = this.options.stunServers ?? [
+      "stun:stun.l.google.com:19302"
+    ];
+    for (const urls of stunServers) {
+      iceServers.push({ urls });
+    }
+    if (this.options.turnServers) {
+      iceServers.push(...this.options.turnServers);
+    }
+    const peerConnection = new RTCPeerConnection({
+      iceServers,
+      codecs: {
+        video: [
+          new RTCRtpCodecParameters({
+            mimeType: "video/H264",
+            clockRate: 9e4,
+            rtcpFeedback: [
+              { type: "nack" },
+              { type: "nack", parameter: "pli" },
+              { type: "goog-remb" }
+            ],
+            parameters: "packetization-mode=1;profile-level-id=42e01f;level-asymmetry-allowed=1"
+          })
+        ],
+        audio: [
+          new RTCRtpCodecParameters({
+            mimeType: "audio/opus",
+            clockRate: 48e3,
+            channels: 2
+          })
+        ]
+      }
+    });
+    const session = {
+      id: sessionId,
+      peerConnection,
+      videoTrack: null,
+      audioTrack: null,
+      videoDataChannel: null,
+      nativeStream: null,
+      intercom: null,
+      dataChannel: null,
+      videoCodec: null,
+      createdAt: /* @__PURE__ */ new Date(),
+      state: "connecting",
+      stats: {
+        videoFrames: 0,
+        audioFrames: 0,
+        bytesSent: 0,
+        intercomBytesSent: 0
+      }
+    };
+    this.sessions.set(sessionId, session);
+    const videoSsrc = Math.random() * 4294967295 >>> 0;
+    const videoTrack = new MediaStreamTrack({ kind: "video", ssrc: videoSsrc });
+    const videoSender = peerConnection.addTrack(videoTrack);
+    session.videoTrack = videoTrack;
+    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", {
+      ordered: true,
+      maxRetransmits: 0
+      // Unreliable for real-time video
+    });
+    session.videoDataChannel = videoDataChannel;
+    videoDataChannel.onopen = () => {
+      this.log("info", `Video data channel opened for session ${sessionId}`);
+    };
+    if (this.options.enableIntercom) {
+      const dataChannel = peerConnection.createDataChannel("intercom", {
+        ordered: true
+      });
+      session.dataChannel = dataChannel;
+      dataChannel.onopen = () => {
+        this.log(
+          "info",
+          `Intercom data channel opened for session ${sessionId}`
+        );
+        this.emit("intercom-started", { sessionId });
+      };
+      dataChannel.onmessage = async (event) => {
+        if (session.intercom && event.data instanceof ArrayBuffer) {
+          try {
+            const audioData = Buffer.from(event.data);
+            await session.intercom.sendAudio(audioData);
+            session.stats.intercomBytesSent += audioData.length;
+          } catch (err) {
+            this.log("error", `Failed to send intercom audio: ${err}`);
+          }
+        }
+      };
+      dataChannel.onclose = () => {
+        this.log(
+          "info",
+          `Intercom data channel closed for session ${sessionId}`
+        );
+        this.emit("intercom-stopped", { sessionId });
+      };
+    }
+    peerConnection.iceConnectionStateChange.subscribe((state) => {
+      this.log("info", `ICE connection state for ${sessionId}: ${state}`);
+      if (state === "connected") {
+        session.state = "connected";
+        this.emit("session-connected", { sessionId });
+      } else if (state === "failed") {
+        session.state = state;
+        this.closeSession(sessionId).catch((err) => {
+          this.log("error", `Error closing session on ICE ${state}: ${err}`);
+        });
+      }
+    });
+    peerConnection.connectionStateChange.subscribe((state) => {
+      this.log("debug", `Connection state for ${sessionId}: ${state}`);
+      if (state === "closed" || state === "failed") {
+        this.closeSession(sessionId).catch((err) => {
+          this.log(
+            "error",
+            `Error closing session on connection ${state}: ${err}`
+          );
+        });
+      }
+    });
+    const offer = await peerConnection.createOffer();
+    await peerConnection.setLocalDescription(offer);
+    await this.waitForIceGathering(peerConnection, 3e3);
+    const localDescription = peerConnection.localDescription;
+    if (!localDescription) {
+      throw new Error("Failed to create local description");
+    }
+    this.emit("session-created", { sessionId });
+    return {
+      sessionId,
+      offer: {
+        sdp: localDescription.sdp,
+        type: "offer"
+      }
+    };
+  }
+  /**
+   * Handle WebRTC answer from browser and start streaming
+   */
+  async handleAnswer(sessionId, answer) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+    const werift = await this.loadWerift();
+    const { RTCSessionDescription } = werift;
+    this.log("info", `Handling WebRTC answer for session ${sessionId}`);
+    await session.peerConnection.setRemoteDescription(
+      new RTCSessionDescription(answer.sdp, answer.type)
+    );
+    await this.startNativeStream(session);
+    if (this.options.enableIntercom && session.dataChannel) {
+      await this.startIntercom(session);
+    }
+  }
+  /**
+   * Add ICE candidate from browser
+   */
+  async addIceCandidate(sessionId, candidate) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+    const werift = await this.loadWerift();
+    const { RTCIceCandidate } = werift;
+    await session.peerConnection.addIceCandidate(
+      new RTCIceCandidate(candidate.candidate, candidate.sdpMid ?? "0")
+    );
+  }
+  /**
+   * Close a WebRTC session
+   */
+  async closeSession(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+    this.log("info", `Closing WebRTC session ${sessionId}`);
+    session.state = "disconnected";
+    if (session.intercom) {
+      try {
+        await session.intercom.stop();
+      } catch (err) {
+        this.log("debug", `Error stopping intercom: ${err}`);
+      }
+      session.intercom = null;
+    }
+    if (session.dataChannel) {
+      try {
+        session.dataChannel.close();
+      } catch (err) {
+        this.log("debug", `Error closing data channel: ${err}`);
+      }
+      session.dataChannel = null;
+    }
+    if (session.cleanup) {
+      session.cleanup();
+    }
+    try {
+      await session.peerConnection.close();
+    } catch (err) {
+      this.log("debug", `Error closing peer connection: ${err}`);
+    }
+    this.sessions.delete(sessionId);
+    this.emit("session-closed", { sessionId });
+    this.log(
+      "info",
+      `WebRTC session ${sessionId} closed (active sessions: ${this.sessions.size})`
+    );
+  }
+  /**
+   * Get information about all active sessions
+   */
+  getSessions() {
+    return Array.from(this.sessions.values()).map((s) => ({
+      id: s.id,
+      state: s.state,
+      createdAt: s.createdAt,
+      stats: { ...s.stats }
+    }));
+  }
+  /**
+   * Get information about a specific session
+   */
+  getSession(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return null;
+    return {
+      id: session.id,
+      state: session.state,
+      createdAt: session.createdAt,
+      stats: { ...session.stats }
+    };
+  }
+  /**
+   * Close all sessions and stop the server
+   */
+  async stop() {
+    this.log("info", "Stopping WebRTC server");
+    const sessionIds = Array.from(this.sessions.keys());
+    await Promise.all(sessionIds.map((id) => this.closeSession(id)));
+    this.log("info", "WebRTC server stopped");
+  }
+  /**
+   * Get the number of active sessions
+   */
+  get sessionCount() {
+    return this.sessions.size;
+  }
+  // ============================================================================
+  // Private Methods
+  // ============================================================================
+  /**
+   * Wait for ICE gathering to complete
+   */
+  async waitForIceGathering(pc, timeoutMs) {
+    if (pc.iceGatheringState === "complete") return;
+    return new Promise((resolve) => {
+      const timeout = setTimeout(() => {
+        resolve();
+      }, timeoutMs);
+      pc.iceGatheringStateChange.subscribe((state) => {
+        if (state === "complete") {
+          clearTimeout(timeout);
+          resolve();
+        }
+      });
+    });
+  }
+  /**
+   * Start native Baichuan stream and pump frames to WebRTC
+   */
+  async startNativeStream(session) {
+    this.log(
+      "info",
+      `Starting native stream for session ${session.id} (channel=${this.options.channel}, profile=${this.options.profile})`
+    );
+    session.nativeStream = createNativeStream(
+      this.options.api,
+      this.options.channel,
+      this.options.profile,
+      this.options.variant !== void 0 ? { variant: this.options.variant } : void 0
+    );
+    this.pumpFramesToWebRTC(session).catch((err) => {
+      this.log("error", `Frame pump error for session ${session.id}: ${err}`);
+      this.closeSession(session.id).catch(() => {
+      });
+    });
+  }
+  /**
+   * Pump frames from native stream to WebRTC tracks
+   * H.264 → RTP media track (standard WebRTC)
+   * H.265 → DataChannel with raw Annex-B frames (decoded by WebCodecs in browser)
+   */
+  async pumpFramesToWebRTC(session) {
+    if (!session.nativeStream) {
+      this.log("warn", `No native stream for session ${session.id}`);
+      return;
+    }
+    this.log("info", `Starting frame pump for session ${session.id}`);
+    const werift = await this.loadWerift();
+    const { RtpPacket, RtpHeader } = werift;
+    let sequenceNumber = Math.floor(Math.random() * 65535);
+    let timestamp = Math.floor(Math.random() * 4294967295);
+    const videoClockRate = 9e4;
+    let lastTimeMicros = 0;
+    let lastLogTime = Date.now();
+    let packetsSentSinceLastLog = 0;
+    let frameNumber = 0;
+    try {
+      this.log("info", `Entering frame loop for session ${session.id}`);
+      for await (const frame of session.nativeStream) {
+        if (session.state === "disconnected" || session.state === "failed") {
+          this.log(
+            "debug",
+            `Session ${session.id} state is ${session.state}, breaking frame loop`
+          );
+          break;
+        }
+        if (frame.audio) {
+          session.stats.audioFrames++;
+        } else {
+          if (frame.data) {
+            if (!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({
+                  type: "codec",
+                  codec: session.videoCodec,
+                  width: frame.width || 0,
+                  height: frame.height || 0
+                });
+                session.videoDataChannel.send(codecInfo);
+              }
+            }
+            if (frame.microseconds && lastTimeMicros > 0) {
+              const deltaMicros = frame.microseconds - lastTimeMicros;
+              const deltaTicks = Math.floor(
+                deltaMicros / 1e6 * videoClockRate
+              );
+              timestamp = timestamp + deltaTicks >>> 0;
+            } else {
+              timestamp = timestamp + 3e3 >>> 0;
+            }
+            lastTimeMicros = frame.microseconds || 0;
+            if (session.videoCodec === "H264") {
+              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 + packetsSent & 65535;
+              packetsSentSinceLastLog += packetsSent;
+              frameNumber++;
+              session.stats.videoFrames++;
+              session.stats.bytesSent += frame.data.length;
+            } else if (session.videoCodec === "H265") {
+              const sent = await this.sendVideoFrameViaDataChannel(
+                session,
+                frame,
+                frameNumber,
+                "H265"
+              );
+              if (sent) {
+                packetsSentSinceLastLog++;
+                frameNumber++;
+                session.stats.videoFrames++;
+                session.stats.bytesSent += frame.data.length;
+              }
+            }
+            const now = Date.now();
+            if (now - lastLogTime >= 5e3) {
+              this.log(
+                "debug",
+                `WebRTC session ${session.id} [${session.videoCodec}]: sent ${session.stats.videoFrames} frames, ${packetsSentSinceLastLog} packets, ${Math.round(session.stats.bytesSent / 1024)} KB`
+              );
+              lastLogTime = now;
+              packetsSentSinceLastLog = 0;
+            }
+          }
+        }
+      }
+    } catch (err) {
+      this.log(
+        "error",
+        `Error pumping frames for session ${session.id}: ${err}`
+      );
+    }
+    this.log("info", `Native stream ended for session ${session.id}`);
+  }
+  /**
+   * Send H.264 frame via RTP media track
+   * Returns the number of RTP packets sent
+   */
+  async sendH264Frame(session, werift, frameData, sequenceNumber, timestamp) {
+    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 === nalList.length - 1;
+      const nalType = getH264NalType(nalUnit);
+      if (nalType === 9) continue;
+      const rtpPackets = this.createH264RtpPackets(
+        werift,
+        nalUnit,
+        currentSeqNum,
+        timestamp,
+        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) {
+        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 {
-        this.logger.warn(`[BaichuanHttpStreamServer] FFmpeg stderr: ${output.trim()}`);
+        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]));
+        }
       }
-    });
-    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}`));
+      return true;
+    } catch (err) {
+      this.log("error", `Error sending ${codec} frame ${frameNumber}: ${err}`);
+      return false;
+    }
+  }
+  /**
+   * Send H.265 frame via DataChannel
+   * Format: 12-byte header + Annex-B data
+   * Header: [frameNum (4)] [timestamp (4)] [flags (1)] [keyframe (1)] [reserved (2)]
+   */
+  async sendH265Frame(session, frame, frameNumber) {
+    if (!session.videoDataChannel) {
+      if (frameNumber === 0) {
+        this.log("warn", `No video data channel for session ${session.id}`);
       }
-      this.active = false;
-      this.emit("close");
+      return;
+    }
+    if (session.videoDataChannel.readyState !== "open") {
+      if (frameNumber === 0) {
+        this.log(
+          "warn",
+          `Video data channel not open for session ${session.id}: ${session.videoDataChannel.readyState}`
+        );
+      }
+      return;
+    }
+    let isKeyframe = frame.isKeyframe === true;
+    if (!isKeyframe && frame.isKeyframe === void 0) {
+      const nalUnits = parseAnnexBNalUnits(frame.data);
+      for (const nalUnit of nalUnits) {
+        if (nalUnit.length === 0) continue;
+        const nalType = getH265NalType2(nalUnit);
+        if (nalType === 32 || nalType === 33 || nalType === 34 || nalType === 19 || nalType === 20) {
+          isKeyframe = true;
+          break;
+        }
+      }
+    }
+    const header = Buffer.alloc(12);
+    header.writeUInt32BE(frameNumber, 0);
+    header.writeUInt32BE(frame.microseconds ? frame.microseconds / 1e3 : 0, 4);
+    header.writeUInt8(1, 8);
+    header.writeUInt8(isKeyframe ? 1 : 0, 9);
+    header.writeUInt16BE(0, 10);
+    const packet = Buffer.concat([header, frame.data]);
+    if (frameNumber < 3) {
+      this.log(
+        "info",
+        `Sending H.265 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]));
+        }
+      }
+    } catch (err) {
+      this.log("error", `Error sending H.265 frame ${frameNumber}: ${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, ssrc) {
+    const { RtpPacket, RtpHeader } = werift;
+    const MTU = 1200;
+    const packets = [];
+    if (nalUnit.length <= MTU) {
+      const header = new RtpHeader();
+      header.payloadType = 96;
+      header.sequenceNumber = sequenceNumber;
+      header.timestamp = timestamp;
+      header.marker = marker;
+      header.ssrc = ssrc;
+      packets.push(new RtpPacket(header, nalUnit));
+    } else {
+      const nalHeader = nalUnit[0];
+      const nalType = nalHeader & 31;
+      const nri = nalHeader & 96;
+      const fuIndicator = (nri | 28) & 255;
+      let offset = 1;
+      let isFirst = true;
+      while (offset < nalUnit.length) {
+        const remaining = nalUnit.length - offset;
+        const chunkSize = Math.min(remaining, MTU - 2);
+        const isLast = offset + chunkSize >= nalUnit.length;
+        let fuHeader = nalType;
+        if (isFirst) fuHeader |= 128;
+        if (isLast) fuHeader |= 64;
+        const fuPayload = Buffer.alloc(2 + chunkSize);
+        fuPayload[0] = fuIndicator;
+        fuPayload[1] = fuHeader;
+        nalUnit.copy(fuPayload, 2, offset, offset + chunkSize);
+        const header = new RtpHeader();
+        header.payloadType = 96;
+        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;
+      }
+    }
+    return packets;
+  }
+  /**
+   * Start intercom (two-way audio)
+   */
+  async startIntercom(session) {
+    try {
+      session.intercom = new Intercom({
+        api: this.options.api,
+        channel: this.options.channel
+      });
+      await session.intercom.start();
+      this.log("info", `Intercom started for session ${session.id}`);
+    } catch (err) {
+      this.log(
+        "error",
+        `Failed to start intercom for session ${session.id}: ${err}`
+      );
+      session.intercom = null;
+    }
+  }
+  /**
+   * Log helper
+   */
+  log(level, message) {
+    if (this.options.logger) {
+      this.options.logger(level, message);
+    }
+  }
+};
+
+// src/baichuan/stream/BaichuanHlsServer.ts
+var import_node_events10 = require("events");
+var import_node_fs = __toESM(require("fs"), 1);
+var import_promises3 = __toESM(require("fs/promises"), 1);
+var import_node_os3 = __toESM(require("os"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+var import_node_child_process10 = require("child_process");
+init_BcMediaAnnexBDecoder();
+init_H264Converter();
+init_H265Converter();
+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 import_node_events10.EventEmitter {
+  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 ?? (() => {
     });
-    this.active = true;
   }
   /**
-   * Get HTTP URL for this stream.
+   * Start HLS streaming
    */
-  getStreamUrl() {
-    return `http://127.0.0.1:${this.listenPort}${this.path}.ts`;
+  async start() {
+    if (this.state === "running" || this.state === "starting") {
+      return;
+    }
+    this.state = "starting";
+    this.lastError = null;
+    try {
+      if (!this.outputDir) {
+        this.outputDir = await import_promises3.default.mkdtemp(
+          import_node_path3.default.join(import_node_os3.default.tmpdir(), `nodelink-hls-${this.profile}-`)
+        );
+        this.createdTempDir = true;
+      } else {
+        await import_promises3.default.mkdir(this.outputDir, { recursive: true });
+      }
+      this.playlistPath = import_node_path3.default.join(this.outputDir, "playlist.m3u8");
+      this.segmentPattern = import_node_path3.default.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 HTTP stream server.
+   * Stop HLS streaming
    */
   async stop() {
-    for (const client of this.clients) {
-      if (!client.destroyed) {
-        client.end();
-      }
+    if (this.state === "idle" || this.state === "stopped") {
+      return;
     }
-    this.clients.clear();
+    this.state = "stopping";
+    this.log("info", "Stopping HLS stream");
     try {
-      await this.videoStream.stop();
+      this.ffmpeg?.stdin?.end();
     } catch {
     }
-    if (this.videoListener) {
-      this.videoStream.removeListener("videoAccessUnit", this.videoListener);
-      this.videoStream.removeListener("videoFrame", this.videoListener);
+    try {
+      this.ffmpeg?.kill("SIGKILL");
+    } catch {
     }
-    this.videoListener = void 0;
-    if (this.ffmpegProcess) {
-      const proc = this.ffmpegProcess;
+    this.ffmpeg = null;
+    if (this.nativeStream) {
       try {
-        proc.kill("SIGTERM");
+        await this.nativeStream.return(void 0);
       } catch {
       }
-      await new Promise((resolve) => {
-        const t = setTimeout(() => {
+      this.nativeStream = null;
+    }
+    if (this.pumpPromise) {
+      try {
+        await this.pumpPromise;
+      } catch {
+      }
+      this.pumpPromise = null;
+    }
+    if (this.createdTempDir && this.outputDir) {
+      try {
+        await import_promises3.default.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 (import_node_fs.default.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 = import_node_path3.default.join(this.outputDir, safe);
+    if (!import_node_fs.default.existsSync(filePath)) {
+      return null;
+    }
+    const data = await import_promises3.default.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 {
-            proc.kill("SIGKILL");
+            if (this.ffmpeg?.stdin && !this.ffmpeg.stdin.destroyed) {
+              for (const ps of pendingParamSets) {
+                this.ffmpeg.stdin.write(ps);
+              }
+            }
           } 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;
+        }
+        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);
     }
-    this.active = false;
   }
-  isActive() {
-    return this.active;
+  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 = (0, import_node_child_process10.spawn)(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;
   }
 };
 
@@ -29519,10 +32552,10 @@ async function autoDetectDeviceType(inputs) {
 }
 
 // src/multifocal/compositeRtspServer.ts
-var import_node_events7 = require("events");
-var import_node_child_process9 = require("child_process");
+var import_node_events11 = require("events");
+var import_node_child_process11 = require("child_process");
 var net3 = __toESM(require("net"), 1);
-var CompositeRtspServer = class extends import_node_events7.EventEmitter {
+var CompositeRtspServer = class extends import_node_events11.EventEmitter {
   options;
   compositeStream = null;
   rtspServer = null;
@@ -29627,7 +32660,7 @@ var CompositeRtspServer = class extends import_node_events7.EventEmitter {
     this.logger.log?.(
       `[CompositeRtspServer] Starting ffmpeg RTSP server: ${ffmpegArgs.join(" ")}`
     );
-    this.ffmpegProcess = (0, import_node_child_process9.spawn)("ffmpeg", ffmpegArgs, {
+    this.ffmpegProcess = (0, import_node_child_process11.spawn)("ffmpeg", ffmpegArgs, {
       stdio: ["pipe", "pipe", "pipe"]
     });
     this.ffmpegProcess.on("error", (error) => {
@@ -29840,9 +32873,12 @@ var CompositeRtspServer = class extends import_node_events7.EventEmitter {
   BaichuanClient,
   BaichuanEventEmitter,
   BaichuanFrameParser,
+  BaichuanHlsServer,
   BaichuanHttpStreamServer,
+  BaichuanMjpegServer,
   BaichuanRtspServer,
   BaichuanVideoStream,
+  BaichuanWebRTCServer,
   BcMediaAnnexBDecoder,
   BcMediaCodec,
   BcUdpStream,
@@ -29853,7 +32889,9 @@ var CompositeRtspServer = class extends import_node_events7.EventEmitter {
   DUAL_LENS_SINGLE_MOTION_MODELS,
   H264RtpDepacketizer,
   H265RtpDepacketizer,
+  HlsSessionManager,
   Intercom,
+  MjpegTransformer,
   NVR_HUB_EXACT_TYPES,
   NVR_HUB_MODEL_PATTERNS,
   ReolinkBaichuanApi,
@@ -29873,6 +32911,7 @@ var CompositeRtspServer = class extends import_node_events7.EventEmitter {
   buildBinaryExtensionXml,
   buildChannelExtensionXml,
   buildFloodlightManualXml,
+  buildHlsRedirectUrl,
   buildLoginXml,
   buildPreviewStopXml,
   buildPreviewStopXmlV11,
@@ -29900,6 +32939,7 @@ var CompositeRtspServer = class extends import_node_events7.EventEmitter {
   createDebugGateLogger,
   createDiagnosticsBundle,
   createLogger,
+  createMjpegBoundary,
   createNativeStream,
   createNullLogger,
   createReplayHttpServer,
@@ -29907,8 +32947,10 @@ var CompositeRtspServer = class extends import_node_events7.EventEmitter {
   createRfc4571TcpServerForReplay,
   createRtspProxyServer,
   createTaggedLogger,
+  decideVideoclipTranscodeMode,
   decodeHeader,
   deriveAesKey,
+  detectIosClient,
   detectVideoCodecFromNal,
   discoverReolinkDevices,
   discoverViaHttpScan,
@@ -29921,10 +32963,13 @@ var CompositeRtspServer = class extends import_node_events7.EventEmitter {
   extractSpsFromAnnexB,
   extractVpsFromAnnexB,
   flattenAbilitiesForChannel,
+  formatMjpegFrame,
   getConstructedVideoStreamOptions,
   getGlobalLogger,
   getH265NalType,
+  getMjpegContentType,
   getVideoStream,
+  getVideoclipClientInfo,
   getXmlText,
   hasH265StartCodes,
   hasStartCodes,