@apocaliss92/nodelink-js 0.4.24 → 0.4.28

package/dist/index.cjs

@@ -3293,10 +3293,10 @@ function buildRtspPath(channel, stream) {
 }
 function buildRtspUrl(params) {
   const port = params.port ?? 554;
-  const path6 = buildRtspPath(params.channel, params.stream);
+  const path7 = buildRtspPath(params.channel, params.stream);
   const user = encodeURIComponent(params.username);
   const pass = encodeURIComponent(params.password);
-  return `rtsp://${user}:${pass}@${params.host}:${port}${path6}`;
+  return `rtsp://${user}:${pass}@${params.host}:${port}${path7}`;
 }
 var init_urls = __esm({
   "src/rtsp/urls.ts"() {
@@ -4845,8 +4845,8 @@ async function runMultifocalDiagnosticsConsecutively(params) {
     for (const app of rtmpApps) {
       for (const streamName of streams) {
         const streamType = streamName.includes("sub") || streamName === "sub" || streamName === "mobile" ? 1 : 0;
-        const path6 = `/${app}/channel${params.channel}_${streamName}.bcs`;
-        const u = new URL(`rtmp://${params.host}:1935${path6}`);
+        const path7 = `/${app}/channel${params.channel}_${streamName}.bcs`;
+        const u = new URL(`rtmp://${params.host}:1935${path7}`);
         u.searchParams.set("channel", params.channel.toString());
         u.searchParams.set("stream", streamType.toString());
         u.searchParams.set("user", params.username);
@@ -8334,6 +8334,7 @@ __export(index_exports, {
   ReolinkCgiApi: () => ReolinkCgiApi,
   ReolinkHttpClient: () => ReolinkHttpClient,
   Rfc4571Muxer: () => Rfc4571Muxer,
+  _resetEmailPushBusForTests: () => _resetEmailPushBusForTests,
   abilitiesHasAny: () => abilitiesHasAny,
   aesDecrypt: () => aesDecrypt,
   aesEncrypt: () => aesEncrypt,
@@ -8379,6 +8380,7 @@ __export(index_exports, {
   createBaichuanEndpointsServer: () => createBaichuanEndpointsServer,
   createDebugGateLogger: () => createDebugGateLogger,
   createDiagnosticsBundle: () => createDiagnosticsBundle,
+  createEmailPushServer: () => createEmailPushServer,
   createLogger: () => createLogger,
   createMjpegBoundary: () => createMjpegBoundary,
   createNativeStream: () => createNativeStream,
@@ -8406,6 +8408,7 @@ __export(index_exports, {
   discoverViaTcpPortScan: () => discoverViaTcpPortScan,
   discoverViaUdpBroadcast: () => discoverViaUdpBroadcast,
   discoverViaUdpDirect: () => discoverViaUdpDirect,
+  emitEmailPushEvent: () => emitEmailPushEvent,
   encodeHeader: () => encodeHeader,
   encodeMotionScopeBitmap: () => encodeMotionScopeBitmap,
   encodeMotionSensitivityListXml: () => encodeMotionSensitivityListXml,
@@ -8422,10 +8425,14 @@ __export(index_exports, {
   flattenAbilitiesForChannel: () => flattenAbilitiesForChannel,
   formatMjpegFrame: () => formatMjpegFrame,
   fullCoverageScope: () => fullCoverageScope,
+  getCameraEmailAddress: () => getCameraEmailAddress,
   getConstructedVideoStreamOptions: () => getConstructedVideoStreamOptions,
+  getEmailPushCameraResolver: () => getEmailPushCameraResolver,
   getGlobalLogger: () => getGlobalLogger,
   getH265NalType: () => getH265NalType,
+  getLastEmailPushEvent: () => getLastEmailPushEvent,
   getMjpegContentType: () => getMjpegContentType,
+  getRecentEmailPushEvents: () => getRecentEmailPushEvents,
   getSupportItemForChannel: () => getSupportItemForChannel,
   getVideoStream: () => getVideoStream,
   getVideoclipClientInfo: () => getVideoclipClientInfo,
@@ -8440,12 +8447,15 @@ __export(index_exports, {
   isTcpFailureThatShouldFallbackToUdp: () => isTcpFailureThatShouldFallbackToUdp,
   isValidH264AnnexBAccessUnit: () => isValidH264AnnexBAccessUnit,
   isValidH265AnnexBAccessUnit: () => isValidH265AnnexBAccessUnit,
+  loadEmailPushTls: () => loadEmailPushTls,
+  mapEmailPushInferredType: () => mapEmailPushInferredType,
   maskUid: () => maskUid,
   md5HexUpper: () => md5HexUpper,
   md5StrModern: () => md5StrModern,
   normalizeDayNightMode: () => normalizeDayNightMode,
   normalizeOpenClose: () => normalizeOpenClose,
   normalizeUid: () => normalizeUid,
+  onEmailPushEvent: () => onEmailPushEvent,
   packetizeAacAdtsFrame: () => packetizeAacAdtsFrame,
   packetizeAacRawFrame: () => packetizeAacRawFrame,
   packetizeH264: () => packetizeH264,
@@ -8463,6 +8473,7 @@ __export(index_exports, {
   runMultifocalDiagnosticsConsecutively: () => runMultifocalDiagnosticsConsecutively,
   sampleStreams: () => sampleStreams,
   sanitizeFixtureData: () => sanitizeFixtureData,
+  setEmailPushCameraResolver: () => setEmailPushCameraResolver,
   setGlobalLogger: () => setGlobalLogger,
   splitAnnexBToNalPayloads: () => splitAnnexBToNalPayloads,
   splitAnnexBToNals: () => splitAnnexBToNals,
@@ -13646,6 +13657,21 @@ async function* createNativeStream(api, channel, profile, options) {
   let audioSampleRate = null;
   let streamStarted = false;
   let closed = false;
+  const signal = options?.signal;
+  let sleepResolve = null;
+  let sleepTimer = null;
+  const clearSleepTimer = () => {
+    if (sleepTimer) {
+      clearTimeout(sleepTimer);
+      sleepTimer = null;
+    }
+  };
+  const handleAbort = () => {
+    clearSleepTimer();
+    const r = sleepResolve;
+    sleepResolve = null;
+    r?.();
+  };
   const onError = (_error) => {
     closed = true;
     api.logger?.warn?.(
@@ -13743,7 +13769,13 @@ async function* createNativeStream(api, channel, profile, options) {
       }
     });
     streamStarted = true;
-    const signal = options?.signal;
+    if (signal) {
+      if (signal.aborted) {
+        closed = true;
+      } else {
+        signal.addEventListener("abort", handleAbort);
+      }
+    }
     while (!closed && !signal?.aborted) {
       if (frameQueue.length > 0) {
         const frame = frameQueue.shift();
@@ -13751,31 +13783,30 @@ async function* createNativeStream(api, channel, profile, options) {
       } else {
         await new Promise((resolve) => {
           frameResolve = resolve;
-          const timer = setTimeout(() => {
+          sleepResolve = resolve;
+          sleepTimer = setTimeout(() => {
+            sleepTimer = null;
+            if (sleepResolve === resolve) sleepResolve = null;
             if (frameResolve === resolve) {
               frameResolve = null;
               resolve();
             }
           }, 1e3);
-          if (signal) {
-            const onAbort = () => {
-              clearTimeout(timer);
-              if (frameResolve === resolve) frameResolve = null;
-              resolve();
-            };
-            if (signal.aborted) {
-              clearTimeout(timer);
-              frameResolve = null;
-              resolve();
-            } else {
-              signal.addEventListener("abort", onAbort, { once: true });
-            }
+          if (signal?.aborted) {
+            clearSleepTimer();
+            sleepResolve = null;
+            frameResolve = null;
+            resolve();
           }
         });
+        sleepResolve = null;
+        clearSleepTimer();
       }
     }
   } finally {
     closed = true;
+    if (signal) signal.removeEventListener("abort", handleAbort);
+    clearSleepTimer();
     try {
       await videoStream.stop();
     } catch {
@@ -15809,12 +15840,13 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.E
         if (frame.videoType === "H264" || frame.videoType === "H265") {
           this.setFlowVideoType(frame.videoType, "native stream");
         }
-        this.flow.extractParameterSets(frame.data);
-        const { hasParamSets: hasParamSets2 } = this.flow.getFmtp();
-        if (hasParamSets2) {
+        if (!this.flow.getFmtp().hasParamSets) {
+          this.flow.extractParameterSets(frame.data);
+        }
+        if (this.flow.getFmtp().hasParamSets) {
           this.markFirstFrameReceived();
         }
-        const isKeyframe = this.isRawFrameKeyframe(frame);
+        const isKeyframe = typeof frame.isKeyframe === "boolean" ? frame.isKeyframe : this.isRawFrameKeyframe(frame);
         this.prebuffer.push({
           frame: { ...frame, data: Buffer.from(frame.data) },
           time: Date.now(),
@@ -19635,6 +19667,93 @@ var applyFloodlightSettingsToXml = (xml, settings) => {
   return modifiedXml;
 };
 
+// src/reolink/baichuan/utils/whiteLedStatusPush.ts
+var parseFloodlightStatusListPushXml = (xml) => {
+  const out = [];
+  const re = /<channel>\s*(\d+)\s*<\/channel>[\s\S]*?<status>\s*(\d+)\s*<\/status>/gi;
+  let m;
+  while ((m = re.exec(xml)) !== null) {
+    const channel = Number.parseInt(m[1] ?? "", 10);
+    const status = Number.parseInt(m[2] ?? "", 10);
+    if (!Number.isFinite(channel) || !Number.isFinite(status)) continue;
+    out.push({ channel, status });
+  }
+  return out;
+};
+
+// src/reolink/baichuan/utils/sirenStatusPush.ts
+var parseSirenStatusListPushXml = (xml) => {
+  const out = [];
+  const re = /<(?:channelId|channel)>\s*(\d+)\s*<\/(?:channelId|channel)>[\s\S]*?<status>\s*(\d+)\s*<\/status>(?:[\s\S]*?<playing>\s*(\d+)\s*<\/playing>)?/gi;
+  let m;
+  while ((m = re.exec(xml)) !== null) {
+    const channel = Number.parseInt(m[1] ?? "", 10);
+    const status = Number.parseInt(m[2] ?? "", 10);
+    if (!Number.isFinite(channel) || !Number.isFinite(status)) continue;
+    const entry = { channel, status };
+    if (m[3] !== void 0) {
+      const playing = Number.parseInt(m[3], 10);
+      if (Number.isFinite(playing)) entry.playing = playing;
+    }
+    out.push(entry);
+  }
+  return out;
+};
+
+// src/emailPush/bus.ts
+var import_node_events5 = require("events");
+var emitter = new import_node_events5.EventEmitter();
+var cameraResolver = () => void 0;
+var lastEventByCamera = /* @__PURE__ */ new Map();
+var MAX_GLOBAL_EVENTS = 300;
+var globalRecentEvents = [];
+function setEmailPushCameraResolver(resolver) {
+  cameraResolver = resolver;
+}
+function getEmailPushCameraResolver() {
+  return cameraResolver;
+}
+function onEmailPushEvent(handler) {
+  emitter.on("event", handler);
+  return () => emitter.off("event", handler);
+}
+function emitEmailPushEvent(event) {
+  lastEventByCamera.set(event.cameraId, event);
+  globalRecentEvents.unshift(event);
+  if (globalRecentEvents.length > MAX_GLOBAL_EVENTS) {
+    globalRecentEvents.length = MAX_GLOBAL_EVENTS;
+  }
+  emitter.emit("event", event);
+}
+function getLastEmailPushEvent(cameraId) {
+  return lastEventByCamera.get(cameraId);
+}
+function getRecentEmailPushEvents(limit = MAX_GLOBAL_EVENTS) {
+  const clamped = Math.max(0, Math.min(limit, MAX_GLOBAL_EVENTS));
+  return globalRecentEvents.slice(0, clamped);
+}
+function mapEmailPushInferredType(inferred) {
+  switch (inferred) {
+    case "motion":
+    case "doorbell":
+    case "people":
+    case "vehicle":
+    case "animal":
+    case "face":
+    case "package":
+      return inferred;
+    case "other":
+    default:
+      return "motion";
+  }
+}
+function _resetEmailPushBusForTests() {
+  emitter.removeAllListeners();
+  cameraResolver = () => void 0;
+  lastEventByCamera.clear();
+  globalRecentEvents.length = 0;
+}
+
 // src/reolink/baichuan/ReolinkBaichuanApi.ts
 var DUAL_LENS_DUAL_MOTION_MODELS = /* @__PURE__ */ new Set([
   "Reolink Duo PoE",
@@ -19780,7 +19899,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
    * general socket is created, logged in, and all event/push/guard listeners
    * are re-attached automatically.
    *
-   * This is a **no-op** when the API is already {@link isReady}.
+   * This is a **no-op** when the API is already ready (see `isReadyState()`).
    *
    * @throws If `close()` was called — the API is permanently closed and a new
    *         instance must be created.
@@ -19861,7 +19980,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
   /**
    * Attach event, push, channelInfo, and guard listeners to the current
    * "general" client.  Called from the constructor and from
-   * {@link reconnectGeneralSocket}.
+   * `reconnectGeneralSocket()`.
    */
   setupGeneralClientListeners() {
     const client = this.client;
@@ -19913,7 +20032,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
     });
     client.on("push", (frame) => {
       const cmdId = frame.header.cmdId;
-      if (cmdId !== BC_CMD_ID_PUSH_VIDEO_INPUT && cmdId !== BC_CMD_ID_PUSH_SERIAL && cmdId !== BC_CMD_ID_PUSH_NET_INFO && cmdId !== BC_CMD_ID_PUSH_DINGDONG_LIST && cmdId !== BC_CMD_ID_PUSH_SLEEP_STATUS && cmdId !== BC_CMD_ID_PUSH_COORDINATE_POINT_LIST) {
+      if (cmdId !== BC_CMD_ID_PUSH_VIDEO_INPUT && cmdId !== BC_CMD_ID_PUSH_SERIAL && cmdId !== BC_CMD_ID_PUSH_NET_INFO && cmdId !== BC_CMD_ID_PUSH_DINGDONG_LIST && cmdId !== BC_CMD_ID_PUSH_SLEEP_STATUS && cmdId !== BC_CMD_ID_PUSH_COORDINATE_POINT_LIST && cmdId !== BC_CMD_ID_FLOODLIGHT_STATUS_LIST && cmdId !== BC_CMD_ID_GET_AUDIO_ALARM) {
         return;
       }
       try {
@@ -21450,6 +21569,40 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
       this.econnresetStormRebootInFlight = void 0;
     });
   }
+  /**
+   * Bind this API instance to the global email-push bus so that incoming
+   * SMTP-delivered motion / AI events for the matching camera surface on
+   * this instance's standard `onSimpleEvent` channel. The consumer keeps
+   * a single subscription (`onSimpleEvent`) and gets both the native
+   * Baichuan push and the email-push transport on the same stream.
+   *
+   * - `cameraId` shorthand: match events with `event.cameraId === cameraId`.
+   * - `match`: arbitrary predicate (e.g. when the consumer uses a
+   *   nickname-based mapping or wants to handle multiple recipients).
+   *
+   * Returns an `off()` handle. Safe to call repeatedly — each call
+   * registers its own listener.
+   */
+  subscribeEmailPushEvents(params) {
+    const channel = params.channel ?? 0;
+    const matches = "match" in params ? params.match : (event) => event.cameraId === params.cameraId;
+    const off = onEmailPushEvent((event) => {
+      if (!matches(event)) return;
+      this.dispatchSimpleEvent({
+        type: mapEmailPushInferredType(event.inferredType),
+        channel,
+        timestamp: event.receivedAtMs
+      });
+      if (event.inferredType !== "motion" && event.inferredType !== "doorbell" && event.inferredType !== "other") {
+        this.dispatchSimpleEvent({
+          type: "motion",
+          channel,
+          timestamp: event.receivedAtMs
+        });
+      }
+    });
+    return off;
+  }
   /**
    * Subscribe to minimal high-level events.
    * The API manages Baichuan subscribe/unsubscribe automatically.
@@ -21508,7 +21661,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
    * Subscribe to per-frame detection events sourced from the BcMedia
    * `additionalHeader` block on active video streams.
    *
-   * Mirrors {@link onSimpleEvent} but is fed by the streaming side-channel:
+   * Mirrors `onSimpleEvent()` but is fed by the streaming side-channel:
    * one event fires for every I-frame / P-frame that carries an overlay block.
    * Coordinates are reported in normalized [0, 1] fractions of the source
    * frame, so the same box renders correctly on mainStream, subStream, and
@@ -21535,7 +21688,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
    * Subscribe to AI object detections (people / vehicle / animal / face boxes
    * with class label and confidence) without managing a video stream yourself.
    *
-   * Mirrors {@link onSimpleEvent} end-to-end: on the first listener for a given
+   * Mirrors `onSimpleEvent()` end-to-end: on the first listener for a given
    * `(channel, profile)` tuple the API ensures the corresponding video stream
    * is running (the pool socket may already be shared with a regular consumer),
    * forwards every box-bearing `additionalHeader` to your callback, and tears
@@ -25355,24 +25508,24 @@ ${stderr}`)
   async muxToMp4(params) {
     const { spawn: spawn13 } = await import("child_process");
     const { randomUUID: randomUUID3 } = await import("crypto");
-    const fs6 = await import("fs/promises");
+    const fs7 = await import("fs/promises");
     const os2 = await import("os");
-    const path6 = await import("path");
+    const path7 = await import("path");
     const ffmpeg = params.ffmpegPath ?? "ffmpeg";
     const tmpDir = os2.tmpdir();
     const id = randomUUID3();
     const videoFormat = params.videoCodec === "H265" ? "hevc" : "h264";
-    const videoPath = path6.join(tmpDir, `reolink-${id}.${videoFormat}`);
-    const outputPath = path6.join(tmpDir, `reolink-${id}.mp4`);
+    const videoPath = path7.join(tmpDir, `reolink-${id}.${videoFormat}`);
+    const outputPath = path7.join(tmpDir, `reolink-${id}.mp4`);
     let audioPath = null;
     if (params.audioData && params.audioData.length > 0 && params.audioCodec) {
       const audioExt = params.audioCodec === "Aac" ? "aac" : "raw";
-      audioPath = path6.join(tmpDir, `reolink-${id}.${audioExt}`);
+      audioPath = path7.join(tmpDir, `reolink-${id}.${audioExt}`);
     }
     try {
-      await fs6.writeFile(videoPath, params.videoData);
+      await fs7.writeFile(videoPath, params.videoData);
       if (audioPath && params.audioData) {
-        await fs6.writeFile(audioPath, params.audioData);
+        await fs7.writeFile(audioPath, params.audioData);
       }
       const args = ["-hide_banner", "-loglevel", "error", "-y"];
       if (params.fps > 0) {
@@ -25425,13 +25578,13 @@ ${stderr}`)
           }
         });
       });
-      return await fs6.readFile(outputPath);
+      return await fs7.readFile(outputPath);
     } finally {
-      await fs6.unlink(videoPath).catch(() => {
+      await fs7.unlink(videoPath).catch(() => {
       });
-      if (audioPath) await fs6.unlink(audioPath).catch(() => {
+      if (audioPath) await fs7.unlink(audioPath).catch(() => {
       });
-      await fs6.unlink(outputPath).catch(() => {
+      await fs7.unlink(outputPath).catch(() => {
       });
     }
   }
@@ -28379,7 +28532,7 @@ ${xml}`
    * Field meaning per stream:
    *  - `audio`           — 0/1 toggle
    *  - `width`/`height`  — resolution in pixels. Must be one of the
-   *                        resolutions returned by {@link getStreamInfoList}.
+   *                        resolutions returned by `getStreamInfoList()`.
    *  - `bitRate`         — kbps. Must match the table from `getStreamInfoList`.
    *  - `frameRate`       — fps. Must match the table from `getStreamInfoList`.
    *  - `videoEncType`    — `"h264"` or `"h265"`
@@ -28954,6 +29107,33 @@ ${xml}`
       };
       return;
     }
+    if (cmdId === BC_CMD_ID_FLOODLIGHT_STATUS_LIST) {
+      const entries = parseFloodlightStatusListPushXml(xml);
+      if (entries.length === 0) return;
+      for (const entry of entries) {
+        const channel = normalizePushChannel(entry.channel) ?? channelFromHeader;
+        getEntry(channel).floodlightStatus = {
+          updatedAtMs: now,
+          value: { status: entry.status === 1 }
+        };
+      }
+      return;
+    }
+    if (cmdId === BC_CMD_ID_GET_AUDIO_ALARM) {
+      const entries = parseSirenStatusListPushXml(xml);
+      if (entries.length === 0) return;
+      for (const entry of entries) {
+        const channel = normalizePushChannel(entry.channel) ?? channelFromHeader;
+        getEntry(channel).sirenStatus = {
+          updatedAtMs: now,
+          value: {
+            status: entry.status === 1,
+            ...entry.playing !== void 0 ? { playing: entry.playing === 1 } : {}
+          }
+        };
+      }
+      return;
+    }
   }
   /** Read-only snapshot of cached settings pushes (cmd_id 78/79/464/484/623/723). */
   getSettingsPushCacheSnapshot() {
@@ -28986,6 +29166,18 @@ ${xml}`
             ...entry.coordinatePointList,
             value: { ...entry.coordinatePointList.value }
           }
+        } : {},
+        ...entry.floodlightStatus ? {
+          floodlightStatus: {
+            ...entry.floodlightStatus,
+            value: { ...entry.floodlightStatus.value }
+          }
+        } : {},
+        ...entry.sirenStatus ? {
+          sirenStatus: {
+            ...entry.sirenStatus,
+            value: { ...entry.sirenStatus.value }
+          }
         } : {}
       });
     }
@@ -29009,6 +29201,29 @@ ${xml}`
   getCoordinatePointListFromPushCache(channel = 0) {
     return this.settingsPushCache.get(channel)?.coordinatePointList;
   }
+  /**
+   * Last cmd_id 291 (FloodlightStatusList) push observed for the channel.
+   * The camera emits this whenever the floodlight transitions on/off,
+   * including the auto-off after the FloodlightManual duration. This is
+   * the only reliable source for the current manual state because cmd 289
+   * only returns the FloodlightTask config.
+   *
+   * Returns undefined when no push has been received yet.
+   */
+  getCachedFloodlightStatus(channel = 0) {
+    return this.settingsPushCache.get(channel)?.floodlightStatus;
+  }
+  /**
+   * Last cmd_id 547 (SirenStatusList) push observed for the channel.
+   * Captures the actual on/off transitions including the firmware's
+   * built-in auto-off after the siren playback duration expires —
+   * polling cmd 547 alone can race that auto-off.
+   *
+   * Returns undefined when no push has been received yet.
+   */
+  getCachedSirenStatus(channel = 0) {
+    return this.settingsPushCache.get(channel)?.sirenStatus;
+  }
   // --------------------
   // PCAP-derived settings getters (typed wrappers)
   // --------------------
@@ -29706,10 +29921,12 @@ ${xml}`
     const triggers = params.triggerTypes ?? ["MD", "people", "vehicle"];
     const attachmentType = params.attachmentType ?? "picture";
     const interval = params.interval ?? 30;
+    const rawUser = params.authUsername ?? recipient;
+    const wireUser = rawUser.includes("@") ? rawUser : `${rawUser}@${domain}`;
     const emailPatch = {
       smtpServer: params.managerHost,
       smtpPort: port,
-      userName: params.authUsername ?? recipient,
+      userName: wireUser,
       password: params.authPassword ?? "",
       address1: recipient,
       address2: "",
@@ -30721,16 +30938,16 @@ ${scheduleItems}
     const logger = params.logger ?? this.logger;
     const hlsSegmentDuration = params.hlsSegmentDuration ?? 4;
     const os2 = await import("os");
-    const path6 = await import("path");
-    const fs6 = await import("fs/promises");
+    const path7 = await import("path");
+    const fs7 = await import("fs/promises");
     const crypto3 = await import("crypto");
-    const tempDir = path6.join(
+    const tempDir = path7.join(
       os2.tmpdir(),
       `reolink-hls-${crypto3.randomBytes(8).toString("hex")}`
     );
-    await fs6.mkdir(tempDir, { recursive: true });
-    const playlistPath = path6.join(tempDir, "playlist.m3u8");
-    const segmentPattern = path6.join(tempDir, "segment_%03d.ts");
+    await fs7.mkdir(tempDir, { recursive: true });
+    const playlistPath = path7.join(tempDir, "playlist.m3u8");
+    const segmentPattern = path7.join(tempDir, "segment_%03d.ts");
     const parsed = parseRecordingFileName(params.fileName);
     const durationMs = parsed?.durationMs ?? 3e5;
     const fps = parsed?.framerate && parsed.framerate > 0 ? parsed.framerate : 15;
@@ -30767,13 +30984,13 @@ ${scheduleItems}
     const segments = /* @__PURE__ */ new Map();
     const startSegmentWatcher = () => {
       if (segmentWatcher || !readyResolve) return;
-      const firstSegmentPath = path6.join(tempDir, "segment_000.ts");
+      const firstSegmentPath = path7.join(tempDir, "segment_000.ts");
       let checkCount = 0;
       const maxChecks = Math.ceil((hlsSegmentDuration + 2) * 10);
       segmentWatcher = setInterval(async () => {
         checkCount++;
         try {
-          const stats = await fs6.stat(firstSegmentPath);
+          const stats = await fs7.stat(firstSegmentPath);
           if (stats.size > 256) {
             if (segmentWatcher) {
               clearInterval(segmentWatcher);
@@ -30915,12 +31132,12 @@ ${scheduleItems}
       ]);
       setTimeout(async () => {
         try {
-          const files = await fs6.readdir(tempDir);
+          const files = await fs7.readdir(tempDir);
           for (const file of files) {
-            await fs6.unlink(path6.join(tempDir, file)).catch(() => {
+            await fs7.unlink(path7.join(tempDir, file)).catch(() => {
             });
           }
-          await fs6.rmdir(tempDir).catch(() => {
+          await fs7.rmdir(tempDir).catch(() => {
           });
         } catch {
         }
@@ -30996,7 +31213,7 @@ ${scheduleItems}
         }
         try {
           const { readFileSync } = require("fs");
-          const segmentPath = path6.join(tempDir, name);
+          const segmentPath = path7.join(tempDir, name);
           const data = readFileSync(segmentPath);
           segments.set(name, data);
           return data;
@@ -34169,7 +34386,7 @@ init_BaichuanVideoStream();
 // src/multifocal/compositeStream.ts
 var import_node_child_process7 = require("child_process");
 var import_node_crypto5 = require("crypto");
-var import_node_events5 = require("events");
+var import_node_events6 = require("events");
 function calculateOverlayPosition(position, mainWidth, mainHeight, pipWidth, pipHeight, margin) {
   const pipW = Math.floor(pipWidth);
   const pipH = Math.floor(pipHeight);
@@ -34197,7 +34414,7 @@ function calculateOverlayPosition(position, mainWidth, mainHeight, pipWidth, pip
       return { x: m, y: m };
   }
 }
-var CompositeStream = class extends import_node_events5.EventEmitter {
+var CompositeStream = class extends import_node_events6.EventEmitter {
   options;
   widerStream = null;
   teleStream = null;
@@ -36620,7 +36837,7 @@ async function createReplayHttpServer(options) {
 init_BaichuanVideoStream();
 
 // src/baichuan/stream/Go2rtcTcpServer.ts
-var import_node_events6 = require("events");
+var import_node_events7 = require("events");
 var net4 = __toESM(require("net"), 1);
 init_H264Converter();
 init_H265Converter();
@@ -36732,7 +36949,7 @@ var NativeStreamFanout2 = class {
     this.pumpPromise = null;
   }
 };
-var Go2rtcTcpServer = class _Go2rtcTcpServer extends import_node_events6.EventEmitter {
+var Go2rtcTcpServer = class _Go2rtcTcpServer extends import_node_events7.EventEmitter {
   api;
   channel;
   profile;
@@ -37423,7 +37640,7 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends import_node_events6.EventEm
 };
 
 // src/baichuan/stream/BaichuanHttpStreamServer.ts
-var import_node_events7 = require("events");
+var import_node_events8 = require("events");
 var import_node_child_process9 = require("child_process");
 var http4 = __toESM(require("http"), 1);
 var NAL_START_CODE_4B4 = Buffer.from([0, 0, 0, 1]);
@@ -37470,7 +37687,7 @@ function isH264KeyframeFromAnnexB(annexB) {
   }
   return false;
 }
-var BaichuanHttpStreamServer = class extends import_node_events7.EventEmitter {
+var BaichuanHttpStreamServer = class extends import_node_events8.EventEmitter {
   videoStream;
   listenPort;
   path;
@@ -37742,15 +37959,15 @@ var BaichuanHttpStreamServer = class extends import_node_events7.EventEmitter {
 };
 
 // src/baichuan/stream/BaichuanMjpegServer.ts
-var import_node_events9 = require("events");
+var import_node_events10 = require("events");
 var http5 = __toESM(require("http"), 1);
 
 // src/baichuan/stream/MjpegTransformer.ts
-var import_node_events8 = require("events");
+var import_node_events9 = require("events");
 var import_node_child_process10 = require("child_process");
 var JPEG_SOI = Buffer.from([255, 216]);
 var JPEG_EOI = Buffer.from([255, 217]);
-var MjpegTransformer = class extends import_node_events8.EventEmitter {
+var MjpegTransformer = class extends import_node_events9.EventEmitter {
   options;
   ffmpeg = null;
   started = false;
@@ -37949,7 +38166,7 @@ Content-Length: ${frame.length}\r
 // src/baichuan/stream/BaichuanMjpegServer.ts
 init_H264Converter();
 init_H265Converter();
-var BaichuanMjpegServer = class extends import_node_events9.EventEmitter {
+var BaichuanMjpegServer = class extends import_node_events10.EventEmitter {
   options;
   clients = /* @__PURE__ */ new Map();
   httpServer = null;
@@ -37971,9 +38188,9 @@ var BaichuanMjpegServer = class extends import_node_events9.EventEmitter {
     this.started = true;
     const port = this.options.port ?? 8080;
     const host = this.options.host ?? "0.0.0.0";
-    const path6 = this.options.path ?? "/mjpeg";
+    const path7 = this.options.path ?? "/mjpeg";
     this.httpServer = http5.createServer((req, res) => {
-      this.handleRequest(req, res, path6);
+      this.handleRequest(req, res, path7);
     });
     return new Promise((resolve, reject) => {
       this.httpServer.on("error", (err) => {
@@ -37983,9 +38200,9 @@ var BaichuanMjpegServer = class extends import_node_events9.EventEmitter {
       this.httpServer.listen(port, host, () => {
         this.log(
           "info",
-          `MJPEG server started on http://${host}:${port}${path6}`
+          `MJPEG server started on http://${host}:${port}${path7}`
         );
-        this.emit("started", { host, port, path: path6 });
+        this.emit("started", { host, port, path: path7 });
         resolve();
       });
     });
@@ -38230,14 +38447,14 @@ var BaichuanMjpegServer = class extends import_node_events9.EventEmitter {
 };
 
 // src/baichuan/stream/BaichuanWebRTCServer.ts
-var import_node_events11 = require("events");
+var import_node_events12 = require("events");
 init_BcMediaAnnexBDecoder();
 
 // src/baichuan/stream/AacToOpusTranscoder.ts
 var import_node_child_process11 = require("child_process");
 var import_node_dgram3 = require("dgram");
-var import_node_events10 = require("events");
-var AacToOpusTranscoder = class extends import_node_events10.EventEmitter {
+var import_node_events11 = require("events");
+var AacToOpusTranscoder = class extends import_node_events11.EventEmitter {
   opts;
   socket = null;
   ffmpeg = null;
@@ -38454,7 +38671,7 @@ function getH264NalType(nalUnit) {
 function getH265NalType2(nalUnit) {
   return nalUnit[0] >> 1 & 63;
 }
-var BaichuanWebRTCServer = class extends import_node_events11.EventEmitter {
+var BaichuanWebRTCServer = class extends import_node_events12.EventEmitter {
   options;
   sessions = /* @__PURE__ */ new Map();
   sessionIdCounter = 0;
@@ -39446,7 +39663,7 @@ Error: ${err}`
 };
 
 // src/baichuan/stream/BaichuanHlsServer.ts
-var import_node_events12 = require("events");
+var import_node_events13 = 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);
@@ -39526,7 +39743,7 @@ function getNalTypes(codec, annexB) {
     }
   });
 }
-var BaichuanHlsServer = class extends import_node_events12.EventEmitter {
+var BaichuanHlsServer = class extends import_node_events13.EventEmitter {
   api;
   channel;
   profile;
@@ -40550,10 +40767,10 @@ async function autoDetectDeviceType(inputs) {
 }
 
 // src/multifocal/compositeRtspServer.ts
-var import_node_events13 = require("events");
+var import_node_events14 = require("events");
 var import_node_child_process13 = require("child_process");
 var net5 = __toESM(require("net"), 1);
-var CompositeRtspServer = class extends import_node_events13.EventEmitter {
+var CompositeRtspServer = class extends import_node_events14.EventEmitter {
   options;
   compositeStream = null;
   rtspServer = null;
@@ -40846,6 +41063,272 @@ function base64DecodeToBytes(b64) {
   }
   return out.subarray(0, outIdx);
 }
+
+// src/emailPush/server.ts
+var import_smtp_server = require("smtp-server");
+var import_mailparser = require("mailparser");
+
+// src/emailPush/tls.ts
+var import_node_fs2 = __toESM(require("fs"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
+async function loadEmailPushTls(params) {
+  const certPath = import_node_path4.default.join(params.dir, "cert.pem");
+  const keyPath = import_node_path4.default.join(params.dir, "key.pem");
+  const warn = params.warn ?? ((m) => console.warn(`[email-push-tls] ${m}`));
+  if (!import_node_fs2.default.existsSync(certPath) || !import_node_fs2.default.existsSync(keyPath)) {
+    warn(
+      `Email-push TLS requested but ${certPath} or ${keyPath} is missing. Place a PEM cert+key under that directory to enable STARTTLS, or disable TLS in the consumer config to silence this warning.`
+    );
+    return void 0;
+  }
+  return {
+    cert: import_node_fs2.default.readFileSync(certPath),
+    key: import_node_fs2.default.readFileSync(keyPath)
+  };
+}
+
+// src/emailPush/server.ts
+async function defaultLoadTls(dir, warn) {
+  return loadEmailPushTls({ dir, warn });
+}
+function classifyMessage(parsed) {
+  const haystack = `${parsed.subject ?? ""} ${parsed.text ?? ""}`.toLowerCase();
+  if (/person|people|human/.test(haystack)) return "people";
+  if (/vehicle|car|truck/.test(haystack)) return "vehicle";
+  if (/dog[_\s-]?cat|pet|animal/.test(haystack)) return "animal";
+  if (/face/.test(haystack)) return "face";
+  if (/package|parcel/.test(haystack)) return "package";
+  if (/doorbell|ring(?:ing)?\s+button/.test(haystack)) return "doorbell";
+  if (/motion|alarm|alert|detect/.test(haystack)) return "motion";
+  return "other";
+}
+function getCameraEmailAddress(cameraId, domain) {
+  return `cam-${cameraId}@${domain}`;
+}
+function createEmailPushServer(params) {
+  const log = {
+    debug: params.logger?.debug ?? (() => {
+    }),
+    info: params.logger?.info ?? (() => {
+    }),
+    warn: params.logger?.warn ?? (() => {
+    }),
+    error: params.logger?.error ?? (() => {
+    })
+  };
+  let config = params.config;
+  let server;
+  let status = buildInitialStatus(config);
+  function parseRecipient(rcpt) {
+    const [local, domain] = rcpt.toLowerCase().split("@");
+    if (!local || !domain) return void 0;
+    return { local, domain };
+  }
+  function resolveCameraIdFromRecipient(rcpt) {
+    const parsed = parseRecipient(rcpt);
+    if (!parsed) return void 0;
+    if (parsed.domain !== config.domain.toLowerCase()) return void 0;
+    const match = parsed.local.match(/^cam-(.+)$/);
+    if (!match || !match[1]) return void 0;
+    return params.cameraResolver(match[1]);
+  }
+  async function handleIncomingMessage(cameraId, recipient, raw) {
+    let parsed;
+    try {
+      parsed = await (0, import_mailparser.simpleParser)(raw);
+    } catch (err) {
+      log.warn(
+        `Failed to parse mail for ${cameraId}: ${err instanceof Error ? err.message : err}`
+      );
+      status.messagesRejected++;
+      return;
+    }
+    const receivedAtMs = Date.now();
+    const event = {
+      cameraId,
+      recipient,
+      inferredType: classifyMessage(parsed),
+      receivedAtMs,
+      subject: parsed.subject ?? "",
+      from: typeof parsed.from === "object" && parsed.from !== null && "text" in parsed.from ? String(parsed.from.text) : "",
+      bodyExcerpt: (parsed.text ?? "").slice(0, 500)
+    };
+    status.messagesAccepted++;
+    log.info(
+      `Email push for camera=${cameraId} type=${event.inferredType} subject="${event.subject.slice(0, 80)}"`
+    );
+    emitEmailPushEvent(event);
+  }
+  async function start() {
+    if (server) {
+      log.debug("startEmailPushServer called but server already running");
+      return;
+    }
+    const tlsOptions = config.tls ? await (params.loadTls ?? defaultLoadTls)(
+      config.tlsDir ?? "./email-push-tls",
+      (m) => log.warn(m)
+    ) : void 0;
+    status = buildInitialStatus(config);
+    const next = new import_smtp_server.SMTPServer({
+      authOptional: !config.requireAuth,
+      disabledCommands: config.requireAuth ? [] : ["AUTH"],
+      allowInsecureAuth: !config.tls,
+      size: config.maxMessageBytes,
+      logger: {
+        info: (...args) => log.debug(`[smtp] ${args.map((a) => String(a)).join(" ")}`),
+        debug: (...args) => log.debug(`[smtp] ${args.map((a) => String(a)).join(" ")}`),
+        error: (...args) => log.warn(`[smtp] ${args.map((a) => String(a)).join(" ")}`)
+      },
+      ...tlsOptions ? { secure: false, ...tlsOptions } : {},
+      onConnect(session, callback) {
+        log.info(
+          `SMTP connect from ${session.remoteAddress} (sessionId=${session.id})`
+        );
+        callback();
+      },
+      onClose(session) {
+        log.debug(
+          `SMTP close ${session.remoteAddress} (sessionId=${session.id})`
+        );
+      },
+      onMailFrom(address, session, callback) {
+        log.info(
+          `SMTP MAIL FROM ${address.address} (sessionId=${session.id})`
+        );
+        callback();
+      },
+      onAuth(auth, session, callback) {
+        const expectedUser = config.authUsername;
+        const expectedPass = config.authPassword;
+        if (!expectedUser || !expectedPass) {
+          log.warn(
+            `SMTP AUTH rejected from ${session.remoteAddress} (sessionId=${session.id}): server has no credentials configured`
+          );
+          return callback(new Error("Email push auth not configured"));
+        }
+        const stripDomain = (u) => {
+          const at = u.lastIndexOf("@");
+          if (at < 0) return u;
+          const local = u.slice(0, at);
+          const domain = u.slice(at + 1).toLowerCase();
+          return domain === config.domain.toLowerCase() ? local : u;
+        };
+        const triedUserNorm = stripDomain(auth.username ?? "");
+        const expectedUserNorm = stripDomain(expectedUser);
+        if (triedUserNorm === expectedUserNorm && auth.password === expectedPass) {
+          log.info(
+            `SMTP AUTH ok method=${auth.method} user=${auth.username} (sessionId=${session.id})`
+          );
+          return callback(null, { user: auth.username });
+        }
+        log.warn(
+          `SMTP AUTH FAIL method=${auth.method} from=${session.remoteAddress} triedUser="${auth.username}" expectedUser="${expectedUser}" triedPasswordLen=${auth.password?.length ?? 0} (sessionId=${session.id})`
+        );
+        return callback(new Error("Invalid username or password"));
+      },
+      onRcptTo(address, _session, callback) {
+        const cameraId = resolveCameraIdFromRecipient(address.address);
+        if (!cameraId) {
+          status.messagesRejected++;
+          return callback(
+            new Error(
+              `Unknown recipient ${address.address} (not registered)`
+            )
+          );
+        }
+        callback();
+      },
+      onData(stream, session, callback) {
+        const chunks = [];
+        stream.on("data", (chunk) => chunks.push(chunk));
+        stream.on("end", () => {
+          const recipients = session.envelope.rcptTo?.map((r) => r.address) ?? [];
+          const buffer = Buffer.concat(chunks);
+          const matched = recipients.map((r) => ({
+            recipient: r,
+            cameraId: resolveCameraIdFromRecipient(r)
+          })).filter(
+            (m) => Boolean(m.cameraId)
+          );
+          if (matched.length === 0) {
+            status.messagesRejected++;
+            return callback(new Error("No recognised recipients"));
+          }
+          Promise.all(
+            matched.map(
+              (m) => handleIncomingMessage(m.cameraId, m.recipient, buffer)
+            )
+          ).then(() => callback()).catch((err) => {
+            const msg = err instanceof Error ? err.message : String(err);
+            log.error(`Email push pipeline error: ${msg}`);
+            status.lastErrorMessage = msg;
+            callback(new Error(msg));
+          });
+        });
+        stream.on("error", (err) => {
+          log.warn(`SMTP stream error: ${err.message}`);
+          callback(err);
+        });
+      }
+    });
+    next.on("error", (err) => {
+      status.lastErrorMessage = err.message;
+      log.error(`Email push server error: ${err.message}`);
+    });
+    await new Promise((resolve, reject) => {
+      next.listen(config.port, config.bindHost, () => {
+        status.running = true;
+        status.startedAtMs = Date.now();
+        log.info(
+          `Email push SMTP listening on ${config.bindHost}:${config.port} (domain=${config.domain}, auth=${config.requireAuth}, tls=${config.tls})`
+        );
+        resolve();
+      });
+      next.once("error", reject);
+    });
+    server = next;
+  }
+  async function stop() {
+    if (!server) return;
+    const active = server;
+    server = void 0;
+    await new Promise((resolve) => {
+      active.close(() => resolve());
+    });
+    status.running = false;
+    log.info("Email push SMTP server stopped");
+  }
+  async function restart() {
+    await stop();
+    await start();
+  }
+  return {
+    start,
+    stop,
+    restart,
+    getStatus() {
+      return { ...status };
+    },
+    updateConfig(next) {
+      config = next;
+    }
+  };
+}
+function buildInitialStatus(config) {
+  return {
+    enabled: true,
+    running: false,
+    port: config.port,
+    bindHost: config.bindHost,
+    domain: config.domain,
+    requireAuth: config.requireAuth,
+    tls: config.tls,
+    messagesAccepted: 0,
+    messagesRejected: 0,
+    startedAtMs: void 0,
+    lastErrorMessage: void 0
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AesStreamDecryptor,
@@ -41019,6 +41502,7 @@ function base64DecodeToBytes(b64) {
   ReolinkCgiApi,
   ReolinkHttpClient,
   Rfc4571Muxer,
+  _resetEmailPushBusForTests,
   abilitiesHasAny,
   aesDecrypt,
   aesEncrypt,
@@ -41064,6 +41548,7 @@ function base64DecodeToBytes(b64) {
   createBaichuanEndpointsServer,
   createDebugGateLogger,
   createDiagnosticsBundle,
+  createEmailPushServer,
   createLogger,
   createMjpegBoundary,
   createNativeStream,
@@ -41091,6 +41576,7 @@ function base64DecodeToBytes(b64) {
   discoverViaTcpPortScan,
   discoverViaUdpBroadcast,
   discoverViaUdpDirect,
+  emitEmailPushEvent,
   encodeHeader,
   encodeMotionScopeBitmap,
   encodeMotionSensitivityListXml,
@@ -41107,10 +41593,14 @@ function base64DecodeToBytes(b64) {
   flattenAbilitiesForChannel,
   formatMjpegFrame,
   fullCoverageScope,
+  getCameraEmailAddress,
   getConstructedVideoStreamOptions,
+  getEmailPushCameraResolver,
   getGlobalLogger,
   getH265NalType,
+  getLastEmailPushEvent,
   getMjpegContentType,
+  getRecentEmailPushEvents,
   getSupportItemForChannel,
   getVideoStream,
   getVideoclipClientInfo,
@@ -41125,12 +41615,15 @@ function base64DecodeToBytes(b64) {
   isTcpFailureThatShouldFallbackToUdp,
   isValidH264AnnexBAccessUnit,
   isValidH265AnnexBAccessUnit,
+  loadEmailPushTls,
+  mapEmailPushInferredType,
   maskUid,
   md5HexUpper,
   md5StrModern,
   normalizeDayNightMode,
   normalizeOpenClose,
   normalizeUid,
+  onEmailPushEvent,
   packetizeAacAdtsFrame,
   packetizeAacRawFrame,
   packetizeH264,
@@ -41148,6 +41641,7 @@ function base64DecodeToBytes(b64) {
   runMultifocalDiagnosticsConsecutively,
   sampleStreams,
   sanitizeFixtureData,
+  setEmailPushCameraResolver,
   setGlobalLogger,
   splitAnnexBToNalPayloads,
   splitAnnexBToNals,