@camstack/system 1.2.262 → 1.2.263

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

@@ -595,82 +595,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) {
@@ -689,6 +657,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.
 */
@@ -721,10 +726,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);
@@ -732,7 +734,7 @@ var GridSnapshotSource = class {
 			tags: { deviceId },
 			meta: {
 				reason: "never-composed",
-				profiles: sessions.length
+				compositions: sessions.length
 			}
 		});
 		return null;
@@ -741,18 +743,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: errMsg(error)
-				}
+				meta: { error: errMsg(error) }
 			});
 			return null;
 		}
@@ -806,24 +802,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;
 	}
@@ -862,16 +849,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;
 		}
@@ -905,7 +889,6 @@ var GridStreamRelay = class {
 							tags: { deviceId: session.deviceId },
 							meta: {
 								instanceId,
-								profile,
 								stalledForMs: SLOW_READER_MS
 							}
 						});
@@ -918,7 +901,6 @@ var GridStreamRelay = class {
 						tags: { deviceId: session.deviceId },
 						meta: {
 							instanceId,
-							profile,
 							reason
 						}
 					});
@@ -931,7 +913,6 @@ var GridStreamRelay = class {
 				tags: { deviceId: session.deviceId },
 				meta: {
 					instanceId,
-					profile,
 					error: errMsg(error)
 				}
 			});
@@ -967,13 +948,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",
@@ -982,8 +963,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
 	};
 }
@@ -1761,21 +1742,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() {
@@ -1785,7 +1763,7 @@ var GridSessionEntry = class {
 var CameraGridAddon = class extends 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();
@@ -1799,7 +1777,7 @@ var CameraGridAddon = class extends 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";
@@ -1902,7 +1880,7 @@ var CameraGridAddon = class extends 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 DeclaredDevices({
 			logger: this.ctx.logger.child("declaration"),
@@ -1969,15 +1947,15 @@ var CameraGridAddon = class extends 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();
@@ -1996,69 +1974,70 @@ var CameraGridAddon = class extends 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,
@@ -2069,6 +2048,8 @@ var CameraGridAddon = class extends 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",
@@ -2118,11 +2099,7 @@ var CameraGridAddon = class extends BaseAddon {
 				if (!instance) return null;
 				return gridPlanFor(instance, {
 					encoder: "libx264",
-					decodeHwAccel: null,
-					canvas: gridCanvasFor({
-						width: instance.width,
-						height: instance.height
-					}, profile)
+					decodeHwAccel: null
 				});
 			}
 		});
@@ -2130,18 +2107,14 @@ var CameraGridAddon = class extends 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) {
@@ -2150,10 +2123,7 @@ var CameraGridAddon = class extends 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();
@@ -2161,7 +2131,7 @@ var CameraGridAddon = class extends 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);
 		}
 	}
 	/**
@@ -2174,10 +2144,7 @@ var CameraGridAddon = class extends 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");
 		}
@@ -2212,24 +2179,15 @@ var CameraGridAddon = class extends 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;
@@ -2254,11 +2212,15 @@ var CameraGridAddon = class extends 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) {
@@ -2284,7 +2246,7 @@ var CameraGridAddon = class extends 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");
@@ -2350,4 +2312,4 @@ var CameraGridAddon = class extends BaseAddon {
 	}
 };
 //#endregion
-export { CameraGridAddon, CameraGridAddon as default, GRID_CAM_STREAM_ID, GRID_PROFILES, GRID_SILENCED_CAP_NAMES, GridCameraDevice, GridFrameSampler, GridLastFrameFileStore, GridSnapshotSource, GridStreamRelay, GridStreamSession, buildGridCameraDeclarations, buildGridFilterGraph, gridCamStreamId, gridCameraReconciliationIndex, gridCanvasFor, gridPlanFor, gridSnapshotAnswerFor, gridSourceDial, gridStreamDescriptor, gridStreamInvocation, installGridCameraRuntime, newGridCameraStableId, normalizeGridRows, offeredGridProfiles, parseGridStreamPath, readGridInstances, silenceAnalysisFor, startGridChild };
+export { CameraGridAddon, CameraGridAddon as default, GRID_CAM_STREAM_ID, GRID_OUTPUT_PROFILE, GRID_SILENCED_CAP_NAMES, GridCameraDevice, GridFrameSampler, GridLastFrameFileStore, GridSnapshotSource, GridStreamRelay, GridStreamSession, buildGridCameraDeclarations, buildGridFilterGraph, gridCameraReconciliationIndex, gridPlanFor, gridSnapshotAnswerFor, gridSourceDial, gridSourceProfiles, gridStreamDescriptor, gridStreamInvocation, installGridCameraRuntime, lowestServedProfile, newGridCameraStableId, normalizeGridRows, parseGridStreamPath, readGridInstances, silenceAnalysisFor, startGridChild };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/system",
-  "version": "1.2.262",
+  "version": "1.2.263",
   "description": "Core addon for CamStack — builtins, pipeline, process management, auth, logging, events",
   "keywords": [
     "camstack",