@camstack/addon-export-hap 1.2.113 → 1.2.115

package/dist/hap-export.addon.js

@@ -84,7 +84,7 @@ function carryForward(base, existing, keys) {
 	return out;
 }
 //#endregion
-//#region ../types/dist/event-category-ZyX6jcse.mjs
+//#region ../types/dist/event-category-BVDXG4tB.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
 	EventCategory["SystemAddonsReady"] = "system.addons-ready";
@@ -701,6 +701,20 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	* pull-reconcile from the provider's `getStatus` on reconnect. */
 	EventCategory["MeshNetworkChanged"] = "network.mesh.changed";
 	EventCategory["BackupCompleted"] = "backup.completed";
+	/**
+	* A whole backup RUN finished — every destination attempted, win or lose.
+	*
+	* `backup.completed` fires once per DESTINATION, which is the right grain for
+	* a progress UI and the wrong one for a notification: an operator with three
+	* destinations would be told three times. And a run where two of three
+	* destinations succeeded is not a clean success — a single "backup
+	* completed" that hid the failed one would be a lie, so the count of each is
+	* carried here and the message says both.
+	*
+	* Emitted by the backup orchestrator only after the destination loop, so a
+	* run that dies during the BUILD phase produces no completion at all.
+	*/
+	EventCategory["BackupRunCompleted"] = "backup.run-completed";
 	EventCategory["BackupRestored"] = "backup.restored";
 	EventCategory["NotificationDispatched"] = "notification.dispatched";
 	EventCategory["NotificationFailed"] = "notification.failed";
@@ -5431,7 +5445,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-DBKu2-U5.mjs
+//#region ../types/dist/sleep-BDR76Ykr.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -8059,6 +8073,28 @@ var EncodeProfileSchema = object({
 	outputArgs: array(string()).optional()
 });
 /**
+* THE target rule: which of two sizes serves a consumer better.
+*
+* "Prefer at or above the target so the consumer downscales instead of
+* upscaling; among those the SMALLEST, because the extra pixels are thrown
+* away and the decode is not; among the rest the LARGEST, because it is the
+* closest we can get." One sentence, and until now it was written twice — once
+* here in lines, once in `stream-selection.ts` in pixels, for the same two
+* exporters. The two agreed, which is luck, not a property.
+*
+* The `size` is whatever measure the caller ranks by: the cap ranks by LINES
+* (a consumer's requirement is stated in p), the RTSP picker by PIXELS (it
+* compares entries of possibly different aspect). The rule is the same either
+* way and the measure is the caller's business.
+*
+* Returns a sort delta: negative when `a` should come first.
+*/
+function compareToTarget(a, b, target) {
+	const aReaches = a >= target;
+	if (aReaches !== b >= target) return aReaches ? -1 : 1;
+	return aReaches ? a - b : b - a;
+}
+/**
 * The shape every live egress starts from: H.264 Baseline 3.1 at 720p25.
 * Baseline because it is the one profile every consumer in this repo decodes
 * (Echo, iOS, an old browser); 3.1 because that is what the SDPs advertise.
@@ -9971,6 +10007,47 @@ var LogChannelWindowSchema = object({
 	/** `null` = every camera. A non-empty list narrows to those numeric ids. */
 	deviceIds: array(number().int()).readonly().nullable()
 });
+/**
+* Shared stream-selection picker for export addons.
+*
+* Both `addon-export-alexa` and `addon-export-hap` resolve the
+* operator's `streamPreference` setting against the broker's RTSP
+* entries before dialling a camera. Each addon used to roll its own:
+* Alexa had `pickPreferredRtspEntry` under `handlers/`, HAP had an
+* inline `"prefer /mid, then /high, then first"` chain inside its
+* camera-streams mapper. The chains drifted (Alexa honoured
+* `streamPreference`, HAP didn't; only Alexa got the smart
+* resolution-targeted auto-pick) and the cross-addon import rule
+* blocks deduping in either direction.
+*
+* Lifting the picker into `@camstack/types` lets every exporter call
+* the same code path with the consumer's target resolution baked into
+* the call site — Alexa passes 1280×720, HomeKit passes 1920×1080,
+* the picker handles the rest.
+*
+* Selection algorithm:
+*   - pref === '<profile>' → profile-keyed entries (from
+*                         `getProfileRtspEntries`) match on `e.profile`;
+*                         legacy raw entries match on the brokerId
+*                         suffix (`brokerId` ENDS WITH `/${pref}`, shape
+*                         `${deviceId}/${camStreamId}`). Addons store the
+*                         bare profile/camStream id in their
+*                         `ExportDeviceSettings.streamPreference`. Falls
+*                         back to 'auto' when no enabled entry matches
+*                         either way.
+*   - pref === 'auto'   → when `targetResolution` is given, pick the
+*                         entry whose source resolution is closest to
+*                         it (prefer ≥ target so the consumer
+*                         downscales instead of upscaling). Without a
+*                         target, fall back to first-enabled. If no
+*                         entry advertises a resolution at all
+*                         (broker hasn't probed yet), also fall back
+*                         to first-enabled so cold start still serves.
+*
+* Returns `null` when nothing is publishable — callers fold that into
+* the consumer's "no stream" error (Alexa: STREAM_TYPE_UNSUPPORTED;
+* HAP: a thrown error inside `startFfmpegForSession`).
+*/
 function pickPreferredRtspEntry(entries, pref, deviceId, options = {}) {
 	if (entries.length === 0) return null;
 	const prefix = `${deviceId}/`;
@@ -10000,30 +10077,23 @@ function pickPreferredRtspEntry(entries, pref, deviceId, options = {}) {
 	return toPicked(eligible[0]);
 }
 /**
-* Pick the entry whose `resolution` is closest to `target`. Prefer
-* entries ≥ target (downscale is cheap at the consumer; upscale is
-* lossy). Among the rest pick the LARGEST still ≤ target so the
-* consumer gets the best feasible quality. "Closeness" is the
-* `width × height` pixel delta.
+* Pick the entry whose `resolution` is closest to `target`, by the ONE target
+* rule ({@link compareToTarget}): prefer at or above the target so the consumer
+* downscales instead of upscaling; among those the smallest; among the rest the
+* largest.
+*
+* This function used to implement that rule itself, in pixels, while
+* `rankStreams` implemented it again in lines — the same sentence written twice
+* for the same two exporters, agreeing by luck rather than by construction.
+* Only the MEASURE is this picker's own: it compares whole pixel counts because
+* its entries can differ in aspect, where the cap's requirement is stated in p.
 */
 function pickClosestResolution(entries, target) {
 	const targetPixels = target.width * target.height;
-	let bestAbove;
-	let bestBelow;
-	for (const e of entries) {
-		if (e.resolution === void 0) continue;
-		const pixels = e.resolution.width * e.resolution.height;
-		if (pixels >= targetPixels) {
-			if (!bestAbove || pixels < bestAbove.pixels) bestAbove = {
-				entry: e,
-				pixels
-			};
-		} else if (!bestBelow || pixels > bestBelow.pixels) bestBelow = {
-			entry: e,
-			pixels
-		};
-	}
-	return bestAbove?.entry ?? bestBelow?.entry;
+	return [...entries.flatMap((entry) => entry.resolution === void 0 ? [] : [{
+		entry,
+		pixels: entry.resolution.width * entry.resolution.height
+	}])].sort((a, b) => compareToTarget(a.pixels, b.pixels, targetPixels))[0]?.entry;
 }
 var MODEL_FORMATS = [
 	"onnx",
@@ -12211,6 +12281,58 @@ method(ListInputSchema, array(BrokerInfoSchema$1)), method(GetInputSchema, Broke
 	auth: "admin"
 }), method(GetStateInputSchema, unknown().nullable()), method(_void(), RegistryStatusSchema);
 DeviceType.Camera;
+/**
+* The signals a device can emit to WAKE its own stream.
+*
+* A camera whose stream is built on demand sleeps until something asks for it,
+* and "something" cannot be a consumer that is merely attached — a Frigate-style
+* puller holds a session open for ever, and treating that as demand would keep
+* a battery camera awake for ever, which is the whole thing the battery is for
+* (D173). So the wake has to come from the CAMERA: an event it noticed by
+* itself, with no stream running.
+*
+* ## The vocabulary is the PROVIDER'S, not ours
+*
+* Like `consumables`, this cap declares no vocabulary of its own. A provider
+* names each signal with a `code` it chooses and a `label` an operator reads.
+* Reolink offers motion and camera-native detection; another provider may offer
+* a tamper, a doorbell press, a PIR, or something no camera in this fleet has
+* yet. A fixed enum here would mean every new signal is a framework release.
+*
+* It is deliberately NOT derived from the caps a device already binds. Whether
+* a camera CAN push firmware motion is expressed by `motionSources` containing
+* `'onboard'`, and whether it does AI on-camera by the `native-object-detection`
+* binding — but both answer "what drives the detection pipeline", which is a
+* different question from "what may wake a sleeping stream". A camera can do
+* the first and not be trusted with the second, and the operator picks per
+* camera. Two questions, two authorities.
+*
+* ## Availability is not permission
+*
+* `listSignals` says what the device CAN emit. Whether a given signal actually
+* wakes the stream is the operator's per-camera choice, held by the broker
+* alongside the cooldown — see the stream-broker cap's wake settings. A
+* provider declaring a signal is not a provider enabling it.
+*/
+/** One signal a device can emit. */
+var StreamSignalSchema = object({
+	/** Stable id chosen by the provider, e.g. `'motion'`, `'person'`, `'tamper'`. */
+	code: string().min(1),
+	/** What an operator reads in the picker. The provider's own wording. */
+	label: string().min(1),
+	/**
+	* Whether the provider recommends this signal ON when a camera is first set
+	* up. A provider knows which of its signals are cheap and reliable; an
+	* operator should not have to discover that by trial. Reolink recommends
+	* both of its own.
+	*/
+	recommended: boolean()
+});
+object({
+	signals: array(StreamSignalSchema),
+	lastFetchedAt: number()
+});
+Object.values(DeviceType), method(_void(), array(StreamSignalSchema).readonly());
 /** Stream delivery format. (Relocated from the retired `streaming-engine` cap.) */
 var StreamFormatSchema = _enum([
 	"webrtc",
@@ -12607,6 +12729,22 @@ var EgressTranscodeSchema = object({
 	camStreamId: string().nullable()
 });
 method(object({
+	deviceId: number().int().nonnegative(),
+	/** The provider's signal code. */
+	code: string().min(1),
+	/** Ms epoch. Absent ⇒ now. */
+	at: number().optional()
+}), object({
+	/** Whether the broker acted on it, and if not, why. */
+	accepted: boolean(),
+	reason: _enum([
+		"woke",
+		"hold-extended",
+		"not-enabled",
+		"no-consumer",
+		"unknown-code"
+	])
+}), { kind: "mutation" }), method(object({
 	deviceId: number().int().nonnegative(),
 	camStreamId: string().min(1),
 	kind: CamStreamKindSchema,
@@ -12861,6 +12999,16 @@ var PickStreamRequirementsSchema = object({
 	acceptCodecs: array(StreamCodecSchema).readonly().optional(),
 	/** Minimum vertical resolution. Streams shorter than this are dropped. */
 	minHeight: number().int().positive().optional(),
+	/**
+	* Maximum vertical resolution. Streams TALLER than this are dropped.
+	*
+	* A consumer can have a ceiling as real as its floor: Alexa documents
+	* 480p to 1080p, and a 4K stream is as unusable to an Echo as a 360p one.
+	* Without this the ceiling had to be re-implemented by every caller — and
+	* one caller implementing it privately is how a second scoring authority
+	* gets born.
+	*/
+	maxHeight: number().int().positive().optional(),
 	/** Minimum horizontal resolution. */
 	minWidth: number().int().positive().optional(),
 	/**
@@ -12877,7 +13025,22 @@ var PickStreamRequirementsSchema = object({
 	* transcoded" guard: if the device is already serving the consumer's
 	* codec end-to-end, there's nothing to optimise.
 	*/
-	requireSiblingCodec: array(StreamCodecSchema).readonly().optional()
+	requireSiblingCodec: array(StreamCodecSchema).readonly().optional(),
+	/**
+	* Whether a stream the consumer CANNOT decode may still be picked, on the
+	* understanding that it will be transcoded.
+	*
+	* Default `false` — today's behaviour, and the right one for a bypass
+	* question ("is there a stream I can forward untouched?"). Set `true` to
+	* ask the larger question: "what is the best stream for me, transcoding if
+	* I must?" A stream that satisfies `acceptCodecs` always outranks one that
+	* does not, so a passthrough is never lost to a transcode; the answer says
+	* which it is in {@link PickedCamStreamSchema.transcodes}.
+	*
+	* This is what lets one picker serve both the bypass and the full source
+	* choice, instead of a consumer scoring privately when the bypass misses.
+	*/
+	allowTranscode: boolean().optional()
 }).readonly();
 var PickStreamPreferencesSchema = object({
 	/**
@@ -12891,12 +13054,32 @@ var PickStreamPreferencesSchema = object({
 	* picks the tallest stream; `'lowest'` picks the shortest (used by
 	* memory-constrained consumers / Apple Home guest sessions).
 	*/
-	resolutionPreference: _enum(["highest", "lowest"]).optional()
+	resolutionPreference: _enum(["highest", "lowest"]).optional(),
+	/**
+	* The height the consumer actually wants to DELIVER.
+	*
+	* Not a constraint — an ordering. With it set, the SMALLEST stream at or
+	* above the target wins, and only if nothing reaches it does the tallest
+	* take over. Pulling 1296 lines to draw 720 on a 1280x800 Echo panel costs
+	* a decode and buys nothing, and `resolutionPreference: 'highest'` cannot
+	* express that: it says "as big as possible", which is a different wish.
+	*
+	* Ignored when absent, so every existing caller keeps its ordering.
+	*/
+	targetHeight: number().int().positive().optional()
 }).readonly();
 var PickedCamStreamSchema = object({
 	camStreamId: string(),
 	codec: string().optional(),
 	resolution: CamStreamResolutionSchema.optional(),
+	/**
+	* Whether serving this stream requires a decode + re-encode.
+	*
+	* `false` is a stream the consumer can take as it stands. Only ever `true`
+	* when the caller asked for it with `allowTranscode`, so a caller that did
+	* not ask cannot be handed a cost it never agreed to pay.
+	*/
+	transcodes: boolean(),
 	/** One-line explanation of why this stream won — for logs / debug UI. */
 	reason: string()
 });
@@ -17166,6 +17349,8 @@ var NcSystemEventKindSchema = _enum([
 	"device-enabled",
 	"device-battery-low",
 	"device-battery-normal",
+	"device-consumable-low",
+	"device-consumable-normal",
 	"stream-online",
 	"stream-offline",
 	"node-online",
@@ -17184,6 +17369,7 @@ var NcSystemEventKindSchema = _enum([
 	"addon-updated",
 	"server-updated",
 	"export-completed",
+	"backup-completed",
 	"camera-online",
 	"camera-offline",
 	"camera-disabled",
@@ -18506,6 +18692,48 @@ var NcAlarmConfigSchema = object({
 	settings: NcAlarmSettingsSchema,
 	coverage: array(NcAlarmModeCoverageSchema)
 });
+/**
+* ONE rule's demand on ONE camera's clip ring.
+*
+* A rule, not a camera: the broker takes the MAX over the asks that reach a
+* camera, so the answer stays a faithful description of the rules and the
+* bounding (the byte budget, the broker's own ceiling) stays where the cost
+* lives. A camera that appears in no ask is being told **nothing** — which is
+* a different thing from never having been told, and only the envelope
+* (`rulesLoaded`) can tell those apart.
+*/
+var NcClipRetentionAskSchema = object({
+	/**
+	* The camera this ask is about. **Absent = every camera**, which is what a
+	* rule with no `conditions.devices` means: it can fire anywhere, so it is
+	* asking everywhere.
+	*/
+	deviceId: number().int().nonnegative().optional(),
+	/** Seconds of history the rule needs held for it. Never zero — a rule that
+	*  needs nothing produces no ask at all. */
+	seconds: number().min(0).max(60),
+	/** The profile the rule cuts from, when it named one. Absent = the cheapest
+	*  assigned, which is what the cut defaults to. */
+	profile: CamProfileSchema.optional(),
+	/** Who is asking — so a retention the operator did not expect names a rule. */
+	ruleId: string(),
+	ruleName: string(),
+	/** Why this many seconds: the rule's own window, or the occupancy ceiling. */
+	reason: _enum(["window", "occupancy"])
+});
+/**
+* The whole answer, with the one bit that keeps absence from reading as zero.
+*
+* `rulesLoaded` is false until the rule ledger has completed a load at least
+* once. A centre that is up but has not read its rules yet answers with an
+* empty ask list that means nothing at all — applying it would drop every
+* camera's ring to zero for the first events after a restart, which is the
+* footage this mechanism exists to keep.
+*/
+var NcClipRetentionPlanSchema = object({
+	rulesLoaded: boolean(),
+	asks: array(NcClipRetentionAskSchema).readonly()
+});
 method(object({}), object({ rules: array(NcRuleSchema) }), { auth: "admin" }), method(object({ ruleId: string() }), object({ rule: NcRuleSchema.nullable() }), { auth: "admin" }), method(object({ rule: NcRuleInputSchema }), object({ rule: NcRuleSchema }), {
 	kind: "mutation",
 	auth: "admin",
@@ -18526,7 +18754,7 @@ method(object({}), object({ rules: array(NcRuleSchema) }), { auth: "admin" }), m
 }), object({ success: literal(true) }), {
 	kind: "mutation",
 	auth: "admin"
-}), method(object({}), object({ mutedDeviceIds: array(number().int()).readonly() }), { auth: "admin" }), method(object({
+}), method(object({}), NcClipRetentionPlanSchema, { auth: "admin" }), method(object({}), object({ mutedDeviceIds: array(number().int()).readonly() }), { auth: "admin" }), method(object({
 	deviceId: number().int(),
 	muted: boolean()
 }), object({ success: literal(true) }), {
@@ -21060,6 +21288,33 @@ var RunReplayFrameProcessorResultSchema = object({ tracks: array(object({
 	*  solid is this track", cheaper than re-deriving it from a trajectory. */
 	framesMatched: number().int()
 })).readonly() });
+/**
+* The long-term series a camera produces. A closed union so a typo cannot
+* invent one, and the ONE declaration of it — the addon's `AnalyticsLtsSeries`
+* is an alias of this, not a second list.
+*/
+var AnalyticsLtsSeriesSchema = _enum([
+	"motion",
+	"audio-dbfs",
+	"battery",
+	"occupancy"
+]);
+/**
+* One closed 5-minute bucket of a long-term series.
+*
+* `samples` is how many readings the bucket folded — it is the ACTIVITY for a
+* series like `motion`, and the confidence for one like `occupancy`. A bucket
+* that exists at all was measured; a bucket that is absent was not, which is a
+* different claim from zero and the reason this is a sparse series.
+*/
+var LtsBucketSchema = object({
+	scope: string(),
+	bucketStart: number().int(),
+	samples: number().int().nonnegative(),
+	sum: number(),
+	min: number(),
+	max: number()
+});
 DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).readonly()), method(object({
 	deviceId: number(),
 	trackId: string()
@@ -21106,6 +21361,14 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
 	kinds: array(string()).optional(),
 	limit: number().int().min(1).max(MAX_EVENT_QUERY_LIMIT).default(DEFAULT_EVENT_QUERY_LIMIT)
 }), array(SensorEventSchema).readonly()), method(KeyEventQueryInput, array(KeyEventSchema).readonly()), method(KeyEventBatchQueryInput, array(KeyEventsForDeviceSchema).readonly()), method(object({
+	deviceId: number(),
+	series: AnalyticsLtsSeriesSchema,
+	/** Omit for EVERY scope of this series in the range. */
+	scope: string().optional(),
+	from: number(),
+	to: number(),
+	limit: number().int().positive().optional()
+}), array(LtsBucketSchema).readonly()), method(object({
 	deviceId: number(),
 	since: number(),
 	until: number(),
@@ -21724,6 +21987,14 @@ var MotionSourceEnum = _enum([
 */
 var MotionSourcesSchema = array(MotionSourceEnum);
 /**
+* Which root detectors a camera runs. Deliberately the SAME vocabulary
+* post-analysis already tags every detection with (`DetectionSource`) rather
+* than a second spelling of the same two ideas — the value an operator picks
+* here is the value that comes back on the track, the overlay and the debug
+* row.
+*/
+var DetectionSourcesSchema = array(DetectionSourceSchema);
+/**
 * Input shape for `pipeline-runner.reportMotion` cap method. Exported
 * so cap-side consumers (the orchestrator forward, the runner addon's
 * cap implementation, tests) can reuse the type instead of redeclaring
@@ -21874,6 +22145,35 @@ var RunnerCameraConfigSchema = object({
 	*   events; the orchestrator forwards to `reportMotion`.
 	*/
 	motionSources: MotionSourcesSchema.default(["analyzer"]),
+	/**
+	* WHICH root detector runs for this camera. The detection counterpart of
+	* {@link motionSources}, same shape and same discipline: a per-camera list
+	* of sources the system understands, vendor-agnostic, owned here.
+	*
+	* - `pipeline` — this runner's own root step on decoded pixels (`steps`).
+	* - `onboard` — the CAMERA's own detector, admitted only when it is named
+	*   here. Its boxes reach post-analysis on the same
+	*   `PipelineInferenceResult` payload as the pipeline's, so an onboard-born
+	*   track gets the same tracker, the same overlay and the same detail
+	*   subtree (face / plate / embedding).
+	*
+	* `['onboard']` alone is the REPLACEMENT: this runner's root step does not
+	* run, and that is where a camera with a usable onboard detector buys back
+	* its share of the accelerator. It saves the root inference, not the decode
+	* — the detail subtree still needs pixels to cut crops from.
+	*
+	* A camera whose onboard detections carry no geometry cannot serve as a root
+	* step at all (there is nothing to track), and the cap that knows this says
+	* so on `native-object-detection.getOptions().geometry`. On Reolink that is
+	* every battery camera: the boxes ride a sub-stream a battery camera never
+	* attaches, so such a camera stays on `['pipeline']` and its onboard AI is
+	* worth exactly what it already is — a wake signal with a class.
+	*
+	* Defaults to `['pipeline']`, which is byte-for-byte today's behaviour: a
+	* vendor never turns a detector on for the operator, and neither does a
+	* default.
+	*/
+	detectionSources: DetectionSourcesSchema.default(["pipeline"]),
 	pipelineEnabled: boolean().default(true),
 	/** Ordered tree of video steps. Absent → runner skips video detection. */
 	steps: array(PipelineStepInputSchema).readonly().optional(),
@@ -22055,7 +22355,47 @@ var RunnerLocalMetricsSchema = object({
 	queueDepth: number(),
 	frameLazy: FrameLazyMetricsSchema.optional()
 });
+/**
+* Pipeline Runner capability — runtime detection workhorse.
+*
+* One instance per node. Receives camera assignments from
+* `addon-pipeline-orchestrator`, subscribes to the local stream-broker for
+* decoded frames, drains motion + detection queues, calls the local
+* `motion-detection` and `pipeline-executor` capabilities, and emits typed
+* `pipeline.inference-result` and `detection.motion-analysis` events on
+* the bus.
+*
+* Distinct from `pipeline-orchestrator` (the hub-side load balancer) — the
+* runner has zero knowledge of other agents, no global state, and never
+* makes assignment decisions itself.
+*/
+/**
+* Why a runner declined to look at a camera out of band. Named rather than a
+* bare `false`: a camera asleep on battery (D173), one attached elsewhere, one
+* already mid-session and one already bursting are four different facts, and a
+* caller told only "no" cannot tell a protection from a bug.
+*/
+var OccupancyBurstRefusalSchema = _enum([
+	"not-attached",
+	"battery-asleep",
+	"not-watching",
+	"already-bursting"
+]);
 method(RunnerCameraConfigSchema, object({ success: literal(true) }), { kind: "mutation" }), method(object({ deviceId: number() }), object({ success: literal(true) }), { kind: "mutation" }), method(ReportMotionInputSchema, object({ success: literal(true) }), { kind: "mutation" }), method(_void(), RunnerLocalLoadSchema), method(_void(), RunnerLocalMetricsSchema), method(object({ deviceId: number() }), CameraMetricsSchema.nullable()), method(_void(), array(CameraMetricsWithDeviceIdSchema).readonly()), method(_void(), array(number()).readonly()), method(object({
+	deviceId: number(),
+	/** How many frames to collect. The caller sizes this against what its
+	*  own confirmation needs; the runner clamps it to the field's range. */
+	frames: number().int().positive().optional(),
+	/** Why, for the log. A burst nobody can attribute is a cost nobody can
+	*  defend — the periodic one at least has a timer to point at. */
+	reason: string()
+}), object({
+	started: boolean(),
+	refusedBecause: OccupancyBurstRefusalSchema.optional()
+}), {
+	auth: "admin",
+	kind: "mutation"
+}), method(object({
 	handle: FrameHandleSchema,
 	bbox: NativeCropBboxSchema,
 	maxWidth: number().int().positive().optional(),
@@ -24425,10 +24765,28 @@ DeviceType.Camera, method(object({ deviceId: number().int().nonnegative() }), ar
 }), boolean()), method(object({
 	deviceId: number().int().nonnegative(),
 	sessionId: string()
-}), object({ pendingRenegotiation: object({
-	target: WebrtcStreamTargetSchema,
-	epoch: number()
-}).nullable() }));
+}), object({
+	pendingRenegotiation: object({
+		target: WebrtcStreamTargetSchema,
+		epoch: number()
+	}).nullable(),
+	/**
+	* Whether the session still EXISTS.
+	*
+	* A consumer that holds a resource for the life of a session needs to
+	* be able to ask, because a session does not always end the way it
+	* began. Measured on this hub 2026-09-13: an Echo that got stuck never
+	* sent `SessionDisconnected`, so the Alexa exporter's
+	* `releaseEgressTranscode` never ran, and a 2304x1296 HEVC to 720p
+	* H.264 transcode kept running for NOBODY for more than twenty
+	* minutes. The WebRTC session had logged `WebRTC session closed`
+	* minutes earlier — the broker knew; the holder had no way to ask.
+	*
+	* `false` for a session id the provider has never heard of, which is
+	* the same answer as "it ended": either way nothing is holding it up.
+	*/
+	alive: boolean()
+}));
 object({
 	/** All accessory children of the parent. */
 	childDeviceIds: array(number()).readonly(),
@@ -27542,7 +27900,7 @@ var NativeDetectionSchema = object({
 	/** Firmware-provided confidence [0..1]. Reolink pushes don't carry it → undefined. */
 	confidence: number().min(0).max(1).optional()
 });
-object({
+var NativeObjectDetectionStatusSchema = object({
 	/**
 	* Last observed instance per class. Missing entries mean the class
 	* is supported but nothing has been seen since the provider started.
@@ -27559,14 +27917,56 @@ object({
 	supportedClasses: array(NativeObjectClassEnum).readonly(),
 	/**
 	* Whether forwarding of onboard AI detections is enabled for this device.
-	* Default FALSE (opt-in, cold-start) — onboard AI pushes are noisy/sparse and
-	* churn the tracker, so forwarding stays off until the operator enables it.
+	*
+	* Cold-start OFF on every camera. A vendor does not decide which detector a
+	* camera runs — that is the operator's choice, and it is made where every
+	* other detection choice is made. `geometry` on
+	* {@link NativeObjectDetectionOptionsSchema} is how the form says what the
+	* choice would buy this particular camera.
 	*/
 	enabled: boolean()
-}).extend({ 
+});
+/**
+* WHEN a camera's onboard detections carry geometry.
+*
+* - `boxed` — always. The provider holds a standing channel for the boxes, so
+*   a detection is a trackable subject whenever the camera sees one.
+* - `while-streaming` — only while some stream of this camera is already open.
+*   The boxes ride the video's own side-channel rather than a feed of their
+*   own, so they cost nothing and they exist only when something is pulling.
+*   On Reolink this is every BATTERY camera: a persistent second feed is real
+*   radio drain, but a camera that is awake is awake precisely because
+*   something is in front of it, and its stream is already being pulled.
+* - `flag-only` — never. The firmware ships the class and nothing else; the
+*   pipeline needs geometry to make a subject, so such a push reaches the
+*   tracker as motion and no further.
+*
+* Reported and not inferred, because the operator's question in front of the
+* picker is "what do I get", and these are three different answers (D14: the
+* derived form is only as honest as `getOptions`).
+*/
+var NativeObjectGeometryEnum = _enum([
+	"boxed",
+	"while-streaming",
+	"flag-only"
+]);
+var NativeObjectDetectionOptionsSchema = object({
+	/** Classes this firmware can detect — the same list the status reports. */
+	supportedClasses: array(NativeObjectClassEnum).readonly(),
+	/** What a detection from this camera carries. */
+	geometry: NativeObjectGeometryEnum
+});
+var NativeObjectDetectionSettingsPatchSchema = object({ enabled: boolean().optional() });
+NativeObjectDetectionStatusSchema.extend({ 
 /** Required by createRuntimeStateBridge — epoch ms of last refresh. */
 lastFetchedAt: number() });
-DeviceType.Camera, method(object({
+DeviceType.Camera, method(object({ deviceId: number() }), NativeObjectDetectionOptionsSchema), method(object({
+	deviceId: number(),
+	settings: NativeObjectDetectionSettingsPatchSchema
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
 	deviceId: number(),
 	enabled: boolean()
 }), _void(), {
@@ -31390,7 +31790,28 @@ var PerScopeBreakdownSchema = object({
 	/** Total tracked objects in this scope (frame / zone / unzoned). */
 	totalObjects: number().int().nonnegative(),
 	/** Per-class count. Keys are macro class names (e.g. `person`, `car`). */
-	byClass: record(string(), number().int().nonnegative())
+	byClass: record(string(), number().int().nonnegative()),
+	/**
+	* Of `totalObjects`, how many are STANDING — objects the census holds,
+	* present but not going anywhere (a parked car, a bin, a statue).
+	*
+	* The operator's question about a scene has two halves and they answer
+	* different things: "what is parked here" is stable for hours and must not
+	* flap, while "who is walking through" is the thing an alert is about. One
+	* number could only serve one of them, and `totalObjects` served the first
+	* badly — a passer-by moved it and every occupancy rule saw a change.
+	*
+	* `standing + transient === totalObjects`, always. The total keeps its old
+	* meaning exactly, so no rule written against it changes behaviour.
+	*
+	* ABSENT means UNKNOWN, never zero (D393): a snapshot from a node older than
+	* this field cannot say, and a reader that folds absence in as 0 reports "no
+	* parked objects here" about a camera whose lot is full.
+	*/
+	standingObjects: number().int().nonnegative().optional(),
+	/** Of `totalObjects`, how many are passing through. See `standingObjects` —
+	*  same absence rule. */
+	transientObjects: number().int().nonnegative().optional()
 });
 var ZoneScopeBreakdownSchema = PerScopeBreakdownSchema.extend({
 	zoneId: string(),
@@ -34329,12 +34750,24 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"nativeObjectDetection.getOptions": {
+		capName: "native-object-detection",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"nativeObjectDetection.setEnabled": {
 		capName: "native-object-detection",
 		capScope: "device",
 		addonId: null,
 		access: "create"
 	},
+	"nativeObjectDetection.setSettings": {
+		capName: "native-object-detection",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"navigation.getFeatures": {
 		capName: "navigation",
 		capScope: "device",
@@ -34599,6 +35032,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"notificationRules.getClipRetentionAsks": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"notificationRules.getConditionCatalog": {
 		capName: "notification-rules",
 		capScope: "system",
@@ -35109,6 +35548,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineAnalytics.readLongTermSeries": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.rebuildObjectEmbeddings": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -35781,6 +36226,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineRunner.requestOccupancyBurst": {
+		capName: "pipeline-runner",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineRunner.runDetailSubtree": {
 		capName: "pipeline-runner",
 		capScope: "system",
@@ -36993,6 +37444,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"streamBroker.reportStreamSignal": {
+		capName: "stream-broker",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"streamBroker.restartProfile": {
 		capName: "stream-broker",
 		capScope: "system",
@@ -37077,6 +37534,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"streamSignals.listSignals": {
+		capName: "stream-signals",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"switch.setState": {
 		capName: "switch",
 		capScope: "device",
@@ -38549,11 +39012,21 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"nativeObjectDetection.getOptions": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"nativeObjectDetection.setEnabled": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
+	"nativeObjectDetection.setSettings": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"navigation.getFeatures": [{
 		name: "deviceId",
 		form: "single",
@@ -38903,6 +39376,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"pipelineAnalytics.readLongTermSeries": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"pipelineAnalytics.rebuildObjectEmbeddings": [{
 		name: "deviceId",
 		form: "single",
@@ -39093,6 +39571,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"pipelineRunner.requestOccupancyBurst": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"pipelineRunner.runDetailSubtree": [{
 		name: "deviceId",
 		form: "single",
@@ -39449,6 +39932,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"streamBroker.reportStreamSignal": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"streamBroker.restartProfile": [{
 		name: "deviceId",
 		form: "single",
@@ -87070,6 +87558,123 @@ function clearPairingFiles(accessoryUuid, logger) {
 		} });
 	}
 }
+/**
+* Whether this device's accessory belongs on the bridge.
+*
+* A camera is `false` whatever the operator picked — the answer is HomeKit's,
+* not ours, and an operator who switched it on before the field was gated must
+* not end up with a camera nobody can pair.
+*
+* Absent means ON for everything else: the field did not exist for entries
+* persisted before it, and the default the operator asked for is the bridge.
+*/
+function shouldBridge(input) {
+	if (input.mapperKind === "camera") return false;
+	return input.useBridge !== false;
+}
+/** Whether the bridge has room for one more. */
+function bridgeHasRoom(current) {
+	return current < 149;
+}
+//#endregion
+//#region src/bridge-host.ts
+/**
+* THE bridge accessory — one per node, created on demand, holding every
+* non-camera accessory the operator routed onto it.
+*
+* One mDNS advertisement, one HAP connection, one pairing, N accessories
+* inside. The alternative — what this addon did until now — gives every
+* switch, sensor and alarm panel its own port, its own advertisement and its
+* own "Add Accessory" in the Home app. Cameras stay standalone, because
+* HomeKit forbids bridging them (`bridge-policy.ts`).
+*
+* ONE bridge, deliberately. The ceiling is 149 accessories
+* ({@link MAX_BRIDGED_ACCESSORIES}) and this hub exposes 46 devices in total,
+* cameras included; a second bridge is a thing to build when the count
+* approaches the ceiling, not before, and the refusal at the ceiling is
+* explicit rather than a library throw.
+*
+* The bridge is LAZY: it is published the first time an accessory needs it,
+* so a fleet of nothing but cameras advertises no empty bridge. It is not
+* unpublished when the last accessory leaves — an unpublish would drop the
+* pairing record the operator already entered a code for, and an empty bridge
+* in the Home app is a far smaller cost than a re-pair.
+*/
+var BridgeHost = class {
+	opts;
+	bridge = null;
+	published = false;
+	constructor(opts) {
+		this.opts = opts;
+	}
+	/** The live bridge accessory, or `null` before anything needed one. */
+	get accessory() {
+		return this.bridge;
+	}
+	/** How many accessories are riding it right now. */
+	get size() {
+		return this.bridge?.bridgedAccessories.length ?? 0;
+	}
+	/**
+	* Put an accessory on the bridge, publishing the bridge if this is the
+	* first. Returns `false` — without throwing, and having logged — when the
+	* bridge is full: the caller then falls back to standalone, which is worse
+	* for the operator and still works.
+	*/
+	async add(accessory) {
+		const bridge = this.ensure();
+		if (!bridgeHasRoom(bridge.bridgedAccessories.length)) {
+			this.opts.logger.warn("export-hap: the bridge is FULL — publishing standalone instead", { meta: {
+				uuid: accessory.UUID,
+				bridged: bridge.bridgedAccessories.length,
+				max: 149
+			} });
+			return false;
+		}
+		bridge.addBridgedAccessory(accessory);
+		await this.publishOnce();
+		return true;
+	}
+	/** Take an accessory off the bridge. A bridged accessory is never
+	*  `unpublish`ed — it has no server of its own. */
+	remove(accessory) {
+		if (this.bridge === null) return;
+		if (!this.bridge.bridgedAccessories.some((a) => a.UUID === accessory.UUID)) return;
+		this.bridge.removeBridgedAccessory(accessory, false);
+	}
+	/** Whether this accessory is currently on the bridge. */
+	holds(accessory) {
+		return this.bridge?.bridgedAccessories.some((a) => a.UUID === accessory.UUID) ?? false;
+	}
+	/** Tear the bridge down — process shutdown only. */
+	async dispose() {
+		if (this.bridge === null || !this.published) return;
+		await unpublishAccessory(this.bridge, this.opts.logger);
+		this.published = false;
+	}
+	ensure() {
+		if (this.bridge !== null) return this.bridge;
+		const bridge = new import_dist.Accessory(this.opts.displayName, this.opts.uuid);
+		bridge.category = import_dist.Categories.BRIDGE;
+		this.bridge = bridge;
+		return bridge;
+	}
+	async publishOnce() {
+		if (this.published || this.bridge === null) return;
+		if (this.opts.publish !== void 0) await this.opts.publish(this.bridge, this.opts.pincode);
+		else await publishStandalone(this.bridge, {
+			pincode: this.opts.pincode,
+			port: 0,
+			bind: this.opts.bind,
+			logger: this.opts.logger
+		});
+		this.published = true;
+		this.opts.logger.info("export-hap: the bridge is published", { meta: {
+			displayName: this.opts.displayName,
+			uuid: this.opts.uuid
+		} });
+	}
+};
 //#endregion
 //#region src/hap-setup-uri.ts
 function errMsg$15(e) {
@@ -99477,6 +100082,19 @@ async function startFfmpegForSession(bctx, session, sessionId, video, advertised
 		} });
 		throw new Error(`export-hap: no enabled RTSP entries for device ${numericDeviceId}`);
 	}
+	if (fit.kind === "transcode" && bctx.options.hapDeviceSettings?.allowTranscode === false) {
+		startLog.warn("export-hap: stream start REFUSED — transcoding is switched off", {
+			tags: { deviceId: numericDeviceId },
+			meta: {
+				sessionId,
+				streamPreference: pref,
+				negotiated: `${video.width}x${video.height}`,
+				pickedProfile: fit.profile,
+				pickedCodec: fit.picked.codec ?? "unknown"
+			}
+		});
+		throw new Error(`export-hap: device ${numericDeviceId} needs a transcode and transcoding is switched off`);
+	}
 	const picked = fit.picked;
 	const rtspUrl = picked.url;
 	const slot = brokerStreams.find((s) => s.profile === fit.profile);
@@ -102596,6 +103214,12 @@ var ExportHapAddon = class extends BaseAddon {
 	* hardware init.
 	*/
 	decodeMemos = createHapDecodeMemos();
+	/**
+	* THE bridge. Lazily created and published the first time a non-camera
+	* accessory needs it; never torn down while the addon runs, because an
+	* unpublish would drop a pairing the operator already entered a code for.
+	*/
+	bridgeHost = null;
 	constructor() {
 		super({ ...DEFAULT_CONFIG });
 	}
@@ -102603,6 +103227,13 @@ var ExportHapAddon = class extends BaseAddon {
 		const identity = await this.ensureIdentity();
 		this.pincode = identity.pincode;
 		this.bind = this.config.interfaceName || void 0;
+		this.bridgeHost = new BridgeHost({
+			displayName: this.config.bridgeName,
+			uuid: identity.uuid,
+			pincode: identity.pincode,
+			bind: this.bind,
+			logger: this.ctx.logger
+		});
 		try {
 			await initHapStorage(node_path.join(this.ctx.dataDir, "hap-store"));
 		} catch (err) {
@@ -102631,6 +103262,7 @@ var ExportHapAddon = class extends BaseAddon {
 		}
 		this.ctx.addDisposer(async () => {
 			await this.detachAll();
+			await this.bridgeHost?.dispose();
 		});
 		this.subscribeDeviceProvisionedForReconcile();
 		this.subscribeDeviceReadyForReconcile();
@@ -102787,16 +103419,24 @@ var ExportHapAddon = class extends BaseAddon {
 				decodeMemos: this.decodeMemos,
 				hapDeviceSettings: {
 					streamPreference: entrySettings.streamPreference ?? "auto",
-					hksvRecording: resolveHksvRecording(entrySettings)
+					hksvRecording: resolveHksvRecording(entrySettings),
+					allowTranscode: entrySettings.allowTranscode !== false
 				}
 			}
 		});
-		for (const accessory of mapper.accessories) await publishStandalone(accessory, {
-			pincode: this.pincode,
-			port: 0,
-			bind: this.bind,
-			logger: this.ctx.logger
+		const wantsBridge = shouldBridge({
+			mapperKind: entry.mapperKind,
+			useBridge: entry.settings?.useBridge
 		});
+		for (const accessory of mapper.accessories) {
+			if (wantsBridge && this.bridgeHost !== null && await this.bridgeHost.add(accessory)) continue;
+			await publishStandalone(accessory, {
+				pincode: this.pincode,
+				port: 0,
+				bind: this.bind,
+				logger: this.ctx.logger
+			});
+		}
 		this.exposed.set(entry.deviceId, mapper);
 		return { childAccessoryUuids: [] };
 	}
@@ -102809,7 +103449,13 @@ var ExportHapAddon = class extends BaseAddon {
 		const mapper = this.exposed.get(deviceId);
 		if (!mapper) return;
 		this.exposed.delete(deviceId);
-		for (const accessory of mapper.accessories) await unpublishAccessory(accessory, this.ctx.logger);
+		for (const accessory of mapper.accessories) {
+			if (this.bridgeHost?.holds(accessory) === true) {
+				this.bridgeHost.remove(accessory);
+				continue;
+			}
+			await unpublishAccessory(accessory, this.ctx.logger);
+		}
 		await mapper.dispose().catch((err) => {
 			this.ctx.logger.withTags({ deviceId: Number.parseInt(deviceId, 10) }).warn("export-hap: mapper dispose failed", { meta: { error: errMsg(err) } });
 		});
@@ -103104,42 +103750,79 @@ var ExportHapAddon = class extends BaseAddon {
 		const enabledKey = `hap:${deviceId}:enabled`;
 		const streamPreferenceKey = `hap:${deviceId}:streamPreference`;
 		const hksvKey = `hap:${deviceId}:hksvRecording`;
+		const useBridgeKey = `hap:${deviceId}:useBridge`;
+		const allowTranscodeKey = `hap:${deviceId}:allowTranscode`;
 		const mapper = this.exposed.get(String(deviceId)) ?? null;
 		const paired = mapper ? accessoryPaired(mapper.accessory) : false;
+		const bridged = mapper !== null && this.bridgeHost?.holds(mapper.accessory) === true;
 		const name = entry?.displayName ?? `Device ${deviceId}`;
-		const statusLabel = !enabled ? "Not exposed" : paired ? `Paired — exposed as “${name}”` : `Exposed as “${name}” — not paired yet. In iOS Home: + → Add Accessory → “${name}”, then enter setup code ${this.config.identity.pincode}.`;
+		const bridgePaired = this.bridgeHost?.accessory !== null && this.bridgeHost?.accessory !== void 0 ? accessoryPaired(this.bridgeHost.accessory) : false;
+		const statusLabel = !enabled ? "Not exposed" : bridged ? bridgePaired ? `On the “${this.config.bridgeName}” bridge, as “${name}”` : `On the “${this.config.bridgeName}” bridge, as “${name}” — the BRIDGE is not paired yet. In iOS Home: + → Add Accessory → “${this.config.bridgeName}”, then enter setup code ${this.config.identity.pincode}. Every bridged device arrives with it.` : paired ? `Paired — exposed as “${name}”` : `Exposed as “${name}” — not paired yet. In iOS Home: + → Add Accessory → “${name}”, then enter setup code ${this.config.identity.pincode}.`;
+		const qrSource = bridged ? this.bridgeHost?.accessory ?? null : mapper?.accessory ?? null;
 		let qrValue = "";
-		if (mapper) try {
-			qrValue = mapper.accessory.setupURI();
+		if (qrSource) try {
+			qrValue = qrSource.setupURI();
 		} catch (err) {
 			this.ctx.logger.withTags({ deviceId }).debug("export-hap: setupURI failed for per-device contribution", { meta: { error: errMsg(err) } });
 		}
-		const cameraFields = kind !== "camera" ? [] : [{
-			type: "select",
-			key: streamPreferenceKey,
-			label: "Source stream (HomeKit)",
-			description: "Which camstack profile slot HomeKit pulls. Auto = the broker picks the slot closest to 1080p at session start.",
-			options: HAP_STREAM_PREFERENCE_OPTIONS,
-			required: true,
-			value: settings.streamPreference,
-			showWhen: {
-				field: enabledKey,
-				equals: true
-			},
-			immediate: true
-		}, {
+		const bridgeFields = kind === "camera" ? [] : [{
 			type: "boolean",
-			key: hksvKey,
-			label: "HomeKit recording (Secure Video)",
-			description: "Offer “Stream and Allow Recording” in iOS Home. Requires iCloud+ and a home hub. Keeps a continuous 8s prebuffer for this camera (~0.7% of one CPU core, H.264 sources only).",
+			key: useBridgeKey,
+			label: "Export through the bridge",
+			description: "Publish this device inside the shared CamStack bridge — one pairing and one entry in Add Accessory for every non-camera device, instead of one each. Turning this off gives it its own advertisement. Either way the switch REBUILDS the accessory and it must be added to the Home app again.",
 			style: "switch",
-			value: resolveHksvRecording(settings),
+			value: shouldBridge({
+				mapperKind: kind,
+				useBridge: settings.useBridge
+			}),
 			showWhen: {
 				field: enabledKey,
 				equals: true
 			},
 			immediate: true
 		}];
+		const cameraFields = kind !== "camera" ? [] : [
+			{
+				type: "select",
+				key: streamPreferenceKey,
+				label: "Source stream (HomeKit)",
+				description: "Which camstack profile slot HomeKit pulls. Auto = the broker picks the slot closest to 1080p at session start.",
+				options: HAP_STREAM_PREFERENCE_OPTIONS,
+				required: true,
+				value: settings.streamPreference,
+				showWhen: {
+					field: enabledKey,
+					equals: true
+				},
+				immediate: true
+			},
+			{
+				type: "boolean",
+				key: hksvKey,
+				label: "HomeKit recording (Secure Video)",
+				description: "Offer “Stream and Allow Recording” in iOS Home. Requires iCloud+ and a home hub. Keeps a continuous 8s prebuffer for this camera (~0.7% of one CPU core, H.264 sources only).",
+				style: "switch",
+				value: resolveHksvRecording(settings),
+				showWhen: {
+					field: enabledKey,
+					equals: true
+				},
+				immediate: true
+			},
+			{
+				type: "boolean",
+				key: allowTranscodeKey,
+				label: "Allow transcoding for HomeKit",
+				description: "Let the hub re-encode this camera when the resolution HomeKit negotiated cannot be served by a direct copy. Off means only a stream that can be forwarded as-is is offered — cheaper, but a session HomeKit negotiates outside what the camera publishes will be refused instead of transcoded.",
+				style: "switch",
+				value: settings.allowTranscode !== false,
+				showWhen: {
+					field: enabledKey,
+					equals: true
+				},
+				immediate: true
+			}
+		];
 		return {
 			tabs: [{
 				id: "export",
@@ -103184,6 +103867,7 @@ var ExportHapAddon = class extends BaseAddon {
 						value: enabled,
 						immediate: true
 					},
+					...bridgeFields,
 					...cameraFields
 				]
 			}]
@@ -103209,14 +103893,20 @@ var ExportHapAddon = class extends BaseAddon {
 		const enabledKey = `hap:${deviceId}:enabled`;
 		const streamPreferenceKey = `hap:${deviceId}:streamPreference`;
 		const hksvKey = `hap:${deviceId}:hksvRecording`;
+		const useBridgeKey = `hap:${deviceId}:useBridge`;
+		const allowTranscodeKey = `hap:${deviceId}:allowTranscode`;
 		const enabledValue = enabledKey in patch ? Boolean(patch[enabledKey]) : wasEnabled;
 		const streamPreferenceRaw = streamPreferenceKey in patch ? patch[streamPreferenceKey] : current?.settings?.streamPreference;
 		const streamPreference = typeof streamPreferenceRaw === "string" && streamPreferenceRaw.trim().length > 0 ? streamPreferenceRaw : "auto";
 		const hksvRecording = hksvKey in patch ? Boolean(patch[hksvKey]) : resolveHksvRecording(current?.settings);
+		const useBridge = useBridgeKey in patch ? Boolean(patch[useBridgeKey]) : current?.settings?.useBridge !== false;
+		const allowTranscode = allowTranscodeKey in patch ? Boolean(patch[allowTranscodeKey]) : current?.settings?.allowTranscode !== false;
 		const nextSettings = {
 			...current?.settings ?? DEFAULT_DEVICE_SETTINGS,
 			streamPreference,
-			hksvRecording
+			hksvRecording,
+			useBridge,
+			allowTranscode
 		};
 		if (!enabledValue) {
 			if (wasEnabled) await this.unexposeDevice(deviceIdStr);
@@ -103229,8 +103919,17 @@ var ExportHapAddon = class extends BaseAddon {
 		}
 		const currentPref = current?.settings?.streamPreference ?? "auto";
 		const currentHksv = resolveHksvRecording(current?.settings);
+		const mapperKind = current?.mapperKind ?? "generic";
+		const wasBridged = shouldBridge({
+			mapperKind,
+			useBridge: current?.settings?.useBridge
+		});
+		const willBridge = shouldBridge({
+			mapperKind,
+			useBridge
+		});
 		await this.updateEntrySettings(deviceIdStr, nextSettings);
-		if (currentPref !== streamPreference || currentHksv !== hksvRecording) {
+		if (currentPref !== streamPreference || currentHksv !== hksvRecording || wasBridged !== willBridge) {
 			log.info("export-hap: per-camera export settings changed — refreshing accessory", { meta: {
 				streamPreference: {
 					from: currentPref,
@@ -103239,10 +103938,14 @@ var ExportHapAddon = class extends BaseAddon {
 				hksvRecording: {
 					from: currentHksv,
 					to: hksvRecording
+				},
+				bridged: {
+					from: wasBridged,
+					to: willBridge
 				}
 			} });
 			try {
-				await this.unexposeDevice(deviceIdStr, { clearPairing: false });
+				await this.unexposeDevice(deviceIdStr, { clearPairing: wasBridged !== willBridge });
 				await this.exposeDevice(deviceIdStr);
 			} catch (err) {
 				log.warn("export-hap: failed to refresh accessory after a settings change", { meta: { error: errMsg(err) } });