@apocaliss92/nodelink-js 0.6.3 → 0.6.5

package/dist/{chunk-Q4AXRV2G.js → chunk-WQ2TQCYP.js}

@@ -689,6 +689,7 @@ function readCache(uid, now) {
 }
 async function getServerBinding(uid, options = {}) {
   if (!uid || typeof uid !== "string") return void 0;
+  uid = uid.toUpperCase();
   const now = Date.now();
   const cached = readCache(uid, now);
   if (cached?.kind === "ok") return cached.response;
@@ -5976,9 +5977,354 @@ async function* createNativeStream(api, channel, profile, options) {
   }
 }
 
-// src/baichuan/stream/BaichuanRtspServer.ts
-import { EventEmitter as EventEmitter3 } from "events";
+// 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
 import { spawn } from "child_process";
+import { Jimp, JimpMime, loadFont, measureText, measureTextHeight } from "jimp";
+import { SANS_32_WHITE, SANS_64_WHITE, SANS_128_WHITE } from "jimp/fonts";
+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 = 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 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 ? SANS_128_WHITE : image.width >= 640 ? SANS_64_WHITE : SANS_32_WHITE;
+    const font = await loadFont(fontDef);
+    const text = this.opts.text;
+    const textWidth = measureText(font, text);
+    const textHeight = 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(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
+import { EventEmitter as EventEmitter3 } from "events";
+var ContinuousVideoStream = class extends EventEmitter3 {
+  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/BaichuanRtspServer.ts
+import { EventEmitter as EventEmitter4 } from "events";
+import { spawn as spawn2 } from "child_process";
 import * as net2 from "net";
 import * as dgram2 from "dgram";
 import * as crypto from "crypto";
@@ -6205,7 +6551,7 @@ function envBool(value, defaultValue) {
   if (v === "0" || v === "false" || v === "no" || v === "off") return false;
   return defaultValue;
 }
-var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
+var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter4 {
   api;
   channel;
   profile;
@@ -6220,6 +6566,12 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
   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;
@@ -6234,6 +6586,8 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
   // 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;
@@ -6421,6 +6775,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
     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");
   }
@@ -7544,7 +7899,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
       this.rtspDebugLog(
         `Spawning ffmpeg for client ${clientId}: ffmpeg ${ffmpegArgs.join(" ")}`
       );
-      ffmpeg = spawn("ffmpeg", ffmpegArgs, {
+      ffmpeg = spawn2("ffmpeg", ffmpegArgs, {
         stdio
       });
       try {
@@ -7908,6 +8263,141 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
       }
     });
   }
+  /**
+   * 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.
@@ -7969,7 +8459,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
     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
@@ -8052,6 +8542,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
             } 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)`
@@ -8065,7 +8556,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
     });
     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) {
@@ -8078,7 +8569,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
       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(
@@ -8165,7 +8656,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
       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();
@@ -8236,9 +8727,22 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
     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) {
@@ -9198,8 +9702,8 @@ function patchMotionSensitivityListXml(currentXml, bands) {
 }
 
 // src/emailPush/bus.ts
-import { EventEmitter as EventEmitter4 } from "events";
-var emitter = new EventEmitter4();
+import { EventEmitter as EventEmitter5 } from "events";
+var emitter = new EventEmitter5();
 var cameraResolver = () => void 0;
 var lastEventByCamera = /* @__PURE__ */ new Map();
 var MAX_GLOBAL_EVENTS = 300;
@@ -9252,7 +9756,7 @@ function _resetEmailPushBusForTests() {
 }
 
 // src/reolink/baichuan/ReolinkBaichuanApi.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import { mkdir } from "fs/promises";
 import { dirname } from "path";
 import { PassThrough } from "stream";
@@ -9581,7 +10085,7 @@ function buildSetSystemGeneralXml(patch) {
 }
 
 // src/reolink/baichuan/ReolinkBaichuanApi.ts
-import { Jimp, JimpMime } from "jimp";
+import { Jimp as Jimp2, JimpMime as JimpMime2 } from "jimp";
 
 // src/reolink/baichuan/utils/abilityInfo.ts
 var parseAbilityInfoXml = (xml) => {
@@ -15708,12 +16212,12 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
       let wideImg;
       let teleImg;
       try {
-        wideImg = await Jimp.read(wide);
+        wideImg = await Jimp2.read(wide);
       } catch {
         return wide;
       }
       try {
-        teleImg = await Jimp.read(tele);
+        teleImg = await Jimp2.read(tele);
       } catch {
         return wide;
       }
@@ -15747,7 +16251,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
       });
       teleImg.resize({ w: pipW, h: pipH });
       wideImg.composite(teleImg, left, top);
-      return await wideImg.getBuffer(JimpMime.jpeg, { quality: 80 });
+      return await wideImg.getBuffer(JimpMime2.jpeg, { quality: 80 });
     }
     const ch = channel !== void 0 ? this.normalizeChannel(channel) : 0;
     const variant = options?.variant ?? "default";
@@ -16705,7 +17209,7 @@ ${xml}`);
         const chunks = [];
         let stderr = "";
         let timedOut = false;
-        const ff = spawn2(params.ffmpegPath, [
+        const ff = spawn3(params.ffmpegPath, [
           "-hide_banner",
           "-loglevel",
           "error",
@@ -16790,7 +17294,7 @@ ${xml}`);
       const chunks = [];
       let stderr = "";
       let timedOut = false;
-      const ff = spawn2(ffmpegPath, [
+      const ff = spawn3(ffmpegPath, [
         "-hide_banner",
         "-loglevel",
         "error",
@@ -16906,7 +17410,7 @@ ${xml}`);
         ensureEnabled: true
       });
       await new Promise((resolve, reject) => {
-        const ff = spawn2(ffmpegPath, [
+        const ff = spawn3(ffmpegPath, [
           "-hide_banner",
           "-loglevel",
           "error",
@@ -16962,7 +17466,7 @@ ${stderr}`));
     const atSeconds = Number.isFinite(params.atSeconds) && params.atSeconds >= 0 ? params.atSeconds : 0;
     await mkdir(dirname(params.outputPath), { recursive: true });
     await new Promise((resolve, reject) => {
-      const ff = spawn2(ffmpegPath, [
+      const ff = spawn3(ffmpegPath, [
         "-hide_banner",
         "-loglevel",
         "error",
@@ -17527,7 +18031,7 @@ ${stderr}`)
    * Convert a raw video keyframe to JPEG using ffmpeg.
    */
   async convertFrameToJpeg(params) {
-    const { spawn: spawn3 } = await import("child_process");
+    const { spawn: spawn4 } = await import("child_process");
     const ffmpeg = params.ffmpegPath ?? "ffmpeg";
     const inputFormat = params.videoCodec === "H265" ? "hevc" : "h264";
     return new Promise((resolve, reject) => {
@@ -17549,7 +18053,7 @@ ${stderr}`)
         "2",
         "pipe:1"
       ];
-      const proc = spawn3(ffmpeg, args, {
+      const proc = spawn4(ffmpeg, args, {
         stdio: ["pipe", "pipe", "pipe"]
       });
       const chunks = [];
@@ -17692,7 +18196,7 @@ ${stderr}`)
    * Internal helper to mux video+audio into MP4 using ffmpeg.
    */
   async muxToMp4(params) {
-    const { spawn: spawn3 } = await import("child_process");
+    const { spawn: spawn4 } = await import("child_process");
     const { randomUUID: randomUUID3 } = await import("crypto");
     const fs = await import("fs/promises");
     const os = await import("os");
@@ -17744,7 +18248,7 @@ ${stderr}`)
         outputPath
       );
       await new Promise((resolve, reject) => {
-        const p = spawn3(ffmpeg, args, { stdio: ["ignore", "ignore", "pipe"] });
+        const p = spawn4(ffmpeg, args, { stdio: ["ignore", "ignore", "pipe"] });
         let stderr = "";
         p.stderr.on("data", (d) => {
           stderr += d.toString();
@@ -22731,7 +23235,7 @@ ${scheduleItems}
       "mjpeg",
       "pipe:1"
     ];
-    const ff = spawn2("ffmpeg", args, { stdio: ["pipe", "pipe", "pipe"] });
+    const ff = spawn3("ffmpeg", args, { stdio: ["pipe", "pipe", "pipe"] });
     const chunks = [];
     let stderr = "";
     ff.stdout.on("data", (d) => chunks.push(Buffer.from(d)));
@@ -22855,7 +23359,7 @@ ${scheduleItems}
           "pipe:1"
         ];
       }
-      ff = spawn2("ffmpeg", args, { stdio: ["pipe", "pipe", "pipe"] });
+      ff = spawn3("ffmpeg", args, { stdio: ["pipe", "pipe", "pipe"] });
       if (!ff.stdin || !ff.stdout || !ff.stderr) {
         throw new Error("ffmpeg stdio streams not available");
       }
@@ -23102,7 +23606,7 @@ ${scheduleItems}
       "mp4",
       "pipe:1"
     ];
-    ff = spawn2("ffmpeg", args, { stdio: ["pipe", "pipe", "pipe"] });
+    ff = spawn3("ffmpeg", args, { stdio: ["pipe", "pipe", "pipe"] });
     if (!ff.stdin || !ff.stdout || !ff.stderr) {
       throw new Error("ffmpeg stdio streams not available");
     }
@@ -23311,7 +23815,7 @@ ${scheduleItems}
         "independent_segments+temp_file",
         playlistPath
       ];
-      ff = spawn2("ffmpeg", args, { stdio: ["pipe", "pipe", "pipe"] });
+      ff = spawn3("ffmpeg", args, { stdio: ["pipe", "pipe", "pipe"] });
       if (!ff.stdin || !ff.stderr) {
         throw new Error("ffmpeg stdio streams not available");
       }
@@ -24704,7 +25208,7 @@ function selectViableUdpMethods(hasUid, methods = ALL_UDP_DISCOVERY_METHODS) {
   return methods.filter((m) => m === "local-direct");
 }
 function normalizeUid(uid) {
-  const v = uid?.trim();
+  const v = uid?.trim().toUpperCase();
   return v ? v : void 0;
 }
 function maskUid(uid) {
@@ -24783,13 +25287,13 @@ async function pingHost(host, timeoutMs = 3e3) {
     }
     return ["-c", "1", "-W", String(Math.max(1, Math.floor(timeoutMs / 1e3))), host];
   };
-  const { spawn: spawn3 } = await import("child_process");
+  const { spawn: spawn4 } = await import("child_process");
   for (const bin of pingCandidates) {
     const ranOk = await new Promise((resolve) => {
       let settled = false;
       let child;
       try {
-        child = spawn3(bin, pingArgs(bin), { stdio: "ignore" });
+        child = spawn4(bin, pingArgs(bin), { stdio: "ignore" });
       } catch {
         resolve("spawn-failed");
         return;
@@ -25443,6 +25947,10 @@ export {
   Intercom,
   BaichuanEventEmitter,
   createNativeStream,
+  ALWAYS_ON_DEFAULTS,
+  PlaceholderRenderer,
+  ContinuousVideoStream,
+  AlwaysOnController,
   BaichuanRtspServer,
   MpegTsMuxer,
   flattenAbilitiesForChannel,
@@ -25496,4 +26004,4 @@ export {
   tcpReachabilityProbe,
   autoDetectDeviceType
 };
-//# sourceMappingURL=chunk-Q4AXRV2G.js.map
+//# sourceMappingURL=chunk-WQ2TQCYP.js.map