@camstack/addon-pipeline 0.1.17 → 0.1.19

package/dist/stream-broker/index.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const index = require("../index-p-6GfKOg.js");
+const index = require("../index-BbPPvoCx.js");
 const crypto = require("node:crypto");
 const net = require("node:net");
 const net$1 = require("net");
 const events = require("events");
 const node_child_process = require("node:child_process");
 const promises = require("node:dns/promises");
+const os = require("node:os");
 const fs = require("node:fs");
 const path = require("node:path");
-const os = require("node:os");
 const node_events = require("node:events");
 function _interopNamespaceDefault(e) {
   const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
@@ -29,9 +29,9 @@ function _interopNamespaceDefault(e) {
 }
 const crypto__namespace = /* @__PURE__ */ _interopNamespaceDefault(crypto);
 const net__namespace = /* @__PURE__ */ _interopNamespaceDefault(net);
+const os__namespace = /* @__PURE__ */ _interopNamespaceDefault(os);
 const fs__namespace = /* @__PURE__ */ _interopNamespaceDefault(fs);
 const path__namespace = /* @__PURE__ */ _interopNamespaceDefault(path);
-const os__namespace = /* @__PURE__ */ _interopNamespaceDefault(os);
 class DecoderSessionProxy {
   constructor(api, sessionId) {
     this.api = api;
@@ -57,14 +57,28 @@ class DecoderSessionProxy {
    * Mirrors `startPolling` but drains `pullHandles` — the decoder has
    * already written the pixels into a shared-memory ring, so what crosses
    * the cap boundary is the tiny serialisable handle. Runs until
-   * `stopPolling` or `destroy`.
+   * `stopPolling`, `destroy`, or the session is destroyed externally.
+   *
+   * When the decoder reports the session is gone (`unknown sessionId` /
+   * `Service … not found`) the loop exits gracefully — those errors are
+   * expected during decoder restart/shutdown and must not be re-thrown to
+   * the caller's `.catch()` handler, which would otherwise spin forever.
    */
   async startHandlePolling(onHandle) {
     this.polling = true;
     while (this.polling) {
-      const handles = await this.api.pullHandles({ sessionId: this.sessionId, maxCount: 4 });
-      for (const handle of handles) onHandle(handle);
-      if (handles.length === 0) await new Promise((r) => setTimeout(r, 1));
+      try {
+        const handles = await this.api.pullHandles({ sessionId: this.sessionId, maxCount: 4 });
+        for (const handle of handles) onHandle(handle);
+        if (handles.length === 0) await new Promise((r) => setTimeout(r, 1));
+      } catch (err) {
+        this.polling = false;
+        const msg = err instanceof Error ? err.message : String(err);
+        if (!msg.includes("unknown sessionId") && !msg.includes("Service") && !msg.includes("not found")) {
+          throw err;
+        }
+        return;
+      }
     }
   }
   stopPolling() {
@@ -178,6 +192,8 @@ class FrameHandlePlane {
   pullHandles(subscriptionId, maxCount) {
     const subscription = this.subscriptions.get(subscriptionId);
     if (!subscription) return [];
+    const stale = subscription.queue.size - maxCount;
+    if (stale > 0) subscription.queue.drain(stale);
     const handles = subscription.queue.drain(maxCount);
     subscription.framesDelivered += handles.length;
     return handles;
@@ -231,9 +247,18 @@ class FrameHandlePlane {
     for (const session of this.sessions.values()) {
       if (!session.proxy) continue;
       session.proxy.pushPacket(packet).catch((err) => {
+        const msg = index.errMsg(err);
         this.logger?.warn("frame-handle plane: decoder push error", {
-          meta: { format: session.format, error: index.errMsg(err) }
+          meta: { format: session.format, error: msg }
         });
+        if (msg.includes("unknown sessionId") || msg.includes("Service") || msg.includes("not found")) {
+          this.logger?.info("frame-handle plane: invalidating stale proxy", {
+            meta: { format: session.format }
+          });
+          void this.destroySession(session).catch(() => {
+          });
+          this.sessions.delete(session.format);
+        }
       });
     }
   }
@@ -3778,6 +3803,26 @@ class StreamBroker {
   /** Tracking flags set synchronously by the RTP depacketizer callback. */
   _lastNalKeyframe = false;
   _lastNalParamSet = false;
+  /**
+   * Source-RTP pre-buffer: a ring of raw source RTP packets trimmed to
+   * begin at the most recent keyframe access unit — i.e. the current GOP so
+   * far. A late-joining WebRTC viewer on the repacketizer path replays this
+   * on connect (`getRtpPreBuffer`) so its decoder initialises immediately
+   * from a keyframe instead of waiting for the camera's next IDR (which can
+   * be many seconds away on a long-GOP 4K stream). This is the RTP-level
+   * counterpart to the AnnexB `preBuffer`, kept separately because the
+   * repacketizer path needs the original RTP wire packets, not AnnexB.
+   * Only populated for RTP sources (`isRtpSource()`).
+   */
+  rtpRing = [];
+  rtpRingCurAuStart = 0;
+  rtpRingPrevMarker = true;
+  rtpRingHasKeyframe = false;
+  rtpRingBytes = 0;
+  /** Memory ceiling for the RTP ring. A GOP that exceeds this (pathological
+   *  long-GOP high-bitrate stream) drops the bootstrap rather than balloon
+   *  memory — late joiners fall back to waiting for the next keyframe. */
+  static RTP_RING_MAX_BYTES = 24 * 1024 * 1024;
   /** Stream stats tracking */
   totalBytes = 0;
   bytesInWindow = 0;
@@ -4196,7 +4241,7 @@ class StreamBroker {
         this.lastKeyframeMs = now;
       }
     }
-    if (packet.type === "video") {
+    if (packet.type === "video" && !this.isRtpSource()) {
       this.preBuffer.push(packet);
     }
     for (const cb of this.encodedCallbacks) {
@@ -4342,6 +4387,46 @@ class StreamBroker {
   getSdpParameterSets() {
     return this.sdpParameterSets;
   }
+  /**
+   * Append a source RTP packet to the pre-buffer ring, trimming it to begin
+   * at the most recent keyframe access unit. Access-unit boundaries are
+   * detected via the RTP marker bit (set on the last packet of a frame);
+   * keyframe-ness comes from the depacketizer flags set just before this
+   * call. The ring therefore always holds `[current keyframe AU start .. now]`.
+   */
+  captureRtpForPreBuffer(rtpData) {
+    const marker = rtpData.length > 1 && (rtpData[1] & 128) !== 0;
+    const auStart = this.rtpRingPrevMarker || this.rtpRing.length === 0;
+    if (auStart) this.rtpRingCurAuStart = this.rtpRing.length;
+    this.rtpRing.push(rtpData);
+    this.rtpRingBytes += rtpData.length;
+    if (this._lastNalParamSet || this._lastNalKeyframe) {
+      if (this.rtpRingCurAuStart > 0) {
+        const dropped = this.rtpRing.splice(0, this.rtpRingCurAuStart);
+        for (const b of dropped) this.rtpRingBytes -= b.length;
+        this.rtpRingCurAuStart = 0;
+      }
+      this.rtpRingHasKeyframe = true;
+    }
+    this.rtpRingPrevMarker = marker;
+    if (this.rtpRingBytes > StreamBroker.RTP_RING_MAX_BYTES) {
+      this.rtpRing = [];
+      this.rtpRingBytes = 0;
+      this.rtpRingCurAuStart = 0;
+      this.rtpRingPrevMarker = true;
+      this.rtpRingHasKeyframe = false;
+    }
+  }
+  /**
+   * Snapshot of the source-RTP pre-buffer (the current GOP from its
+   * keyframe) for a late-joining repacketizer-path viewer to replay on
+   * connect — instant decoder start. Empty until a keyframe has been seen
+   * (or after a cap overflow), in which case the viewer falls back to
+   * waiting for the camera's next keyframe.
+   */
+  getRtpPreBuffer() {
+    return this.rtpRingHasKeyframe ? this.rtpRing.slice() : [];
+  }
   getSourceType() {
     return this.source?.type ?? null;
   }
@@ -4737,6 +4822,7 @@ class StreamBroker {
           this._lastNalKeyframe,
           this._lastNalParamSet
         );
+        this.captureRtpForPreBuffer(rtpData);
         if (this.rtpVideoCallbacks.size > 0) {
           for (const cb of this.rtpVideoCallbacks) {
             try {
@@ -6239,6 +6325,14 @@ const STREAM_HEALTH_POLL_MS = 15e3;
 function brokerIdFor(deviceId, camStreamId) {
   return `${deviceId}/${camStreamId}`;
 }
+function parseBrokerId(brokerId) {
+  const slash = brokerId.indexOf("/");
+  if (slash <= 0) return null;
+  const deviceId = Number(brokerId.slice(0, slash));
+  const camStreamId = brokerId.slice(slash + 1);
+  if (!Number.isInteger(deviceId) || deviceId < 0 || camStreamId.length === 0) return null;
+  return { deviceId, camStreamId };
+}
 class StreamBrokerManager {
   /**
    * brokers keyed by brokerId = `${deviceId}/${camStreamId}`.
@@ -6662,6 +6756,114 @@ class StreamBrokerManager {
     this.emitCamStreamsChanged(deviceId);
     return { success: true };
   }
+  // ── Catalog reconcile (PULL) ─────────────────────────────────────────
+  //
+  // The broker is the authority for its own cam-stream registry: it PULLS
+  // each camera's `stream-catalog` (via DeviceProxy) and reconciles, rather
+  // than relying on providers to push. This makes the broker self-heal after
+  // a restart — it re-derives the full registry from the providers. Driven by
+  // the host addon on start + a configurable poll + device / stream-params
+  // events.
+  /**
+   * Race a catalog pull against a timeout so a wedged provider handler
+   * can't leave the reconcile pending forever. Rejects (caught upstream →
+   * retry next tick) if the provider hasn't answered in time.
+   */
+  async withCatalogTimeout(promise, deviceId) {
+    let timer;
+    const timeout = new Promise((_resolve, reject) => {
+      timer = setTimeout(
+        () => reject(new Error(`stream-catalog.getCatalog timed out for device ${String(deviceId)}`)),
+        12e3
+      );
+    });
+    try {
+      return await Promise.race([promise, timeout]);
+    } finally {
+      if (timer !== void 0) clearTimeout(timer);
+    }
+  }
+  /**
+   * Pull one camera's `stream-catalog` and reconcile its cam-streams: upsert
+   * every descriptor, retract any cam-stream no longer in the catalog. A pull
+   * that throws (provider mid-restart, no `stream-catalog` cap) is skipped —
+   * the poll retries. An EMPTY catalog is also skipped rather than tearing
+   * down (a provider probe can transiently return none); genuine removal flows
+   * through the device-unregistered path.
+   */
+  async reconcileDeviceCatalog(deviceId) {
+    if (!this.api) return;
+    let descriptors;
+    try {
+      descriptors = await this.withCatalogTimeout(
+        this.api.streamCatalog.getCatalog.query({ deviceId }),
+        deviceId
+      ) ?? [];
+    } catch (err) {
+      this.logger.debug("reconcileDeviceCatalog: stream-catalog pull failed — will retry", {
+        tags: { deviceId },
+        meta: { error: index.errMsg(err) }
+      });
+      return;
+    }
+    if (descriptors.length === 0) return;
+    const keep = new Set(descriptors.map((d) => d.camStreamId));
+    for (const d of descriptors) {
+      await this.publishCameraStream({ deviceId, ...d });
+    }
+    const existing = this.cameraStreams.get(deviceId);
+    if (existing) {
+      for (const camStreamId of [...existing.keys()]) {
+        if (!keep.has(camStreamId)) {
+          await this.retractCameraStream({ deviceId, camStreamId });
+        }
+      }
+    }
+  }
+  /**
+   * Enumerate every camera and reconcile its catalog. The reconcile backstop
+   * (poll cadence) and the start-up fetch. Per-device failures are isolated so
+   * one unreachable camera can't block the rest.
+   */
+  async reconcileAllCatalogs() {
+    if (!this.api) return;
+    let devices;
+    try {
+      devices = await this.api.deviceManager.listAll.query({});
+    } catch (err) {
+      this.logger.debug("reconcileAllCatalogs: deviceManager.listAll failed — will retry", {
+        meta: { error: index.errMsg(err) }
+      });
+      return;
+    }
+    const cameras = devices.filter((d) => d.isCamera || d.type === index.DeviceType.Camera);
+    await Promise.allSettled(cameras.map((d) => this.reconcileDeviceCatalog(d.id)));
+  }
+  /**
+   * Drop a device's cam-streams entirely — fired on `device.unregistered`.
+   */
+  async retractDevice(deviceId) {
+    const existing = this.cameraStreams.get(deviceId);
+    if (!existing) return;
+    for (const camStreamId of [...existing.keys()]) {
+      await this.retractCameraStream({ deviceId, camStreamId });
+    }
+  }
+  /**
+   * Lazily (re)create the broker instance for a `brokerId` if its cam-stream
+   * is known. The audio/frame subscribe paths call this so a consumer's
+   * retry RESURRECTS the broker after a restart — the video path already
+   * `ensureBroker`s, but audio/frame subscribers previously assumed an
+   * existing instance and failed forever once the process respawned.
+   * No-op when the brokerId is malformed or its cam-stream isn't (yet)
+   * reconciled into the registry (`ensureBroker` itself guards on that).
+   */
+  async ensureBrokerForId(brokerId) {
+    if (this.brokers.has(brokerId)) return;
+    const parsed = parseBrokerId(brokerId);
+    if (!parsed) return;
+    await this.ensureBroker(parsed.deviceId, parsed.camStreamId);
+  }
   // ── Cap methods: profile assignment ─────────────────────────────────
   async assignProfile(input) {
     const { deviceId, profile, camStreamId } = input;
@@ -6757,6 +6959,7 @@ class StreamBrokerManager {
    * `FrameRingReader`.
    */
   async subscribeFrames(input) {
+    await this.ensureBrokerForId(input.brokerId);
     const broker = this.brokers.get(input.brokerId);
     if (!broker) {
       throw new Error(`stream-broker: no broker for "${input.brokerId}"`);
@@ -6815,6 +7018,7 @@ class StreamBrokerManager {
    * so their bytes travel inline on the RPC wire — no shared memory.
    */
   async subscribeAudioChunks(input) {
+    await this.ensureBrokerForId(input.brokerId);
     const broker = this.brokers.get(input.brokerId);
     if (!broker) {
       throw new Error(`stream-broker: no broker for "${input.brokerId}"`);
@@ -7932,6 +8136,58 @@ function isH264IdrAccessUnit(annexB) {
   }
   return hasSps;
 }
+function extractH264ParamSets(annexB) {
+  const nals = splitAnnexBToNals(annexB);
+  let sps;
+  let pps;
+  let profileLevelId;
+  for (const nal of nals) {
+    if (nal.length < 1) continue;
+    const nalType = nal[0] & 31;
+    if (nalType === 7) {
+      sps = nal;
+      if (nal.length >= 4) {
+        profileLevelId = Buffer.from([nal[1], nal[2], nal[3]]).toString(
+          "hex"
+        );
+      }
+    } else if (nalType === 8) {
+      pps = nal;
+    }
+  }
+  const out = {};
+  if (sps) out.sps = sps;
+  if (pps) out.pps = pps;
+  if (profileLevelId) out.profileLevelId = profileLevelId;
+  return out;
+}
+function isBaselineProfileLevelId(profileLevelId) {
+  return profileLevelId.length >= 2 && profileLevelId.slice(0, 2).toLowerCase() === "42";
+}
+function groupNalsIntoAccessUnits(nals) {
+  const accessUnits = [];
+  let current = [];
+  let currentHasVcl = false;
+  const isVcl = (type) => type >= 1 && type <= 5;
+  const startsNewAccessUnit = (type, nal) => {
+    if (isVcl(type)) return nal.length >= 2 && (nal[1] & 128) === 128;
+    return type === 9 || type === 7 || type === 8 || type === 6;
+  };
+  for (const nal of nals) {
+    if (nal.length < 1) continue;
+    const type = nal[0] & 31;
+    if (currentHasVcl && startsNewAccessUnit(type, nal)) {
+      accessUnits.push(current);
+      current = [];
+      currentHasVcl = false;
+    }
+    if (type === 9) continue;
+    current.push(nal);
+    if (isVcl(type)) currentHasVcl = true;
+  }
+  if (current.length > 0) accessUnits.push(current);
+  return accessUnits;
+}
 function tryConvertWithLengthReader(data, readLen) {
   const result = [];
   let offset = 0;
@@ -8047,14 +8303,20 @@ async function resolveMdnsCandidatesInSdp(sdp, logger, sessionTag) {
   const hosts = /* @__PURE__ */ new Set();
   for (const match of sdp.matchAll(mdnsHostRe)) hosts.add(match[1]);
   if (hosts.size === 0) return sdp;
+  const MDNS_LOOKUP_TIMEOUT_MS = 400;
   const replacements = await Promise.all(
     [...hosts].map(async (host) => {
       try {
-        const { address } = await promises.lookup(host, { family: 4 });
+        const address = await Promise.race([
+          promises.lookup(host, { family: 4 }).then((r) => r.address),
+          new Promise(
+            (_, reject) => setTimeout(() => reject(new Error(`mDNS lookup timed out after ${MDNS_LOOKUP_TIMEOUT_MS}ms`)), MDNS_LOOKUP_TIMEOUT_MS).unref?.()
+          )
+        ]);
         logger.info("mDNS resolve succeeded", { meta: { sessionTag, host, address } });
         return [host, address];
       } catch (err) {
-        logger.warn("mDNS resolve failed", { meta: { sessionTag, host, error: index.errMsg(err) } });
+        logger.warn("mDNS resolve failed (dropping host candidate, srflx/relay still used)", { meta: { sessionTag, host, error: index.errMsg(err) } });
         return [host, null];
       }
     })
@@ -8145,17 +8407,17 @@ const NAL_TYPE_IDR_N_LP = 20;
 const NAL_TYPE_CRA_NUT = 21;
 const NAL_TYPE_RSV_IRAP_VCL23 = 23;
 const NAL_TYPE_VPS = 32;
-const NAL_TYPE_SPS = 33;
-const NAL_TYPE_PPS = 34;
+const NAL_TYPE_SPS$1 = 33;
+const NAL_TYPE_PPS$1 = 34;
 const NAL_TYPE_AUD = 35;
 const NAL_TYPE_SEI_PREFIX = 39;
 const NAL_TYPE_SEI_SUFFIX = 40;
 const NAL_TYPE_AP = 48;
 const NAL_TYPE_FU = 49;
-const NAL_HEADER_SIZE = 2;
+const NAL_HEADER_SIZE$1 = 2;
 const FU_HEADER_SIZE = 3;
-const LENGTH_FIELD_SIZE = 2;
-const AP_HEADER_SIZE = NAL_HEADER_SIZE + LENGTH_FIELD_SIZE;
+const LENGTH_FIELD_SIZE$1 = 2;
+const AP_HEADER_SIZE = NAL_HEADER_SIZE$1 + LENGTH_FIELD_SIZE$1;
 function getNalType(data) {
   return (data[0] & 126) >> 1;
 }
@@ -8168,12 +8430,12 @@ function isKeyFrame(nalType) {
 function depacketizeAP(data) {
   const ret = [];
   let lastPos;
-  let pos = NAL_HEADER_SIZE;
+  let pos = NAL_HEADER_SIZE$1;
   while (pos < data.length) {
     if (lastPos !== void 0)
       ret.push(data.subarray(lastPos, pos));
     const naluSize = data.readUInt16BE(pos);
-    pos += LENGTH_FIELD_SIZE;
+    pos += LENGTH_FIELD_SIZE$1;
     lastPos = pos;
     pos += naluSize;
   }
@@ -8293,7 +8555,7 @@ class H265Repacketizer {
     const fuHeaderEnd = noEnd ? fuHeaderMiddle : Buffer.from([...fuNalHeader, nalType | 64]);
     let fuHeader = fuHeaderStart;
     const packages = [];
-    let offset = NAL_HEADER_SIZE;
+    let offset = NAL_HEADER_SIZE$1;
     while (offset < data.length) {
       let payload;
       const packageSize = Math.min(this.fuMax, data.length - offset);
@@ -8318,9 +8580,9 @@ class H265Repacketizer {
     apHeader[0] = NAL_TYPE_AP << 1;
     apHeader[1] = 1;
     const payload = [apHeader];
-    while (datas.length && datas[0].length + LENGTH_FIELD_SIZE <= availableSize && counter < 9) {
+    while (datas.length && datas[0].length + LENGTH_FIELD_SIZE$1 <= availableSize && counter < 9) {
       const nalu = datas.shift();
-      availableSize -= LENGTH_FIELD_SIZE + nalu.length;
+      availableSize -= LENGTH_FIELD_SIZE$1 + nalu.length;
       counter += 1;
       const lengthField = Buffer.alloc(2);
       lengthField.writeUInt16BE(nalu.length, 0);
@@ -8376,7 +8638,7 @@ class H265Repacketizer {
       originalFragments.unshift(originalNalHeader);
       return Buffer.concat(originalFragments);
     };
-    if (originalNalType === NAL_TYPE_VPS || originalNalType === NAL_TYPE_SPS) {
+    if (originalNalType === NAL_TYPE_VPS || originalNalType === NAL_TYPE_SPS$1) {
       const defragmented = getDefragmentedPendingFu();
       const splits = splitH265NaluStartCode(defragmented);
       while (splits.length) {
@@ -8384,9 +8646,9 @@ class H265Repacketizer {
         const splitNaluType = getNalType(split);
         if (splitNaluType === NAL_TYPE_VPS) {
           this.updateVps(split);
-        } else if (splitNaluType === NAL_TYPE_SPS) {
+        } else if (splitNaluType === NAL_TYPE_SPS$1) {
           this.updateSps(split);
-        } else if (splitNaluType === NAL_TYPE_PPS) {
+        } else if (splitNaluType === NAL_TYPE_PPS$1) {
           this.updatePps(split);
         } else {
           if (isKeyFrame(splitNaluType)) {
@@ -8521,7 +8783,7 @@ class H265Repacketizer {
       this.pendingFU.push(packet);
       if (isFuEnd) {
         this.flushPendingFU(ret);
-      } else if (this.pendingFU.reduce((p, c) => p + c.payload.length - FU_HEADER_SIZE, NAL_HEADER_SIZE) > this.maxPacketSize) {
+      } else if (this.pendingFU.reduce((p, c) => p + c.payload.length - FU_HEADER_SIZE, NAL_HEADER_SIZE$1) > this.maxPacketSize) {
         const last = this.pendingFU[this.pendingFU.length - 1].clone();
         const partial = [];
         this.flushPendingFU(partial);
@@ -8542,10 +8804,10 @@ class H265Repacketizer {
         if (nalType2 === NAL_TYPE_VPS) {
           hasVps = true;
           this.updateVps(payload);
-        } else if (nalType2 === NAL_TYPE_SPS) {
+        } else if (nalType2 === NAL_TYPE_SPS$1) {
           hasSps = true;
           this.updateSps(payload);
-        } else if (nalType2 === NAL_TYPE_PPS) {
+        } else if (nalType2 === NAL_TYPE_PPS$1) {
           hasPps = true;
           this.updatePps(payload);
         } else if (nalType2 === NAL_TYPE_SEI_PREFIX) {
@@ -8586,11 +8848,11 @@ class H265Repacketizer {
         this.extraPackets--;
         this.updateVps(packet.payload);
         return;
-      } else if (nalType === NAL_TYPE_SPS) {
+      } else if (nalType === NAL_TYPE_SPS$1) {
         this.extraPackets--;
         this.updateSps(packet.payload);
         return;
-      } else if (nalType === NAL_TYPE_PPS) {
+      } else if (nalType === NAL_TYPE_PPS$1) {
         this.extraPackets--;
         this.updatePps(packet.payload);
         return;
@@ -8618,136 +8880,740 @@ class H265Repacketizer {
     return;
   }
 }
-let _werift;
-async function loadWerift() {
-  if (_werift) return _werift;
-  try {
-    const moduleName = "werift";
-    _werift = await Function("m", "return import(m)")(moduleName);
-    return _werift;
-  } catch {
-    throw new Error(
-      "The 'werift' package is required for WebRTC support but is not installed. Install it with: npm install werift"
-    );
+const NAL_TYPE_STAP_A = 24;
+const NAL_TYPE_FU_A = 28;
+const NAL_TYPE_IDR = 5;
+const NAL_TYPE_SEI = 6;
+const NAL_TYPE_SPS = 7;
+const NAL_TYPE_PPS = 8;
+const NAL_HEADER_SIZE = 1;
+const FU_A_HEADER_SIZE = 2;
+const LENGTH_FIELD_SIZE = 2;
+const STAP_A_HEADER_SIZE = NAL_HEADER_SIZE + LENGTH_FIELD_SIZE;
+function depacketizeStapA(data) {
+  const ret = [];
+  let lastPos;
+  let pos = NAL_HEADER_SIZE;
+  while (pos < data.length) {
+    if (lastPos !== void 0)
+      ret.push(data.subarray(lastPos, pos));
+    const naluSize = data.readUInt16BE(pos);
+    pos += LENGTH_FIELD_SIZE;
+    lastPos = pos;
+    pos += naluSize;
   }
+  ret.push(data.subarray(lastPos));
+  return ret;
 }
-class AdaptiveSession {
-  sessionId;
-  source;
-  logger;
-  intercom;
-  iceConfig;
-  onStats;
-  debug;
-  sourceCodec;
-  /** Codec actually negotiated with the browser after SDP answer. */
-  negotiatedCodec = "H264";
-  /** True when source is H.265 but browser negotiated H.264 — needs transcode. */
-  get needsTranscode() {
-    return this.sourceCodec === "H265" && this.negotiatedCodec === "H264";
+function splitH264NaluStartCode(data) {
+  const ret = [];
+  let previous = 0;
+  let offset = 0;
+  const maybeAddSlice = () => {
+    const slice = data.subarray(previous, offset);
+    if (slice.length)
+      ret.push(slice);
+    offset += 4;
+    previous = offset;
+  };
+  while (offset < data.length - 4) {
+    const startCode = data.readUInt32BE(offset);
+    if (startCode === 1) {
+      maybeAddSlice();
+    } else {
+      offset++;
+    }
   }
-  _firstKeyFrame;
-  /**
-   * Last seen SPS and PPS NALs. Many cameras send SPS/PPS only once
-   * at stream start (not inline with every IDR). We cache them so
-   * PLI-triggered keyframe re-sends include the parameter sets the
-   * decoder needs to re-initialise.
-   */
-  lastSps = null;
-  lastPps = null;
-  /** H.265 VPS (Video Parameter Set) — required before every IRAP for decoder init. */
-  lastVps = null;
-  /** Whether replaceRTP has been called on the video sender to sync SSRC/seq. */
-  videoRtpSynced = false;
-  createdAt;
-  state = "new";
-  pc = null;
-  videoTrack = null;
-  audioTrack = null;
-  /** Transceiver senders for direct sendRtp (more reliable than track.writeRtp) */
-  videoSender = null;
-  audioSender = null;
-  feedAbort = null;
-  closed = false;
-  statsTimer = null;
-  /**
-   * Notification hook invoked exactly once when `close()` finishes. The
-   * adaptive server wires this up after `createSession()` so the ICE
-   * disconnect/failed path (see the `iceConnectionStateChange` handler
-   * that calls `this.close()` on its own) reaches `cam.sessions.delete`
-   * + `scheduleCameraAutoStop`. Without this callback the server kept
-   * stale entries in `cam.sessions`, the auto-stop guard (`size > 0`)
-   * never fired, ffmpeg stayed up, and the RTSP client toward the
-   * broker leaked forever (`rtspClients: 2` on idle brokers).
-   */
-  onClosed = null;
-  /** RTP sequence number counter (must increment per packet). */
-  videoSeqNum = 0;
-  audioSeqNum = 0;
-  /**
-   * Cached last keyframe NALs (SPS + PPS + IDR slices) in Annex-B format,
-   * split and ready for RTP packetization. When the browser sends a PLI
-   * (Picture Loss Indication) because it lost reference frames, we
-   * immediately re-send this stored keyframe so the decoder can recover
-   * without waiting for the next natural keyframe from the encoder.
-   */
-  lastKeyframeNals = null;
-  lastKeyframeRtpTs = 0;
-  /** Throttle: minimum interval between PLI-triggered keyframe re-sends (ms). */
-  static PLI_RESEND_COOLDOWN_MS = 500;
-  lastPliResendAt = 0;
-  /**
-   * Per-session H.265 RTP repacketizer (lazy-init). The H.265 path
-   * forwards source RTP from the broker through this repacketizer so
-   * Chrome's HEVC depacketizer sees an RTP shape it actually accepts —
-   * the prior depacketize → AnnexB → re-packetize-from-scratch path
-   * produced `framesAssembledFromMultiplePackets = 0` regardless of
-   * codec metadata being correct. See `forwardSourceRtpVideo`.
-   */
-  h265Repacketizer = null;
-  /** RTP MTU for the repacketizer — leave headroom for SRTP auth tag. */
-  static H265_REPACKETIZER_MTU = 1180;
-  /** Source SSRC — captured on first source RTP, used to populate the
-   *  outbound packets so werift's send pipeline doesn't reject them. */
-  sourceVideoSsrc = null;
-  constructor(options) {
-    this.sessionId = options.sessionId;
-    this.source = options.source;
-    this.logger = options.logger;
-    this.intercom = options.intercom;
-    this.iceConfig = options.iceConfig;
-    this.onStats = options.onStats;
-    this.debug = options.debug ?? false;
-    this.sourceCodec = options.sourceCodec ?? "H264";
-    this.createdAt = Date.now();
+  offset = data.length;
+  maybeAddSlice();
+  return ret;
+}
+class H264Repacketizer {
+  constructor(console2, maxPacketSize, codecInfo, jitterBuffer = new JitterBuffer(console2, 4)) {
+    this.console = console2;
+    this.maxPacketSize = maxPacketSize;
+    this.codecInfo = codecInfo;
+    this.jitterBuffer = jitterBuffer;
+    this.setMaxPacketSize(maxPacketSize);
   }
-  /** Build PeerConnection options including H.264 codec config. */
-  async buildPcOptions() {
-    const werift = await loadWerift();
-    const iceServers = [];
-    for (const entry of this.iceConfig?.iceServers ?? []) {
-      const urlList = Array.isArray(entry.urls) ? entry.urls : [entry.urls];
-      for (const url of urlList) {
-        iceServers.push({
-          urls: url,
-          ...entry.username !== void 0 ? { username: entry.username } : {},
-          ...entry.credential !== void 0 ? { credential: entry.credential } : {}
-        });
-      }
+  extraPackets = 0;
+  fuaMax;
+  pendingFuA;
+  // the stapa packet that will be sent before an idr frame.
+  stapa;
+  fuaMin;
+  setMaxPacketSize(maxPacketSize) {
+    this.maxPacketSize = maxPacketSize;
+    this.fuaMax = maxPacketSize - FU_A_HEADER_SIZE;
+    this.fuaMin = Math.round(maxPacketSize * 0.8);
+  }
+  ensureCodecInfo() {
+    if (!this.codecInfo) {
+      this.codecInfo = {};
     }
-    const rtcpFeedback = [
-      { type: "transport-cc" },
-      { type: "ccm", parameter: "fir" },
-      { type: "nack" },
-      { type: "nack", parameter: "pli" },
-      { type: "goog-remb" }
-    ];
-    const h264Codec = new werift.RTCRtpCodecParameters({
-      mimeType: "video/H264",
-      clockRate: 9e4,
-      payloadType: 96,
-      parameters: "level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f",
-      rtcpFeedback
+    return this.codecInfo;
+  }
+  updateSps(sps) {
+    this.ensureCodecInfo().sps = sps;
+  }
+  updatePps(pps) {
+    this.ensureCodecInfo().pps = pps;
+  }
+  updateSei(sei) {
+    this.ensureCodecInfo().sei = sei;
+  }
+  shouldFilter(_nalType) {
+    return false;
+  }
+  // a fragmentation unit (fua) is a NAL unit broken into multiple fragments.
+  // https://datatracker.ietf.org/doc/html/rfc6184#section-5.8
+  packetizeFuA(data, noStart, noEnd) {
+    const initialNalType = data[0] & 31;
+    if (initialNalType === NAL_TYPE_FU_A) {
+      const fnri2 = data[0] & (128 | 96);
+      const originalNalType = data[1] & 31;
+      const isFuStart = !!(data[1] & 128);
+      const isFuEnd = !!(data[1] & 64);
+      const isFuMiddle = !isFuStart && !isFuEnd;
+      const originalNalHeader = Buffer.from([fnri2 | originalNalType]);
+      data = Buffer.concat([originalNalHeader, data.subarray(FU_A_HEADER_SIZE)]);
+      if (isFuStart) {
+        noEnd = true;
+      } else if (isFuEnd) {
+        noStart = true;
+      } else if (isFuMiddle) {
+        noStart = true;
+        noEnd = true;
+      }
+    }
+    const fnri = data[0] & (128 | 96);
+    const nalType = data[0] & 31;
+    const fuIndicator = fnri | NAL_TYPE_FU_A;
+    const fuHeaderMiddle = Buffer.from([fuIndicator, nalType]);
+    const fuHeaderStart = noStart ? fuHeaderMiddle : Buffer.from([fuIndicator, nalType | 128]);
+    const fuHeaderEnd = noEnd ? fuHeaderMiddle : Buffer.from([fuIndicator, nalType | 64]);
+    let fuHeader = fuHeaderStart;
+    const packages = [];
+    let offset = NAL_HEADER_SIZE;
+    while (offset < data.length) {
+      const packageSize = Math.min(this.fuaMax, data.length - offset);
+      const payload = data.subarray(offset, offset + packageSize);
+      offset += packageSize;
+      if (offset === data.length) {
+        fuHeader = fuHeaderEnd;
+      }
+      packages.push(Buffer.concat([fuHeader, payload]));
+      fuHeader = fuHeaderMiddle;
+    }
+    return packages;
+  }
+  // https://datatracker.ietf.org/doc/html/rfc6184#section-5.7.1
+  packetizeOneStapA(datas) {
+    const payload = [];
+    if (!datas.length)
+      throw new Error("packetizeOneStapA requires at least one NAL");
+    let counter = 0;
+    let availableSize = this.maxPacketSize - STAP_A_HEADER_SIZE;
+    const stapHeader = NAL_TYPE_STAP_A;
+    while (datas.length && datas[0].length + LENGTH_FIELD_SIZE <= availableSize && counter < 9) {
+      const nalu = datas.shift();
+      availableSize -= LENGTH_FIELD_SIZE + nalu.length;
+      counter += 1;
+      const packed = Buffer.alloc(2);
+      packed.writeUInt16BE(nalu.length, 0);
+      payload.push(packed, nalu);
+    }
+    if (counter === 0)
+      return datas.shift();
+    if (counter === 1) {
+      return payload[1];
+    }
+    payload.unshift(Buffer.from([stapHeader]));
+    return Buffer.concat(payload);
+  }
+  packetizeStapA(datas) {
+    const ret = [];
+    while (datas.length) {
+      const nalu = this.packetizeOneStapA(datas);
+      if (nalu.length < this.maxPacketSize) {
+        ret.push(nalu);
+        continue;
+      }
+      const fuas = this.packetizeFuA(nalu);
+      ret.push(...fuas);
+    }
+    return ret;
+  }
+  createPacket(rtp, data, marker) {
+    const ret = rtp.clone();
+    ret.header.sequenceNumber = (rtp.header.sequenceNumber + this.extraPackets + 65536) % 65536;
+    ret.header.marker = marker;
+    ret.header.padding = false;
+    ret.payload = data;
+    if (data.length > this.maxPacketSize)
+      this.console.warn("packet exceeded max packet size. this may be a bug.");
+    return ret;
+  }
+  flushPendingFuA(ret) {
+    const pending = this.pendingFuA;
+    if (!pending || pending.length === 0)
+      return;
+    const first = pending[0];
+    const last = pending[pending.length - 1];
+    const originalNalType = first.payload[1] & 31;
+    const hasFuStart = !!(first.payload[1] & 128);
+    const hasFuEnd = !!(last.payload[1] & 64);
+    const fnri = first.payload[0] & (128 | 96);
+    const originalNalHeader = Buffer.from([fnri | originalNalType]);
+    const getDefragmentedPendingFua = () => {
+      const originalFragments = pending.map((packet) => packet.payload.subarray(FU_A_HEADER_SIZE));
+      originalFragments.unshift(originalNalHeader);
+      return Buffer.concat(originalFragments);
+    };
+    if (originalNalType === NAL_TYPE_SPS) {
+      const defragmented = getDefragmentedPendingFua();
+      const splits = splitH264NaluStartCode(defragmented);
+      while (splits.length) {
+        const split = splits.shift();
+        const splitNaluType = split[0] & 31;
+        if (splitNaluType === NAL_TYPE_SPS) {
+          this.updateSps(split);
+        } else if (splitNaluType === NAL_TYPE_PPS) {
+          this.updatePps(split);
+        } else {
+          if (splitNaluType === NAL_TYPE_IDR)
+            this.maybeSendStapACodecInfo(first, ret);
+          this.fragment(first, ret, {
+            payload: split,
+            noStart: !hasFuStart,
+            noEnd: !hasFuEnd,
+            marker: last.header.marker
+          });
+        }
+      }
+    } else {
+      while (pending.length) {
+        const fua = pending[0];
+        if (fua.payload.length > this.maxPacketSize || fua.payload.length < this.fuaMin)
+          break;
+        pending.shift();
+        ret.push(this.createPacket(fua, fua.payload, fua.header.marker));
+      }
+      if (!pending.length) {
+        this.pendingFuA = void 0;
+        return;
+      }
+      const refragFirst = pending[0];
+      const refragLast = pending[pending.length - 1];
+      const refragHasFuStart = !!(refragFirst.payload[1] & 128);
+      const refragHasFuEnd = !!(refragLast.payload[1] & 64);
+      const defragmented = getDefragmentedPendingFua();
+      this.fragment(refragFirst, ret, {
+        payload: defragmented,
+        noStart: !refragHasFuStart,
+        noEnd: !refragHasFuEnd,
+        marker: refragLast.header.marker
+      });
+    }
+    this.extraPackets -= pending.length - 1;
+    this.pendingFuA = void 0;
+  }
+  createRtpPackets(packet, nalus, ret, hadMarker = packet.header.marker) {
+    nalus.forEach((packetized, index2) => {
+      if (index2 !== 0)
+        this.extraPackets++;
+      const marker = hadMarker && index2 === nalus.length - 1;
+      ret.push(this.createPacket(packet, packetized, marker));
+    });
+  }
+  maybeSendStapACodecInfo(packet, ret) {
+    if (this.stapa) {
+      this.stapa = void 0;
+      return;
+    }
+    if (!this.codecInfo?.sps || !this.codecInfo?.pps)
+      return;
+    const agg = [this.codecInfo.sps, this.codecInfo.pps];
+    if (this.codecInfo?.sei)
+      agg.push(this.codecInfo.sei);
+    const aggregates = this.packetizeStapA(agg);
+    if (aggregates.length !== 1) {
+      this.console.error("expected only 1 packet for sps/pps stapa");
+      return;
+    }
+    this.createRtpPackets(packet, aggregates, ret, false);
+    this.extraPackets++;
+  }
+  // given the packet, fragment it into multiple packets as needed.
+  // a fragment of a payload may be provided via fuaOptions.
+  fragment(packet, ret, fuaOptions = {
+    payload: packet.payload,
+    noStart: false,
+    noEnd: false,
+    marker: packet.header.marker
+  }) {
+    const { payload, noStart, noEnd, marker } = fuaOptions;
+    if (payload.length > this.maxPacketSize || noStart || noEnd) {
+      const fragments = this.packetizeFuA(payload, noStart, noEnd);
+      this.createRtpPackets(packet, fragments, ret, marker);
+    } else {
+      ret.push(this.createPacket(packet, payload, marker));
+    }
+  }
+  repacketize(packet) {
+    const ret = [];
+    for (const dejittered of this.jitterBuffer.queue(packet)) {
+      this.repacketizeOne(dejittered, ret);
+    }
+    return ret;
+  }
+  repacketizeOne(packet, ret) {
+    if (!packet.payload.length) {
+      this.flushPendingFuA(ret);
+      this.extraPackets--;
+      return;
+    }
+    const nalType = packet.payload[0] & 31;
+    if (this.pendingFuA && this.pendingFuA[0].header.timestamp !== packet.header.timestamp) {
+      this.flushPendingFuA(ret);
+    }
+    if (nalType === NAL_TYPE_FU_A) {
+      const data = packet.payload;
+      const originalNalType = data[1] & 31;
+      if (this.shouldFilter(originalNalType)) {
+        this.extraPackets--;
+        return;
+      }
+      const isFuStart = !!(data[1] & 128);
+      if (isFuStart) {
+        if (this.pendingFuA)
+          this.console.error("fua restarted. skipping refragmentation of previous fua.", originalNalType);
+        this.pendingFuA = void 0;
+        if (originalNalType === NAL_TYPE_IDR) {
+          this.maybeSendStapACodecInfo(packet, ret);
+        }
+      } else {
+        if (this.pendingFuA) {
+          const last = this.pendingFuA[this.pendingFuA.length - 1];
+          if (!isNextSequenceNumber(last.header.sequenceNumber, packet.header.sequenceNumber)) {
+            this.console.error("fua packet missing. skipping refragmentation.", originalNalType);
+            return;
+          }
+        }
+      }
+      if (!this.pendingFuA)
+        this.pendingFuA = [];
+      this.pendingFuA.push(packet);
+      const isFuEnd = !!(packet.payload[1] & 64);
+      if (isFuEnd) {
+        this.flushPendingFuA(ret);
+      } else if (this.pendingFuA.reduce((p, c) => p + c.payload.length - FU_A_HEADER_SIZE, NAL_HEADER_SIZE) > this.maxPacketSize) {
+        const last = this.pendingFuA[this.pendingFuA.length - 1].clone();
+        const partial = [];
+        this.flushPendingFuA(partial);
+        const retain = partial.pop();
+        if (retain)
+          last.payload = retain.payload;
+        this.pendingFuA = [last];
+        ret.push(...partial);
+      }
+    } else if (nalType === NAL_TYPE_STAP_A) {
+      this.flushPendingFuA(ret);
+      let hasSps = false;
+      let hasPps = false;
+      const depacketized = depacketizeStapA(packet.payload);
+      depacketized.forEach((payload) => {
+        const stapNalType = payload[0] & 31;
+        if (stapNalType === NAL_TYPE_SPS) {
+          hasSps = true;
+          this.updateSps(payload);
+        } else if (stapNalType === NAL_TYPE_PPS) {
+          hasPps = true;
+          this.updatePps(payload);
+        } else if (stapNalType === NAL_TYPE_SEI) {
+          this.updateSei(payload);
+        }
+      });
+      if (hasSps && hasPps)
+        this.stapa = packet;
+      const stapa = this.packetizeStapA(depacketized);
+      this.createRtpPackets(packet, stapa, ret);
+    } else if (nalType >= 1 && nalType < 24) {
+      this.flushPendingFuA(ret);
+      if (this.shouldFilter(nalType)) {
+        this.extraPackets--;
+        return;
+      }
+      if (nalType === NAL_TYPE_SPS) {
+        this.extraPackets--;
+        this.updateSps(packet.payload);
+        return;
+      } else if (nalType === NAL_TYPE_PPS) {
+        this.extraPackets--;
+        this.updatePps(packet.payload);
+        return;
+      } else if (nalType === NAL_TYPE_SEI) {
+        this.extraPackets--;
+        this.updateSei(packet.payload);
+        return;
+      }
+      if (nalType === NAL_TYPE_IDR) {
+        this.maybeSendStapACodecInfo(packet, ret);
+      }
+      this.fragment(packet, ret);
+    } else {
+      this.console.error("unknown nal unit type " + nalType);
+      this.extraPackets--;
+    }
+  }
+}
+let _werift;
+async function loadWerift() {
+  if (_werift) return _werift;
+  try {
+    const moduleName = "werift";
+    _werift = await Function("m", "return import(m)")(moduleName);
+    return _werift;
+  } catch {
+    throw new Error(
+      "The 'werift' package is required for WebRTC support but is not installed. Install it with: npm install werift"
+    );
+  }
+}
+function isTailscaleIpv4(address) {
+  const parts = address.split(".");
+  if (parts.length !== 4) return false;
+  const a = Number.parseInt(parts[0] ?? "", 10);
+  const b = Number.parseInt(parts[1] ?? "", 10);
+  if (Number.isNaN(a) || Number.isNaN(b)) return false;
+  return a === 100 && b >= 64 && b <= 127;
+}
+function isTailscaleIpv6(address) {
+  const pct = address.indexOf("%");
+  const clean = (pct === -1 ? address : address.slice(0, pct)).toLowerCase();
+  return clean.startsWith("fd7a:");
+}
+function getTailscaleHostAddresses(interfaces = os.networkInterfaces()) {
+  const found = /* @__PURE__ */ new Set();
+  for (const entries of Object.values(interfaces)) {
+    if (!entries) continue;
+    for (const entry of entries) {
+      if (entry.internal) continue;
+      const fam = entry.family;
+      const isV4 = fam === "IPv4" || fam === 4;
+      const isV6 = fam === "IPv6" || fam === 6;
+      if (isV4 && isTailscaleIpv4(entry.address)) found.add(entry.address);
+      else if (isV6 && isTailscaleIpv6(entry.address)) {
+        const pct = entry.address.indexOf("%");
+        found.add(pct === -1 ? entry.address : entry.address.slice(0, pct));
+      }
+    }
+  }
+  return [...found];
+}
+function resolveVideoTranscode(input) {
+  const { sourceCodec, negotiatedCodec, transcodeToBaseline } = input;
+  if (sourceCodec === "H265" && negotiatedCodec === "H264") return true;
+  if (sourceCodec === "H264" && negotiatedCodec === "H264" && transcodeToBaseline) return true;
+  return false;
+}
+function detectNegotiatedVideoCodec(sdp) {
+  const m = sdp.match(/a=rtpmap:\d+ (H264|H265)\/90000/i)?.[1]?.toUpperCase();
+  return m === "H264" || m === "H265" ? m : void 0;
+}
+function transcodeInputFormat(sourceCodec) {
+  return sourceCodec === "H265" ? "hevc" : "h264";
+}
+class AdaptiveSession {
+  sessionId;
+  deviceId;
+  source;
+  logger;
+  intercom;
+  iceConfig;
+  /** Force TURN-relay-only ICE — set for client-offer (Alexa) sessions whose
+   *  peer is a cloud media server unreachable via host/srflx behind NAT. */
+  forceRelayOnly = false;
+  /** Latest RTCP Receiver Report from the remote viewer (jitter/loss),
+   *  captured via sender.onRtcp. null until the first RR arrives. */
+  lastRr = null;
+  /** Monotonic base (ms, performance.now) for send-time RTP timestamps. */
+  videoRtpClockBaseMs = null;
+  /** Log the camera's actual H.264 profile-level-id once per session. */
+  profileLogged = false;
+  onStats;
+  debug;
+  sourceCodec;
+  /**
+   * H.264 source profile is non-Baseline (Main/High) → egress must be
+   * re-encoded to Constrained Baseline for iOS. Set by the broker from the
+   * camera SPS; ignored for H.265 sources. Default false.
+   */
+  transcodeToBaseline;
+  /** Codec actually negotiated with the browser after SDP answer. */
+  negotiatedCodec = "H264";
+  /**
+   * True when the egress can't be the camera's native bytes: H.265 source
+   * with an H.264-only browser, or an H.264 Main/High source that must be
+   * forced to Constrained Baseline for iOS. See `resolveVideoTranscode`.
+   */
+  get needsTranscode() {
+    return resolveVideoTranscode({
+      sourceCodec: this.sourceCodec,
+      negotiatedCodec: this.negotiatedCodec,
+      transcodeToBaseline: this.transcodeToBaseline
+    });
+  }
+  _firstKeyFrame;
+  /**
+   * Last seen SPS and PPS NALs. Many cameras send SPS/PPS only once
+   * at stream start (not inline with every IDR). We cache them so
+   * PLI-triggered keyframe re-sends include the parameter sets the
+   * decoder needs to re-initialise.
+   */
+  lastSps = null;
+  lastPps = null;
+  /** H.265 VPS (Video Parameter Set) — required before every IRAP for decoder init. */
+  lastVps = null;
+  /** Whether replaceRTP has been called on the video sender to sync SSRC/seq. */
+  videoRtpSynced = false;
+  createdAt;
+  state = "new";
+  pc = null;
+  videoTrack = null;
+  audioTrack = null;
+  /** Transceiver senders for direct sendRtp (more reliable than track.writeRtp) */
+  videoSender = null;
+  audioSender = null;
+  feedAbort = null;
+  closed = false;
+  statsTimer = null;
+  /**
+   * Notification hook invoked exactly once when `close()` finishes. The
+   * adaptive server wires this up after `createSession()` so the ICE
+   * disconnect/failed path (see the `iceConnectionStateChange` handler
+   * that calls `this.close()` on its own) reaches `cam.sessions.delete`
+   * + `scheduleCameraAutoStop`. Without this callback the server kept
+   * stale entries in `cam.sessions`, the auto-stop guard (`size > 0`)
+   * never fired, ffmpeg stayed up, and the RTSP client toward the
+   * broker leaked forever (`rtspClients: 2` on idle brokers).
+   */
+  onClosed = null;
+  /** RTP sequence number counter (must increment per packet). */
+  videoSeqNum = 0;
+  audioSeqNum = 0;
+  /**
+   * Cached last keyframe NALs (SPS + PPS + IDR slices) in Annex-B format,
+   * split and ready for RTP packetization. When the browser sends a PLI
+   * (Picture Loss Indication) because it lost reference frames, we
+   * immediately re-send this stored keyframe so the decoder can recover
+   * without waiting for the next natural keyframe from the encoder.
+   */
+  lastKeyframeNals = null;
+  lastKeyframeRtpTs = 0;
+  /** Throttle: minimum interval between PLI-triggered keyframe re-sends (ms). */
+  static PLI_RESEND_COOLDOWN_MS = 500;
+  lastPliResendAt = 0;
+  /**
+   * Per-session H.265 RTP repacketizer (lazy-init). The H.265 path
+   * forwards source RTP from the broker through this repacketizer so
+   * Chrome's HEVC depacketizer sees an RTP shape it actually accepts —
+   * the prior depacketize → AnnexB → re-packetize-from-scratch path
+   * produced `framesAssembledFromMultiplePackets = 0` regardless of
+   * codec metadata being correct. See `forwardSourceRtpVideo`.
+   */
+  h265Repacketizer = null;
+  /** RTP MTU for the repacketizer. 1100 keeps the full wire packet
+   *  (payload + RTP hdr + hdr-extensions + SRTP/GCM tag + UDP + IPv4/IPv6)
+   *  comfortably under the Tailscale/WireGuard overlay MTU (1280) — at the
+   *  old 1180/1200 a packet is ~1266 B, which fits a plain 1500-MTU LAN but
+   *  is at/over the 1280 overlay limit, so keyframe packets silently drop
+   *  over Tailscale → the keyframe never reassembles → endless PLI storm
+   *  (LAN-OK / remote-fail). 1100 leaves ~90 B of headroom for IPv6. */
+  static H265_REPACKETIZER_MTU = 1100;
+  /**
+   * Per-session H.264 RTP repacketizer (lazy-init). H.264 RTSP sources
+   * forward source RTP through this — same Tailscale-safe MTU and the same
+   * reason as H.265: iOS (WebKit) rejects the `writeVideoNals` synthesized
+   * RTP shape for Main/High passthrough; the repacketizer preserves the
+   * native RTP layout (STAP-A SPS/PPS + FU-A). See `forwardSourceRtpVideo`.
+   */
+  h264Repacketizer = null;
+  static H264_REPACKETIZER_MTU = 1100;
+  /** Broker source-RTP pre-buffer accessor + one-shot replay guard. */
+  rtpBootstrap;
+  rtpBootstrapDone = false;
+  /**
+   * Trickle ICE: the server's locally-gathered candidates, buffered as werift
+   * surfaces them via `onIceCandidate`. The client polls `getIceCandidates`
+   * and adds each. Lets `handleOffer` return the answer IMMEDIATELY (no
+   * gathering wait) — candidates flow afterwards → ~0s connect.
+   */
+  localIceCandidates = [];
+  iceGatheringComplete = false;
+  /** Source SSRC — captured on first source RTP, used to populate the
+   *  outbound packets so werift's send pipeline doesn't reject them. */
+  sourceVideoSsrc = null;
+  constructor(options) {
+    this.sessionId = options.sessionId;
+    this.deviceId = options.deviceId;
+    this.source = options.source;
+    this.logger = options.logger;
+    this.intercom = options.intercom;
+    this.iceConfig = options.iceConfig;
+    this.onStats = options.onStats;
+    this.debug = options.debug ?? false;
+    this.sourceCodec = options.sourceCodec ?? "H264";
+    this.transcodeToBaseline = options.transcodeToBaseline ?? false;
+    this.rtpBootstrap = options.rtpBootstrap;
+    this.createdAt = Date.now();
+  }
+  /**
+   * Force TURN-relay-only ICE for this session. MUST be called before
+   * `createOffer()` (which builds the PeerConnection via
+   * `buildPcOptions`) — once the PC exists the policy is fixed.
+   *
+   * Set by the broker for remote (non-LAN) viewers: with the patched
+   * werift, `iceTransportPolicy:'relay'` produces a genuinely relay-only
+   * SDP, so a CGNAT client (which can only offer a relay candidate) gets
+   * a clean relay↔relay media path instead of werift nominating a dead
+   * host/hairpin-srflx pair. The Alexa/WHEP `handleOffer` path sets this
+   * internally; this setter is the server-offer (browser live-view) path.
+   */
+  setForceRelayOnly(value) {
+    this.forceRelayOnly = value;
+  }
+  /**
+   * Wait for ICE gathering to yield a usable candidate, then return — do NOT
+   * block on full gathering "complete". The direct LAN/Tailscale path only
+   * needs a host candidate (present in <1s); waiting for STUN/TURN gathering
+   * to finish cost many seconds of dead startup latency before the offer/
+   * answer could be sent. srflx/relay keep gathering into the local SDP; we
+   * just don't wait on them. A small floor (600ms) lets a fast srflx also
+   * land in the SDP. Hard cap (2.5s) bounds a stalled agent — e.g. a
+   * remote-only peer that genuinely needs a slow relay.
+   */
+  async waitForIceGatheringFast() {
+    if (!this.pc) return;
+    if (this.pc.iceGatheringState === "complete") return;
+    await new Promise((resolve) => {
+      let settled = false;
+      let poll;
+      const finish = () => {
+        if (settled) return;
+        settled = true;
+        if (poll) clearInterval(poll);
+        resolve();
+      };
+      this.pc?.iceGatheringStateChange.subscribe((state) => {
+        if (state === "complete") finish();
+      });
+      const start = Date.now();
+      poll = setInterval(() => {
+        const sdp = this.pc?.localDescription?.sdp ?? "";
+        if (/ typ host/.test(sdp) && Date.now() - start >= 600) finish();
+      }, 100);
+      setTimeout(finish, 2500);
+    });
+  }
+  /**
+   * Read the nominated (selected) ICE candidate pair off the live
+   * werift connection, via the video sender's DTLS → ICE transport.
+   * Returns null until ICE has nominated a pair (or if werift hasn't
+   * wired the transport chain yet). Used by the media diagnostic to
+   * confirm — on a remote retest — whether werift converged on a
+   * relay↔relay pair.
+   */
+  readNominatedPair() {
+    const conn = this.videoSender?.dtlsTransport?.iceTransport?.connection;
+    const pair = conn?.nominated;
+    if (!pair) return null;
+    const lc = pair.localCandidate;
+    const rc = pair.remoteCandidate;
+    return {
+      localType: lc.type,
+      localAddr: `${lc.host}:${lc.port}`,
+      remoteType: rc.type,
+      remoteAddr: `${rc.host}:${rc.port}`
+    };
+  }
+  /**
+   * Log the nominated ICE candidate pair once ICE connects. werift may
+   * populate `connection.nominated` a tick AFTER the "connected" event
+   * fires, so retry briefly before giving up. This is the decisive
+   * one-shot line for a remote retest: a `relay/…` ↔ `relay/…` pair
+   * means the relay-only fix took effect; anything else (or null) on a
+   * remote session is the dead-pair symptom.
+   */
+  logNominatedPair(attempt = 0) {
+    if (this.closed) return;
+    const pair = this.readNominatedPair();
+    if (!pair) {
+      if (attempt < 5) {
+        setTimeout(() => this.logNominatedPair(attempt + 1), 200);
+        return;
+      }
+      this.logger.info("ICE nominated pair", {
+        meta: {
+          phase: "session",
+          sessionId: this.sessionId,
+          deviceId: this.deviceId,
+          forceRelayOnly: this.forceRelayOnly,
+          nominated: "none"
+        }
+      });
+      return;
+    }
+    this.logger.info("ICE nominated pair", {
+      meta: {
+        phase: "session",
+        sessionId: this.sessionId,
+        deviceId: this.deviceId,
+        forceRelayOnly: this.forceRelayOnly,
+        selectedLocalType: pair.localType,
+        selectedLocalAddr: pair.localAddr,
+        selectedRemoteType: pair.remoteType,
+        selectedRemoteAddr: pair.remoteAddr
+      }
+    });
+  }
+  /** Build PeerConnection options including H.264 codec config. */
+  async buildPcOptions() {
+    const werift = await loadWerift();
+    const iceServers = [];
+    for (const entry of this.iceConfig?.iceServers ?? []) {
+      const urlList = Array.isArray(entry.urls) ? entry.urls : [entry.urls];
+      for (const url of urlList) {
+        iceServers.push({
+          urls: url,
+          ...entry.username !== void 0 ? { username: entry.username } : {},
+          ...entry.credential !== void 0 ? { credential: entry.credential } : {}
+        });
+      }
+    }
+    const rtcpFeedback = [
+      { type: "transport-cc" },
+      { type: "ccm", parameter: "fir" },
+      { type: "nack" },
+      { type: "nack", parameter: "pli" },
+      { type: "goog-remb" }
+    ];
+    const h264Codec = new werift.RTCRtpCodecParameters({
+      mimeType: "video/H264",
+      clockRate: 9e4,
+      payloadType: 96,
+      // Constrained Baseline 3.1. iOS Safari WebRTC ONLY negotiates Constrained
+      // Baseline for H.264 RECEIVE — offering Main (4d0033) or High (640034)
+      // makes werift's handleAnswer throw "negotiate codecs failed" because iOS
+      // answers Baseline and werift can't reconcile. So Baseline is the only
+      // value that negotiates with iOS; the catch is iOS then decodes ONLY
+      // Baseline, so the CAMERA must emit Baseline for the picture to render
+      // (set the camera/substream to a low/baseline profile). Desktop Chrome
+      // decodes any profile regardless. For a Main/High camera that can't be
+      // set to Baseline, the only werift-passthrough route to iOS is H.265
+      // (iOS negotiates + HW-decodes HEVC natively); H.264 needs transcoding.
+      parameters: "level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f",
+      rtcpFeedback
     });
     const h265Codec = new werift.RTCRtpCodecParameters({
       mimeType: "video/H265",
@@ -8770,13 +9636,20 @@ class AdaptiveSession {
           })
         ]
       },
-      // RTP header extensions required for BUNDLE demuxing and congestion control.
-      // Without sdes:mid, browsers cannot demux incoming RTP on a BUNDLE'd connection.
+      // RTP header extensions — KEEP `sdes:mid` only (required for BUNDLE
+      // demux; without it browsers can't route incoming RTP to the right
+      // m-line). DROP `transport-wide-cc` + `abs-send-time`: werift emits
+      // unreliable timing values on those, which a Chrome receiver feeds into
+      // its jitter buffer. On a ~zero-jitter LAN the bad timing is harmless,
+      // but over a real remote path (Tailscale/4G jitter+RTT) the jitter
+      // buffer discards frames as "too late" → never decodes → PLI storm,
+      // even though every packet arrives (browser sends RR, sends NO NACK).
+      // Dropping them lets Chrome time playout off its own receive clock.
+      // (Distinct from the earlier mistaken full-disable that also removed
+      // sdes:mid and regressed LAN demux.)
       headerExtensions: {
         video: [
-          { uri: "urn:ietf:params:rtp-hdrext:sdes:mid" },
-          { uri: "http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01" },
-          { uri: "http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time" }
+          { uri: "urn:ietf:params:rtp-hdrext:sdes:mid" }
         ],
         audio: [
           { uri: "urn:ietf:params:rtp-hdrext:sdes:mid" }
@@ -8784,9 +9657,51 @@ class AdaptiveSession {
       }
     };
     if (iceServers.length > 0) pcOptions.iceServers = iceServers;
+    if (this.forceRelayOnly) pcOptions.iceTransportPolicy = "relay";
+    if (this.debug) {
+      const loggedPairs = /* @__PURE__ */ new Set();
+      pcOptions.iceFilterCandidatePair = (pair) => {
+        try {
+          const lc = pair.localCandidate;
+          const rc = pair.remoteCandidate;
+          const key = `${lc?.type}:${lc?.host}:${lc?.port}|${rc?.type}:${rc?.host}:${rc?.port}`;
+          if (!loggedPairs.has(key)) {
+            loggedPairs.add(key);
+            this.logger.info("ICE candidate pair", {
+              meta: {
+                phase: "session",
+                sessionId: this.sessionId,
+                local: `${lc?.type ?? "?"}/${lc?.host ?? "?"}:${lc?.port ?? "?"}`,
+                remote: `${rc?.type ?? "?"}/${rc?.host ?? "?"}:${rc?.port ?? "?"}`,
+                proto: pair?.protocol?.type
+              }
+            });
+          }
+        } catch {
+        }
+        return true;
+      };
+    }
     if (this.iceConfig?.portRange) pcOptions.icePortRange = this.iceConfig.portRange;
-    if (this.iceConfig?.additionalHostAddresses?.length) {
-      pcOptions.iceAdditionalHostAddresses = [...this.iceConfig.additionalHostAddresses];
+    const tailscaleHosts = getTailscaleHostAddresses();
+    const mergedHostAddrs = [
+      .../* @__PURE__ */ new Set([
+        ...this.iceConfig?.additionalHostAddresses ?? [],
+        ...tailscaleHosts
+      ])
+    ];
+    if (mergedHostAddrs.length > 0) {
+      pcOptions.iceAdditionalHostAddresses = mergedHostAddrs;
+      if (tailscaleHosts.length > 0) {
+        this.logger.info("offering Tailscale host candidate(s)", {
+          meta: {
+            phase: "session",
+            sessionId: this.sessionId,
+            tailscaleHosts: tailscaleHosts.join(","),
+            additionalHostAddresses: mergedHostAddrs.join(",")
+          }
+        });
+      }
     }
     return { werift, pcOptions };
   }
@@ -8795,9 +9710,10 @@ class AdaptiveSession {
     const { werift, pcOptions } = await this.buildPcOptions();
     this.pc = new werift.RTCPeerConnection(pcOptions);
     this.pc.iceConnectionStateChange.subscribe((state) => {
-      this.logger.info("ICE state changed", { meta: { phase: "session", sessionId: this.sessionId, state } });
+      this.logger.info("ICE state changed", { meta: { phase: "session", sessionId: this.sessionId, deviceId: this.deviceId, state, forceRelayOnly: this.forceRelayOnly } });
       if (state === "connected") {
         this.state = "connected";
+        this.logNominatedPair();
         this.startStatsCollection();
       } else if (state === "disconnected" || state === "failed" || state === "closed") {
         this.state = state === "disconnected" ? "disconnected" : "closed";
@@ -8830,16 +9746,7 @@ class AdaptiveSession {
     }
     const offer = await this.pc.createOffer();
     await this.pc.setLocalDescription(offer);
-    await new Promise((resolve) => {
-      if (this.pc?.iceGatheringState === "complete") {
-        resolve();
-        return;
-      }
-      this.pc?.iceGatheringStateChange.subscribe((state) => {
-        if (state === "complete") resolve();
-      });
-      setTimeout(resolve, 5e3);
-    });
+    await this.waitForIceGatheringFast();
     let finalSdp = this.pc.localDescription?.sdp ?? offer.sdp;
     finalSdp = finalSdp.replace(/a=setup:active\r?\n/g, "a=setup:actpass\r\n");
     this.state = "connecting";
@@ -8864,8 +9771,8 @@ class AdaptiveSession {
     const resolvedSdp = await resolveMdnsCandidatesInSdp(answer.sdp, this.logger, `session:${this.sessionId}`);
     const desc = new werift.RTCSessionDescription(resolvedSdp, answer.type);
     await this.pc.setRemoteDescription(desc);
-    const answerVideoCodec = resolvedSdp.match(/a=rtpmap:\d+ (H264|H265)\/90000/i)?.[1]?.toUpperCase();
-    if (answerVideoCodec === "H264" || answerVideoCodec === "H265") {
+    const answerVideoCodec = detectNegotiatedVideoCodec(resolvedSdp);
+    if (answerVideoCodec) {
       this.negotiatedCodec = answerVideoCodec;
     }
     this.logger.info("Codec negotiated", {
@@ -8905,27 +9812,49 @@ class AdaptiveSession {
     const { werift, pcOptions } = await this.buildPcOptions();
     this.pc = new werift.RTCPeerConnection(pcOptions);
     this.pc.iceConnectionStateChange.subscribe((state) => {
-      this.logger.debug("ICE state", { meta: { phase: "session", sessionId: this.sessionId, state } });
+      this.logger.info("ICE state", { meta: { phase: "session", sessionId: this.sessionId, deviceId: this.deviceId, state, forceRelayOnly: this.forceRelayOnly } });
       if (state === "connected") {
         this.state = "connected";
+        this.logNominatedPair();
         this.startStatsCollection();
       } else if (state === "disconnected" || state === "failed" || state === "closed") {
         this.state = state === "disconnected" ? "disconnected" : "closed";
         void this.close();
       }
     });
+    this.pc.onIceCandidate.subscribe((c) => {
+      if (!c || !c.candidate) {
+        this.iceGatheringComplete = true;
+        return;
+      }
+      this.localIceCandidates.push({
+        candidate: c.candidate,
+        sdpMid: c.sdpMid ?? null,
+        sdpMLineIndex: c.sdpMLineIndex ?? null
+      });
+    });
     const resolvedOfferSdp = await resolveMdnsCandidatesInSdp(clientOffer.sdp, this.logger, `session:${this.sessionId}`);
+    const offerCandidates = resolvedOfferSdp.split("\n").map((l) => l.trim()).filter((l) => l.startsWith("a=candidate:"));
+    if (this.debug) {
+      this.logger.info("client offer ICE candidates", {
+        meta: { phase: "session", sessionId: this.sessionId, count: offerCandidates.length, candidates: offerCandidates }
+      });
+    }
     const remoteDesc = new werift.RTCSessionDescription(resolvedOfferSdp, clientOffer.type);
     await this.pc.setRemoteDescription(remoteDesc);
     const transceivers = this.pc.getTransceivers();
     for (const t of transceivers) {
       const kind = t.receiver?.track?.kind ?? t.kind;
       if (kind === "video" && !this.videoTrack) {
+        t.setDirection("sendonly");
         this.videoTrack = new werift.MediaStreamTrack({ kind: "video" });
         await t.sender.replaceTrack(this.videoTrack);
+        this.videoSender = t.sender;
       } else if (kind === "audio" && !this.audioTrack) {
+        t.setDirection("sendonly");
         this.audioTrack = new werift.MediaStreamTrack({ kind: "audio" });
         await t.sender.replaceTrack(this.audioTrack);
+        this.audioSender = t.sender;
       }
     }
     if (!this.videoTrack) {
@@ -8933,28 +9862,76 @@ class AdaptiveSession {
         meta: { phase: "session", sessionId: this.sessionId }
       });
       this.videoTrack = new werift.MediaStreamTrack({ kind: "video" });
-      this.pc.addTransceiver(this.videoTrack, { direction: "sendonly" });
+      const videoTransceiver = this.pc.addTransceiver(this.videoTrack, { direction: "sendonly" });
+      this.videoSender = videoTransceiver.sender;
     }
     if (!this.audioTrack) {
       this.logger.warn("No audio transceiver found in offer, adding one", {
         meta: { phase: "session", sessionId: this.sessionId }
       });
       this.audioTrack = new werift.MediaStreamTrack({ kind: "audio" });
-      this.pc.addTransceiver(this.audioTrack, { direction: "sendonly" });
+      const audioTransceiver = this.pc.addTransceiver(this.audioTrack, { direction: "sendonly" });
+      this.audioSender = audioTransceiver.sender;
     }
     const answerDesc = await this.pc.createAnswer();
-    await this.pc.setLocalDescription(answerDesc);
+    void this.pc.setLocalDescription(answerDesc).catch((e) => {
+      this.logger.warn("setLocalDescription failed", { meta: { phase: "session", sessionId: this.sessionId, error: index.errMsg(e) } });
+    });
+    const finalSdp = this.pc?.localDescription?.sdp ?? answerDesc.sdp;
     this.state = "connecting";
-    this.logger.info("WHEP answer created", { meta: { phase: "session", sessionId: this.sessionId } });
+    const answerVideoCodec = detectNegotiatedVideoCodec(finalSdp);
+    if (answerVideoCodec) {
+      this.negotiatedCodec = answerVideoCodec;
+    }
+    this.logger.info("Codec negotiated (client-offer)", {
+      meta: { phase: "session", sessionId: this.sessionId, source: this.sourceCodec, negotiated: this.negotiatedCodec, needsTranscode: this.needsTranscode }
+    });
+    if (this.debug) {
+      const gatheredCandidates = finalSdp.split("\n").map((l) => l.trim()).filter((l) => l.startsWith("a=candidate:"));
+      this.logger.info("WHEP answer created", {
+        meta: { phase: "session", sessionId: this.sessionId, candidateCount: gatheredCandidates.length, candidates: gatheredCandidates }
+      });
+    }
+    void this.startFeedingWhenDtlsReady();
+    return { sdp: finalSdp, type: "answer" };
+  }
+  /**
+   * Wait for the video sender's DTLS transport to connect, then start
+   * feeding. Used by the client-offer (`handleOffer`) path, which must
+   * return its SDP answer before the browser performs the DTLS handshake —
+   * so feeding can only safely begin once the transport is up. Mirrors the
+   * inline DTLS wait `handleAnswer` does for the server-offer path. Bounded
+   * (10s) so a never-connecting session doesn't leak the wait forever.
+   */
+  async startFeedingWhenDtlsReady() {
+    const dtlsTransport = this.videoSender?.dtlsTransport;
+    if (dtlsTransport && dtlsTransport.state !== "connected") {
+      const deadline = Date.now() + 1e4;
+      while (dtlsTransport.state !== "connected" && Date.now() < deadline && !this.closed) {
+        await new Promise((r) => setTimeout(r, 100));
+      }
+      this.logger.debug("client-offer DTLS wait complete", {
+        meta: { phase: "session", sessionId: this.sessionId, state: dtlsTransport.state }
+      });
+    }
+    if (this.closed) return;
     this.startFeedingFrames();
-    return { sdp: answerDesc.sdp, type: "answer" };
   }
-  /** Add ICE candidate. */
+  /** Add a remote (client) ICE candidate — trickle ICE client→server. */
   async addIceCandidate(candidate) {
     if (!this.pc) throw new Error("Call createOffer() first");
     const werift = await loadWerift();
     await this.pc.addIceCandidate(new werift.RTCIceCandidate(candidate));
   }
+  /**
+   * Snapshot of the server's locally-gathered ICE candidates for trickle
+   * polling (server→client). The client polls this after receiving the bare
+   * answer and adds each candidate; `done` flips true when gathering finishes
+   * so the client can stop polling.
+   */
+  getIceCandidatesSnapshot() {
+    return { candidates: [...this.localIceCandidates], done: this.iceGatheringComplete };
+  }
   /**
    * Detach the frame source (for connection pooling).
    * The session stays alive (ICE/DTLS connected) but stops feeding frames.
@@ -9062,46 +10039,111 @@ class AdaptiveSession {
       codecInfo
     );
   }
+  /**
+   * Seed the H.264 repacketizer's SPS/PPS from SDP-published parameter sets
+   * so the STAP-A codec packet can precede the first IDR even when the
+   * camera doesn't emit param sets in-band. H.264 sibling of
+   * `seedH265CodecInfoFromSdp`. No-op on non-H.264 sessions.
+   */
+  seedH264CodecInfoFromSdp(parameterSets) {
+    if (this.negotiatedCodec !== "H264") return;
+    if (!parameterSets.length) return;
+    this.ensureH264Repacketizer();
+    const rep = this.h264Repacketizer;
+    for (const ps of parameterSets) {
+      const nalType = ps[0] & 31;
+      if (nalType === 7) rep.updateSps(Buffer.from(ps));
+      else if (nalType === 8) rep.updatePps(Buffer.from(ps));
+    }
+    if (this.debug) {
+      this.logger.info("seeded H.264 repacketizer codecInfo from SDP", {
+        meta: {
+          phase: "session",
+          sessionId: this.sessionId,
+          psCount: parameterSets.length,
+          hasSps: !!rep.codecInfo?.sps,
+          hasPps: !!rep.codecInfo?.pps
+        }
+      });
+    }
+  }
+  ensureH264Repacketizer() {
+    if (this.h264Repacketizer) return;
+    this.h264Repacketizer = new H264Repacketizer(
+      console,
+      AdaptiveSession.H264_REPACKETIZER_MTU
+    );
+  }
   /**
    * Forward a source RTP video packet (raw on-wire bytes) through the
-   * H.265 repacketizer to the browser.  Used by the broker's H.265
-   * direct-RTP subscription — bypasses the AnnexB→writeVideoNals
-   * path entirely.
+   * codec's repacketizer to the browser. Used by the broker's RTSP
+   * direct-RTP subscription for BOTH H.265 and H.264 — bypasses the
+   * AnnexB→writeVideoNals path entirely so the native RTP layout (which
+   * iOS's strict depacketizer requires) is preserved.
    *
    * Drops everything until the SDP answer has been negotiated
-   * (`negotiatedCodec`/`videoSender` populated) and silently no-ops on
-   * non-H.265 sessions.
+   * (`negotiatedCodec`/`videoSender` populated).
    */
   forwardSourceRtpVideo(rtpData) {
     if (this.closed) return;
-    if (this.negotiatedCodec !== "H265") return;
+    const codec = this.negotiatedCodec;
+    if (codec !== "H265" && codec !== "H264") return;
     if (!this.videoSender || !_werift) return;
+    if (this.videoSender.dtlsTransport?.state !== "connected") return;
+    if (!this.rtpBootstrapDone) {
+      this.rtpBootstrapDone = true;
+      const bootstrap = this.rtpBootstrap?.() ?? [];
+      if (bootstrap.length > 0) {
+        let sent = 0;
+        for (const b of bootstrap) {
+          if (this.sendSourceRtpPacket(b, codec)) sent++;
+        }
+        this.logger.info("replayed source-RTP pre-buffer (instant start)", {
+          meta: { phase: "session", sessionId: this.sessionId, codec, packets: bootstrap.length, sent }
+        });
+        return;
+      }
+    }
+    this.sendSourceRtpPacket(rtpData, codec);
+  }
+  /**
+   * Repacketize one source RTP packet and send it on the video sender.
+   * Shared by the live forward path and the pre-buffer bootstrap replay.
+   * Returns true when at least one output packet was sent.
+   */
+  sendSourceRtpPacket(rtpData, codec) {
+    if (!this.videoSender || !_werift) return false;
     const werift = _werift;
-    this.ensureH265Repacketizer();
-    const rep = this.h265Repacketizer;
     let srcPkt;
     try {
       srcPkt = werift.RtpPacket.deSerialize(rtpData);
     } catch (err) {
-      this.logger.warn("H265 RTP deserialize failed", {
-        meta: { phase: "session", sessionId: this.sessionId, error: index.errMsg(err), len: rtpData.length }
+      this.logger.warn("source RTP deserialize failed", {
+        meta: { phase: "session", sessionId: this.sessionId, codec, error: index.errMsg(err), len: rtpData.length }
       });
-      return;
+      return false;
     }
     if (this.sourceVideoSsrc === null) {
       this.sourceVideoSsrc = srcPkt.header.ssrc;
     }
     const senderCodec = this.videoSender.codec;
-    const pt = senderCodec?.payloadType ?? 97;
+    const pt = senderCodec?.payloadType ?? (codec === "H265" ? 97 : 96);
     let outPkts;
     try {
-      outPkts = rep.repacketize(srcPkt);
+      if (codec === "H265") {
+        this.ensureH265Repacketizer();
+        outPkts = this.h265Repacketizer.repacketize(srcPkt);
+      } else {
+        this.ensureH264Repacketizer();
+        outPkts = this.h264Repacketizer.repacketize(srcPkt);
+      }
     } catch (err) {
-      this.logger.warn("H265 repacketize failed", {
-        meta: { phase: "session", sessionId: this.sessionId, error: index.errMsg(err) }
+      this.logger.warn("repacketize failed", {
+        meta: { phase: "session", sessionId: this.sessionId, codec, error: index.errMsg(err) }
       });
-      return;
+      return false;
     }
+    let sent = false;
     for (const pkt of outPkts) {
       pkt.header.payloadType = pt;
       if (!this.videoRtpSynced) {
@@ -9120,19 +10162,21 @@ class AdaptiveSession {
       try {
         this.videoSender.sendRtp(pkt);
         this.rtpPacketsSent++;
+        sent = true;
         if (this.debug && (this.rtpPacketsSent === 1 || this.rtpPacketsSent % 500 === 0)) {
-          this.logger.info("H265 source-RTP forwarded", {
-            meta: { phase: "session", sessionId: this.sessionId, count: this.rtpPacketsSent }
+          this.logger.info("source-RTP forwarded", {
+            meta: { phase: "session", sessionId: this.sessionId, codec, count: this.rtpPacketsSent }
           });
         }
       } catch (err) {
         if (this.rtpPacketsSent <= 10) {
-          this.logger.error("sendRtp (h265 forward) error", {
-            meta: { phase: "session", sessionId: this.sessionId, error: index.errMsg(err) }
+          this.logger.error("sendRtp (source forward) error", {
+            meta: { phase: "session", sessionId: this.sessionId, codec, error: index.errMsg(err) }
           });
         }
       }
     }
+    return sent;
   }
   // -----------------------------------------------------------------------
   // PLI handling — resend cached keyframe on picture loss
@@ -9141,6 +10185,14 @@ class AdaptiveSession {
     const sender = this.videoSender;
     if (!sender) return;
     const onPli = () => this.handlePli();
+    if (sender.onRtcp) {
+      sender.onRtcp.subscribe((rtcp) => {
+        const reports = rtcp?.reports;
+        if (!reports || reports.length === 0) return;
+        const mine = reports.find((r) => r.ssrc === sender.ssrc) ?? reports[0];
+        if (mine) this.lastRr = mine;
+      });
+    }
     if (sender.onPictureLossIndication) {
       sender.onPictureLossIndication.subscribe(onPli);
       this.logger.debug("PLI listener attached (onPictureLossIndication)", {
@@ -9179,7 +10231,7 @@ class AdaptiveSession {
         totalBytes: this.lastKeyframeNals.reduce((s, n) => s + n.length, 0)
       }
     });
-    this.writeVideoNals(this.lastKeyframeNals, this.lastKeyframeRtpTs, this.negotiatedCodec);
+    this.writeVideoNals(this.lastKeyframeNals, this.sendRtpTimestamp(), this.negotiatedCodec);
   }
   // -----------------------------------------------------------------------
   // Frame feeding
@@ -9204,7 +10256,6 @@ class AdaptiveSession {
   startDirectFeed(signal) {
     void (async () => {
       let gotKeyframe = false;
-      let videoTimestampBase = null;
       let audioTimestampBase = null;
       let frameCount = 0;
       try {
@@ -9257,10 +10308,7 @@ class AdaptiveSession {
                 meta: { phase: "session", sessionId: this.sessionId, frameCount, size: annexB.length, ice: iceState }
               });
             }
-            if (videoTimestampBase === null) videoTimestampBase = frame.timestampMicros;
-            const rtpTs = Math.floor(
-              (frame.timestampMicros - videoTimestampBase) * 9e4 / 1e6
-            ) >>> 0;
+            const rtpTs = this.sendRtpTimestamp();
             const isH265 = frame.codec === "H265";
             const allNals = splitAnnexBToNals(annexB);
             const nals = allNals.filter((n) => {
@@ -9318,7 +10366,25 @@ class AdaptiveSession {
                 let auNals = nals;
                 for (const n of nals) {
                   const nalType = n[0] & 31;
-                  if (nalType === 7) this.lastSps = Buffer.from(n);
+                  if (nalType === 7) {
+                    this.lastSps = Buffer.from(n);
+                    if (!this.profileLogged && n.length >= 4) {
+                      this.profileLogged = true;
+                      const plid = `${n[1].toString(16).padStart(2, "0")}${n[2].toString(16).padStart(2, "0")}${n[3].toString(16).padStart(2, "0")}`;
+                      this.logger.info("camera H.264 SPS profile-level-id", {
+                        meta: {
+                          phase: "session",
+                          sessionId: this.sessionId,
+                          deviceId: this.deviceId,
+                          actualProfileLevelId: plid,
+                          advertisedProfileLevelId: "42e01f",
+                          match: plid === "42e01f",
+                          profileIdc: n[1],
+                          levelIdc: n[3]
+                        }
+                      });
+                    }
+                  }
                   if (nalType === 8) this.lastPps = Buffer.from(n);
                 }
                 if (isH264IdrAccessUnit(annexB)) {
@@ -9365,22 +10431,25 @@ class AdaptiveSession {
       }
     })();
   }
-  /** Max RTP payload size (MTU 1200 to stay under typical network MTU). */
   /**
-   * Transcode feed — source is H.265 but browser only supports H.264.
-   * Pipes raw H.265 Annex-B to ffmpeg stdin, reads H.264 from stdout.
+   * Transcode feed — re-encode the source to Constrained Baseline H.264:
+   * H.265→H.264 (browser lacks HEVC) or H.264 Main/High→Baseline (iOS only
+   * decodes Baseline). Pipes the source Annex-B to ffmpeg stdin, reads
+   * Baseline H.264 from stdout, and re-frames it into access units so each
+   * picture is sent with one RTP timestamp (see the stdout handler).
    */
   startTranscodeFeed(signal) {
     const { spawn } = require("node:child_process");
-    this.logger.info("Starting H.265→H.264 transcode feed", {
-      meta: { phase: "session", sessionId: this.sessionId }
+    const inputFormat = transcodeInputFormat(this.sourceCodec);
+    this.logger.info(`Starting ${this.sourceCodec}→H.264 Baseline transcode feed`, {
+      meta: { phase: "session", sessionId: this.sessionId, sourceCodec: this.sourceCodec, inputFormat }
     });
     const ff = spawn("ffmpeg", [
       "-hide_banner",
       "-loglevel",
       "error",
       "-f",
-      "hevc",
+      inputFormat,
       "-i",
       "pipe:0",
       "-c:v",
@@ -9411,18 +10480,24 @@ class AdaptiveSession {
       if (msg.length > 0) this.logger.warn("Transcode ffmpeg stderr", { meta: { sessionId: this.sessionId, msg } });
     });
     let pendingBuf = Buffer.alloc(0);
-    let rtpTs = 0;
-    const FRAME_INTERVAL_90K = 3e3;
+    let carryNals = [];
     ff.stdout.on("data", (chunk) => {
       pendingBuf = Buffer.concat([pendingBuf, chunk]);
       const lastSc = findLastStartCode(pendingBuf);
       if (lastSc <= 0) return;
       const complete = pendingBuf.subarray(0, lastSc);
       pendingBuf = Buffer.from(pendingBuf.subarray(lastSc));
-      const completedNals = splitAnnexBToNals(complete);
-      if (completedNals.length === 0) return;
-      rtpTs = rtpTs + FRAME_INTERVAL_90K >>> 0;
-      this.writeVideoNals(completedNals, rtpTs, "H264");
+      const nals = carryNals.concat(splitAnnexBToNals(complete));
+      const accessUnits = groupNalsIntoAccessUnits(nals);
+      if (accessUnits.length <= 1) {
+        carryNals = nals;
+        return;
+      }
+      carryNals = accessUnits[accessUnits.length - 1];
+      for (let i = 0; i < accessUnits.length - 1; i++) {
+        const auNals = accessUnits[i].filter((n) => (n[0] & 31) !== 6);
+        if (auNals.length > 0) this.writeVideoNals(auNals, this.sendRtpTimestamp(), "H264");
+      }
     });
     void (async () => {
       try {
@@ -9447,9 +10522,36 @@ class AdaptiveSession {
       }
     })();
   }
-  static MAX_RTP_PAYLOAD = 1200;
+  // 1100 (not 1200): keep the full wire packet under the Tailscale/WireGuard
+  // overlay MTU (1280). See H265_REPACKETIZER_MTU for the rationale — at 1200
+  // a keyframe's RTP packets are ~1266 B and silently drop over the overlay,
+  // causing a never-decoding PLI storm that works fine on a 1500-MTU LAN.
+  static MAX_RTP_PAYLOAD = 1100;
   rtpPacketsSent = 0;
   rtpLogCounter = 0;
+  /**
+   * RTP timestamp (90 kHz) derived from the hub's MONOTONIC clock at the
+   * moment of sending — NOT the camera capture time.
+   *
+   * Forwarding live media with capture-time RTP timestamps creates a cadence
+   * mismatch vs the actual send time: the pipeline/decoder adds variable
+   * latency between capture (`frame.timestampMicros`) and the instant we push
+   * the packets out. A remote receiver measures that mismatch as high RTCP
+   * jitter (~80 ms observed over Tailscale, with ZERO packet loss) — its
+   * jitter buffer can't lock onto a stable clock, so frames are discarded and
+   * it PLI-storms. A ~0-RTT LAN absorbs it; a real remote path does not.
+   *
+   * Stamping off send time makes the RTP-timestamp cadence equal the actual
+   * transmit cadence, so arrival cadence matches and the receiver's jitter
+   * collapses to true network jitter. Same effect ffmpeg/libwebrtc achieve by
+   * pacing output. All video send paths (live feed + PLI keyframe resend)
+   * share this one clock so timestamps stay monotonic.
+   */
+  sendRtpTimestamp() {
+    const now = performance.now();
+    if (this.videoRtpClockBaseMs === null) this.videoRtpClockBaseMs = now;
+    return Math.floor((now - this.videoRtpClockBaseMs) * 90) >>> 0;
+  }
   writeVideoNals(nals, rtpTs, codec) {
     if (!this.videoSender || !_werift) {
       if (this.rtpLogCounter === 0) {
@@ -9594,40 +10696,52 @@ class AdaptiveSession {
   // RTCP stats collection
   // -----------------------------------------------------------------------
   startStatsCollection() {
-    if (this.statsTimer || !this.onStats) return;
+    if (this.statsTimer) return;
     this.statsTimer = setInterval(() => {
       if (!this.pc || this.closed) return;
       this.collectStats();
     }, 3e3);
   }
   collectStats() {
-    if (!this.pc || !this.onStats) return;
-    try {
-      const senders = this.pc.getSenders?.() ?? [];
-      for (const sender of senders) {
-        const track = sender.track;
-        if (!track || track.kind !== "video") continue;
-        const report = sender.lastReceiverReport ?? sender.rtcpReport;
-        if (!report) continue;
-        const fractionLost = report.fractionLost ?? 0;
-        const packetsLost = report.packetsLost ?? report.cumulativeLost ?? 0;
-        const jitter = report.jitter ?? 0;
-        const rtt = report.roundTripTime ?? report.rtt ?? 0;
-        const packetLoss = fractionLost / 256;
-        this.onStats({
-          sessionId: this.sessionId,
-          packetLoss,
-          jitterMs: jitter,
-          rttMs: rtt * 1e3,
-          // seconds → ms
-          packetsReceived: 0,
-          // Not available from sender side
-          packetsLost,
-          timestamp: Date.now()
-        });
-        return;
+    if (!this.pc) return;
+    const report = this.lastRr ?? void 0;
+    const fractionLost = report?.fractionLost ?? 0;
+    const packetsLost = report?.packetsLost ?? report?.cumulativeLost ?? 0;
+    const jitter = report?.jitter ?? 0;
+    const rtt = report?.roundTripTime ?? report?.rtt ?? 0;
+    const nominated = this.readNominatedPair();
+    this.logger.info("webrtc media diag", {
+      meta: {
+        phase: "session",
+        sessionId: this.sessionId,
+        deviceId: this.deviceId,
+        rtpPacketsSent: this.rtpPacketsSent,
+        dtls: this.videoSender?.dtlsTransport?.state ?? "unknown",
+        ice: this.state,
+        forceRelayOnly: this.forceRelayOnly,
+        hasReceiverReport: !!report,
+        fractionLostPct: report ? Math.round(fractionLost / 256 * 100) : -1,
+        packetsLost,
+        // video RTP clock is 90 kHz → jitter ticks / 90 = milliseconds.
+        jitterMs: report ? Math.round(jitter / 90) : -1,
+        rttMs: Math.round(rtt * 1e3),
+        selectedLocalType: nominated?.localType ?? "none",
+        selectedLocalAddr: nominated?.localAddr ?? "none",
+        selectedRemoteType: nominated?.remoteType ?? "none",
+        selectedRemoteAddr: nominated?.remoteAddr ?? "none"
       }
-    } catch {
+    });
+    if (report && this.onStats) {
+      this.onStats({
+        sessionId: this.sessionId,
+        packetLoss: fractionLost / 256,
+        // Fraction lost is 0–255
+        jitterMs: jitter,
+        rttMs: rtt * 1e3,
+        packetsReceived: 0,
+        packetsLost,
+        timestamp: Date.now()
+      });
     }
   }
 }
@@ -9637,6 +10751,49 @@ function findLastStartCode(buf) {
   }
   return -1;
 }
+function resolveBrokerTranscodeToBaseline(sessionCodec, sourceProfileLevelId) {
+  if (sessionCodec !== "H264") return false;
+  if (!sourceProfileLevelId) return false;
+  return !isBaselineProfileLevelId(sourceProfileLevelId);
+}
+function h264ProfileIdc(profileLevelId) {
+  if (profileLevelId.length < 2) return 0;
+  const idc = Number.parseInt(profileLevelId.slice(0, 2), 16);
+  return Number.isNaN(idc) ? 0 : idc;
+}
+function extractOfferedH264ProfileLevelIds(sdp) {
+  const ids = [];
+  const re = /profile-level-id=([0-9a-fA-F]{6})/g;
+  let m;
+  while ((m = re.exec(sdp)) !== null) ids.push(m[1].toLowerCase());
+  return ids;
+}
+function resolveClientOfferTranscodeToBaseline(sessionCodec, sourceProfileLevelId, offeredProfileLevelIds) {
+  if (sessionCodec !== "H264") return false;
+  if (!sourceProfileLevelId) return false;
+  if (isBaselineProfileLevelId(sourceProfileLevelId)) return false;
+  const sourceIdc = h264ProfileIdc(sourceProfileLevelId);
+  const maxOfferedIdc = offeredProfileLevelIds.reduce(
+    (max, plid) => Math.max(max, h264ProfileIdc(plid)),
+    0
+  );
+  return maxOfferedIdc < sourceIdc;
+}
+function deriveH264ProfileLevelId(sdpParameterSets, preBuffer) {
+  if (sdpParameterSets) {
+    for (const ps of sdpParameterSets) {
+      if (ps.length >= 4 && (ps[0] & 31) === 7) {
+        return Buffer.from([ps[1], ps[2], ps[3]]).toString("hex");
+      }
+    }
+  }
+  for (const pkt of preBuffer) {
+    if (pkt.type !== "video") continue;
+    const { profileLevelId } = extractH264ParamSets(convertH264ToAnnexB(pkt.data));
+    if (profileLevelId) return profileLevelId;
+  }
+  return void 0;
+}
 const LABEL_DEFAULTS = {
   high: { pixels: 1920 * 1080, bitrateKbps: 4e3 },
   mid: { pixels: 1280 * 720, bitrateKbps: 1200 },
@@ -9733,14 +10890,19 @@ class BrokerWebrtcServer {
   async createSession(streamId, hints = {}, opts = {}) {
     const setup = await this.setupSessionForBroker(streamId, hints, opts);
     try {
+      if (opts.relayOnly === true) {
+        setup.session.setForceRelayOnly(true);
+      }
       const offer = await setup.session.createOffer();
       setup.sessionLogger.info("WebRTC session created", {
         meta: {
           sessionId: setup.sessionId,
+          deviceId: setup.deviceId,
           brokerId: setup.brokerId,
           iceServers: setup.iceServerCount,
           codec: setup.sessionCodec,
-          useH265Repacketizer: setup.useH265Repacketizer
+          useRtpRepacketizer: setup.useRtpRepacketizer,
+          relayOnly: opts.relayOnly === true
         }
       });
       return { sessionId: setup.sessionId, sdpOffer: offer.sdp };
@@ -9764,16 +10926,21 @@ class BrokerWebrtcServer {
    * RTC controller / Alexa handler closes the session the same way.
    */
   async handleOffer(streamId, clientOfferSdp, hints = {}, opts = {}) {
-    const setup = await this.setupSessionForBroker(streamId, hints, opts);
+    const setup = await this.setupSessionForBroker(streamId, hints, { ...opts, clientOfferSdp });
     try {
+      if (opts.relayOnly === true) {
+        setup.session.setForceRelayOnly(true);
+      }
       const answer = await setup.session.handleOffer({ sdp: clientOfferSdp, type: "offer" });
       setup.sessionLogger.info("WebRTC session created (client-offer)", {
         meta: {
           sessionId: setup.sessionId,
+          deviceId: setup.deviceId,
           brokerId: setup.brokerId,
           iceServers: setup.iceServerCount,
           codec: setup.sessionCodec,
-          useH265Repacketizer: setup.useH265Repacketizer
+          useRtpRepacketizer: setup.useRtpRepacketizer,
+          relayOnly: opts.relayOnly === true
         }
       });
       return { sessionId: setup.sessionId, sdpAnswer: answer.sdp };
@@ -9803,20 +10970,21 @@ class BrokerWebrtcServer {
     const broker = this.brokers.get(brokerId);
     if (!broker) throw new Error(`No broker for stream "${streamId}" (resolved: "${brokerId}")`);
     const slashIdx = brokerId.indexOf("/");
-    const deviceTags = slashIdx > 0 ? {
-      deviceId: Number.parseInt(brokerId.slice(0, slashIdx), 10),
-      camStreamId: brokerId.slice(slashIdx + 1)
-    } : { deviceId: -1, camStreamId: brokerId };
+    const deviceId = deviceIdFromBrokerId(brokerId);
+    const deviceTags = {
+      deviceId,
+      camStreamId: slashIdx > 0 ? brokerId.slice(slashIdx + 1) : brokerId
+    };
     const sessionLogger = this.logger.withTags(deviceTags);
     const brokerCodec = broker.getStats().codec ?? "h264";
     const isHevc = brokerCodec === "h265" || brokerCodec === "hevc";
     const sessionCodec = isHevc ? "H265" : "H264";
     const sourceType = broker.getSourceType();
     const isRtp = broker.isRtpSource();
-    const useH265Repacketizer = sessionCodec === "H265" && isRtp;
+    const useRtpRepacketizer = isRtp;
     sessionLogger.info(
-      `WebRTC session: codec=${sessionCodec} brokerCodec=${brokerCodec} sourceType=${sourceType ?? "null"} isRtp=${isRtp} repacketizer=${useH265Repacketizer}`,
-      { meta: { brokerId, sessionCodec, brokerCodec, sourceType, isRtp, useH265Repacketizer } }
+      `WebRTC session: codec=${sessionCodec} brokerCodec=${brokerCodec} sourceType=${sourceType ?? "null"} isRtp=${isRtp} repacketizer=${useRtpRepacketizer}`,
+      { meta: { brokerId, sessionCodec, brokerCodec, sourceType, isRtp, useRtpRepacketizer } }
     );
     const { source, pushFrame, close: closeSource } = createPushFrameSource();
     const pendingParamNals = [];
@@ -9824,7 +10992,7 @@ class BrokerWebrtcServer {
     let seenRealPacket = false;
     const unsubBroker = broker.onEncodedData((packet) => {
       if (packet.type === "video") {
-        if (useH265Repacketizer) return;
+        if (useRtpRepacketizer) return;
         if (!packet.isPlaceholder && !seenRealPacket) {
           seenRealPacket = true;
           pendingParamNals.length = 0;
@@ -9883,7 +11051,7 @@ class BrokerWebrtcServer {
     const preParamNals = stickyParamSets ? [Buffer.from(stickyParamSets)] : pendingParamNals.length > 0 ? pendingParamNals.map((b) => Buffer.from(b)) : [];
     for (const pkt of preBuffer) {
       if (pkt.type === "video") {
-        if (useH265Repacketizer) continue;
+        if (useRtpRepacketizer) continue;
         const annexB = convertH264ToAnnexB(pkt.data);
         const nalTypeInfo = detectFirstNalType(annexB, isHevc);
         if (nalTypeInfo.isParamSet) {
@@ -9915,40 +11083,68 @@ class BrokerWebrtcServer {
     }
     const sessionId = requestedSessionId ?? crypto.randomUUID();
     const iceServers = await this.resolveIceServers();
+    const sourceProfileLevelId = sessionCodec === "H264" ? deriveH264ProfileLevelId(broker.getSdpParameterSets(), broker.getPreBuffer()) : void 0;
+    const offeredProfileLevelIds = opts.clientOfferSdp ? extractOfferedH264ProfileLevelIds(opts.clientOfferSdp) : void 0;
+    const transcodeToBaseline = offeredProfileLevelIds ? resolveClientOfferTranscodeToBaseline(sessionCodec, sourceProfileLevelId, offeredProfileLevelIds) : resolveBrokerTranscodeToBaseline(sessionCodec, sourceProfileLevelId);
+    if (transcodeToBaseline) {
+      sessionLogger.info(
+        "WebRTC: source H.264 is non-Baseline and the client cannot decode it — re-encoding egress to Constrained Baseline",
+        { meta: { brokerId, sessionId, sourceProfileLevelId, offeredProfileLevelIds, clientOffer: opts.clientOfferSdp !== void 0 } }
+      );
+    } else if (offeredProfileLevelIds && sourceProfileLevelId && !isBaselineProfileLevelId(sourceProfileLevelId)) {
+      sessionLogger.info(
+        "WebRTC: client offered a profile that decodes the non-Baseline H.264 source — passthrough (no re-encode)",
+        { meta: { brokerId, sessionId, sourceProfileLevelId, offeredProfileLevelIds } }
+      );
+    }
     const session = new AdaptiveSession({
       sessionId,
       source,
       sourceCodec: sessionCodec,
+      transcodeToBaseline,
       iceConfig: {
         iceServers,
         portRange: this.icePortRange,
         additionalHostAddresses: this.iceAdditionalHostAddresses
       },
-      logger: this.logger,
+      // Device-tagged logger so every WebRTC session lifecycle line
+      // (ICE state, candidate pairs, nominated pair, feed progress)
+      // carries `deviceId` — operator log filters scoped to one device
+      // no longer drop session logs as `dev=?`.
+      logger: sessionLogger,
+      deviceId,
+      // Source-RTP pre-buffer accessor for instant start on the repacketizer
+      // path — the session replays the current GOP on its first forwarded
+      // packet. Only meaningful for RTP sources (returns [] otherwise).
+      rtpBootstrap: useRtpRepacketizer ? (() => broker.getRtpPreBuffer()) : void 0,
       debug: opts.streamingDebug === true
     });
+    const seedFromSdp = (ps) => {
+      if (sessionCodec === "H265") session.seedH265CodecInfoFromSdp(ps);
+      else session.seedH264CodecInfoFromSdp(ps);
+    };
     let unsubRtp = null;
     let unsubSdpParams = null;
-    if (useH265Repacketizer) {
+    if (useRtpRepacketizer) {
       const sdpPs = broker.getSdpParameterSets();
       if (sdpPs && sdpPs.length > 0) {
-        session.seedH265CodecInfoFromSdp(sdpPs);
-        sessionLogger.info("H.265 session seeded from SDP at create-time", {
-          meta: { sessionId, brokerId, psCount: sdpPs.length }
+        seedFromSdp(sdpPs);
+        sessionLogger.info("RTP session seeded from SDP at create-time", {
+          meta: { sessionId, brokerId, codec: sessionCodec, psCount: sdpPs.length }
         });
       } else {
-        sessionLogger.info("H.265 session deferred: SDP params not ready, subscribing for late delivery", {
-          meta: { sessionId, brokerId }
+        sessionLogger.info("RTP session deferred: SDP params not ready, subscribing for late delivery", {
+          meta: { sessionId, brokerId, codec: sessionCodec }
         });
         unsubSdpParams = broker.onSdpParameterSets((ps) => {
           try {
-            session.seedH265CodecInfoFromSdp(ps);
-            sessionLogger.info("H.265 session seeded from SDP late delivery", {
-              meta: { sessionId, brokerId, psCount: ps.length }
+            seedFromSdp(ps);
+            sessionLogger.info("RTP session seeded from SDP late delivery", {
+              meta: { sessionId, brokerId, codec: sessionCodec, psCount: ps.length }
             });
           } catch (err) {
-            sessionLogger.warn("seedH265CodecInfoFromSdp threw", {
-              meta: { sessionId, error: index.errMsg(err) }
+            sessionLogger.warn("seedCodecInfoFromSdp threw", {
+              meta: { sessionId, codec: sessionCodec, error: index.errMsg(err) }
             });
           }
         });
@@ -9957,15 +11153,15 @@ class BrokerWebrtcServer {
       unsubRtp = broker.onVideoRtp((rtpData) => {
         if (!firstRtpForwarded) {
           firstRtpForwarded = true;
-          sessionLogger.info("H.265 session: first source RTP forwarded to repacketizer", {
-            meta: { sessionId, brokerId, bytes: rtpData.length }
+          sessionLogger.info("RTP session: first source RTP forwarded to repacketizer", {
+            meta: { sessionId, brokerId, codec: sessionCodec, bytes: rtpData.length }
           });
         }
         try {
           session.forwardSourceRtpVideo(rtpData);
         } catch (err) {
           sessionLogger.warn("forwardSourceRtpVideo threw", {
-            meta: { sessionId, error: index.errMsg(err) }
+            meta: { sessionId, codec: sessionCodec, error: index.errMsg(err) }
           });
         }
       });
@@ -9977,9 +11173,10 @@ class BrokerWebrtcServer {
       sessionId,
       session,
       sessionLogger,
+      deviceId,
       brokerId,
       sessionCodec,
-      useH265Repacketizer,
+      useRtpRepacketizer,
       iceServerCount: iceServers.length
     };
   }
@@ -9988,13 +11185,29 @@ class BrokerWebrtcServer {
     if (!entry) throw new Error(`Session not found: ${sessionId}`);
     await entry.session.handleAnswer({ sdp: sdpAnswer, type: "answer" });
   }
+  /** Trickle ICE — add a remote (client) candidate to a live session. */
+  async addIceCandidate(sessionId, candidate) {
+    const entry = this.sessions.get(sessionId);
+    if (!entry) return;
+    await entry.session.addIceCandidate(candidate).catch((err) => {
+      this.logger.warn("addIceCandidate threw", { meta: { sessionId, error: index.errMsg(err) } });
+    });
+  }
+  /** Trickle ICE — the server's gathered candidates for a session (poll). */
+  getIceCandidates(sessionId) {
+    const entry = this.sessions.get(sessionId);
+    if (!entry) return { candidates: [], done: true };
+    return entry.session.getIceCandidatesSnapshot();
+  }
   async closeSession(sessionId) {
     const entry = this.sessions.get(sessionId);
     if (!entry) return;
     this.cleanupSession(sessionId);
     await entry.session.close().catch(() => {
     });
-    this.logger.info("WebRTC session closed", { meta: { sessionId } });
+    this.logger.info("WebRTC session closed", {
+      meta: { sessionId, deviceId: deviceIdFromBrokerId(entry.brokerId) }
+    });
   }
   async stop() {
     if (this.stopped) return;
@@ -10090,6 +11303,12 @@ class BrokerWebrtcServer {
     return this.staticIceServers ?? [];
   }
 }
+function deviceIdFromBrokerId(brokerId) {
+  const slashIdx = brokerId.indexOf("/");
+  if (slashIdx <= 0) return -1;
+  const parsed = Number.parseInt(brokerId.slice(0, slashIdx), 10);
+  return Number.isNaN(parsed) ? -1 : parsed;
+}
 function detectFirstNalType(annexB, isHevc) {
   for (let i = 0; i < annexB.length - 4; i++) {
     if (annexB[i] === 0 && annexB[i + 1] === 0 && annexB[i + 2] === 0 && annexB[i + 3] === 1 && i + 4 < annexB.length) {
@@ -10260,7 +11479,10 @@ class WebrtcSessionProvider {
   async createSession(input) {
     const streamId = this.resolveTargetToStreamId(input.deviceId, input.target);
     const streamingDebug = typeof this.manager.isStreamingDebug === "function" ? this.manager.isStreamingDebug(input.deviceId) : false;
-    return this.webrtcServer.createSession(streamId, input.hints, { streamingDebug });
+    return this.webrtcServer.createSession(streamId, input.hints, {
+      streamingDebug,
+      relayOnly: input.relayOnly === true
+    });
   }
   async handleOffer(input) {
     const target = input.target ?? { kind: "adaptive" };
@@ -10268,12 +11490,23 @@ class WebrtcSessionProvider {
     const streamingDebug = typeof this.manager.isStreamingDebug === "function" ? this.manager.isStreamingDebug(input.deviceId) : false;
     return this.webrtcServer.handleOffer(streamId, input.sdpOffer, void 0, {
       streamingDebug,
-      sessionId: input.sessionId
+      sessionId: input.sessionId,
+      relayOnly: input.relayOnly === true
     });
   }
   async handleAnswer(input) {
     await this.webrtcServer.handleAnswer(input.sessionId, input.sdpAnswer);
   }
+  async addIceCandidate(input) {
+    await this.webrtcServer.addIceCandidate(input.sessionId, {
+      candidate: input.candidate,
+      sdpMid: input.sdpMid ?? null,
+      sdpMLineIndex: input.sdpMLineIndex ?? null
+    });
+  }
+  async getIceCandidates(input) {
+    return this.webrtcServer.getIceCandidates(input.sessionId);
+  }
   async closeSession(input) {
     await this.webrtcServer.closeSession(input.sessionId);
   }
@@ -10303,6 +11536,7 @@ const BROKER_METRICS_HEARTBEAT_MS = 3e4;
 class StreamBrokerAddon extends index.BaseAddon {
   brokerManager = null;
   metricsSnapshotTimer = null;
+  catalogReconcileTimer = null;
   /**
    * Snapshot-equality cache for the broker-metrics emit. Each
    * broker emits a stats snapshot every BROKER_METRICS_SNAPSHOT_-
@@ -10323,7 +11557,8 @@ class StreamBrokerAddon extends index.BaseAddon {
       rtspPort: 8554,
       maxDecodeFps: 5,
       initialReconnectDelayMs: 1e3,
-      maxReconnectDelayMs: 3e4
+      maxReconnectDelayMs: 3e4,
+      catalogReconcileIntervalSec: 30
     });
   }
   async onInitialize() {
@@ -10502,6 +11737,38 @@ class StreamBrokerAddon extends index.BaseAddon {
         });
       }
     });
+    const reconcileAll = (reason) => {
+      void this.brokerManager?.reconcileAllCatalogs().catch((err) => {
+        this.ctx.logger.warn("catalog reconcile failed", { meta: { reason, error: index.errMsg(err) } });
+      });
+    };
+    const reconcileDevice = (deviceId, reason) => {
+      void this.brokerManager?.reconcileDeviceCatalog(deviceId).catch((err) => {
+        this.ctx.logger.warn("device catalog reconcile failed", {
+          tags: { deviceId },
+          meta: { reason, error: index.errMsg(err) }
+        });
+      });
+    };
+    reconcileAll("startup");
+    const reconcileMs = Math.max(5, this.config.catalogReconcileIntervalSec) * 1e3;
+    this.catalogReconcileTimer = setInterval(() => reconcileAll("poll"), reconcileMs);
+    this.subscribe({ category: index.EventCategory.DeviceRegistered }, (event) => {
+      const deviceId = event.data.deviceId;
+      if (typeof deviceId === "number") reconcileDevice(deviceId, "device-registered");
+    });
+    this.subscribe({ category: index.EventCategory.DeviceUnregistered }, (event) => {
+      const deviceId = event.data.deviceId;
+      if (typeof deviceId === "number") {
+        void this.brokerManager?.retractDevice(deviceId).catch((err) => {
+          this.ctx.logger.warn("device retract failed", { tags: { deviceId }, meta: { error: index.errMsg(err) } });
+        });
+      }
+    });
+    this.subscribe({ category: index.EventCategory.StreamParamsChanged }, (event) => {
+      const deviceId = event.data.deviceId;
+      if (typeof deviceId === "number") reconcileDevice(deviceId, "stream-params-changed");
+    });
     const cameraStreamsProvider = new CameraStreamsProvider(this.brokerManager);
     const turnApi = this.ctx.api;
     const webrtcServer = new BrokerWebrtcServer({
@@ -10519,6 +11786,9 @@ class StreamBrokerAddon extends index.BaseAddon {
               ...s.credential ? { credential: s.credential } : {}
             });
           }
+          this.ctx.logger.info("broker getIceServers resolved", {
+            meta: { count: out.length, urls: out.map((s) => Array.isArray(s.urls) ? s.urls[0] : s.urls) }
+          });
           return out;
         } catch (err) {
           this.ctx.logger.warn("turnProvider.getTurnServers failed — session will start without TURN", {
@@ -10578,6 +11848,10 @@ class StreamBrokerAddon extends index.BaseAddon {
       clearInterval(this.metricsSnapshotTimer);
       this.metricsSnapshotTimer = null;
     }
+    if (this.catalogReconcileTimer) {
+      clearInterval(this.catalogReconcileTimer);
+      this.catalogReconcileTimer = null;
+    }
     await this.brokerManager?.destroyAll();
     this.brokerManager = null;
   }
@@ -10660,6 +11934,17 @@ class StreamBrokerAddon extends index.BaseAddon {
               max: 30,
               step: 1,
               default: 5
+            },
+            {
+              type: "number",
+              key: "catalogReconcileIntervalSec",
+              label: "Catalog Reconcile Interval",
+              description: "How often the broker re-pulls every camera’s stream catalog (reconcile backstop)",
+              min: 5,
+              max: 300,
+              step: 5,
+              default: 30,
+              unit: "s"
             }
           ]
         },