@apocaliss92/nodelink-js 0.1.7 → 0.1.9

package/dist/index.js

@@ -37,7 +37,7 @@ import {
   normalizeUid,
   parseSupportXml,
   setGlobalLogger
-} from "./chunk-JMT75JNG.js";
+} from "./chunk-YUBYINJF.js";
 import {
   AesStreamDecryptor,
   BC_AES_IV,
@@ -203,7 +203,365 @@ import {
   testChannelStreams,
   xmlEscape,
   zipDirectory
-} from "./chunk-MC2BRLLE.js";
+} from "./chunk-TZFZ5WJX.js";
+
+// src/reolink/baichuan/HlsSessionManager.ts
+var withTimeout = async (p, ms, label) => {
+  let t;
+  try {
+    return await Promise.race([
+      p,
+      new Promise((_, reject) => {
+        t = setTimeout(
+          () => reject(new Error(`${label} timed out after ${ms}ms`)),
+          ms
+        );
+      })
+    ]);
+  } finally {
+    if (t) clearTimeout(t);
+  }
+};
+var HlsSessionManager = class {
+  constructor(api, options) {
+    this.api = api;
+    this.logger = options?.logger;
+    this.sessionTtlMs = options?.sessionTtlMs ?? 5 * 60 * 1e3;
+    const cleanupIntervalMs = options?.cleanupIntervalMs ?? 3e4;
+    this.cleanupTimer = setInterval(() => {
+      void this.cleanupExpiredSessions();
+    }, cleanupIntervalMs);
+  }
+  sessions = /* @__PURE__ */ new Map();
+  logger;
+  sessionTtlMs;
+  cleanupTimer;
+  creationLocks = /* @__PURE__ */ new Map();
+  /**
+   * Handle an HLS request and return the HTTP response.
+   *
+   * @param params - Request parameters
+   * @returns HTTP response ready to be sent
+   */
+  async handleRequest(params) {
+    const {
+      sessionKey,
+      hlsPath,
+      requestUrl,
+      createSession,
+      exclusiveKeyPrefix
+    } = params;
+    try {
+      let entry = this.sessions.get(sessionKey);
+      const isPlaylist = hlsPath === "playlist.m3u8" || hlsPath === "";
+      const isSegment = hlsPath.endsWith(".ts");
+      if (!entry && isSegment) {
+        this.logger?.debug?.(
+          `[HlsSessionManager] Segment request without session (likely stale after clip switch): ${sessionKey} ${hlsPath}`
+        );
+        return {
+          statusCode: 404,
+          headers: {
+            "Content-Type": "text/plain",
+            "Cache-Control": "no-store, no-cache, must-revalidate, max-age=0",
+            Pragma: "no-cache",
+            "Retry-After": "1"
+          },
+          body: "Segment not found"
+        };
+      }
+      if (!entry) {
+        if (!isPlaylist) {
+          return {
+            statusCode: 400,
+            headers: { "Content-Type": "text/plain" },
+            body: "Invalid HLS path"
+          };
+        }
+        const lockKey = exclusiveKeyPrefix ?? sessionKey;
+        await this.withCreationLock(lockKey, async () => {
+          entry = this.sessions.get(sessionKey);
+          if (entry) return;
+          if (exclusiveKeyPrefix) {
+            await this.stopOtherSessionsWithPrefix(
+              exclusiveKeyPrefix,
+              sessionKey
+            );
+          }
+          this.logger?.log?.(
+            `[HlsSessionManager] Creating new session: ${sessionKey}`
+          );
+          this.logger?.debug?.(
+            `[HlsSessionManager] createSession(): ${sessionKey}`
+          );
+          const sessionParams = await createSession();
+          this.logger?.debug?.(
+            `[HlsSessionManager] Starting createRecordingReplayHlsSession: ${sessionKey}`
+          );
+          const session = await withTimeout(
+            this.api.createRecordingReplayHlsSession({
+              channel: sessionParams.channel,
+              fileName: sessionParams.fileName,
+              ...sessionParams.isNvr !== void 0 && {
+                isNvr: sessionParams.isNvr
+              },
+              ...this.logger && { logger: this.logger },
+              ...sessionParams.deviceId && {
+                deviceId: sessionParams.deviceId
+              },
+              transcodeH265ToH264: sessionParams.transcodeH265ToH264 ?? true,
+              hlsSegmentDuration: sessionParams.hlsSegmentDuration ?? 4
+            }),
+            2e4,
+            "createRecordingReplayHlsSession"
+          );
+          try {
+            await withTimeout(
+              session.waitForReady(),
+              12e3,
+              "hls waitForReady"
+            );
+          } catch (e) {
+            this.logger?.warn?.(
+              `[HlsSessionManager] waitForReady did not complete in time for ${sessionKey}: ${e instanceof Error ? e.message : String(e)}`
+            );
+          }
+          entry = {
+            session,
+            createdAt: Date.now(),
+            lastAccessAt: Date.now()
+          };
+          this.sessions.set(sessionKey, entry);
+          this.logger?.log?.(
+            `[HlsSessionManager] Session ready: ${sessionKey}`
+          );
+        });
+        entry = this.sessions.get(sessionKey);
+        if (!entry) {
+          return {
+            statusCode: 500,
+            headers: {
+              "Content-Type": "text/plain",
+              "Cache-Control": "no-store, no-cache, must-revalidate, max-age=0",
+              Pragma: "no-cache"
+            },
+            body: "HLS session was not created"
+          };
+        }
+      }
+      entry.lastAccessAt = Date.now();
+      if (isPlaylist) {
+        return this.servePlaylist(entry.session, requestUrl, sessionKey);
+      }
+      if (isSegment) {
+        return this.serveSegment(entry.session, hlsPath, sessionKey);
+      }
+      return {
+        statusCode: 400,
+        headers: { "Content-Type": "text/plain" },
+        body: "Invalid HLS path"
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger?.error?.(
+        `[HlsSessionManager] Error handling request: ${message}`
+      );
+      return {
+        statusCode: 500,
+        headers: { "Content-Type": "text/plain" },
+        body: `HLS error: ${message}`
+      };
+    }
+  }
+  async withCreationLock(lockKey, fn) {
+    const prev = this.creationLocks.get(lockKey) ?? Promise.resolve();
+    let release;
+    const current = new Promise((resolve) => {
+      release = resolve;
+    });
+    const chained = prev.then(
+      () => current,
+      () => current
+    );
+    this.creationLocks.set(lockKey, chained);
+    await prev.catch(() => {
+    });
+    try {
+      await fn();
+    } finally {
+      release();
+      if (this.creationLocks.get(lockKey) === chained) {
+        this.creationLocks.delete(lockKey);
+      }
+    }
+  }
+  /**
+   * Check if a session exists for the given key.
+   */
+  hasSession(sessionKey) {
+    return this.sessions.has(sessionKey);
+  }
+  /**
+   * Stop a specific session.
+   */
+  async stopSession(sessionKey) {
+    const entry = this.sessions.get(sessionKey);
+    if (entry) {
+      this.logger?.debug?.(
+        `[HlsSessionManager] Stopping session: ${sessionKey}`
+      );
+      this.sessions.delete(sessionKey);
+      await entry.session.stop().catch(() => {
+      });
+    }
+  }
+  /**
+   * Stop all sessions and cleanup.
+   */
+  async stopAll() {
+    this.logger?.debug?.(`[HlsSessionManager] Stopping all sessions`);
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = void 0;
+    }
+    const stopPromises = Array.from(this.sessions.values()).map(
+      (entry) => entry.session.stop().catch(() => {
+      })
+    );
+    this.sessions.clear();
+    await Promise.all(stopPromises);
+  }
+  /**
+   * Get the number of active sessions.
+   */
+  get sessionCount() {
+    return this.sessions.size;
+  }
+  /**
+   * Serve the HLS playlist with rewritten segment URLs.
+   */
+  servePlaylist(session, requestUrl, sessionKey) {
+    let playlist = session.getPlaylist();
+    try {
+      const url = new URL(requestUrl, "http://localhost");
+      const basePath = url.pathname;
+      const baseParams = new URLSearchParams(url.searchParams);
+      baseParams.delete("hls");
+      playlist = playlist.replace(/^(segment_\d+\.ts)$/gm, (match) => {
+        const params = new URLSearchParams(baseParams);
+        params.set("hls", match);
+        return `${basePath}?${params.toString()}`;
+      });
+    } catch {
+    }
+    this.logger?.debug?.(
+      `[HlsSessionManager] Serving playlist: ${sessionKey}, length=${playlist.length}`
+    );
+    return {
+      statusCode: 200,
+      headers: {
+        "Content-Type": "application/vnd.apple.mpegurl",
+        "Cache-Control": "no-store, no-cache, must-revalidate, max-age=0",
+        Pragma: "no-cache"
+      },
+      body: playlist
+    };
+  }
+  /**
+   * Serve an HLS segment.
+   */
+  serveSegment(session, segmentName, sessionKey) {
+    const segment = session.getSegment(segmentName);
+    if (!segment) {
+      this.logger?.warn?.(
+        `[HlsSessionManager] Segment not found: ${segmentName}`
+      );
+      return {
+        statusCode: 404,
+        headers: {
+          "Content-Type": "text/plain",
+          "Cache-Control": "no-store, no-cache, must-revalidate, max-age=0",
+          Pragma: "no-cache",
+          "Retry-After": "1"
+        },
+        body: "Segment not found"
+      };
+    }
+    this.logger?.debug?.(
+      `[HlsSessionManager] Serving segment: ${segmentName} for ${sessionKey}, size=${segment.length}`
+    );
+    return {
+      statusCode: 200,
+      headers: {
+        "Content-Type": "video/mp2t",
+        "Cache-Control": "no-store, no-cache, must-revalidate, max-age=0",
+        Pragma: "no-cache",
+        "Content-Length": String(segment.length)
+      },
+      body: segment
+    };
+  }
+  /**
+   * Cleanup expired sessions.
+   */
+  async cleanupExpiredSessions() {
+    const now = Date.now();
+    const expiredKeys = [];
+    for (const [key, entry] of this.sessions) {
+      if (now - entry.lastAccessAt > this.sessionTtlMs) {
+        expiredKeys.push(key);
+      }
+    }
+    if (!expiredKeys.length) return;
+    await Promise.allSettled(
+      expiredKeys.map(async (key) => {
+        const entry = this.sessions.get(key);
+        if (!entry) return;
+        this.logger?.log?.(
+          `[HlsSessionManager] TTL expired: stopping session ${key}`
+        );
+        this.sessions.delete(key);
+        try {
+          await entry.session.stop();
+        } catch {
+        }
+      })
+    );
+  }
+  async stopOtherSessionsWithPrefix(prefix, exceptKey) {
+    const toStop = [];
+    for (const key of this.sessions.keys()) {
+      if (key !== exceptKey && key.startsWith(prefix)) toStop.push(key);
+    }
+    if (!toStop.length) return;
+    this.logger?.log?.(
+      `[HlsSessionManager] Switch: stopping ${toStop.length} session(s) for prefix=${prefix}`
+    );
+    await Promise.all(
+      toStop.map(async (key) => {
+        const entry = this.sessions.get(key);
+        if (!entry) return;
+        this.sessions.delete(key);
+        await entry.session.stop().catch(() => {
+        });
+      })
+    );
+  }
+};
+function detectIosClient(userAgent) {
+  const ua = (userAgent ?? "").toLowerCase();
+  const isIos = /iphone|ipad|ipod/.test(ua);
+  const isIosInstalledApp = ua.includes("installedapp");
+  return {
+    isIos,
+    isIosInstalledApp,
+    // iOS InstalledApp needs HLS for video playback
+    needsHls: isIos && isIosInstalledApp
+  };
+}
+function buildHlsRedirectUrl(originalUrl) {
+  return `${originalUrl}${originalUrl.includes("?") ? "&" : "?"}hls=playlist.m3u8`;
+}
 
 // src/reolink/AutodiscoveryClient.ts
 var AutodiscoveryClient = class {
@@ -495,6 +853,79 @@ var AutodiscoveryClient = class {
   }
 };
 
+// src/reolink/baichuan/types.ts
+function getVideoclipClientInfo(headers) {
+  const getHeader = (key) => {
+    const val = headers[key] ?? headers[key.toLowerCase()] ?? headers[key.toUpperCase()];
+    return Array.isArray(val) ? val[0] : val;
+  };
+  return {
+    userAgent: getHeader("user-agent") ?? getHeader("User-Agent"),
+    accept: getHeader("accept") ?? getHeader("Accept"),
+    range: getHeader("range") ?? getHeader("Range"),
+    secChUa: getHeader("sec-ch-ua") ?? getHeader("Sec-CH-UA"),
+    secChUaMobile: getHeader("sec-ch-ua-mobile") ?? getHeader("Sec-CH-UA-Mobile"),
+    secChUaPlatform: getHeader("sec-ch-ua-platform") ?? getHeader("Sec-CH-UA-Platform")
+  };
+}
+function decideVideoclipTranscodeMode(headers, forceMode) {
+  const clientInfo = getVideoclipClientInfo(headers);
+  if (forceMode) {
+    return {
+      mode: forceMode,
+      reason: `forced: ${forceMode}`,
+      clientInfo
+    };
+  }
+  const ua = (clientInfo.userAgent ?? "").toLowerCase();
+  const platform = (clientInfo.secChUaPlatform ?? "").toLowerCase().replace(/"/g, "");
+  const isIos = /iphone|ipad|ipod/.test(ua);
+  if (isIos) {
+    return {
+      mode: "transcode-h264",
+      reason: "iOS device detected - no native H.265 support in <video>",
+      clientInfo
+    };
+  }
+  const isFirefox = ua.includes("firefox");
+  if (isFirefox) {
+    return {
+      mode: "transcode-h264",
+      reason: "Firefox detected - no H.265 support",
+      clientInfo
+    };
+  }
+  const isAndroid = ua.includes("android") || platform === "android";
+  if (isAndroid) {
+    return {
+      mode: "transcode-h264",
+      reason: "Android device detected - variable H.265 support",
+      clientInfo
+    };
+  }
+  const isChromium = ua.includes("chrome") || ua.includes("edg");
+  const isMac = ua.includes("mac os") || platform === "macos";
+  if (isChromium && !isMac) {
+    return {
+      mode: "transcode-h264",
+      reason: "Chrome/Edge on non-Mac detected - limited H.265 support",
+      clientInfo
+    };
+  }
+  if (isMac) {
+    return {
+      mode: "passthrough",
+      reason: "macOS detected - native H.265 hardware decoding available",
+      clientInfo
+    };
+  }
+  return {
+    mode: "transcode-h264",
+    reason: "Unknown client - transcoding for compatibility",
+    clientInfo
+  };
+}
+
 // src/reolink/baichuan/endpoints-server.ts
 import http from "http";
 import { spawn } from "child_process";
@@ -503,6 +934,13 @@ function parseIntParam(v, def) {
   const n = Number.parseInt(v, 10);
   return Number.isFinite(n) ? n : def;
 }
+function parseBoolParam(v, def) {
+  if (v == null) return def;
+  const s = v.trim().toLowerCase();
+  if (s === "1" || s === "true" || s === "yes" || s === "y") return true;
+  if (s === "0" || s === "false" || s === "no" || s === "n") return false;
+  return def;
+}
 function parseProfile(v) {
   const p = (v ?? "sub").trim();
   if (p === "main" || p === "sub" || p === "ext") return p;
@@ -533,6 +971,11 @@ function createBaichuanEndpointsServer(opts) {
   const api = new ReolinkBaichuanApi({
     ...opts.baichuan
   });
+  const hlsManager = new HlsSessionManager(api, {
+    logger: console,
+    sessionTtlMs: 6e4,
+    cleanupIntervalMs: 5e3
+  });
   const listenHost = opts.listenHost ?? "127.0.0.1";
   const rtspListenHost = opts.rtspListenHost ?? "127.0.0.1";
   const rtspServers = /* @__PURE__ */ new Map();
@@ -578,6 +1021,46 @@ function createBaichuanEndpointsServer(opts) {
         res.end(JSON.stringify({ rtspUrl }));
         return;
       }
+      if (u.pathname === "/hls") {
+        const channel = parseIntParam(u.searchParams.get("channel"), 0);
+        const fileName = (u.searchParams.get("fileName") ?? "").trim();
+        const deviceId = (u.searchParams.get("deviceId") ?? "anon").trim();
+        const isNvr = parseBoolParam(u.searchParams.get("isNvr"), false);
+        const transcode = parseBoolParam(u.searchParams.get("transcode"), true);
+        const hlsSegmentDuration = parseIntParam(
+          u.searchParams.get("hlsSegmentDuration"),
+          2
+        );
+        const hlsPath = (u.searchParams.get("hls") ?? "playlist.m3u8").trim();
+        if (!fileName) {
+          res.statusCode = 400;
+          res.end("Missing fileName");
+          return;
+        }
+        const sessionKey = `hls:${deviceId}:ch${channel}:${fileName}`;
+        const exclusiveKeyPrefix = `hls:${deviceId}:ch${channel}:`;
+        const requestUrl = `http://${listenHost}:${opts.listenPort}${u.pathname}${u.search}`;
+        const result = await hlsManager.handleRequest({
+          sessionKey,
+          hlsPath,
+          requestUrl,
+          exclusiveKeyPrefix,
+          createSession: () => ({
+            channel,
+            fileName,
+            isNvr,
+            deviceId,
+            transcodeH265ToH264: transcode,
+            hlsSegmentDuration
+          })
+        });
+        res.statusCode = result.statusCode;
+        for (const [k, v] of Object.entries(result.headers)) {
+          res.setHeader(k, v);
+        }
+        res.end(result.body);
+        return;
+      }
       if (u.pathname === "/download") {
         const channel = parseIntParam(u.searchParams.get("channel"), 0);
         const uid = (u.searchParams.get("uid") ?? "").trim();
@@ -4308,11 +4791,1870 @@ var BaichuanHttpStreamServer = class extends EventEmitter2 {
   }
 };
 
-// src/multifocal/compositeRtspServer.ts
+// src/baichuan/stream/BaichuanMjpegServer.ts
+import { EventEmitter as EventEmitter4 } from "events";
+import * as http5 from "http";
+
+// src/baichuan/stream/MjpegTransformer.ts
 import { EventEmitter as EventEmitter3 } from "events";
 import { spawn as spawn6 } from "child_process";
+var JPEG_SOI = Buffer.from([255, 216]);
+var JPEG_EOI = Buffer.from([255, 217]);
+var MjpegTransformer = class extends EventEmitter3 {
+  options;
+  ffmpeg = null;
+  started = false;
+  closed = false;
+  jpegBuffer = Buffer.alloc(0);
+  frameCount = 0;
+  lastTimestamp = 0;
+  constructor(options) {
+    super();
+    this.options = {
+      codec: options.codec,
+      quality: options.quality ?? 5,
+      width: options.width,
+      height: options.height,
+      maxFps: options.maxFps,
+      logger: options.logger
+    };
+  }
+  /**
+   * Start the transformer (spawns FFmpeg process)
+   */
+  start() {
+    if (this.started || this.closed) return;
+    this.started = true;
+    const { codec, quality, width, height, maxFps } = this.options;
+    const args = [
+      "-hide_banner",
+      "-loglevel",
+      "error",
+      // Input: raw video from stdin
+      "-f",
+      codec === "h265" ? "hevc" : "h264",
+      "-i",
+      "pipe:0"
+    ];
+    const filters = [];
+    if (width || height) {
+      const w = width ?? -1;
+      const h = height ?? -1;
+      filters.push(`scale=${w}:${h}`);
+    }
+    if (maxFps) {
+      filters.push(`fps=${maxFps}`);
+    }
+    if (filters.length > 0) {
+      args.push("-vf", filters.join(","));
+    }
+    args.push(
+      "-c:v",
+      "mjpeg",
+      "-q:v",
+      String(quality),
+      "-f",
+      "mjpeg",
+      "pipe:1"
+    );
+    this.log("debug", `Starting FFmpeg with args: ${args.join(" ")}`);
+    this.ffmpeg = spawn6("ffmpeg", args, {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.ffmpeg.stdout.on("data", (data) => {
+      this.handleJpegData(data);
+    });
+    this.ffmpeg.stderr.on("data", (data) => {
+      const msg = data.toString().trim();
+      if (msg) {
+        this.log("debug", `FFmpeg: ${msg}`);
+      }
+    });
+    this.ffmpeg.on("close", (code) => {
+      this.log("debug", `FFmpeg closed with code ${code}`);
+      this.ffmpeg = null;
+      if (!this.closed) {
+        this.emit("close", code);
+      }
+    });
+    this.ffmpeg.on("error", (err) => {
+      this.log("error", `FFmpeg error: ${err.message}`);
+      this.emit("error", err);
+    });
+  }
+  /**
+   * Push an H.264/H.265 access unit (Annex-B format with start codes)
+   */
+  push(accessUnit, timestamp) {
+    if (!this.started || this.closed || !this.ffmpeg) {
+      return;
+    }
+    this.lastTimestamp = timestamp ?? Date.now() * 1e3;
+    try {
+      this.ffmpeg.stdin.write(accessUnit);
+    } catch (err) {
+      this.log("error", `Failed to write to FFmpeg: ${err}`);
+    }
+  }
+  /**
+   * Handle JPEG data from FFmpeg stdout
+   * FFmpeg outputs complete JPEG images, each starting with SOI (0xFFD8)
+   * and ending with EOI (0xFFD9)
+   */
+  handleJpegData(data) {
+    this.jpegBuffer = Buffer.concat([this.jpegBuffer, data]);
+    while (true) {
+      const soiIndex = this.jpegBuffer.indexOf(JPEG_SOI);
+      if (soiIndex < 0) {
+        this.jpegBuffer = Buffer.alloc(0);
+        break;
+      }
+      if (soiIndex > 0) {
+        this.jpegBuffer = this.jpegBuffer.subarray(soiIndex);
+      }
+      const eoiIndex = this.jpegBuffer.indexOf(JPEG_EOI, 2);
+      if (eoiIndex < 0) {
+        break;
+      }
+      const frameEnd = eoiIndex + 2;
+      const jpegFrame = this.jpegBuffer.subarray(0, frameEnd);
+      this.jpegBuffer = this.jpegBuffer.subarray(frameEnd);
+      this.frameCount++;
+      const frame = {
+        data: jpegFrame,
+        timestamp: this.lastTimestamp
+      };
+      this.emit("frame", frame);
+    }
+  }
+  /**
+   * Stop the transformer
+   */
+  async stop() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.ffmpeg) {
+      try {
+        this.ffmpeg.stdin.end();
+      } catch {
+      }
+      await new Promise((resolve) => {
+        const ff = this.ffmpeg;
+        if (!ff) {
+          resolve();
+          return;
+        }
+        const timeout = setTimeout(() => {
+          ff.kill("SIGKILL");
+          resolve();
+        }, 1e3);
+        ff.once("close", () => {
+          clearTimeout(timeout);
+          resolve();
+        });
+        try {
+          ff.kill("SIGTERM");
+        } catch {
+          clearTimeout(timeout);
+          resolve();
+        }
+      });
+      this.ffmpeg = null;
+    }
+    this.emit("close", 0);
+  }
+  /**
+   * Get frame count
+   */
+  getFrameCount() {
+    return this.frameCount;
+  }
+  /**
+   * Check if running
+   */
+  isRunning() {
+    return this.started && !this.closed && this.ffmpeg !== null;
+  }
+  log(level, message) {
+    this.options.logger?.(level, `[MjpegTransformer] ${message}`);
+  }
+};
+function createMjpegBoundary() {
+  return `mjpegboundary${Date.now()}`;
+}
+function getMjpegContentType(boundary) {
+  return `multipart/x-mixed-replace; boundary=${boundary}`;
+}
+function formatMjpegFrame(frame, boundary) {
+  const header = Buffer.from(
+    `--${boundary}\r
+Content-Type: image/jpeg\r
+Content-Length: ${frame.length}\r
+\r
+`
+  );
+  return Buffer.concat([header, frame, Buffer.from("\r\n")]);
+}
+
+// src/baichuan/stream/BaichuanMjpegServer.ts
+var BaichuanMjpegServer = class extends EventEmitter4 {
+  options;
+  clients = /* @__PURE__ */ new Map();
+  httpServer = null;
+  transformer = null;
+  nativeStream = null;
+  streamPump = null;
+  detectedCodec = null;
+  started = false;
+  clientIdCounter = 0;
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+  /**
+   * Start the MJPEG server
+   */
+  async start() {
+    if (this.started) return;
+    this.started = true;
+    const port = this.options.port ?? 8080;
+    const host = this.options.host ?? "0.0.0.0";
+    const path2 = this.options.path ?? "/mjpeg";
+    this.httpServer = http5.createServer((req, res) => {
+      this.handleRequest(req, res, path2);
+    });
+    return new Promise((resolve, reject) => {
+      this.httpServer.on("error", (err) => {
+        this.log("error", `HTTP server error: ${err.message}`);
+        reject(err);
+      });
+      this.httpServer.listen(port, host, () => {
+        this.log(
+          "info",
+          `MJPEG server started on http://${host}:${port}${path2}`
+        );
+        this.emit("started", { host, port, path: path2 });
+        resolve();
+      });
+    });
+  }
+  /**
+   * Stop the MJPEG server
+   */
+  async stop() {
+    if (!this.started) return;
+    this.started = false;
+    for (const [id, client] of this.clients) {
+      try {
+        client.response.end();
+      } catch {
+      }
+      this.clients.delete(id);
+    }
+    await this.stopStream();
+    if (this.httpServer) {
+      await new Promise((resolve) => {
+        this.httpServer.close(() => resolve());
+      });
+      this.httpServer = null;
+    }
+    this.log("info", "MJPEG server stopped");
+    this.emit("stopped");
+  }
+  /**
+   * Handle HTTP request
+   */
+  handleRequest(req, res, expectedPath) {
+    const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+    if (url.pathname !== expectedPath) {
+      res.statusCode = 404;
+      res.end("Not Found");
+      return;
+    }
+    if (req.method !== "GET") {
+      res.statusCode = 405;
+      res.end("Method Not Allowed");
+      return;
+    }
+    this.handleMjpegClient(req, res);
+  }
+  /**
+   * Handle new MJPEG client
+   */
+  handleMjpegClient(req, res) {
+    const clientId = `client-${++this.clientIdCounter}`;
+    const boundary = createMjpegBoundary();
+    const client = {
+      id: clientId,
+      response: res,
+      boundary,
+      connectedAt: Date.now()
+    };
+    this.clients.set(clientId, client);
+    this.log(
+      "info",
+      `MJPEG client connected: ${clientId} (total: ${this.clients.size})`
+    );
+    this.emit("client-connected", { id: clientId, total: this.clients.size });
+    res.writeHead(200, {
+      "Content-Type": getMjpegContentType(boundary),
+      "Cache-Control": "no-cache, no-store, must-revalidate",
+      Pragma: "no-cache",
+      Expires: "0",
+      Connection: "close"
+    });
+    const cleanup = () => {
+      this.clients.delete(clientId);
+      this.log(
+        "info",
+        `MJPEG client disconnected: ${clientId} (remaining: ${this.clients.size})`
+      );
+      this.emit("client-disconnected", {
+        id: clientId,
+        total: this.clients.size
+      });
+      if (this.clients.size === 0) {
+        this.stopStream();
+      }
+    };
+    req.on("close", cleanup);
+    res.on("close", cleanup);
+    res.on("error", cleanup);
+    if (!this.transformer) {
+      this.startStream();
+    }
+  }
+  /**
+   * Start the native video stream and MJPEG transformer
+   */
+  async startStream() {
+    if (this.transformer) return;
+    this.log("info", "Starting native video stream...");
+    const { api, channel, profile, variant, quality, width, height, maxFps } = this.options;
+    try {
+      this.nativeStream = createNativeStream(
+        api,
+        channel,
+        profile,
+        variant ? { variant } : void 0
+      );
+      this.streamPump = this.pumpStream();
+    } catch (err) {
+      this.log("error", `Failed to start stream: ${err}`);
+      this.emit("error", err);
+    }
+  }
+  /**
+   * Pump native stream and feed to transformer
+   */
+  async pumpStream() {
+    if (!this.nativeStream) return;
+    let frameBuffer = [];
+    let waitingForKeyframe = true;
+    try {
+      for await (const frame of this.nativeStream) {
+        if (!this.started || this.clients.size === 0) break;
+        const { type, data, microseconds, videoType } = frame;
+        if (type !== "Iframe" && type !== "Pframe") continue;
+        if (!data || data.length === 0) continue;
+        let annexB;
+        if (videoType === "H265") {
+          annexB = convertToAnnexB2(data);
+          if (!this.detectedCodec) {
+            this.detectedCodec = "h265";
+            this.initTransformer();
+          }
+        } else {
+          annexB = convertToAnnexB(data);
+          if (!this.detectedCodec) {
+            this.detectedCodec = "h264";
+            this.initTransformer();
+          }
+        }
+        if (waitingForKeyframe) {
+          if (type === "Iframe") {
+            waitingForKeyframe = false;
+          } else {
+            continue;
+          }
+        }
+        if (this.transformer) {
+          this.transformer.push(annexB, microseconds);
+        }
+      }
+    } catch (err) {
+      if (this.started) {
+        this.log("error", `Stream error: ${err}`);
+        this.emit("error", err);
+      }
+    }
+  }
+  /**
+   * Initialize MJPEG transformer once codec is detected
+   */
+  initTransformer() {
+    if (this.transformer || !this.detectedCodec) return;
+    const { quality, width, height, maxFps } = this.options;
+    this.transformer = new MjpegTransformer({
+      codec: this.detectedCodec,
+      quality,
+      width,
+      height,
+      maxFps,
+      logger: this.options.logger
+    });
+    this.transformer.on("frame", (frame) => {
+      this.broadcastFrame(frame);
+    });
+    this.transformer.on("error", (err) => {
+      this.log("error", `Transformer error: ${err}`);
+    });
+    this.transformer.on("close", () => {
+      this.log("debug", "Transformer closed");
+    });
+    this.transformer.start();
+    this.log(
+      "info",
+      `MJPEG transformer started (codec: ${this.detectedCodec})`
+    );
+  }
+  /**
+   * Broadcast JPEG frame to all connected clients
+   */
+  broadcastFrame(frame) {
+    for (const client of this.clients.values()) {
+      try {
+        const mjpegData = formatMjpegFrame(frame.data, client.boundary);
+        client.response.write(mjpegData);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Stop the stream and transformer
+   */
+  async stopStream() {
+    if (this.transformer) {
+      await this.transformer.stop();
+      this.transformer = null;
+    }
+    if (this.nativeStream) {
+      try {
+        await this.nativeStream.return(void 0);
+      } catch {
+      }
+      this.nativeStream = null;
+    }
+    if (this.streamPump) {
+      try {
+        await this.streamPump;
+      } catch {
+      }
+      this.streamPump = null;
+    }
+    this.detectedCodec = null;
+    this.log("debug", "Stream stopped");
+  }
+  /**
+   * Get current number of connected clients
+   */
+  getClientCount() {
+    return this.clients.size;
+  }
+  /**
+   * Get server status
+   */
+  getStatus() {
+    return {
+      running: this.started,
+      clients: this.clients.size,
+      codec: this.detectedCodec,
+      frames: this.transformer?.getFrameCount() ?? 0
+    };
+  }
+  log(level, message) {
+    this.options.logger?.(level, `[BaichuanMjpegServer] ${message}`);
+  }
+};
+
+// src/baichuan/stream/BaichuanWebRTCServer.ts
+import { EventEmitter as EventEmitter5 } from "events";
+function parseAnnexBNalUnits(annexB) {
+  const nalUnits = [];
+  let offset = 0;
+  while (offset < annexB.length) {
+    let startCodeLen = 0;
+    if (offset + 4 <= annexB.length && annexB[offset] === 0 && annexB[offset + 1] === 0 && annexB[offset + 2] === 0 && annexB[offset + 3] === 1) {
+      startCodeLen = 4;
+    } else if (offset + 3 <= annexB.length && annexB[offset] === 0 && annexB[offset + 1] === 0 && annexB[offset + 2] === 1) {
+      startCodeLen = 3;
+    } else {
+      offset++;
+      continue;
+    }
+    const naluStart = offset + startCodeLen;
+    let naluEnd = annexB.length;
+    for (let i = naluStart; i < annexB.length - 2; i++) {
+      if (annexB[i] === 0 && annexB[i + 1] === 0 && (annexB[i + 2] === 1 || i + 3 < annexB.length && annexB[i + 2] === 0 && annexB[i + 3] === 1)) {
+        naluEnd = i;
+        break;
+      }
+    }
+    if (naluEnd > naluStart) {
+      nalUnits.push(annexB.subarray(naluStart, naluEnd));
+    }
+    offset = naluEnd;
+  }
+  return nalUnits;
+}
+function getH264NalType(nalUnit) {
+  return nalUnit[0] & 31;
+}
+function getH265NalType2(nalUnit) {
+  return nalUnit[0] >> 1 & 63;
+}
+var BaichuanWebRTCServer = class extends EventEmitter5 {
+  options;
+  sessions = /* @__PURE__ */ new Map();
+  sessionIdCounter = 0;
+  weriftModule = null;
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+  /**
+   * Initialize werift module (lazy load to avoid requiring it if not used)
+   */
+  async loadWerift() {
+    if (this.weriftModule) return this.weriftModule;
+    try {
+      this.weriftModule = await import("werift");
+      return this.weriftModule;
+    } catch (err) {
+      throw new Error(
+        `Failed to load werift module. Make sure it's installed: npm install werift
+Error: ${err}`
+      );
+    }
+  }
+  /**
+   * Create a new WebRTC session
+   * Returns a session ID and SDP offer to send to the browser
+   */
+  async createSession() {
+    const werift = await this.loadWerift();
+    const { RTCPeerConnection, MediaStreamTrack, RTCRtpCodecParameters } = werift;
+    const sessionId = `webrtc-${++this.sessionIdCounter}-${Date.now()}`;
+    this.log("info", `Creating WebRTC session ${sessionId}`);
+    const iceServers = [];
+    const stunServers = this.options.stunServers ?? [
+      "stun:stun.l.google.com:19302"
+    ];
+    for (const urls of stunServers) {
+      iceServers.push({ urls });
+    }
+    if (this.options.turnServers) {
+      iceServers.push(...this.options.turnServers);
+    }
+    const peerConnection = new RTCPeerConnection({
+      iceServers,
+      codecs: {
+        video: [
+          new RTCRtpCodecParameters({
+            mimeType: "video/H264",
+            clockRate: 9e4,
+            rtcpFeedback: [
+              { type: "nack" },
+              { type: "nack", parameter: "pli" },
+              { type: "goog-remb" }
+            ],
+            parameters: "packetization-mode=1;profile-level-id=42e01f;level-asymmetry-allowed=1"
+          })
+        ],
+        audio: [
+          new RTCRtpCodecParameters({
+            mimeType: "audio/opus",
+            clockRate: 48e3,
+            channels: 2
+          })
+        ]
+      }
+    });
+    const session = {
+      id: sessionId,
+      peerConnection,
+      videoTrack: null,
+      audioTrack: null,
+      videoDataChannel: null,
+      nativeStream: null,
+      intercom: null,
+      dataChannel: null,
+      videoCodec: null,
+      createdAt: /* @__PURE__ */ new Date(),
+      state: "connecting",
+      stats: {
+        videoFrames: 0,
+        audioFrames: 0,
+        bytesSent: 0,
+        intercomBytesSent: 0
+      }
+    };
+    this.sessions.set(sessionId, session);
+    const videoSsrc = Math.random() * 4294967295 >>> 0;
+    const videoTrack = new MediaStreamTrack({ kind: "video", ssrc: videoSsrc });
+    const videoSender = peerConnection.addTrack(videoTrack);
+    session.videoTrack = videoTrack;
+    this.log(
+      "info",
+      `Video track created: ssrc=${videoTrack.ssrc}, sender params=${JSON.stringify(videoSender?.getParameters?.() ?? {})}`
+    );
+    const audioSsrc = Math.random() * 4294967295 >>> 0;
+    const audioTrack = new MediaStreamTrack({ kind: "audio", ssrc: audioSsrc });
+    peerConnection.addTrack(audioTrack);
+    session.audioTrack = audioTrack;
+    const videoDataChannel = peerConnection.createDataChannel("video", {
+      ordered: true,
+      maxRetransmits: 0
+      // Unreliable for real-time video
+    });
+    session.videoDataChannel = videoDataChannel;
+    videoDataChannel.onopen = () => {
+      this.log("info", `Video data channel opened for session ${sessionId}`);
+    };
+    if (this.options.enableIntercom) {
+      const dataChannel = peerConnection.createDataChannel("intercom", {
+        ordered: true
+      });
+      session.dataChannel = dataChannel;
+      dataChannel.onopen = () => {
+        this.log(
+          "info",
+          `Intercom data channel opened for session ${sessionId}`
+        );
+        this.emit("intercom-started", { sessionId });
+      };
+      dataChannel.onmessage = async (event) => {
+        if (session.intercom && event.data instanceof ArrayBuffer) {
+          try {
+            const audioData = Buffer.from(event.data);
+            await session.intercom.sendAudio(audioData);
+            session.stats.intercomBytesSent += audioData.length;
+          } catch (err) {
+            this.log("error", `Failed to send intercom audio: ${err}`);
+          }
+        }
+      };
+      dataChannel.onclose = () => {
+        this.log(
+          "info",
+          `Intercom data channel closed for session ${sessionId}`
+        );
+        this.emit("intercom-stopped", { sessionId });
+      };
+    }
+    peerConnection.iceConnectionStateChange.subscribe((state) => {
+      this.log("info", `ICE connection state for ${sessionId}: ${state}`);
+      if (state === "connected") {
+        session.state = "connected";
+        this.emit("session-connected", { sessionId });
+      } else if (state === "failed") {
+        session.state = state;
+        this.closeSession(sessionId).catch((err) => {
+          this.log("error", `Error closing session on ICE ${state}: ${err}`);
+        });
+      }
+    });
+    peerConnection.connectionStateChange.subscribe((state) => {
+      this.log("debug", `Connection state for ${sessionId}: ${state}`);
+      if (state === "closed" || state === "failed") {
+        this.closeSession(sessionId).catch((err) => {
+          this.log(
+            "error",
+            `Error closing session on connection ${state}: ${err}`
+          );
+        });
+      }
+    });
+    const offer = await peerConnection.createOffer();
+    await peerConnection.setLocalDescription(offer);
+    await this.waitForIceGathering(peerConnection, 3e3);
+    const localDescription = peerConnection.localDescription;
+    if (!localDescription) {
+      throw new Error("Failed to create local description");
+    }
+    this.emit("session-created", { sessionId });
+    return {
+      sessionId,
+      offer: {
+        sdp: localDescription.sdp,
+        type: "offer"
+      }
+    };
+  }
+  /**
+   * Handle WebRTC answer from browser and start streaming
+   */
+  async handleAnswer(sessionId, answer) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+    const werift = await this.loadWerift();
+    const { RTCSessionDescription } = werift;
+    this.log("info", `Handling WebRTC answer for session ${sessionId}`);
+    await session.peerConnection.setRemoteDescription(
+      new RTCSessionDescription(answer.sdp, answer.type)
+    );
+    await this.startNativeStream(session);
+    if (this.options.enableIntercom && session.dataChannel) {
+      await this.startIntercom(session);
+    }
+  }
+  /**
+   * Add ICE candidate from browser
+   */
+  async addIceCandidate(sessionId, candidate) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+    const werift = await this.loadWerift();
+    const { RTCIceCandidate } = werift;
+    await session.peerConnection.addIceCandidate(
+      new RTCIceCandidate(candidate.candidate, candidate.sdpMid ?? "0")
+    );
+  }
+  /**
+   * Close a WebRTC session
+   */
+  async closeSession(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+    this.log("info", `Closing WebRTC session ${sessionId}`);
+    session.state = "disconnected";
+    if (session.intercom) {
+      try {
+        await session.intercom.stop();
+      } catch (err) {
+        this.log("debug", `Error stopping intercom: ${err}`);
+      }
+      session.intercom = null;
+    }
+    if (session.dataChannel) {
+      try {
+        session.dataChannel.close();
+      } catch (err) {
+        this.log("debug", `Error closing data channel: ${err}`);
+      }
+      session.dataChannel = null;
+    }
+    if (session.cleanup) {
+      session.cleanup();
+    }
+    try {
+      await session.peerConnection.close();
+    } catch (err) {
+      this.log("debug", `Error closing peer connection: ${err}`);
+    }
+    this.sessions.delete(sessionId);
+    this.emit("session-closed", { sessionId });
+    this.log(
+      "info",
+      `WebRTC session ${sessionId} closed (active sessions: ${this.sessions.size})`
+    );
+  }
+  /**
+   * Get information about all active sessions
+   */
+  getSessions() {
+    return Array.from(this.sessions.values()).map((s) => ({
+      id: s.id,
+      state: s.state,
+      createdAt: s.createdAt,
+      stats: { ...s.stats }
+    }));
+  }
+  /**
+   * Get information about a specific session
+   */
+  getSession(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return null;
+    return {
+      id: session.id,
+      state: session.state,
+      createdAt: session.createdAt,
+      stats: { ...session.stats }
+    };
+  }
+  /**
+   * Close all sessions and stop the server
+   */
+  async stop() {
+    this.log("info", "Stopping WebRTC server");
+    const sessionIds = Array.from(this.sessions.keys());
+    await Promise.all(sessionIds.map((id) => this.closeSession(id)));
+    this.log("info", "WebRTC server stopped");
+  }
+  /**
+   * Get the number of active sessions
+   */
+  get sessionCount() {
+    return this.sessions.size;
+  }
+  // ============================================================================
+  // Private Methods
+  // ============================================================================
+  /**
+   * Wait for ICE gathering to complete
+   */
+  async waitForIceGathering(pc, timeoutMs) {
+    if (pc.iceGatheringState === "complete") return;
+    return new Promise((resolve) => {
+      const timeout = setTimeout(() => {
+        resolve();
+      }, timeoutMs);
+      pc.iceGatheringStateChange.subscribe((state) => {
+        if (state === "complete") {
+          clearTimeout(timeout);
+          resolve();
+        }
+      });
+    });
+  }
+  /**
+   * Start native Baichuan stream and pump frames to WebRTC
+   */
+  async startNativeStream(session) {
+    this.log(
+      "info",
+      `Starting native stream for session ${session.id} (channel=${this.options.channel}, profile=${this.options.profile})`
+    );
+    session.nativeStream = createNativeStream(
+      this.options.api,
+      this.options.channel,
+      this.options.profile,
+      this.options.variant !== void 0 ? { variant: this.options.variant } : void 0
+    );
+    this.pumpFramesToWebRTC(session).catch((err) => {
+      this.log("error", `Frame pump error for session ${session.id}: ${err}`);
+      this.closeSession(session.id).catch(() => {
+      });
+    });
+  }
+  /**
+   * Pump frames from native stream to WebRTC tracks
+   * H.264 → RTP media track (standard WebRTC)
+   * H.265 → DataChannel with raw Annex-B frames (decoded by WebCodecs in browser)
+   */
+  async pumpFramesToWebRTC(session) {
+    if (!session.nativeStream) {
+      this.log("warn", `No native stream for session ${session.id}`);
+      return;
+    }
+    this.log("info", `Starting frame pump for session ${session.id}`);
+    const werift = await this.loadWerift();
+    const { RtpPacket, RtpHeader } = werift;
+    let sequenceNumber = Math.floor(Math.random() * 65535);
+    let timestamp = Math.floor(Math.random() * 4294967295);
+    const videoClockRate = 9e4;
+    let lastTimeMicros = 0;
+    let lastLogTime = Date.now();
+    let packetsSentSinceLastLog = 0;
+    let frameNumber = 0;
+    try {
+      this.log("info", `Entering frame loop for session ${session.id}`);
+      for await (const frame of session.nativeStream) {
+        if (session.state === "disconnected" || session.state === "failed") {
+          this.log(
+            "debug",
+            `Session ${session.id} state is ${session.state}, breaking frame loop`
+          );
+          break;
+        }
+        if (frame.audio) {
+          session.stats.audioFrames++;
+        } else {
+          if (frame.data) {
+            if (!session.videoCodec && frame.videoType) {
+              const detected = detectVideoCodecFromNal(frame.data);
+              session.videoCodec = detected ?? frame.videoType;
+              this.log("info", `Detected video codec: ${session.videoCodec}`);
+              if (session.videoDataChannel && session.videoDataChannel.readyState === "open") {
+                const codecInfo = JSON.stringify({
+                  type: "codec",
+                  codec: session.videoCodec,
+                  width: frame.width || 0,
+                  height: frame.height || 0
+                });
+                session.videoDataChannel.send(codecInfo);
+              }
+            }
+            if (frame.microseconds && lastTimeMicros > 0) {
+              const deltaMicros = frame.microseconds - lastTimeMicros;
+              const deltaTicks = Math.floor(
+                deltaMicros / 1e6 * videoClockRate
+              );
+              timestamp = timestamp + deltaTicks >>> 0;
+            } else {
+              timestamp = timestamp + 3e3 >>> 0;
+            }
+            lastTimeMicros = frame.microseconds || 0;
+            if (session.videoCodec === "H264") {
+              const connState = session.peerConnection.connectionState;
+              const iceState = session.peerConnection.iceConnectionState;
+              const isConnected = connState === "connected" || iceState === "connected" || iceState === "completed";
+              if (!isConnected) {
+                if (frameNumber < 10) {
+                  this.log(
+                    "debug",
+                    `Waiting for connection, dropping H.264 frame ${frameNumber}`
+                  );
+                }
+                frameNumber++;
+                continue;
+              }
+              const packetsSent = await this.sendH264Frame(
+                session,
+                werift,
+                frame.data,
+                sequenceNumber,
+                timestamp
+              );
+              sequenceNumber = sequenceNumber + packetsSent & 65535;
+              packetsSentSinceLastLog += packetsSent;
+              frameNumber++;
+              session.stats.videoFrames++;
+              session.stats.bytesSent += frame.data.length;
+            } else if (session.videoCodec === "H265") {
+              const sent = await this.sendVideoFrameViaDataChannel(
+                session,
+                frame,
+                frameNumber,
+                "H265"
+              );
+              if (sent) {
+                packetsSentSinceLastLog++;
+                frameNumber++;
+                session.stats.videoFrames++;
+                session.stats.bytesSent += frame.data.length;
+              }
+            }
+            const now = Date.now();
+            if (now - lastLogTime >= 5e3) {
+              this.log(
+                "debug",
+                `WebRTC session ${session.id} [${session.videoCodec}]: sent ${session.stats.videoFrames} frames, ${packetsSentSinceLastLog} packets, ${Math.round(session.stats.bytesSent / 1024)} KB`
+              );
+              lastLogTime = now;
+              packetsSentSinceLastLog = 0;
+            }
+          }
+        }
+      }
+    } catch (err) {
+      this.log(
+        "error",
+        `Error pumping frames for session ${session.id}: ${err}`
+      );
+    }
+    this.log("info", `Native stream ended for session ${session.id}`);
+  }
+  /**
+   * Send H.264 frame via RTP media track
+   * Returns the number of RTP packets sent
+   */
+  async sendH264Frame(session, werift, frameData, sequenceNumber, timestamp) {
+    const annexB = convertToAnnexB(frameData);
+    const nalUnits = splitAnnexBToNalPayloads(annexB);
+    let hasSps = false;
+    let hasPps = false;
+    let hasIdr = false;
+    const nalTypes = [];
+    for (const nal of nalUnits) {
+      const t = (nal[0] ?? 0) & 31;
+      nalTypes.push(t);
+      if (t === 7) {
+        hasSps = true;
+        session.lastH264Sps = nal;
+      }
+      if (t === 8) {
+        hasPps = true;
+        session.lastH264Pps = nal;
+      }
+      if (t === 5) hasIdr = true;
+    }
+    if (session.stats.videoFrames < 10) {
+      this.log(
+        "debug",
+        `H.264 frame NAL types: [${nalTypes.join(",")}] (5=IDR, 7=SPS, 8=PPS, 1=P-slice)`
+      );
+    }
+    const isKeyframe = hasIdr;
+    let nalList = nalUnits;
+    if (hasIdr && (!hasSps || !hasPps)) {
+      const prepend = [];
+      if (!hasSps && session.lastH264Sps) {
+        prepend.push(session.lastH264Sps);
+        this.log("debug", `Prepending cached SPS to IDR frame`);
+      }
+      if (!hasPps && session.lastH264Pps) {
+        prepend.push(session.lastH264Pps);
+        this.log("debug", `Prepending cached PPS to IDR frame`);
+      }
+      if (prepend.length > 0) {
+        nalList = [...prepend, ...nalUnits];
+      } else if (!session.lastH264Sps || !session.lastH264Pps) {
+        this.log(
+          "warn",
+          `IDR frame without SPS/PPS and no cached parameters - frame may not decode`
+        );
+      }
+    }
+    if (!session.hasReceivedKeyframe) {
+      if (hasIdr && session.lastH264Sps && session.lastH264Pps) {
+        session.hasReceivedKeyframe = true;
+        this.log(
+          "info",
+          `First H.264 keyframe received with SPS/PPS - starting video stream`
+        );
+      } else if (hasIdr) {
+        this.log(
+          "debug",
+          `IDR received but waiting for SPS/PPS before starting stream`
+        );
+        return 0;
+      } else {
+        if (session.stats.videoFrames < 5) {
+          this.log(
+            "debug",
+            `Dropping P-frame ${session.stats.videoFrames} while waiting for keyframe`
+          );
+        }
+        return 0;
+      }
+    }
+    let totalPacketsSent = 0;
+    let currentSeqNum = sequenceNumber;
+    const ssrc = session.videoTrack.ssrc || 0;
+    for (let i = 0; i < nalList.length; i++) {
+      const nalUnit = nalList[i];
+      if (nalUnit.length === 0) continue;
+      const isLastNalu = i === nalList.length - 1;
+      const nalType = getH264NalType(nalUnit);
+      if (nalType === 9) continue;
+      const rtpPackets = this.createH264RtpPackets(
+        werift,
+        nalUnit,
+        currentSeqNum,
+        timestamp,
+        isLastNalu,
+        ssrc
+      );
+      if (session.stats.videoFrames < 3) {
+        this.log(
+          "info",
+          `NAL ${i}: type=${nalType}, size=${nalUnit.length}, rtpPackets=${rtpPackets.length}`
+        );
+      }
+      for (const rtpPacket of rtpPackets) {
+        try {
+          session.videoTrack.writeRtp(rtpPacket);
+          currentSeqNum = currentSeqNum + 1 & 65535;
+          totalPacketsSent++;
+        } catch (err) {
+          this.log(
+            "error",
+            `Error writing RTP packet for session ${session.id}: ${err}`
+          );
+        }
+      }
+    }
+    if (session.stats.videoFrames < 3) {
+      this.log(
+        "info",
+        `H.264 frame sent: nalCount=${nalList.length} packets=${totalPacketsSent} seq=${sequenceNumber}->${currentSeqNum} ts=${timestamp} keyframe=${isKeyframe}`
+      );
+    }
+    return totalPacketsSent;
+  }
+  /**
+   * Send video frame via DataChannel (works for both H.264 and H.265)
+   * Format: 12-byte header + Annex-B data
+   * Header: [frameNum (4)] [timestamp (4)] [flags (1)] [keyframe (1)] [reserved (2)]
+   * Flags: 0x01 = H.265, 0x02 = H.264
+   */
+  async sendVideoFrameViaDataChannel(session, frame, frameNumber, codec) {
+    if (!session.videoDataChannel) {
+      if (frameNumber === 0) {
+        this.log("warn", `No video data channel for session ${session.id}`);
+      }
+      return false;
+    }
+    if (session.videoDataChannel.readyState !== "open") {
+      if (frameNumber === 0) {
+        this.log(
+          "warn",
+          `Video data channel not open for session ${session.id}: ${session.videoDataChannel.readyState}`
+        );
+      }
+      return false;
+    }
+    const nalUnits = parseAnnexBNalUnits(frame.data);
+    let isKeyframe = frame.isKeyframe === true;
+    let hasIdr = false;
+    let hasSps = false;
+    let hasPps = false;
+    let hasVps = false;
+    const nalTypes = [];
+    for (const nalUnit of nalUnits) {
+      if (nalUnit.length === 0) continue;
+      if (codec === "H265") {
+        const nalType = getH265NalType2(nalUnit);
+        nalTypes.push(nalType);
+        if (nalType === 32) {
+          hasVps = true;
+          session.lastH265Vps = nalUnit;
+        }
+        if (nalType === 33) {
+          hasSps = true;
+          session.lastH265Sps = nalUnit;
+        }
+        if (nalType === 34) {
+          hasPps = true;
+          session.lastH265Pps = nalUnit;
+        }
+        if (nalType === 19 || nalType === 20) {
+          hasIdr = true;
+          isKeyframe = true;
+        }
+      } else {
+        const nalType = getH264NalType(nalUnit);
+        nalTypes.push(nalType);
+        if (nalType === 7) {
+          hasSps = true;
+          session.lastH264Sps = nalUnit;
+        }
+        if (nalType === 8) {
+          hasPps = true;
+          session.lastH264Pps = nalUnit;
+        }
+        if (nalType === 5) {
+          hasIdr = true;
+          isKeyframe = true;
+        }
+      }
+    }
+    if (frameNumber < 5) {
+      this.log(
+        "debug",
+        `${codec} frame ${frameNumber} NAL types: [${nalTypes.join(",")}] hasIdr=${hasIdr} hasSps=${hasSps} hasPps=${hasPps}`
+      );
+    }
+    if (!session.hasReceivedKeyframe) {
+      if (codec === "H264") {
+        if (hasIdr && session.lastH264Sps && session.lastH264Pps) {
+          session.hasReceivedKeyframe = true;
+          this.log(
+            "info",
+            `First H.264 keyframe received with SPS/PPS - starting video stream`
+          );
+        } else if (hasSps || hasPps) {
+          this.log("debug", `Received H.264 parameter sets, waiting for IDR`);
+          return false;
+        } else if (hasIdr) {
+          this.log("debug", `IDR received but waiting for SPS/PPS`);
+          return false;
+        } else {
+          if (frameNumber < 10) {
+            this.log(
+              "debug",
+              `Dropping H.264 P-frame ${frameNumber} while waiting for keyframe`
+            );
+          }
+          return false;
+        }
+      } else {
+        if (hasIdr && session.lastH265Vps && session.lastH265Sps && session.lastH265Pps) {
+          session.hasReceivedKeyframe = true;
+          this.log(
+            "info",
+            `First H.265 keyframe received with VPS/SPS/PPS - starting video stream`
+          );
+        } else if (hasVps || hasSps || hasPps) {
+          this.log("debug", `Received H.265 parameter sets, waiting for IDR`);
+          return false;
+        } else if (hasIdr) {
+          this.log("debug", `H.265 IDR received but waiting for VPS/SPS/PPS`);
+          return false;
+        } else {
+          if (frameNumber < 10) {
+            this.log(
+              "debug",
+              `Dropping H.265 P-frame ${frameNumber} while waiting for keyframe`
+            );
+          }
+          return false;
+        }
+      }
+    }
+    let frameData = frame.data;
+    if (hasIdr) {
+      if (codec === "H264" && (!hasSps || !hasPps)) {
+        const parts = [];
+        if (!hasSps && session.lastH264Sps) {
+          parts.push(Buffer.from([0, 0, 0, 1]));
+          parts.push(session.lastH264Sps);
+        }
+        if (!hasPps && session.lastH264Pps) {
+          parts.push(Buffer.from([0, 0, 0, 1]));
+          parts.push(session.lastH264Pps);
+        }
+        if (parts.length > 0) {
+          frameData = Buffer.concat([...parts, frame.data]);
+          this.log("debug", `Prepended cached SPS/PPS to H.264 IDR frame`);
+        }
+      } else if (codec === "H265" && (!hasVps || !hasSps || !hasPps)) {
+        const parts = [];
+        if (!hasVps && session.lastH265Vps) {
+          parts.push(Buffer.from([0, 0, 0, 1]));
+          parts.push(session.lastH265Vps);
+        }
+        if (!hasSps && session.lastH265Sps) {
+          parts.push(Buffer.from([0, 0, 0, 1]));
+          parts.push(session.lastH265Sps);
+        }
+        if (!hasPps && session.lastH265Pps) {
+          parts.push(Buffer.from([0, 0, 0, 1]));
+          parts.push(session.lastH265Pps);
+        }
+        if (parts.length > 0) {
+          frameData = Buffer.concat([...parts, frame.data]);
+          this.log("debug", `Prepended cached VPS/SPS/PPS to H.265 IDR frame`);
+        }
+      }
+    }
+    const header = Buffer.alloc(12);
+    header.writeUInt32BE(frameNumber, 0);
+    header.writeUInt32BE(frame.microseconds ? frame.microseconds / 1e3 : 0, 4);
+    header.writeUInt8(codec === "H265" ? 1 : 2, 8);
+    header.writeUInt8(isKeyframe ? 1 : 0, 9);
+    header.writeUInt16BE(0, 10);
+    const packet = Buffer.concat([header, frameData]);
+    if (frameNumber < 3) {
+      this.log(
+        "info",
+        `Sending ${codec} frame ${frameNumber}: ${packet.length} bytes, keyframe=${isKeyframe}`
+      );
+    }
+    const MAX_CHUNK_SIZE = 16e3;
+    try {
+      if (packet.length <= MAX_CHUNK_SIZE) {
+        session.videoDataChannel.send(packet);
+      } else {
+        const totalChunks = Math.ceil(packet.length / MAX_CHUNK_SIZE);
+        for (let i = 0; i < totalChunks; i++) {
+          const start = i * MAX_CHUNK_SIZE;
+          const end = Math.min(start + MAX_CHUNK_SIZE, packet.length);
+          const chunk = packet.subarray(start, end);
+          const chunkHeader = Buffer.alloc(2);
+          chunkHeader.writeUInt8(i, 0);
+          chunkHeader.writeUInt8(totalChunks, 1);
+          session.videoDataChannel.send(Buffer.concat([chunkHeader, chunk]));
+        }
+      }
+      return true;
+    } catch (err) {
+      this.log("error", `Error sending ${codec} frame ${frameNumber}: ${err}`);
+      return false;
+    }
+  }
+  /**
+   * Send H.265 frame via DataChannel
+   * Format: 12-byte header + Annex-B data
+   * Header: [frameNum (4)] [timestamp (4)] [flags (1)] [keyframe (1)] [reserved (2)]
+   */
+  async sendH265Frame(session, frame, frameNumber) {
+    if (!session.videoDataChannel) {
+      if (frameNumber === 0) {
+        this.log("warn", `No video data channel for session ${session.id}`);
+      }
+      return;
+    }
+    if (session.videoDataChannel.readyState !== "open") {
+      if (frameNumber === 0) {
+        this.log(
+          "warn",
+          `Video data channel not open for session ${session.id}: ${session.videoDataChannel.readyState}`
+        );
+      }
+      return;
+    }
+    let isKeyframe = frame.isKeyframe === true;
+    if (!isKeyframe && frame.isKeyframe === void 0) {
+      const nalUnits = parseAnnexBNalUnits(frame.data);
+      for (const nalUnit of nalUnits) {
+        if (nalUnit.length === 0) continue;
+        const nalType = getH265NalType2(nalUnit);
+        if (nalType === 32 || nalType === 33 || nalType === 34 || nalType === 19 || nalType === 20) {
+          isKeyframe = true;
+          break;
+        }
+      }
+    }
+    const header = Buffer.alloc(12);
+    header.writeUInt32BE(frameNumber, 0);
+    header.writeUInt32BE(frame.microseconds ? frame.microseconds / 1e3 : 0, 4);
+    header.writeUInt8(1, 8);
+    header.writeUInt8(isKeyframe ? 1 : 0, 9);
+    header.writeUInt16BE(0, 10);
+    const packet = Buffer.concat([header, frame.data]);
+    if (frameNumber < 3) {
+      this.log(
+        "info",
+        `Sending H.265 frame ${frameNumber}: ${packet.length} bytes, keyframe=${isKeyframe}`
+      );
+    }
+    const MAX_CHUNK_SIZE = 16e3;
+    try {
+      if (packet.length <= MAX_CHUNK_SIZE) {
+        session.videoDataChannel.send(packet);
+      } else {
+        const totalChunks = Math.ceil(packet.length / MAX_CHUNK_SIZE);
+        for (let i = 0; i < totalChunks; i++) {
+          const start = i * MAX_CHUNK_SIZE;
+          const end = Math.min(start + MAX_CHUNK_SIZE, packet.length);
+          const chunk = packet.subarray(start, end);
+          const chunkHeader = Buffer.alloc(2);
+          chunkHeader.writeUInt8(i, 0);
+          chunkHeader.writeUInt8(totalChunks, 1);
+          session.videoDataChannel.send(Buffer.concat([chunkHeader, chunk]));
+        }
+      }
+    } catch (err) {
+      this.log("error", `Error sending H.265 frame ${frameNumber}: ${err}`);
+    }
+  }
+  /**
+   * Create RTP packets for H.264 NAL unit
+   * Handles single NAL, STAP-A aggregation, and FU-A fragmentation
+   */
+  createH264RtpPackets(werift, nalUnit, sequenceNumber, timestamp, marker, ssrc) {
+    const { RtpPacket, RtpHeader } = werift;
+    const MTU = 1200;
+    const packets = [];
+    if (nalUnit.length <= MTU) {
+      const header = new RtpHeader();
+      header.payloadType = 96;
+      header.sequenceNumber = sequenceNumber;
+      header.timestamp = timestamp;
+      header.marker = marker;
+      header.ssrc = ssrc;
+      packets.push(new RtpPacket(header, nalUnit));
+    } else {
+      const nalHeader = nalUnit[0];
+      const nalType = nalHeader & 31;
+      const nri = nalHeader & 96;
+      const fuIndicator = (nri | 28) & 255;
+      let offset = 1;
+      let isFirst = true;
+      while (offset < nalUnit.length) {
+        const remaining = nalUnit.length - offset;
+        const chunkSize = Math.min(remaining, MTU - 2);
+        const isLast = offset + chunkSize >= nalUnit.length;
+        let fuHeader = nalType;
+        if (isFirst) fuHeader |= 128;
+        if (isLast) fuHeader |= 64;
+        const fuPayload = Buffer.alloc(2 + chunkSize);
+        fuPayload[0] = fuIndicator;
+        fuPayload[1] = fuHeader;
+        nalUnit.copy(fuPayload, 2, offset, offset + chunkSize);
+        const header = new RtpHeader();
+        header.payloadType = 96;
+        header.sequenceNumber = sequenceNumber + packets.length & 65535;
+        header.timestamp = timestamp;
+        header.marker = isLast && marker;
+        header.ssrc = ssrc;
+        packets.push(new RtpPacket(header, fuPayload));
+        offset += chunkSize;
+        isFirst = false;
+      }
+    }
+    return packets;
+  }
+  /**
+   * Start intercom (two-way audio)
+   */
+  async startIntercom(session) {
+    try {
+      session.intercom = new Intercom({
+        api: this.options.api,
+        channel: this.options.channel
+      });
+      await session.intercom.start();
+      this.log("info", `Intercom started for session ${session.id}`);
+    } catch (err) {
+      this.log(
+        "error",
+        `Failed to start intercom for session ${session.id}: ${err}`
+      );
+      session.intercom = null;
+    }
+  }
+  /**
+   * Log helper
+   */
+  log(level, message) {
+    if (this.options.logger) {
+      this.options.logger(level, message);
+    }
+  }
+};
+
+// src/baichuan/stream/BaichuanHlsServer.ts
+import { EventEmitter as EventEmitter6 } from "events";
+import fs from "fs";
+import fsp from "fs/promises";
+import os from "os";
+import path from "path";
+import { spawn as spawn7 } from "child_process";
+function parseAnnexBNalUnits2(data) {
+  const units = [];
+  const len = data.length;
+  const findStart = (from) => {
+    for (let i = from; i + 3 < len; i++) {
+      if (data[i] === 0 && data[i + 1] === 0) {
+        if (data[i + 2] === 1) return i;
+        if (i + 4 < len && data[i + 2] === 0 && data[i + 3] === 1)
+          return i;
+      }
+    }
+    return -1;
+  };
+  const startCodeLenAt = (i) => {
+    if (i + 3 < len && data[i] === 0 && data[i + 1] === 0) {
+      if (data[i + 2] === 1) return 3;
+      if (i + 4 < len && data[i + 2] === 0 && data[i + 3] === 1) return 4;
+    }
+    return 0;
+  };
+  let start = findStart(0);
+  if (start < 0) return units;
+  while (start >= 0) {
+    const scLen = startCodeLenAt(start);
+    if (!scLen) break;
+    const nalStart = start + scLen;
+    let next = findStart(nalStart);
+    if (next < 0) next = len;
+    if (nalStart < next) units.push(data.subarray(nalStart, next));
+    start = next < len ? next : -1;
+  }
+  return units;
+}
+function isKeyframeAnnexB(codec, annexB) {
+  const nals = parseAnnexBNalUnits2(annexB);
+  for (const nal of nals) {
+    if (!nal || nal.length === 0) continue;
+    if (codec === "h264") {
+      const nalType = nal[0] & 31;
+      if (nalType === 5) return true;
+    } else {
+      const nalType = nal[0] >> 1 & 63;
+      if (nalType >= 16 && nalType <= 21) return true;
+    }
+  }
+  return false;
+}
+function hasParamSets(codec, annexB) {
+  const nals = parseAnnexBNalUnits2(annexB);
+  for (const nal of nals) {
+    if (!nal || nal.length === 0) continue;
+    if (codec === "h264") {
+      const nalType = nal[0] & 31;
+      if (nalType === 7 || nalType === 8) return true;
+    } else {
+      const nalType = nal[0] >> 1 & 63;
+      if (nalType === 32 || nalType === 33 || nalType === 34) return true;
+    }
+  }
+  return false;
+}
+function getNalTypes(codec, annexB) {
+  const nals = parseAnnexBNalUnits2(annexB);
+  return nals.map((nal) => {
+    if (codec === "h265") {
+      return nal[0] >> 1 & 63;
+    } else {
+      return nal[0] & 31;
+    }
+  });
+}
+var BaichuanHlsServer = class extends EventEmitter6 {
+  api;
+  channel;
+  profile;
+  variant;
+  segmentDuration;
+  playlistSize;
+  ffmpegPath;
+  log;
+  outputDir = null;
+  createdTempDir = false;
+  playlistPath = null;
+  segmentPattern = null;
+  state = "idle";
+  codec = null;
+  framesReceived = 0;
+  ffmpeg = null;
+  nativeStream = null;
+  pumpPromise = null;
+  startedAt = null;
+  lastError = null;
+  constructor(options) {
+    super();
+    this.api = options.api;
+    this.channel = options.channel;
+    this.profile = options.profile;
+    this.variant = options.variant ?? void 0;
+    this.segmentDuration = options.segmentDuration ?? 2;
+    this.playlistSize = options.playlistSize ?? 5;
+    this.ffmpegPath = options.ffmpegPath ?? "ffmpeg";
+    if (options.outputDir) {
+      this.outputDir = options.outputDir;
+      this.createdTempDir = false;
+    }
+    this.log = options.logger ?? (() => {
+    });
+  }
+  /**
+   * Start HLS streaming
+   */
+  async start() {
+    if (this.state === "running" || this.state === "starting") {
+      return;
+    }
+    this.state = "starting";
+    this.lastError = null;
+    try {
+      if (!this.outputDir) {
+        this.outputDir = await fsp.mkdtemp(
+          path.join(os.tmpdir(), `nodelink-hls-${this.profile}-`)
+        );
+        this.createdTempDir = true;
+      } else {
+        await fsp.mkdir(this.outputDir, { recursive: true });
+      }
+      this.playlistPath = path.join(this.outputDir, "playlist.m3u8");
+      this.segmentPattern = path.join(this.outputDir, "segment_%05d.ts");
+      this.log("info", `Starting HLS stream to ${this.outputDir}`);
+      this.nativeStream = createNativeStream(
+        this.api,
+        this.channel,
+        this.profile,
+        this.variant ? { variant: this.variant } : void 0
+      );
+      this.pumpPromise = this.pumpNativeToFfmpeg();
+      this.startedAt = /* @__PURE__ */ new Date();
+      this.state = "running";
+      this.emit("started", { outputDir: this.outputDir });
+    } catch (err) {
+      this.state = "error";
+      this.lastError = String(err);
+      this.log("error", `Failed to start HLS: ${err}`);
+      throw err;
+    }
+  }
+  /**
+   * Stop HLS streaming
+   */
+  async stop() {
+    if (this.state === "idle" || this.state === "stopped") {
+      return;
+    }
+    this.state = "stopping";
+    this.log("info", "Stopping HLS stream");
+    try {
+      this.ffmpeg?.stdin?.end();
+    } catch {
+    }
+    try {
+      this.ffmpeg?.kill("SIGKILL");
+    } catch {
+    }
+    this.ffmpeg = null;
+    if (this.nativeStream) {
+      try {
+        await this.nativeStream.return(void 0);
+      } catch {
+      }
+      this.nativeStream = null;
+    }
+    if (this.pumpPromise) {
+      try {
+        await this.pumpPromise;
+      } catch {
+      }
+      this.pumpPromise = null;
+    }
+    if (this.createdTempDir && this.outputDir) {
+      try {
+        await fsp.rm(this.outputDir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+    this.state = "stopped";
+    this.emit("stopped");
+  }
+  /**
+   * Get current status
+   */
+  getStatus() {
+    return {
+      state: this.state,
+      codec: this.codec,
+      framesReceived: this.framesReceived,
+      ffmpegRunning: this.ffmpeg !== null && !this.ffmpeg.killed,
+      playlistPath: this.playlistPath,
+      outputDir: this.outputDir,
+      startedAt: this.startedAt,
+      error: this.lastError
+    };
+  }
+  /**
+   * Get playlist file path
+   */
+  getPlaylistPath() {
+    return this.playlistPath;
+  }
+  /**
+   * Get output directory
+   */
+  getOutputDir() {
+    return this.outputDir;
+  }
+  /**
+   * Check if playlist file exists
+   */
+  async waitForPlaylist(timeoutMs = 2e4) {
+    if (!this.playlistPath) return false;
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      if (fs.existsSync(this.playlistPath)) {
+        return true;
+      }
+      await new Promise((r) => setTimeout(r, 150));
+    }
+    return false;
+  }
+  /**
+   * Read an HLS asset (playlist or segment)
+   */
+  async readAsset(assetName) {
+    if (!this.outputDir) return null;
+    const safe = assetName.replace(/^\/+/, "");
+    if (safe.includes("..") || safe.includes("/")) {
+      return null;
+    }
+    const filePath = path.join(this.outputDir, safe);
+    if (!fs.existsSync(filePath)) {
+      return null;
+    }
+    const data = await fsp.readFile(filePath);
+    let contentType = "application/octet-stream";
+    if (safe.endsWith(".m3u8")) {
+      contentType = "application/vnd.apple.mpegurl";
+    } else if (safe.endsWith(".ts")) {
+      contentType = "video/mp2t";
+    }
+    return { data, contentType };
+  }
+  // ============================================================================
+  // Private Methods
+  // ============================================================================
+  async pumpNativeToFfmpeg() {
+    if (!this.nativeStream || !this.playlistPath || !this.segmentPattern) {
+      return;
+    }
+    let startedFfmpeg = false;
+    let pendingParamSets = [];
+    const MAX_FRAMES_WAIT_FOR_KEYFRAME = 180;
+    const collectParamSets = (codec, annexB) => {
+      const nals = parseAnnexBNalUnits2(annexB);
+      for (const nal of nals) {
+        if (!nal || nal.length === 0) continue;
+        if (codec === "h264") {
+          const t = nal[0] & 31;
+          if (t === 7 || t === 8) {
+            pendingParamSets.push(
+              Buffer.concat([Buffer.from([0, 0, 0, 1]), nal])
+            );
+          }
+        } else {
+          const t = nal[0] >> 1 & 63;
+          if (t === 32 || t === 33 || t === 34) {
+            pendingParamSets.push(
+              Buffer.concat([Buffer.from([0, 0, 0, 1]), nal])
+            );
+          }
+        }
+      }
+      if (pendingParamSets.length > 12) {
+        pendingParamSets = pendingParamSets.slice(-12);
+      }
+    };
+    try {
+      for await (const frame of this.nativeStream) {
+        if (this.state !== "running") break;
+        if (frame.audio) continue;
+        if (!frame.data || frame.data.length === 0) continue;
+        if (!this.codec) {
+          const detected = detectVideoCodecFromNal(frame.data);
+          const fromMeta = frame.videoType === "H265" ? "h265" : "h264";
+          this.codec = detected ? detected.toLowerCase() : fromMeta;
+          this.log(
+            "info",
+            `HLS codec detected: meta=${fromMeta} detected=${detected} (using ${this.codec})`
+          );
+          this.emit("codec-detected", { codec: this.codec });
+        }
+        const annexB = this.codec === "h265" ? convertToAnnexB2(frame.data) : convertToAnnexB(frame.data);
+        this.framesReceived++;
+        const shouldLog = this.framesReceived <= 5 || this.framesReceived <= 60 && this.framesReceived % 10 === 0;
+        if (shouldLog) {
+          const nalTypes = getNalTypes(this.codec, annexB);
+          const hasIdr = isKeyframeAnnexB(this.codec, annexB);
+          const hasParams = hasParamSets(this.codec, annexB);
+          this.log(
+            "debug",
+            `HLS frame#${this.framesReceived}: bytes=${annexB.length} nalTypes=[${nalTypes.join(",")}] hasIDR=${hasIdr} hasParams=${hasParams}`
+          );
+        }
+        collectParamSets(this.codec, annexB);
+        const isKeyframe = isKeyframeAnnexB(this.codec, annexB);
+        if (!isKeyframe && !startedFfmpeg) {
+          if (this.framesReceived < MAX_FRAMES_WAIT_FOR_KEYFRAME) {
+            continue;
+          }
+          this.log(
+            "warn",
+            `No keyframe after ${this.framesReceived} frames, starting ffmpeg anyway`
+          );
+        }
+        if (!startedFfmpeg) {
+          this.log(
+            "info",
+            `Starting ffmpeg: codec=${this.codec} framesSeen=${this.framesReceived} isKeyframe=${isKeyframe} paramSets=${pendingParamSets.length}`
+          );
+          this.ffmpeg = this.spawnFfmpeg();
+          startedFfmpeg = true;
+          this.emit("ffmpeg-started");
+          try {
+            if (this.ffmpeg?.stdin && !this.ffmpeg.stdin.destroyed) {
+              for (const ps of pendingParamSets) {
+                this.ffmpeg.stdin.write(ps);
+              }
+            }
+          } catch {
+          }
+        }
+        if (!this.ffmpeg || !this.ffmpeg.stdin || this.ffmpeg.stdin.destroyed) {
+          this.log("warn", "ffmpeg stdin not available, stopping pump");
+          break;
+        }
+        try {
+          this.ffmpeg.stdin.write(annexB);
+          if (this.framesReceived % 100 === 0 || this.framesReceived <= 5 || this.framesReceived <= 50 && this.framesReceived % 10 === 0) {
+            this.log(
+              "debug",
+              `HLS fed frame #${this.framesReceived} to ffmpeg (${annexB.length} bytes)`
+            );
+          }
+        } catch (err) {
+          this.log("error", `Failed to write to ffmpeg: ${err}`);
+          break;
+        }
+      }
+    } catch (e) {
+      this.log("error", `HLS pump error: ${e}`);
+      this.lastError = String(e);
+      this.state = "error";
+      this.emit("error", e);
+    }
+  }
+  spawnFfmpeg() {
+    if (!this.playlistPath || !this.segmentPattern) {
+      throw new Error("Playlist path not set");
+    }
+    const codec = this.codec ?? "h264";
+    const args = [
+      "-hide_banner",
+      "-loglevel",
+      "warning",
+      "-fflags",
+      "+genpts",
+      "-use_wallclock_as_timestamps",
+      "1",
+      "-r",
+      "25",
+      "-f",
+      codec === "h265" ? "hevc" : "h264",
+      "-i",
+      "pipe:0"
+    ];
+    if (codec === "h265") {
+      args.push(
+        "-c:v",
+        "libx264",
+        "-preset",
+        "veryfast",
+        "-tune",
+        "zerolatency",
+        "-pix_fmt",
+        "yuv420p"
+      );
+    } else {
+      args.push("-c:v", "copy");
+    }
+    args.push(
+      "-f",
+      "hls",
+      "-hls_time",
+      String(this.segmentDuration),
+      "-hls_list_size",
+      String(this.playlistSize),
+      "-hls_flags",
+      "delete_segments+append_list+omit_endlist",
+      "-hls_segment_filename",
+      this.segmentPattern,
+      this.playlistPath
+    );
+    const p = spawn7(this.ffmpegPath, args, {
+      stdio: ["pipe", "ignore", "pipe"]
+    });
+    p.on("error", (err) => {
+      this.log("error", `ffmpeg spawn error: ${err}`);
+      this.emit("ffmpeg-error", err);
+    });
+    p.stderr?.on("data", (d) => {
+      const s = String(d ?? "").trim();
+      if (s) this.log("warn", `[ffmpeg] ${s}`);
+    });
+    p.on("exit", (code, signal) => {
+      this.log(
+        "warn",
+        `ffmpeg exited (code=${code ?? "?"} signal=${signal ?? "?"})`
+      );
+      this.emit("ffmpeg-exited", { code, signal });
+    });
+    return p;
+  }
+};
+
+// src/multifocal/compositeRtspServer.ts
+import { EventEmitter as EventEmitter7 } from "events";
+import { spawn as spawn8 } from "child_process";
 import * as net from "net";
-var CompositeRtspServer = class extends EventEmitter3 {
+var CompositeRtspServer = class extends EventEmitter7 {
   options;
   compositeStream = null;
   rtspServer = null;
@@ -4417,7 +6759,7 @@ var CompositeRtspServer = class extends EventEmitter3 {
     this.logger.log?.(
       `[CompositeRtspServer] Starting ffmpeg RTSP server: ${ffmpegArgs.join(" ")}`
     );
-    this.ffmpegProcess = spawn6("ffmpeg", ffmpegArgs, {
+    this.ffmpegProcess = spawn8("ffmpeg", ffmpegArgs, {
       stdio: ["pipe", "pipe", "pipe"]
     });
     this.ffmpegProcess.on("error", (error) => {
@@ -4629,9 +6971,12 @@ export {
   BaichuanClient,
   BaichuanEventEmitter,
   BaichuanFrameParser,
+  BaichuanHlsServer,
   BaichuanHttpStreamServer,
+  BaichuanMjpegServer,
   BaichuanRtspServer,
   BaichuanVideoStream,
+  BaichuanWebRTCServer,
   BcMediaAnnexBDecoder,
   BcMediaCodec,
   BcUdpStream,
@@ -4642,7 +6987,9 @@ export {
   DUAL_LENS_SINGLE_MOTION_MODELS,
   H264RtpDepacketizer,
   H265RtpDepacketizer,
+  HlsSessionManager,
   Intercom,
+  MjpegTransformer,
   NVR_HUB_EXACT_TYPES,
   NVR_HUB_MODEL_PATTERNS,
   ReolinkBaichuanApi,
@@ -4662,6 +7009,7 @@ export {
   buildBinaryExtensionXml,
   buildChannelExtensionXml,
   buildFloodlightManualXml,
+  buildHlsRedirectUrl,
   buildLoginXml,
   buildPreviewStopXml,
   buildPreviewStopXmlV11,
@@ -4689,6 +7037,7 @@ export {
   createDebugGateLogger,
   createDiagnosticsBundle,
   createLogger,
+  createMjpegBoundary,
   createNativeStream,
   createNullLogger,
   createReplayHttpServer,
@@ -4696,8 +7045,10 @@ export {
   createRfc4571TcpServerForReplay,
   createRtspProxyServer,
   createTaggedLogger,
+  decideVideoclipTranscodeMode,
   decodeHeader,
   deriveAesKey,
+  detectIosClient,
   detectVideoCodecFromNal,
   discoverReolinkDevices,
   discoverViaHttpScan,
@@ -4710,10 +7061,13 @@ export {
   extractSpsFromAnnexB,
   extractVpsFromAnnexB,
   flattenAbilitiesForChannel,
+  formatMjpegFrame,
   getConstructedVideoStreamOptions,
   getGlobalLogger,
   getH265NalType,
+  getMjpegContentType,
   getVideoStream,
+  getVideoclipClientInfo,
   getXmlText,
   hasStartCodes2 as hasH265StartCodes,
   hasStartCodes,