@apocaliss92/nodelink-js 0.1.7 → 0.1.9

package/dist/{chunk-JMT75JNG.js → chunk-YUBYINJF.js}

@@ -134,7 +134,7 @@ import {
   talkTraceLog,
   traceLog,
   xmlEscape
-} from "./chunk-MC2BRLLE.js";
+} from "./chunk-TZFZ5WJX.js";
 
 // src/protocol/framing.ts
 function encodeHeader(h) {
@@ -7701,10 +7701,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);
@@ -7731,6 +7736,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);
@@ -9028,6 +9036,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.
@@ -9137,22 +9149,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.
@@ -9215,14 +9240,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();
           });
         });
       }
@@ -9292,30 +9338,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,
@@ -9327,15 +9411,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.
@@ -9372,6 +9522,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 {
@@ -11227,7 +11380,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 {
@@ -11363,7 +11517,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 {
@@ -12410,11 +12565,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({
@@ -12425,7 +12589,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({
@@ -12436,7 +12606,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,
@@ -12448,6 +12624,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) : "";
@@ -14520,11 +14699,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);
@@ -15630,7 +15811,7 @@ ${xml}`
    * @returns Test results for all stream types and profiles
    */
   async testChannelStreams(channel, logger) {
-    const { testChannelStreams } = await import("./DiagnosticsTools-MTXG65O3.js");
+    const { testChannelStreams } = await import("./DiagnosticsTools-EC7DADEQ.js");
     return await testChannelStreams({
       api: this,
       channel: this.normalizeChannel(channel),
@@ -15646,7 +15827,7 @@ ${xml}`
    * @returns Complete diagnostics for all channels and streams
    */
   async collectMultifocalDiagnostics(logger) {
-    const { collectMultifocalDiagnostics } = await import("./DiagnosticsTools-MTXG65O3.js");
+    const { collectMultifocalDiagnostics } = await import("./DiagnosticsTools-EC7DADEQ.js");
     return await collectMultifocalDiagnostics({
       api: this,
       logger
@@ -16666,11 +16847,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,
@@ -16679,39 +16862,84 @@ ${scheduleItems}
       ...params.isNvr != null ? { isNvr: params.isNvr } : {},
       ...params.deviceId != null ? { deviceId: params.deviceId } : {}
     };
-    const { result: replayResult, release: releaseQueueSlot } = await this.enqueueStreamingReplayOperation(
-      () => this.startRecordingReplayStream(startParams)
-    );
+    const { result: replayResult, release: releaseQueueSlot } = await this.enqueueStreamingReplayOperation(async () => {
+      try {
+        return await this.startRecordingReplayStream(startParams);
+      } catch (e) {
+        if (!params.deviceId) throw e;
+        const sessionKey = `replay:${params.deviceId}`;
+        logger?.debug?.(
+          `[createRecordingReplayMp4Stream] startRecordingReplayStream failed; force-closing dedicated client and retrying once`
+        );
+        await this.forceCloseDedicatedClient(sessionKey, logger);
+        return await this.startRecordingReplayStream(startParams);
+      }
+    });
     const { stream, stop: stopReplay } = replayResult;
     const input = new PassThrough();
     const output = new PassThrough();
+    const H264_AUD = Buffer.from([0, 0, 0, 1, 9, 240]);
     let tsMuxer = null;
     let ff = null;
     let ended = false;
     let frameCount = 0;
     const startFfmpeg = (videoType) => {
       if (ff) return;
+      const needsTranscode = videoType === "H265" && params.transcodeH265ToH264 === true;
       logger?.debug?.(
-        `[createRecordingReplayMp4Stream] Starting ffmpeg with videoType=${videoType}`
+        `[createRecordingReplayMp4Stream] Starting ffmpeg with videoType=${videoType}, transcode=${needsTranscode}, useMpegTsMuxer=${useMpegTsMuxer}, fps=${fps}`
       );
-      MpegTsMuxer.resetCounters();
-      tsMuxer = new MpegTsMuxer({ videoType });
-      const args = [
-        "-hide_banner",
-        "-loglevel",
-        "error",
-        "-f",
-        "mpegts",
-        "-i",
-        "pipe:0",
-        "-c",
-        "copy",
-        "-movflags",
-        "frag_keyframe+empty_moov",
-        "-f",
-        "mp4",
-        "pipe:1"
-      ];
+      let args;
+      if (useMpegTsMuxer) {
+        MpegTsMuxer.resetCounters();
+        tsMuxer = new MpegTsMuxer({ videoType });
+        args = [
+          "-hide_banner",
+          "-loglevel",
+          "error",
+          "-f",
+          "mpegts",
+          "-i",
+          "pipe:0",
+          // Video codec: transcode H.265→H.264 if requested, otherwise copy
+          ...needsTranscode ? ["-c:v", "libx264", "-preset", "ultrafast", "-crf", "23"] : ["-c", "copy"],
+          // frag_keyframe: create new fragment at each keyframe
+          // empty_moov: write ftyp/moov immediately (required for streaming)
+          // default_base_moof: required for iOS Media Source Extensions
+          // negative_cts_offsets: fixes some iOS playback issues
+          "-movflags",
+          "frag_keyframe+empty_moov+default_base_moof+negative_cts_offsets",
+          "-f",
+          "mp4",
+          "pipe:1"
+        ];
+      } else {
+        const inputFormat = videoType === "H265" ? "hevc" : "h264";
+        args = [
+          "-hide_banner",
+          "-loglevel",
+          "error",
+          "-fflags",
+          "+genpts",
+          "-r",
+          String(fps),
+          "-f",
+          inputFormat,
+          "-i",
+          "pipe:0",
+          // Video codec: transcode H.265→H.264 if requested, otherwise copy
+          ...needsTranscode ? ["-c:v", "libx264", "-preset", "ultrafast", "-crf", "23"] : ["-c", "copy"],
+          // frag_keyframe: create new fragment at each keyframe
+          // empty_moov: write ftyp/moov immediately (required for streaming)
+          // default_base_moof: required for iOS Media Source Extensions
+          // negative_cts_offsets: fixes some iOS playback issues
+          "-movflags",
+          "frag_keyframe+empty_moov+default_base_moof+negative_cts_offsets",
+          "-f",
+          "mp4",
+          "pipe:1"
+        ];
+      }
       ff = spawn2("ffmpeg", args, { stdio: ["pipe", "pipe", "pipe"] });
       if (!ff.stdin || !ff.stdout || !ff.stderr) {
         throw new Error("ffmpeg stdio streams not available");
@@ -16749,17 +16977,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 {
@@ -16772,7 +17002,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(
       () => {
@@ -16794,15 +17028,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);
         }
       }
     );
@@ -16841,19 +17085,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 PassThrough();
     const output = new PassThrough();
     let ff = null;
@@ -16925,6 +17203,338 @@ ${scheduleItems}
       stop: stopAll
     };
   }
+  /**
+   * Create an HLS (HTTP Live Streaming) session for a recording.
+   *
+   * 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 session = await api.createRecordingReplayHlsSession({
+   *   channel: 0,
+   *   fileName: "/mnt/sda/Mp4Record/2026-01-25/RecS03.mp4",
+   * });
+   *
+   * // Serve playlist
+   * app.get('/clip.m3u8', (req, res) => {
+   *   res.type('application/vnd.apple.mpegurl');
+   *   res.send(session.getPlaylist());
+   * });
+   *
+   * // 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 createRecordingReplayHlsSession(params) {
+    const logger = params.logger ?? this.logger;
+    const hlsSegmentDuration = params.hlsSegmentDuration ?? 4;
+    const os = await import("os");
+    const path = await import("path");
+    const fs = await import("fs/promises");
+    const crypto2 = await import("crypto");
+    const tempDir = path.join(
+      os.tmpdir(),
+      `reolink-hls-${crypto2.randomBytes(8).toString("hex")}`
+    );
+    await fs.mkdir(tempDir, { recursive: true });
+    const playlistPath = path.join(tempDir, "playlist.m3u8");
+    const segmentPattern = path.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 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 = path.join(tempDir, "segment_000.ts");
+      let checkCount = 0;
+      const maxChecks = Math.ceil((hlsSegmentDuration + 2) * 10);
+      segmentWatcher = setInterval(async () => {
+        checkCount++;
+        try {
+          const stats = await fs.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 = spawn2("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 fs.readdir(tempDir);
+          for (const file of files) {
+            await fs.unlink(path.join(tempDir, file)).catch(() => {
+            });
+          }
+          await fs.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 = path.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
   // ============================================================
@@ -18066,4 +18676,4 @@ export {
   isTcpFailureThatShouldFallbackToUdp,
   autoDetectDeviceType
 };
-//# sourceMappingURL=chunk-JMT75JNG.js.map
+//# sourceMappingURL=chunk-YUBYINJF.js.map