@apocaliss92/nodelink-js 0.1.8 → 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: spawn11 } = 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 = spawn11(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,6 +7377,7 @@ __export(index_exports, {
   BaichuanClient: () => BaichuanClient,
   BaichuanEventEmitter: () => BaichuanEventEmitter,
   BaichuanFrameParser: () => BaichuanFrameParser,
+  BaichuanHlsServer: () => BaichuanHlsServer,
   BaichuanHttpStreamServer: () => BaichuanHttpStreamServer,
   BaichuanMjpegServer: () => BaichuanMjpegServer,
   BaichuanRtspServer: () => BaichuanRtspServer,
@@ -7330,6 +7393,7 @@ __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,
@@ -7351,6 +7415,7 @@ __export(index_exports, {
   buildBinaryExtensionXml: () => buildBinaryExtensionXml,
   buildChannelExtensionXml: () => buildChannelExtensionXml,
   buildFloodlightManualXml: () => buildFloodlightManualXml,
+  buildHlsRedirectUrl: () => buildHlsRedirectUrl,
   buildLoginXml: () => buildLoginXml,
   buildPreviewStopXml: () => buildPreviewStopXml,
   buildPreviewStopXmlV11: () => buildPreviewStopXmlV11,
@@ -7389,6 +7454,7 @@ __export(index_exports, {
   decideVideoclipTranscodeMode: () => decideVideoclipTranscodeMode,
   decodeHeader: () => decodeHeader,
   deriveAesKey: () => deriveAesKey,
+  detectIosClient: () => detectIosClient,
   detectVideoCodecFromNal: () => detectVideoCodecFromNal,
   discoverReolinkDevices: () => discoverReolinkDevices,
   discoverViaHttpScan: () => discoverViaHttpScan,
@@ -7719,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) {
@@ -7747,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) {
@@ -7795,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) {
@@ -12720,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([
@@ -12733,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})`
               );
@@ -12914,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}`
       );
@@ -13571,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(
@@ -13603,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(
@@ -13764,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();
         }
       },
@@ -15059,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);
@@ -15089,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);
@@ -16403,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.
@@ -16512,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.
@@ -16590,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();
           });
         });
       }
@@ -16667,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,
@@ -16702,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.
@@ -16747,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 {
@@ -18602,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 {
@@ -18738,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 {
@@ -19785,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({
@@ -19800,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({
@@ -19811,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,
@@ -19823,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) : "";
@@ -20118,7 +20363,7 @@ ${stderr}`)
    * Convert a raw video keyframe to JPEG using ffmpeg.
    */
   async convertFrameToJpeg(params) {
-    const { spawn: spawn11 } = 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) => {
@@ -20140,7 +20385,7 @@ ${stderr}`)
         "2",
         "pipe:1"
       ];
-      const proc = spawn11(ffmpeg, args, {
+      const proc = spawn12(ffmpeg, args, {
         stdio: ["pipe", "pipe", "pipe"]
       });
       const chunks = [];
@@ -20283,26 +20528,26 @@ ${stderr}`)
    * Internal helper to mux video+audio into MP4 using ffmpeg.
    */
   async muxToMp4(params) {
-    const { spawn: spawn11 } = 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) {
@@ -20335,7 +20580,7 @@ ${stderr}`)
         outputPath
       );
       await new Promise((resolve, reject) => {
-        const p = spawn11(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();
@@ -20355,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(() => {
       });
     }
   }
@@ -21895,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);
@@ -24041,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,
@@ -24054,12 +24303,23 @@ ${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;
@@ -24068,26 +24328,59 @@ ${scheduleItems}
       if (ff) return;
       const needsTranscode = videoType === "H265" && params.transcodeH265ToH264 === true;
       logger?.debug?.(
-        `[createRecordingReplayMp4Stream] Starting ffmpeg with videoType=${videoType}, transcode=${needsTranscode}`
+        `[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",
-        // Video codec: transcode H.265→H.264 if requested, otherwise copy
-        ...needsTranscode ? ["-c:v", "libx264", "-preset", "ultrafast", "-crf", "23"] : ["-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");
@@ -24125,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 {
@@ -24148,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(
       () => {
@@ -24170,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);
         }
       }
     );
@@ -24217,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;
@@ -24301,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
@@ -24539,6 +25214,364 @@ ${scheduleItems}
   }
 };
 
+// src/reolink/baichuan/HlsSessionManager.ts
+var withTimeout = async (p, ms, label) => {
+  let t;
+  try {
+    return await Promise.race([
+      p,
+      new Promise((_, reject) => {
+        t = setTimeout(
+          () => reject(new Error(`${label} timed out after ${ms}ms`)),
+          ms
+        );
+      })
+    ]);
+  } finally {
+    if (t) clearTimeout(t);
+  }
+};
+var HlsSessionManager = class {
+  constructor(api, options) {
+    this.api = api;
+    this.logger = options?.logger;
+    this.sessionTtlMs = options?.sessionTtlMs ?? 5 * 60 * 1e3;
+    const cleanupIntervalMs = options?.cleanupIntervalMs ?? 3e4;
+    this.cleanupTimer = setInterval(() => {
+      void this.cleanupExpiredSessions();
+    }, cleanupIntervalMs);
+  }
+  sessions = /* @__PURE__ */ new Map();
+  logger;
+  sessionTtlMs;
+  cleanupTimer;
+  creationLocks = /* @__PURE__ */ new Map();
+  /**
+   * Handle an HLS request and return the HTTP response.
+   *
+   * @param params - Request parameters
+   * @returns HTTP response ready to be sent
+   */
+  async handleRequest(params) {
+    const {
+      sessionKey,
+      hlsPath,
+      requestUrl,
+      createSession,
+      exclusiveKeyPrefix
+    } = params;
+    try {
+      let entry = this.sessions.get(sessionKey);
+      const isPlaylist = hlsPath === "playlist.m3u8" || hlsPath === "";
+      const isSegment = hlsPath.endsWith(".ts");
+      if (!entry && isSegment) {
+        this.logger?.debug?.(
+          `[HlsSessionManager] Segment request without session (likely stale after clip switch): ${sessionKey} ${hlsPath}`
+        );
+        return {
+          statusCode: 404,
+          headers: {
+            "Content-Type": "text/plain",
+            "Cache-Control": "no-store, no-cache, must-revalidate, max-age=0",
+            Pragma: "no-cache",
+            "Retry-After": "1"
+          },
+          body: "Segment not found"
+        };
+      }
+      if (!entry) {
+        if (!isPlaylist) {
+          return {
+            statusCode: 400,
+            headers: { "Content-Type": "text/plain" },
+            body: "Invalid HLS path"
+          };
+        }
+        const lockKey = exclusiveKeyPrefix ?? sessionKey;
+        await this.withCreationLock(lockKey, async () => {
+          entry = this.sessions.get(sessionKey);
+          if (entry) return;
+          if (exclusiveKeyPrefix) {
+            await this.stopOtherSessionsWithPrefix(
+              exclusiveKeyPrefix,
+              sessionKey
+            );
+          }
+          this.logger?.log?.(
+            `[HlsSessionManager] Creating new session: ${sessionKey}`
+          );
+          this.logger?.debug?.(
+            `[HlsSessionManager] createSession(): ${sessionKey}`
+          );
+          const sessionParams = await createSession();
+          this.logger?.debug?.(
+            `[HlsSessionManager] Starting createRecordingReplayHlsSession: ${sessionKey}`
+          );
+          const session = await withTimeout(
+            this.api.createRecordingReplayHlsSession({
+              channel: sessionParams.channel,
+              fileName: sessionParams.fileName,
+              ...sessionParams.isNvr !== void 0 && {
+                isNvr: sessionParams.isNvr
+              },
+              ...this.logger && { logger: this.logger },
+              ...sessionParams.deviceId && {
+                deviceId: sessionParams.deviceId
+              },
+              transcodeH265ToH264: sessionParams.transcodeH265ToH264 ?? true,
+              hlsSegmentDuration: sessionParams.hlsSegmentDuration ?? 4
+            }),
+            2e4,
+            "createRecordingReplayHlsSession"
+          );
+          try {
+            await withTimeout(
+              session.waitForReady(),
+              12e3,
+              "hls waitForReady"
+            );
+          } catch (e) {
+            this.logger?.warn?.(
+              `[HlsSessionManager] waitForReady did not complete in time for ${sessionKey}: ${e instanceof Error ? e.message : String(e)}`
+            );
+          }
+          entry = {
+            session,
+            createdAt: Date.now(),
+            lastAccessAt: Date.now()
+          };
+          this.sessions.set(sessionKey, entry);
+          this.logger?.log?.(
+            `[HlsSessionManager] Session ready: ${sessionKey}`
+          );
+        });
+        entry = this.sessions.get(sessionKey);
+        if (!entry) {
+          return {
+            statusCode: 500,
+            headers: {
+              "Content-Type": "text/plain",
+              "Cache-Control": "no-store, no-cache, must-revalidate, max-age=0",
+              Pragma: "no-cache"
+            },
+            body: "HLS session was not created"
+          };
+        }
+      }
+      entry.lastAccessAt = Date.now();
+      if (isPlaylist) {
+        return this.servePlaylist(entry.session, requestUrl, sessionKey);
+      }
+      if (isSegment) {
+        return this.serveSegment(entry.session, hlsPath, sessionKey);
+      }
+      return {
+        statusCode: 400,
+        headers: { "Content-Type": "text/plain" },
+        body: "Invalid HLS path"
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger?.error?.(
+        `[HlsSessionManager] Error handling request: ${message}`
+      );
+      return {
+        statusCode: 500,
+        headers: { "Content-Type": "text/plain" },
+        body: `HLS error: ${message}`
+      };
+    }
+  }
+  async withCreationLock(lockKey, fn) {
+    const prev = this.creationLocks.get(lockKey) ?? Promise.resolve();
+    let release;
+    const current = new Promise((resolve) => {
+      release = resolve;
+    });
+    const chained = prev.then(
+      () => current,
+      () => current
+    );
+    this.creationLocks.set(lockKey, chained);
+    await prev.catch(() => {
+    });
+    try {
+      await fn();
+    } finally {
+      release();
+      if (this.creationLocks.get(lockKey) === chained) {
+        this.creationLocks.delete(lockKey);
+      }
+    }
+  }
+  /**
+   * Check if a session exists for the given key.
+   */
+  hasSession(sessionKey) {
+    return this.sessions.has(sessionKey);
+  }
+  /**
+   * Stop a specific session.
+   */
+  async stopSession(sessionKey) {
+    const entry = this.sessions.get(sessionKey);
+    if (entry) {
+      this.logger?.debug?.(
+        `[HlsSessionManager] Stopping session: ${sessionKey}`
+      );
+      this.sessions.delete(sessionKey);
+      await entry.session.stop().catch(() => {
+      });
+    }
+  }
+  /**
+   * Stop all sessions and cleanup.
+   */
+  async stopAll() {
+    this.logger?.debug?.(`[HlsSessionManager] Stopping all sessions`);
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = void 0;
+    }
+    const stopPromises = Array.from(this.sessions.values()).map(
+      (entry) => entry.session.stop().catch(() => {
+      })
+    );
+    this.sessions.clear();
+    await Promise.all(stopPromises);
+  }
+  /**
+   * Get the number of active sessions.
+   */
+  get sessionCount() {
+    return this.sessions.size;
+  }
+  /**
+   * Serve the HLS playlist with rewritten segment URLs.
+   */
+  servePlaylist(session, requestUrl, sessionKey) {
+    let playlist = session.getPlaylist();
+    try {
+      const url = new URL(requestUrl, "http://localhost");
+      const basePath = url.pathname;
+      const baseParams = new URLSearchParams(url.searchParams);
+      baseParams.delete("hls");
+      playlist = playlist.replace(/^(segment_\d+\.ts)$/gm, (match) => {
+        const params = new URLSearchParams(baseParams);
+        params.set("hls", match);
+        return `${basePath}?${params.toString()}`;
+      });
+    } catch {
+    }
+    this.logger?.debug?.(
+      `[HlsSessionManager] Serving playlist: ${sessionKey}, length=${playlist.length}`
+    );
+    return {
+      statusCode: 200,
+      headers: {
+        "Content-Type": "application/vnd.apple.mpegurl",
+        "Cache-Control": "no-store, no-cache, must-revalidate, max-age=0",
+        Pragma: "no-cache"
+      },
+      body: playlist
+    };
+  }
+  /**
+   * Serve an HLS segment.
+   */
+  serveSegment(session, segmentName, sessionKey) {
+    const segment = session.getSegment(segmentName);
+    if (!segment) {
+      this.logger?.warn?.(
+        `[HlsSessionManager] Segment not found: ${segmentName}`
+      );
+      return {
+        statusCode: 404,
+        headers: {
+          "Content-Type": "text/plain",
+          "Cache-Control": "no-store, no-cache, must-revalidate, max-age=0",
+          Pragma: "no-cache",
+          "Retry-After": "1"
+        },
+        body: "Segment not found"
+      };
+    }
+    this.logger?.debug?.(
+      `[HlsSessionManager] Serving segment: ${segmentName} for ${sessionKey}, size=${segment.length}`
+    );
+    return {
+      statusCode: 200,
+      headers: {
+        "Content-Type": "video/mp2t",
+        "Cache-Control": "no-store, no-cache, must-revalidate, max-age=0",
+        Pragma: "no-cache",
+        "Content-Length": String(segment.length)
+      },
+      body: segment
+    };
+  }
+  /**
+   * Cleanup expired sessions.
+   */
+  async cleanupExpiredSessions() {
+    const now = Date.now();
+    const expiredKeys = [];
+    for (const [key, entry] of this.sessions) {
+      if (now - entry.lastAccessAt > this.sessionTtlMs) {
+        expiredKeys.push(key);
+      }
+    }
+    if (!expiredKeys.length) return;
+    await Promise.allSettled(
+      expiredKeys.map(async (key) => {
+        const entry = this.sessions.get(key);
+        if (!entry) return;
+        this.logger?.log?.(
+          `[HlsSessionManager] TTL expired: stopping session ${key}`
+        );
+        this.sessions.delete(key);
+        try {
+          await entry.session.stop();
+        } catch {
+        }
+      })
+    );
+  }
+  async stopOtherSessionsWithPrefix(prefix, exceptKey) {
+    const toStop = [];
+    for (const key of this.sessions.keys()) {
+      if (key !== exceptKey && key.startsWith(prefix)) toStop.push(key);
+    }
+    if (!toStop.length) return;
+    this.logger?.log?.(
+      `[HlsSessionManager] Switch: stopping ${toStop.length} session(s) for prefix=${prefix}`
+    );
+    await Promise.all(
+      toStop.map(async (key) => {
+        const entry = this.sessions.get(key);
+        if (!entry) return;
+        this.sessions.delete(key);
+        await entry.session.stop().catch(() => {
+        });
+      })
+    );
+  }
+};
+function detectIosClient(userAgent) {
+  const ua = (userAgent ?? "").toLowerCase();
+  const isIos = /iphone|ipad|ipod/.test(ua);
+  const isIosInstalledApp = ua.includes("installedapp");
+  return {
+    isIos,
+    isIosInstalledApp,
+    // iOS InstalledApp needs HLS for video playback
+    needsHls: isIos && isIosInstalledApp
+  };
+}
+function buildHlsRedirectUrl(originalUrl) {
+  return `${originalUrl}${originalUrl.includes("?") ? "&" : "?"}hls=playlist.m3u8`;
+}
+
 // src/reolink/discovery.ts
 var import_node_dgram2 = __toESM(require("dgram"), 1);
 var import_node_os2 = require("os");
@@ -25314,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;
@@ -25344,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();
@@ -25389,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();
@@ -29357,9 +30442,9 @@ var BaichuanMjpegServer = class extends import_node_events8.EventEmitter {
     this.started = true;
     const port = this.options.port ?? 8080;
     const host = this.options.host ?? "0.0.0.0";
-    const path5 = this.options.path ?? "/mjpeg";
+    const path6 = this.options.path ?? "/mjpeg";
     this.httpServer = http5.createServer((req, res) => {
-      this.handleRequest(req, res, path5);
+      this.handleRequest(req, res, path6);
     });
     return new Promise((resolve, reject) => {
       this.httpServer.on("error", (err) => {
@@ -29369,9 +30454,9 @@ var BaichuanMjpegServer = class extends import_node_events8.EventEmitter {
       this.httpServer.listen(port, host, () => {
         this.log(
           "info",
-          `MJPEG server started on http://${host}:${port}${path5}`
+          `MJPEG server started on http://${host}:${port}${path6}`
         );
-        this.emit("started", { host, port, path: path5 });
+        this.emit("started", { host, port, path: path6 });
         resolve();
       });
     });
@@ -29617,6 +30702,8 @@ var BaichuanMjpegServer = class extends import_node_events8.EventEmitter {
 
 // src/baichuan/stream/BaichuanWebRTCServer.ts
 var import_node_events9 = require("events");
+init_BcMediaAnnexBDecoder();
+init_H264Converter();
 function parseAnnexBNalUnits(annexB) {
   const nalUnits = [];
   let offset = 0;
@@ -29738,10 +30825,16 @@ Error: ${err}`
       }
     };
     this.sessions.set(sessionId, session);
-    const videoTrack = new MediaStreamTrack({ kind: "video" });
-    peerConnection.addTrack(videoTrack);
+    const videoSsrc = Math.random() * 4294967295 >>> 0;
+    const videoTrack = new MediaStreamTrack({ kind: "video", ssrc: videoSsrc });
+    const videoSender = peerConnection.addTrack(videoTrack);
     session.videoTrack = videoTrack;
-    const audioTrack = new MediaStreamTrack({ kind: "audio" });
+    this.log(
+      "info",
+      `Video track created: ssrc=${videoTrack.ssrc}, sender params=${JSON.stringify(videoSender?.getParameters?.() ?? {})}`
+    );
+    const audioSsrc = Math.random() * 4294967295 >>> 0;
+    const audioTrack = new MediaStreamTrack({ kind: "audio", ssrc: audioSsrc });
     peerConnection.addTrack(audioTrack);
     session.audioTrack = audioTrack;
     const videoDataChannel = peerConnection.createDataChannel("video", {
@@ -29785,11 +30878,11 @@ Error: ${err}`
       };
     }
     peerConnection.iceConnectionStateChange.subscribe((state) => {
-      this.log("debug", `ICE connection state for ${sessionId}: ${state}`);
+      this.log("info", `ICE connection state for ${sessionId}: ${state}`);
       if (state === "connected") {
         session.state = "connected";
         this.emit("session-connected", { sessionId });
-      } else if (state === "disconnected" || state === "failed") {
+      } else if (state === "failed") {
         session.state = state;
         this.closeSession(sessionId).catch((err) => {
           this.log("error", `Error closing session on ICE ${state}: ${err}`);
@@ -30009,7 +31102,8 @@ Error: ${err}`
         } else {
           if (frame.data) {
             if (!session.videoCodec && frame.videoType) {
-              session.videoCodec = frame.videoType;
+              const detected = detectVideoCodecFromNal(frame.data);
+              session.videoCodec = detected ?? frame.videoType;
               this.log("info", `Detected video codec: ${session.videoCodec}`);
               if (session.videoDataChannel && session.videoDataChannel.readyState === "open") {
                 const codecInfo = JSON.stringify({
@@ -30032,22 +31126,45 @@ Error: ${err}`
             }
             lastTimeMicros = frame.microseconds || 0;
             if (session.videoCodec === "H264") {
-              await this.sendH264Frame(
+              const connState = session.peerConnection.connectionState;
+              const iceState = session.peerConnection.iceConnectionState;
+              const isConnected = connState === "connected" || iceState === "connected" || iceState === "completed";
+              if (!isConnected) {
+                if (frameNumber < 10) {
+                  this.log(
+                    "debug",
+                    `Waiting for connection, dropping H.264 frame ${frameNumber}`
+                  );
+                }
+                frameNumber++;
+                continue;
+              }
+              const packetsSent = await this.sendH264Frame(
                 session,
                 werift,
                 frame.data,
                 sequenceNumber,
                 timestamp
               );
-              sequenceNumber = sequenceNumber + Math.ceil(frame.data.length / 1200) & 65535;
-              packetsSentSinceLastLog++;
+              sequenceNumber = sequenceNumber + packetsSent & 65535;
+              packetsSentSinceLastLog += packetsSent;
+              frameNumber++;
+              session.stats.videoFrames++;
+              session.stats.bytesSent += frame.data.length;
             } else if (session.videoCodec === "H265") {
-              await this.sendH265Frame(session, frame, frameNumber);
-              packetsSentSinceLastLog++;
+              const sent = await this.sendVideoFrameViaDataChannel(
+                session,
+                frame,
+                frameNumber,
+                "H265"
+              );
+              if (sent) {
+                packetsSentSinceLastLog++;
+                frameNumber++;
+                session.stats.videoFrames++;
+                session.stats.bytesSent += frame.data.length;
+              }
             }
-            frameNumber++;
-            session.stats.videoFrames++;
-            session.stats.bytesSent += frame.data.length;
             const now = Date.now();
             if (now - lastLogTime >= 5e3) {
               this.log(
@@ -30060,36 +31177,321 @@ Error: ${err}`
           }
         }
       }
-    } catch (err) {
+    } 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(
-        "error",
-        `Error pumping frames for session ${session.id}: ${err}`
+        "info",
+        `Sending ${codec} frame ${frameNumber}: ${packet.length} bytes, keyframe=${isKeyframe}`
       );
     }
-    this.log("info", `Native stream ended for session ${session.id}`);
-  }
-  /**
-   * Send H.264 frame via RTP media track
-   */
-  async sendH264Frame(session, werift, frameData, sequenceNumber, timestamp) {
-    const nalUnits = parseAnnexBNalUnits(frameData);
-    for (let i = 0; i < nalUnits.length; i++) {
-      const nalUnit = nalUnits[i];
-      if (nalUnit.length === 0) continue;
-      const isLastNalu = i === nalUnits.length - 1;
-      const nalType = getH264NalType(nalUnit);
-      if (nalType === 9) continue;
-      const rtpPackets = this.createH264RtpPackets(
-        werift,
-        nalUnit,
-        sequenceNumber,
-        timestamp,
-        isLastNalu
-      );
-      for (const rtpPacket of rtpPackets) {
-        session.videoTrack.writeRtp(rtpPacket);
-        sequenceNumber = sequenceNumber + 1 & 65535;
+    const MAX_CHUNK_SIZE = 16e3;
+    try {
+      if (packet.length <= MAX_CHUNK_SIZE) {
+        session.videoDataChannel.send(packet);
+      } else {
+        const totalChunks = Math.ceil(packet.length / MAX_CHUNK_SIZE);
+        for (let i = 0; i < totalChunks; i++) {
+          const start = i * MAX_CHUNK_SIZE;
+          const end = Math.min(start + MAX_CHUNK_SIZE, packet.length);
+          const chunk = packet.subarray(start, end);
+          const chunkHeader = Buffer.alloc(2);
+          chunkHeader.writeUInt8(i, 0);
+          chunkHeader.writeUInt8(totalChunks, 1);
+          session.videoDataChannel.send(Buffer.concat([chunkHeader, chunk]));
+        }
       }
+      return true;
+    } catch (err) {
+      this.log("error", `Error sending ${codec} frame ${frameNumber}: ${err}`);
+      return false;
     }
   }
   /**
@@ -30162,7 +31564,7 @@ Error: ${err}`
    * Create RTP packets for H.264 NAL unit
    * Handles single NAL, STAP-A aggregation, and FU-A fragmentation
    */
-  createH264RtpPackets(werift, nalUnit, sequenceNumber, timestamp, marker) {
+  createH264RtpPackets(werift, nalUnit, sequenceNumber, timestamp, marker, ssrc) {
     const { RtpPacket, RtpHeader } = werift;
     const MTU = 1200;
     const packets = [];
@@ -30172,6 +31574,7 @@ Error: ${err}`
       header.sequenceNumber = sequenceNumber;
       header.timestamp = timestamp;
       header.marker = marker;
+      header.ssrc = ssrc;
       packets.push(new RtpPacket(header, nalUnit));
     } else {
       const nalHeader = nalUnit[0];
@@ -30196,6 +31599,7 @@ Error: ${err}`
         header.sequenceNumber = sequenceNumber + packets.length & 65535;
         header.timestamp = timestamp;
         header.marker = isLast && marker;
+        header.ssrc = ssrc;
         packets.push(new RtpPacket(header, fuPayload));
         offset += chunkSize;
         isFirst = false;
@@ -30232,6 +31636,448 @@ Error: ${err}`
   }
 };
 
+// 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 ?? (() => {
+    });
+  }
+  /**
+   * Start HLS streaming
+   */
+  async start() {
+    if (this.state === "running" || this.state === "starting") {
+      return;
+    }
+    this.state = "starting";
+    this.lastError = null;
+    try {
+      if (!this.outputDir) {
+        this.outputDir = await 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 HLS streaming
+   */
+  async stop() {
+    if (this.state === "idle" || this.state === "stopped") {
+      return;
+    }
+    this.state = "stopping";
+    this.log("info", "Stopping HLS stream");
+    try {
+      this.ffmpeg?.stdin?.end();
+    } catch {
+    }
+    try {
+      this.ffmpeg?.kill("SIGKILL");
+    } catch {
+    }
+    this.ffmpeg = null;
+    if (this.nativeStream) {
+      try {
+        await this.nativeStream.return(void 0);
+      } catch {
+      }
+      this.nativeStream = null;
+    }
+    if (this.pumpPromise) {
+      try {
+        await this.pumpPromise;
+      } catch {
+      }
+      this.pumpPromise = null;
+    }
+    if (this.createdTempDir && this.outputDir) {
+      try {
+        await 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 {
+            if (this.ffmpeg?.stdin && !this.ffmpeg.stdin.destroyed) {
+              for (const ps of pendingParamSets) {
+                this.ffmpeg.stdin.write(ps);
+              }
+            }
+          } catch {
+          }
+        }
+        if (!this.ffmpeg || !this.ffmpeg.stdin || this.ffmpeg.stdin.destroyed) {
+          this.log("warn", "ffmpeg stdin not available, stopping pump");
+          break;
+        }
+        try {
+          this.ffmpeg.stdin.write(annexB);
+          if (this.framesReceived % 100 === 0 || this.framesReceived <= 5 || this.framesReceived <= 50 && this.framesReceived % 10 === 0) {
+            this.log(
+              "debug",
+              `HLS fed frame #${this.framesReceived} to ffmpeg (${annexB.length} bytes)`
+            );
+          }
+        } catch (err) {
+          this.log("error", `Failed to write to ffmpeg: ${err}`);
+          break;
+        }
+      }
+    } catch (e) {
+      this.log("error", `HLS pump error: ${e}`);
+      this.lastError = String(e);
+      this.state = "error";
+      this.emit("error", e);
+    }
+  }
+  spawnFfmpeg() {
+    if (!this.playlistPath || !this.segmentPattern) {
+      throw new Error("Playlist path not set");
+    }
+    const codec = this.codec ?? "h264";
+    const args = [
+      "-hide_banner",
+      "-loglevel",
+      "warning",
+      "-fflags",
+      "+genpts",
+      "-use_wallclock_as_timestamps",
+      "1",
+      "-r",
+      "25",
+      "-f",
+      codec === "h265" ? "hevc" : "h264",
+      "-i",
+      "pipe:0"
+    ];
+    if (codec === "h265") {
+      args.push(
+        "-c:v",
+        "libx264",
+        "-preset",
+        "veryfast",
+        "-tune",
+        "zerolatency",
+        "-pix_fmt",
+        "yuv420p"
+      );
+    } else {
+      args.push("-c:v", "copy");
+    }
+    args.push(
+      "-f",
+      "hls",
+      "-hls_time",
+      String(this.segmentDuration),
+      "-hls_list_size",
+      String(this.playlistSize),
+      "-hls_flags",
+      "delete_segments+append_list+omit_endlist",
+      "-hls_segment_filename",
+      this.segmentPattern,
+      this.playlistPath
+    );
+    const p = (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;
+  }
+};
+
 // src/index.ts
 init_BcMediaParser();
 init_BcMediaCodec();
@@ -30706,10 +32552,10 @@ async function autoDetectDeviceType(inputs) {
 }
 
 // src/multifocal/compositeRtspServer.ts
-var import_node_events10 = require("events");
-var import_node_child_process10 = 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_events10.EventEmitter {
+var CompositeRtspServer = class extends import_node_events11.EventEmitter {
   options;
   compositeStream = null;
   rtspServer = null;
@@ -30814,7 +32660,7 @@ var CompositeRtspServer = class extends import_node_events10.EventEmitter {
     this.logger.log?.(
       `[CompositeRtspServer] Starting ffmpeg RTSP server: ${ffmpegArgs.join(" ")}`
     );
-    this.ffmpegProcess = (0, import_node_child_process10.spawn)("ffmpeg", ffmpegArgs, {
+    this.ffmpegProcess = (0, import_node_child_process11.spawn)("ffmpeg", ffmpegArgs, {
       stdio: ["pipe", "pipe", "pipe"]
     });
     this.ffmpegProcess.on("error", (error) => {
@@ -31027,6 +32873,7 @@ var CompositeRtspServer = class extends import_node_events10.EventEmitter {
   BaichuanClient,
   BaichuanEventEmitter,
   BaichuanFrameParser,
+  BaichuanHlsServer,
   BaichuanHttpStreamServer,
   BaichuanMjpegServer,
   BaichuanRtspServer,
@@ -31042,6 +32889,7 @@ var CompositeRtspServer = class extends import_node_events10.EventEmitter {
   DUAL_LENS_SINGLE_MOTION_MODELS,
   H264RtpDepacketizer,
   H265RtpDepacketizer,
+  HlsSessionManager,
   Intercom,
   MjpegTransformer,
   NVR_HUB_EXACT_TYPES,
@@ -31063,6 +32911,7 @@ var CompositeRtspServer = class extends import_node_events10.EventEmitter {
   buildBinaryExtensionXml,
   buildChannelExtensionXml,
   buildFloodlightManualXml,
+  buildHlsRedirectUrl,
   buildLoginXml,
   buildPreviewStopXml,
   buildPreviewStopXmlV11,
@@ -31101,6 +32950,7 @@ var CompositeRtspServer = class extends import_node_events10.EventEmitter {
   decideVideoclipTranscodeMode,
   decodeHeader,
   deriveAesKey,
+  detectIosClient,
   detectVideoCodecFromNal,
   discoverReolinkDevices,
   discoverViaHttpScan,