@camstack/addon-export-hap 1.2.113 → 1.2.114

package/dist/hap-export.addon.mjs

@@ -72,7 +72,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";
@@ -689,6 +689,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";
@@ -5419,7 +5433,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-DBKu2-U5.mjs
+//#region ../types/dist/sleep-DEuj7E3j.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -8047,6 +8061,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.
@@ -9959,6 +9995,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}/`;
@@ -9988,30 +10065,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",
@@ -12199,6 +12269,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",
@@ -12595,6 +12717,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,
@@ -12849,6 +12987,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(),
 	/**
@@ -12865,7 +13013,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({
 	/**
@@ -12879,12 +13042,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()
 });
@@ -17154,6 +17337,8 @@ var NcSystemEventKindSchema = _enum([
 	"device-enabled",
 	"device-battery-low",
 	"device-battery-normal",
+	"device-consumable-low",
+	"device-consumable-normal",
 	"stream-online",
 	"stream-offline",
 	"node-online",
@@ -17172,6 +17357,7 @@ var NcSystemEventKindSchema = _enum([
 	"addon-updated",
 	"server-updated",
 	"export-completed",
+	"backup-completed",
 	"camera-online",
 	"camera-offline",
 	"camera-disabled",
@@ -24413,10 +24599,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(),
@@ -36981,6 +37185,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",
@@ -37065,6 +37275,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"streamSignals.listSignals": {
+		capName: "stream-signals",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"switch.setState": {
 		capName: "switch",
 		capScope: "device",
@@ -39437,6 +39653,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"streamBroker.reportStreamSignal": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"streamBroker.restartProfile": [{
 		name: "deviceId",
 		form: "single",
@@ -87058,6 +87279,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) {
@@ -99465,6 +99803,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);
@@ -102584,6 +102935,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 });
 	}
@@ -102591,6 +102948,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(path.join(this.ctx.dataDir, "hap-store"));
 		} catch (err) {
@@ -102619,6 +102983,7 @@ var ExportHapAddon = class extends BaseAddon {
 		}
 		this.ctx.addDisposer(async () => {
 			await this.detachAll();
+			await this.bridgeHost?.dispose();
 		});
 		this.subscribeDeviceProvisionedForReconcile();
 		this.subscribeDeviceReadyForReconcile();
@@ -102775,16 +103140,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: [] };
 	}
@@ -102797,7 +103170,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) } });
 		});
@@ -103092,42 +103471,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",
@@ -103172,6 +103588,7 @@ var ExportHapAddon = class extends BaseAddon {
 						value: enabled,
 						immediate: true
 					},
+					...bridgeFields,
 					...cameraFields
 				]
 			}]
@@ -103197,14 +103614,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);
@@ -103217,8 +103640,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,
@@ -103227,10 +103659,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) } });