@camstack/system 1.2.267 → 1.2.269

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-BbPssgI6.js");
+const require_dist = require("../../dist-BTpfLiUX.js");
 let zod = require("zod");
 let _camstack_types_node = require("@camstack/types/node");
 let node_path = require("node:path");
@@ -260,11 +260,36 @@ var GridInstanceSchema = zod.z.object({
 	cameraStableId: zod.z.string().min(1).max(256),
 	name: zod.z.string().min(1).max(160),
 	enabled: zod.z.boolean(),
-	/** Canvas size — the composite camera's own resolution. */
-	width: zod.z.number().int().min(160).max(7680),
-	height: zod.z.number().int().min(120).max(4320),
+	/**
+	* NO canvas size. It is DERIVED, per profile, from the cells and the sources'
+	* own dimensions (`grid-canvas-derivation.ts`) — the two numbers that used to
+	* live here were typed into the editor and silently decided both how much the
+	* composite cost and how sharp it was.
+	*
+	* Rows written before that change still carry `width`/`height`; zod drops
+	* unknown keys, so they are ignored rather than migrated. Nothing reads them,
+	* and a migration that rewrote every row to delete two fields would be a
+	* write with no reader.
+	*/
 	fps: zod.z.number().int().min(1).max(60),
 	/**
+	* Which profiles this grid PUBLISHES, of the ones it could serve.
+	*
+	* Default `mid` + `low`, and the default is the finding: a grid's `high` is
+	* composed of its sources' `high`, so on this fleet it is a 4K canvas built
+	* from 4K decodes — a thing to opt into, not to be handed by a viewer's
+	* adaptive climbing to the top rung it can see.
+	*
+	* Absent on rows written before this, which is why the default lives in the
+	* schema rather than at the call site: an old grid starts publishing the two
+	* cheap rungs without anyone touching it.
+	*/
+	publishedProfiles: zod.z.array(zod.z.enum([
+		"high",
+		"mid",
+		"low"
+	])).max(3).default(["mid", "low"]),
+	/**
 	* Empty is the NORMAL freshly-created state: a grid is created from the
 	* integration page with a name only, and laid out afterwards in the camera's
 	* own settings. A grid with no cells declares its camera and emits nothing.
@@ -325,10 +350,7 @@ function gridPlanFor(instance, encode) {
 			cell: cell.cell
 		};
 	});
-	const canvas = encode.canvas ?? {
-		width: instance.width,
-		height: instance.height
-	};
+	const canvas = encode.canvas;
 	return {
 		layout: {
 			width: canvas.width,
@@ -926,92 +948,240 @@ var GridLastFrameFileStore = class {
 	}
 };
 //#endregion
-//#region src/builtins/camera-grid/grid-profiles.ts
+//#region src/builtins/camera-grid/grid-canvas.ts
+/** Bytes one yuv420p frame of this size occupies. */
+function yuv420pSize(width, height) {
+	return width * height + 2 * (width / 2) * (height / 2);
+}
 /**
-* One id, for every grid, forever.
+* Round DOWN to even.
 *
-* 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.
+* Down and not nearest: a tile that rounded UP would claim a row of samples the
+* decoder was never asked to produce, and the copy would either overrun or be
+* refused at the moment the picture is wanted.
 */
-var GRID_CAM_STREAM_ID = "grid";
+function evenDown(value) {
+	return Math.max(0, Math.floor(value / 2) * 2);
+}
+var GridCanvas = class {
+	width;
+	height;
+	buffer;
+	lumaBytes;
+	chromaBytes;
+	constructor(width, height) {
+		this.width = width;
+		this.height = height;
+		this.lumaBytes = width * height;
+		this.chromaBytes = width / 2 * (height / 2);
+		this.buffer = Buffer.alloc(yuv420pSize(width, height));
+		this.clear();
+	}
+	/**
+	* Legible black — Y 0, chroma 128 (neutral).
+	*
+	* `Buffer.alloc` already zeroes, and zeroed CHROMA is not black: it is a
+	* strong green. A cell nobody has filled yet has to look like an empty cell,
+	* not like a fault.
+	*/
+	clear() {
+		this.buffer.fill(0, 0, this.lumaBytes);
+		this.buffer.fill(128, this.lumaBytes);
+	}
+	/**
+	* Copy one decoded tile in at `origin`.
+	*
+	* Returns false — never throws, never writes a partial tile — when the tile
+	* does not fit, is the wrong size for the dimensions it claims, or sits on an
+	* odd boundary. This runs on the output tick, so a bad frame from one source
+	* must cost that source's rectangle and nothing else.
+	*/
+	blit(tile, size, origin) {
+		if (!isEven(size.width) || !isEven(size.height)) return false;
+		if (!isEven(origin.x) || !isEven(origin.y)) return false;
+		if (size.width <= 0 || size.height <= 0) return false;
+		if (origin.x < 0 || origin.y < 0) return false;
+		if (origin.x + size.width > this.width) return false;
+		if (origin.y + size.height > this.height) return false;
+		if (tile.length !== yuv420pSize(size.width, size.height)) return false;
+		for (let row = 0; row < size.height; row += 1) {
+			const from = row * size.width;
+			const to = (origin.y + row) * this.width + origin.x;
+			tile.copy(this.buffer, to, from, from + size.width);
+		}
+		const tileLuma = size.width * size.height;
+		const tileChroma = size.width / 2 * (size.height / 2);
+		const halfW = size.width / 2;
+		const halfH = size.height / 2;
+		const canvasHalfW = this.width / 2;
+		for (let plane = 0; plane < 2; plane += 1) {
+			const tileBase = tileLuma + plane * tileChroma;
+			const canvasBase = this.lumaBytes + plane * this.chromaBytes;
+			for (let row = 0; row < halfH; row += 1) {
+				const from = tileBase + row * halfW;
+				const to = canvasBase + (origin.y / 2 + row) * canvasHalfW + origin.x / 2;
+				tile.copy(this.buffer, to, from, from + halfW);
+			}
+		}
+		return true;
+	}
+};
+function isEven(value) {
+	return Number.isInteger(value) && value % 2 === 0;
+}
+//#endregion
+//#region src/builtins/camera-grid/grid-canvas-derivation.ts
 /**
-* The slot the single composition claims.
+* The canvas is a RESULT, not a field.
+*
+* ## Why the operator stopped typing it
+*
+* A grid's resolution used to be two numbers in the editor, beside FPS. They
+* looked harmless and were not: that number silently decided how much the
+* composite cost and how sharp it was. An operator typing 1920x1080 was, without
+* being told, committing the hub to reading two 4 MP streams — or, with the
+* rule before it, to upscaling a 640x360 sub-stream by 3x. Neither is a thing
+* anyone can be expected to work out from a text field.
+*
+* ## What it is derived from
+*
+* The operator draws two rectangles per camera — which part of the source to
+* take, and where it lands — and both are fractions, so nothing is pixels yet.
+* Exactly one number is missing: how many pixels the whole canvas is worth.
+*
+* A cell has `sourceResolution x crop` REAL pixels behind it. Showing them 1:1
+* neither invents nor discards anything, so the cell should be exactly that
+* many pixels — and since the cell is a fraction `f` of the canvas, the canvas
+* it implies is `real / f`. Each cell proposes one, and the LARGEST wins: the
+* hungriest cell is served 1:1 and the others scale down by a hair, never up.
+*
+* Gaps change nothing. Cells need not cover the canvas, and an uncovered part
+* is background — it has no pixels to propose.
+*
+* ## One per profile
 *
-* 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.
+* A source is a different size at each profile, so each profile derives its own
+* canvas: a grid's `low` composes its sources' `low` onto the canvas their
+* `low` implies. That is what makes the three outputs 1:1 with what they are
+* made of, and what lets a viewer's adaptive pick a rung without the grid
+* needing to know it exists.
 */
-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;
-}
-/** The pixels a cell needs BEHIND it, before the crop takes its share. */
-function requiredSourceSize(cell, canvas) {
-	const tileWidth = cell.cell.width * canvas.width;
-	const tileHeight = cell.cell.height * canvas.height;
-	const cropWidth = cell.source.width > 0 ? cell.source.width : 1;
-	const cropHeight = cell.source.height > 0 ? cell.source.height : 1;
+/**
+* What an encoder will take. Not a taste: `libx264` refuses beyond 8192 in
+* either axis, and a canvas that large is a composition nobody can decode
+* anyway. Reached only by a cell that shows a sliver of a source at full
+* canvas width, which is a layout, not a mistake — so it is CLAMPED rather
+* than refused, and clamped in both axes together so the picture the operator
+* drew keeps its shape.
+*/
+var MAX_CANVAS_WIDTH = 7680;
+var MAX_CANVAS_HEIGHT = 4320;
+/** Below this a composition is not a cheaper picture, it is no picture. */
+var MIN_CANVAS_EDGE = 160;
+/**
+* The canvas these cells imply, or `null` when they imply none.
+*
+* `null` for a grid with no cells — the normal freshly-created state — and for
+* a layout whose every rectangle is degenerate. Both are "there is no picture
+* to size", which the caller turns into "this profile is not on offer" rather
+* than into a guess.
+*/
+function deriveGridCanvas(cells) {
+	let width = 0;
+	let height = 0;
+	for (const entry of cells) {
+		if (entry.cell.width <= 0 || entry.cell.height <= 0) continue;
+		if (entry.sourceSize.width <= 0 || entry.sourceSize.height <= 0) continue;
+		const realWidth = entry.sourceSize.width * entry.source.width;
+		const realHeight = entry.sourceSize.height * entry.source.height;
+		if (realWidth <= 0 || realHeight <= 0) continue;
+		width = Math.max(width, realWidth / entry.cell.width);
+		height = Math.max(height, realHeight / entry.cell.height);
+	}
+	if (width <= 0 || height <= 0) return null;
+	const overshoot = Math.max(width / MAX_CANVAS_WIDTH, height / MAX_CANVAS_HEIGHT, 1);
+	const factor = Math.max(MIN_CANVAS_EDGE / width, MIN_CANVAS_EDGE / height, 1) / overshoot;
 	return {
-		width: tileWidth / cropWidth,
-		height: tileHeight / cropHeight
+		width: Math.max(2, evenDown(width * factor)),
+		height: Math.max(2, evenDown(height * factor))
 	};
 }
+//#endregion
+//#region src/builtins/camera-grid/grid-profiles.ts
 /**
-* The cheapest stream that covers `need`, or the BIGGEST when none does.
+* One id per profile, for every grid, forever.
 *
-* Soft beats absent: a camera whose best stream cannot fill its cell still
-* composes, at the best it has. Refusing would take the whole grid down over
-* one cell being drawn larger than its source.
-*
-* A stream that states NO size cannot be compared, so it is ordered as cheapest
-* rather than discarded — an unmeasurable stream is still a stream, and the
-* picture is what the operator asked for.
+* D519's reason is what keeps `high`'s id bare: a 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 any of this and still is.
 */
-function bestFit(served, need) {
-	if (served.length === 0) return null;
-	const order = new Map(CHEAPEST_FIRST.map((profile, index) => [profile, index]));
-	const cheapestFirst = [...served].sort((a, b) => (order.get(a.profile) ?? 0) - (order.get(b.profile) ?? 0));
-	const unmeasurable = cheapestFirst.find((s) => s.width <= 0 || s.height <= 0);
-	if (unmeasurable !== void 0) return unmeasurable.profile;
-	const covering = cheapestFirst.find((s) => s.width >= need.width && s.height >= need.height);
-	if (covering !== void 0) return covering.profile;
-	return cheapestFirst.reduce((best, s) => s.width * s.height > best.width * best.height ? s : best).profile;
+var GRID_CAM_STREAM_ID = "grid";
+/** Every profile a grid can compose, in descending quality. */
+var GRID_PROFILES = [
+	"high",
+	"mid",
+	"low"
+];
+/** 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}`;
 }
-/** Which stream to read each source at, and who cannot be read at all. */
-function gridSourceProfiles(input) {
-	const neededBySource = /* @__PURE__ */ new Map();
-	for (const cell of input.cells) {
-		const need = requiredSourceSize(cell, input.canvas);
-		const current = neededBySource.get(cell.deviceId);
-		neededBySource.set(cell.deviceId, {
-			width: Math.max(current?.width ?? 0, need.width),
-			height: Math.max(current?.height ?? 0, need.height)
-		});
-	}
-	const profileBySource = /* @__PURE__ */ new Map();
-	const missingSources = [];
-	for (const [deviceId, need] of neededBySource) {
-		const served = input.profilesServedBy(deviceId);
-		const chosen = served === null ? null : bestFit(served, need);
-		if (chosen === null) missingSources.push(deviceId);
-		else profileBySource.set(deviceId, chosen);
-	}
-	return {
-		offered: neededBySource.size > 0 && missingSources.length === 0,
-		profileBySource,
-		missingSources
-	};
+/**
+* What this grid can honestly publish, per profile, with the canvas or the
+* refusal.
+*
+* 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 gridProfilePlans(input) {
+	const sourceDeviceIds = [...new Set(input.cells.map((cell) => cell.deviceId))];
+	const servedBy = /* @__PURE__ */ new Map();
+	for (const deviceId of sourceDeviceIds) servedBy.set(deviceId, input.profilesServedBy(deviceId));
+	return GRID_PROFILES.map((profile) => {
+		if (sourceDeviceIds.length === 0) return {
+			profile,
+			offered: false,
+			missingSources: []
+		};
+		const sizeBySource = /* @__PURE__ */ new Map();
+		const missingSources = [];
+		for (const deviceId of sourceDeviceIds) {
+			const match = (servedBy.get(deviceId) ?? null)?.find((entry) => entry.profile === profile);
+			if (match === void 0 || match.width <= 0 || match.height <= 0) {
+				missingSources.push(deviceId);
+				continue;
+			}
+			sizeBySource.set(deviceId, {
+				width: match.width,
+				height: match.height
+			});
+		}
+		if (missingSources.length > 0) return {
+			profile,
+			offered: false,
+			missingSources
+		};
+		const canvas = deriveGridCanvas(input.cells.map((cell) => ({
+			source: cell.source,
+			cell: cell.cell,
+			sourceSize: sizeBySource.get(cell.deviceId) ?? {
+				width: 0,
+				height: 0
+			}
+		})));
+		if (canvas === null) return {
+			profile,
+			offered: false,
+			missingSources: []
+		};
+		return {
+			profile,
+			offered: true,
+			canvas,
+			published: input.publishedProfiles.includes(profile)
+		};
+	});
 }
 //#endregion
 //#region src/builtins/camera-grid/grid-sentry-sources.ts
@@ -1176,15 +1346,24 @@ 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;
-/** `/grid/<instanceId>.flv`, or `null` when it is anything else. */
+function asProfile(raw) {
+	return GRID_PROFILES.find((profile) => profile === raw) ?? null;
+}
+/** `/grid/<instanceId>/<profile>.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);
-	if (raw.length === 0 || raw.includes("/")) return null;
+	const at = raw.lastIndexOf("/");
+	if (at <= 0) return null;
+	const profile = asProfile(raw.slice(at + 1));
+	if (profile === null) return null;
 	try {
-		const instanceId = decodeURIComponent(raw);
-		return instanceId.length > 0 ? { instanceId } : null;
+		const instanceId = decodeURIComponent(raw.slice(0, at));
+		return instanceId.length > 0 ? {
+			instanceId,
+			profile
+		} : null;
 	} catch {
 		return null;
 	}
@@ -1223,13 +1402,16 @@ 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}${PATH_SUFFIX}`;
+		return `${this.baseUrl}${PATH_PREFIX}${instance}/${request.profile}${PATH_SUFFIX}`;
 	}
 	async serve(request, res) {
-		const { instanceId } = request;
+		const { instanceId, profile } = 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 } });
+			this.deps.logger.warn("camera grid: a stream was requested for an unknown grid", { meta: {
+				instanceId,
+				profile
+			} });
 			res.writeHead(404).end();
 			return;
 		}
@@ -1263,6 +1445,7 @@ var GridStreamRelay = class {
 							tags: { deviceId: session.deviceId },
 							meta: {
 								instanceId,
+								profile,
 								stalledForMs: SLOW_READER_MS
 							}
 						});
@@ -1275,6 +1458,7 @@ var GridStreamRelay = class {
 						tags: { deviceId: session.deviceId },
 						meta: {
 							instanceId,
+							profile,
 							reason
 						}
 					});
@@ -1287,6 +1471,7 @@ var GridStreamRelay = class {
 				tags: { deviceId: session.deviceId },
 				meta: {
 					instanceId,
+					profile,
 					error: require_dist.errMsg(error)
 				}
 			});
@@ -1322,13 +1507,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.
 *
-* 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.
+* With several compositions published the hint does a second job: it 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.
 */
 function gridStreamDescriptor(input) {
 	return {
-		camStreamId: GRID_CAM_STREAM_ID,
+		camStreamId: gridCamStreamId(input.profile),
 		kind: GRID_WIRE_STREAM_KIND,
 		url: input.url,
 		codec: "h264",
@@ -1337,8 +1522,8 @@ function gridStreamDescriptor(input) {
 			height: input.height
 		},
 		fps: input.fps,
-		label: "Grid composition",
-		profileHint: GRID_OUTPUT_PROFILE,
+		label: `Grid composition (${input.profile})`,
+		profileHint: input.profile,
 		autoEligible: true
 	};
 }
@@ -1841,88 +2026,6 @@ async function silenceAnalysisFor(deps, deviceId) {
 	if (failures.length > 0) throw new Error(`camera grid ${deviceId}: could not switch off ${failures.length} analyzer(s) — it will run at full detection cost (${failures.join("; ")})`);
 }
 //#endregion
-//#region src/builtins/camera-grid/grid-canvas.ts
-/** Bytes one yuv420p frame of this size occupies. */
-function yuv420pSize(width, height) {
-	return width * height + 2 * (width / 2) * (height / 2);
-}
-/**
-* Round DOWN to even.
-*
-* Down and not nearest: a tile that rounded UP would claim a row of samples the
-* decoder was never asked to produce, and the copy would either overrun or be
-* refused at the moment the picture is wanted.
-*/
-function evenDown(value) {
-	return Math.max(0, Math.floor(value / 2) * 2);
-}
-var GridCanvas = class {
-	width;
-	height;
-	buffer;
-	lumaBytes;
-	chromaBytes;
-	constructor(width, height) {
-		this.width = width;
-		this.height = height;
-		this.lumaBytes = width * height;
-		this.chromaBytes = width / 2 * (height / 2);
-		this.buffer = Buffer.alloc(yuv420pSize(width, height));
-		this.clear();
-	}
-	/**
-	* Legible black — Y 0, chroma 128 (neutral).
-	*
-	* `Buffer.alloc` already zeroes, and zeroed CHROMA is not black: it is a
-	* strong green. A cell nobody has filled yet has to look like an empty cell,
-	* not like a fault.
-	*/
-	clear() {
-		this.buffer.fill(0, 0, this.lumaBytes);
-		this.buffer.fill(128, this.lumaBytes);
-	}
-	/**
-	* Copy one decoded tile in at `origin`.
-	*
-	* Returns false — never throws, never writes a partial tile — when the tile
-	* does not fit, is the wrong size for the dimensions it claims, or sits on an
-	* odd boundary. This runs on the output tick, so a bad frame from one source
-	* must cost that source's rectangle and nothing else.
-	*/
-	blit(tile, size, origin) {
-		if (!isEven(size.width) || !isEven(size.height)) return false;
-		if (!isEven(origin.x) || !isEven(origin.y)) return false;
-		if (size.width <= 0 || size.height <= 0) return false;
-		if (origin.x < 0 || origin.y < 0) return false;
-		if (origin.x + size.width > this.width) return false;
-		if (origin.y + size.height > this.height) return false;
-		if (tile.length !== yuv420pSize(size.width, size.height)) return false;
-		for (let row = 0; row < size.height; row += 1) {
-			const from = row * size.width;
-			const to = (origin.y + row) * this.width + origin.x;
-			tile.copy(this.buffer, to, from, from + size.width);
-		}
-		const tileLuma = size.width * size.height;
-		const tileChroma = size.width / 2 * (size.height / 2);
-		const halfW = size.width / 2;
-		const halfH = size.height / 2;
-		const canvasHalfW = this.width / 2;
-		for (let plane = 0; plane < 2; plane += 1) {
-			const tileBase = tileLuma + plane * tileChroma;
-			const canvasBase = this.lumaBytes + plane * this.chromaBytes;
-			for (let row = 0; row < halfH; row += 1) {
-				const from = tileBase + row * halfW;
-				const to = canvasBase + (origin.y / 2 + row) * canvasHalfW + origin.x / 2;
-				tile.copy(this.buffer, to, from, from + halfW);
-			}
-		}
-		return true;
-	}
-};
-function isEven(value) {
-	return Number.isInteger(value) && value % 2 === 0;
-}
-//#endregion
 //#region src/builtins/camera-grid/grid-tile-feed.ts
 /**
 * One source's decoded tiles, of which only the LATEST is ever wanted.
@@ -1974,6 +2077,20 @@ var GridTileFeed = class {
 	hasFresh() {
 		return this.fresh;
 	}
+	/**
+	* Forget the half frame, keep the picture.
+	*
+	* Raw video has no framing: the feed cuts on a fixed length, so bytes from a
+	* NEW decoder concatenated onto a partial frame from the old one would be
+	* misaligned for ever — every frame after it sheared, with nothing to
+	* re-sync on. Called whenever a tile's decoder is replaced.
+	*
+	* The newest frame is kept deliberately: the cell holds its last picture
+	* while its decoder comes back, instead of blinking to black.
+	*/
+	resetPartial() {
+		this.partial = Buffer.alloc(0);
+	}
 	/** For the bound in the spec: one frame plus at most a partial one. */
 	bufferedBytes() {
 		return (this.newest?.length ?? 0) + this.partial.length;
@@ -2057,6 +2174,16 @@ var GridCompositor = class {
 		}
 		return this.deps.write(this.canvas.buffer);
 	}
+	/**
+	* A tile's decoder was replaced: drop its half frame, keep its picture.
+	*
+	* Without this the new decoder's bytes would be appended to the old one's
+	* partial frame and every frame after would be sheared — raw video has no
+	* framing to re-sync on.
+	*/
+	resetTile(tileId) {
+		this.placed.get(tileId)?.feed.resetPartial();
+	}
 	/** After this, a tick emits nothing — a dead child must not keep writing. */
 	close() {
 		this.closed = true;
@@ -2243,13 +2370,22 @@ function gridCanvasEncoderInvocation(input) {
 * is how a stalled encoder becomes an OOM, and a dropped frame in a live
 * composite costs nothing anybody can see.
 *
-* ## Any child exiting ends the composition
+* ## A tile comes back; only the ENCODER ends the composition
+*
+* Every child exiting used to end it, on the reasoning that a frozen tile is a
+* nicer picture and a worse fact. In practice it produced neither: a 4K source
+* ended mid-run (`code=0` — the input simply finished), the composition tore
+* down, the consumer re-dialled, and the grid served nothing but restarts. That
+* is what the operator saw as the `auto` rung being stuck.
 *
-* Same policy as the single child (`maxRestarts: 0`): the session tells its
-* consumers why and tears down, and the next read starts a cold composition
-* with freshly acquired sources. Leaving a dead tile frozen while the others
-* run would be a nicer picture and a worse fact — the operator would be looking
-* at a camera that stopped minutes ago with nothing saying so.
+* A canvas makes the better answer cheap: while a decoder comes back, its cell
+* holds the last frame it produced and every other cell carries on. The bound
+* (`TILE_MAX_RESTARTS`) keeps a source that is genuinely gone from respawning
+* for ever — and when it is reached, the composition does end, with the tile
+* named.
+*
+* The encoder is different: nothing downstream of it exists without it, so its
+* exit is the composition's exit, first time.
 */
 /**
 * The encoder must produce its first bytes quickly, because the tick feeds it a
@@ -2263,6 +2399,15 @@ var ENCODER_FIRST_DATA_MS = 5e3;
 * already on screen.
 */
 var DECODER_FIRST_DATA_MS = 15e3;
+/**
+* How many times a tile's decoder may come back before the composition gives up
+* on it.
+*
+* The bound exists so a source that is genuinely gone still ends the
+* composition rather than respawning for ever; below it, a decoder that dies is
+* simply replaced while its cell holds the last frame it produced.
+*/
+var TILE_MAX_RESTARTS = 5;
 async function startGridCompositorChild(ctx, plan, sources, onEnded) {
 	const tilePlan = buildGridTilePlan({
 		canvas: {
@@ -2372,14 +2517,17 @@ async function startGridCompositorChild(ctx, plan, sources, onEnded) {
 				height: tile.size.height
 			},
 			firstDataTimeoutMs: DECODER_FIRST_DATA_MS,
-			maxRestarts: 0,
+			maxRestarts: TILE_MAX_RESTARTS,
 			onChild: (child) => {
 				child.stdout?.on("data", (chunk) => {
 					compositor.onTile(tile.id, chunk);
 				});
 				child.stderr?.on("data", () => {});
 			},
-			onExit: (exit) => end(`tile ${tile.id}:${exit.classification}`)
+			onExit: () => {
+				compositor.resetTile(tile.id);
+			},
+			onGiveUp: (error) => end(`tile ${tile.id}: ${error.message}`)
 		});
 		decoders.push(decoder);
 		await decoder.start();
@@ -2424,18 +2572,26 @@ var DEFAULTS = {
 	cameraGrids: [],
 	cameraGridTombstones: []
 };
+/** One composition per (grid, profile) — a grid composes each separately. */
+function sessionKey(instanceId, profile) {
+	return `${instanceId}::${profile}`;
+}
 /**
-* One grid's composition — there is exactly one, keyed by the grid itself.
+* One grid's composition of one profile.
 *
-* 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.
+* The profile is back in the key after a spell with a single output. What made
+* the per-profile shape painful was never the count: it was that a rebuild
+* meant a blank screen until the slowest source produced a key frame. An output
+* clock (D530) shows the picture at once and fills the cells in, so a rung the
+* adaptive can stand on costs what it is worth.
 */
 var GridSessionEntry = class {
 	instanceId;
+	profile;
 	session;
-	constructor(instanceId, session) {
+	constructor(instanceId, profile, session) {
 		this.instanceId = instanceId;
+		this.profile = profile;
 		this.session = session;
 	}
 	isRunning() {
@@ -2459,7 +2615,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.
 	*/
-	planByInstanceId = /* @__PURE__ */ new Map();
+	plansByInstanceId = /* @__PURE__ */ new Map();
 	activity = null;
 	snapshots = null;
 	frameSampler = null;
@@ -2692,9 +2848,9 @@ var CameraGridAddon = class extends require_dist.BaseAddon {
 			if (instance.cells.filter((cell) => cell.deviceId === sourceDeviceId).length === 0) continue;
 			targets.push({
 				deviceId,
-				canvas: {
-					width: instance.width,
-					height: instance.height
+				canvas: this.canvasFor(instanceId) ?? {
+					width: 0,
+					height: 0
 				},
 				cellsForSource: (id) => instance.cells.filter((cell) => cell.deviceId === id).map((cell) => ({
 					source: cell.source,
@@ -2737,11 +2893,8 @@ var CameraGridAddon = class extends require_dist.BaseAddon {
 			servedBy.set(slot.deviceId, profiles);
 		}
 		for (const instance of instances) {
-			const plan = gridSourceProfiles({
-				canvas: {
-					width: instance.width,
-					height: instance.height
-				},
+			const plans = gridProfilePlans({
+				publishedProfiles: instance.publishedProfiles,
 				cells: instance.cells.map((cell) => ({
 					deviceId: cell.deviceId,
 					source: cell.source,
@@ -2749,9 +2902,9 @@ var CameraGridAddon = class extends require_dist.BaseAddon {
 				})),
 				profilesServedBy: (deviceId) => servedBy.get(deviceId) ?? null
 			});
-			const previous = this.planByInstanceId.get(instance.id);
-			this.planByInstanceId.set(instance.id, plan);
-			this.logSourcePlan(instance, plan, previous);
+			const previous = this.plansByInstanceId.get(instance.id);
+			this.plansByInstanceId.set(instance.id, plans);
+			this.logSourcePlan(instance, plans, previous);
 		}
 	}
 	/**
@@ -2767,48 +2920,65 @@ var CameraGridAddon = class extends require_dist.BaseAddon {
 	* Logged on the EDGE: a grid that cannot be composed would otherwise write a
 	* line a minute for ever.
 	*/
-	logSourcePlan(instance, plan, previous) {
-		const shape = (value) => JSON.stringify([
-			value.offered,
-			[...value.profileBySource],
-			value.missingSources
-		]);
-		if (previous !== void 0 && shape(previous) === shape(plan)) return;
+	logSourcePlan(instance, plans, previous) {
+		const shape = (value) => JSON.stringify(value);
+		if (previous !== void 0 && shape(previous) === shape(plans)) return;
 		const deviceId = this.deviceIdByInstanceId.get(instance.id) ?? 0;
-		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", {
+		for (const row of plans) {
+			if (row.offered || row.missingSources.length === 0) continue;
+			this.ctx.logger.info("camera grid: a profile is NOT on offer", {
+				tags: { deviceId },
+				meta: {
+					instanceId: instance.id,
+					profile: row.profile,
+					missingSources: [...row.missingSources]
+				}
+			});
+		}
+		this.ctx.logger.info("camera grid: published profiles", {
 			tags: { deviceId },
 			meta: {
 				instanceId: instance.id,
-				offered: plan.offered,
-				readAt: Object.fromEntries([...plan.profileBySource].map(([id, p]) => [String(id), p]))
+				offered: Object.fromEntries(plans.filter((row) => row.offered && row.published).map((row) => [row.profile, row.offered ? `${String(row.canvas.width)}x${String(row.canvas.height)}` : ""]))
 			}
 		});
 	}
-	planFor(instanceId) {
-		return this.planByInstanceId.get(instanceId) ?? null;
+	plansFor(instanceId) {
+		return this.plansByInstanceId.get(instanceId) ?? null;
+	}
+	planFor(instanceId, profile) {
+		return this.plansFor(instanceId)?.find((row) => row.profile === profile) ?? null;
+	}
+	/**
+	* The canvas of the BEST profile this grid offers.
+	*
+	* Used where a single geometry is needed for something that is not a
+	* composition — the detection boxes a grid forwards (`grid-activity`), which
+	* are normalized against whatever picture the viewer is looking at. The best
+	* offered one is the honest default; a grid offering nothing has no geometry
+	* and says so.
+	*/
+	canvasFor(instanceId) {
+		for (const row of this.plansFor(instanceId) ?? []) if (row.offered) return row.canvas;
+		return null;
 	}
 	ensureSessions(instanceId, deviceId) {
-		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();
+		for (const profile of GRID_PROFILES) {
+			const key = sessionKey(instanceId, profile);
+			const plan = this.planFor(instanceId, profile);
+			if (plan === null || !plan.offered || !plan.published) {
+				const stale = this.sessions.get(key);
+				if (stale) {
+					this.sessions.delete(key);
+					stale.session.dispose();
+				}
+				continue;
 			}
-			return;
+			if (this.sessions.has(key)) continue;
+			this.sessions.set(key, new GridSessionEntry(instanceId, profile, this.makeSession(instanceId, deviceId, profile)));
 		}
-		if (this.sessions.has(instanceId)) return;
-		const session = this.makeSession(instanceId, deviceId);
-		this.sessions.set(instanceId, new GridSessionEntry(instanceId, session));
 	}
-	makeSession(instanceId, deviceId) {
+	makeSession(instanceId, deviceId, profile) {
 		const childContext = {
 			binaryPath: this.ffmpegBinaryPath,
 			logger: this.ctx.logger,
@@ -2819,8 +2989,6 @@ 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",
@@ -2867,10 +3035,12 @@ var CameraGridAddon = class extends require_dist.BaseAddon {
 			},
 			resolvePlan: () => {
 				const instance = this.instanceById(instanceId);
-				if (!instance) return null;
+				const plan = this.planFor(instanceId, profile);
+				if (!instance || plan === null || !plan.offered || !plan.published) return null;
 				return gridPlanFor(instance, {
 					encoder: "libx264",
-					decodeHwAccel: null
+					decodeHwAccel: null,
+					canvas: plan.canvas
 				});
 			}
 		});
@@ -2878,14 +3048,18 @@ 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(request.instanceId)?.session ?? null;
+		return this.sessions.get(sessionKey(request.instanceId, request.profile))?.session ?? null;
 	}
-	/** This grid's composition, as the list the snapshot source expects. */
+	/** This grid's sessions, in DESCENDING quality — the snapshot takes the first running one. */
 	sessionsForDevice(deviceId) {
 		const instanceId = this.instanceIdForDevice(deviceId);
 		if (instanceId === null) return [];
-		const entry = this.sessions.get(instanceId);
-		return entry ? [entry] : [];
+		const entries = [];
+		for (const profile of GRID_PROFILES) {
+			const entry = this.sessions.get(sessionKey(instanceId, profile));
+			if (entry) entries.push(entry);
+		}
+		return entries;
 	}
 	/** A grid that is gone stops immediately - it must not keep N sources dialled. */
 	async retireWithdrawnSessions(instances) {
@@ -2903,7 +3077,7 @@ var CameraGridAddon = class extends require_dist.BaseAddon {
 			if (live.has(instanceId)) continue;
 			this.activity?.forget(this.deviceIdByInstanceId.get(instanceId) ?? 0);
 			this.deviceIdByInstanceId.delete(instanceId);
-			this.planByInstanceId.delete(instanceId);
+			this.plansByInstanceId.delete(instanceId);
 		}
 	}
 	/**
@@ -2951,15 +3125,18 @@ var CameraGridAddon = class extends require_dist.BaseAddon {
 	descriptorsFor(instanceId) {
 		const instance = this.instanceById(instanceId);
 		const relay = this.relay;
-		const plan = this.planFor(instanceId);
-		if (!instance || !relay || plan === null) return null;
-		if (!plan.offered) return [];
-		return [gridStreamDescriptor({
-			width: instance.width,
-			height: instance.height,
+		const plans = this.plansFor(instanceId);
+		if (!instance || !relay || plans === null) return null;
+		return plans.filter((row) => row.offered && row.published).map((row) => gridStreamDescriptor({
+			profile: row.profile,
+			width: row.offered ? row.canvas.width : 0,
+			height: row.offered ? row.canvas.height : 0,
 			fps: instance.fps,
-			url: relay.streamUrl({ instanceId })
-		})];
+			url: relay.streamUrl({
+				instanceId,
+				profile: row.profile
+			})
+		}));
 	}
 	instanceIdForDevice(deviceId) {
 		for (const [instanceId, id] of this.deviceIdByInstanceId) if (id === deviceId) return instanceId;
@@ -2976,23 +3153,19 @@ var CameraGridAddon = class extends require_dist.BaseAddon {
 			instanceId: instance.id,
 			deviceId,
 			name: instance.name,
-			width: instance.width,
-			height: instance.height,
 			fps: instance.fps,
 			cells: instance.cells.map((cell) => ({
 				deviceId: cell.deviceId,
 				source: cell.source,
 				cell: cell.cell
 			})),
-			profiles: (() => {
-				const plan = this.planByInstanceId.get(instance.id);
-				if (plan === void 0) return [];
-				return [{
-					profile: GRID_OUTPUT_PROFILE,
-					offered: plan.offered,
-					missingSources: [...plan.missingSources]
-				}];
-			})()
+			profiles: (this.plansByInstanceId.get(instance.id) ?? []).map((row) => ({
+				profile: row.profile,
+				offered: row.offered,
+				published: row.offered && row.published,
+				missingSources: row.offered ? [] : [...row.missingSources],
+				canvas: row.offered ? `${String(row.canvas.width)}x${String(row.canvas.height)}` : ""
+			}))
 		};
 	}
 	async saveGridLayout(input) {
@@ -3001,9 +3174,8 @@ var CameraGridAddon = class extends require_dist.BaseAddon {
 		const updated = {
 			...instance,
 			...input.name !== void 0 ? { name: input.name.trim() } : {},
-			...input.width !== void 0 ? { width: input.width } : {},
-			...input.height !== void 0 ? { height: input.height } : {},
 			...input.fps !== void 0 ? { fps: input.fps } : {},
+			...input.publishedProfiles !== void 0 ? { publishedProfiles: [...input.publishedProfiles] } : {},
 			cells: input.cells.map((cell) => ({ ...cell }))
 		};
 		this.ctx.logger.info("camera grid: layout saved", {
@@ -3011,7 +3183,7 @@ var CameraGridAddon = class extends require_dist.BaseAddon {
 			meta: {
 				cells: updated.cells.length,
 				sources: [...new Set(updated.cells.map((cell) => cell.deviceId))],
-				canvas: `${String(updated.width)}x${String(updated.height)}`
+				fps: updated.fps
 			}
 		});
 		await this.updateGlobalSettings({ cameraGrids: this.config.cameraGrids.map((row) => row["id"] === instance.id ? {
@@ -3350,7 +3522,7 @@ async function startGridChild(ctx, plan, sources, onEnded) {
 //#endregion
 exports.CameraGridAddon = CameraGridAddon;
 exports.GRID_CAM_STREAM_ID = GRID_CAM_STREAM_ID;
-exports.GRID_OUTPUT_PROFILE = GRID_OUTPUT_PROFILE;
+exports.GRID_PROFILES = GRID_PROFILES;
 exports.GRID_SILENCED_CAP_NAMES = GRID_SILENCED_CAP_NAMES;
 exports.GridCameraDevice = GridCameraDevice;
 exports.GridFrameSampler = GridFrameSampler;
@@ -3361,15 +3533,16 @@ exports.GridStreamSession = GridStreamSession;
 exports.buildGridCameraDeclarations = buildGridCameraDeclarations;
 exports.buildGridFilterGraph = buildGridFilterGraph;
 exports.default = CameraGridAddon;
+exports.deriveGridCanvas = deriveGridCanvas;
+exports.gridCamStreamId = gridCamStreamId;
 exports.gridCameraReconciliationIndex = gridCameraReconciliationIndex;
 exports.gridPlanFor = gridPlanFor;
+exports.gridProfilePlans = gridProfilePlans;
 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.parseGridStreamPath = parseGridStreamPath;