@apocaliss92/nodelink-js 0.6.4 → 0.6.5

package/dist/cli/rtsp-server.cjs

@@ -4635,12 +4635,12 @@ var init_ReolinkCgiApi = __esm({
           "getVideoclipThumbnailJpeg",
           `Extracting thumbnail from VOD URL (FLV): ${vodUrl.substring(0, 100)}... (seek=${seekSeconds}s)`
         );
-        const { spawn: spawn4 } = await import("child_process");
+        const { spawn: spawn5 } = await import("child_process");
         return new Promise((resolve, reject) => {
           const chunks = [];
           let stderr = "";
           let timedOut = false;
-          const ffmpeg = spawn4(ffmpegPath, [
+          const ffmpeg = spawn5(ffmpegPath, [
             "-y",
             "-analyzeduration",
             "10000000",
@@ -5443,7 +5443,7 @@ function spawnFfmpeg(args, logPath) {
   return new Promise((resolve) => {
     mkdirp(path4.dirname(logPath));
     const logStream = fs4.createWriteStream(logPath, { flags: "a" });
-    const p = (0, import_node_child_process2.spawn)("ffmpeg", args, { stdio: ["ignore", "ignore", "pipe"] });
+    const p = (0, import_node_child_process3.spawn)("ffmpeg", args, { stdio: ["ignore", "ignore", "pipe"] });
     p.on("error", (e) => {
       logStream.write(
         `ffmpeg spawn error: ${e instanceof Error ? e.message : String(e)}
@@ -5474,7 +5474,7 @@ function spawnFfprobeJson(args, logPath) {
   return new Promise((resolve) => {
     mkdirp(path4.dirname(logPath));
     const logStream = fs4.createWriteStream(logPath, { flags: "a" });
-    const p = (0, import_node_child_process2.spawn)("ffprobe", args, { stdio: ["ignore", "pipe", "pipe"] });
+    const p = (0, import_node_child_process3.spawn)("ffprobe", args, { stdio: ["ignore", "pipe", "pipe"] });
     p.on("error", (e) => {
       const msg = e instanceof Error ? e.message : String(e);
       logStream.write(`ffprobe spawn error: ${msg}
@@ -5582,7 +5582,7 @@ async function testStreamWithFfmpeg(params) {
     // Output to null (we just want to test connection)
   ];
   return new Promise((resolve) => {
-    const p = (0, import_node_child_process2.spawn)("ffmpeg", args, { stdio: ["ignore", "ignore", "pipe"] });
+    const p = (0, import_node_child_process3.spawn)("ffmpeg", args, { stdio: ["ignore", "ignore", "pipe"] });
     let stderr = "";
     let hasData = false;
     p.stderr.on("data", (d) => {
@@ -8129,14 +8129,14 @@ async function captureModelFixtures(params) {
   }
   return { calls, outDir, summary };
 }
-var fs4, path4, import_node_crypto3, import_node_child_process2, import_node_path, REDACT_KEYS, MASK_KEYS, IPV4_RE, MAC_RE;
+var fs4, path4, import_node_crypto3, import_node_child_process3, import_node_path, REDACT_KEYS, MASK_KEYS, IPV4_RE, MAC_RE;
 var init_DiagnosticsTools = __esm({
   "src/debug/DiagnosticsTools.ts"() {
     "use strict";
     fs4 = __toESM(require("fs"), 1);
     path4 = __toESM(require("path"), 1);
     import_node_crypto3 = require("crypto");
-    import_node_child_process2 = require("child_process");
+    import_node_child_process3 = require("child_process");
     init_ReolinkCgiApi();
     import_node_path = require("path");
     init_zip();
@@ -8171,14 +8171,14 @@ var init_DiagnosticsTools = __esm({
 });
 
 // src/reolink/baichuan/ReolinkBaichuanApi.ts
-var import_node_child_process3 = require("child_process");
+var import_node_child_process4 = require("child_process");
 var import_promises2 = require("fs/promises");
 var import_node_path2 = require("path");
 var import_node_stream = require("stream");
 
 // src/baichuan/stream/BaichuanRtspServer.ts
-var import_node_events2 = require("events");
-var import_node_child_process = require("child_process");
+var import_node_events3 = require("events");
+var import_node_child_process2 = require("child_process");
 var net = __toESM(require("net"), 1);
 var dgram = __toESM(require("dgram"), 1);
 var crypto = __toESM(require("crypto"), 1);
@@ -8378,6 +8378,358 @@ async function* createNativeStream(api, channel, profile, options) {
   }
 }
 
+// src/baichuan/stream/BaichuanRtspServer.ts
+init_BaichuanVideoStream();
+
+// src/baichuan/stream/ContinuousVideoStream.ts
+var import_node_events2 = require("events");
+
+// src/baichuan/stream/PlaceholderRenderer.ts
+var import_node_child_process = require("child_process");
+var import_jimp = require("jimp");
+var import_fonts = require("jimp/fonts");
+
+// src/baichuan/stream/alwaysOnTypes.ts
+var ALWAYS_ON_DEFAULTS = {
+  triggers: ["motion", "doorbell"],
+  windowMs: 15e3,
+  idleFps: 1,
+  primeOnStart: true,
+  placeholder: { enabled: true, text: "Sleeping", opacity: 0.5 }
+};
+
+// src/baichuan/stream/PlaceholderRenderer.ts
+function ffmpegCodec(videoType) {
+  if (videoType === "H265") {
+    return {
+      inputFormat: "hevc",
+      encoder: "libx265",
+      outputFormat: "hevc"
+    };
+  }
+  return {
+    inputFormat: "h264",
+    encoder: "libx264",
+    outputFormat: "h264"
+  };
+}
+function runFfmpeg(args, input) {
+  return new Promise((resolve, reject) => {
+    const proc = (0, import_node_child_process.spawn)("ffmpeg", args, { stdio: ["pipe", "pipe", "pipe"] });
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    proc.stdout?.on("data", (chunk) => stdoutChunks.push(chunk));
+    proc.stderr?.on("data", (chunk) => stderrChunks.push(chunk));
+    proc.on("error", (error) => reject(error));
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve(Buffer.concat(stdoutChunks));
+        return;
+      }
+      const stderr = Buffer.concat(stderrChunks).toString("utf8").trim();
+      reject(new Error(`ffmpeg exited with code ${code}: ${stderr}`));
+    });
+    const stdin = proc.stdin;
+    if (!stdin) {
+      reject(new Error("ffmpeg stdin not available"));
+      return;
+    }
+    stdin.on("error", (error) => reject(error));
+    stdin.end(input);
+  });
+}
+var PlaceholderRenderer = class {
+  opts;
+  logger;
+  constructor(args) {
+    this.opts = { ...ALWAYS_ON_DEFAULTS.placeholder, ...args.placeholder ?? {} };
+    this.logger = args.logger;
+  }
+  /** Returns the access unit bytes to emit as placeholder, or null if none available. */
+  async render(keyframe) {
+    if (!keyframe) return null;
+    if (!this.opts.enabled) return keyframe.data;
+    try {
+      const jpeg = await this.decodeToJpeg(keyframe);
+      const decorated = await this.decorate(jpeg);
+      const idr = await this.encodeIdr(decorated, keyframe.videoType);
+      if (!idr || idr.length === 0) {
+        throw new Error("ffmpeg produced empty IDR output");
+      }
+      return idr;
+    } catch (error) {
+      this.logger?.warn?.(
+        "PlaceholderRenderer: decoration failed, falling back to raw keyframe",
+        error instanceof Error ? error.message : error
+      );
+      return keyframe.data;
+    }
+  }
+  /** Decodes the cached keyframe access unit into a single JPEG still via ffmpeg. */
+  async decodeToJpeg(keyframe) {
+    const { inputFormat } = ffmpegCodec(keyframe.videoType);
+    return runFfmpeg(
+      [
+        "-hide_banner",
+        "-loglevel",
+        "error",
+        "-f",
+        inputFormat,
+        "-i",
+        "pipe:0",
+        "-frames:v",
+        "1",
+        "-f",
+        "mjpeg",
+        "pipe:1"
+      ],
+      keyframe.data
+    );
+  }
+  /** Dims the still and prints the overlay text using jimp, returning a JPEG buffer. */
+  async decorate(jpeg) {
+    const image = await import_jimp.Jimp.read(jpeg);
+    const op = Math.max(0, Math.min(1, this.opts.opacity));
+    if (op < 1) {
+      const data = image.bitmap.data;
+      for (let i = 0; i < data.length; i += 4) {
+        data[i] = data[i] * op;
+        data[i + 1] = data[i + 1] * op;
+        data[i + 2] = data[i + 2] * op;
+      }
+    }
+    const fontDef = image.width >= 1280 ? import_fonts.SANS_128_WHITE : image.width >= 640 ? import_fonts.SANS_64_WHITE : import_fonts.SANS_32_WHITE;
+    const font = await (0, import_jimp.loadFont)(fontDef);
+    const text = this.opts.text;
+    const textWidth = (0, import_jimp.measureText)(font, text);
+    const textHeight = (0, import_jimp.measureTextHeight)(font, text, image.width);
+    const x = Math.max(0, Math.round((image.width - textWidth) / 2));
+    const y = Math.max(0, Math.round((image.height - textHeight) / 2));
+    image.print({ font, x, y, text });
+    return image.getBuffer(import_jimp.JimpMime.jpeg);
+  }
+  /** Encodes the decorated JPEG into a single IDR access unit in the target codec. */
+  async encodeIdr(jpeg, videoType) {
+    const { encoder, outputFormat } = ffmpegCodec(videoType);
+    return runFfmpeg(
+      [
+        "-hide_banner",
+        "-loglevel",
+        "error",
+        "-f",
+        "image2pipe",
+        "-i",
+        "pipe:0",
+        "-frames:v",
+        "1",
+        "-c:v",
+        encoder,
+        "-pix_fmt",
+        "yuv420p",
+        "-f",
+        outputFormat,
+        "pipe:1"
+      ],
+      jpeg
+    );
+  }
+};
+
+// src/baichuan/stream/ContinuousVideoStream.ts
+var ContinuousVideoStream = class extends import_node_events2.EventEmitter {
+  constructor(opts) {
+    super();
+    this.opts = opts;
+    this.idleFps = Math.max(0.1, opts.idleFps ?? ALWAYS_ON_DEFAULTS.idleFps);
+    this.logger = opts.logger;
+    const rendererArgs = {};
+    if (opts.placeholder !== void 0) rendererArgs.placeholder = opts.placeholder;
+    if (opts.logger !== void 0) rendererArgs.logger = opts.logger;
+    this.renderer = opts.renderer ?? new PlaceholderRenderer(rendererArgs);
+  }
+  live = null;
+  lastKeyframe = null;
+  lastMicroseconds = 0;
+  idleFps;
+  renderer;
+  logger;
+  stopped = false;
+  starting = false;
+  idleTimer = null;
+  idlePlaceholder = null;
+  hasCachedKeyframe() {
+    return this.lastKeyframe !== null;
+  }
+  async goLive() {
+    if (this.stopped || this.live || this.starting) return;
+    this.starting = true;
+    try {
+      this.stopIdleLoop();
+      const stream = await this.opts.createLiveStream();
+      this.live = stream;
+      stream.on("videoAccessUnit", this.onLiveAccessUnit);
+      stream.on("additionalHeader", this.onAdditionalHeader);
+      stream.on("audioFrame", this.onAudioFrame);
+      stream.on("error", this.onLiveError);
+      await stream.start().catch((e) => this.emit("error", e));
+    } finally {
+      this.starting = false;
+    }
+  }
+  async goIdle() {
+    if (!this.live) return;
+    const s = this.live;
+    this.live = null;
+    s.off("videoAccessUnit", this.onLiveAccessUnit);
+    s.off("additionalHeader", this.onAdditionalHeader);
+    s.off("audioFrame", this.onAudioFrame);
+    s.off("error", this.onLiveError);
+    await s.stop().catch(() => {
+    });
+    await this.startIdleLoop();
+  }
+  async stop() {
+    this.stopped = true;
+    await this.goIdle();
+    this.stopIdleLoop();
+    this.emit("close");
+  }
+  async startIdleLoop() {
+    if (this.stopped) return;
+    this.idlePlaceholder = await this.renderer.render(this.lastKeyframe);
+    if (!this.idlePlaceholder || !this.lastKeyframe) {
+      this.logger?.debug?.("[ContinuousVideoStream] no keyframe yet; idle loop deferred");
+      return;
+    }
+    const stepUs = Math.round(1e6 / this.idleFps);
+    const videoType = this.lastKeyframe.videoType;
+    this.idleTimer = setInterval(() => {
+      if (!this.idlePlaceholder) return;
+      this.lastMicroseconds += stepUs;
+      this.emit("videoAccessUnit", {
+        data: this.idlePlaceholder,
+        isKeyframe: true,
+        videoType,
+        microseconds: this.lastMicroseconds
+      });
+    }, Math.round(1e3 / this.idleFps));
+  }
+  stopIdleLoop() {
+    if (this.idleTimer) {
+      clearInterval(this.idleTimer);
+      this.idleTimer = null;
+    }
+    this.idlePlaceholder = null;
+  }
+  onLiveAccessUnit = (au) => {
+    if (au.isKeyframe) {
+      this.lastKeyframe = { data: au.data, videoType: au.videoType };
+    }
+    this.lastMicroseconds = au.microseconds;
+    this.emit("videoAccessUnit", au);
+  };
+  onAdditionalHeader = (h) => this.emit("additionalHeader", h);
+  onAudioFrame = (a) => this.emit("audioFrame", a);
+  onLiveError = (e) => this.emit("error", e);
+};
+
+// src/baichuan/stream/AlwaysOnController.ts
+var AlwaysOnController = class {
+  constructor(o) {
+    this.o = o;
+    this.triggers = new Set(o.options.triggers ?? ALWAYS_ON_DEFAULTS.triggers);
+    this.windowMs = o.options.windowMs ?? ALWAYS_ON_DEFAULTS.windowMs;
+    this.primeOnStart = o.options.primeOnStart ?? ALWAYS_ON_DEFAULTS.primeOnStart;
+    this.logger = o.logger;
+  }
+  triggers;
+  windowMs;
+  primeOnStart;
+  logger;
+  windowTimer = null;
+  live = false;
+  started = false;
+  handler = (e) => void this.onEvent(e);
+  get windowSeconds() {
+    return Math.round(this.windowMs / 1e3);
+  }
+  async start() {
+    if (this.started) return;
+    this.started = true;
+    await this.o.api.onSimpleEvent(this.handler);
+    this.logger?.info?.(
+      `[AlwaysOnController] started ch${this.o.channel} \u2014 triggers=[${[...this.triggers].join(", ")}], window=${this.windowSeconds}s, primeOnStart=${this.primeOnStart}`
+    );
+    if (this.primeOnStart) {
+      await this.openWindow("prime");
+    }
+  }
+  async stop() {
+    if (!this.started) return;
+    this.started = false;
+    if (this.windowTimer) {
+      clearTimeout(this.windowTimer);
+      this.windowTimer = null;
+    }
+    await this.o.api.offSimpleEvent(this.handler).catch(() => {
+    });
+    if (this.live) {
+      this.live = false;
+      await this.o.goIdle().catch(() => {
+      });
+    }
+    this.logger?.info?.(`[AlwaysOnController] stopped ch${this.o.channel}`);
+  }
+  async onEvent(e) {
+    if (e.channel !== this.o.channel) return;
+    if (!this.triggers.has(e.type)) {
+      this.logger?.debug?.(
+        `[AlwaysOnController] event '${e.type}' ch${e.channel} ignored (not a configured trigger)`
+      );
+      return;
+    }
+    await this.openWindow(e.type);
+  }
+  async openWindow(reason) {
+    if (this.windowTimer) clearTimeout(this.windowTimer);
+    if (!this.live) {
+      this.live = true;
+      try {
+        await this.o.api.wakeUp(this.o.channel).catch(() => {
+        });
+        await this.o.goLive();
+        this.logger?.info?.(
+          `[AlwaysOnController] live window OPENED (trigger=${reason}) \u2014 streaming real frames; will sleep in ${this.windowSeconds}s without new events`
+        );
+      } catch (err) {
+        this.live = false;
+        this.logger?.warn?.(
+          `[AlwaysOnController] goLive failed: ${err?.message}`
+        );
+        return;
+      }
+    } else {
+      this.logger?.info?.(
+        `[AlwaysOnController] live window EXTENDED (trigger=${reason}) \u2014 sleep timer reset to ${this.windowSeconds}s`
+      );
+    }
+    this.windowTimer = setTimeout(() => void this.closeWindow(), this.windowMs);
+  }
+  async closeWindow() {
+    this.windowTimer = null;
+    if (!this.live) return;
+    this.live = false;
+    this.logger?.info?.(
+      `[AlwaysOnController] live window CLOSED \u2014 going idle (placeholder); camera can sleep`
+    );
+    await this.o.goIdle().catch(
+      (err) => this.logger?.warn?.(
+        `[AlwaysOnController] goIdle failed: ${err?.message}`
+      )
+    );
+  }
+};
+
 // src/baichuan/stream/rtspFlow.ts
 init_H264Converter();
 init_H265Converter();
@@ -8604,7 +8956,7 @@ function envBool(value, defaultValue) {
   if (v === "0" || v === "false" || v === "no" || v === "off") return false;
   return defaultValue;
 }
-var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events2.EventEmitter {
+var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events3.EventEmitter {
   api;
   channel;
   profile;
@@ -8619,6 +8971,12 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events2.E
   deviceId;
   dedicatedSessionRelease;
   externalListener;
+  // Always-on continuous stream (battery cameras). Populated only when
+  // `options.alwaysOn?.enabled`; the default (non-alwaysOn) path leaves these
+  // null/undefined and is byte-for-byte equivalent in behaviour.
+  alwaysOnOptions;
+  continuousStream = null;
+  alwaysOnController = null;
   // Authentication
   authCredentials = [];
   requireAuth;
@@ -8633,6 +8991,8 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events2.E
   // Set of client IDs (IP:port)
   nativeStreamActive = false;
   // Whether the native stream is currently active
+  tearingDown = false;
+  // True while stop() is running; suppresses onEnd-driven restarts
   clientConnectionServer;
   // TCP server to track connections
   streamMetadata = null;
@@ -8820,6 +9180,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events2.E
     this.requireAuth = options.requireAuth ?? this.authCredentials.length > 0;
     this.AUTH_REALM = options.authRealm ?? "BaichuanRtspServer";
     this.lazyMetadata = options.lazyMetadata ?? false;
+    this.alwaysOnOptions = options.alwaysOn;
     const transport = this.api.client.getTransport();
     this.flow = createRtspFlow(transport, "H264");
   }
@@ -9943,7 +10304,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events2.E
       this.rtspDebugLog(
         `Spawning ffmpeg for client ${clientId}: ffmpeg ${ffmpegArgs.join(" ")}`
       );
-      ffmpeg = (0, import_node_child_process.spawn)("ffmpeg", ffmpegArgs, {
+      ffmpeg = (0, import_node_child_process2.spawn)("ffmpeg", ffmpegArgs, {
         stdio
       });
       try {
@@ -10307,6 +10668,141 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events2.E
       }
     });
   }
+  /**
+   * Always-on source: bridge a {@link ContinuousVideoStream} into the existing
+   * fanout. Yields the same frame shape that `createNativeStream` produces, so
+   * the rest of the pipeline (prebuffer, param-set extraction, per-client
+   * subscribe, ffmpeg/direct-RTP) is unchanged.
+   *
+   * The CVS itself is long-lived (created once, reused across native-stream
+   * restarts) and is driven by the {@link AlwaysOnController}, which opens/closes
+   * live windows from camera events. Each fanout source generator only forwards
+   * CVS events to the fanout pump for as long as `signal` is not aborted.
+   */
+  async *createContinuousSource(dedicatedClient, signal) {
+    const cvs = this.ensureContinuousStream(dedicatedClient);
+    const queue = [];
+    const MAX_QUEUE = 200;
+    let wake = null;
+    let done = false;
+    const push = (frame) => {
+      queue.push(frame);
+      if (queue.length > MAX_QUEUE) {
+        queue.splice(0, queue.length - MAX_QUEUE);
+      }
+      if (wake) {
+        const w = wake;
+        wake = null;
+        w();
+      }
+    };
+    const onVideo = (au) => {
+      push({
+        audio: false,
+        data: au.data,
+        codec: null,
+        sampleRate: null,
+        microseconds: au.microseconds,
+        videoType: au.videoType,
+        isKeyframe: au.isKeyframe
+      });
+    };
+    const onAudio = (frame) => {
+      push({
+        audio: true,
+        data: frame,
+        codec: "aac",
+        sampleRate: 8e3,
+        microseconds: null
+      });
+    };
+    const finish = () => {
+      done = true;
+      if (wake) {
+        const w = wake;
+        wake = null;
+        w();
+      }
+    };
+    const onAbort = () => finish();
+    cvs.on("videoAccessUnit", onVideo);
+    cvs.on("audioFrame", onAudio);
+    cvs.on("close", finish);
+    if (signal.aborted) {
+      done = true;
+    } else {
+      signal.addEventListener("abort", onAbort);
+    }
+    try {
+      while (!done && !signal.aborted) {
+        if (queue.length > 0) {
+          yield queue.shift();
+        } else {
+          await new Promise((resolve) => {
+            wake = resolve;
+            if (done || signal.aborted) {
+              wake = null;
+              resolve();
+            }
+          });
+        }
+      }
+      while (queue.length > 0 && !signal.aborted) {
+        yield queue.shift();
+      }
+    } finally {
+      cvs.off("videoAccessUnit", onVideo);
+      cvs.off("audioFrame", onAudio);
+      cvs.off("close", finish);
+      signal.removeEventListener("abort", onAbort);
+    }
+  }
+  /**
+   * Lazily build the long-lived {@link ContinuousVideoStream} +
+   * {@link AlwaysOnController} for always-on mode. Both are created once and
+   * reused for the lifetime of the server (across native-stream restarts).
+   */
+  ensureContinuousStream(dedicatedClient) {
+    if (this.continuousStream) return this.continuousStream;
+    const createLiveStream = async () => {
+      const client = dedicatedClient ?? this.api.client;
+      return new BaichuanVideoStream({
+        client,
+        api: this.api,
+        channel: this.channel,
+        profile: this.profile,
+        ...this.variant !== "default" ? { variant: this.variant } : {},
+        ...this.logger ? { logger: this.logger } : {}
+      });
+    };
+    const cvsOptions = {
+      createLiveStream,
+      ...this.alwaysOnOptions?.idleFps !== void 0 ? { idleFps: this.alwaysOnOptions.idleFps } : {},
+      ...this.alwaysOnOptions?.placeholder !== void 0 ? { placeholder: this.alwaysOnOptions.placeholder } : {},
+      ...this.logger ? { logger: this.logger } : {}
+    };
+    const cvs = new ContinuousVideoStream(cvsOptions);
+    cvs.on("error", (e) => {
+      this.logger.warn(
+        `[BaichuanRtspServer] ContinuousVideoStream error: ${e?.message ?? e}`
+      );
+    });
+    this.continuousStream = cvs;
+    this.alwaysOnController = new AlwaysOnController({
+      api: this.api,
+      channel: this.channel,
+      options: this.alwaysOnOptions,
+      goLive: () => cvs.goLive(),
+      goIdle: () => cvs.goIdle(),
+      ...this.logger ? { logger: this.logger } : {}
+    });
+    void this.alwaysOnController.start().catch((e) => {
+      this.logger.warn(
+        `[BaichuanRtspServer] AlwaysOnController start failed: ${e?.message ?? e}`
+      );
+    });
+    return cvs;
+  }
   /**
    * Start native stream (mark as active).
    * Each client will create its own generator, so we just track that the stream is active.
@@ -10368,7 +10864,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events2.E
     await this.flow.startKeepAlive(this.api);
     this.nativeFanout = new NativeStreamFanout({
       maxQueueItems: 200,
-      createSource: (signal) => createNativeStream(this.api, this.channel, this.profile, {
+      createSource: (signal) => this.alwaysOnOptions?.enabled ? this.createContinuousSource(dedicatedClient, signal) : createNativeStream(this.api, this.channel, this.profile, {
         variant: this.variant,
         ...dedicatedClient ? { client: dedicatedClient } : {},
         signal
@@ -10451,6 +10947,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events2.E
             } catch {
             }
           }
+          if (this.tearingDown) return;
           if (this.connectedClients.size > 0 && hadFrames) {
             this.logger.info(
               `[rebroadcast] restarting native stream for ${this.connectedClients.size} active client(s)`
@@ -10464,7 +10961,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events2.E
     });
     this.nativeFanout.start();
     this.clearNoFrameDeadlineTimer();
-    if (this.nativeStreamNoFrameDeadlineMs > 0) {
+    if (this.nativeStreamNoFrameDeadlineMs > 0 && !this.alwaysOnOptions?.enabled) {
       this.noFrameDeadlineTimer = setTimeout(() => {
         this.noFrameDeadlineTimer = void 0;
         if (!this.firstFrameReceived && this.nativeStreamActive) {
@@ -10477,7 +10974,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events2.E
       this.noFrameDeadlineTimer?.unref?.();
     }
     this.clearNoClientAutoStopTimer();
-    if (this.nativeStreamPrimeIdleStopMs > 0) {
+    if (this.nativeStreamPrimeIdleStopMs > 0 && !this.alwaysOnOptions?.enabled) {
       this.noClientAutoStopTimer = setTimeout(() => {
         if (this.connectedClients.size === 0) {
           this.rtspDebugLog(
@@ -10564,7 +11061,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events2.E
       this.emit("clientDisconnected", clientId);
       if (this.connectedClients.size === 0) {
         this.clearNoClientAutoStopTimer();
-        if (this.nativeStreamIdleStopMs > 0) {
+        if (this.nativeStreamIdleStopMs > 0 && !this.alwaysOnOptions?.enabled) {
           this.noClientAutoStopTimer = setTimeout(() => {
             if (this.connectedClients.size === 0) {
               void this.stopNativeStream();
@@ -10635,9 +11132,22 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events2.E
     if (!this.active) {
       return;
     }
+    this.tearingDown = true;
     this.logger.info(
       `[BaichuanRtspServer] Stopping RTSP server on ${this.listenHost}:${this.listenPort}...`
     );
+    if (this.alwaysOnController) {
+      const controller = this.alwaysOnController;
+      this.alwaysOnController = null;
+      await controller.stop().catch(() => {
+      });
+    }
+    if (this.continuousStream) {
+      const cvs = this.continuousStream;
+      this.continuousStream = null;
+      await cvs.stop().catch(() => {
+      });
+    }
     await this.stopNativeStream();
     const clientIds = Array.from(this.connectedClients);
     for (const clientId of clientIds) {
@@ -10977,14 +11487,14 @@ var MpegTsMuxer = class {
 };
 
 // src/client/BaichuanClient.ts
-var import_node_events4 = require("events");
+var import_node_events5 = require("events");
 var import_node_crypto2 = require("crypto");
 var import_node_net = __toESM(require("net"), 1);
 
 // src/bcudp/BcUdpStream.ts
 var import_node_dgram = __toESM(require("dgram"), 1);
 var import_promises = __toESM(require("dns/promises"), 1);
-var import_node_events3 = require("events");
+var import_node_events4 = require("events");
 var import_node_os = require("os");
 var import_node_timers = require("timers");
 
@@ -11651,7 +12161,7 @@ var cachedP2pLookups = /* @__PURE__ */ new Map();
 var negCachedP2pLookups = /* @__PURE__ */ new Map();
 var P2P_LOOKUP_CACHE_TTL_MS = 3e4;
 var P2P_LOOKUP_NEG_CACHE_TTL_MS = 15e3;
-var BcUdpStream = class extends import_node_events3.EventEmitter {
+var BcUdpStream = class extends import_node_events4.EventEmitter {
   opts;
   /**
    * Optional info-level logger for diagnostic milestones — set via
@@ -13114,7 +13624,7 @@ init_xml();
 function isTalkCmd(cmdId) {
   return cmdId === BC_CMD_ID_TALK_ABILITY || cmdId === BC_CMD_ID_TALK_RESET || cmdId === BC_CMD_ID_TALK_CONFIG || cmdId === BC_CMD_ID_TALK;
 }
-var BaichuanClient = class _BaichuanClient extends import_node_events4.EventEmitter {
+var BaichuanClient = class _BaichuanClient extends import_node_events5.EventEmitter {
   /**
    * Process-wide streaming activity registry.
    *
@@ -16700,7 +17210,7 @@ function buildSetSystemGeneralXml(patch) {
 }
 
 // src/reolink/baichuan/ReolinkBaichuanApi.ts
-var import_jimp = require("jimp");
+var import_jimp2 = require("jimp");
 init_ReolinkCgiApi();
 init_ReolinkHttpClient();
 
@@ -19660,8 +20170,8 @@ var parseSirenStatusListPushXml = (xml) => {
 };
 
 // src/emailPush/bus.ts
-var import_node_events5 = require("events");
-var emitter = new import_node_events5.EventEmitter();
+var import_node_events6 = require("events");
+var emitter = new import_node_events6.EventEmitter();
 function onEmailPushEvent(handler) {
   emitter.on("event", handler);
   return () => emitter.off("event", handler);
@@ -23509,12 +24019,12 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
       let wideImg;
       let teleImg;
       try {
-        wideImg = await import_jimp.Jimp.read(wide);
+        wideImg = await import_jimp2.Jimp.read(wide);
       } catch {
         return wide;
       }
       try {
-        teleImg = await import_jimp.Jimp.read(tele);
+        teleImg = await import_jimp2.Jimp.read(tele);
       } catch {
         return wide;
       }
@@ -23548,7 +24058,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
       });
       teleImg.resize({ w: pipW, h: pipH });
       wideImg.composite(teleImg, left, top);
-      return await wideImg.getBuffer(import_jimp.JimpMime.jpeg, { quality: 80 });
+      return await wideImg.getBuffer(import_jimp2.JimpMime.jpeg, { quality: 80 });
     }
     const ch = channel !== void 0 ? this.normalizeChannel(channel) : 0;
     const variant = options?.variant ?? "default";
@@ -24506,7 +25016,7 @@ ${xml}`);
         const chunks = [];
         let stderr = "";
         let timedOut = false;
-        const ff = (0, import_node_child_process3.spawn)(params.ffmpegPath, [
+        const ff = (0, import_node_child_process4.spawn)(params.ffmpegPath, [
           "-hide_banner",
           "-loglevel",
           "error",
@@ -24591,7 +25101,7 @@ ${xml}`);
       const chunks = [];
       let stderr = "";
       let timedOut = false;
-      const ff = (0, import_node_child_process3.spawn)(ffmpegPath, [
+      const ff = (0, import_node_child_process4.spawn)(ffmpegPath, [
         "-hide_banner",
         "-loglevel",
         "error",
@@ -24707,7 +25217,7 @@ ${xml}`);
         ensureEnabled: true
       });
       await new Promise((resolve, reject) => {
-        const ff = (0, import_node_child_process3.spawn)(ffmpegPath, [
+        const ff = (0, import_node_child_process4.spawn)(ffmpegPath, [
           "-hide_banner",
           "-loglevel",
           "error",
@@ -24763,7 +25273,7 @@ ${stderr}`));
     const atSeconds = Number.isFinite(params.atSeconds) && params.atSeconds >= 0 ? params.atSeconds : 0;
     await (0, import_promises2.mkdir)((0, import_node_path2.dirname)(params.outputPath), { recursive: true });
     await new Promise((resolve, reject) => {
-      const ff = (0, import_node_child_process3.spawn)(ffmpegPath, [
+      const ff = (0, import_node_child_process4.spawn)(ffmpegPath, [
         "-hide_banner",
         "-loglevel",
         "error",
@@ -25328,7 +25838,7 @@ ${stderr}`)
    * Convert a raw video keyframe to JPEG using ffmpeg.
    */
   async convertFrameToJpeg(params) {
-    const { spawn: spawn4 } = await import("child_process");
+    const { spawn: spawn5 } = await import("child_process");
     const ffmpeg = params.ffmpegPath ?? "ffmpeg";
     const inputFormat = params.videoCodec === "H265" ? "hevc" : "h264";
     return new Promise((resolve, reject) => {
@@ -25350,7 +25860,7 @@ ${stderr}`)
         "2",
         "pipe:1"
       ];
-      const proc = spawn4(ffmpeg, args, {
+      const proc = spawn5(ffmpeg, args, {
         stdio: ["pipe", "pipe", "pipe"]
       });
       const chunks = [];
@@ -25493,7 +26003,7 @@ ${stderr}`)
    * Internal helper to mux video+audio into MP4 using ffmpeg.
    */
   async muxToMp4(params) {
-    const { spawn: spawn4 } = await import("child_process");
+    const { spawn: spawn5 } = await import("child_process");
     const { randomUUID: randomUUID3 } = await import("crypto");
     const fs5 = await import("fs/promises");
     const os = await import("os");
@@ -25545,7 +26055,7 @@ ${stderr}`)
         outputPath
       );
       await new Promise((resolve, reject) => {
-        const p = spawn4(ffmpeg, args, { stdio: ["ignore", "ignore", "pipe"] });
+        const p = spawn5(ffmpeg, args, { stdio: ["ignore", "ignore", "pipe"] });
         let stderr = "";
         p.stderr.on("data", (d) => {
           stderr += d.toString();
@@ -30532,7 +31042,7 @@ ${scheduleItems}
       "mjpeg",
       "pipe:1"
     ];
-    const ff = (0, import_node_child_process3.spawn)("ffmpeg", args, { stdio: ["pipe", "pipe", "pipe"] });
+    const ff = (0, import_node_child_process4.spawn)("ffmpeg", args, { stdio: ["pipe", "pipe", "pipe"] });
     const chunks = [];
     let stderr = "";
     ff.stdout.on("data", (d) => chunks.push(Buffer.from(d)));
@@ -30656,7 +31166,7 @@ ${scheduleItems}
           "pipe:1"
         ];
       }
-      ff = (0, import_node_child_process3.spawn)("ffmpeg", args, { stdio: ["pipe", "pipe", "pipe"] });
+      ff = (0, import_node_child_process4.spawn)("ffmpeg", args, { stdio: ["pipe", "pipe", "pipe"] });
       if (!ff.stdin || !ff.stdout || !ff.stderr) {
         throw new Error("ffmpeg stdio streams not available");
       }
@@ -30903,7 +31413,7 @@ ${scheduleItems}
       "mp4",
       "pipe:1"
     ];
-    ff = (0, import_node_child_process3.spawn)("ffmpeg", args, { stdio: ["pipe", "pipe", "pipe"] });
+    ff = (0, import_node_child_process4.spawn)("ffmpeg", args, { stdio: ["pipe", "pipe", "pipe"] });
     if (!ff.stdin || !ff.stdout || !ff.stderr) {
       throw new Error("ffmpeg stdio streams not available");
     }
@@ -31112,7 +31622,7 @@ ${scheduleItems}
         "independent_segments+temp_file",
         playlistPath
       ];
-      ff = (0, import_node_child_process3.spawn)("ffmpeg", args, { stdio: ["pipe", "pipe", "pipe"] });
+      ff = (0, import_node_child_process4.spawn)("ffmpeg", args, { stdio: ["pipe", "pipe", "pipe"] });
       if (!ff.stdin || !ff.stderr) {
         throw new Error("ffmpeg stdio streams not available");
       }
@@ -31725,13 +32235,13 @@ ${scheduleItems}
 init_constants();
 
 // src/reolink/discovery.ts
-var import_node_child_process4 = require("child_process");
+var import_node_child_process5 = require("child_process");
 var import_node_crypto4 = require("crypto");
 var import_node_dgram2 = __toESM(require("dgram"), 1);
 var net3 = __toESM(require("net"), 1);
 var import_node_os2 = require("os");
 var import_node_util = require("util");
-var execFileAsync = (0, import_node_util.promisify)(import_node_child_process4.execFile);
+var execFileAsync = (0, import_node_util.promisify)(import_node_child_process5.execFile);
 async function discoverViaUdpDirect(host, options) {
   if (!options.enableUdpDiscovery) return [];
   const logger = options.logger;
@@ -32007,13 +32517,13 @@ async function pingHost(host, timeoutMs = 3e3) {
     }
     return ["-c", "1", "-W", String(Math.max(1, Math.floor(timeoutMs / 1e3))), host];
   };
-  const { spawn: spawn4 } = await import("child_process");
+  const { spawn: spawn5 } = await import("child_process");
   for (const bin of pingCandidates) {
     const ranOk = await new Promise((resolve) => {
       let settled = false;
       let child;
       try {
-        child = spawn4(bin, pingArgs(bin), { stdio: "ignore" });
+        child = spawn5(bin, pingArgs(bin), { stdio: "ignore" });
       } catch {
         resolve("spawn-failed");
         return;