@camstack/system 1.2.262 → 1.2.264

package/dist/builtins/camera-grid/index.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-6hiXbrNY.js");
+const require_dist = require("../../dist-BhYweLVr.js");
 let zod = require("zod");
 let _camstack_types_node = require("@camstack/types/node");
 let node_path = require("node:path");
@@ -197,6 +197,10 @@ var GridCameraDevice = class extends require_dist.BaseDevice {
 			getSnapshot: async ({ deviceId }) => activeRuntime().getSnapshot(deviceId),
 			invalidateCache: async () => {}
 		});
+		this.ctx.registerNativeCap(require_dist.motionCapability, {
+			getStatus: async ({ deviceId }) => activeRuntime().motionStatus(deviceId),
+			isDetected: async ({ deviceId }) => activeRuntime().motionStatus(deviceId).detected
+		});
 		this.markOnline(true);
 	}
 	catalog() {
@@ -400,6 +404,330 @@ function normalizeGridRows(raw, mintId) {
 	};
 }
 //#endregion
+//#region src/builtins/camera-grid/grid-activity-mirror.ts
+/**
+* What a grid says about ITSELF, kept from what its sources said.
+*
+* ## Why the grid answers at all
+*
+* A grid is a camera, and the viewer already knows how to light a camera: the
+* motion ring keys off `motion.on-motion-changed` filtered by `deviceId`, the
+* audio one off `pipeline.audio-inference-result`. So the grid does not need a
+* new channel, a new cap or a line of app code — it needs to answer those
+* questions about its own device id. The operator set both rules: motion is on
+* if AT LEAST ONE source has it, and the audio level is the LOUDEST of them.
+*
+* It is derived from the SOURCES' events and never from the composed picture.
+* Analysing the composite would be a second motion authority for cameras that
+* already have one, and a decode this addon does not pay today.
+*
+* ## The falling edge is the whole difficulty
+*
+* Bus events are telemetry and may be dropped (D8/D11). A lost `detected:
+* false` would leave a grid lit for ever, and the grid has no phase machine to
+* produce a falling edge of its own — a real camera's comes from the pipeline
+* runner, which a grid deliberately does not run.
+*
+* So a source's motion is remembered WITH ITS TIME and expires on its own. That
+* is D49's shape: in-memory state refreshed off the event path, never a gate
+* that re-reads something fallible in order to decide. A dropped clear costs a
+* ring that stays lit until the expiry instead of for ever, and a subject that
+* is genuinely still there keeps renewing it.
+*
+* The expiry is `MOTION_CLOSE_AFTER_MS`, imported and not re-spelled: it is the
+* system's one answer to "how long after the last push is a camera still
+* moving", and a second number here would be a second authority disagreeing
+* with the first on exactly the cameras that make up the grid.
+*/
+/**
+* How long an audio reading counts as current.
+*
+* The analyzer emits one per window per camera, so a source that has gone quiet
+* simply stops arriving — there is no "silence" event to wait for. Without a
+* window the loudest reading of the day would be the grid's level for ever.
+* Chosen to span several analysis windows so an ordinary gap does not blink the
+* level away, and to be far shorter than a person notices a stale ring.
+*/
+var AUDIO_FRESH_MS = 5e3;
+var GridActivityMirror = class {
+	motion = /* @__PURE__ */ new Map();
+	audio = /* @__PURE__ */ new Map();
+	lastDetectedAt = null;
+	/** One source's motion push. `detected: false` is as important as `true`. */
+	noteMotion(sourceDeviceId, detected, atMs) {
+		this.motion.set(sourceDeviceId, {
+			detected,
+			atMs
+		});
+		if (detected) this.lastDetectedAt = Math.max(this.lastDetectedAt ?? 0, atMs);
+	}
+	/** One source's audio window. `dbfs` is the level, on the analyzer's scale. */
+	noteAudio(sourceDeviceId, dbfs, atMs) {
+		this.audio.set(sourceDeviceId, {
+			dbfs,
+			atMs
+		});
+	}
+	/**
+	* Drop every source this grid no longer composes.
+	*
+	* A cell removed while its camera was moving would otherwise hold the grid
+	* lit until the expiry, for a picture the source is not even in.
+	*/
+	keepOnly(sourceDeviceIds) {
+		const keep = new Set(sourceDeviceIds);
+		const motionIds = Array.from(this.motion.keys());
+		const audioIds = Array.from(this.audio.keys());
+		for (const id of motionIds) if (!keep.has(id)) this.motion.delete(id);
+		for (const id of audioIds) if (!keep.has(id)) this.audio.delete(id);
+	}
+	/** At least one source moving, as of `nowMs`. */
+	motionAt(nowMs) {
+		let detected = false;
+		for (const state of this.motion.values()) {
+			if (!state.detected) continue;
+			if (nowMs - state.atMs > 15e3) continue;
+			detected = true;
+			break;
+		}
+		return {
+			detected,
+			lastDetectedAt: this.lastDetectedAt
+		};
+	}
+	/**
+	* The loudest CURRENT reading, or `null` when nothing fresh has been heard.
+	*
+	* Null and not `-Infinity`: "nobody has reported a level" is a different
+	* answer from "it is silent", and a number here would have the viewer draw a
+	* level for a grid whose sources are not being analysed at all.
+	*/
+	loudestAt(nowMs) {
+		let loudest = null;
+		for (const state of this.audio.values()) {
+			if (nowMs - state.atMs > AUDIO_FRESH_MS) continue;
+			if (loudest === null || state.dbfs > loudest) loudest = state.dbfs;
+		}
+		return loudest;
+	}
+};
+//#endregion
+//#region src/builtins/camera-grid/grid-detection-mapping.ts
+/**
+* Where this detection lands on the canvas — once per cell that shows it.
+*
+* Empty is a real answer: the subject is in a part of the source this grid does
+* not display, or the frame arrived with no size to measure against. Neither is
+* a reason to guess.
+*/
+function mapDetectionToCanvas(input) {
+	const { width: frameW, height: frameH } = input.sourceFrame;
+	if (frameW <= 0 || frameH <= 0) return [];
+	const left = input.bbox.x / frameW;
+	const top = input.bbox.y / frameH;
+	const right = (input.bbox.x + input.bbox.width) / frameW;
+	const bottom = (input.bbox.y + input.bbox.height) / frameH;
+	const out = [];
+	for (const { source, cell } of input.cells) {
+		if (source.width <= 0 || source.height <= 0) continue;
+		const l = Math.max(left, source.x);
+		const t = Math.max(top, source.y);
+		const r = Math.min(right, source.x + source.width);
+		const b = Math.min(bottom, source.y + source.height);
+		if (r <= l || b <= t) continue;
+		const cx = (l - source.x) / source.width;
+		const cy = (t - source.y) / source.height;
+		const cw = (r - l) / source.width;
+		const ch = (b - t) / source.height;
+		out.push({
+			x: (cell.x + cx * cell.width) * input.canvas.width,
+			y: (cell.y + cy * cell.height) * input.canvas.height,
+			width: cw * cell.width * input.canvas.width,
+			height: ch * cell.height * input.canvas.height
+		});
+	}
+	return out;
+}
+//#endregion
+//#region src/builtins/camera-grid/grid-activity.ts
+/**
+* The grid's own motion / audio / detection, forwarded from its sources.
+*
+* ## Why the grid speaks a camera's language instead of a new one
+*
+* The operator asked for the grid's tile to light up in the viewer exactly as a
+* camera's card does, with NO app change. The app already knows how: it filters
+* `motion.on-motion-changed` by `deviceId` for the motion ring,
+* `pipeline.audio-inference-result` for the audio one, and `detection.result`
+* for the detection one. So the grid answers those three questions about its
+* own device id, in the same shapes. Nothing new is invented, and nothing in
+* the viewer is touched.
+*
+* The rules are the operator's: motion if AT LEAST ONE source has it, and the
+* LOUDEST source's level for audio.
+*
+* ## What speaking a camera's language costs, and why it is safe here
+*
+* Those categories have other listeners, and emitting on them makes the grid a
+* motion source for the whole system. Checked, one by one, before shipping:
+* the recorder's event capture, the HomeKit and Alexa exports and the Home
+* Assistant export are all per-device and do nothing until an operator enables
+* them for this camera — and if an operator DOES export a grid to HomeKit, a
+* grid reporting motion is correct, not a surprise.
+*
+* The one listener with no gate of its own was `pipeline-analytics`, which
+* would have opened a motion EPISODE per grid, duplicating the rows its sources
+* already write. Its gate turned out to be the `pipeline-analytics` WRAPPER
+* BINDING, so the answer is the one the operator gave: a derived camera is
+* created with the analytics wrappers OFF (`grid-analytics-defaults.ts`).
+* That is a binding, not a new flag, so an operator who wants a grid analysed
+* can simply turn it back on.
+*
+* ## Detection carries boxes whether or not anyone wanted them
+*
+* `detection.result` is the same event the viewer draws BOXES from, so a grid
+* that reports detections reports boxes. Sending the source's own pixel box
+* would draw it against the composed canvas at confidently wrong coordinates,
+* so every box is carried through the cell geometry first
+* (`grid-detection-mapping.ts`) and lands where the subject actually is.
+*/
+/**
+* One mirror per grid, and the emission that follows an update.
+*
+* Deliberately NOT one mirror per source: the question is always "is THIS grid
+* lit", and a source shared by two grids answers it twice, differently, because
+* the other cells differ.
+*/
+var GridActivityForwarder = class {
+	deps;
+	mirrors = /* @__PURE__ */ new Map();
+	constructor(deps) {
+		this.deps = deps;
+	}
+	/** A source camera's motion push. */
+	onSourceMotion(sourceDeviceId, detected, atMs) {
+		for (const grid of this.deps.gridsForSource(sourceDeviceId)) {
+			const mirror = this.mirrorFor(grid);
+			const before = mirror.motionAt(atMs).detected;
+			mirror.noteMotion(sourceDeviceId, detected, atMs);
+			const after = mirror.motionAt(atMs);
+			if (after.detected === before) continue;
+			this.emitMotion(grid.deviceId, after, atMs);
+		}
+	}
+	/** A source camera's audio window. */
+	onSourceAudio(sourceDeviceId, dbfs, atMs) {
+		for (const grid of this.deps.gridsForSource(sourceDeviceId)) {
+			const mirror = this.mirrorFor(grid);
+			mirror.noteAudio(sourceDeviceId, dbfs, atMs);
+			const loudest = mirror.loudestAt(atMs);
+			if (loudest === null) continue;
+			this.emitAudio(grid.deviceId, loudest, atMs);
+		}
+	}
+	/** A source camera's detection frame, with its boxes in SOURCE pixels. */
+	onSourceDetections(frame) {
+		for (const grid of this.deps.gridsForSource(frame.deviceId)) {
+			const cells = grid.cellsForSource(frame.deviceId);
+			if (cells.length === 0) continue;
+			const detections = [];
+			for (const detection of frame.detections) for (const bbox of mapDetectionToCanvas({
+				bbox: detection.bbox,
+				sourceFrame: {
+					width: frame.width,
+					height: frame.height
+				},
+				canvas: grid.canvas,
+				cells
+			})) {
+				const { refinedBbox: _refined, mask: _mask, ...rest } = detection;
+				detections.push({
+					...rest,
+					bbox
+				});
+			}
+			if (detections.length === 0) continue;
+			this.emitDetections(grid, frame, detections);
+		}
+	}
+	/** The grid's own motion answer, for `motion.getStatus`. */
+	motionStatusFor(deviceId, nowMs) {
+		return this.mirrors.get(deviceId)?.motionAt(nowMs) ?? {
+			detected: false,
+			lastDetectedAt: null
+		};
+	}
+	/** Drop the mirror of a grid that no longer exists. */
+	forget(deviceId) {
+		this.mirrors.delete(deviceId);
+	}
+	mirrorFor(grid) {
+		let mirror = this.mirrors.get(grid.deviceId);
+		if (mirror === void 0) {
+			mirror = new GridActivityMirror();
+			this.mirrors.set(grid.deviceId, mirror);
+		}
+		mirror.keepOnly(grid.sourceDeviceIds);
+		return mirror;
+	}
+	source(deviceId) {
+		return {
+			type: "device",
+			id: deviceId,
+			addonId: this.deps.addonId,
+			deviceId
+		};
+	}
+	emitMotion(deviceId, state, atMs) {
+		const payload = {
+			deviceId,
+			detected: state.detected,
+			timestamp: atMs,
+			source: "onboard"
+		};
+		this.deps.eventBus.emit(require_dist.createEvent(require_dist.EventCategory.MotionOnMotionChanged, this.source(deviceId), payload));
+		this.deps.logger.debug("camera grid: motion forwarded", {
+			tags: { deviceId },
+			meta: { detected: state.detected }
+		});
+	}
+	emitAudio(deviceId, dbfs, atMs) {
+		const payload = {
+			deviceId,
+			frame: {
+				kind: "audio-window",
+				windowId: `grid-${String(deviceId)}-${String(atMs)}`,
+				deviceId,
+				timestamp: atMs,
+				startMs: atMs,
+				endMs: atMs,
+				level: {
+					rms: 0,
+					dbfs
+				},
+				detections: []
+			},
+			nodeId: "hub"
+		};
+		this.deps.eventBus.emit(require_dist.createEvent(require_dist.EventCategory.PipelineAudioInferenceResult, this.source(deviceId), payload));
+	}
+	emitDetections(grid, sourceFrame, detections) {
+		const payload = {
+			frame: {
+				kind: "frame",
+				frameId: `grid-${String(grid.deviceId)}-${sourceFrame.frameId}`,
+				deviceId: grid.deviceId,
+				timestamp: sourceFrame.timestamp,
+				width: grid.canvas.width,
+				height: grid.canvas.height,
+				detections
+			},
+			analysisResults: []
+		};
+		this.deps.eventBus.emit(require_dist.createEvent(require_dist.EventCategory.DetectionResult, this.source(grid.deviceId), payload));
+	}
+};
+//#endregion
 //#region src/builtins/camera-grid/grid-wire-format.ts
 /** What the relay answers with, and what the sampler must demux. */
 var GRID_WIRE_CONTENT_TYPE = "video/x-flv";
@@ -600,82 +928,50 @@ var GridLastFrameFileStore = class {
 //#endregion
 //#region src/builtins/camera-grid/grid-profiles.ts
 /**
-* One id, for every grid, forever — for the HIGH composition.
+* One id, for every grid, forever.
 *
-* D519's reason still holds and is what keeps this id bare: a per-instance or
-* newly-spelled id mints a second cam-stream and orphans whatever profile
-* assignment the operator had made. `grid` was `high` on the live hub before
-* this change, so `high` keeps it and the other two are new.
+* D519's reason is what keeps this id bare: a per-instance or newly-spelled id
+* mints a second cam-stream and orphans whatever profile assignment the
+* operator had made. It was `high` on the live hub before the per-profile
+* detour and it is `high` again, so nothing an operator assigned is disturbed.
 */
 var GRID_CAM_STREAM_ID = "grid";
-/** Every profile a grid could conceivably compose, in descending quality. */
-var GRID_PROFILES = [
-	"high",
-	"mid",
-	"low"
-];
 /**
-* Canvas scale per profile. Named constants and not a computation: the numbers
-* are a policy (what a `mid` grid is FOR), and a policy that lives in an
-* expression is a policy nobody can find.
-*/
-var CANVAS_SCALE = {
-	high: 1,
-	mid: .5,
-	low: .25
-};
-/**
-* The smallest canvas a composition is allowed to shrink to. A grid of four
-* cells at 40x30 is not a cheaper picture, it is no picture.
+* The slot the single composition claims.
+*
+* NOT decoration. A device publishing one stream with no hint is ranked by
+* pixel count and lands in `mid` — the slot `recordings` does not select on its
+* own, that `recordingsLow` ignores, and that scrub never reads. The Dreame
+* robot's single 720p relay landed exactly there and its footage was written
+* where nothing looked.
 */
-var MIN_CANVAS_WIDTH = 160;
-var MIN_CANVAS_HEIGHT = 90;
-/** The cam-stream id a grid publishes for one profile. */
-function gridCamStreamId(profile) {
-	return profile === "high" ? GRID_CAM_STREAM_ID : `${GRID_CAM_STREAM_ID}-${profile}`;
+var GRID_OUTPUT_PROFILE = "high";
+/** Cheapest first — the order a source is read in. */
+var CHEAPEST_FIRST = [
+	"low",
+	"mid",
+	"high"
+];
+/** The cheapest stream this source serves, or `null` when it serves none. */
+function lowestServedProfile(served) {
+	return CHEAPEST_FIRST.find((profile) => served.includes(profile)) ?? null;
 }
-/** Even, floored, scaled by the profile. libx264 refuses an odd dimension. */
-function gridCanvasFor(canvas, profile) {
-	const scale = CANVAS_SCALE[profile];
+/** Which stream to read each source at, and who cannot be read at all. */
+function gridSourceProfiles(input) {
+	const profileBySource = /* @__PURE__ */ new Map();
+	const missingSources = [];
+	for (const deviceId of input.sourceDeviceIds) {
+		const served = input.profilesServedBy(deviceId);
+		const chosen = served === null ? null : lowestServedProfile(served);
+		if (chosen === null) missingSources.push(deviceId);
+		else profileBySource.set(deviceId, chosen);
+	}
 	return {
-		width: evenAtLeast(canvas.width * scale, MIN_CANVAS_WIDTH),
-		height: evenAtLeast(canvas.height * scale, MIN_CANVAS_HEIGHT)
+		offered: input.sourceDeviceIds.length > 0 && missingSources.length === 0,
+		profileBySource,
+		missingSources
 	};
 }
-function evenAtLeast(value, floor) {
-	const rounded = Math.max(floor, Math.round(value));
-	return rounded % 2 === 0 ? rounded : rounded + 1;
-}
-/**
-* What this grid can honestly publish, per profile, with the refusal named.
-*
-* Every profile gets a row whether it is offered or not: an absent row says
-* nothing, and the caller logging a refusal needs the reason more than the
-* caller publishing an offer needs the offer.
-*/
-function offeredGridProfiles(input) {
-	const served = /* @__PURE__ */ new Map();
-	for (const deviceId of input.sourceDeviceIds) served.set(deviceId, input.profilesServedBy(deviceId));
-	return GRID_PROFILES.map((profile) => {
-		if (input.sourceDeviceIds.length === 0) return {
-			profile,
-			offered: false,
-			missingSources: []
-		};
-		const missingSources = input.sourceDeviceIds.filter((deviceId) => {
-			const profiles = served.get(deviceId);
-			return profiles === null || profiles === void 0 || !profiles.includes(profile);
-		});
-		return missingSources.length === 0 ? {
-			profile,
-			offered: true
-		} : {
-			profile,
-			offered: false,
-			missingSources
-		};
-	});
-}
 //#endregion
 //#region src/builtins/camera-grid/grid-sentry-sources.ts
 function gridSourceDial(acquired) {
@@ -694,6 +990,43 @@ function gridSourceDial(acquired) {
 //#endregion
 //#region src/builtins/camera-grid/grid-snapshot.ts
 /**
+* A grid's snapshot — a frame of the COMPOSITION, never a dial.
+*
+* ## The decision, and the two things it rejects
+*
+* The operator: *"Lo snapshot possiamo sempre farlo dallo stream sempre, non
+* c'e' bisogno di comporre gli snapshots"*. So:
+*
+* - **Not composed from source snapshots.** That would be a SECOND compositor,
+*   with its own geometry, its own aspect handling and its own bugs, producing
+*   a picture that differs from the real one in ways nobody would ever notice
+*   until they mattered.
+* - **Not produced by starting the composition.** The whole of D519 is "a grid
+*   costs nothing when nobody watches". A thumbnail that dials N cameras — and
+*   on a battery camera, wakes one — spends the entire budget of the feature on
+*   a 160-pixel-wide picture in a list.
+*
+* ## The three states, all answered
+*
+* | state | answer |
+* | --- | --- |
+* | a composition is running | one frame sampled out of the bytes it is already emitting |
+* | nothing running, a frame was kept | that frame — stale, and honest about it |
+* | nothing running, nothing ever kept | `null`, logged with the reason |
+*
+* `null` is the courtesy card, which is the correct picture of "this grid has
+* never been watched". What it must never be is a reason to dial.
+*
+* ## Why this is a NATIVE snapshot provider
+*
+* The wrapper's ladder is native-first: a native that produces a frame
+* short-circuits before the broker frame-grab, and the broker frame-grab is the
+* thing that would wake the sources. A grid with a stored frame or a live
+* composition therefore never reaches it. The residual — a grid that has never
+* once been composed — is documented in D519; it cannot wake a battery camera,
+* because a grid never dials one live at all (`grid-sentry-sources.ts`).
+*/
+/**
 * Which of the three answers applies. Pure, so the rule can be read — and
 * sabotaged — without a socket, a file or an ffmpeg.
 */
@@ -726,10 +1059,7 @@ var GridSnapshotSource = class {
 				return toImage(sampled);
 			}
 			if (stored !== null) return toImage(stored);
-			this.deps.logger.warn("camera grid: the composition is running but produced no frame, and none was kept", {
-				tags: { deviceId },
-				meta: { profile: live.profile }
-			});
+			this.deps.logger.warn("camera grid: the composition is running but produced no frame, and none was kept", { tags: { deviceId } });
 			return null;
 		}
 		if (answer.kind === "stored" && stored !== null) return toImage(stored);
@@ -737,7 +1067,7 @@ var GridSnapshotSource = class {
 			tags: { deviceId },
 			meta: {
 				reason: "never-composed",
-				profiles: sessions.length
+				compositions: sessions.length
 			}
 		});
 		return null;
@@ -746,18 +1076,12 @@ var GridSnapshotSource = class {
 		try {
 			const jpeg = await this.deps.sampleFrame(session);
 			if (jpeg !== null && jpeg.length > 0) return jpeg;
-			this.deps.logger.warn("camera grid: could not sample a frame from the live composition", {
-				tags: { deviceId },
-				meta: { profile: session.profile }
-			});
+			this.deps.logger.warn("camera grid: could not sample a frame from the live composition", { tags: { deviceId } });
 			return null;
 		} catch (error) {
 			this.deps.logger.warn("camera grid: could not sample a frame from the live composition", {
 				tags: { deviceId },
-				meta: {
-					profile: session.profile,
-					error: require_dist.errMsg(error)
-				}
+				meta: { error: require_dist.errMsg(error) }
 			});
 			return null;
 		}
@@ -811,24 +1135,15 @@ var PATH_PREFIX = "/grid/";
 var PATH_SUFFIX = GRID_WIRE_PATH_SUFFIX;
 /** How long a reader may refuse to drain before it is cut. */
 var SLOW_READER_MS = 5e3;
-function asProfile(raw) {
-	return GRID_PROFILES.find((profile) => profile === raw) ?? null;
-}
-/** `/grid/<instanceId>/<profile>.flv`, or `null` when it is anything else. */
+/** `/grid/<instanceId>.flv`, or `null` when it is anything else. */
 function parseGridStreamPath(url) {
 	const path = (url ?? "").split("?")[0] ?? "";
 	if (!path.startsWith(PATH_PREFIX) || !path.endsWith(PATH_SUFFIX)) return null;
 	const raw = path.slice(6, path.length - PATH_SUFFIX.length);
-	const at = raw.lastIndexOf("/");
-	if (at <= 0) return null;
-	const profile = asProfile(raw.slice(at + 1));
-	if (profile === null) return null;
+	if (raw.length === 0 || raw.includes("/")) return null;
 	try {
-		const instanceId = decodeURIComponent(raw.slice(0, at));
-		return instanceId.length > 0 ? {
-			instanceId,
-			profile
-		} : null;
+		const instanceId = decodeURIComponent(raw);
+		return instanceId.length > 0 ? { instanceId } : null;
 	} catch {
 		return null;
 	}
@@ -867,16 +1182,13 @@ var GridStreamRelay = class {
 	streamUrl(request) {
 		if (!this.baseUrl) throw new Error("camera-grid: the stream relay is not started");
 		const instance = encodeURIComponent(request.instanceId);
-		return `${this.baseUrl}${PATH_PREFIX}${instance}/${request.profile}${PATH_SUFFIX}`;
+		return `${this.baseUrl}${PATH_PREFIX}${instance}${PATH_SUFFIX}`;
 	}
 	async serve(request, res) {
-		const { instanceId, profile } = request;
+		const { instanceId } = request;
 		const session = this.deps.sessionFor(request);
 		if (session === null) {
-			this.deps.logger.warn("camera grid: a stream was requested for an unknown grid", { meta: {
-				instanceId,
-				profile
-			} });
+			this.deps.logger.warn("camera grid: a stream was requested for an unknown grid", { meta: { instanceId } });
 			res.writeHead(404).end();
 			return;
 		}
@@ -910,7 +1222,6 @@ var GridStreamRelay = class {
 							tags: { deviceId: session.deviceId },
 							meta: {
 								instanceId,
-								profile,
 								stalledForMs: SLOW_READER_MS
 							}
 						});
@@ -923,7 +1234,6 @@ var GridStreamRelay = class {
 						tags: { deviceId: session.deviceId },
 						meta: {
 							instanceId,
-							profile,
 							reason
 						}
 					});
@@ -936,7 +1246,6 @@ var GridStreamRelay = class {
 				tags: { deviceId: session.deviceId },
 				meta: {
 					instanceId,
-					profile,
 					error: require_dist.errMsg(error)
 				}
 			});
@@ -972,13 +1281,13 @@ var GridStreamRelay = class {
 * scrub never reads. The Dreame robot's one 720p relay landed exactly there and
 * its footage was written nowhere anything looked.
 *
-* With several compositions published the hint does a second job: it is the
-* only thing that says which slot each one is FOR. Ranked by pixels a grid's
-* `mid` would take the `high` slot on any grid whose `high` was not offered.
+* So the single composition claims `high` EXPLICITLY (`GRID_OUTPUT_PROFILE`).
+* It is also the slot this stream held before the per-profile detour, which is
+* what keeps an operator's existing assignment intact.
 */
 function gridStreamDescriptor(input) {
 	return {
-		camStreamId: gridCamStreamId(input.profile),
+		camStreamId: GRID_CAM_STREAM_ID,
 		kind: GRID_WIRE_STREAM_KIND,
 		url: input.url,
 		codec: "h264",
@@ -987,8 +1296,8 @@ function gridStreamDescriptor(input) {
 			height: input.height
 		},
 		fps: input.fps,
-		label: `Grid composition (${input.profile})`,
-		profileHint: input.profile,
+		label: "Grid composition",
+		profileHint: GRID_OUTPUT_PROFILE,
 		autoEligible: true
 	};
 }
@@ -1421,11 +1730,14 @@ var GridStreamSession = class {
 * for a grid must win, and a reconcile that re-asserted every pass would silently
 * overrule them once a minute.
 */
-var GRID_SILENCED_CAP_NAMES = [
-	"motion-detection",
-	require_dist.DETECTION_PIPELINE_CAP_NAME,
-	require_dist.AUDIO_ANALYSIS_CAP_NAME
-];
+/**
+* The list lives in `@camstack/types` now, and this is an alias rather than a
+* second copy. There WERE two — this one and the Terminal addon's — and they
+* had drifted: neither named `pipeline-analytics`, the one cap with no gate of
+* its own, which is what a grid forwarding its sources' motion would have used
+* to write a duplicate motion episode per event.
+*/
+var GRID_SILENCED_CAP_NAMES = require_dist.DERIVED_CAMERA_SILENCED_CAP_NAMES;
 /**
 * Resolve the addon currently providing `capName` for this device, from the
 * device's OWN bindings. `listBindableCapsForDeviceType` answers for the device
@@ -1766,21 +2078,18 @@ var DEFAULTS = {
 	cameraGrids: [],
 	cameraGridTombstones: []
 };
-/** One session per (grid, profile). A grid composes each profile separately. */
-function sessionKey(instanceId, profile) {
-	return `${instanceId}::${profile}`;
-}
 /**
-* One grid's composition of one profile, and enough about it for the snapshot
-* to choose between them without reaching into the session.
+* One grid's composition — there is exactly one, keyed by the grid itself.
+*
+* It used to be one per profile, and the key carried the profile. That shape
+* is what made a viewer's adaptive step tear a composition down and build
+* another; see `grid-profiles.ts` for the log that showed it.
 */
 var GridSessionEntry = class {
 	instanceId;
-	profile;
 	session;
-	constructor(instanceId, profile, session) {
+	constructor(instanceId, session) {
 		this.instanceId = instanceId;
-		this.profile = profile;
 		this.session = session;
 	}
 	isRunning() {
@@ -1790,7 +2099,7 @@ var GridSessionEntry = class {
 var CameraGridAddon = class extends require_dist.BaseAddon {
 	relay = null;
 	reconcileTimer = null;
-	/** Keyed by {@link sessionKey} — one composition per grid per profile. */
+	/** Keyed by instance id — ONE composition per grid. */
 	sessions = /* @__PURE__ */ new Map();
 	deviceIdByInstanceId = /* @__PURE__ */ new Map();
 	tombstones = /* @__PURE__ */ new Set();
@@ -1804,7 +2113,8 @@ var CameraGridAddon = class extends require_dist.BaseAddon {
 	* (D224), and 60 s is the window for a fact — "does 615 have a low assigned"
 	* — that only changes when an operator changes it.
 	*/
-	offersByInstanceId = /* @__PURE__ */ new Map();
+	planByInstanceId = /* @__PURE__ */ new Map();
+	activity = null;
 	snapshots = null;
 	frameSampler = null;
 	ffmpegBinaryPath = "ffmpeg";
@@ -1833,11 +2143,29 @@ var CameraGridAddon = class extends require_dist.BaseAddon {
 				sampleFrame: async (session) => this.sampleFrame(session),
 				store: new GridLastFrameFileStore({ dataDir: this.ctx.dataDir })
 			});
+			this.activity = new GridActivityForwarder({
+				eventBus: this.ctx.eventBus,
+				logger: this.ctx.logger.child("activity"),
+				addonId: this.ctx.id,
+				gridsForSource: (sourceDeviceId) => this.gridsForSource(sourceDeviceId),
+				now: () => Date.now()
+			});
+			this.subscribeSourceActivity();
 			installGridCameraRuntime({
 				descriptorsFor: (instanceId) => this.descriptorsFor(instanceId),
 				getLayout: (deviceId) => this.gridViewFor(deviceId),
 				saveLayout: async (patch) => this.saveGridLayout(patch),
-				getSnapshot: async (deviceId) => this.getSnapshot(deviceId)
+				getSnapshot: async (deviceId) => this.getSnapshot(deviceId),
+				motionStatus: (deviceId) => {
+					const state = this.activity?.motionStatusFor(deviceId, Date.now()) ?? {
+						detected: false,
+						lastDetectedAt: null
+					};
+					return {
+						...state,
+						autoClearAfterMs: state.detected ? require_dist.MOTION_CLOSE_AFTER_MS : null
+					};
+				}
 			});
 			await this.reconcile().catch((error) => {
 				this.ctx.logger.warn("camera grid: initial reconciliation failed — will retry", { meta: { error: require_dist.errMsg(error) } });
@@ -1907,7 +2235,7 @@ var CameraGridAddon = class extends require_dist.BaseAddon {
 		if (!this.relay) return;
 		const instances = this.instances();
 		const declarations = buildGridCameraDeclarations(instances);
-		await this.refreshProfileOffers(instances);
+		await this.refreshSourcePlans(instances);
 		await this.retireWithdrawnSessions(instances);
 		const result = await new require_dist.DeclaredDevices({
 			logger: this.ctx.logger.child("declaration"),
@@ -1974,15 +2302,73 @@ var CameraGridAddon = class extends require_dist.BaseAddon {
 		}
 	}
 	/**
-	* Which profiles each grid can honestly publish, asked of the BROKER.
+	* Listen to the SOURCES, so the grid can say the same things about itself.
+	*
+	* Filtered by source id inside the handler rather than by subscribing per
+	* camera: the bus filter is per category, the set of sources changes whenever
+	* an operator drags a cell, and a per-camera subscription would have to be
+	* torn down and rebuilt on every layout save.
+	*
+	* Every handler is TOTAL — a malformed payload is ignored, never thrown out
+	* of. These are telemetry events on a shared bus (D8/D11), and a throw here
+	* would take the grid's forwarding down for every grid because one camera
+	* emitted something unexpected.
+	*/
+	subscribeSourceActivity() {
+		this.subscribe({ category: require_dist.EventCategory.MotionOnMotionChanged }, (event) => {
+			const data = event.data;
+			if (typeof data.deviceId !== "number" || typeof data.detected !== "boolean") return;
+			const at = typeof data.timestamp === "number" ? data.timestamp : Date.now();
+			this.activity?.onSourceMotion(data.deviceId, data.detected, at);
+		});
+		this.subscribe({ category: require_dist.EventCategory.PipelineAudioInferenceResult }, (event) => {
+			const data = event.data;
+			const dbfs = data.frame?.level?.dbfs;
+			if (typeof data.deviceId !== "number" || typeof dbfs !== "number") return;
+			this.activity?.onSourceAudio(data.deviceId, dbfs, Date.now());
+		});
+		this.subscribe({ category: require_dist.EventCategory.DetectionResult }, (event) => {
+			const frame = event.data.frame;
+			if (frame === void 0 || frame.kind !== "frame") return;
+			this.activity?.onSourceDetections(frame);
+		});
+	}
+	/**
+	* Which grids show this camera. Empty for the overwhelming majority of
+	* events, which is why it is the FIRST thing every handler asks.
+	*/
+	gridsForSource(sourceDeviceId) {
+		const targets = [];
+		for (const [instanceId, deviceId] of this.deviceIdByInstanceId) {
+			const instance = this.instanceById(instanceId);
+			if (!instance || !instance.enabled) continue;
+			if (sourceDeviceId === deviceId) continue;
+			if (instance.cells.filter((cell) => cell.deviceId === sourceDeviceId).length === 0) continue;
+			targets.push({
+				deviceId,
+				canvas: {
+					width: instance.width,
+					height: instance.height
+				},
+				cellsForSource: (id) => instance.cells.filter((cell) => cell.deviceId === id).map((cell) => ({
+					source: cell.source,
+					cell: cell.cell
+				})),
+				sourceDeviceIds: [...new Set(instance.cells.map((cell) => cell.deviceId))]
+			});
+		}
+		return targets;
+	}
+	/**
+	* Which stream each grid reads each of its sources at, asked of the BROKER.
 	*
 	* `listAllProfileSlots` is the one authority on "does 615 have a low
 	* assigned", and `sourceCamStreamId === null` is its way of saying no. A read
-	* that FAILS leaves the previous answer in place and says so - it is not an
+	* that FAILS leaves the previous answer in place and says so — it is not an
 	* empty catalog, and turning it into one would retract the streams of every
 	* grid on the hub.
 	*/
-	async refreshProfileOffers(instances) {
+	async refreshSourcePlans(instances) {
 		let slots;
 		try {
 			slots = await this.ctx.api.streamBroker.listAllProfileSlots.query();
@@ -2001,69 +2387,70 @@ var CameraGridAddon = class extends require_dist.BaseAddon {
 			servedBy.set(slot.deviceId, profiles);
 		}
 		for (const instance of instances) {
-			const offers = offeredGridProfiles({
+			const plan = gridSourceProfiles({
 				sourceDeviceIds: [...new Set(instance.cells.map((cell) => cell.deviceId))],
 				profilesServedBy: (deviceId) => servedBy.get(deviceId) ?? null
 			});
-			const previous = this.offersByInstanceId.get(instance.id);
-			this.offersByInstanceId.set(instance.id, offers);
-			this.logRefusals(instance, offers, previous);
+			const previous = this.planByInstanceId.get(instance.id);
+			this.planByInstanceId.set(instance.id, plan);
+			this.logSourcePlan(instance, plan, previous);
 		}
 	}
 	/**
-	* Say which profiles this grid will NOT publish, and why - once per change.
+	* Say WHICH stream each cell is read at, and who could not be read - once per
+	* change.
 	*
-	* A profile silently missing from a catalog is indistinguishable from a
-	* broker that swept it. Logged on the EDGE rather than every minute: a grid
-	* that can only serve `high` would otherwise write two lines a minute for
-	* ever.
+	* Both halves earn their line. A grid silently missing from a catalog is
+	* indistinguishable from a broker that swept it, so the refusal names the
+	* sources. And the chosen profiles are the answer to "why is this tile
+	* soft?" — a camera whose only assigned slot is `high` is read at `high`, and
+	* nothing else in the system would ever say so.
+	*
+	* Logged on the EDGE: a grid that cannot be composed would otherwise write a
+	* line a minute for ever.
 	*/
-	logRefusals(instance, offers, previous) {
-		if (previous !== void 0 && JSON.stringify(previous) === JSON.stringify(offers)) return;
+	logSourcePlan(instance, plan, previous) {
+		const shape = (value) => JSON.stringify([
+			value.offered,
+			[...value.profileBySource],
+			value.missingSources
+		]);
+		if (previous !== void 0 && shape(previous) === shape(plan)) return;
 		const deviceId = this.deviceIdByInstanceId.get(instance.id) ?? 0;
-		for (const offer of offers) {
-			if (offer.offered) continue;
-			if (offer.missingSources.length === 0) continue;
-			this.ctx.logger.info("camera grid: a profile is NOT on offer", {
-				tags: { deviceId },
-				meta: {
-					instanceId: instance.id,
-					profile: offer.profile,
-					missingSources: [...offer.missingSources]
-				}
-			});
-		}
-		this.ctx.logger.info("camera grid: published profiles", {
+		if (plan.missingSources.length > 0) this.ctx.logger.info("camera grid: a source cannot be read — the grid is NOT on offer", {
+			tags: { deviceId },
+			meta: {
+				instanceId: instance.id,
+				missingSources: [...plan.missingSources]
+			}
+		});
+		this.ctx.logger.info("camera grid: composing", {
 			tags: { deviceId },
 			meta: {
 				instanceId: instance.id,
-				offered: offers.filter((offer) => offer.offered).map((offer) => offer.profile)
+				offered: plan.offered,
+				readAt: Object.fromEntries([...plan.profileBySource].map(([id, p]) => [String(id), p]))
 			}
 		});
 	}
-	offeredProfiles(instanceId) {
-		const offers = this.offersByInstanceId.get(instanceId);
-		if (offers === void 0) return null;
-		return offers.filter((offer) => offer.offered).map((offer) => offer.profile);
+	planFor(instanceId) {
+		return this.planByInstanceId.get(instanceId) ?? null;
 	}
 	ensureSessions(instanceId, deviceId) {
-		const offered = this.offeredProfiles(instanceId) ?? [];
-		for (const profile of GRID_PROFILES) {
-			const key = sessionKey(instanceId, profile);
-			if (!offered.includes(profile)) {
-				const stale = this.sessions.get(key);
-				if (stale) {
-					this.sessions.delete(key);
-					stale.session.dispose();
-				}
-				continue;
+		const plan = this.planFor(instanceId);
+		if (plan === null || !plan.offered) {
+			const stale = this.sessions.get(instanceId);
+			if (stale) {
+				this.sessions.delete(instanceId);
+				stale.session.dispose();
 			}
-			if (this.sessions.has(key)) continue;
-			const session = this.makeSession(instanceId, deviceId, profile);
-			this.sessions.set(key, new GridSessionEntry(instanceId, profile, session));
+			return;
 		}
+		if (this.sessions.has(instanceId)) return;
+		const session = this.makeSession(instanceId, deviceId);
+		this.sessions.set(instanceId, new GridSessionEntry(instanceId, session));
 	}
-	makeSession(instanceId, deviceId, profile) {
+	makeSession(instanceId, deviceId) {
 		const childContext = {
 			binaryPath: this.ffmpegBinaryPath,
 			logger: this.ctx.logger,
@@ -2074,6 +2461,8 @@ var CameraGridAddon = class extends require_dist.BaseAddon {
 			deps: {
 				logger: this.ctx.logger,
 				acquireSource: async (sourceDeviceId) => {
+					const profile = this.planFor(instanceId)?.profileBySource.get(sourceDeviceId);
+					if (profile === void 0) throw new Error(`camera-grid: no stream is assigned for source ${String(sourceDeviceId)}`);
 					const dial = gridSourceDial(await acquireWithRetry(() => this.ctx.api.streamBroker.getStreamWithCodec.mutate({
 						deviceId: sourceDeviceId,
 						video: "copy",
@@ -2123,11 +2512,7 @@ var CameraGridAddon = class extends require_dist.BaseAddon {
 				if (!instance) return null;
 				return gridPlanFor(instance, {
 					encoder: "libx264",
-					decodeHwAccel: null,
-					canvas: gridCanvasFor({
-						width: instance.width,
-						height: instance.height
-					}, profile)
+					decodeHwAccel: null
 				});
 			}
 		});
@@ -2135,18 +2520,14 @@ var CameraGridAddon = class extends require_dist.BaseAddon {
 	}
 	/** The session a dial is asking for, or `null` - which the relay answers 404 to. */
 	sessionFor(request) {
-		return this.sessions.get(sessionKey(request.instanceId, request.profile))?.session ?? null;
+		return this.sessions.get(request.instanceId)?.session ?? null;
 	}
-	/** This grid's sessions, in DESCENDING quality - the snapshot takes the first running one. */
+	/** This grid's composition, as the list the snapshot source expects. */
 	sessionsForDevice(deviceId) {
 		const instanceId = this.instanceIdForDevice(deviceId);
 		if (instanceId === null) return [];
-		const entries = [];
-		for (const profile of GRID_PROFILES) {
-			const entry = this.sessions.get(sessionKey(instanceId, profile));
-			if (entry) entries.push(entry);
-		}
-		return entries;
+		const entry = this.sessions.get(instanceId);
+		return entry ? [entry] : [];
 	}
 	/** A grid that is gone stops immediately - it must not keep N sources dialled. */
 	async retireWithdrawnSessions(instances) {
@@ -2155,18 +2536,16 @@ var CameraGridAddon = class extends require_dist.BaseAddon {
 			if (live.has(entry.instanceId)) continue;
 			this.ctx.logger.info("camera grid: retiring a withdrawn grid", {
 				tags: { deviceId: this.deviceIdByInstanceId.get(entry.instanceId) ?? 0 },
-				meta: {
-					instanceId: entry.instanceId,
-					profile: entry.profile
-				}
+				meta: { instanceId: entry.instanceId }
 			});
 			this.sessions.delete(key);
 			await entry.session.dispose();
 		}
 		for (const instanceId of [...this.deviceIdByInstanceId.keys()]) {
 			if (live.has(instanceId)) continue;
+			this.activity?.forget(this.deviceIdByInstanceId.get(instanceId) ?? 0);
 			this.deviceIdByInstanceId.delete(instanceId);
-			this.offersByInstanceId.delete(instanceId);
+			this.planByInstanceId.delete(instanceId);
 		}
 	}
 	/**
@@ -2179,10 +2558,7 @@ var CameraGridAddon = class extends require_dist.BaseAddon {
 			if (!entry.session.isRunning()) continue;
 			this.ctx.logger.info("camera grid: the layout changed - restarting the composition", {
 				tags: { deviceId: this.deviceIdByInstanceId.get(entry.instanceId) ?? 0 },
-				meta: {
-					instanceId: entry.instanceId,
-					profile: entry.profile
-				}
+				meta: { instanceId: entry.instanceId }
 			});
 			entry.session.onChildEnded("layout-changed");
 		}
@@ -2217,24 +2593,15 @@ var CameraGridAddon = class extends require_dist.BaseAddon {
 	descriptorsFor(instanceId) {
 		const instance = this.instanceById(instanceId);
 		const relay = this.relay;
-		const offered = this.offeredProfiles(instanceId);
-		if (!instance || !relay || offered === null) return null;
-		return offered.map((profile) => {
-			const canvas = gridCanvasFor({
-				width: instance.width,
-				height: instance.height
-			}, profile);
-			return gridStreamDescriptor({
-				profile,
-				width: canvas.width,
-				height: canvas.height,
-				fps: instance.fps,
-				url: relay.streamUrl({
-					instanceId,
-					profile
-				})
-			});
-		});
+		const plan = this.planFor(instanceId);
+		if (!instance || !relay || plan === null) return null;
+		if (!plan.offered) return [];
+		return [gridStreamDescriptor({
+			width: instance.width,
+			height: instance.height,
+			fps: instance.fps,
+			url: relay.streamUrl({ instanceId })
+		})];
 	}
 	instanceIdForDevice(deviceId) {
 		for (const [instanceId, id] of this.deviceIdByInstanceId) if (id === deviceId) return instanceId;
@@ -2259,11 +2626,15 @@ var CameraGridAddon = class extends require_dist.BaseAddon {
 				source: cell.source,
 				cell: cell.cell
 			})),
-			profiles: (this.offersByInstanceId.get(instance.id) ?? []).map((offer) => ({
-				profile: offer.profile,
-				offered: offer.offered,
-				missingSources: offer.offered ? [] : [...offer.missingSources]
-			}))
+			profiles: (() => {
+				const plan = this.planByInstanceId.get(instance.id);
+				if (plan === void 0) return [];
+				return [{
+					profile: GRID_OUTPUT_PROFILE,
+					offered: plan.offered,
+					missingSources: [...plan.missingSources]
+				}];
+			})()
 		};
 	}
 	async saveGridLayout(input) {
@@ -2289,7 +2660,7 @@ var CameraGridAddon = class extends require_dist.BaseAddon {
 			...row,
 			...updated
 		} : row) });
-		await this.refreshProfileOffers(this.instances());
+		await this.refreshSourcePlans(this.instances());
 		this.ensureSessions(instance.id, input.deviceId);
 		const view = this.gridViewFor(input.deviceId);
 		if (!view) throw new Error("camera-grid: the grid vanished while it was being saved");
@@ -2357,7 +2728,7 @@ var CameraGridAddon = class extends require_dist.BaseAddon {
 //#endregion
 exports.CameraGridAddon = CameraGridAddon;
 exports.GRID_CAM_STREAM_ID = GRID_CAM_STREAM_ID;
-exports.GRID_PROFILES = GRID_PROFILES;
+exports.GRID_OUTPUT_PROFILE = GRID_OUTPUT_PROFILE;
 exports.GRID_SILENCED_CAP_NAMES = GRID_SILENCED_CAP_NAMES;
 exports.GridCameraDevice = GridCameraDevice;
 exports.GridFrameSampler = GridFrameSampler;
@@ -2368,18 +2739,17 @@ exports.GridStreamSession = GridStreamSession;
 exports.buildGridCameraDeclarations = buildGridCameraDeclarations;
 exports.buildGridFilterGraph = buildGridFilterGraph;
 exports.default = CameraGridAddon;
-exports.gridCamStreamId = gridCamStreamId;
 exports.gridCameraReconciliationIndex = gridCameraReconciliationIndex;
-exports.gridCanvasFor = gridCanvasFor;
 exports.gridPlanFor = gridPlanFor;
 exports.gridSnapshotAnswerFor = gridSnapshotAnswerFor;
 exports.gridSourceDial = gridSourceDial;
+exports.gridSourceProfiles = gridSourceProfiles;
 exports.gridStreamDescriptor = gridStreamDescriptor;
 exports.gridStreamInvocation = gridStreamInvocation;
 exports.installGridCameraRuntime = installGridCameraRuntime;
+exports.lowestServedProfile = lowestServedProfile;
 exports.newGridCameraStableId = newGridCameraStableId;
 exports.normalizeGridRows = normalizeGridRows;
-exports.offeredGridProfiles = offeredGridProfiles;
 exports.parseGridStreamPath = parseGridStreamPath;
 exports.readGridInstances = readGridInstances;
 exports.silenceAnalysisFor = silenceAnalysisFor;