@camstack/addon-export-alexa 1.2.107 → 1.2.109

package/dist/export-alexa.addon.mjs

@@ -1,5 +1,5 @@
 import * as crypto$1 from "node:crypto";
-//#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";
@@ -616,6 +616,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";
@@ -5346,7 +5360,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).
@@ -7488,7 +7502,23 @@ var EncodeProfileSchema = object({
 			"zerolatency",
 			"film",
 			"animation"
-		]).optional()
+		]).optional(),
+		/**
+		* ONE slice per access unit.
+		*
+		* `-tune zerolatency` turns on x264's sliced threads, and a frame then leaves
+		* the encoder as five NAL slices that share one RTP timestamp and carry one
+		* marker bit. A libwebrtc depacketiser sees five frame-starts and one
+		* frame-end per frame: the first pictures render and the video then freezes
+		* for good while the audio, on its own plane, plays on. Measured on this hub
+		* 2026-09-13 against the Echo, and reduced to one slice by this flag alone.
+		*
+		* A NAMED field and not a raw flag, because {@link EgressEncodeSchema} omits
+		* `outputArgs` on purpose: an opaque array is part of the sharing key, so two
+		* consumers meaning the same thing spelled differently would stop sharing one
+		* child. Absent means "whatever the encoder does" — today's behaviour.
+		*/
+		singleSlicePerFrame: boolean().optional()
 	}),
 	audio: union([literal("passthrough"), object({
 		codec: _enum([
@@ -7517,6 +7547,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.
@@ -7564,31 +7616,10 @@ var BASE_LIVE_EGRESS_PROFILE = {
 var ALEXA_EGRESS_PROFILE = {
 	...BASE_LIVE_EGRESS_PROFILE,
 	audio: { codec: "opus" },
-	/**
-	* ONE slice per access unit.
-	*
-	* `-tune zerolatency` turns on x264's sliced threads, and every access unit
-	* came out of this encode as FIVE slices — measured on the hub 2026-09-13 on
-	* the exact argv this path spawns, and reduced to one by this single flag.
-	*
-	* Five slices share one RTP timestamp and carry one marker bit, so a
-	* libwebrtc depacketiser sees five frame-starts and one frame-end per frame.
-	* The Echo renders the first pictures and then freezes for good, while the
-	* audio — a separate plane — plays on. It is the only structural property
-	* that survived the elimination: the same freeze reproduced at 2304×1296
-	* HEVC with 217 KB keyframes AND at 640×360 H.264 with 67 KB keyframes and a
-	* fifth of the bitrate, so source, resolution, bitrate, keyframe burst,
-	* hardware decode, parameter sets, drift and bitstream conformance are all
-	* out — each ruled out by a measurement, not by elimination.
-	*
-	* The tune STAYS: it also drops the lookahead and the B-frames, which a live
-	* path wants. Only the slicing is unwanted, and this is the flag that says so.
-	*
-	* Scoped to Alexa deliberately. HomeKit and the browser transcode inherit
-	* {@link BASE_LIVE_EGRESS_PROFILE}; whether they want the same shape is a
-	* question for their own evidence, and the browser has not been measured.
-	*/
-	outputArgs: ["-x264-params", "sliced-threads=0"]
+	video: {
+		...BASE_LIVE_EGRESS_PROFILE.video,
+		singleSlicePerFrame: true
+	}
 };
 /**
 * Deep wiring healthcheck — snapshot of active reachability probes across
@@ -9452,6 +9483,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}/`;
@@ -9481,30 +9553,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",
@@ -11718,6 +11783,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",
@@ -12114,6 +12231,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,
@@ -12368,6 +12501,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(),
 	/**
@@ -12384,7 +12527,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({
 	/**
@@ -12398,12 +12556,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()
 });
@@ -16476,7 +16654,7 @@ var AlarmArmModeSchema = _enum([
 	"vacation",
 	"custom_bypass"
 ]);
-object({
+var AlarmPanelStatusSchema = object({
 	/** Current lifecycle state. */
 	state: AlarmStateSchema,
 	/** Subset of arm modes the panel accepts. UI renders one button per
@@ -16639,6 +16817,8 @@ var NcSystemEventKindSchema = _enum([
 	"device-enabled",
 	"device-battery-low",
 	"device-battery-normal",
+	"device-consumable-low",
+	"device-consumable-normal",
 	"stream-online",
 	"stream-offline",
 	"node-online",
@@ -16657,6 +16837,7 @@ var NcSystemEventKindSchema = _enum([
 	"addon-updated",
 	"server-updated",
 	"export-completed",
+	"backup-completed",
 	"camera-online",
 	"camera-offline",
 	"camera-disabled",
@@ -23914,10 +24095,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(),
@@ -36421,6 +36620,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",
@@ -36505,6 +36710,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"streamSignals.listSignals": {
+		capName: "stream-signals",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"switch.setState": {
 		capName: "switch",
 		capScope: "device",
@@ -38877,6 +39088,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"streamBroker.reportStreamSignal": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"streamBroker.restartProfile": [{
 		name: "deviceId",
 		form: "single",
@@ -39707,7 +39923,7 @@ async function acquireAlexaEgress(input) {
 			profile: sourceProfile
 		},
 		encode: ALEXA_EGRESS_PROFILE,
-		rateControl: "relaxed",
+		rateControl: "tight",
 		publishLocally: true,
 		tag: `alexa/${sessionId}`
 	});
@@ -39731,6 +39947,7 @@ async function acquireAlexaEgress(input) {
 		meta: {
 			pipelineKey: transcode.pipelineKey,
 			camStreamId,
+			sourceProfile: input.sourceProfile,
 			encoder: transcode.encoder,
 			decodeHwAccel: transcode.decodeHwAccel ?? "software"
 		}
@@ -39764,6 +39981,148 @@ async function releaseAlexaEgress(input) {
 	}
 }
 //#endregion
+//#region src/egress/egress-handle-reaper.ts
+/**
+* Which handles should be released now.
+*
+* A session the broker says is GONE is reclaimed. A session it could not be
+* asked about is KEPT — a read that failed is not evidence of death, and
+* releasing a live session's transcode would black out a working stream to
+* save a process (D393, read in the direction that destroys work).
+*/
+async function reapDeadEgressHandles(input) {
+	const dead = [];
+	for (const handle of input.held) if (await input.isAlive(handle) === false) dead.push(handle);
+	return dead;
+}
+/** How often the sweep runs. Well under the minute Amazon requires a session
+*  to survive, so a genuinely dead one is not transcoding for long. */
+var EGRESS_REAP_INTERVAL_MS = 3e4;
+function logReaped(logger, handle) {
+	logger?.warn("alexa egress: session is GONE — reclaiming the transcode it still held", {
+		tags: { deviceId: handle.deviceId },
+		meta: {
+			sessionId: handle.sessionId,
+			pipelineKey: handle.pipelineKey,
+			reason: "no SessionDisconnected directive"
+		}
+	});
+}
+//#endregion
+//#region src/egress/alexa-source-pick.ts
+/** Amazon's documented ceiling. */
+var ALEXA_MAX_LINES = 1080;
+/**
+* Which profile slot serves `camStreamId`, or `null` when none does — a read
+* that failed is `null` too, and the caller keeps its previous behaviour
+* rather than guessing a slot from an error (D393).
+*/
+async function profileForCamStream(input) {
+	try {
+		const slots = await input.api.streamBroker.listAllProfileSlots.query();
+		for (const slot of slots) {
+			if (slot.deviceId !== input.deviceId) continue;
+			if (slot.sourceCamStreamId !== input.camStreamId) continue;
+			if (slot.profile === "high" || slot.profile === "mid" || slot.profile === "low") return slot.profile;
+		}
+		return null;
+	} catch (err) {
+		input.logger?.warn("alexa rtc-session: could not read the profile slots", {
+			tags: { deviceId: input.deviceId },
+			meta: { error: errMsg(err) }
+		});
+		return null;
+	}
+}
+//#endregion
+//#region src/handlers/endpoint-id.ts
+var SEPARATOR = "__";
+function parseCameraEndpointId(raw) {
+	if (!raw.includes(SEPARATOR)) {
+		const id = parseNonNegativeInt(raw);
+		if (id === null) return {
+			kind: "invalid",
+			reason: `not a numeric deviceId: ${raw}`
+		};
+		return {
+			kind: "camera",
+			deviceId: id
+		};
+	}
+	const [head, tail, ...rest] = raw.split(SEPARATOR);
+	if (head === void 0 || tail === void 0 || rest.length > 0) return {
+		kind: "invalid",
+		reason: `unexpected segments in endpointId: ${raw}`
+	};
+	const parent = parseNonNegativeInt(head);
+	if (parent === null) return {
+		kind: "invalid",
+		reason: `parent segment not numeric: ${raw}`
+	};
+	if (tail === "autotrack") return {
+		kind: "autotrack",
+		parentDeviceId: parent
+	};
+	if (tail === "privacy") return {
+		kind: "privacy",
+		parentDeviceId: parent
+	};
+	if (tail === "alarm") return {
+		kind: "alarm-panel",
+		deviceId: parent
+	};
+	const child = parseNonNegativeInt(tail);
+	if (child === null) return {
+		kind: "invalid",
+		reason: `child segment not numeric and not 'autotrack'/'privacy'/'alarm': ${raw}`
+	};
+	return {
+		kind: "child",
+		parentDeviceId: parent,
+		childDeviceId: child
+	};
+}
+function parseNonNegativeInt(s) {
+	if (!/^\d+$/.test(s)) return null;
+	const n = Number.parseInt(s, 10);
+	if (!Number.isFinite(n) || n < 0) return null;
+	return n;
+}
+//#endregion
+//#region src/handlers/error-envelope.ts
+/**
+* Shared Alexa `Alexa/ErrorResponse` envelope builder.
+*
+* Lives in its own module so every handler (and the directive router)
+* can emit its own namespace-appropriate error without circular imports.
+*/
+object({ event: object({
+	header: object({
+		namespace: literal("Alexa"),
+		name: literal("ErrorResponse"),
+		messageId: string(),
+		payloadVersion: literal("3")
+	}),
+	payload: object({
+		type: string(),
+		message: string()
+	})
+}) });
+function errorEnvelope(header, type, message) {
+	return { event: {
+		header: {
+			namespace: "Alexa",
+			name: "ErrorResponse",
+			messageId: header.messageId,
+			payloadVersion: "3"
+		},
+		payload: {
+			type,
+			message
+		}
+	} };
+}
+//#endregion
 //#region src/handlers/types.ts
 /**
 * Zod schemas for the subset of the Alexa Smart Home directive surface
@@ -39825,6 +40184,369 @@ var InitiateSessionWithOfferPayloadSchema = object({
 var SessionDisconnectedPayloadSchema = object({ sessionId: string() });
 var SetModePayloadSchema = object({ mode: string() });
 //#endregion
+//#region src/handlers/rtc-session.ts
+var InitiateSessionWithOfferDirectiveSchema = object({
+	endpoint: EndpointRefSchema,
+	payload: InitiateSessionWithOfferPayloadSchema
+});
+var SessionDisconnectedDirectiveSchema = object({
+	endpoint: EndpointRefSchema,
+	payload: SessionDisconnectedPayloadSchema
+});
+/**
+* Live egress handles, keyed by `<deviceId>/<sessionId>`.
+*
+* The primitive's refcount has no lease TTL: a holder that vanishes without
+* releasing leaks a child until the broker restarts (D67). This handler is a
+* holder, so it keeps the one piece of state that lets it not be that holder —
+* the `pipelineKey` its `SessionDisconnected` has to release.
+*
+* A module-level map is right here because the directive handlers are free
+* functions called per directive; the entry is written on a successful acquire
+* and deleted on the release path, both of which are the same tick as the
+* directive that owns it.
+*/
+var EGRESS_HANDLES = /* @__PURE__ */ new Map();
+function egressHandleKey(deviceId, sessionId) {
+	return `${deviceId}/${sessionId}`;
+}
+/** Every handle currently held, for the sweep. */
+function heldEgressHandles() {
+	const held = [];
+	for (const [key, pipelineKey] of EGRESS_HANDLES) {
+		const slash = key.indexOf("/");
+		if (slash <= 0) continue;
+		const deviceId = Number.parseInt(key.slice(0, slash), 10);
+		if (!Number.isFinite(deviceId)) continue;
+		held.push({
+			deviceId,
+			sessionId: key.slice(slash + 1),
+			pipelineKey
+		});
+	}
+	return held;
+}
+/** Drop a handle the sweep reclaimed, so it is not reaped twice. */
+function forgetEgressHandle(handle) {
+	EGRESS_HANDLES.delete(egressHandleKey(handle.deviceId, handle.sessionId));
+}
+var WEBRTC_PROFILE_NAMES = [
+	"high",
+	"mid",
+	"low"
+];
+function resolveWebrtcTarget(pref) {
+	if (pref === "auto") return void 0;
+	if (WEBRTC_PROFILE_NAMES.includes(pref)) return {
+		kind: "profile",
+		profile: pref
+	};
+	return {
+		kind: "cam-stream",
+		camStreamId: pref
+	};
+}
+async function handleInitiateSessionWithOffer(header, endpointRaw, payloadRaw, deps, _callerIdentity) {
+	const parsed = InitiateSessionWithOfferDirectiveSchema.safeParse({
+		endpoint: endpointRaw,
+		payload: payloadRaw ?? {}
+	});
+	if (!parsed.success) return errorEnvelope(header, "INVALID_DIRECTIVE", `payload validation failed: ${parsed.error.message}`);
+	const endpoint = parsed.data.endpoint;
+	const payload = parsed.data.payload;
+	const parsedId = parseCameraEndpointId(endpoint.endpointId);
+	if (parsedId.kind !== "camera") return errorEnvelope(header, "INVALID_DIRECTIVE", `endpointId ${endpoint.endpointId} is not a camera`);
+	const deviceId = parsedId.deviceId;
+	const sessionId = payload.sessionId;
+	const log = deps.logger.withTags({
+		deviceId,
+		sessionId
+	});
+	const sdpOffer = payload.offer.value;
+	if (sdpOffer.length === 0) return errorEnvelope(header, "INVALID_DIRECTIVE", "offer.value is empty");
+	const api = deps.ctx.api;
+	const exposedEntry = deps.listExposed().find((e) => e.deviceId === deviceId);
+	const pinnedProfile = (() => {
+		const pref = exposedEntry?.settings?.streamPreference;
+		if (pref === "low" || pref === "mid" || pref === "high") return pref;
+	})();
+	const allowTranscode = exposedEntry?.settings?.allowTranscode !== false;
+	const scored = pinnedProfile === void 0 ? await api.cameraStreams.pickStream.query({
+		deviceId,
+		requirements: {
+			acceptCodecs: ["h264"],
+			minHeight: 480,
+			maxHeight: ALEXA_MAX_LINES,
+			excludeDerived: true,
+			allowTranscode
+		},
+		preferences: { targetHeight: 720 }
+	}).catch((err) => {
+		log.warn("alexa rtc-session: pickStream threw — falling back to the high slot", {
+			tags: { deviceId },
+			meta: { error: err instanceof Error ? err.message : String(err) }
+		});
+		return null;
+	}) : null;
+	const scoredProfile = scored === null ? null : await profileForCamStream({
+		api,
+		deviceId,
+		camStreamId: scored.camStreamId,
+		logger: log
+	});
+	const sourceProfile = pinnedProfile ?? scoredProfile ?? "high";
+	if (pinnedProfile === void 0) log.info("alexa rtc-session: source scored against the Echo requirements", {
+		tags: { deviceId },
+		meta: {
+			chosen: sourceProfile,
+			scored: scored === null ? "none-eligible" : scored.reason,
+			camStreamId: scored?.camStreamId ?? null,
+			slot: scoredProfile ?? (scored === null ? null : "no-slot"),
+			height: scored?.resolution?.height ?? null,
+			transcodes: scored?.transcodes ?? null,
+			allowTranscode
+		}
+	});
+	let derivedTarget;
+	/**
+	* The primitive's release handle, when this session acquired one. Recorded so
+	* `SessionDisconnected` can release it: a refcount whose holder disappears is
+	* the one gap D67 leaves open, and the least this handler can do is not BE
+	* that holder.
+	*/
+	let egressPipelineKey = null;
+	const picked = await api.cameraStreams.pickStream.query({
+		deviceId,
+		requirements: {
+			acceptCodecs: ["h264"],
+			minHeight: 480,
+			excludeDerived: true,
+			requireSiblingCodec: ["h265", "hevc"]
+		}
+	}).catch((err) => {
+		log.warn("alexa rtc-session: cameraStreams.pickStream threw — falling back to transcode", { meta: { error: err instanceof Error ? err.message : String(err) } });
+		return null;
+	});
+	if (picked) {
+		log.info("alexa rtc-session: bypassing transcode via cameraStreams.pickStream", { meta: {
+			sourceProfile,
+			selectedCamStreamId: picked.camStreamId,
+			reason: picked.reason
+		} });
+		derivedTarget = {
+			kind: "cam-stream",
+			camStreamId: picked.camStreamId
+		};
+	} else try {
+		const acquired = await acquireAlexaEgress({
+			api,
+			deviceId,
+			sourceProfile,
+			sessionId,
+			logger: log
+		});
+		egressPipelineKey = acquired.pipelineKey;
+		EGRESS_HANDLES.set(egressHandleKey(deviceId, sessionId), acquired.pipelineKey);
+		derivedTarget = {
+			kind: "cam-stream",
+			camStreamId: acquired.camStreamId
+		};
+	} catch (err) {
+		log.warn("alexa rtc-session: egress acquire failed, falling back to streamPreference target", { meta: { error: err instanceof Error ? err.message : String(err) } });
+		derivedTarget = resolveWebrtcTarget(exposedEntry?.settings?.streamPreference ?? "auto");
+	}
+	try {
+		const result = await api.webrtcSession.handleOffer.mutate({
+			deviceId,
+			sdpOffer,
+			sessionId,
+			target: derivedTarget,
+			relayOnly: false,
+			nonTrickle: true,
+			disableTurn: true,
+			disableIpv6: true,
+			consumerAttribution: {
+				kind: "alexa",
+				sessionId
+			}
+		});
+		log.info("alexa rtc-session: AnswerGenerated", { meta: {
+			returnedSessionId: result.sessionId,
+			sdpAnswerLen: result.sdpAnswer.length
+		} });
+		return { event: {
+			header: {
+				namespace: "Alexa.RTCSessionController",
+				name: "AnswerGeneratedForSession",
+				messageId: header.messageId,
+				correlationToken: header.correlationToken,
+				payloadVersion: "3"
+			},
+			endpoint: { endpointId: endpoint.endpointId },
+			payload: { answer: {
+				format: payload.offer.format ?? "SDP",
+				value: result.sdpAnswer
+			} }
+		} };
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		const mSectionSummary = (() => {
+			const lines = sdpOffer.split(/\r?\n/);
+			const sections = [];
+			let current = null;
+			for (const raw of lines) {
+				const line = raw.trim();
+				if (line.startsWith("m=")) {
+					if (current) sections.push(current);
+					current = {
+						mid: null,
+						kind: line.split(" ")[0]?.slice(2) ?? "unknown",
+						direction: null,
+						codecs: []
+					};
+				} else if (current) {
+					if (line.startsWith("a=mid:")) current.mid = line.slice(6);
+					else if (/^a=(sendonly|recvonly|sendrecv|inactive)$/.test(line)) current.direction = line.slice(2);
+					else if (line.startsWith("a=rtpmap:")) current.codecs.push(line.slice(9));
+				}
+			}
+			if (current) sections.push(current);
+			return sections;
+		})();
+		log.warn("alexa rtc-session: handleOffer failed", { meta: {
+			error: message,
+			offerLen: sdpOffer.length,
+			mSections: mSectionSummary,
+			offerSdp: sdpOffer
+		} });
+		if (egressPipelineKey !== null) {
+			EGRESS_HANDLES.delete(egressHandleKey(deviceId, sessionId));
+			await releaseAlexaEgress({
+				api,
+				deviceId,
+				pipelineKey: egressPipelineKey,
+				logger: log
+			});
+		}
+		return errorEnvelope(header, "INTERNAL_ERROR", `webrtc-session.handleOffer failed: ${message}`);
+	}
+}
+async function handleSessionDisconnected(header, endpointRaw, payloadRaw, deps, _callerIdentity) {
+	const parsed = SessionDisconnectedDirectiveSchema.safeParse({
+		endpoint: endpointRaw,
+		payload: payloadRaw ?? {}
+	});
+	if (!parsed.success) return errorEnvelope(header, "INVALID_DIRECTIVE", `payload validation failed: ${parsed.error.message}`);
+	const endpoint = parsed.data.endpoint;
+	const parsedId = parseCameraEndpointId(endpoint.endpointId);
+	if (parsedId.kind === "camera") {
+		const handleKey = egressHandleKey(parsedId.deviceId, parsed.data.payload.sessionId);
+		const pipelineKey = EGRESS_HANDLES.get(handleKey);
+		if (pipelineKey !== void 0) {
+			EGRESS_HANDLES.delete(handleKey);
+			await releaseAlexaEgress({
+				api: deps.ctx.api,
+				deviceId: parsedId.deviceId,
+				pipelineKey,
+				logger: deps.logger
+			});
+		}
+		try {
+			await deps.ctx.api.webrtcSession.closeSession.mutate({
+				deviceId: parsedId.deviceId,
+				sessionId: parsed.data.payload.sessionId
+			});
+		} catch (err) {
+			deps.logger.warn("alexa rtc-session: closeSession threw on disconnect (continuing to ack)", {
+				tags: {
+					deviceId: parsedId.deviceId,
+					sessionId: parsed.data.payload.sessionId
+				},
+				meta: { error: err instanceof Error ? err.message : String(err) }
+			});
+		}
+	}
+	const disconnectedDeviceId = parsedId.kind === "camera" ? parsedId.deviceId : void 0;
+	deps.logger.info("alexa rtc-session: SessionDisconnected", {
+		tags: {
+			sessionId: parsed.data.payload.sessionId,
+			...disconnectedDeviceId !== void 0 ? { deviceId: disconnectedDeviceId } : {}
+		},
+		meta: { endpointId: endpoint.endpointId }
+	});
+	return { event: {
+		header: {
+			namespace: "Alexa",
+			name: "Response",
+			messageId: header.messageId,
+			correlationToken: header.correlationToken,
+			payloadVersion: "3"
+		},
+		endpoint: { endpointId: endpoint.endpointId },
+		payload: {}
+	} };
+}
+//#endregion
+//#region src/handlers/security-panel-arm-state.ts
+/**
+* The panel modes behind each Alexa arm state, PRIMARY first — the mirror of
+* `MODES_BY_TARGET` in the HomeKit exporter, and for the same reason: one
+* Alexa state stands for two panel modes, so a panel offering only the
+* secondary would otherwise be sent a mode it refuses.
+*/
+var MODES_BY_ARM_STATE = {
+	ARMED_STAY: ["home", "custom_bypass"],
+	ARMED_AWAY: ["away", "vacation"],
+	ARMED_NIGHT: ["night"]
+};
+var ARM_STATES = [
+	"ARMED_STAY",
+	"ARMED_AWAY",
+	"ARMED_NIGHT"
+];
+/** The panel's state as Alexa's `armState` property. */
+function alexaArmStateFor(state) {
+	switch (state) {
+		case "armed_home":
+		case "armed_custom_bypass": return "ARMED_STAY";
+		case "armed_night": return "ARMED_NIGHT";
+		case "armed_away":
+		case "armed_vacation":
+		case "pending":
+		case "triggered": return "ARMED_AWAY";
+		default: return "DISARMED";
+	}
+}
+/** `burglaryAlarm`, the only alarm property this cap can honestly fill. */
+function burglaryAlarmFor(state) {
+	return { value: state === "triggered" ? "ALARM" : "OK" };
+}
+/**
+* The `supportedArmStates` for discovery.
+*
+* `DISARMED` is always present: disarming is not one of the panel's arm modes.
+* An EMPTY `availableModes` is unknown, not "none" — a provider that never
+* populated the list looks identical to one that accepts nothing, and
+* publishing a panel that can only be disarmed on that guess takes the
+* controls off a working alarm. The caller logs it.
+*/
+function supportedArmStatesFor(availableModes) {
+	return [...availableModes.length === 0 ? ARM_STATES : ARM_STATES.filter((armState) => MODES_BY_ARM_STATE[armState].some((mode) => availableModes.includes(mode))), "DISARMED"];
+}
+/**
+* The arm mode to send for an Alexa arm state, or `null` when there is none.
+*
+* `null` is not a shrug: `DISARMED` is the Disarm DIRECTIVE, a different call,
+* and an arm state the panel accepts no mode for is a directive the handler
+* refuses with `NOT_READY_FOR_ARM` rather than translating into a guess.
+*/
+function alarmArmModeForAlexa(armState, availableModes) {
+	if (armState === "DISARMED") return null;
+	const candidates = MODES_BY_ARM_STATE[armState];
+	if (availableModes.length === 0) return candidates[0] ?? null;
+	return candidates.find((mode) => availableModes.includes(mode)) ?? null;
+}
+//#endregion
 //#region src/endpoints/builder.ts
 var DEFAULT_RESOLUTIONS = [{
 	width: 1920,
@@ -40147,55 +40869,55 @@ function buildPrivacyEndpoint(input) {
 		}
 	};
 }
-//#endregion
-//#region src/handlers/error-envelope.ts
 /**
-* Shared Alexa `Alexa/ErrorResponse` envelope builder.
-*
-* Lives in its own module so every handler (and the directive router)
-* can emit its own namespace-appropriate error without circular imports.
-*/
-object({ event: object({
-	header: object({
-		namespace: literal("Alexa"),
-		name: literal("ErrorResponse"),
-		messageId: string(),
-		payloadVersion: literal("3")
-	}),
-	payload: object({
-		type: string(),
-		message: string()
-	})
-}) });
-function errorEnvelope(header, type, message) {
-	return { event: {
-		header: {
-			namespace: "Alexa",
-			name: "ErrorResponse",
-			messageId: header.messageId,
-			payloadVersion: "3"
+* An `alarm-panel` device as an `Alexa.SecurityPanelController` endpoint.
+*
+* It is its OWN endpoint, not a child of a camera: a panel is a standalone
+* device and has no stream, no doorbell and no PTZ. The `__alarm` suffix on
+* the endpoint id is a routing tag (see `handlers/endpoint-id.ts`).
+*
+* ## What is declared, and what is deliberately not
+*
+*  - `armState` and `burglaryAlarm` are the two properties this cap can fill
+*    honestly. `fireAlarm` / `carbonMonoxideAlarm` / `waterAlarm` are NOT
+*    declared: `alarm-panel` has no field saying WHICH alarm is sounding, and
+*    declaring a property we would always answer `OK` on is a claim with no
+*    basis behind it. The reasoning is in `security-panel-arm-state.ts`.
+*  - `proactivelyReported: false`. This addon's Event Gateway pushes
+*    ChangeReports for camera motion only; a panel state change is not wired
+*    to it, and promising a report nothing sends is how an endpoint ends up
+*    looking broken. `retrievable: true` — `Alexa/ReportState` answers.
+*  - `supportedAuthorizationTypes` appears only for a panel that requires a
+*    code. Alexa's Disarm directive can carry a PIN; its **Arm directive
+*    cannot**, which is why a PIN-gated arm is refused by the handler with
+*    `AUTHORIZATION_REQUIRED` rather than attempted.
+*/
+function buildAlarmPanelEndpoint(input) {
+	const configuration = { supportedArmStates: supportedArmStatesFor(input.availableModes).map((value) => ({ value })) };
+	if (input.requiresCode) configuration.supportedAuthorizationTypes = [{ type: "FOUR_DIGIT_PIN" }];
+	const securityPanelController = {
+		type: "AlexaInterface",
+		interface: "Alexa.SecurityPanelController",
+		version: "3",
+		properties: {
+			supported: [{ name: "armState" }, { name: "burglaryAlarm" }],
+			proactivelyReported: false,
+			retrievable: true
 		},
-		payload: {
-			type,
-			message
-		}
-	} };
+		configuration
+	};
+	return {
+		endpointId: `${input.deviceId}__alarm`,
+		manufacturerName: "camstack",
+		description: "CamStack alarm panel",
+		friendlyName: input.friendlyName.trim().length > 0 ? input.friendlyName.trim() : `Alarm ${input.deviceId}`,
+		displayCategories: ["SECURITY_PANEL"],
+		capabilities: [ALEXA_BASE_CAPABILITY, securityPanelController],
+		cookie: { stableId: input.stableId }
+	};
 }
 //#endregion
 //#region src/handlers/discovery.ts
-/**
-* `Alexa.Discovery/Discover` handler — fires when the Alexa app pulls
-* the user's device list. We respond with the operator-curated
-* `exposed-devices.json` list, resolved against the live device
-* registry (so we don't return zombie endpoints for deleted devices).
-*
-* Feature detection is PASSIVE: per exposed device we inspect the
-* `DeviceInfo.features` + bound caps (from `device-manager.getBindings`)
-* and emit only the Alexa capabilities backed by something on our side.
-* Child accessories (siren/floodlight/PIR/…) become SEPARATE endpoints
-* with `endpointId = ${parent}__${child}` so directive handlers can
-* route to the right cap on the right device.
-*/
 var discoveryPayloadSchema = DiscoveryDirectiveSchema.shape.payload;
 /** Devices built at once in `handleDiscovery` — latency-bound tRPC reads, so
 *  six lanes hide the round-trips without stampeding a booting hub. */
@@ -40209,6 +40931,7 @@ var CAP_SWITCH = "switch";
 var CAP_BRIGHTNESS = "brightness";
 var CAP_BATTERY = "battery";
 var CAP_PRIVACY_MASK = "privacy-mask";
+var CAP_ALARM_PANEL = "alarm-panel";
 async function handleDiscovery(header, payloadRaw, deps, callerIdentity) {
 	if (!discoveryPayloadSchema.safeParse(payloadRaw).success) return errorEnvelope(header, "INVALID_DIRECTIVE", "Discovery payload shape unexpected");
 	const exposed = await deps.listExposed();
@@ -40248,6 +40971,7 @@ async function buildEndpointsForExposedDevice(deviceId, deps) {
 		return [];
 	}
 	const parentInfo = await loadBoundDeviceInfo(device, api);
+	if (parentInfo.capNames.includes(CAP_ALARM_PANEL)) return [await buildAlarmPanelEndpointFor(parentInfo, api, deps)];
 	const children = await api.deviceManager.getChildren.query({ parentDeviceId: deviceId }).catch((err) => {
 		deps.logger.warn("alexa discovery: getChildren failed", {
 			tags: { deviceId },
@@ -40327,6 +41051,47 @@ async function buildEndpointsForExposedDevice(deviceId, deps) {
 	}
 	return out;
 }
+/**
+* The panel endpoint, with what the panel says it accepts.
+*
+* A `getStatus` that fails leaves `availableModes` empty and `requiresCode`
+* false, and those are the UNKNOWN readings, not assertions: an empty mode
+* list makes discovery declare all three arm states (`supportedArmStatesFor`)
+* rather than publishing a panel that can only be disarmed, and the directive
+* handler re-reads the panel before it commands anything, so a PIN discovered
+* later is still honoured. The blind read is logged against the device id.
+*/
+async function buildAlarmPanelEndpointFor(info, api, deps) {
+	const status = await api.alarmPanel.getStatus.query({ deviceId: info.id }).catch((err) => {
+		deps.logger.warn("alexa discovery: alarmPanel.getStatus failed — declaring every arm state", {
+			tags: { deviceId: info.id },
+			meta: { error: err instanceof Error ? err.message : String(err) }
+		});
+		return null;
+	});
+	const parsed = AlarmPanelStatusSchema.pick({
+		availableModes: true,
+		requiresCode: true
+	}).safeParse(status);
+	if (!parsed.success && status !== null) deps.logger.warn("alexa discovery: panel status did not match the cap schema", { tags: { deviceId: info.id } });
+	const availableModes = parsed.success ? parsed.data.availableModes : [];
+	const requiresCode = parsed.success ? parsed.data.requiresCode : false;
+	deps.logger.info("alexa discovery: built alarm panel endpoint", {
+		tags: { deviceId: info.id },
+		meta: {
+			name: info.name,
+			availableModes: [...availableModes],
+			requiresCode
+		}
+	});
+	return buildAlarmPanelEndpoint({
+		deviceId: info.id,
+		stableId: info.stableId,
+		friendlyName: info.name,
+		availableModes,
+		requiresCode
+	});
+}
 async function loadBoundDeviceInfo(device, api) {
 	const capNames = (await api.deviceManager.getBindings.query({ deviceId: device.id })).entries.map((e) => e.capName);
 	return {
@@ -40360,55 +41125,67 @@ function discoveryResponse(header, endpoints) {
 	} };
 }
 //#endregion
-//#region src/handlers/endpoint-id.ts
-var SEPARATOR = "__";
-function parseCameraEndpointId(raw) {
-	if (!raw.includes(SEPARATOR)) {
-		const id = parseNonNegativeInt(raw);
-		if (id === null) return {
-			kind: "invalid",
-			reason: `not a numeric deviceId: ${raw}`
-		};
-		return {
-			kind: "camera",
-			deviceId: id
-		};
+//#region src/handlers/brightness-controller.ts
+var SetBrightnessDirectiveSchema = object({
+	header: object({
+		namespace: literal("Alexa.BrightnessController"),
+		name: literal("SetBrightness")
+	}),
+	endpoint: EndpointRefSchema,
+	payload: object({ brightness: number().min(0).max(100) })
+});
+async function handleSetBrightness(header, endpointRaw, payloadRaw, deps, _callerIdentity) {
+	const parsed = SetBrightnessDirectiveSchema.safeParse({
+		header: {
+			namespace: header.namespace,
+			name: header.name
+		},
+		endpoint: endpointRaw,
+		payload: payloadRaw ?? {}
+	});
+	if (!parsed.success) return errorEnvelope(header, "INVALID_DIRECTIVE", `payload validation failed: ${parsed.error.message}`);
+	const endpointId = parsed.data.endpoint.endpointId;
+	const parsedId = parseCameraEndpointId(endpointId);
+	if (parsedId.kind === "autotrack" || parsedId.kind === "privacy" || parsedId.kind === "alarm-panel") return errorEnvelope(header, "INVALID_DIRECTIVE", `BrightnessController is not exposed on the ${parsedId.kind} endpoint`);
+	if (parsedId.kind === "camera") return errorEnvelope(header, "INVALID_DIRECTIVE", "BrightnessController is not exposed on camera endpoints — direct the directive at the dimmable child accessory");
+	if (parsedId.kind === "invalid") return errorEnvelope(header, "INVALID_DIRECTIVE", parsedId.reason);
+	const percentage = parsed.data.payload.brightness;
+	const api = deps.ctx.api;
+	try {
+		await api.brightness.setBrightness.mutate({
+			deviceId: parsedId.childDeviceId,
+			percentage
+		});
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		deps.logger.warn("alexa brightness-controller: setBrightness failed", { meta: {
+			deviceId: parsedId.childDeviceId,
+			percentage,
+			error: message
+		} });
+		return errorEnvelope(header, "INTERNAL_ERROR", `brightness.setBrightness failed: ${message}`);
 	}
-	const [head, tail, ...rest] = raw.split(SEPARATOR);
-	if (head === void 0 || tail === void 0 || rest.length > 0) return {
-		kind: "invalid",
-		reason: `unexpected segments in endpointId: ${raw}`
-	};
-	const parent = parseNonNegativeInt(head);
-	if (parent === null) return {
-		kind: "invalid",
-		reason: `parent segment not numeric: ${raw}`
-	};
-	if (tail === "autotrack") return {
-		kind: "autotrack",
-		parentDeviceId: parent
-	};
-	if (tail === "privacy") return {
-		kind: "privacy",
-		parentDeviceId: parent
-	};
-	const child = parseNonNegativeInt(tail);
-	if (child === null) return {
-		kind: "invalid",
-		reason: `child segment not numeric and not 'autotrack'/'privacy': ${raw}`
-	};
 	return {
-		kind: "child",
-		parentDeviceId: parent,
-		childDeviceId: child
+		event: {
+			header: {
+				namespace: "Alexa",
+				name: "Response",
+				messageId: header.messageId,
+				correlationToken: header.correlationToken,
+				payloadVersion: "3"
+			},
+			endpoint: { endpointId },
+			payload: {}
+		},
+		context: { properties: [{
+			namespace: "Alexa.BrightnessController",
+			name: "brightness",
+			value: percentage,
+			timeOfSample: (/* @__PURE__ */ new Date()).toISOString(),
+			uncertaintyInMilliseconds: 500
+		}] }
 	};
 }
-function parseNonNegativeInt(s) {
-	if (!/^\d+$/.test(s)) return null;
-	const n = Number.parseInt(s, 10);
-	if (!Number.isFinite(n) || n < 0) return null;
-	return n;
-}
 //#endregion
 //#region src/handlers/camera-stream.ts
 /**
@@ -40492,347 +41269,42 @@ async function handleInitializeCameraStreams(header, endpointRaw, payloadRaw, de
 	} };
 }
 //#endregion
-//#region src/handlers/rtc-session.ts
-var InitiateSessionWithOfferDirectiveSchema = object({
-	endpoint: EndpointRefSchema,
-	payload: InitiateSessionWithOfferPayloadSchema
-});
-var SessionDisconnectedDirectiveSchema = object({
-	endpoint: EndpointRefSchema,
-	payload: SessionDisconnectedPayloadSchema
-});
-/**
-* Live egress handles, keyed by `<deviceId>/<sessionId>`.
-*
-* The primitive's refcount has no lease TTL: a holder that vanishes without
-* releasing leaks a child until the broker restarts (D67). This handler is a
-* holder, so it keeps the one piece of state that lets it not be that holder —
-* the `pipelineKey` its `SessionDisconnected` has to release.
-*
-* A module-level map is right here because the directive handlers are free
-* functions called per directive; the entry is written on a successful acquire
-* and deleted on the release path, both of which are the same tick as the
-* directive that owns it.
-*/
-var EGRESS_HANDLES = /* @__PURE__ */ new Map();
-function egressHandleKey(deviceId, sessionId) {
-	return `${deviceId}/${sessionId}`;
-}
-var WEBRTC_PROFILE_NAMES = [
-	"high",
-	"mid",
-	"low"
-];
-function resolveWebrtcTarget(pref) {
-	if (pref === "auto") return void 0;
-	if (WEBRTC_PROFILE_NAMES.includes(pref)) return {
-		kind: "profile",
-		profile: pref
-	};
-	return {
-		kind: "cam-stream",
-		camStreamId: pref
-	};
-}
-async function handleInitiateSessionWithOffer(header, endpointRaw, payloadRaw, deps, _callerIdentity) {
-	const parsed = InitiateSessionWithOfferDirectiveSchema.safeParse({
-		endpoint: endpointRaw,
-		payload: payloadRaw ?? {}
-	});
-	if (!parsed.success) return errorEnvelope(header, "INVALID_DIRECTIVE", `payload validation failed: ${parsed.error.message}`);
-	const endpoint = parsed.data.endpoint;
-	const payload = parsed.data.payload;
-	const parsedId = parseCameraEndpointId(endpoint.endpointId);
-	if (parsedId.kind !== "camera") return errorEnvelope(header, "INVALID_DIRECTIVE", `endpointId ${endpoint.endpointId} is not a camera`);
-	const deviceId = parsedId.deviceId;
-	const sessionId = payload.sessionId;
-	const log = deps.logger.withTags({
-		deviceId,
-		sessionId
-	});
-	const sdpOffer = payload.offer.value;
-	if (sdpOffer.length === 0) return errorEnvelope(header, "INVALID_DIRECTIVE", "offer.value is empty");
-	const api = deps.ctx.api;
-	const exposedEntry = deps.listExposed().find((e) => e.deviceId === deviceId);
-	const explicitSourceProfile = exposedEntry?.settings?.sourceProfile;
-	const mappedFromPreference = (() => {
-		const pref = exposedEntry?.settings?.streamPreference;
-		if (pref === "low" || pref === "mid" || pref === "high") return pref;
-	})();
-	const sourceProfile = explicitSourceProfile ?? mappedFromPreference ?? "high";
-	let derivedTarget;
-	/**
-	* The primitive's release handle, when this session acquired one. Recorded so
-	* `SessionDisconnected` can release it: a refcount whose holder disappears is
-	* the one gap D67 leaves open, and the least this handler can do is not BE
-	* that holder.
-	*/
-	let egressPipelineKey = null;
-	const picked = await api.cameraStreams.pickStream.query({
-		deviceId,
-		requirements: {
-			acceptCodecs: ["h264"],
-			minHeight: 480,
-			excludeDerived: true,
-			requireSiblingCodec: ["h265", "hevc"]
-		}
-	}).catch((err) => {
-		log.warn("alexa rtc-session: cameraStreams.pickStream threw — falling back to transcode", { meta: { error: err instanceof Error ? err.message : String(err) } });
-		return null;
-	});
-	if (picked) {
-		log.info("alexa rtc-session: bypassing transcode via cameraStreams.pickStream", { meta: {
-			sourceProfile,
-			selectedCamStreamId: picked.camStreamId,
-			reason: picked.reason
-		} });
-		derivedTarget = {
-			kind: "cam-stream",
-			camStreamId: picked.camStreamId
-		};
-	} else try {
-		const acquired = await acquireAlexaEgress({
-			api,
-			deviceId,
-			sourceProfile,
-			sessionId,
-			logger: log
-		});
-		egressPipelineKey = acquired.pipelineKey;
-		EGRESS_HANDLES.set(egressHandleKey(deviceId, sessionId), acquired.pipelineKey);
-		derivedTarget = {
-			kind: "cam-stream",
-			camStreamId: acquired.camStreamId
-		};
-	} catch (err) {
-		log.warn("alexa rtc-session: egress acquire failed, falling back to streamPreference target", { meta: { error: err instanceof Error ? err.message : String(err) } });
-		derivedTarget = resolveWebrtcTarget(exposedEntry?.settings?.streamPreference ?? "auto");
-	}
-	try {
-		const result = await api.webrtcSession.handleOffer.mutate({
-			deviceId,
-			sdpOffer,
-			sessionId,
-			target: derivedTarget,
-			relayOnly: false,
-			nonTrickle: true,
-			disableTurn: true,
-			disableIpv6: true,
-			consumerAttribution: {
-				kind: "alexa",
-				sessionId
-			}
-		});
-		log.info("alexa rtc-session: AnswerGenerated", { meta: {
-			returnedSessionId: result.sessionId,
-			sdpAnswerLen: result.sdpAnswer.length
-		} });
-		return { event: {
-			header: {
-				namespace: "Alexa.RTCSessionController",
-				name: "AnswerGeneratedForSession",
-				messageId: header.messageId,
-				correlationToken: header.correlationToken,
-				payloadVersion: "3"
-			},
-			endpoint: { endpointId: endpoint.endpointId },
-			payload: { answer: {
-				format: payload.offer.format ?? "SDP",
-				value: result.sdpAnswer
-			} }
-		} };
-	} catch (err) {
-		const message = err instanceof Error ? err.message : String(err);
-		const mSectionSummary = (() => {
-			const lines = sdpOffer.split(/\r?\n/);
-			const sections = [];
-			let current = null;
-			for (const raw of lines) {
-				const line = raw.trim();
-				if (line.startsWith("m=")) {
-					if (current) sections.push(current);
-					current = {
-						mid: null,
-						kind: line.split(" ")[0]?.slice(2) ?? "unknown",
-						direction: null,
-						codecs: []
-					};
-				} else if (current) {
-					if (line.startsWith("a=mid:")) current.mid = line.slice(6);
-					else if (/^a=(sendonly|recvonly|sendrecv|inactive)$/.test(line)) current.direction = line.slice(2);
-					else if (line.startsWith("a=rtpmap:")) current.codecs.push(line.slice(9));
-				}
-			}
-			if (current) sections.push(current);
-			return sections;
-		})();
-		log.warn("alexa rtc-session: handleOffer failed", { meta: {
-			error: message,
-			offerLen: sdpOffer.length,
-			mSections: mSectionSummary,
-			offerSdp: sdpOffer
-		} });
-		if (egressPipelineKey !== null) {
-			EGRESS_HANDLES.delete(egressHandleKey(deviceId, sessionId));
-			await releaseAlexaEgress({
-				api,
-				deviceId,
-				pipelineKey: egressPipelineKey,
-				logger: log
-			});
-		}
-		return errorEnvelope(header, "INTERNAL_ERROR", `webrtc-session.handleOffer failed: ${message}`);
-	}
-}
-async function handleSessionDisconnected(header, endpointRaw, payloadRaw, deps, _callerIdentity) {
-	const parsed = SessionDisconnectedDirectiveSchema.safeParse({
-		endpoint: endpointRaw,
-		payload: payloadRaw ?? {}
-	});
-	if (!parsed.success) return errorEnvelope(header, "INVALID_DIRECTIVE", `payload validation failed: ${parsed.error.message}`);
-	const endpoint = parsed.data.endpoint;
-	const parsedId = parseCameraEndpointId(endpoint.endpointId);
-	if (parsedId.kind === "camera") {
-		const handleKey = egressHandleKey(parsedId.deviceId, parsed.data.payload.sessionId);
-		const pipelineKey = EGRESS_HANDLES.get(handleKey);
-		if (pipelineKey !== void 0) {
-			EGRESS_HANDLES.delete(handleKey);
-			await releaseAlexaEgress({
-				api: deps.ctx.api,
-				deviceId: parsedId.deviceId,
-				pipelineKey,
-				logger: deps.logger
-			});
-		}
-		try {
-			await deps.ctx.api.webrtcSession.closeSession.mutate({
-				deviceId: parsedId.deviceId,
-				sessionId: parsed.data.payload.sessionId
-			});
-		} catch (err) {
-			deps.logger.warn("alexa rtc-session: closeSession threw on disconnect (continuing to ack)", {
-				tags: {
-					deviceId: parsedId.deviceId,
-					sessionId: parsed.data.payload.sessionId
-				},
-				meta: { error: err instanceof Error ? err.message : String(err) }
-			});
-		}
-	}
-	const disconnectedDeviceId = parsedId.kind === "camera" ? parsedId.deviceId : void 0;
-	deps.logger.info("alexa rtc-session: SessionDisconnected", {
-		tags: {
-			sessionId: parsed.data.payload.sessionId,
-			...disconnectedDeviceId !== void 0 ? { deviceId: disconnectedDeviceId } : {}
-		},
-		meta: { endpointId: endpoint.endpointId }
-	});
-	return { event: {
-		header: {
-			namespace: "Alexa",
-			name: "Response",
-			messageId: header.messageId,
-			correlationToken: header.correlationToken,
-			payloadVersion: "3"
-		},
-		endpoint: { endpointId: endpoint.endpointId },
-		payload: {}
-	} };
-}
-//#endregion
-//#region src/handlers/ptz-preset.ts
-/**
-* `Alexa.ModeController/SetMode` handler — dispatches three PTZ instances:
-*
-*   `ptz.preset` — preset-recall. Decodes the preset name from the mode
-*     value and calls `ptz.goToPreset({deviceId, presetId})`.
-*
-*   `ptz.pan`  — momentary pan. `ptz.pan.left|right|center` issues a
-*     continuousMove pulse stopped on a timer; the dropdown reverts to
-*     `center` server-side so subsequent picks re-trigger the move.
-*
-*   `ptz.tilt` — momentary tilt. Mirrors ptz.pan with up|down|center.
-*/
-var SetModeDirectiveSchema = object({
+//#region src/handlers/power-controller.ts
+var PowerDirectiveSchema = object({
 	header: object({
-		namespace: literal("Alexa.ModeController"),
-		name: literal("SetMode"),
-		instance: string().optional()
+		namespace: literal("Alexa.PowerController"),
+		name: _enum(["TurnOn", "TurnOff"])
 	}),
-	endpoint: EndpointRefSchema,
-	payload: SetModePayloadSchema
+	endpoint: EndpointRefSchema
 });
-var PTZ_PRESET_MODE_PREFIX = "ptz.preset.";
-var PTZ_DIRECTION_PULSE_MS = 1e3;
-var PTZ_PAN_MOVES = {
-	"ptz.pan.left": { pan: -1 },
-	"ptz.pan.right": { pan: 1 },
-	"ptz.pan.center": {}
-};
-var PTZ_TILT_MOVES = {
-	"ptz.tilt.up": { tilt: 1 },
-	"ptz.tilt.down": { tilt: -1 },
-	"ptz.tilt.center": {}
-};
-async function handleSetMode(header, endpointRaw, payloadRaw, deps, _callerIdentity) {
-	const parsed = SetModeDirectiveSchema.safeParse({
+async function handlePower(header, endpointRaw, deps, _callerIdentity) {
+	const parsed = PowerDirectiveSchema.safeParse({
 		header: {
 			namespace: header.namespace,
-			name: header.name,
-			instance: header.instance
+			name: header.name
 		},
-		endpoint: endpointRaw,
-		payload: payloadRaw ?? {}
+		endpoint: endpointRaw
 	});
 	if (!parsed.success) return errorEnvelope(header, "INVALID_DIRECTIVE", `payload validation failed: ${parsed.error.message}`);
-	const instance = parsed.data.header.instance;
-	if (instance !== "ptz.preset" && instance !== "ptz.pan" && instance !== "ptz.tilt") return errorEnvelope(header, "INVALID_DIRECTIVE", `ModeController instance not supported: ${instance ?? "(missing)"}`);
 	const endpointId = parsed.data.endpoint.endpointId;
 	const parsedId = parseCameraEndpointId(endpointId);
-	if (parsedId.kind !== "camera") return errorEnvelope(header, "INVALID_DIRECTIVE", `ModeController only supported on camera endpoints — got ${endpointId}`);
-	const mode = parsed.data.payload.mode;
+	const on = parsed.data.header.name === "TurnOn";
 	const api = deps.ctx.api;
-	if (instance === "ptz.pan" || instance === "ptz.tilt") {
-		const move = (instance === "ptz.pan" ? PTZ_PAN_MOVES : PTZ_TILT_MOVES)[mode];
-		if (!move) return errorEnvelope(header, "INVALID_DIRECTIVE", `mode '${mode}' is not a valid ${instance} mode`);
-		if (Object.keys(move).length === 0) await api.ptz.stop.mutate({ deviceId: parsedId.deviceId }).catch((err) => {
-			deps.logger.debug("alexa ptz-mode: stop (center) failed (non-fatal)", { meta: {
-				deviceId: parsedId.deviceId,
-				instance,
-				error: err instanceof Error ? err.message : String(err)
-			} });
-		});
-		else try {
-			await api.ptz.continuousMove.mutate({
-				deviceId: parsedId.deviceId,
-				...move
-			});
-			setTimeout(() => {
-				api.ptz.stop.mutate({ deviceId: parsedId.deviceId }).catch((err) => {
-					deps.logger.debug("alexa ptz-mode: stop after pulse failed (non-fatal)", { meta: {
-						deviceId: parsedId.deviceId,
-						instance,
-						error: err instanceof Error ? err.message : String(err)
-					} });
-				});
-			}, PTZ_DIRECTION_PULSE_MS);
-		} catch (err) {
-			return errorEnvelope(header, "INTERNAL_ERROR", `ptz.continuousMove failed: ${err instanceof Error ? err.message : String(err)}`);
-		}
-		return modeSuccessResponse(header, endpointId, instance, instance === "ptz.pan" ? "ptz.pan.center" : "ptz.tilt.center");
-	}
-	if (!mode.startsWith(PTZ_PRESET_MODE_PREFIX)) return errorEnvelope(header, "INVALID_DIRECTIVE", `mode '${mode}' is not a ptz.preset mode`);
-	const presetName = mode.slice(11);
-	if (presetName.length === 0) return errorEnvelope(header, "INVALID_DIRECTIVE", "preset name missing after prefix");
-	const preset = (await api.ptz.getPresets.query({ deviceId: parsedId.deviceId })).find((p) => p.name === presetName);
-	if (!preset) return errorEnvelope(header, "INVALID_DIRECTIVE", `preset '${presetName}' not found on device ${parsedId.deviceId}`);
-	await api.ptz.goToPreset.mutate({
-		deviceId: parsedId.deviceId,
-		presetId: preset.id
+	if (parsedId.kind === "autotrack") await api.ptzAutotrack.setEnabled.mutate({
+		deviceId: parsedId.parentDeviceId,
+		enabled: on
 	});
-	return modeSuccessResponse(header, endpointId, "ptz.preset", mode);
-}
-function modeSuccessResponse(header, endpointId, instance, mode) {
+	else if (parsedId.kind === "privacy") await api.privacyMask.setMask.mutate({
+		deviceId: parsedId.parentDeviceId,
+		patch: { enabled: on }
+	});
+	else if (parsedId.kind === "child") await api.switch.setState.mutate({
+		deviceId: parsedId.childDeviceId,
+		on
+	});
+	else if (parsedId.kind === "camera") return errorEnvelope(header, "INVALID_DIRECTIVE", "PowerController is not exposed on camera endpoints — direct the directive at the child accessory");
+	else if (parsedId.kind === "alarm-panel") return errorEnvelope(header, "INVALID_DIRECTIVE", "PowerController is not exposed on alarm-panel endpoints — use Alexa.SecurityPanelController");
+	else return errorEnvelope(header, "INVALID_DIRECTIVE", parsedId.reason);
 	return {
 		event: {
 			header: {
@@ -40846,10 +41318,9 @@ function modeSuccessResponse(header, endpointId, instance, mode) {
 			payload: {}
 		},
 		context: { properties: [{
-			namespace: "Alexa.ModeController",
-			instance,
-			name: "mode",
-			value: mode,
+			namespace: "Alexa.PowerController",
+			name: "powerState",
+			value: on ? "ON" : "OFF",
 			timeOfSample: (/* @__PURE__ */ new Date()).toISOString(),
 			uncertaintyInMilliseconds: 500
 		}] }
@@ -40949,133 +41420,99 @@ function successResponse(header, endpointId, toggleState, instance) {
 	};
 }
 //#endregion
-//#region src/handlers/power-controller.ts
-/**
-* `Alexa.PowerController/{TurnOn,TurnOff}` handler.
-*
-* Routing decodes the endpoint id:
-*   - `${parent}__${child}` → call `switch.setState({deviceId: child, on})`
-*   - `${parent}__autotrack` → call `ptzAutotrack.setEnabled({deviceId: parent, enabled})`
-*   - `${parent}__privacy` → call `privacyMask.setMask({deviceId: parent, patch: { enabled } })`
-*   - `${deviceId}` (bare parent camera) → reject with INVALID_DIRECTIVE
-*     (we never expose PowerController on the camera itself).
-*
-* Auth: verify the directive's scope token (same as every other
-* controller).
-*/
-var PowerDirectiveSchema = object({
-	header: object({
-		namespace: literal("Alexa.PowerController"),
-		name: _enum(["TurnOn", "TurnOff"])
-	}),
-	endpoint: EndpointRefSchema
-});
-async function handlePower(header, endpointRaw, deps, _callerIdentity) {
-	const parsed = PowerDirectiveSchema.safeParse({
-		header: {
-			namespace: header.namespace,
-			name: header.name
-		},
-		endpoint: endpointRaw
-	});
-	if (!parsed.success) return errorEnvelope(header, "INVALID_DIRECTIVE", `payload validation failed: ${parsed.error.message}`);
-	const endpointId = parsed.data.endpoint.endpointId;
-	const parsedId = parseCameraEndpointId(endpointId);
-	const on = parsed.data.header.name === "TurnOn";
-	const api = deps.ctx.api;
-	if (parsedId.kind === "autotrack") await api.ptzAutotrack.setEnabled.mutate({
-		deviceId: parsedId.parentDeviceId,
-		enabled: on
-	});
-	else if (parsedId.kind === "privacy") await api.privacyMask.setMask.mutate({
-		deviceId: parsedId.parentDeviceId,
-		patch: { enabled: on }
-	});
-	else if (parsedId.kind === "child") await api.switch.setState.mutate({
-		deviceId: parsedId.childDeviceId,
-		on
-	});
-	else if (parsedId.kind === "camera") return errorEnvelope(header, "INVALID_DIRECTIVE", "PowerController is not exposed on camera endpoints — direct the directive at the child accessory");
-	else return errorEnvelope(header, "INVALID_DIRECTIVE", parsedId.reason);
-	return {
-		event: {
-			header: {
-				namespace: "Alexa",
-				name: "Response",
-				messageId: header.messageId,
-				correlationToken: header.correlationToken,
-				payloadVersion: "3"
-			},
-			endpoint: { endpointId },
-			payload: {}
-		},
-		context: { properties: [{
-			namespace: "Alexa.PowerController",
-			name: "powerState",
-			value: on ? "ON" : "OFF",
-			timeOfSample: (/* @__PURE__ */ new Date()).toISOString(),
-			uncertaintyInMilliseconds: 500
-		}] }
-	};
-}
-//#endregion
-//#region src/handlers/brightness-controller.ts
+//#region src/handlers/ptz-preset.ts
 /**
-* `Alexa.BrightnessController/SetBrightness` handler.
+* `Alexa.ModeController/SetMode` handler — dispatches three PTZ instances:
 *
-* The Discovery handler declares `Alexa.BrightnessController` only on
-* child accessory endpoints that bind the `brightness` cap (today:
-* Reolink floodlights, Hikvision supplemental lights). Brightness is
-* NEVER exposed on the parent camera endpoint or on the synthetic
-* autotrack endpoint — both reject INVALID_DIRECTIVE here.
+*   `ptz.preset` — preset-recall. Decodes the preset name from the mode
+*     value and calls `ptz.goToPreset({deviceId, presetId})`.
 *
-* Routing:
-*   - `${parent}__${child}` → `brightness.setBrightness({deviceId: child, percentage})`
+*   `ptz.pan`  — momentary pan. `ptz.pan.left|right|center` issues a
+*     continuousMove pulse stopped on a timer; the dropdown reverts to
+*     `center` server-side so subsequent picks re-trigger the move.
 *
-* Auth: same scope-token verification path as the other controllers.
-* The response carries the `Alexa.BrightnessController.brightness`
-* property echoing the new level so the Echo updates its UI without an
-* extra ReportState round-trip.
+*   `ptz.tilt` — momentary tilt. Mirrors ptz.pan with up|down|center.
 */
-var SetBrightnessDirectiveSchema = object({
+var SetModeDirectiveSchema = object({
 	header: object({
-		namespace: literal("Alexa.BrightnessController"),
-		name: literal("SetBrightness")
+		namespace: literal("Alexa.ModeController"),
+		name: literal("SetMode"),
+		instance: string().optional()
 	}),
 	endpoint: EndpointRefSchema,
-	payload: object({ brightness: number().min(0).max(100) })
+	payload: SetModePayloadSchema
 });
-async function handleSetBrightness(header, endpointRaw, payloadRaw, deps, _callerIdentity) {
-	const parsed = SetBrightnessDirectiveSchema.safeParse({
+var PTZ_PRESET_MODE_PREFIX = "ptz.preset.";
+var PTZ_DIRECTION_PULSE_MS = 1e3;
+var PTZ_PAN_MOVES = {
+	"ptz.pan.left": { pan: -1 },
+	"ptz.pan.right": { pan: 1 },
+	"ptz.pan.center": {}
+};
+var PTZ_TILT_MOVES = {
+	"ptz.tilt.up": { tilt: 1 },
+	"ptz.tilt.down": { tilt: -1 },
+	"ptz.tilt.center": {}
+};
+async function handleSetMode(header, endpointRaw, payloadRaw, deps, _callerIdentity) {
+	const parsed = SetModeDirectiveSchema.safeParse({
 		header: {
 			namespace: header.namespace,
-			name: header.name
+			name: header.name,
+			instance: header.instance
 		},
 		endpoint: endpointRaw,
 		payload: payloadRaw ?? {}
 	});
 	if (!parsed.success) return errorEnvelope(header, "INVALID_DIRECTIVE", `payload validation failed: ${parsed.error.message}`);
+	const instance = parsed.data.header.instance;
+	if (instance !== "ptz.preset" && instance !== "ptz.pan" && instance !== "ptz.tilt") return errorEnvelope(header, "INVALID_DIRECTIVE", `ModeController instance not supported: ${instance ?? "(missing)"}`);
 	const endpointId = parsed.data.endpoint.endpointId;
 	const parsedId = parseCameraEndpointId(endpointId);
-	if (parsedId.kind === "autotrack" || parsedId.kind === "privacy") return errorEnvelope(header, "INVALID_DIRECTIVE", `BrightnessController is not exposed on the ${parsedId.kind} endpoint`);
-	if (parsedId.kind === "camera") return errorEnvelope(header, "INVALID_DIRECTIVE", "BrightnessController is not exposed on camera endpoints — direct the directive at the dimmable child accessory");
-	if (parsedId.kind === "invalid") return errorEnvelope(header, "INVALID_DIRECTIVE", parsedId.reason);
-	const percentage = parsed.data.payload.brightness;
+	if (parsedId.kind !== "camera") return errorEnvelope(header, "INVALID_DIRECTIVE", `ModeController only supported on camera endpoints — got ${endpointId}`);
+	const mode = parsed.data.payload.mode;
 	const api = deps.ctx.api;
-	try {
-		await api.brightness.setBrightness.mutate({
-			deviceId: parsedId.childDeviceId,
-			percentage
+	if (instance === "ptz.pan" || instance === "ptz.tilt") {
+		const move = (instance === "ptz.pan" ? PTZ_PAN_MOVES : PTZ_TILT_MOVES)[mode];
+		if (!move) return errorEnvelope(header, "INVALID_DIRECTIVE", `mode '${mode}' is not a valid ${instance} mode`);
+		if (Object.keys(move).length === 0) await api.ptz.stop.mutate({ deviceId: parsedId.deviceId }).catch((err) => {
+			deps.logger.debug("alexa ptz-mode: stop (center) failed (non-fatal)", { meta: {
+				deviceId: parsedId.deviceId,
+				instance,
+				error: err instanceof Error ? err.message : String(err)
+			} });
 		});
-	} catch (err) {
-		const message = err instanceof Error ? err.message : String(err);
-		deps.logger.warn("alexa brightness-controller: setBrightness failed", { meta: {
-			deviceId: parsedId.childDeviceId,
-			percentage,
-			error: message
-		} });
-		return errorEnvelope(header, "INTERNAL_ERROR", `brightness.setBrightness failed: ${message}`);
+		else try {
+			await api.ptz.continuousMove.mutate({
+				deviceId: parsedId.deviceId,
+				...move
+			});
+			setTimeout(() => {
+				api.ptz.stop.mutate({ deviceId: parsedId.deviceId }).catch((err) => {
+					deps.logger.debug("alexa ptz-mode: stop after pulse failed (non-fatal)", { meta: {
+						deviceId: parsedId.deviceId,
+						instance,
+						error: err instanceof Error ? err.message : String(err)
+					} });
+				});
+			}, PTZ_DIRECTION_PULSE_MS);
+		} catch (err) {
+			return errorEnvelope(header, "INTERNAL_ERROR", `ptz.continuousMove failed: ${err instanceof Error ? err.message : String(err)}`);
+		}
+		return modeSuccessResponse(header, endpointId, instance, instance === "ptz.pan" ? "ptz.pan.center" : "ptz.tilt.center");
 	}
+	if (!mode.startsWith(PTZ_PRESET_MODE_PREFIX)) return errorEnvelope(header, "INVALID_DIRECTIVE", `mode '${mode}' is not a ptz.preset mode`);
+	const presetName = mode.slice(11);
+	if (presetName.length === 0) return errorEnvelope(header, "INVALID_DIRECTIVE", "preset name missing after prefix");
+	const preset = (await api.ptz.getPresets.query({ deviceId: parsedId.deviceId })).find((p) => p.name === presetName);
+	if (!preset) return errorEnvelope(header, "INVALID_DIRECTIVE", `preset '${presetName}' not found on device ${parsedId.deviceId}`);
+	await api.ptz.goToPreset.mutate({
+		deviceId: parsedId.deviceId,
+		presetId: preset.id
+	});
+	return modeSuccessResponse(header, endpointId, "ptz.preset", mode);
+}
+function modeSuccessResponse(header, endpointId, instance, mode) {
 	return {
 		event: {
 			header: {
@@ -41089,9 +41526,10 @@ async function handleSetBrightness(header, endpointRaw, payloadRaw, deps, _calle
 			payload: {}
 		},
 		context: { properties: [{
-			namespace: "Alexa.BrightnessController",
-			name: "brightness",
-			value: percentage,
+			namespace: "Alexa.ModeController",
+			instance,
+			name: "mode",
+			value: mode,
 			timeOfSample: (/* @__PURE__ */ new Date()).toISOString(),
 			uncertaintyInMilliseconds: 500
 		}] }
@@ -41112,6 +41550,7 @@ async function handleReportState(header, endpointRaw, deps, _callerIdentity) {
 		else if (parsed.kind === "privacy") await collectPrivacyProperties(api, parsed.parentDeviceId, properties, nowIso, deps.logger);
 		else if (parsed.kind === "autotrack") await collectAutotrackProperties(api, parsed.parentDeviceId, properties, nowIso, deps.logger);
 		else if (parsed.kind === "child") await collectChildProperties(api, parsed.childDeviceId, properties, nowIso, deps.logger);
+		else if (parsed.kind === "alarm-panel") await collectAlarmPanelProperties(api, parsed.deviceId, properties, nowIso, deps.logger);
 	} catch (err) {
 		deps.logger.warn("alexa report-state: collection failed", { meta: {
 			endpointId,
@@ -41173,6 +41612,42 @@ async function collectCameraProperties(api, deviceId, properties, timeOfSample,
 		uncertaintyInMilliseconds: 0
 	});
 }
+/**
+* The panel's two declared properties.
+*
+* Both are omitted when the panel cannot be read — an `armState` we guessed
+* would be a claim about whether a house is locked, and Alexa rendering the
+* endpoint as unavailable is the truthful outcome of a panel nobody reached.
+* The failure is logged with the device id, never swallowed.
+*/
+async function collectAlarmPanelProperties(api, deviceId, properties, timeOfSample, logger) {
+	const status = await api.alarmPanel.getStatus.query({ deviceId }).catch((err) => {
+		logger.warn("alexa report-state: alarmPanel.getStatus FAILED — Alexa will show the panel as unavailable", {
+			tags: { deviceId },
+			meta: { error: err instanceof Error ? err.message : String(err) }
+		});
+		return null;
+	});
+	const parsed = AlarmPanelStatusSchema.pick({ state: true }).safeParse(status);
+	if (!parsed.success) {
+		if (status !== null) logger.warn("alexa report-state: panel status did not match the cap schema — omitting", { tags: { deviceId } });
+		return;
+	}
+	properties.push({
+		namespace: "Alexa.SecurityPanelController",
+		name: "armState",
+		value: alexaArmStateFor(parsed.data.state),
+		timeOfSample,
+		uncertaintyInMilliseconds: 0
+	});
+	properties.push({
+		namespace: "Alexa.SecurityPanelController",
+		name: "burglaryAlarm",
+		value: burglaryAlarmFor(parsed.data.state),
+		timeOfSample,
+		uncertaintyInMilliseconds: 0
+	});
+}
 async function collectPrivacyProperties(api, parentDeviceId, properties, timeOfSample, _logger) {
 	const status = await api.privacyMask.getStatus.query({ deviceId: parentDeviceId }).catch(() => null);
 	const enabled = Boolean(status?.enabled);
@@ -41226,6 +41701,230 @@ async function collectChildProperties(api, childDeviceId, properties, timeOfSamp
 	});
 }
 //#endregion
+//#region src/handlers/security-panel.ts
+var ArmPayloadSchema = object({ armState: _enum([
+	"ARMED_STAY",
+	"ARMED_AWAY",
+	"ARMED_NIGHT"
+]) });
+var DisarmPayloadSchema = object({ authorization: object({
+	type: literal("FOUR_DIGIT_PIN"),
+	value: string().min(1)
+}).optional() });
+/** The subset of the panel status the directives read. */
+var PanelReadSchema = AlarmPanelStatusSchema.pick({
+	state: true,
+	availableModes: true,
+	requiresCode: true
+});
+/**
+* `Alexa.SecurityPanelController.ErrorResponse`.
+*
+* A namespace of its own, because the four types that matter here
+* (`AUTHORIZATION_REQUIRED`, `UNAUTHORIZED`, `NOT_READY_FOR_ARM`,
+* `BYPASS_NEEDED`) are only understood under it — the generic `Alexa`
+* `ErrorResponse` from `error-envelope.ts` carries none of them, and a PIN
+* problem reported there is a message the Alexa app cannot act on.
+*/
+function securityPanelError(header, type, message) {
+	return { event: {
+		header: {
+			namespace: "Alexa.SecurityPanelController",
+			name: "ErrorResponse",
+			messageId: header.messageId,
+			correlationToken: header.correlationToken,
+			payloadVersion: "3"
+		},
+		payload: {
+			type,
+			message
+		}
+	} };
+}
+/** Resolve the alarm panel this directive targets, or the refusal to send. */
+function resolveDeviceId(endpointRaw) {
+	const parsedEndpoint = EndpointRefSchema.safeParse(endpointRaw);
+	if (!parsedEndpoint.success) return { reason: "missing or malformed endpoint" };
+	const parsedId = parseCameraEndpointId(parsedEndpoint.data.endpointId);
+	if (parsedId.kind === "alarm-panel") return { deviceId: parsedId.deviceId };
+	return { reason: `SecurityPanelController is only exposed on alarm-panel endpoints — got '${parsedEndpoint.data.endpointId}'` };
+}
+/**
+* What the panel currently accepts, or `null` when it could not be read.
+*
+* `null` is the honest answer and the callers treat it as unknown; nothing
+* here substitutes a default that would read as "accepts nothing, needs no
+* PIN".
+*/
+async function readPanel(api, deviceId, logger, phase) {
+	const raw = await api.alarmPanel.getStatus.query({ deviceId }).catch((err) => {
+		logger.warn("alexa security-panel: alarmPanel.getStatus failed — proceeding without it", {
+			tags: { deviceId },
+			meta: {
+				phase,
+				error: err instanceof Error ? err.message : String(err)
+			}
+		});
+		return null;
+	});
+	const parsed = PanelReadSchema.safeParse(raw);
+	if (!parsed.success) {
+		if (raw !== null) logger.warn("alexa security-panel: panel status did not match the cap schema", {
+			tags: { deviceId },
+			meta: { phase }
+		});
+		return null;
+	}
+	return parsed.data;
+}
+/** The `context.properties` block for a panel whose state we re-read. */
+function panelProperties(facts, fallback) {
+	const timeOfSample = (/* @__PURE__ */ new Date()).toISOString();
+	const parsedState = facts === null ? null : AlarmPanelStatusSchema.shape.state.parse(facts.state);
+	const armState = parsedState === null ? fallback : alexaArmStateFor(parsedState);
+	const burglary = parsedState === null ? { value: "OK" } : burglaryAlarmFor(parsedState);
+	return [{
+		namespace: "Alexa.SecurityPanelController",
+		name: "armState",
+		value: armState,
+		timeOfSample,
+		uncertaintyInMilliseconds: 0
+	}, {
+		namespace: "Alexa.SecurityPanelController",
+		name: "burglaryAlarm",
+		value: burglary,
+		timeOfSample,
+		uncertaintyInMilliseconds: 0
+	}];
+}
+async function handleArm(header, endpointRaw, payloadRaw, deps, _callerIdentity) {
+	const target = resolveDeviceId(endpointRaw);
+	if (!("deviceId" in target)) return errorEnvelope(header, "INVALID_DIRECTIVE", target.reason);
+	const { deviceId } = target;
+	const payload = ArmPayloadSchema.safeParse(payloadRaw);
+	if (!payload.success) {
+		deps.logger.warn("alexa security-panel: Arm payload is not an arm state Alexa defines", {
+			tags: { deviceId },
+			meta: { error: payload.error.message }
+		});
+		return errorEnvelope(header, "INVALID_DIRECTIVE", `Arm payload unexpected: ${payload.error.message}`);
+	}
+	const requested = payload.data.armState;
+	const api = deps.ctx.api;
+	const facts = await readPanel(api, deviceId, deps.logger, "arm");
+	if (facts?.requiresCode === true) {
+		deps.logger.warn("alexa security-panel: panel requires a PIN and the Arm directive carries none — REFUSED", {
+			tags: { deviceId },
+			meta: { requested }
+		});
+		return securityPanelError(header, "AUTHORIZATION_REQUIRED", "this panel requires a PIN to arm, and Alexa cannot supply one on an Arm directive");
+	}
+	const mode = alarmArmModeForAlexa(requested, facts?.availableModes ?? []);
+	if (mode === null) {
+		deps.logger.warn("alexa security-panel: panel accepts no mode for this arm state — REFUSED", {
+			tags: { deviceId },
+			meta: {
+				requested,
+				availableModes: facts?.availableModes ?? null
+			}
+		});
+		return securityPanelError(header, "NOT_READY_FOR_ARM", `panel does not accept ${requested}`);
+	}
+	try {
+		await api.alarmPanel.arm.mutate({
+			deviceId,
+			mode
+		});
+	} catch (err) {
+		deps.logger.warn("alexa security-panel: arm command failed", {
+			tags: { deviceId },
+			meta: {
+				requested,
+				mode,
+				error: err instanceof Error ? err.message : String(err)
+			}
+		});
+		return securityPanelError(header, "NOT_READY_FOR_ARM", err instanceof Error ? err.message : String(err));
+	}
+	deps.logger.info("alexa security-panel: armed", {
+		tags: { deviceId },
+		meta: {
+			requested,
+			mode
+		}
+	});
+	const after = await readPanel(api, deviceId, deps.logger, "arm-confirm");
+	if (after?.state === "arming") deps.logger.info("alexa security-panel: panel is in its exit delay — reporting DISARMED until it is set", {
+		tags: { deviceId },
+		meta: {
+			requested,
+			mode
+		}
+	});
+	return {
+		event: {
+			header: {
+				namespace: "Alexa.SecurityPanelController",
+				name: "Arm.Response",
+				messageId: header.messageId,
+				correlationToken: header.correlationToken,
+				payloadVersion: "3"
+			},
+			endpoint: { endpointId: `${deviceId}__alarm` },
+			payload: {}
+		},
+		context: { properties: panelProperties(after, requested) }
+	};
+}
+async function handleDisarm(header, endpointRaw, payloadRaw, deps, _callerIdentity) {
+	const target = resolveDeviceId(endpointRaw);
+	if (!("deviceId" in target)) return errorEnvelope(header, "INVALID_DIRECTIVE", target.reason);
+	const { deviceId } = target;
+	const payload = DisarmPayloadSchema.safeParse(payloadRaw ?? {});
+	if (!payload.success) return errorEnvelope(header, "INVALID_DIRECTIVE", `Disarm payload unexpected: ${payload.error.message}`);
+	const code = payload.data.authorization?.value;
+	const api = deps.ctx.api;
+	if ((await readPanel(api, deviceId, deps.logger, "disarm"))?.requiresCode === true && code === void 0) {
+		deps.logger.warn("alexa security-panel: panel requires a PIN and the Disarm directive carried none — REFUSED", { tags: { deviceId } });
+		return securityPanelError(header, "AUTHORIZATION_REQUIRED", "this panel requires a PIN to disarm");
+	}
+	try {
+		await api.alarmPanel.disarm.mutate(code === void 0 ? { deviceId } : {
+			deviceId,
+			code
+		});
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		deps.logger.warn("alexa security-panel: disarm command failed", {
+			tags: { deviceId },
+			meta: {
+				codeSupplied: code !== void 0,
+				error: message
+			}
+		});
+		return code === void 0 ? errorEnvelope(header, "INTERNAL_ERROR", message) : securityPanelError(header, "UNAUTHORIZED", message);
+	}
+	deps.logger.info("alexa security-panel: disarmed", {
+		tags: { deviceId },
+		meta: { codeSupplied: code !== void 0 }
+	});
+	const after = await readPanel(api, deviceId, deps.logger, "disarm-confirm");
+	return {
+		event: {
+			header: {
+				namespace: "Alexa",
+				name: "Response",
+				messageId: header.messageId,
+				correlationToken: header.correlationToken,
+				payloadVersion: "3"
+			},
+			endpoint: { endpointId: `${deviceId}__alarm` },
+			payload: {}
+		},
+		context: { properties: panelProperties(after, "DISARMED") }
+	};
+}
+//#endregion
 //#region src/handlers/stubs.ts
 /**
 * Stub responder for namespaces not yet implemented (CameraStream /
@@ -41305,7 +42004,9 @@ async function dispatchDirective(rawBody, deps, callerIdentity) {
 		"Alexa.ModeController/SetMode": "create",
 		"Alexa.ToggleController/TurnOn": "create",
 		"Alexa.ToggleController/TurnOff": "create",
-		"Alexa/ReportState": "view"
+		"Alexa/ReportState": "view",
+		"Alexa.SecurityPanelController/Arm": "create",
+		"Alexa.SecurityPanelController/Disarm": "create"
 	};
 	try {
 		const key = `${header.namespace}/${header.name}`;
@@ -41350,6 +42051,14 @@ async function dispatchDirective(rawBody, deps, callerIdentity) {
 			status: 200,
 			body: await handlePtzDirection(header, endpoint, deps.ptzDirection, callerIdentity)
 		};
+		if (key === "Alexa.SecurityPanelController/Arm") return {
+			status: 200,
+			body: await handleArm(header, endpoint, payload, deps.securityPanel, callerIdentity)
+		};
+		if (key === "Alexa.SecurityPanelController/Disarm") return {
+			status: 200,
+			body: await handleDisarm(header, endpoint, payload, deps.securityPanel, callerIdentity)
+		};
 		if (key === "Alexa/ReportState") return {
 			status: 200,
 			body: await handleReportState(header, endpoint, deps.reportState, callerIdentity)
@@ -42906,7 +43615,13 @@ var DEFAULT_CONFIG = {
 	enforceIngressToken: false,
 	staleEndpointPurgeInput: ""
 };
-var SUPPORTED_KINDS = ["camera", "doorbell"];
+/** UI filter for the Export picker. `alarm-panel` publishes an
+*  `Alexa.SecurityPanelController` endpoint (`endpoints/builder.ts`). */
+var SUPPORTED_KINDS = [
+	"camera",
+	"doorbell",
+	DeviceType.AlarmPanel
+];
 var ExportAlexaAddon = class extends BaseAddon {
 	lwaGateway = null;
 	syncEngine = null;
@@ -42975,6 +43690,10 @@ var ExportAlexaAddon = class extends BaseAddon {
 				reportState: {
 					ctx: this.ctx,
 					logger: this.ctx.logger
+				},
+				securityPanel: {
+					ctx: this.ctx,
+					logger: this.ctx.logger
 				}
 			},
 			lwaTokensCallbackDeps: {
@@ -43029,6 +43748,11 @@ var ExportAlexaAddon = class extends BaseAddon {
 			});
 		});
 		this.ctx.addDisposer(async () => offTunnelStarted());
+		const reaper = setInterval(() => {
+			this.reapDeadEgressHandles();
+		}, EGRESS_REAP_INTERVAL_MS);
+		reaper.unref?.();
+		this.ctx.addDisposer(async () => clearInterval(reaper));
 		this.ctx.logger.info("export-alexa: initialized", { meta: {
 			exposedCount: this.config.exposed.length,
 			skillMode: this.config.skillMode,
@@ -43683,6 +44407,37 @@ var ExportAlexaAddon = class extends BaseAddon {
 			]
 		}] });
 	}
+	/**
+	* One sweep: ask the broker which held sessions are still alive, and release
+	* the transcodes the dead ones are still holding.
+	*/
+	async reapDeadEgressHandles() {
+		const held = heldEgressHandles();
+		if (held.length === 0) return;
+		const dead = await reapDeadEgressHandles({
+			held,
+			isAlive: async (handle) => {
+				try {
+					return (await this.ctx.api.webrtcSession.getSessionState.query({
+						deviceId: handle.deviceId,
+						sessionId: handle.sessionId
+					})).alive;
+				} catch {
+					return null;
+				}
+			}
+		});
+		for (const handle of dead) {
+			logReaped(this.ctx.logger, handle);
+			forgetEgressHandle(handle);
+			await releaseAlexaEgress({
+				api: this.ctx.api,
+				deviceId: handle.deviceId,
+				pipelineKey: handle.pipelineKey,
+				logger: this.ctx.logger
+			}).catch(() => {});
+		}
+	}
 	async buildDeviceSettingsContribution(deviceId) {
 		if (!await this.isCameraDevice(deviceId)) return null;
 		const entry = this.findEntry(deviceId);
@@ -43690,6 +44445,7 @@ var ExportAlexaAddon = class extends BaseAddon {
 		const enabled = entry !== null;
 		const enabledKey = `alexa:${deviceId}:enabled`;
 		const streamPreferenceKey = `alexa:${deviceId}:streamPreference`;
+		const allowTranscodeKey = `alexa:${deviceId}:allowTranscode`;
 		const linkedCount = this.config.linkedAccounts.length;
 		return {
 			tabs: [{
@@ -43735,6 +44491,19 @@ var ExportAlexaAddon = class extends BaseAddon {
 							equals: true
 						},
 						immediate: true
+					},
+					{
+						type: "boolean",
+						key: allowTranscodeKey,
+						label: "Allow transcoding for Alexa",
+						description: "Let the hub re-encode this camera for the Echo when no stream is directly usable. Off means only a stream Alexa can take as-is (H.264, 480p-1080p) is offered — cheaper, but a camera that publishes only H.265, or only a small sub-stream, will not be streamable to Alexa at all.",
+						style: "switch",
+						value: settings.allowTranscode !== false,
+						showWhen: {
+							field: enabledKey,
+							equals: true
+						},
+						immediate: true
 					}
 				]
 			}]
@@ -43754,26 +44523,17 @@ var ExportAlexaAddon = class extends BaseAddon {
 		const idStr = String(deviceId);
 		const current = this.findEntry(deviceId);
 		const wasEnabled = current !== null;
-		const sourceProfileKey = `alexa:${deviceId}:sourceProfile`;
-		if (sourceProfileKey in patch) {
-			if (!wasEnabled) return { success: true };
-			const currentSettings = current?.settings ?? DEFAULT_DEVICE_SETTINGS;
-			const sourceProfileRaw = patch[sourceProfileKey];
-			const sourceProfile = sourceProfileRaw === "mid" ? "mid" : sourceProfileRaw === "low" ? "low" : "high";
-			await this.patchEntrySettings(deviceId, {
-				...currentSettings,
-				sourceProfile
-			});
-			return { success: true };
-		}
 		const enabledKey = `alexa:${deviceId}:enabled`;
 		const streamPreferenceKey = `alexa:${deviceId}:streamPreference`;
+		const allowTranscodeKey = `alexa:${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 allowTranscode = allowTranscodeKey in patch ? Boolean(patch[allowTranscodeKey]) : current?.settings?.allowTranscode !== false;
 		const nextSettings = {
 			...current?.settings ?? DEFAULT_DEVICE_SETTINGS,
-			streamPreference
+			streamPreference,
+			allowTranscode
 		};
 		if (!enabledValue) {
 			if (wasEnabled) await this.unexposeDevice(idStr);
@@ -43785,13 +44545,22 @@ var ExportAlexaAddon = class extends BaseAddon {
 			return { success: true };
 		}
 		const currentPref = current?.settings?.streamPreference ?? "auto";
+		const currentAllow = current?.settings?.allowTranscode !== false;
 		await this.patchEntrySettings(deviceId, nextSettings);
-		if (currentPref !== streamPreference) {
-			this.ctx.logger.info("export-alexa: streamPreference changed — refreshing exposure", { meta: {
-				deviceId,
-				from: currentPref,
-				to: streamPreference
-			} });
+		if (currentPref !== streamPreference || currentAllow !== allowTranscode) {
+			this.ctx.logger.info("export-alexa: source settings changed — refreshing exposure", {
+				tags: { deviceId },
+				meta: {
+					streamPreference: {
+						from: currentPref,
+						to: streamPreference
+					},
+					allowTranscode: {
+						from: currentAllow,
+						to: allowTranscode
+					}
+				}
+			});
 			try {
 				await this.unexposeDevice(idStr);
 				await this.exposeDevice(idStr);