@camstack/addon-export-alexa 1.2.108 → 1.2.110

package/dist/export-alexa.addon.js

@@ -26,7 +26,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 //#endregion
 let node_crypto = require("node:crypto");
 node_crypto = __toESM(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";
@@ -643,6 +643,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";
@@ -5373,7 +5387,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-DBKu2-U5.mjs
+//#region ../types/dist/sleep-BDR76Ykr.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -7254,6 +7268,28 @@ var DeviceRole = /* @__PURE__ */ function(DeviceRole) {
 	DeviceRole["GenericNotifier"] = "generic-notifier";
 	return DeviceRole;
 }({});
+/**
+* Identity — preserves literal types for downstream inference.
+*
+* The constraint is `Record<string, unknown>` (not `CustomActionsSpec`) so
+* TypeScript does not widen each entry's literal `kind`/`auth` fields to
+* the broader unions declared on `CustomActionSpec`'s default generics.
+* Shape validity is enforced separately by the `customAction(...)` helper
+* whose return type is already a `CustomActionSpec<...>`.
+*/
+function defineCustomActions(spec) {
+	return spec;
+}
+function customAction(input, output, options) {
+	return {
+		input,
+		output,
+		kind: options?.kind ?? "query",
+		auth: options?.auth ?? "protected",
+		scope: options?.scope ?? { kind: "system" },
+		...options?.caller ? { caller: "required" } : {}
+	};
+}
 var StaticDirOutputSchema = object({ staticDir: string() });
 var VersionOutputSchema = object({ version: string() });
 method(_void(), StaticDirOutputSchema, { auth: "admin" }), method(_void(), VersionOutputSchema, { auth: "admin" });
@@ -7560,6 +7596,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.
@@ -9474,6 +9532,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}/`;
@@ -9503,30 +9602,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",
@@ -11740,6 +11832,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",
@@ -12136,6 +12280,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,
@@ -12390,6 +12550,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(),
 	/**
@@ -12406,7 +12576,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({
 	/**
@@ -12420,12 +12605,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()
 });
@@ -12543,28 +12748,6 @@ method(object({}), object({ blocks: array(CoreBlockSchema) }), { auth: "admin" }
 	content: string()
 })) }), { auth: "admin" });
 /**
-* Identity — preserves literal types for downstream inference.
-*
-* The constraint is `Record<string, unknown>` (not `CustomActionsSpec`) so
-* TypeScript does not widen each entry's literal `kind`/`auth` fields to
-* the broader unions declared on `CustomActionSpec`'s default generics.
-* Shape validity is enforced separately by the `customAction(...)` helper
-* whose return type is already a `CustomActionSpec<...>`.
-*/
-function defineCustomActions(spec) {
-	return spec;
-}
-function customAction(input, output, options) {
-	return {
-		input,
-		output,
-		kind: options?.kind ?? "query",
-		auth: options?.auth ?? "protected",
-		scope: options?.scope ?? { kind: "system" },
-		...options?.caller ? { caller: "required" } : {}
-	};
-}
-/**
 * `custom-model-registry` — collection cap exposing operator-registered
 * custom detection models. Each provider (today: `addon-model-studio`)
 * contributes a list of `CustomModelDescriptor`s; the hub auto-concatenates
@@ -16661,6 +16844,8 @@ var NcSystemEventKindSchema = _enum([
 	"device-enabled",
 	"device-battery-low",
 	"device-battery-normal",
+	"device-consumable-low",
+	"device-consumable-normal",
 	"stream-online",
 	"stream-offline",
 	"node-online",
@@ -16679,6 +16864,7 @@ var NcSystemEventKindSchema = _enum([
 	"addon-updated",
 	"server-updated",
 	"export-completed",
+	"backup-completed",
 	"camera-online",
 	"camera-offline",
 	"camera-disabled",
@@ -18001,6 +18187,48 @@ var NcAlarmConfigSchema = object({
 	settings: NcAlarmSettingsSchema,
 	coverage: array(NcAlarmModeCoverageSchema)
 });
+/**
+* ONE rule's demand on ONE camera's clip ring.
+*
+* A rule, not a camera: the broker takes the MAX over the asks that reach a
+* camera, so the answer stays a faithful description of the rules and the
+* bounding (the byte budget, the broker's own ceiling) stays where the cost
+* lives. A camera that appears in no ask is being told **nothing** — which is
+* a different thing from never having been told, and only the envelope
+* (`rulesLoaded`) can tell those apart.
+*/
+var NcClipRetentionAskSchema = object({
+	/**
+	* The camera this ask is about. **Absent = every camera**, which is what a
+	* rule with no `conditions.devices` means: it can fire anywhere, so it is
+	* asking everywhere.
+	*/
+	deviceId: number().int().nonnegative().optional(),
+	/** Seconds of history the rule needs held for it. Never zero — a rule that
+	*  needs nothing produces no ask at all. */
+	seconds: number().min(0).max(60),
+	/** The profile the rule cuts from, when it named one. Absent = the cheapest
+	*  assigned, which is what the cut defaults to. */
+	profile: CamProfileSchema.optional(),
+	/** Who is asking — so a retention the operator did not expect names a rule. */
+	ruleId: string(),
+	ruleName: string(),
+	/** Why this many seconds: the rule's own window, or the occupancy ceiling. */
+	reason: _enum(["window", "occupancy"])
+});
+/**
+* The whole answer, with the one bit that keeps absence from reading as zero.
+*
+* `rulesLoaded` is false until the rule ledger has completed a load at least
+* once. A centre that is up but has not read its rules yet answers with an
+* empty ask list that means nothing at all — applying it would drop every
+* camera's ring to zero for the first events after a restart, which is the
+* footage this mechanism exists to keep.
+*/
+var NcClipRetentionPlanSchema = object({
+	rulesLoaded: boolean(),
+	asks: array(NcClipRetentionAskSchema).readonly()
+});
 method(object({}), object({ rules: array(NcRuleSchema) }), { auth: "admin" }), method(object({ ruleId: string() }), object({ rule: NcRuleSchema.nullable() }), { auth: "admin" }), method(object({ rule: NcRuleInputSchema }), object({ rule: NcRuleSchema }), {
 	kind: "mutation",
 	auth: "admin",
@@ -18021,7 +18249,7 @@ method(object({}), object({ rules: array(NcRuleSchema) }), { auth: "admin" }), m
 }), object({ success: literal(true) }), {
 	kind: "mutation",
 	auth: "admin"
-}), method(object({}), object({ mutedDeviceIds: array(number().int()).readonly() }), { auth: "admin" }), method(object({
+}), method(object({}), NcClipRetentionPlanSchema, { auth: "admin" }), method(object({}), object({ mutedDeviceIds: array(number().int()).readonly() }), { auth: "admin" }), method(object({
 	deviceId: number().int(),
 	muted: boolean()
 }), object({ success: literal(true) }), {
@@ -20571,6 +20799,33 @@ var RunReplayFrameProcessorResultSchema = object({ tracks: array(object({
 	*  solid is this track", cheaper than re-deriving it from a trajectory. */
 	framesMatched: number().int()
 })).readonly() });
+/**
+* The long-term series a camera produces. A closed union so a typo cannot
+* invent one, and the ONE declaration of it — the addon's `AnalyticsLtsSeries`
+* is an alias of this, not a second list.
+*/
+var AnalyticsLtsSeriesSchema = _enum([
+	"motion",
+	"audio-dbfs",
+	"battery",
+	"occupancy"
+]);
+/**
+* One closed 5-minute bucket of a long-term series.
+*
+* `samples` is how many readings the bucket folded — it is the ACTIVITY for a
+* series like `motion`, and the confidence for one like `occupancy`. A bucket
+* that exists at all was measured; a bucket that is absent was not, which is a
+* different claim from zero and the reason this is a sparse series.
+*/
+var LtsBucketSchema = object({
+	scope: string(),
+	bucketStart: number().int(),
+	samples: number().int().nonnegative(),
+	sum: number(),
+	min: number(),
+	max: number()
+});
 DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).readonly()), method(object({
 	deviceId: number(),
 	trackId: string()
@@ -20617,6 +20872,14 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
 	kinds: array(string()).optional(),
 	limit: number().int().min(1).max(MAX_EVENT_QUERY_LIMIT).default(DEFAULT_EVENT_QUERY_LIMIT)
 }), array(SensorEventSchema).readonly()), method(KeyEventQueryInput, array(KeyEventSchema).readonly()), method(KeyEventBatchQueryInput, array(KeyEventsForDeviceSchema).readonly()), method(object({
+	deviceId: number(),
+	series: AnalyticsLtsSeriesSchema,
+	/** Omit for EVERY scope of this series in the range. */
+	scope: string().optional(),
+	from: number(),
+	to: number(),
+	limit: number().int().positive().optional()
+}), array(LtsBucketSchema).readonly()), method(object({
 	deviceId: number(),
 	since: number(),
 	until: number(),
@@ -21235,6 +21498,14 @@ var MotionSourceEnum = _enum([
 */
 var MotionSourcesSchema = array(MotionSourceEnum);
 /**
+* Which root detectors a camera runs. Deliberately the SAME vocabulary
+* post-analysis already tags every detection with (`DetectionSource`) rather
+* than a second spelling of the same two ideas — the value an operator picks
+* here is the value that comes back on the track, the overlay and the debug
+* row.
+*/
+var DetectionSourcesSchema = array(DetectionSourceSchema);
+/**
 * Input shape for `pipeline-runner.reportMotion` cap method. Exported
 * so cap-side consumers (the orchestrator forward, the runner addon's
 * cap implementation, tests) can reuse the type instead of redeclaring
@@ -21385,6 +21656,35 @@ var RunnerCameraConfigSchema = object({
 	*   events; the orchestrator forwards to `reportMotion`.
 	*/
 	motionSources: MotionSourcesSchema.default(["analyzer"]),
+	/**
+	* WHICH root detector runs for this camera. The detection counterpart of
+	* {@link motionSources}, same shape and same discipline: a per-camera list
+	* of sources the system understands, vendor-agnostic, owned here.
+	*
+	* - `pipeline` — this runner's own root step on decoded pixels (`steps`).
+	* - `onboard` — the CAMERA's own detector, admitted only when it is named
+	*   here. Its boxes reach post-analysis on the same
+	*   `PipelineInferenceResult` payload as the pipeline's, so an onboard-born
+	*   track gets the same tracker, the same overlay and the same detail
+	*   subtree (face / plate / embedding).
+	*
+	* `['onboard']` alone is the REPLACEMENT: this runner's root step does not
+	* run, and that is where a camera with a usable onboard detector buys back
+	* its share of the accelerator. It saves the root inference, not the decode
+	* — the detail subtree still needs pixels to cut crops from.
+	*
+	* A camera whose onboard detections carry no geometry cannot serve as a root
+	* step at all (there is nothing to track), and the cap that knows this says
+	* so on `native-object-detection.getOptions().geometry`. On Reolink that is
+	* every battery camera: the boxes ride a sub-stream a battery camera never
+	* attaches, so such a camera stays on `['pipeline']` and its onboard AI is
+	* worth exactly what it already is — a wake signal with a class.
+	*
+	* Defaults to `['pipeline']`, which is byte-for-byte today's behaviour: a
+	* vendor never turns a detector on for the operator, and neither does a
+	* default.
+	*/
+	detectionSources: DetectionSourcesSchema.default(["pipeline"]),
 	pipelineEnabled: boolean().default(true),
 	/** Ordered tree of video steps. Absent → runner skips video detection. */
 	steps: array(PipelineStepInputSchema).readonly().optional(),
@@ -21566,7 +21866,47 @@ var RunnerLocalMetricsSchema = object({
 	queueDepth: number(),
 	frameLazy: FrameLazyMetricsSchema.optional()
 });
+/**
+* Pipeline Runner capability — runtime detection workhorse.
+*
+* One instance per node. Receives camera assignments from
+* `addon-pipeline-orchestrator`, subscribes to the local stream-broker for
+* decoded frames, drains motion + detection queues, calls the local
+* `motion-detection` and `pipeline-executor` capabilities, and emits typed
+* `pipeline.inference-result` and `detection.motion-analysis` events on
+* the bus.
+*
+* Distinct from `pipeline-orchestrator` (the hub-side load balancer) — the
+* runner has zero knowledge of other agents, no global state, and never
+* makes assignment decisions itself.
+*/
+/**
+* Why a runner declined to look at a camera out of band. Named rather than a
+* bare `false`: a camera asleep on battery (D173), one attached elsewhere, one
+* already mid-session and one already bursting are four different facts, and a
+* caller told only "no" cannot tell a protection from a bug.
+*/
+var OccupancyBurstRefusalSchema = _enum([
+	"not-attached",
+	"battery-asleep",
+	"not-watching",
+	"already-bursting"
+]);
 method(RunnerCameraConfigSchema, object({ success: literal(true) }), { kind: "mutation" }), method(object({ deviceId: number() }), object({ success: literal(true) }), { kind: "mutation" }), method(ReportMotionInputSchema, object({ success: literal(true) }), { kind: "mutation" }), method(_void(), RunnerLocalLoadSchema), method(_void(), RunnerLocalMetricsSchema), method(object({ deviceId: number() }), CameraMetricsSchema.nullable()), method(_void(), array(CameraMetricsWithDeviceIdSchema).readonly()), method(_void(), array(number()).readonly()), method(object({
+	deviceId: number(),
+	/** How many frames to collect. The caller sizes this against what its
+	*  own confirmation needs; the runner clamps it to the field's range. */
+	frames: number().int().positive().optional(),
+	/** Why, for the log. A burst nobody can attribute is a cost nobody can
+	*  defend — the periodic one at least has a timer to point at. */
+	reason: string()
+}), object({
+	started: boolean(),
+	refusedBecause: OccupancyBurstRefusalSchema.optional()
+}), {
+	auth: "admin",
+	kind: "mutation"
+}), method(object({
 	handle: FrameHandleSchema,
 	bbox: NativeCropBboxSchema,
 	maxWidth: number().int().positive().optional(),
@@ -23936,10 +24276,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(),
@@ -27017,7 +27375,7 @@ var NativeDetectionSchema = object({
 	/** Firmware-provided confidence [0..1]. Reolink pushes don't carry it → undefined. */
 	confidence: number().min(0).max(1).optional()
 });
-object({
+var NativeObjectDetectionStatusSchema = object({
 	/**
 	* Last observed instance per class. Missing entries mean the class
 	* is supported but nothing has been seen since the provider started.
@@ -27034,14 +27392,56 @@ object({
 	supportedClasses: array(NativeObjectClassEnum).readonly(),
 	/**
 	* Whether forwarding of onboard AI detections is enabled for this device.
-	* Default FALSE (opt-in, cold-start) — onboard AI pushes are noisy/sparse and
-	* churn the tracker, so forwarding stays off until the operator enables it.
+	*
+	* Cold-start OFF on every camera. A vendor does not decide which detector a
+	* camera runs — that is the operator's choice, and it is made where every
+	* other detection choice is made. `geometry` on
+	* {@link NativeObjectDetectionOptionsSchema} is how the form says what the
+	* choice would buy this particular camera.
 	*/
 	enabled: boolean()
-}).extend({ 
+});
+/**
+* WHEN a camera's onboard detections carry geometry.
+*
+* - `boxed` — always. The provider holds a standing channel for the boxes, so
+*   a detection is a trackable subject whenever the camera sees one.
+* - `while-streaming` — only while some stream of this camera is already open.
+*   The boxes ride the video's own side-channel rather than a feed of their
+*   own, so they cost nothing and they exist only when something is pulling.
+*   On Reolink this is every BATTERY camera: a persistent second feed is real
+*   radio drain, but a camera that is awake is awake precisely because
+*   something is in front of it, and its stream is already being pulled.
+* - `flag-only` — never. The firmware ships the class and nothing else; the
+*   pipeline needs geometry to make a subject, so such a push reaches the
+*   tracker as motion and no further.
+*
+* Reported and not inferred, because the operator's question in front of the
+* picker is "what do I get", and these are three different answers (D14: the
+* derived form is only as honest as `getOptions`).
+*/
+var NativeObjectGeometryEnum = _enum([
+	"boxed",
+	"while-streaming",
+	"flag-only"
+]);
+var NativeObjectDetectionOptionsSchema = object({
+	/** Classes this firmware can detect — the same list the status reports. */
+	supportedClasses: array(NativeObjectClassEnum).readonly(),
+	/** What a detection from this camera carries. */
+	geometry: NativeObjectGeometryEnum
+});
+var NativeObjectDetectionSettingsPatchSchema = object({ enabled: boolean().optional() });
+NativeObjectDetectionStatusSchema.extend({ 
 /** Required by createRuntimeStateBridge — epoch ms of last refresh. */
 lastFetchedAt: number() });
-DeviceType.Camera, method(object({
+DeviceType.Camera, method(object({ deviceId: number() }), NativeObjectDetectionOptionsSchema), method(object({
+	deviceId: number(),
+	settings: NativeObjectDetectionSettingsPatchSchema
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
 	deviceId: number(),
 	enabled: boolean()
 }), _void(), {
@@ -30840,7 +31240,28 @@ var PerScopeBreakdownSchema = object({
 	/** Total tracked objects in this scope (frame / zone / unzoned). */
 	totalObjects: number().int().nonnegative(),
 	/** Per-class count. Keys are macro class names (e.g. `person`, `car`). */
-	byClass: record(string(), number().int().nonnegative())
+	byClass: record(string(), number().int().nonnegative()),
+	/**
+	* Of `totalObjects`, how many are STANDING — objects the census holds,
+	* present but not going anywhere (a parked car, a bin, a statue).
+	*
+	* The operator's question about a scene has two halves and they answer
+	* different things: "what is parked here" is stable for hours and must not
+	* flap, while "who is walking through" is the thing an alert is about. One
+	* number could only serve one of them, and `totalObjects` served the first
+	* badly — a passer-by moved it and every occupancy rule saw a change.
+	*
+	* `standing + transient === totalObjects`, always. The total keeps its old
+	* meaning exactly, so no rule written against it changes behaviour.
+	*
+	* ABSENT means UNKNOWN, never zero (D393): a snapshot from a node older than
+	* this field cannot say, and a reader that folds absence in as 0 reports "no
+	* parked objects here" about a camera whose lot is full.
+	*/
+	standingObjects: number().int().nonnegative().optional(),
+	/** Of `totalObjects`, how many are passing through. See `standingObjects` —
+	*  same absence rule. */
+	transientObjects: number().int().nonnegative().optional()
 });
 var ZoneScopeBreakdownSchema = PerScopeBreakdownSchema.extend({
 	zoneId: string(),
@@ -33779,12 +34200,24 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"nativeObjectDetection.getOptions": {
+		capName: "native-object-detection",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"nativeObjectDetection.setEnabled": {
 		capName: "native-object-detection",
 		capScope: "device",
 		addonId: null,
 		access: "create"
 	},
+	"nativeObjectDetection.setSettings": {
+		capName: "native-object-detection",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"navigation.getFeatures": {
 		capName: "navigation",
 		capScope: "device",
@@ -34049,6 +34482,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"notificationRules.getClipRetentionAsks": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"notificationRules.getConditionCatalog": {
 		capName: "notification-rules",
 		capScope: "system",
@@ -34559,6 +34998,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineAnalytics.readLongTermSeries": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.rebuildObjectEmbeddings": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -35231,6 +35676,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineRunner.requestOccupancyBurst": {
+		capName: "pipeline-runner",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineRunner.runDetailSubtree": {
 		capName: "pipeline-runner",
 		capScope: "system",
@@ -36443,6 +36894,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",
@@ -36527,6 +36984,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"streamSignals.listSignals": {
+		capName: "stream-signals",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"switch.setState": {
 		capName: "switch",
 		capScope: "device",
@@ -37999,11 +38462,21 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"nativeObjectDetection.getOptions": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"nativeObjectDetection.setEnabled": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
+	"nativeObjectDetection.setSettings": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"navigation.getFeatures": [{
 		name: "deviceId",
 		form: "single",
@@ -38353,6 +38826,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"pipelineAnalytics.readLongTermSeries": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"pipelineAnalytics.rebuildObjectEmbeddings": [{
 		name: "deviceId",
 		form: "single",
@@ -38543,6 +39021,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"pipelineRunner.requestOccupancyBurst": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"pipelineRunner.runDetailSubtree": [{
 		name: "deviceId",
 		form: "single",
@@ -38899,6 +39382,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"streamBroker.reportStreamSignal": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"streamBroker.restartProfile": [{
 		name: "deviceId",
 		form: "single",
@@ -39729,7 +40217,7 @@ async function acquireAlexaEgress(input) {
 			profile: sourceProfile
 		},
 		encode: ALEXA_EGRESS_PROFILE,
-		rateControl: "relaxed",
+		rateControl: "tight",
 		publishLocally: true,
 		tag: `alexa/${sessionId}`
 	});
@@ -39753,6 +40241,7 @@ async function acquireAlexaEgress(input) {
 		meta: {
 			pipelineKey: transcode.pipelineKey,
 			camStreamId,
+			sourceProfile: input.sourceProfile,
 			encoder: transcode.encoder,
 			decodeHwAccel: transcode.decodeHwAccel ?? "software"
 		}
@@ -39786,6 +40275,512 @@ 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
+* that we actually parse hub-side. The Smart Home Skill API ships
+* thousands of optional fields per namespace — we only validate what
+* we read; everything else passes through as `unknown`.
+*
+* Reference: https://developer.amazon.com/en-US/docs/alexa/smarthome/smart-home-skill-api-message-reference.html
+*/
+/** A directive header carries namespace + name + token + correlation id. */
+var DirectiveHeaderSchema = object({
+	namespace: string(),
+	name: string(),
+	payloadVersion: string(),
+	messageId: string(),
+	correlationToken: string().optional()
+});
+/** Scope carries the bearer token Alexa minted via our OAuth provider. */
+var BearerScopeSchema = object({
+	type: literal("BearerToken"),
+	token: string()
+});
+/** Endpoint reference inside a directive payload. */
+var EndpointRefSchema = object({
+	endpointId: string(),
+	scope: BearerScopeSchema.optional(),
+	cookie: record(string(), string()).optional()
+});
+var DiscoveryDirectiveSchema = object({
+	header: DirectiveHeaderSchema.extend({
+		namespace: literal("Alexa.Discovery"),
+		name: literal("Discover")
+	}),
+	payload: object({ scope: BearerScopeSchema })
+});
+/** Envelope wrapping a directive on the Alexa→skill wire. */
+var DirectiveRequestSchema = object({ directive: object({
+	header: DirectiveHeaderSchema,
+	endpoint: EndpointRefSchema.optional(),
+	payload: unknown().optional()
+}) });
+var InitializeCameraStreamsPayloadSchema = object({ cameraStreams: array(object({
+	protocol: string(),
+	resolution: object({
+		width: number(),
+		height: number()
+	}).optional(),
+	authorizationType: string().optional(),
+	videoCodec: string().optional(),
+	audioCodec: string().optional()
+})).optional() });
+var InitiateSessionWithOfferPayloadSchema = object({
+	sessionId: string(),
+	offer: object({
+		format: string().optional(),
+		value: string()
+	})
+});
+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
@@ -40216,101 +41211,6 @@ function buildAlarmPanelEndpoint(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"
-		},
-		payload: {
-			type,
-			message
-		}
-	} };
-}
-//#endregion
-//#region src/handlers/types.ts
-/**
-* Zod schemas for the subset of the Alexa Smart Home directive surface
-* that we actually parse hub-side. The Smart Home Skill API ships
-* thousands of optional fields per namespace — we only validate what
-* we read; everything else passes through as `unknown`.
-*
-* Reference: https://developer.amazon.com/en-US/docs/alexa/smarthome/smart-home-skill-api-message-reference.html
-*/
-/** A directive header carries namespace + name + token + correlation id. */
-var DirectiveHeaderSchema = object({
-	namespace: string(),
-	name: string(),
-	payloadVersion: string(),
-	messageId: string(),
-	correlationToken: string().optional()
-});
-/** Scope carries the bearer token Alexa minted via our OAuth provider. */
-var BearerScopeSchema = object({
-	type: literal("BearerToken"),
-	token: string()
-});
-/** Endpoint reference inside a directive payload. */
-var EndpointRefSchema = object({
-	endpointId: string(),
-	scope: BearerScopeSchema.optional(),
-	cookie: record(string(), string()).optional()
-});
-var DiscoveryDirectiveSchema = object({
-	header: DirectiveHeaderSchema.extend({
-		namespace: literal("Alexa.Discovery"),
-		name: literal("Discover")
-	}),
-	payload: object({ scope: BearerScopeSchema })
-});
-/** Envelope wrapping a directive on the Alexa→skill wire. */
-var DirectiveRequestSchema = object({ directive: object({
-	header: DirectiveHeaderSchema,
-	endpoint: EndpointRefSchema.optional(),
-	payload: unknown().optional()
-}) });
-var InitializeCameraStreamsPayloadSchema = object({ cameraStreams: array(object({
-	protocol: string(),
-	resolution: object({
-		width: number(),
-		height: number()
-	}).optional(),
-	authorizationType: string().optional(),
-	videoCodec: string().optional(),
-	audioCodec: string().optional()
-})).optional() });
-var InitiateSessionWithOfferPayloadSchema = object({
-	sessionId: string(),
-	offer: object({
-		format: string().optional(),
-		value: string()
-	})
-});
-var SessionDisconnectedPayloadSchema = object({ sessionId: string() });
-var SetModePayloadSchema = object({ mode: string() });
-//#endregion
 //#region src/handlers/discovery.ts
 var discoveryPayloadSchema = DiscoveryDirectiveSchema.shape.payload;
 /** Devices built at once in `handleDiscovery` — latency-bound tRPC reads, so
@@ -40519,60 +41419,6 @@ 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
-		};
-	}
-	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/brightness-controller.ts
 var SetBrightnessDirectiveSchema = object({
 	header: object({
@@ -41149,254 +41995,6 @@ async function collectChildProperties(api, childDeviceId, properties, timeOfSamp
 	});
 }
 //#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/security-panel.ts
 var ArmPayloadSchema = object({ armState: _enum([
 	"ARMED_STAY",
@@ -43444,6 +44042,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,
@@ -44098,6 +44701,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);
@@ -44105,6 +44739,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: [{
@@ -44150,6 +44785,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
 					}
 				]
 			}]
@@ -44169,26 +44817,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);
@@ -44200,13 +44839,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);