@camstack/system 1.2.261 → 1.2.263

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

@@ -600,82 +600,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 +662,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 +731,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 +739,7 @@ var GridSnapshotSource = class {
 			tags: { deviceId },
 			meta: {
 				reason: "never-composed",
-				profiles: sessions.length
+				compositions: sessions.length
 			}
 		});
 		return null;
@@ -746,18 +748,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 +807,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 +854,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 +894,6 @@ var GridStreamRelay = class {
 							tags: { deviceId: session.deviceId },
 							meta: {
 								instanceId,
-								profile,
 								stalledForMs: SLOW_READER_MS
 							}
 						});
@@ -923,7 +906,6 @@ var GridStreamRelay = class {
 						tags: { deviceId: session.deviceId },
 						meta: {
 							instanceId,
-							profile,
 							reason
 						}
 					});
@@ -936,7 +918,6 @@ var GridStreamRelay = class {
 				tags: { deviceId: session.deviceId },
 				meta: {
 					instanceId,
-					profile,
 					error: require_dist.errMsg(error)
 				}
 			});
@@ -972,13 +953,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 +968,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
 	};
 }
@@ -1587,16 +1568,58 @@ var PIXEL_FORMAT = "yuv420p";
 */
 var GOP_SECONDS = 1;
 /**
-* `-analyzeduration` / `-probesize`, well under ffmpeg's 5 s / 5 MB defaults.
+* `-analyzeduration` / `-probesize`, as small as ffmpeg allows.
 *
-* Safe on RTSP specifically: the SDP already declares the codec, so the probe
-* has nothing to discover. It matters more here than anywhere else in the repo
-* because the probes are PARALLEL inputs of one child — the composite emits
-* nothing until the LAST of them has finished, so the default budget is paid
-* once per grid, at the slowest source's pace.
+* ## The probes are SEQUENTIAL, and this is what the tile skew was
+*
+* The sentence that used to be here said the probes are "PARALLEL inputs of one
+* child". They are not. ffmpeg opens its inputs one after another and each open
+* BLOCKS in `avformat_find_stream_info` until its budget is spent — so input 0
+* is already connected and receiving while ffmpeg is still opening input 1, its
+* frames pile up, and `overlay` (which pairs inputs BY PTS) marries input 0's
+* oldest frame to input 1's newest. The lag is fixed for the life of the child:
+* both tiles then advance one frame per output frame, so nothing ever closes it.
+* The FIRST cell is the most behind; the last is live.
+*
+* Reproduced in one command on 2026-09-18 — two sources hstacked, one frame,
+* reading the cameras' own burnt-in clocks out of the composed picture:
+*
+* ```
+* 13:11:21 | 13:11:23      two seconds, and the earlier input is the late one
+* ```
+*
+* ## Why the old numbers cost seconds
+*
+* `-probesize` is a BYTE budget, and 1 MB of a 640x360 sub-stream is tens of
+* seconds of video — so `-analyzeduration 1s` never got the chance to stop it
+* and each open ran until the byte budget filled. Zero and 32 make the probe
+* return from the SDP, which already declares the codec, without reading media.
+*
+* Measured on this hub, the two sources of the live grid, three runs each,
+* production input args otherwise identical — time to the first composed frame,
+* and the skew read off the two burnt-in clocks in that frame:
+*
+* ```
+*   1 s / 1 MB     8986, 9728, 9712 ms      skew 5 s, 5 s, 4 s
+*   0   / 32       2281, 2270, 2304 ms      skew 1 s, 1 s, 0 s
+* ```
+*
+* The same numbers are the ~9 s cold start the operator had accepted: it was a
+* SUM of the opens, never the wait for the slowest source.
+*
+* Checked before shipping, because a probe that reads nothing has to survive
+* what it is not told: h264, h265 and a derived (`mid-to-low`) source all open
+* with `rc=0`, a 20 s run produces 200 frames of 200 either way (so the pacing
+* this file already lost once is untouched), and the skew is still 0 at 25 s
+* into a run — it is set at start-up and does not drift.
+*
+* What remains is the spread in when each source's first key frame arrives, and
+* a `/muted` dial waits for the next IDR. That spread is small here; if it ever
+* is not, the answer is to start the inputs from a join point we hold, NOT to
+* re-time the inputs (see `useWallclockTimestamps` below).
 */
-var ANALYZE_DURATION_US = 1e6;
-var PROBE_SIZE_BYTES = 1e6;
+var ANALYZE_DURATION_US = 0;
+var PROBE_SIZE_BYTES = 32;
 function inputPlanFor(source) {
 	return {
 		url: source.url,
@@ -1724,21 +1747,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() {
@@ -1748,7 +1768,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();
@@ -1762,7 +1782,7 @@ 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();
 	snapshots = null;
 	frameSampler = null;
 	ffmpegBinaryPath = "ffmpeg";
@@ -1865,7 +1885,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"),
@@ -1932,15 +1952,15 @@ var CameraGridAddon = class extends require_dist.BaseAddon {
 		}
 	}
 	/**
-	* Which profiles each grid can honestly publish, asked of the BROKER.
+	* 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();
@@ -1959,69 +1979,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.
+	*
+	* 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.
 	*
-	* 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.
+	* 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,
-				offered: offers.filter((offer) => offer.offered).map((offer) => offer.profile)
+				missingSources: [...plan.missingSources]
+			}
+		});
+		this.ctx.logger.info("camera grid: composing", {
+			tags: { deviceId },
+			meta: {
+				instanceId: instance.id,
+				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,
@@ -2032,6 +2053,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",
@@ -2081,11 +2104,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
 				});
 			}
 		});
@@ -2093,18 +2112,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) {
@@ -2113,10 +2128,7 @@ 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();
@@ -2124,7 +2136,7 @@ var CameraGridAddon = class extends require_dist.BaseAddon {
 		for (const instanceId of [...this.deviceIdByInstanceId.keys()]) {
 			if (live.has(instanceId)) continue;
 			this.deviceIdByInstanceId.delete(instanceId);
-			this.offersByInstanceId.delete(instanceId);
+			this.planByInstanceId.delete(instanceId);
 		}
 	}
 	/**
@@ -2137,10 +2149,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");
 		}
@@ -2175,24 +2184,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;
@@ -2217,11 +2217,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) {
@@ -2247,7 +2251,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");
@@ -2315,7 +2319,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;
@@ -2326,18 +2330,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;