@apocaliss92/nodelink-js 0.6.4 → 0.6.6

package/dist/index.cjs

@@ -7678,12 +7678,12 @@ var init_ReolinkCgiApi = __esm({
           "getVideoclipThumbnailJpeg",
           `Extracting thumbnail from VOD URL (FLV): ${vodUrl.substring(0, 100)}... (seek=${seekSeconds}s)`
         );
-        const { spawn: spawn13 } = await import("child_process");
+        const { spawn: spawn14 } = await import("child_process");
         return new Promise((resolve, reject) => {
           const chunks = [];
           let stderr = "";
           let timedOut = false;
-          const ffmpeg = spawn13(ffmpegPath, [
+          const ffmpeg = spawn14(ffmpegPath, [
             "-y",
             "-analyzeduration",
             "10000000",
@@ -8267,7 +8267,9 @@ var init_ReolinkCgiApi = __esm({
 var index_exports = {};
 __export(index_exports, {
   ALL_UDP_DISCOVERY_METHODS: () => ALL_UDP_DISCOVERY_METHODS,
+  ALWAYS_ON_DEFAULTS: () => ALWAYS_ON_DEFAULTS,
   AesStreamDecryptor: () => AesStreamDecryptor,
+  AlwaysOnController: () => AlwaysOnController,
   AutodiscoveryClient: () => AutodiscoveryClient,
   BC_AES_IV: () => BC_AES_IV,
   BC_CLASS_FILE_DOWNLOAD: () => BC_CLASS_FILE_DOWNLOAD,
@@ -8424,6 +8426,7 @@ __export(index_exports, {
   BcUdpStream: () => BcUdpStream,
   CompositeRtspServer: () => CompositeRtspServer,
   CompositeStream: () => CompositeStream,
+  ContinuousVideoStream: () => ContinuousVideoStream,
   DEFAULT_SHELTER_CANVAS: () => DEFAULT_SHELTER_CANVAS,
   DUAL_LENS_DUAL_MOTION_MODELS: () => DUAL_LENS_DUAL_MOTION_MODELS,
   DUAL_LENS_MODELS: () => DUAL_LENS_MODELS,
@@ -8437,6 +8440,7 @@ __export(index_exports, {
   MpegTsMuxer: () => MpegTsMuxer,
   NVR_HUB_EXACT_TYPES: () => NVR_HUB_EXACT_TYPES,
   NVR_HUB_MODEL_PATTERNS: () => NVR_HUB_MODEL_PATTERNS,
+  PlaceholderRenderer: () => PlaceholderRenderer,
   ReolinkBaichuanApi: () => ReolinkBaichuanApi,
   ReolinkCgiApi: () => ReolinkCgiApi,
   ReolinkHttpClient: () => ReolinkHttpClient,
@@ -14068,14 +14072,14 @@ init_ReolinkHttpClient();
 init_ReolinkCgiApi();
 
 // 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_events4 = require("events");
-var import_node_child_process2 = require("child_process");
+var import_node_events5 = require("events");
+var import_node_child_process3 = require("child_process");
 var net2 = __toESM(require("net"), 1);
 var dgram2 = __toESM(require("dgram"), 1);
 var crypto = __toESM(require("crypto"), 1);
@@ -14436,6 +14440,358 @@ async function* createNativeStream(api, channel, profile, options) {
   }
 }
 
+// src/baichuan/stream/BaichuanRtspServer.ts
+init_BaichuanVideoStream();
+
+// src/baichuan/stream/ContinuousVideoStream.ts
+var import_node_events4 = require("events");
+
+// src/baichuan/stream/PlaceholderRenderer.ts
+var import_node_child_process2 = 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_process2.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_events4.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();
@@ -14662,7 +15018,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_events4.EventEmitter {
+var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events5.EventEmitter {
   api;
   channel;
   profile;
@@ -14677,6 +15033,12 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.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;
@@ -14691,6 +15053,8 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.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;
@@ -14878,6 +15242,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.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");
   }
@@ -16001,7 +16366,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.E
       this.rtspDebugLog(
         `Spawning ffmpeg for client ${clientId}: ffmpeg ${ffmpegArgs.join(" ")}`
       );
-      ffmpeg = (0, import_node_child_process2.spawn)("ffmpeg", ffmpegArgs, {
+      ffmpeg = (0, import_node_child_process3.spawn)("ffmpeg", ffmpegArgs, {
         stdio
       });
       try {
@@ -16365,6 +16730,141 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.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.
@@ -16426,7 +16926,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.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
@@ -16509,6 +17009,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.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)`
@@ -16522,7 +17023,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.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) {
@@ -16535,7 +17036,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.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(
@@ -16622,7 +17123,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.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();
@@ -16693,9 +17194,22 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.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) {
@@ -17186,6 +17700,30 @@ function buildSetNtpXml(current, patch) {
   );
 }
 
+// src/reolink/baichuan/utils/channelEnumeration.ts
+async function resolveBaichuanChannels(deps) {
+  const fromPush = dedupeSorted(deps.pushChannels);
+  if (fromPush.length > 0) return fromPush;
+  const slots = dedupeSorted(deps.supportChnIds);
+  const candidates = slots.length > 0 ? slots : [0];
+  const probed = await Promise.all(
+    candidates.map(
+      async (channel) => await deps.probe(channel) ? channel : void 0
+    )
+  );
+  return dedupeSorted(
+    probed.filter((c) => c !== void 0)
+  );
+}
+function dedupeSorted(values) {
+  const set = /* @__PURE__ */ new Set();
+  for (const v of values) {
+    const n = Number(v);
+    if (Number.isFinite(n) && n >= 0) set.add(n);
+  }
+  return [...set].sort((a, b) => a - b);
+}
+
 // src/reolink/baichuan/utils/dst.ts
 init_xml();
 var parseNumberSafe3 = (text) => {
@@ -17369,7 +17907,7 @@ function buildSetSystemGeneralXml(patch) {
 }
 
 // src/reolink/baichuan/ReolinkBaichuanApi.ts
-var import_jimp = require("jimp");
+var import_jimp2 = require("jimp");
 init_ReolinkCgiApi();
 init_ReolinkHttpClient();
 
@@ -20329,8 +20867,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();
 var cameraResolver = () => void 0;
 var lastEventByCamera = /* @__PURE__ */ new Map();
 var MAX_GLOBAL_EVENTS = 300;
@@ -23595,13 +24133,21 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
    * @param options.source - Data source for the channel list (default: `"cgi"`):
    *   - `"cgi"`: Uses HTTP `GetChannelstatus` — returns the channel list immediately,
    *     no dependency on async push messages. Recommended for first-call discovery.
-   *   - `"baichuan"`: Uses the cmd_id 145 push cache populated when the NVR sends channel
-   *     info after login + event subscription. This push is *asynchronous*: if it has not
-   *     arrived yet, the result will have zero channels. Callers must retry (nvr.ts does this
-   *     with a 1-second loop). Note: explicitly requesting cmd_id 145 is not supported.
+   *   - `"baichuan"`: HTTP-free discovery. Prefers the cmd_id 145 push cache when
+   *     populated; otherwise actively probes the channel slots advertised by Support
+   *     (`items[].chnID`) via `getInfo`. Use this for hubs with HTTP disabled.
+   *
+   * When the api was constructed with `nativeOnly`, the source is forced to
+   * `"baichuan"` regardless of this option (no HTTP/CGI is ever attempted).
    */
   async getNvrChannelsSummary(options) {
-    const source = options?.source ?? "cgi";
+    const source = this.nativeOnly ? "baichuan" : options?.source ?? "cgi";
+    const support = await this.getSupportInfo().catch(() => {
+      this.logger.error?.(
+        "[ReolinkBaichuanApi] getNvrChannelsSummary: failed to get support info"
+      );
+      return void 0;
+    });
     let channels;
     const cgiStatusByChannel = /* @__PURE__ */ new Map();
     if (options?.channels?.length) {
@@ -23631,15 +24177,31 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
         channels = [];
       }
     } else {
-      const pushInfo2 = this.getChannelInfoFromPushCache();
-      channels = Array.from(pushInfo2.keys()).map((c) => Number(c)).filter((n) => Number.isFinite(n));
+      const pushChannels = Array.from(
+        this.getChannelInfoFromPushCache().keys()
+      ).map((c) => Number(c)).filter((n) => Number.isFinite(n));
+      const supportChnIds = (support?.items ?? []).map((i) => Number(i.chnID)).filter((n) => Number.isFinite(n));
+      const probeTimeoutMs = options?.timeoutMs ?? 2500;
+      channels = await resolveBaichuanChannels({
+        pushChannels,
+        supportChnIds,
+        probe: async (channel) => {
+          try {
+            await this.getInfo(channel, {
+              timeoutMs: probeTimeoutMs,
+              tags: ["type", "name"]
+            });
+            return true;
+          } catch {
+            return false;
+          }
+        }
+      });
+      this.logger.debug?.(
+        `[ReolinkBaichuanApi] getNvrChannelsSummary: baichuan resolved ${channels.length} channel(s): [${channels.join(", ")}]`
+      );
     }
     channels = channels.sort((a, b) => a - b);
-    const support = await this.getSupportInfo().catch(() => {
-      this.logger.error?.(
-        "[ReolinkBaichuanApi] getNvrChannelsSummary: failed to get support info"
-      );
-    });
     const truthyNumberLike = (v) => {
       if (typeof v === "number") return v > 0;
       if (typeof v === "string") {
@@ -24209,12 +24771,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;
       }
@@ -24248,7 +24810,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";
@@ -25206,7 +25768,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",
@@ -25291,7 +25853,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",
@@ -25407,7 +25969,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",
@@ -25463,7 +26025,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",
@@ -26028,7 +26590,7 @@ ${stderr}`)
    * Convert a raw video keyframe to JPEG using ffmpeg.
    */
   async convertFrameToJpeg(params) {
-    const { spawn: spawn13 } = await import("child_process");
+    const { spawn: spawn14 } = await import("child_process");
     const ffmpeg = params.ffmpegPath ?? "ffmpeg";
     const inputFormat = params.videoCodec === "H265" ? "hevc" : "h264";
     return new Promise((resolve, reject) => {
@@ -26050,7 +26612,7 @@ ${stderr}`)
         "2",
         "pipe:1"
       ];
-      const proc = spawn13(ffmpeg, args, {
+      const proc = spawn14(ffmpeg, args, {
         stdio: ["pipe", "pipe", "pipe"]
       });
       const chunks = [];
@@ -26193,7 +26755,7 @@ ${stderr}`)
    * Internal helper to mux video+audio into MP4 using ffmpeg.
    */
   async muxToMp4(params) {
-    const { spawn: spawn13 } = await import("child_process");
+    const { spawn: spawn14 } = await import("child_process");
     const { randomUUID: randomUUID3 } = await import("crypto");
     const fs7 = await import("fs/promises");
     const os2 = await import("os");
@@ -26245,7 +26807,7 @@ ${stderr}`)
         outputPath
       );
       await new Promise((resolve, reject) => {
-        const p = spawn13(ffmpeg, args, { stdio: ["ignore", "ignore", "pipe"] });
+        const p = spawn14(ffmpeg, args, { stdio: ["ignore", "ignore", "pipe"] });
         let stderr = "";
         p.stderr.on("data", (d) => {
           stderr += d.toString();
@@ -31232,7 +31794,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)));
@@ -31356,7 +31918,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");
       }
@@ -31603,7 +32165,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");
     }
@@ -31812,7 +32374,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");
       }
@@ -32784,14 +33346,14 @@ function buildHlsRedirectUrl(originalUrl) {
 }
 
 // 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");
 init_ReolinkCgiApi();
-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;
@@ -33833,7 +34395,7 @@ init_recordingFileName();
 
 // src/reolink/baichuan/endpoints-server.ts
 var import_node_http = __toESM(require("http"), 1);
-var import_node_child_process5 = require("child_process");
+var import_node_child_process6 = require("child_process");
 function parseIntParam(v, def) {
   if (v == null) return def;
   const n = Number.parseInt(v, 10);
@@ -34072,7 +34634,7 @@ function createBaichuanEndpointsServer(opts) {
             "Cache-Control": "no-cache",
             Connection: "close"
           });
-          const ff2 = (0, import_node_child_process5.spawn)("ffmpeg", [
+          const ff2 = (0, import_node_child_process6.spawn)("ffmpeg", [
             "-hide_banner",
             "-loglevel",
             "error",
@@ -34105,7 +34667,7 @@ function createBaichuanEndpointsServer(opts) {
         );
         res.setHeader("Cache-Control", "no-cache");
         res.setHeader("Connection", "close");
-        const ff = (0, import_node_child_process5.spawn)("ffmpeg", [
+        const ff = (0, import_node_child_process6.spawn)("ffmpeg", [
           "-hide_banner",
           "-loglevel",
           "error",
@@ -34216,7 +34778,7 @@ init_urls();
 
 // src/rtsp/server.ts
 var import_node_http2 = __toESM(require("http"), 1);
-var import_node_child_process6 = require("child_process");
+var import_node_child_process7 = require("child_process");
 init_urls();
 function createRtspProxyServer(opts) {
   return import_node_http2.default.createServer((req, res) => {
@@ -34257,7 +34819,7 @@ function createRtspProxyServer(opts) {
       Connection: "close"
     });
     const rtspTransport = opts.rtspTransport ?? "tcp";
-    const ff = (0, import_node_child_process6.spawn)("ffmpeg", [
+    const ff = (0, import_node_child_process7.spawn)("ffmpeg", [
       "-hide_banner",
       "-loglevel",
       "error",
@@ -35129,9 +35691,9 @@ var import_node_net2 = __toESM(require("net"), 1);
 init_BaichuanVideoStream();
 
 // src/multifocal/compositeStream.ts
-var import_node_child_process7 = require("child_process");
+var import_node_child_process8 = require("child_process");
 var import_node_crypto6 = require("crypto");
-var import_node_events6 = require("events");
+var import_node_events7 = require("events");
 function calculateOverlayPosition(position, mainWidth, mainHeight, pipWidth, pipHeight, margin) {
   const pipW = Math.floor(pipWidth);
   const pipH = Math.floor(pipHeight);
@@ -35159,7 +35721,7 @@ function calculateOverlayPosition(position, mainWidth, mainHeight, pipWidth, pip
       return { x: m, y: m };
   }
 }
-var CompositeStream = class extends import_node_events6.EventEmitter {
+var CompositeStream = class extends import_node_events7.EventEmitter {
   options;
   widerStream = null;
   teleStream = null;
@@ -35484,7 +36046,7 @@ var CompositeStream = class extends import_node_events6.EventEmitter {
     this.logger.log?.(
       `[CompositeStream] Starting ffmpeg (rtsp inputs): bin=${ffmpegBin} args=${ffmpegArgs.join(" ")}`
     );
-    this.ffmpegProcess = (0, import_node_child_process7.spawn)(ffmpegBin, ffmpegArgs, {
+    this.ffmpegProcess = (0, import_node_child_process8.spawn)(ffmpegBin, ffmpegArgs, {
       stdio: ["ignore", "pipe", "pipe"]
     });
     this.ffmpegProcess.on("error", (error) => {
@@ -35614,7 +36176,7 @@ var CompositeStream = class extends import_node_events6.EventEmitter {
     this.logger.log?.(
       `[CompositeStream] Starting ffmpeg: bin=${ffmpegBin} args=${ffmpegArgs.join(" ")}`
     );
-    this.ffmpegProcess = (0, import_node_child_process7.spawn)(ffmpegBin, ffmpegArgs, {
+    this.ffmpegProcess = (0, import_node_child_process8.spawn)(ffmpegBin, ffmpegArgs, {
       stdio: ["pipe", "pipe", "pipe", "pipe"]
     });
     this.ffmpegProcess.on("error", (error) => {
@@ -36192,7 +36754,8 @@ async function createRfc4571TcpServerInternal(options) {
     apisToClose.add(resolvedCompositeApis.widerApi);
   if (resolvedCompositeApis?.teleApi)
     apisToClose.add(resolvedCompositeApis.teleApi);
-  const uptimeRestartMs = uptimeRestartMsOpt ?? (isComposite ? 6e4 : 1e4);
+  const alwaysOnEnabled = Boolean(options.alwaysOn?.enabled) && !isComposite;
+  const uptimeRestartMs = alwaysOnEnabled ? 0 : uptimeRestartMsOpt ?? (isComposite ? 6e4 : 1e4);
   const variantSuffix = variant && variant !== "default" ? ` variant=${variant}` : "";
   const logPrefix = isComposite ? `[native-rfc4571 composite profile=${profile}${variantSuffix}${requestedId ? ` id=${requestedId}` : ""}]` : `[native-rfc4571 ch=${channel} profile=${profile}${variantSuffix}]`;
   const log = (message) => {
@@ -36216,6 +36779,7 @@ async function createRfc4571TcpServerInternal(options) {
   );
   let videoStream;
   let isCompositeStream = false;
+  let alwaysOnController;
   if (isComposite) {
     const widerChannel = compositeOptions?.widerChannel ?? 0;
     const teleChannel = compositeOptions?.teleChannel ?? 1;
@@ -36358,7 +36922,7 @@ async function createRfc4571TcpServerInternal(options) {
     } else {
       streamClient = baseApi.client;
     }
-    videoStream = new BaichuanVideoStream({
+    const createLiveStream = async () => new BaichuanVideoStream({
       client: streamClient,
       api: baseApi,
       channel: ch,
@@ -36366,10 +36930,39 @@ async function createRfc4571TcpServerInternal(options) {
       variant,
       logger
     });
-    await videoStream.start();
-    log(
-      `stream started (ch=${ch} profile=${profile}${deviceId ? ` dedicated=${deviceId}` : ""})`
-    );
+    if (options.alwaysOn?.enabled) {
+      const cvsOpts = {
+        // ContinuousVideoStream owns the lifecycle: it calls createLiveStream
+        // (which returns a started stream) and re-starts it internally on goLive.
+        createLiveStream,
+        logger
+      };
+      if (options.alwaysOn.idleFps !== void 0)
+        cvsOpts.idleFps = options.alwaysOn.idleFps;
+      if (options.alwaysOn.placeholder !== void 0)
+        cvsOpts.placeholder = options.alwaysOn.placeholder;
+      const cvs = new ContinuousVideoStream(cvsOpts);
+      alwaysOnController = new AlwaysOnController({
+        api: baseApi,
+        channel: ch,
+        options: options.alwaysOn,
+        goLive: () => cvs.goLive(),
+        goIdle: () => cvs.goIdle(),
+        logger
+      });
+      await alwaysOnController.start();
+      videoStream = cvs;
+      log(
+        `always-on stream started (ch=${ch} profile=${profile}${deviceId ? ` dedicated=${deviceId}` : ""})`
+      );
+    } else {
+      const live = await createLiveStream();
+      await live.start();
+      videoStream = live;
+      log(
+        `stream started (ch=${ch} profile=${profile}${deviceId ? ` dedicated=${deviceId}` : ""})`
+      );
+    }
   }
   const waitForKeyframe = async () => {
     if (isCompositeStream) {
@@ -36497,6 +37090,12 @@ async function createRfc4571TcpServerInternal(options) {
   try {
     keyframe = await waitForKeyframe();
   } catch (e) {
+    if (alwaysOnController) {
+      try {
+        await alwaysOnController.stop();
+      } catch {
+      }
+    }
     try {
       await videoStream.stop();
     } catch {
@@ -36745,12 +37344,13 @@ async function createRfc4571TcpServerInternal(options) {
     } catch {
     }
     muxer = makeMuxer();
+    const restartable = videoStream;
     try {
-      await videoStream.stop();
+      await restartable.stop();
     } catch {
     }
     try {
-      await videoStream.start();
+      await restartable.start();
     } catch (e) {
       restarting = false;
       close(e).catch(() => {
@@ -36771,6 +37371,12 @@ async function createRfc4571TcpServerInternal(options) {
     cancelIdleTeardown();
     const reasonStr = reason?.message || reason?.toString?.() || reason || "requested";
     muxer.close();
+    if (alwaysOnController) {
+      try {
+        await alwaysOnController.stop();
+      } catch {
+      }
+    }
     try {
       await videoStream.stop();
     } catch {
@@ -37370,7 +37976,7 @@ async function createRfc4571TcpServerForReplay(options) {
 
 // src/rfc/replay-http-server.ts
 var import_node_http3 = __toESM(require("http"), 1);
-var import_node_child_process8 = require("child_process");
+var import_node_child_process9 = require("child_process");
 var import_node_stream2 = require("stream");
 async function createReplayHttpServer(options) {
   const {
@@ -37524,7 +38130,7 @@ async function createReplayHttpServer(options) {
       "pipe:1"
     ];
     log(`spawning ffmpeg: ${ffmpegPath} ${ffmpegArgs.join(" ")}`);
-    ffmpegProcess = (0, import_node_child_process8.spawn)(ffmpegPath, ffmpegArgs, {
+    ffmpegProcess = (0, import_node_child_process9.spawn)(ffmpegPath, ffmpegArgs, {
       stdio: ["pipe", "pipe", "pipe"]
     });
     ffmpegProcess.stdout?.pipe(outputStream).pipe(res);
@@ -37625,7 +38231,7 @@ async function createReplayHttpServer(options) {
 init_BaichuanVideoStream();
 
 // src/baichuan/stream/Go2rtcTcpServer.ts
-var import_node_events7 = require("events");
+var import_node_events8 = require("events");
 var net4 = __toESM(require("net"), 1);
 init_H264Converter();
 init_H265Converter();
@@ -37737,7 +38343,7 @@ var NativeStreamFanout2 = class {
     this.pumpPromise = null;
   }
 };
-var Go2rtcTcpServer = class _Go2rtcTcpServer extends import_node_events7.EventEmitter {
+var Go2rtcTcpServer = class _Go2rtcTcpServer extends import_node_events8.EventEmitter {
   api;
   channel;
   profile;
@@ -38428,8 +39034,8 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends import_node_events7.EventEm
 };
 
 // src/baichuan/stream/BaichuanHttpStreamServer.ts
-var import_node_events8 = require("events");
-var import_node_child_process9 = require("child_process");
+var import_node_events9 = require("events");
+var import_node_child_process10 = require("child_process");
 var http4 = __toESM(require("http"), 1);
 var NAL_START_CODE_4B4 = Buffer.from([0, 0, 0, 1]);
 var NAL_START_CODE_3B3 = Buffer.from([0, 0, 1]);
@@ -38475,7 +39081,7 @@ function isH264KeyframeFromAnnexB(annexB) {
   }
   return false;
 }
-var BaichuanHttpStreamServer = class extends import_node_events8.EventEmitter {
+var BaichuanHttpStreamServer = class extends import_node_events9.EventEmitter {
   videoStream;
   listenPort;
   path;
@@ -38539,7 +39145,7 @@ var BaichuanHttpStreamServer = class extends import_node_events8.EventEmitter {
       this.httpServer.on("error", reject);
     });
     this.logger.info(`[BaichuanHttpStreamServer] Starting ffmpeg for H.264 -> MPEG-TS conversion...`);
-    const ffmpeg = (0, import_node_child_process9.spawn)("ffmpeg", [
+    const ffmpeg = (0, import_node_child_process10.spawn)("ffmpeg", [
       "-hide_banner",
       // ffmpeg warnings often include non-fatal decode messages (e.g. decode_slice_header),
       // which we don't want to treat as application errors.
@@ -38747,15 +39353,15 @@ var BaichuanHttpStreamServer = class extends import_node_events8.EventEmitter {
 };
 
 // src/baichuan/stream/BaichuanMjpegServer.ts
-var import_node_events10 = require("events");
+var import_node_events11 = require("events");
 var http5 = __toESM(require("http"), 1);
 
 // src/baichuan/stream/MjpegTransformer.ts
-var import_node_events9 = require("events");
-var import_node_child_process10 = require("child_process");
+var import_node_events10 = require("events");
+var import_node_child_process11 = require("child_process");
 var JPEG_SOI = Buffer.from([255, 216]);
 var JPEG_EOI = Buffer.from([255, 217]);
-var MjpegTransformer = class extends import_node_events9.EventEmitter {
+var MjpegTransformer = class extends import_node_events10.EventEmitter {
   options;
   ffmpeg = null;
   started = false;
@@ -38813,7 +39419,7 @@ var MjpegTransformer = class extends import_node_events9.EventEmitter {
       "pipe:1"
     );
     this.log("debug", `Starting FFmpeg with args: ${args.join(" ")}`);
-    this.ffmpeg = (0, import_node_child_process10.spawn)("ffmpeg", args, {
+    this.ffmpeg = (0, import_node_child_process11.spawn)("ffmpeg", args, {
       stdio: ["pipe", "pipe", "pipe"]
     });
     this.ffmpeg.stdout.on("data", (data) => {
@@ -38954,7 +39560,7 @@ Content-Length: ${frame.length}\r
 // src/baichuan/stream/BaichuanMjpegServer.ts
 init_H264Converter();
 init_H265Converter();
-var BaichuanMjpegServer = class extends import_node_events10.EventEmitter {
+var BaichuanMjpegServer = class extends import_node_events11.EventEmitter {
   options;
   clients = /* @__PURE__ */ new Map();
   httpServer = null;
@@ -39235,14 +39841,14 @@ var BaichuanMjpegServer = class extends import_node_events10.EventEmitter {
 };
 
 // src/baichuan/stream/BaichuanWebRTCServer.ts
-var import_node_events12 = require("events");
+var import_node_events13 = require("events");
 init_BcMediaAnnexBDecoder();
 
 // src/baichuan/stream/AacToOpusTranscoder.ts
-var import_node_child_process11 = require("child_process");
+var import_node_child_process12 = require("child_process");
 var import_node_dgram3 = require("dgram");
-var import_node_events11 = require("events");
-var AacToOpusTranscoder = class extends import_node_events11.EventEmitter {
+var import_node_events12 = require("events");
+var AacToOpusTranscoder = class extends import_node_events12.EventEmitter {
   opts;
   socket = null;
   ffmpeg = null;
@@ -39319,7 +39925,7 @@ var AacToOpusTranscoder = class extends import_node_events11.EventEmitter {
       `rtp://127.0.0.1:${this.port}`
     ];
     this.log("info", `spawning ffmpeg with: ${this.opts.ffmpegPath} ${args.join(" ")}`);
-    this.ffmpeg = (0, import_node_child_process11.spawn)(this.opts.ffmpegPath, args, {
+    this.ffmpeg = (0, import_node_child_process12.spawn)(this.opts.ffmpegPath, args, {
       stdio: ["pipe", "ignore", "pipe"]
     });
     this.ffmpeg.on("error", (err) => {
@@ -39459,7 +40065,7 @@ function getH264NalType(nalUnit) {
 function getH265NalType2(nalUnit) {
   return nalUnit[0] >> 1 & 63;
 }
-var BaichuanWebRTCServer = class extends import_node_events12.EventEmitter {
+var BaichuanWebRTCServer = class extends import_node_events13.EventEmitter {
   options;
   sessions = /* @__PURE__ */ new Map();
   sessionIdCounter = 0;
@@ -40451,12 +41057,12 @@ Error: ${err}`
 };
 
 // src/baichuan/stream/BaichuanHlsServer.ts
-var import_node_events13 = require("events");
+var import_node_events14 = 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_process12 = require("child_process");
+var import_node_child_process13 = require("child_process");
 init_BcMediaAnnexBDecoder();
 init_H264Converter();
 init_H265Converter();
@@ -40531,7 +41137,7 @@ function getNalTypes(codec, annexB) {
     }
   });
 }
-var BaichuanHlsServer = class extends import_node_events13.EventEmitter {
+var BaichuanHlsServer = class extends import_node_events14.EventEmitter {
   api;
   channel;
   profile;
@@ -40933,7 +41539,7 @@ var BaichuanHlsServer = class extends import_node_events13.EventEmitter {
       this.segmentPattern,
       this.playlistPath
     );
-    const p = (0, import_node_child_process12.spawn)(this.ffmpegPath, args, {
+    const p = (0, import_node_child_process13.spawn)(this.ffmpegPath, args, {
       stdio: ["pipe", "ignore", "pipe"]
     });
     p.on("error", (err) => {
@@ -41057,13 +41663,13 @@ async function pingHost(host, timeoutMs = 3e3) {
     }
     return ["-c", "1", "-W", String(Math.max(1, Math.floor(timeoutMs / 1e3))), host];
   };
-  const { spawn: spawn13 } = await import("child_process");
+  const { spawn: spawn14 } = await import("child_process");
   for (const bin of pingCandidates) {
     const ranOk = await new Promise((resolve) => {
       let settled = false;
       let child;
       try {
-        child = spawn13(bin, pingArgs(bin), { stdio: "ignore" });
+        child = spawn14(bin, pingArgs(bin), { stdio: "ignore" });
       } catch {
         resolve("spawn-failed");
         return;
@@ -41696,10 +42302,10 @@ async function autoDetectDeviceType(inputs) {
 }
 
 // src/multifocal/compositeRtspServer.ts
-var import_node_events14 = require("events");
-var import_node_child_process13 = require("child_process");
+var import_node_events15 = require("events");
+var import_node_child_process14 = require("child_process");
 var net5 = __toESM(require("net"), 1);
-var CompositeRtspServer = class extends import_node_events14.EventEmitter {
+var CompositeRtspServer = class extends import_node_events15.EventEmitter {
   options;
   compositeStream = null;
   rtspServer = null;
@@ -41804,7 +42410,7 @@ var CompositeRtspServer = class extends import_node_events14.EventEmitter {
     this.logger.log?.(
       `[CompositeRtspServer] Starting ffmpeg RTSP server: ${ffmpegArgs.join(" ")}`
     );
-    this.ffmpegProcess = (0, import_node_child_process13.spawn)("ffmpeg", ffmpegArgs, {
+    this.ffmpegProcess = (0, import_node_child_process14.spawn)("ffmpeg", ffmpegArgs, {
       stdio: ["pipe", "pipe", "pipe"]
     });
     this.ffmpegProcess.on("error", (error) => {
@@ -42475,7 +43081,7 @@ var RtspBackchannel = class _RtspBackchannel {
 };
 
 // src/baichuan/stream/BaichuanRtspBackchannelServer.ts
-var import_node_events15 = require("events");
+var import_node_events16 = require("events");
 var net6 = __toESM(require("net"), 1);
 var crypto3 = __toESM(require("crypto"), 1);
 var md5Hex = (s) => crypto3.createHash("md5").update(s).digest("hex");
@@ -42532,7 +43138,7 @@ function extractPublicEndpoint(url, requestText) {
   if (hostHeader) return hostHeader;
   return null;
 }
-var BaichuanRtspBackchannelServer = class _BaichuanRtspBackchannelServer extends import_node_events15.EventEmitter {
+var BaichuanRtspBackchannelServer = class _BaichuanRtspBackchannelServer extends import_node_events16.EventEmitter {
   listenHost;
   listenPort;
   logger;
@@ -43513,7 +44119,9 @@ function buildInitialStatus(config) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ALL_UDP_DISCOVERY_METHODS,
+  ALWAYS_ON_DEFAULTS,
   AesStreamDecryptor,
+  AlwaysOnController,
   AutodiscoveryClient,
   BC_AES_IV,
   BC_CLASS_FILE_DOWNLOAD,
@@ -43670,6 +44278,7 @@ function buildInitialStatus(config) {
   BcUdpStream,
   CompositeRtspServer,
   CompositeStream,
+  ContinuousVideoStream,
   DEFAULT_SHELTER_CANVAS,
   DUAL_LENS_DUAL_MOTION_MODELS,
   DUAL_LENS_MODELS,
@@ -43683,6 +44292,7 @@ function buildInitialStatus(config) {
   MpegTsMuxer,
   NVR_HUB_EXACT_TYPES,
   NVR_HUB_MODEL_PATTERNS,
+  PlaceholderRenderer,
   ReolinkBaichuanApi,
   ReolinkCgiApi,
   ReolinkHttpClient,