@camstack/addon-export-hap 1.2.11 → 1.2.12

package/dist/export-hap.addon.mjs

@@ -2,7 +2,7 @@ import { createRequire } from "node:module";
 import { createHash, randomBytes } from "node:crypto";
 import * as path from "node:path";
 import { spawn } from "node:child_process";
-import { Accessory, AudioBitrate, AudioRecordingCodecType, AudioRecordingSamplerate, AudioStreamingCodecType, AudioStreamingSamplerate, CameraController, Categories, Characteristic, DoorbellController, EventTriggerOption, H264Level, H264Profile, HAPStorage, MediaContainerType, SRTPCryptoSuites, Service, VideoCodecType, uuid } from "@homebridge/hap-nodejs";
+import { Accessory, AudioBitrate, AudioStreamingCodecType, AudioStreamingSamplerate, CameraController, Categories, Characteristic, DoorbellController, H264Level, H264Profile, HAPStorage, SRTPCryptoSuites, Service, uuid } from "@homebridge/hap-nodejs";
 import * as fs from "node:fs/promises";
 import { createSocket } from "node:dgram";
 import { networkInterfaces } from "node:os";
@@ -14702,6 +14702,70 @@ var EventPruneCountsSchema = object({
 	object: number().int(),
 	audio: number().int()
 });
+/**
+* Re-embed stored tracks from their key frames.
+*
+* The reason this is an operator-callable method and not a migration script:
+* every knob that decides what a vector MEANS — encoder model, crop margin,
+* squaring — is only changeable if the existing vectors can be regenerated.
+* Mixing feature spaces in one index makes cosine scores incomparable, and the
+* symptom is a quality regression with no visible cause.
+*/
+var RebuildObjectEmbeddingsInput = object({
+	/** Restrict to one camera. Omit for the whole fleet. */
+	deviceId: number().optional(),
+	since: number().optional(),
+	until: number().optional(),
+	/** Stop after this many tracks; the result reports whether more remain. */
+	maxTracks: number().int().positive().optional()
+});
+/**
+* Result of emptying the CLIP index.
+*
+* The clean slate before a policy change: a new crop margin or encoder model
+* leaves two feature spaces in one index whose cosine scores are not
+* comparable, so wiping and rebuilding is the only way to be sure every vector
+* means the same thing.
+*/
+var WipeObjectEmbeddingsResultSchema = object({ deleted: number() });
+/**
+* Acknowledgement that a rebuild STARTED.
+*
+* The pass costs ~1s per track — 45 minutes for a 2,600-track fleet — so it
+* runs detached and this returns immediately. Waiting for it made the client
+* time out while the work carried on server-side, which is the worst of both:
+* no result and no way to know it was still going. Poll
+* `getObjectEmbeddingRebuildStatus` for progress.
+*/
+var RebuildObjectEmbeddingsResultSchema = object({
+	started: boolean(),
+	/** True when a pass was already running; the new request is ignored. */
+	alreadyRunning: boolean()
+});
+var RebuildStatusSchema = object({
+	running: boolean(),
+	scanned: number(),
+	rebuilt: number(),
+	/** Tracks whose key frame is gone — nothing to re-embed from. */
+	missingKeyFrame: number(),
+	/** Tracks with no usable detection box. */
+	missingBbox: number(),
+	/**
+	* Tracks the pipeline REFUSED rather than broke on: the camera is not
+	* attached, or `clip-embedding` is not enabled in its step tree. Separate
+	* from `failed` because the remedy is a configuration change, not an engine
+	* investigation — and because a pass over decommissioned cameras would
+	* otherwise read as a total engine outage.
+	*/
+	notRunnable: number(),
+	failed: number(),
+	/** Set once a pass ends: true only when EVERYTHING was covered. */
+	complete: boolean().nullable(),
+	startedAtMs: number().nullable(),
+	finishedAtMs: number().nullable(),
+	/** Present when the pass ended by throwing. */
+	error: string().nullable()
+});
 DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).readonly()), method(object({
 	deviceId: number(),
 	trackId: string()
@@ -14795,7 +14859,13 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
 }), array(MediaFileSchema).readonly()), method(object({
 	trackId: string(),
 	kinds: array(MediaFileKindEnum).optional()
-}), array(MediaFileSchema).readonly()), method(object({ trackId: string() }), array(MediaFileInfoSchema).readonly()), method(SearchObjectEventsInput, array(ScoredObjectEventSchema).readonly()), object({
+}), array(MediaFileSchema).readonly()), method(object({ trackId: string() }), array(MediaFileInfoSchema).readonly()), method(SearchObjectEventsInput, array(ScoredObjectEventSchema).readonly()), method(object({}), WipeObjectEmbeddingsResultSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(RebuildObjectEmbeddingsInput, RebuildObjectEmbeddingsResultSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({}), RebuildStatusSchema), object({
 	deviceId: number(),
 	timestamp: number(),
 	frameWidth: number(),
@@ -15704,6 +15774,17 @@ method(RunnerCameraConfigSchema, object({ success: literal(true) }), { kind: "mu
 }), NativeCropResultSchema.nullable()), method(object({
 	deviceId: number(),
 	frameHandle: FrameHandleSchema.optional(),
+	/**
+	* FULL FRAME (base64 JPEG). The runner derives the crop rectangle from
+	* `parent.bbox` with the cluster crop convention and cuts it itself —
+	* do NOT pre-crop for this field, that is what `cropJpeg` is.
+	*/
+	frameJpeg: string().optional(),
+	/**
+	* PRE-CUT tile (base64 JPEG), used verbatim — NO padding is applied.
+	* The fallback when the lease/session backing the frame is gone and the
+	* caller already holds a crop.
+	*/
 	cropJpeg: string().optional(),
 	parent: DetailParentSchema,
 	steps: array(string()).optional()
@@ -17029,6 +17110,24 @@ var VectorDeleteByFilterInputSchema = object({
 	filter: VectorFilterSchema
 });
 var VectorDeleteResultSchema = object({ deleted: number() });
+var VectorGetInputSchema = object({
+	index: string(),
+	ids: array(string())
+});
+/**
+* Metadata for the requested ids, WITHOUT their vectors.
+*
+* The only caller is a best-of gate that compares a candidate's confidence
+* against the stored one, and shipping 512 floats back to answer "is 0.91 >
+* 0.87" would undo the point of the compact encoding. Ids with no row are
+* simply absent — a caller distinguishing "not stored" from "stored" reads the
+* length, and a null placeholder would invite a `?? 0` that treats a missing
+* row as confidence zero.
+*/
+var VectorGetResultSchema = object({ items: array(object({
+	id: string(),
+	metadata: VectorMetadataSchema
+})) });
 var VectorStatsInputSchema = object({ index: string() });
 var VectorStatsResultSchema = object({
 	/** Provider id, so an operator can tell brute force from an ANN index. */
@@ -17041,7 +17140,7 @@ var VectorStatsResultSchema = object({
 	/** False when the backend ranks approximately. */
 	exact: boolean()
 });
-method(VectorDeclareIndexInputSchema, _void(), { kind: "mutation" }), method(VectorUpsertInputSchema, VectorUpsertResultSchema, { kind: "mutation" }), method(VectorQueryInputSchema, VectorQueryResultSchema), method(VectorDeleteInputSchema, VectorDeleteResultSchema, { kind: "mutation" }), method(VectorDeleteByFilterInputSchema, VectorDeleteResultSchema, { kind: "mutation" }), method(VectorStatsInputSchema, VectorStatsResultSchema);
+method(VectorDeclareIndexInputSchema, _void(), { kind: "mutation" }), method(VectorUpsertInputSchema, VectorUpsertResultSchema, { kind: "mutation" }), method(VectorQueryInputSchema, VectorQueryResultSchema), method(VectorGetInputSchema, VectorGetResultSchema), method(VectorDeleteInputSchema, VectorDeleteResultSchema, { kind: "mutation" }), method(VectorDeleteByFilterInputSchema, VectorDeleteResultSchema, { kind: "mutation" }), method(VectorStatsInputSchema, VectorStatsResultSchema);
 /**
 * `videoclips` — the unified, navigable-clip surface for a camera.
 *
@@ -25304,6 +25403,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineAnalytics.getObjectEmbeddingRebuildStatus": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.getObjectEvents": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -25382,6 +25487,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineAnalytics.rebuildObjectEmbeddings": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineAnalytics.relocateMedia": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -25400,6 +25511,12 @@ Object.freeze({
 		addonId: null,
 		access: "delete"
 	},
+	"pipelineAnalytics.wipeObjectEmbeddings": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "delete"
+	},
 	"pipelineExecutor.cacheFrameInPool": {
 		capName: "pipeline-executor",
 		capScope: "system",
@@ -27320,6 +27437,12 @@ Object.freeze({
 		addonId: null,
 		access: "delete"
 	},
+	"vectorStore.getByIds": {
+		capName: "vector-store",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"vectorStore.query": {
 		capName: "vector-store",
 		capScope: "system",
@@ -27594,6 +27717,30 @@ TimelapseRuleInputSchema.extend({
 	createdAt: number(),
 	updatedAt: number()
 });
+object({
+	/**
+	* Fraction of the box's own size added on EACH side before cutting.
+	*
+	* CLIP is trained on natural images WITH surroundings; a pixel-tight crop
+	* removes exactly the context it is strongest on (a dog cut to its outline
+	* is a dark blob). The right value is an empirical question, which is why it
+	* is a setting: 0 / 0.15 / 0.2 / 0.5 are the interesting points.
+	*/
+	paddingRatio: number().min(0).max(4),
+	/**
+	* Square the window (in PIXELS) before cutting.
+	*
+	* CLIP's input is square, so a tall bbox resized straight to NxN is squashed
+	* — a standing person becomes a shape the model never saw. Squaring costs
+	* extra background, which is context the model wants anyway. Off by default
+	* because the live path has never squared and the stored index reflects that.
+	*/
+	square: boolean()
+});
+({
+	paddingRatio: .15,
+	square: false
+}).paddingRatio;
 /**
 * Deterministic SHA-256 hash of an arbitrary serialisable value. The
 * canonical form sorts object keys alphabetically at every depth so two
@@ -38150,13 +38297,305 @@ var require_src = /* @__PURE__ */ __commonJSMin(((exports) => {
 	__exportStar(require_util(), exports);
 }));
 //#endregion
-//#region src/mappers/builders/camera-streams.ts
+//#region src/mappers/builders/rtcp-gate.ts
 var import_src = require_src();
+/** `packet@42ms` / `timeout@1000ms` — one compact log field. */
+function formatRtcpGate(resolution) {
+	if (resolution === null) return "pending";
+	return `${resolution.reason}@${resolution.waitedMs}ms`;
+}
+/**
+* Resolve as soon as ANY packet arrives on `socket`, or after `timeoutMs`.
+* One-shot: the listener is detached on either path.
+*/
+function makeRtcpGate(socket, timeoutMs) {
+	const armedAt = Date.now();
+	return new Promise((resolve) => {
+		const onMessage = () => {
+			socket.removeListener("message", onMessage);
+			clearTimeout(timer);
+			resolve({
+				reason: "packet",
+				waitedMs: Date.now() - armedAt
+			});
+		};
+		const timer = setTimeout(() => {
+			socket.removeListener("message", onMessage);
+			resolve({
+				reason: "timeout",
+				waitedMs: Date.now() - armedAt
+			});
+		}, timeoutMs);
+		socket.on("message", onMessage);
+	});
+}
+/**
+* The resolutions we offer, before rates are attached. Same list the delegate
+* advertised before R2 — only the frame rate changes, so a controller that had
+* already negotiated a resolution keeps finding it.
+*/
+var CANDIDATE_RESOLUTIONS = [
+	[1920, 1080],
+	[1280, 720],
+	[1024, 768],
+	[640, 480],
+	[640, 360],
+	[480, 360],
+	[480, 270],
+	[320, 240],
+	[320, 180]
+];
+/**
+* Resolve the real frame rate of each profile slot.
+*
+* A slot with no measurement, no publication and no assignment simply does not
+* appear in the map — the caller then advertises {@link ASSUMED_FPS} and says
+* so. Absence is never silently rendered as a number.
+*/
+function resolveProfileFps(input) {
+	const publishedByProfile = publishedFpsByProfile(input.slots, input.camStreams);
+	const out = /* @__PURE__ */ new Map();
+	for (const choice of input.choices) {
+		if (choice.target.kind !== "profile") continue;
+		const profile = choice.target.profile;
+		const measured = clampFps(choice.inputFps);
+		if (measured !== null) {
+			out.set(profile, {
+				profile,
+				fps: measured,
+				source: "measured"
+			});
+			continue;
+		}
+		const published = clampFps(publishedByProfile.get(profile) ?? null);
+		out.set(profile, published !== null ? {
+			profile,
+			fps: published,
+			source: "published"
+		} : {
+			profile,
+			fps: 30,
+			source: "assumed"
+		});
+	}
+	for (const [profile, fps] of publishedByProfile) {
+		if (out.has(profile)) continue;
+		const published = clampFps(fps);
+		if (published !== null) out.set(profile, {
+			profile,
+			fps: published,
+			source: "published"
+		});
+	}
+	return out;
+}
+/**
+* Attach a frame rate to each candidate resolution by asking the REAL picker
+* which slot the START path would dial for it. That coupling is the point: if
+* the picker's steering changes, the advertisement changes with it instead of
+* drifting into a second, silently different opinion.
+*/
+function deriveAdvertisedResolutions(input) {
+	const candidates = input.candidates.length > 0 ? input.candidates : CANDIDATE_RESOLUTIONS;
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const [width, height] of candidates) {
+		const picked = pickPreferredRtspEntry(input.entries, input.pref, input.deviceId, { targetResolution: {
+			width,
+			height
+		} });
+		const profile = picked === null ? null : toCamProfile(picked.profileId);
+		const resolved = profile === null ? void 0 : input.fpsByProfile.get(profile);
+		const advertised = {
+			width,
+			height,
+			fps: resolved?.fps ?? 30,
+			profile,
+			source: resolved?.source ?? "assumed"
+		};
+		const key = `${advertised.width}x${advertised.height}@${advertised.fps}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		out.push(advertised);
+	}
+	return out;
+}
+/** Project onto the `[width, height, fps]` triples hap-nodejs expects. */
+function toHapResolutions(advertised) {
+	return advertised.map((a) => [
+		a.width,
+		a.height,
+		a.fps
+	]);
+}
+/** Compact `1280x720@10(measured)` rendering for a single log field. */
+function formatAdvertisedResolutions(advertised) {
+	return advertised.map((a) => `${a.width}x${a.height}@${a.fps}/${a.profile ?? "-"}(${a.source})`);
+}
+function publishedFpsByProfile(slots, camStreams) {
+	const fpsByCamStream = /* @__PURE__ */ new Map();
+	for (const stream of camStreams) if (typeof stream.fps === "number") fpsByCamStream.set(stream.camStreamId, stream.fps);
+	const out = /* @__PURE__ */ new Map();
+	for (const slot of slots) {
+		if (slot.sourceCamStreamId === null) continue;
+		const fps = fpsByCamStream.get(slot.sourceCamStreamId);
+		if (fps !== void 0) out.set(slot.profile, fps);
+	}
+	return out;
+}
+/**
+* Coerce a probe reading into an advertisable integer rate, or null when the
+* reading carries no information (absent, zero because the broker is idle,
+* negative, NaN, or below the representable floor).
+*/
+function clampFps(value) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return null;
+	const floored = Math.floor(value);
+	if (floored < 1) return null;
+	return Math.min(floored, 30);
+}
+var CAM_PROFILES = [
+	"high",
+	"mid",
+	"low"
+];
+/**
+* `PickedStream.profileId` is the brokerId suffix, which for a profile-keyed
+* entry IS the profile name. Anything else (a raw cam-stream id) is not a
+* profile and must not be coerced into one.
+*/
+function toCamProfile(profileId) {
+	return CAM_PROFILES.find((p) => p === profileId) ?? null;
+}
+//#endregion
+//#region src/mappers/builders/stream-telemetry.ts
+/**
+* Every branch on the streaming path that discards work, and its starting
+* count. This object is the single source of the reason set: the union below
+* is its `keyof`, so adding a silent `return` without adding a reason here is
+* a compile error rather than an invisible hole.
+*/
+var ZERO_DROP_COUNTERS = {
+	/** Outbound: the leg has no SRTP session (prepareStream init failed). */
+	"no-srtp-session": 0,
+	/** Outbound: the leg has no return-path gate — forwarding was never armed. */
+	"no-gate": 0,
+	/** Outbound: werift refused to encrypt the packet. */
+	"srtp-encrypt-failed": 0,
+	/** Outbound: the UDP send itself errored. */
+	"srtp-send-failed": 0,
+	/** Outbound RTCP: the leg has no SRTCP context, so no Sender Report can go out. */
+	"rtcp-no-srtcp": 0,
+	/** Outbound RTCP: building or encrypting the Sender Report failed. */
+	"rtcp-encrypt-failed": 0,
+	/** Upstream: packet shorter than an RTP header. */
+	"upstream-short-packet": 0,
+	/** Upstream: no inbound SRTP context (init failed at prepareStream). */
+	"upstream-no-srtp": 0,
+	/** Upstream: SRTP authentication/decrypt failed. */
+	"upstream-decrypt-failed": 0,
+	/** Upstream: decrypted bytes did not parse as RTP. */
+	"upstream-parse-failed": 0,
+	/** Upstream: audio arrived before `handleStreamRequest('start')` settled. */
+	"upstream-before-start": 0,
+	/** Upstream: payload type is not the negotiated audio PT (RTCP / keepalive). */
+	"upstream-pt-mismatch": 0,
+	/** Upstream: RTP carried a zero-length payload. */
+	"upstream-empty-payload": 0,
+	/** Upstream: no camera-side talk session, so the frame has nowhere to go. */
+	"upstream-no-talk-session": 0,
+	/** Upstream: the camera-side `pushTalkAudio` rejected the frame. */
+	"upstream-push-failed": 0,
+	/** Snapshot: the `snapshot` cap returned nothing. */
+	"snapshot-unavailable": 0
+};
+function emptyDropCounters() {
+	return { ...ZERO_DROP_COUNTERS };
+}
+/** Immutable increment — returns a new record, never touches the input. */
+function recordDrop(counters, reason) {
+	return {
+		...counters,
+		[reason]: counters[reason] + 1
+	};
+}
+/** Only the reasons that actually fired, so a clean session logs `{}`. */
+function nonZeroDrops(counters) {
+	const out = {};
+	for (const [reason, count] of Object.entries(counters)) if (count > 0) out[reason] = count;
+	return out;
+}
+/**
+* Classify a packet received on one of our advertised return ports.
+*
+* RTP and RTCP arrive on the same symmetric port here. RTCP packet types are
+* 200..207, which sit inside the 192..223 band RFC 5761 §4 reserves precisely
+* so the two can be told apart on a shared socket (an RTP packet's marker bit
+* plus payload type can never land there for any payload type we negotiate).
+* The payloads are SRTP/SRTCP-encrypted, but both keep the first two bytes in
+* the clear.
+*/
+function classifyInboundPacket(packet) {
+	if (packet.length < 2) return "malformed";
+	if ((packet[0] >> 6 & 3) !== 2) return "malformed";
+	const typeByte = packet[1];
+	if (typeByte >= 192 && typeByte <= 223) return "rtcp";
+	return "rtp";
+}
+/**
+* Build the meta for `export-hap: stream session summary` — the single line a
+* future session greps to answer "why did this session die".
+*/
+function summariseSession(snapshot) {
+	const durationMs = snapshot.startedAtMs !== null && snapshot.endedAtMs !== null ? snapshot.endedAtMs - snapshot.startedAtMs : null;
+	const negotiated = snapshot.negotiated;
+	const slot = snapshot.selectedSlot;
+	return {
+		sessionId: snapshot.sessionId,
+		durationMs,
+		stopRequestedByController: snapshot.stopRequestedByController,
+		ffmpegExitCode: snapshot.ffmpegExit?.code ?? null,
+		ffmpegExitSignal: snapshot.ffmpegExit?.signal ?? null,
+		negotiatedResolution: negotiated ? `${negotiated.width}x${negotiated.height}` : null,
+		negotiatedFps: negotiated?.fps ?? null,
+		negotiatedMaxBitrateKbps: negotiated?.maxBitrateKbps ?? null,
+		selectedProfile: slot?.profile ?? null,
+		selectedBrokerId: slot?.brokerId ?? null,
+		advertisedFps: slot?.advertisedFps ?? null,
+		advertisedFpsSource: slot?.advertisedFpsSource ?? null,
+		transcode: slot?.transcode ?? null,
+		videoPacketsForwarded: snapshot.videoPacketsForwarded,
+		audioPacketsForwarded: snapshot.audioPacketsForwarded,
+		videoRtcpSrSent: snapshot.videoRtcpSrSent,
+		audioRtcpSrSent: snapshot.audioRtcpSrSent,
+		videoRtcpReceived: snapshot.videoRtcpReceived,
+		audioRtcpReceived: snapshot.audioRtcpReceived,
+		videoRtpReceived: snapshot.videoRtpReceived,
+		audioRtpReceived: snapshot.audioRtpReceived,
+		videoGate: formatRtcpGate(snapshot.videoGate),
+		audioGate: formatRtcpGate(snapshot.audioGate),
+		mediaStarved: snapshot.videoPacketsForwarded === 0,
+		drops: nonZeroDrops(snapshot.drops)
+	};
+}
+//#endregion
+//#region src/mappers/builders/camera-streams.ts
 var SRTP_KEY_LEN = 16;
 var SRTP_SALT_LEN = 14;
+/**
+* Cadence of the per-session heartbeat log.
+*
+* This timer LOGS ONLY. It never kills ffmpeg, never closes a socket and never
+* ends a session. That distinction matters: the two mainstream open-source
+* HomeKit camera stacks arm an idle watchdog that tears the stream down at
+* exactly 30 000 ms, and the ~31 s teardown here was misdiagnosed as one for a
+* long time before it was proven that this accessory has no such timer. Do not
+* make this one act.
+*/
+var SESSION_HEARTBEAT_MS = 5e3;
 var OPUS_BITRATE_KBPS = 24;
 var OPUS_CHANNELS = 1;
-function buildCameraStreamingDelegate(bctx) {
+function buildCameraStreamingDelegate(bctx, advertised) {
 	const { ctx, numericDeviceId } = bctx;
 	const log = ctx.logger.withTags({ deviceId: numericDeviceId });
 	const sessions = /* @__PURE__ */ new Map();
@@ -38175,7 +38614,7 @@ function buildCameraStreamingDelegate(bctx) {
 				});
 			},
 			handleStreamRequest(request, callback) {
-				handleStreamRequest(request, sessions, bctx).then(() => callback()).catch((err) => {
+				handleStreamRequest(request, sessions, bctx, advertised).then(() => callback()).catch((err) => {
 					log.warn("export-hap: handleStreamRequest failed", { meta: { error: errMsg$8(err) } });
 					callback(err instanceof Error ? err : new Error(errMsg$8(err)));
 				});
@@ -38196,58 +38635,7 @@ function buildCameraStreamingDelegate(bctx) {
 						H264Level.LEVEL4_0
 					]
 				},
-				resolutions: [
-					[
-						1920,
-						1080,
-						30
-					],
-					[
-						1280,
-						720,
-						30
-					],
-					[
-						1024,
-						768,
-						30
-					],
-					[
-						640,
-						480,
-						30
-					],
-					[
-						640,
-						360,
-						30
-					],
-					[
-						480,
-						360,
-						30
-					],
-					[
-						480,
-						270,
-						30
-					],
-					[
-						320,
-						240,
-						30
-					],
-					[
-						320,
-						240,
-						15
-					],
-					[
-						320,
-						180,
-						30
-					]
-				]
+				resolutions: toHapResolutions(advertised.resolutions)
 			},
 			audio: {
 				codecs: [{
@@ -38262,10 +38650,16 @@ function buildCameraStreamingDelegate(bctx) {
 		},
 		dispose: async () => {
 			for (const session of sessions.values()) {
+				session.teardownTrigger = "accessory-dispose";
+				const hadFfmpeg = session.ffmpeg !== null;
 				killFfmpeg(session, ctx, numericDeviceId);
+				stopHeartbeat(session);
+				if (!hadFfmpeg) logSessionSummary(session, log, "accessory-dispose-no-ffmpeg");
 				await closeIntercomTalkSession(session, bctx).catch(() => void 0);
 				closeSocket(session.videoUdp);
 				closeSocket(session.audioUdp);
+				closeSocket(session.videoLoopUdp);
+				closeSocket(session.audioLoopUdp);
 			}
 			sessions.clear();
 		}
@@ -38275,7 +38669,10 @@ async function handleSnapshot(bctx, request) {
 	const { proxy, ctx, numericDeviceId } = bctx;
 	const result = await proxy.snapshot?.getSnapshot({});
 	if (!result || typeof result.base64 !== "string") {
-		ctx.logger.withTags({ deviceId: numericDeviceId }).debug("export-hap: snapshot returned null");
+		ctx.logger.withTags({ deviceId: numericDeviceId }).info("export-hap: snapshot dropped", { meta: {
+			reason: "snapshot-unavailable",
+			capBound: proxy.snapshot !== void 0
+		} });
 		throw new Error("snapshot unavailable");
 	}
 	return Buffer.from(result.base64, "base64");
@@ -38347,6 +38744,26 @@ async function prepareStream(request, sessions, bctx) {
 	const videoSsrc = randomSsrc();
 	const audioSsrc = randomSsrc();
 	const session = {
+		sessionId: request.sessionID,
+		startedAtMs: null,
+		endedAtMs: null,
+		negotiated: null,
+		selectedSlot: null,
+		ffmpegExit: null,
+		stopRequestedByController: false,
+		teardownTrigger: null,
+		drops: emptyDropCounters(),
+		videoPacketsForwarded: 0,
+		audioPacketsForwarded: 0,
+		videoRtcpSrSent: 0,
+		audioRtcpSrSent: 0,
+		videoRtcpReceived: 0,
+		audioRtcpReceived: 0,
+		videoRtpReceived: 0,
+		audioRtpReceived: 0,
+		videoGate: null,
+		audioGate: null,
+		heartbeat: null,
 		hapVideoPort: request.video.port,
 		hapAddress: request.targetAddress,
 		videoSrtpKey: request.video.srtp_key,
@@ -38391,19 +38808,33 @@ async function prepareStream(request, sessions, bctx) {
 		audioRtcpIntervalMs: 5e3
 	};
 	sessions.set(request.sessionID, session);
+	const tagLog = bctx.ctx.logger.withTags({ deviceId: bctx.numericDeviceId });
 	session.videoSendGate = makeRtcpGate(videoUdp, 1e3);
 	session.audioSendGate = makeRtcpGate(audioUdp, 1e3);
-	const tagLog = bctx.ctx.logger.withTags({ deviceId: bctx.numericDeviceId });
-	let videoPacketsForwarded = 0;
-	let audioPacketsForwarded = 0;
+	session.videoSendGate.then((resolution) => {
+		session.videoGate = resolution;
+		logGateResolved(session, "video", resolution, tagLog);
+	});
+	session.audioSendGate.then((resolution) => {
+		session.audioGate = resolution;
+		logGateResolved(session, "audio", resolution, tagLog);
+	});
+	videoUdp.on("message", (packet) => {
+		countInbound(session, "video", packet, tagLog);
+	});
+	audioUdp.on("message", (packet) => {
+		countInbound(session, "audio", packet, tagLog);
+	});
 	videoLoopUdp.on("message", (rtpPacket) => {
-		videoPacketsForwarded += 1;
-		if (videoPacketsForwarded === 1 || videoPacketsForwarded % 500 === 0) tagLog.info("export-hap: video loopback packets forwarded", { meta: { count: videoPacketsForwarded } });
+		session.videoPacketsForwarded += 1;
+		if (session.videoPacketsForwarded === 1) tagLog.info("export-hap: first video packet from ffmpeg", { meta: {
+			sessionId: session.sessionId,
+			bytes: rtpPacket.length
+		} });
 		forwardEncryptedRtp(session, rtpPacket, "video", tagLog);
 	});
 	audioLoopUdp.on("message", (rtpPacket) => {
-		audioPacketsForwarded += 1;
-		if (audioPacketsForwarded === 1 || audioPacketsForwarded % 100 === 0) tagLog.info("export-hap: audio loopback packets forwarded", { meta: { count: audioPacketsForwarded } });
+		session.audioPacketsForwarded += 1;
 		forwardEncryptedRtp(session, rtpPacket, "audio", tagLog);
 	});
 	audioUdp.on("message", (packet, rinfo) => {
@@ -38411,6 +38842,19 @@ async function prepareStream(request, sessions, bctx) {
 			bctx.ctx.logger.withTags({ deviceId: bctx.numericDeviceId }).debug("export-hap: incoming-audio handler error (dropped)", { meta: { error: errMsg$8(err) } });
 		});
 	});
+	tagLog.info("export-hap: stream prepared", { meta: {
+		sessionId: request.sessionID,
+		controllerAddress: request.targetAddress,
+		addressVersion: ipVersion,
+		localIp,
+		advertisedVideoPort: localVideoPort,
+		advertisedAudioPort: localAudioPort,
+		controllerVideoPort: request.video.port,
+		controllerAudioPort: request.audio.port,
+		videoSsrc,
+		audioSsrc,
+		upstreamAudioDecrypt: upstreamAudioSrtp !== null
+	} });
 	return {
 		video: {
 			port: localVideoPort,
@@ -38485,30 +38929,110 @@ function sameIpv4Subnet(a, mask, b) {
 async function bindLoopback(ipVersion) {
 	return bindUdp(ipVersion, ipVersion === "ipv6" ? "::1" : "127.0.0.1");
 }
+/** Book a named drop. Every silent `return` on the streaming path routes here. */
+function drop(session, reason) {
+	session.drops = recordDrop(session.drops, reason);
+}
 /**
-* Build a promise that resolves as soon as ANY packet (RTP or RTCP)
-* arrives on `socket`, OR `timeoutMs` elapses. The loopback reader
-* awaits this before forwarding the first encrypted SRTP frame so
-* iOS sees a return-path handshake before our actual stream begins.
-*
-* One-shot: the listener is removed on the first message OR on
-* timeout — the gate then stays resolved for the rest of the session.
+* Report a gate resolution. `timeout` is the interesting one: it means we are
+* about to stream into a port the controller never touched, and it was
+* indistinguishable from a successful probe until now.
 */
-function makeRtcpGate(socket, timeoutMs) {
-	return new Promise((resolve) => {
-		const onMessage = () => {
-			socket.removeListener("message", onMessage);
-			clearTimeout(timer);
-			resolve();
-		};
-		const timer = setTimeout(() => {
-			socket.removeListener("message", onMessage);
-			resolve();
-		}, timeoutMs);
-		socket.on("message", onMessage);
+function logGateResolved(session, leg, resolution, log) {
+	const meta = {
+		sessionId: session.sessionId,
+		leg,
+		reason: resolution.reason,
+		waitedMs: resolution.waitedMs
+	};
+	if (resolution.reason === "packet") log.info("export-hap: RTCP gate opened on a REAL controller packet", { meta });
+	else log.warn("export-hap: RTCP gate opened on the 1s FALLBACK — controller never probed", { meta });
+}
+/** Count and classify one packet the controller sent to a return port. */
+function countInbound(session, leg, packet, log) {
+	const kind = classifyInboundPacket(packet);
+	const firstRtcp = kind === "rtcp" && (leg === "video" ? session.videoRtcpReceived : session.audioRtcpReceived) === 0;
+	if (leg === "video") {
+		if (kind === "rtcp") session.videoRtcpReceived += 1;
+		else if (kind === "rtp") session.videoRtpReceived += 1;
+	} else if (kind === "rtcp") session.audioRtcpReceived += 1;
+	else if (kind === "rtp") session.audioRtpReceived += 1;
+	if (firstRtcp) log.info("export-hap: first inbound RTCP from controller", { meta: {
+		sessionId: session.sessionId,
+		leg,
+		bytes: packet.length
+	} });
+}
+/** Snapshot every counter into the summary meta. */
+function sessionSummaryMeta(session) {
+	return summariseSession({
+		sessionId: session.sessionId,
+		startedAtMs: session.startedAtMs,
+		endedAtMs: session.endedAtMs,
+		negotiated: session.negotiated,
+		selectedSlot: session.selectedSlot,
+		videoPacketsForwarded: session.videoPacketsForwarded,
+		audioPacketsForwarded: session.audioPacketsForwarded,
+		videoRtcpSrSent: session.videoRtcpSrSent,
+		audioRtcpSrSent: session.audioRtcpSrSent,
+		videoRtcpReceived: session.videoRtcpReceived,
+		audioRtcpReceived: session.audioRtcpReceived,
+		videoRtpReceived: session.videoRtpReceived,
+		audioRtpReceived: session.audioRtpReceived,
+		videoGate: session.videoGate,
+		audioGate: session.audioGate,
+		drops: session.drops,
+		ffmpegExit: session.ffmpegExit,
+		stopRequestedByController: session.stopRequestedByController
 	});
 }
 /**
+* Arm the per-session heartbeat. LOGS ONLY — see `SESSION_HEARTBEAT_MS`. It
+* exists so a session that stops producing media says so while it is still
+* alive, instead of being reconstructed after the fact from its final line.
+*/
+function armHeartbeat(session, log) {
+	if (session.heartbeat) clearInterval(session.heartbeat);
+	let lastVideo = session.videoPacketsForwarded;
+	const timer = setInterval(() => {
+		const forwarded = session.videoPacketsForwarded - lastVideo;
+		lastVideo = session.videoPacketsForwarded;
+		log.info("export-hap: stream heartbeat", { meta: {
+			...sessionSummaryMeta(session),
+			videoPacketsSinceLastBeat: forwarded,
+			videoStalled: forwarded === 0
+		} });
+	}, SESSION_HEARTBEAT_MS);
+	timer.unref();
+	session.heartbeat = timer;
+}
+function stopHeartbeat(session) {
+	if (!session.heartbeat) return;
+	clearInterval(session.heartbeat);
+	session.heartbeat = null;
+}
+/**
+* **`export-hap: stream session summary` is the line to grep** when asking why
+* a HomeKit session died. It carries the negotiated parameters, the slot we
+* dialled and the rate we had promised for it, packet counts in both
+* directions on both legs, each leg's gate outcome, ffmpeg's exit, who asked
+* for the teardown, and every named drop.
+*
+* Emitted from the ffmpeg `exit` handler — the only place the exit code is
+* known — and directly from the teardown paths when there is no ffmpeg to wait
+* for. It deliberately does NOT touch the heartbeat: iOS restarts a session
+* in place when it is not getting a picture (one on record was started three
+* times in 16 s), and stopping the heartbeat on the superseded process's exit
+* would silence the replacement.
+*/
+function logSessionSummary(session, log, trigger) {
+	session.endedAtMs = Date.now();
+	log.info("export-hap: stream session summary", { meta: {
+		...sessionSummaryMeta(session),
+		trigger
+	} });
+}
+/**
 * Build the NTP timestamp expected in an RTCP Sender Report.
 *
 * NTP timestamps are 64-bit: upper 32 bits = seconds since 1900-01-01,
@@ -38541,7 +39065,10 @@ function ntpTime() {
 */
 function sendRtcpSr(session, kind, log) {
 	const srtcp = kind === "video" ? session.videoOutSrtcp : session.audioOutSrtcp;
-	if (!srtcp) return;
+	if (!srtcp) {
+		drop(session, "rtcp-no-srtcp");
+		return;
+	}
 	const sink = kind === "video" ? session.videoUdp : session.audioUdp;
 	const port = kind === "video" ? session.hapVideoPort : session.hapAudioPort;
 	try {
@@ -38556,15 +39083,31 @@ function sendRtcpSr(session, kind, log) {
 		});
 		const encrypted = srtcp.encrypt(sr.serialize());
 		sink.send(encrypted, port, session.hapAddress, (err) => {
-			if (err) log.debug("export-hap: RTCP send error", { meta: {
-				kind,
-				error: err.message
-			} });
+			if (err) {
+				drop(session, "srtp-send-failed");
+				log.warn("export-hap: RTCP send error", { meta: {
+					sessionId: session.sessionId,
+					kind,
+					error: err.message
+				} });
+			}
 		});
-		if (kind === "video") session.videoOutLastRtcpAt = Date.now();
-		else session.audioOutLastRtcpAt = Date.now();
+		if (kind === "video") {
+			session.videoOutLastRtcpAt = Date.now();
+			session.videoRtcpSrSent += 1;
+			if (session.videoRtcpSrSent === 1) log.info("export-hap: first VIDEO RTCP Sender Report sent", { meta: {
+				sessionId: session.sessionId,
+				rtpTimestamp: session.videoOutLastRtpTimestamp,
+				intervalMs: session.videoRtcpIntervalMs
+			} });
+		} else {
+			session.audioOutLastRtcpAt = Date.now();
+			session.audioRtcpSrSent += 1;
+		}
 	} catch (err) {
-		log.debug("export-hap: RTCP SR build/encrypt failed", { meta: {
+		drop(session, "rtcp-encrypt-failed");
+		log.warn("export-hap: RTCP SR build/encrypt failed", { meta: {
+			sessionId: session.sessionId,
 			kind,
 			error: err instanceof Error ? err.message : String(err)
 		} });
@@ -38586,7 +39129,14 @@ function forwardEncryptedRtp(session, rtpPacket, kind, log) {
 	const sink = kind === "video" ? session.videoUdp : session.audioUdp;
 	const port = kind === "video" ? session.hapVideoPort : session.hapAudioPort;
 	const gate = kind === "video" ? session.videoSendGate : session.audioSendGate;
-	if (!srtp || !gate) return;
+	if (!srtp) {
+		drop(session, "no-srtp-session");
+		return;
+	}
+	if (!gate) {
+		drop(session, "no-gate");
+		return;
+	}
 	gate.then(() => {
 		try {
 			const parsed = import_src.RtpPacket.deSerialize(rtpPacket);
@@ -38622,32 +39172,46 @@ function forwardEncryptedRtp(session, rtpPacket, kind, log) {
 			}
 			const encrypted = srtp.encrypt(parsed.payload, parsed.header);
 			sink.send(encrypted, port, session.hapAddress, (err) => {
-				if (err) log.debug("export-hap: SRTP send error", { meta: {
-					kind,
-					error: err.message
-				} });
+				if (err) {
+					drop(session, "srtp-send-failed");
+					log.debug("export-hap: SRTP send error", { meta: {
+						sessionId: session.sessionId,
+						kind,
+						error: err.message
+					} });
+				}
 			});
 			const now = Date.now();
 			if (kind === "video") {
 				if (firstVideo || now > session.videoOutLastRtcpAt + session.videoRtcpIntervalMs) sendRtcpSr(session, "video", log);
 			} else if (firstAudio || now > session.audioOutLastRtcpAt + session.audioRtcpIntervalMs) sendRtcpSr(session, "audio", log);
 		} catch (err) {
+			drop(session, "srtp-encrypt-failed");
 			log.debug("export-hap: SRTP encrypt failed", { meta: {
+				sessionId: session.sessionId,
 				kind,
 				error: err instanceof Error ? err.message : String(err)
 			} });
 		}
 	});
 }
-async function handleStreamRequest(request, sessions, bctx) {
+async function handleStreamRequest(request, sessions, bctx, advertised) {
 	const log = bctx.ctx.logger.withTags({ deviceId: bctx.numericDeviceId });
 	const session = sessions.get(request.sessionID);
 	if (!session) {
-		log.warn("export-hap: stream request for unknown session", { meta: { sessionID: request.sessionID } });
+		log.warn("export-hap: stream request for unknown session", { meta: {
+			sessionID: request.sessionID,
+			type: request.type
+		} });
 		return;
 	}
 	if (request.type === "stop") {
+		session.stopRequestedByController = true;
+		session.teardownTrigger = "controller-stop";
+		const hadFfmpeg = session.ffmpeg !== null;
 		killFfmpeg(session, bctx.ctx, bctx.numericDeviceId);
+		stopHeartbeat(session);
+		if (!hadFfmpeg) logSessionSummary(session, log, "controller-stop-no-ffmpeg");
 		await closeIntercomTalkSession(session, bctx).catch(() => void 0);
 		closeSocket(session.videoUdp);
 		closeSocket(session.audioUdp);
@@ -38673,6 +39237,27 @@ async function handleStreamRequest(request, sessions, bctx) {
 		session.videoOutOctetCount = 0;
 		session.videoOutLastRtpTimestamp = 0;
 		session.videoOutLastRtcpAt = 0;
+		session.negotiated = {
+			width: request.video.width,
+			height: request.video.height,
+			fps: request.video.fps,
+			maxBitrateKbps: request.video.max_bit_rate,
+			mtu: request.video.mtu,
+			videoPt: request.video.pt,
+			videoSsrc: session.videoSsrc,
+			videoRtcpIntervalMs: session.videoRtcpIntervalMs,
+			audioPt: request.audio.pt,
+			audioSsrc: session.audioOutSsrc,
+			audioSampleRateKhz: request.audio.sample_rate,
+			audioPacketTimeMs: packetTimeMs,
+			audioRtcpIntervalMs: session.audioRtcpIntervalMs,
+			audioMaxBitrateKbps: request.audio.max_bit_rate
+		};
+		session.startedAtMs = Date.now();
+		log.info("export-hap: stream negotiated", { meta: {
+			sessionId: request.sessionID,
+			...session.negotiated
+		} });
 		session.lastStartParams = {
 			pt: request.video.pt,
 			mtu: request.video.mtu,
@@ -38693,7 +39278,8 @@ async function handleStreamRequest(request, sessions, bctx) {
 			sample_rate: request.audio.sample_rate,
 			packet_time: packetTimeMs
 		};
-		await startFfmpegForSession(bctx, session, request.sessionID, startParams);
+		await startFfmpegForSession(bctx, session, request.sessionID, startParams, advertised);
+		armHeartbeat(session, log);
 		return;
 	}
 	if (request.type === "reconfigure") {
@@ -38720,23 +39306,69 @@ async function handleStreamRequest(request, sessions, bctx) {
 			sample_rate: session.lastStartParams.audioSampleRateEnum,
 			packet_time: session.lastStartParams.audioPacketTimeMs
 		};
-		await startFfmpegForSession(bctx, session, request.sessionID, startParams);
+		log.info("export-hap: stream reconfigured", { meta: {
+			sessionId: request.sessionID,
+			width: request.video.width,
+			height: request.video.height,
+			fps: request.video.fps,
+			maxBitrateKbps: request.video.max_bit_rate
+		} });
+		await startFfmpegForSession(bctx, session, request.sessionID, startParams, advertised);
+		armHeartbeat(session, log);
 	}
 }
-async function startFfmpegForSession(bctx, session, sessionId, video) {
+async function startFfmpegForSession(bctx, session, sessionId, video, advertised) {
 	const { ctx, proxy, numericDeviceId, options } = bctx;
+	const startLog = ctx.logger.withTags({ deviceId: numericDeviceId });
 	const entries = await proxy.cameraStreams?.getProfileRtspEntries({}) ?? [];
-	if (entries.length === 0) throw new Error(`export-hap: no profile RTSP entries for device ${numericDeviceId}`);
+	if (entries.length === 0) {
+		startLog.warn("export-hap: stream start DROPPED — device publishes no profile RTSP entries", { meta: {
+			sessionId,
+			capBound: proxy.cameraStreams !== void 0
+		} });
+		throw new Error(`export-hap: no profile RTSP entries for device ${numericDeviceId}`);
+	}
 	const pref = options.hapDeviceSettings.streamPreference;
 	const picked = pickPreferredRtspEntry(entries, pref, numericDeviceId, { targetResolution: {
 		width: video.width,
 		height: video.height
 	} });
-	if (!picked) throw new Error(`export-hap: no enabled RTSP entries for device ${numericDeviceId}`);
+	if (!picked) {
+		startLog.warn("export-hap: stream start DROPPED — no ENABLED profile RTSP entry", { meta: {
+			sessionId,
+			streamPreference: pref,
+			targetResolution: `${video.width}x${video.height}`,
+			entries: entries.map((e) => `${e.profile}:${e.enabled ? "enabled" : "disabled"}`)
+		} });
+		throw new Error(`export-hap: no enabled RTSP entries for device ${numericDeviceId}`);
+	}
 	const rtspUrl = picked.url;
 	const slot = (await proxy.cameraStreams?.getBrokerStreams({}) ?? []).find((s) => s.brokerId === picked.brokerId);
 	const codec = (picked.codec ?? slot?.codec ?? "").toLowerCase();
 	const needsTranscode = codec.includes("h265") || codec.includes("hevc");
+	const pickedProfile = toKnownProfile(picked.profileId);
+	const resolvedFps = pickedProfile === null ? void 0 : advertised.fpsByProfile.get(pickedProfile);
+	const advertisedFps = resolvedFps?.fps ?? video.fps;
+	const advertisedFpsSource = resolvedFps?.source ?? "assumed";
+	session.selectedSlot = {
+		profile: pickedProfile,
+		brokerId: picked.brokerId,
+		width: picked.resolution?.width ?? null,
+		height: picked.resolution?.height ?? null,
+		advertisedFps,
+		advertisedFpsSource,
+		codec: codec.length > 0 ? codec : "unknown",
+		transcode: needsTranscode
+	};
+	if (advertisedFps !== video.fps) startLog.warn("export-hap: negotiated fps does NOT match the slot we are about to dial", { meta: {
+		sessionId,
+		negotiatedFps: video.fps,
+		slotFps: advertisedFps,
+		slotFpsSource: advertisedFpsSource,
+		profile: pickedProfile,
+		brokerId: picked.brokerId,
+		transcode: needsTranscode
+	} });
 	const videoLoopPort = session.videoLoopUdp.address().port;
 	const audioLoopPort = session.audioLoopUdp.address().port;
 	const videoTarget = `rtp://127.0.0.1:${videoLoopPort}?pkt_size=${video.mtu}`;
@@ -38836,15 +39468,22 @@ async function startFfmpegForSession(bctx, session, sessionId, video) {
 		} });
 	});
 	proc.once("exit", (code, signal) => {
+		session.ffmpegExit = {
+			code,
+			signal
+		};
 		const ok = code === 0 && signal === null;
 		const meta = {
 			sessionId,
 			code,
-			signal
+			signal,
+			stopRequestedByController: session.stopRequestedByController,
+			videoPacketsForwarded: session.videoPacketsForwarded
 		};
-		if (ok) log.info("export-hap: ffmpeg exited", { meta });
-		else log.warn("export-hap: ffmpeg exited abnormally", { meta });
+		if (ok || session.stopRequestedByController) log.info("export-hap: ffmpeg exited", { meta });
+		else log.warn("export-hap: ffmpeg exited without a controller stop", { meta });
 		if (session.ffmpeg === proc) session.ffmpeg = null;
+		logSessionSummary(session, log, session.teardownTrigger ?? "ffmpeg-exit");
 	});
 	proc.once("error", (err) => {
 		log.warn("export-hap: ffmpeg spawn failed", { meta: {
@@ -38855,12 +39494,27 @@ async function startFfmpegForSession(bctx, session, sessionId, video) {
 	log.info("export-hap: stream started", { meta: {
 		sessionId,
 		transcode: needsTranscode,
-		rtspUrl: picked.brokerId,
+		brokerId: picked.brokerId,
+		profile: pickedProfile,
+		sourceResolution: picked.resolution === void 0 ? null : `${picked.resolution.width}x${picked.resolution.height}`,
+		sourceCodec: codec.length > 0 ? codec : "unknown",
+		negotiated: `${video.width}x${video.height}@${video.fps} ${video.max_bit_rate}kbps`,
+		slotFps: advertisedFps,
+		slotFpsSource: advertisedFpsSource,
 		audioCodec: "opus",
 		audioBitrateKbps: OPUS_BITRATE_KBPS
 	} });
 }
 /**
+* `PickedStream.profileId` is the brokerId suffix; for a profile-keyed entry
+* that IS the profile name. Anything else addresses a raw cam-stream and must
+* not be coerced into a profile.
+*/
+function toKnownProfile(profileId) {
+	if (profileId === "high" || profileId === "mid" || profileId === "low") return profileId;
+	return null;
+}
+/**
 * Handle one incoming SRTP audio packet from iOS Home.
 *
 * End-to-end flow:
@@ -38881,15 +39535,22 @@ async function startFfmpegForSession(bctx, session, sessionId, video) {
 *     stays codec-agnostic.
 */
 async function handleIncomingAudioRtp(session, packet, sourceAddress, bctx) {
-	if (packet.length < 12) return;
+	if (packet.length < 12) {
+		drop(session, "upstream-short-packet");
+		return;
+	}
 	const log = bctx.ctx.logger.withTags({ deviceId: bctx.numericDeviceId });
 	session.upstreamRtpPacketsReceived += 1;
-	if (!session.upstreamAudioSrtp) return;
+	if (!session.upstreamAudioSrtp) {
+		drop(session, "upstream-no-srtp");
+		return;
+	}
 	let decryptedPacket;
 	try {
 		decryptedPacket = session.upstreamAudioSrtp.decrypt(packet);
 		session.upstreamRtpPacketsDecrypted += 1;
 	} catch (err) {
+		drop(session, "upstream-decrypt-failed");
 		session.upstreamRtpDecryptFailures += 1;
 		if (session.upstreamRtpDecryptFailures % 100 === 1) log.debug("export-hap: SRTP decrypt failed (rate-limited)", { meta: {
 			failures: session.upstreamRtpDecryptFailures,
@@ -38906,18 +39567,28 @@ async function handleIncomingAudioRtp(session, packet, sourceAddress, bctx) {
 		rtpTimestamp = parsedRtp.header.timestamp;
 		rtpPayloadType = parsedRtp.header.payloadType;
 	} catch (err) {
+		drop(session, "upstream-parse-failed");
 		log.debug("export-hap: RTP parse failed after decrypt", { meta: { error: errMsg$8(err) } });
 		return;
 	}
 	const negotiatedAudioPt = session.lastStartParams?.audioPt;
-	if (negotiatedAudioPt === void 0) return;
-	if (rtpPayloadType !== negotiatedAudioPt) return;
+	if (negotiatedAudioPt === void 0) {
+		drop(session, "upstream-before-start");
+		return;
+	}
+	if (rtpPayloadType !== negotiatedAudioPt) {
+		drop(session, "upstream-pt-mismatch");
+		return;
+	}
 	if (session.firstUpstreamRtpTimestamp === null) {
 		session.firstUpstreamRtpTimestamp = rtpTimestamp;
 		log.info("export-hap: first upstream RTP packet received");
 	}
 	const payload = decryptedPayload;
-	if (payload.length === 0) return;
+	if (payload.length === 0) {
+		drop(session, "upstream-empty-payload");
+		return;
+	}
 	if (session.intercomTalkSessionId === null) {
 		session.intercomTalkSessionId = "";
 		const opened = await openIntercomTalkSession(bctx).catch((err) => {
@@ -38929,7 +39600,10 @@ async function handleIncomingAudioRtp(session, packet, sourceAddress, bctx) {
 			log.info("export-hap: intercom talk session opened", { meta: { sessionId: opened.sessionId } });
 		}
 	}
-	if (!session.intercomTalkSessionId) return;
+	if (!session.intercomTalkSessionId) {
+		drop(session, "upstream-no-talk-session");
+		return;
+	}
 	const opusSampleRateHz = (session.lastStartParams?.audioSampleRateEnum ?? 16) * 1e3;
 	session.intercomPcmSequence += 1;
 	session.upstreamPcmFramesDecoded += 1;
@@ -38942,6 +39616,7 @@ async function handleIncomingAudioRtp(session, packet, sourceAddress, bctx) {
 			sequenceNumber: session.intercomPcmSequence
 		});
 	} catch (err) {
+		drop(session, "upstream-push-failed");
 		log.debug("export-hap: intercom.pushTalkAudio failed (will re-open on next frame)", { meta: {
 			sequenceNumber: session.intercomPcmSequence,
 			error: errMsg$8(err)
@@ -39025,140 +39700,6 @@ function errMsg$7(err) {
 	return err instanceof Error ? err.message : String(err);
 }
 //#endregion
-//#region src/mappers/builders/hksv.ts
-/**
-* HomeKit Secure Video (HKSV) — stub recording delegate.
-*
-* Wires the camera as HKSV-capable so iOS Home shows the "Activity"
-* tab, the per-camera recording settings UI ("Stream and Allow
-* Recording" / "Off"), and notifications. The delegate stub:
-*  - logs every protocol callback (active toggle, config change,
-*    stream request, close);
-*  - returns from `handleRecordingStreamRequest` immediately without
-*    yielding any fragment — iOS sees "no recording available" but
-*    the camera otherwise behaves like an HKSV camera in the UI.
-*
-* Why a stub: a real implementation needs an fMP4 segmenter that runs
-* a per-camera ffmpeg with a sustained pre-buffer, key/IV-derived
-* encrypter, motion-anchored fragment alignment, and storage for the
-* resulting clips. That work belongs behind the `recording` cap
-* (recording + playback-manifest surface) once it grows fragment export,
-* so the segmenter lives in the recorder addon and HKSV becomes a thin
-* wrapper that asks the cap for "fragments since T" and streams them to iOS.
-*
-* Until that cap lands this stub keeps HKSV characteristics visible
-* (a) so the operator can flip "Allow Recording" without HomeKit
-* complaining the camera lacks the service, and (b) so the
-* `CameraController` advertises a `RecordingManagement` service for
-* iOS-side analytics + Activity-tab UX scaffolding.
-*
-* Constructor returns a `{ options, delegate }` pair the caller
-* passes verbatim into `new CameraController({ ..., recording })`.
-*/
-var RECORDING_OPTIONS = {
-	prebufferLength: 4e3,
-	mediaContainerConfiguration: [{
-		type: MediaContainerType.FRAGMENTED_MP4,
-		fragmentLength: 4e3
-	}],
-	video: {
-		type: VideoCodecType.H264,
-		parameters: {
-			profiles: [
-				H264Profile.BASELINE,
-				H264Profile.MAIN,
-				H264Profile.HIGH
-			],
-			levels: [
-				H264Level.LEVEL3_1,
-				H264Level.LEVEL3_2,
-				H264Level.LEVEL4_0
-			]
-		},
-		resolutions: [
-			[
-				1920,
-				1080,
-				30
-			],
-			[
-				1920,
-				1080,
-				24
-			],
-			[
-				1920,
-				1080,
-				15
-			],
-			[
-				1280,
-				720,
-				30
-			],
-			[
-				1280,
-				720,
-				24
-			],
-			[
-				1280,
-				720,
-				15
-			]
-		]
-	},
-	audio: { codecs: [{
-		type: AudioRecordingCodecType.AAC_LC,
-		bitrateMode: AudioBitrate.VARIABLE,
-		audioChannels: 1,
-		samplerate: [AudioRecordingSamplerate.KHZ_16, AudioRecordingSamplerate.KHZ_24]
-	}] },
-	overrideEventTriggerOptions: [EventTriggerOption.MOTION]
-};
-function buildHksvStub(bctx) {
-	const { ctx, numericDeviceId } = bctx;
-	const log = ctx.logger.withTags({ deviceId: numericDeviceId });
-	let activeStreamId = null;
-	return {
-		options: RECORDING_OPTIONS,
-		delegate: {
-			updateRecordingActive(active) {
-				log.info("export-hap: HKSV recording active changed", { meta: { active } });
-			},
-			updateRecordingConfiguration(configuration) {
-				if (!configuration) {
-					log.info("export-hap: HKSV recording configuration cleared");
-					return;
-				}
-				log.info("export-hap: HKSV recording configuration applied", { meta: {
-					prebufferLength: configuration.prebufferLength,
-					fragmentLength: configuration.mediaContainerConfiguration.fragmentLength,
-					videoResolution: `${configuration.videoCodec.resolution[0]}x${configuration.videoCodec.resolution[1]}@${configuration.videoCodec.resolution[2]}`,
-					videoBitrate: configuration.videoCodec.parameters.bitRate,
-					eventTriggers: configuration.eventTriggerTypes
-				} });
-			},
-			async *handleRecordingStreamRequest(streamId, _signal) {
-				activeStreamId = streamId;
-				log.warn("export-hap: HKSV stream requested — stub returns empty (no clip source yet)", { meta: { streamId } });
-			},
-			acknowledgeStream(streamId) {
-				if (activeStreamId === streamId) activeStreamId = null;
-				log.debug("export-hap: HKSV stream acknowledged", { meta: { streamId } });
-			},
-			closeRecordingStream(streamId, reason) {
-				if (activeStreamId === streamId) activeStreamId = null;
-				log.info("export-hap: HKSV stream closed", { meta: {
-					streamId,
-					reason: reason ?? null
-				} });
-			}
-		},
-		handle: { async dispose() {} }
-	};
-}
-//#endregion
 //#region src/mappers/builders/intercom.ts
 async function buildIntercom(input) {
 	const { bctx, streamingOptions } = input;
@@ -39452,6 +39993,65 @@ function errMsg$4(err) {
 	return err instanceof Error ? err.message : String(err);
 }
 //#endregion
+//#region src/mappers/builders/stream-fps-probe.ts
+async function probeAdvertisedVideoProfile(bctx) {
+	const { ctx, proxy, numericDeviceId, options } = bctx;
+	const log = ctx.logger.withTags({ deviceId: numericDeviceId });
+	const entries = await probe(() => proxy.cameraStreams?.getProfileRtspEntries({}), "cameraStreams.getProfileRtspEntries", log);
+	const slots = await probe(() => proxy.cameraStreams?.getBrokerStreams({}), "cameraStreams.getBrokerStreams", log);
+	const camStreams = await probe(() => proxy.cameraStreams?.getCameraStreams({}), "cameraStreams.getCameraStreams", log);
+	const choices = await probe(() => proxy.webrtcSession?.listStreams({}), "webrtcSession.listStreams", log);
+	const fpsByProfile = resolveProfileFps({
+		choices: choices ?? [],
+		slots: slots ?? [],
+		camStreams: camStreams ?? []
+	});
+	const resolutions = deriveAdvertisedResolutions({
+		candidates: CANDIDATE_RESOLUTIONS,
+		entries: entries ?? [],
+		deviceId: numericDeviceId,
+		pref: options.hapDeviceSettings.streamPreference,
+		fpsByProfile
+	});
+	const assumed = resolutions.filter((r) => r.source === "assumed").length;
+	log.info("export-hap: advertised video profile derived", { meta: {
+		streamPreference: options.hapDeviceSettings.streamPreference,
+		resolutions: formatAdvertisedResolutions(resolutions),
+		profileFps: [...fpsByProfile.values()].map((f) => `${f.profile}=${f.fps}(${f.source})`),
+		assumedCount: assumed,
+		previouslyAdvertisedFps: 30
+	} });
+	if (assumed === resolutions.length) log.warn("export-hap: no measured or published frame rate for ANY profile — advertising the assumed rate", { meta: {
+		entries: entries?.length ?? 0,
+		choices: choices?.length ?? 0
+	} });
+	return {
+		resolutions,
+		fpsByProfile
+	};
+}
+/**
+* Run one cap read. Returns null both when the cap is not bound and when the
+* call throws — and LOGS which, because "the camera has no telemetry" and "the
+* telemetry call failed" lead to different fixes.
+*/
+async function probe(call, label, log) {
+	try {
+		const pending = call();
+		if (pending === void 0) {
+			log.info("export-hap: fps probe skipped — cap not bound on this device", { meta: { call: label } });
+			return null;
+		}
+		return await pending;
+	} catch (err) {
+		log.warn("export-hap: fps probe failed — falling back to a lower-authority source", { meta: {
+			call: label,
+			error: err instanceof Error ? err.message : String(err)
+		} });
+		return null;
+	}
+}
+//#endregion
 //#region src/mappers/builders/child-switch.ts
 /**
 * Child-switch builder — turns a camstack accessory child device (siren,
@@ -39678,24 +40278,18 @@ async function buildCameraAccessory(input) {
 		displayName,
 		options
 	};
-	const streams = buildCameraStreamingDelegate(bctx);
+	const streams = buildCameraStreamingDelegate(bctx, await probeAdvertisedVideoProfile(bctx));
 	const handles = [];
 	if (capNames.has("intercom")) handles.push(await buildIntercom({
 		bctx,
 		streamingOptions: streams.streamingOptions
 	}));
-	const hksv = capNames.has("motion-detection") ? buildHksvStub(bctx) : null;
 	const controller = new (isDoorbell ? DoorbellController : CameraController)({
 		delegate: streams.delegate,
 		streamingOptions: streams.streamingOptions,
-		cameraStreamCount: 2,
-		...hksv ? { recording: {
-			options: hksv.options,
-			delegate: hksv.delegate
-		} } : {}
+		cameraStreamCount: 2
 	});
 	accessory.configureController(controller);
-	if (hksv) handles.push(hksv.handle);
 	if (capNames.has("motion-detection")) handles.push(await buildMotionSensor(bctx));
 	if (isDoorbell && controller instanceof DoorbellController) handles.push(await buildDoorbell({
 		bctx,