@camstack/addon-terminal 0.1.52 → 0.1.54

package/dist/addon.js

@@ -8117,6 +8117,20 @@ var RelocateJobSchema = object({
 	* in its row, not in its name, so `MediaRelocateEngine` never reconciles one.
 	*/
 	rowsReconciled: number().int().nonnegative().optional(),
+	/**
+	* Rows this run FORGOT because the file they name is not on disk.
+	*
+	* The mover derived the path from the row's own fields and `stat`ed it; an
+	* ENOENT there is a per-path confirmation that the segment is gone (D296),
+	* and the durable row is dropped through the same channel eviction uses. It
+	* is reported for the same reason `rowsReconciled` is: this is a durable
+	* mutation nobody asked for, and a migration that quietly erases hour rows is
+	* the same failure as one that quietly skips them (D295).
+	*
+	* The production drain of 2026-08-30 would have reported 11 074 here — the
+	* ledger claimed 5.65 GB of footage that no longer existed.
+	*/
+	rowsForgotten: number().int().nonnegative().optional(),
 	startedAt: number(),
 	finishedAt: number().nullable(),
 	error: string().nullable()
@@ -8480,6 +8494,91 @@ var RelocateResidueSchema = object({
 	segments: number().int().nonnegative(),
 	bytes: number().int().nonnegative()
 }).nullable();
+/**
+* Ask one location whether its durable hour rows describe the disk — the walk
+* (D319).
+*
+* `apply` DEFAULTS TO FALSE and that default is the product: the operator's
+* missing tool is the question, and the dry run is how they sanity-check the
+* destructive run before authorising it.
+*/
+var LedgerWalkInputSchema = object({
+	locationId: string().min(1),
+	/** Forget the confirmed-absent rows, rather than only counting them. */
+	apply: boolean().optional(),
+	/** Narrow to one camera. */
+	deviceId: number().int().positive().optional(),
+	/** Narrow to these recording profiles; empty/absent = every profile. */
+	profiles: array(string().min(1)).optional()
+});
+/** Why a whole walk did nothing. Every one leaves the ledger untouched. */
+var LedgerWalkRefusalSchema = _enum([
+	"location-unknown",
+	"source-writable",
+	"no-ledger",
+	"archive-unreadable",
+	"anchor-absent",
+	"anchor-unreadable",
+	"anchor-moved"
+]);
+_enum([
+	"live-tail",
+	"listing-error",
+	"path-mismatch",
+	"durable-refused"
+]);
+/** Every skip reason, always present, always a number — so a reason that never
+*  fired reports as zero rather than absent and the report shape is constant
+*  between passes. Spelled out rather than `z.record` for exactly that. */
+var LedgerWalkSkipCountsSchema = object({
+	"live-tail": number().int().nonnegative(),
+	"listing-error": number().int().nonnegative(),
+	"path-mismatch": number().int().nonnegative(),
+	"durable-refused": number().int().nonnegative()
+});
+/** One camera's share of a walk, so a report names cameras and not rows. */
+var LedgerWalkDeviceReportSchema = object({
+	deviceId: number().int(),
+	hoursWalked: number().int().nonnegative(),
+	hoursMissing: number().int().nonnegative(),
+	ghostSegments: number().int().nonnegative(),
+	ghostBytes: number().int().nonnegative(),
+	forgottenSegments: number().int().nonnegative(),
+	orphanFiles: number().int().nonnegative()
+});
+/**
+* What one walk claimed, listed, found and (only when armed) forgot.
+*
+* `archiveSegments` is the **M** and `segmentsClaimed` the **N** (D295), so a
+* walk that saw a fraction of the location is visible in its own report rather
+* than in the absence of one.
+*/
+var LedgerWalkReportSchema = object({
+	locationId: string(),
+	applied: boolean(),
+	refused: LedgerWalkRefusalSchema.nullable(),
+	archiveSegments: number().int().nonnegative().nullable(),
+	archiveBytes: number().int().nonnegative().nullable(),
+	hoursClaimed: number().int().nonnegative(),
+	hoursWalked: number().int().nonnegative(),
+	hoursMissing: number().int().nonnegative(),
+	/** `readdir` calls issued — the cost, stated in the unit that is paid. */
+	listings: number().int().nonnegative(),
+	segmentsClaimed: number().int().nonnegative(),
+	ghostSegments: number().int().nonnegative(),
+	ghostBytes: number().int().nonnegative(),
+	ghostHoursWhole: number().int().nonnegative(),
+	forgottenSegments: number().int().nonnegative(),
+	forgottenBytes: number().int().nonnegative(),
+	/** Files under a claimed hour that no durable row names. Never deleted. */
+	orphanFiles: number().int().nonnegative(),
+	orphanSample: array(string()).readonly(),
+	hoursSkipped: number().int().nonnegative(),
+	skippedByReason: LedgerWalkSkipCountsSchema,
+	/** The walk stopped at its per-pass hour bound with claims unwalked. */
+	bounded: boolean(),
+	byDevice: array(LedgerWalkDeviceReportSchema).readonly()
+});
 /** How many rows a media pass would still act on against a given target — the
 *  media lane's denominator AND its residue, from ONE derivation so the two can
 *  never disagree. `null` = the count could not be taken. */
@@ -19040,13 +19139,15 @@ var ListGroupsPageSchema = object({
 	groups: array(AnalyticsGroupRecordSchema).readonly(),
 	nextCursor: string().nullable()
 });
+var KEY_EVENTS_DEFAULT_LIMIT = 50;
+var KEY_EVENTS_MAX_LIMIT = 200;
 var KeyEventQueryInput = object({
 	deviceId: number(),
 	/** Window lower bound (track firstSeen ≥ since). */
 	since: number(),
 	/** Window upper bound (track firstSeen ≤ until). */
 	until: number(),
-	limit: number().int().min(1).max(200).default(50),
+	limit: number().int().min(1).max(KEY_EVENTS_MAX_LIMIT).default(KEY_EVENTS_DEFAULT_LIMIT),
 	/** Drop tracks scoring below this importance. */
 	minImportance: number().min(0).max(1).optional(),
 	/** Restrict to a single class (e.g. 'person'). */
@@ -19068,6 +19169,32 @@ var KeyEventSchema = object({
 	...TrackFlagFields,
 	...TrackRetrainFields
 });
+/** `getKeyEvents`' window and filters, asked of a SET of cameras at once. */
+var KeyEventBatchQueryInput = object({
+	deviceIds: array(number()).min(1).max(200),
+	since: number(),
+	until: number(),
+	/** Applied PER CAMERA, exactly as `getKeyEvents.limit` is — never a total
+	*  across the set, which would let a busy camera starve a quiet one of its
+	*  rows and change what the merged feed contains. */
+	limit: number().int().min(1).max(KEY_EVENTS_MAX_LIMIT).default(KEY_EVENTS_DEFAULT_LIMIT),
+	minImportance: number().min(0).max(1).optional(),
+	classFilter: string().optional()
+});
+/**
+* One camera's key events in a batch answer.
+*
+* The row exists for every requested id. `getKeyEvents` degrades to `[]` on
+* error rather than throwing, so a camera whose store read failed and one with
+* no events in the window were ALREADY indistinguishable per camera — the
+* batch does not make that worse, and the row keeps the deviceId the single
+* method's output never carried (the caller used to stamp it from the fan-out
+* key, which only worked because there was one query per camera).
+*/
+var KeyEventsForDeviceSchema = object({
+	deviceId: number(),
+	events: array(KeyEventSchema).readonly()
+});
 object({
 	trackId: string(),
 	className: string(),
@@ -19139,6 +19266,50 @@ var EventStoreFootprintSchema = object({
 	totalBytes: number().int(),
 	devices: array(EventStoreDeviceFootprintSchema).readonly()
 });
+/** Event-media footprint for one {@link MediaFileKind}. */
+var EventMediaKindFootprintSchema = object({
+	kind: MediaFileKindEnum,
+	/** Media rows of this kind. */
+	rows: number().int(),
+	/** Bytes on disk held by those rows. */
+	bytes: number().int()
+});
+/**
+* The media footprint broken down by KIND — the axis a deletion decision
+* actually turns on.
+*
+* A byte total says how much there is; it cannot say what is safe to remove.
+* The deletable set (the periodic `snapshot` filmstrip, the surplus per-edge
+* motion stills) and the keep set (`firstFrame`, rolling `lastFrame`,
+* `thumbnail`/`thumbnailSmall`, `keyFrame`/`keyFrameSmall`, the face/plate
+* buffers, gallery media, the CLIP `crop`) are distinguished by `kind` and by
+* nothing else, so sizing a deletion means summing per kind.
+*
+* ## Why `unaccounted*` exists
+*
+* `kinds` is enumerated from {@link MediaFileKindEnum} — the closed set the
+* writers use — and summed one kind at a time. `totalRows` / `totalBytes` come
+* from a SEPARATE unfiltered aggregate over the same rows, never from adding
+* `kinds` up. A row whose stored `kind` is not in the enum (written by a
+* retired code path, or by a version that knew a kind this one does not) would
+* otherwise vanish from the total silently, and an operator would delete
+* against a denominator smaller than the disk.
+*
+* `unaccountedRows` / `unaccountedBytes` are the difference. They are normally
+* zero; a non-zero value is a real finding and must be shown, not rounded away.
+*/
+var EventMediaKindBreakdownSchema = object({
+	/** Every media row in scope, from one unfiltered aggregate. */
+	totalRows: number().int(),
+	/** Every media byte in scope, from that same aggregate. */
+	totalBytes: number().int(),
+	/** Per-kind footprint, ordered by bytes descending. */
+	kinds: array(EventMediaKindFootprintSchema).readonly(),
+	/** `totalRows` minus the summed `kinds` rows — see the schema note. */
+	unaccountedRows: number().int(),
+	/** `totalBytes` minus the summed `kinds` bytes — see the schema note. */
+	unaccountedBytes: number().int()
+});
 /** Per-kind counts returned by the event-prune / device-delete mutations. */
 var EventPruneCountsSchema = object({
 	motion: number().int(),
@@ -19293,7 +19464,7 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
 	until: number().optional(),
 	kinds: array(string()).optional(),
 	limit: number().int().min(1).max(MAX_EVENT_QUERY_LIMIT).default(DEFAULT_EVENT_QUERY_LIMIT)
-}), array(SensorEventSchema).readonly()), method(KeyEventQueryInput, array(KeyEventSchema).readonly()), method(object({
+}), array(SensorEventSchema).readonly()), method(KeyEventQueryInput, array(KeyEventSchema).readonly()), method(KeyEventBatchQueryInput, array(KeyEventsForDeviceSchema).readonly()), method(object({
 	deviceId: number(),
 	since: number(),
 	until: number(),
@@ -19342,6 +19513,9 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
 }), TrackFlagsSchema, { kind: "mutation" }), method(object({}), EventStoreFootprintSchema, {
 	kind: "query",
 	auth: "admin"
+}), method(object({ deviceId: number().int().optional() }), EventMediaKindBreakdownSchema, {
+	kind: "query",
+	auth: "admin"
 }), method(object({
 	olderThanMs: number(),
 	reason: OpsLogReasonSchema.optional()
@@ -21397,6 +21571,20 @@ method(object({
 	error: string().optional()
 }), { auth: "admin" }), method(_void(), array(ProviderListEntrySchema).readonly()), method(object({
 	providerId: string(),
+	/**
+	* The location this config is an UNSAVED edit of, when there is one.
+	*
+	* `listLocations` replaces every declared secret with the redaction
+	* sentinel, so the edit modal's form state holds the sentinel for any
+	* credential the operator did not retype — and posting that here
+	* without a way to resolve it makes the provider try to authenticate
+	* as `__camstack_redacted__` and report the operator's own working
+	* password as wrong. Given this id, the orchestrator restores each
+	* sentinel from the stored config (same rule as `upsertLocation`)
+	* before dispatching. Omitted by the "Add location" wizard, where
+	* every value was typed just now and nothing is stored yet.
+	*/
+	locationId: string().optional(),
 	config: record(string(), unknown())
 }), object({
 	ok: boolean(),
@@ -28791,6 +28979,9 @@ method(object({
 }), method(RelocateResidueInputSchema, RelocateResidueSchema, {
 	kind: "query",
 	auth: "admin"
+}), method(LedgerWalkInputSchema, LedgerWalkReportSchema, {
+	kind: "mutation",
+	auth: "admin"
 }), method(object({ jobId: string() }), object({ cancelled: boolean() }), {
 	kind: "mutation",
 	auth: "admin"
@@ -29182,6 +29373,25 @@ var SceneMonitorStatusSchema = object({
 	monitors: array(SceneMonitorSchema),
 	lastFetchedAt: number()
 });
+/**
+* One camera's row in a `listScenesBatch` answer.
+*
+* `status` is NULLABLE and the nullability is the whole point. `scene-monitor`
+* is a `defaultActive` wrapper, so every camera is asked; a camera whose
+* provider is absent (pipeline-analytics not deployed, the post-processing node
+* down) cannot answer, and that is not the same fact as a camera with no scenes
+* configured. Fanned out per camera the difference was visible — one query
+* errored while the others resolved — and a batch that returned only the rows
+* it managed would have destroyed it, silently, by making an unreachable camera
+* indistinguishable from one that answered `monitors: []`.
+*
+* So: EVERY requested deviceId gets a row. `status: null` means "this camera
+* could not be read"; `status.monitors: []` means "read, and it has none".
+*/
+var SceneMonitorStatusForDeviceSchema = object({
+	deviceId: number(),
+	status: SceneMonitorStatusSchema.nullable()
+});
 var sceneMonitorCapability = {
 	name: "scene-monitor",
 	scope: "device",
@@ -29191,6 +29401,22 @@ var sceneMonitorCapability = {
 	deviceTypes: [DeviceType.Camera],
 	methods: {
 		listScenes: method(object({ deviceId: number() }), SceneMonitorStatusSchema),
+		/**
+		* The same answer, for a SET of cameras, in one round trip.
+		*
+		* `/scenes` renders every camera and re-reads them on a 30s safety-net
+		* poll behind the push slice. Fanned out client-side that was one query
+		* per camera — 29 round trips through the browser, the hub and the
+		* post-analysis runner every 30 seconds to read an in-memory map the
+		* owner had already merged. The work is unchanged (`statusFor` per
+		* device, all in-process at the owner); what collapses is the transport.
+		*
+		* A camera that cannot answer still gets a row, with `status: null` —
+		* see {@link SceneMonitorStatusForDeviceSchema}. Never fewer rows than
+		* ids: a caller that asked for twenty-nine and got twenty-seven cannot
+		* tell which two are missing, or that any are.
+		*/
+		listScenesBatch: method(object({ deviceIds: array(number()).min(1).max(200) }), array(SceneMonitorStatusForDeviceSchema).readonly()),
 		createScene: method(object({
 			deviceId: number(),
 			label: string(),
@@ -31026,6 +31252,27 @@ var CameraOccupancySnapshotSchema = object({
 	stationaryObjects: array(StationaryObjectSchema).readonly().optional()
 });
 /**
+* One camera's row in a `getCurrentSnapshotBatch` answer.
+*
+* THREE outcomes, and the single-camera method could only express two of them
+* because `snapshot: null` was already spoken for:
+*
+*  - `read: 'read'`, `snapshot` present — the live occupancy reading.
+*  - `read: 'read'`, `snapshot: null`   — read, and this camera has no reading
+*    yet: no frame since boot, and no parked-object registry to hydrate from.
+*  - `read: 'unreadable'`               — the owner could not answer for this
+*    camera. `snapshot` is null, and it does NOT mean "nothing parked here".
+*
+* Collapsing the last two is the failure this field exists to prevent: a
+* hydration that threw would otherwise render as an empty Stationary section,
+* which is a definite claim about a camera nobody could read.
+*/
+var CameraOccupancySnapshotForDeviceSchema = object({
+	deviceId: number(),
+	read: _enum(["read", "unreadable"]),
+	snapshot: CameraOccupancySnapshotSchema.nullable()
+});
+/**
 * Time-series resolution. The history methods return one bucket per
 * step over the requested range. Smaller resolutions cost more
 * memory + bandwidth; bound to discrete steps so caller cannot ask
@@ -31082,6 +31329,20 @@ var zoneAnalyticsCapability = {
 		*  (no inference result emitted since boot or since binding was
 		*  activated). */
 		getCurrentSnapshot: method(object({ deviceId: number() }), CameraOccupancySnapshotSchema.nullable()),
+		/**
+		* The same snapshot, for a SET of cameras, in one round trip.
+		*
+		* The Events page's Stationary section polls this every 15s for every
+		* selected camera. Fanned out client-side that is one query per camera to
+		* read a `Map.get` at the owner — the answer costs nothing, the round trip
+		* costs everything. Batched, N transports become one and the per-device
+		* work is unchanged.
+		*
+		* Every requested deviceId gets a row, tagged `read` — see
+		* {@link CameraOccupancySnapshotForDeviceSchema}. A camera the owner could
+		* not answer for is `'unreadable'`, never an empty reading.
+		*/
+		getCurrentSnapshotBatch: method(object({ deviceIds: array(number()).min(1).max(200) }), array(CameraOccupancySnapshotForDeviceSchema).readonly()),
 		/** Time-series object count inside one zone. `className` optional —
 		*  omit to count every class in the zone. */
 		getZoneHistory: method(object({
@@ -35477,6 +35738,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineAnalytics.getEventMediaFootprintByKind": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.getEventStoreFootprint": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -35495,6 +35762,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineAnalytics.getKeyEventsBatch": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.getMotionEvents": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -36671,6 +36944,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"recording.reconcileLedgerAgainstDisk": {
+		capName: "recording",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"recording.refreshStorageLocationsForMigration": {
 		capName: "recording",
 		capScope: "system",
@@ -36797,6 +37076,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"sceneMonitor.listScenesBatch": {
+		capName: "scene-monitor",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"sceneMonitor.recheckNow": {
 		capName: "scene-monitor",
 		capScope: "device",
@@ -38153,6 +38438,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"zoneAnalytics.getCurrentSnapshotBatch": {
+		capName: "zone-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"zoneAnalytics.getUnzonedHistory": {
 		capName: "zone-analytics",
 		capScope: "device",
@@ -39142,6 +39433,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"pipelineAnalytics.getEventMediaFootprintByKind": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
 	"pipelineAnalytics.getGroup": [{
 		name: "deviceId",
 		form: "single",
@@ -39152,6 +39448,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"pipelineAnalytics.getKeyEventsBatch": [{
+		name: "deviceIds",
+		form: "array",
+		optional: false
+	}],
 	"pipelineAnalytics.getMotionEvents": [{
 		name: "deviceId",
 		form: "single",
@@ -39592,6 +39893,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"recording.reconcileLedgerAgainstDisk": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
 	"recording.relocateFootage": [{
 		name: "deviceId",
 		form: "single",
@@ -39657,6 +39963,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"sceneMonitor.listScenesBatch": [{
+		name: "deviceIds",
+		form: "array",
+		optional: false
+	}],
 	"sceneMonitor.recheckNow": [{
 		name: "deviceId",
 		form: "single",
@@ -39918,6 +40229,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"zoneAnalytics.getCurrentSnapshotBatch": [{
+		name: "deviceIds",
+		form: "array",
+		optional: false
+	}],
 	"zoneAnalytics.getUnzonedHistory": [{
 		name: "deviceId",
 		form: "single",
@@ -40491,6 +40807,111 @@ function resolveGlancesCursesShimEnv(options) {
 	return { PYTHONPATH: existing ? `${options.shimDir}:${existing}` : options.shimDir };
 }
 //#endregion
+//#region src/profile-settings.ts
+var GLANCES_PLUGINS = [
+	{
+		key: "showCpu",
+		plugin: "cpu",
+		label: "CPU"
+	},
+	{
+		key: "showMem",
+		plugin: "mem",
+		label: "Memory"
+	},
+	{
+		key: "showLoad",
+		plugin: "load",
+		label: "Load"
+	},
+	{
+		key: "showNetwork",
+		plugin: "network",
+		label: "Network"
+	},
+	{
+		key: "showDiskIo",
+		plugin: "diskio",
+		label: "Disk I/O"
+	},
+	{
+		key: "showFs",
+		plugin: "fs",
+		label: "Filesystems"
+	},
+	{
+		key: "showProcessList",
+		plugin: "processlist",
+		label: "Process list"
+	},
+	{
+		key: "showContainers",
+		plugin: "containers",
+		label: "Containers"
+	},
+	{
+		key: "showSensors",
+		plugin: "sensors",
+		label: "Sensors"
+	}
+];
+function glancesBooleanField(key, label) {
+	return {
+		type: "boolean",
+		key,
+		label,
+		default: true,
+		style: "switch"
+	};
+}
+function glancesSettingsSchema() {
+	return { sections: [{
+		id: "glances-panels",
+		title: "Glances panels",
+		description: "Turn off a panel to pass --disable-plugin to this Terminal only. All on is the measured default (~1% of one core at the camera grid).",
+		columns: 2,
+		fields: GLANCES_PLUGINS.map((plugin) => glancesBooleanField(plugin.key, plugin.label))
+	}] };
+}
+function settingsSchemaForProfile(profileId) {
+	if (profileId === "glances") return glancesSettingsSchema();
+	return null;
+}
+function glancesSettingsToArgs(settings) {
+	const disabled = GLANCES_PLUGINS.filter((plugin) => settings[plugin.key] === false).map((plugin) => plugin.plugin);
+	if (disabled.length === 0) return [];
+	return ["--disable-plugin", disabled.join(",")];
+}
+function sanitizeProfileSettings(profileId, raw) {
+	if (profileId !== "glances") return {};
+	const bag = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+	const out = {
+		showCpu: true,
+		showMem: true,
+		showLoad: true,
+		showNetwork: true,
+		showDiskIo: true,
+		showFs: true,
+		showProcessList: true,
+		showContainers: true,
+		showSensors: true
+	};
+	for (const plugin of GLANCES_PLUGINS) {
+		const value = bag[plugin.key];
+		if (typeof value === "boolean") out[plugin.key] = value;
+	}
+	return out;
+}
+function profileSettingsToArgs(profileId, settings) {
+	if (profileId !== "glances") return [];
+	return glancesSettingsToArgs(sanitizeProfileSettings(profileId, settings));
+}
+function spawnArgsForInstance(input) {
+	const extra = profileSettingsToArgs(input.profileId, input.profileSettings);
+	if (input.instanceArgs.length > 0) return [...input.instanceArgs, ...extra];
+	if (extra.length > 0) return [...input.profileArgs, ...extra];
+}
+//#endregion
 //#region src/pty.ts
 /**
 * Minimal pty abstraction. The manager depends on this interface, never on
@@ -40672,6 +41093,356 @@ async function silenceAnalysisFor(deps, deviceId) {
 	if (failures.length > 0) throw new Error(`terminal camera ${deviceId}: could not switch off ${failures.length} analyzer(s) — it will run at full detection cost (${failures.join("; ")})`);
 }
 //#endregion
+//#region src/terminal-camera-declarations.ts
+/**
+* Feed DeclaredDevices every live declaration plus one deterministic orphan
+* batch. The generic sweep intentionally refuses an over-limit set; selecting
+* a batch here drains large historical Terminal orphan sets across convergence
+* passes without weakening that global safety guard.
+*/
+function terminalCameraReconciliationIndex(rows, integrationId, declarations, managedStableIds = /* @__PURE__ */ new Set()) {
+	if (!integrationId) return [];
+	const declared = new Set(declarations.map((camera) => camera.stableId));
+	const owned = rows.filter((row) => row.integrationId === integrationId && (declared.has(row.stableId) || managedStableIds.has(row.stableId) || row.stableId.startsWith("terminal-camera-instance-")));
+	return [...owned.filter((row) => declared.has(row.stableId)), ...owned.filter((row) => !declared.has(row.stableId)).sort((left, right) => left.id - right.id).slice(0, 32)];
+}
+/** Explicit persisted instances, never the node × profile template matrix. */
+function buildTerminalInstanceCameraDeclarations(instances) {
+	return instances.filter((instance) => instance.enabled).map((instance) => ({
+		stableId: instance.cameraStableId,
+		name: instance.name,
+		config: {
+			instanceId: instance.id,
+			nodeId: instance.nodeId,
+			profileId: instance.profileId,
+			profileLabel: instance.profileLabel
+		}
+	}));
+}
+/**
+* `DeviceConfig` materializes schema defaults in memory, so comparing
+* `config.get()` cannot detect a legacy `{ nodeId }` row. Reconciliation must
+* inspect the raw persisted blob to make the profile migration durable.
+*/
+function needsTerminalCameraConfigMigration(persistedConfig, declaration) {
+	return persistedConfig.instanceId !== declaration.config.instanceId || persistedConfig.nodeId !== declaration.config.nodeId || persistedConfig.profileId !== declaration.config.profileId || persistedConfig.profileLabel !== declaration.config.profileLabel;
+}
+//#endregion
+//#region src/terminal-cell-runs.ts
+var TERMINAL_DEFAULT_FG = "#d7dce2";
+var TERMINAL_DEFAULT_BG = "#0b0d10";
+/**
+* The 16 ANSI colours, in a dark-theme variant chosen to sit with the existing
+* frame (`#0b0d10` ground, `#d7dce2` text) rather than the raw xterm defaults,
+* whose pure `#0000ff` blue and `#008000` green are close to unreadable on a
+* near-black background at 13px. Index 7 IS the default foreground, so plain
+* `CSI 37m` text renders identically to unstyled text.
+*/
+var TERMINAL_ANSI_PALETTE = [
+	"#282c34",
+	"#e06c75",
+	"#98c379",
+	"#e5c07b",
+	"#61afef",
+	"#c678dd",
+	"#56b6c2",
+	TERMINAL_DEFAULT_FG,
+	"#5c6370",
+	"#ef596f",
+	"#89ca78",
+	"#f0c674",
+	"#6cb6ff",
+	"#d55fde",
+	"#2bbac5",
+	"#ffffff"
+];
+/** The six levels of the xterm 6×6×6 colour cube (indices 16-231). */
+var TERMINAL_CUBE_LEVELS = [
+	0,
+	95,
+	135,
+	175,
+	215,
+	255
+];
+var TERMINAL_CUBE_FIRST = 16;
+var TERMINAL_GRAYSCALE_FIRST = 232;
+var TERMINAL_GRAYSCALE_BASE = 8;
+var TERMINAL_GRAYSCALE_STEP = 10;
+/** SGR 2 keeps the foreground legible; it must not become the background. */
+var TERMINAL_DIM_WEIGHT = .6;
+function channel(value) {
+	return Math.max(0, Math.min(255, Math.round(value))).toString(16).padStart(2, "0");
+}
+function hex(red, green, blue) {
+	return `#${channel(red)}${channel(green)}${channel(blue)}`;
+}
+function parseHex(color) {
+	return [
+		Number.parseInt(color.slice(1, 3), 16),
+		Number.parseInt(color.slice(3, 5), 16),
+		Number.parseInt(color.slice(5, 7), 16)
+	];
+}
+/** Resolve an xterm palette index (0-255) to a hex colour. */
+function terminalPaletteColor(index) {
+	const ansi = TERMINAL_ANSI_PALETTE[index];
+	if (ansi !== void 0) return ansi;
+	if (index >= TERMINAL_GRAYSCALE_FIRST) {
+		const level = TERMINAL_GRAYSCALE_BASE + (index - TERMINAL_GRAYSCALE_FIRST) * TERMINAL_GRAYSCALE_STEP;
+		return hex(level, level, level);
+	}
+	if (index >= TERMINAL_CUBE_FIRST) {
+		const offset = index - TERMINAL_CUBE_FIRST;
+		return hex(TERMINAL_CUBE_LEVELS[Math.floor(offset / 36) % 6] ?? 0, TERMINAL_CUBE_LEVELS[Math.floor(offset / 6) % 6] ?? 0, TERMINAL_CUBE_LEVELS[offset % 6] ?? 0);
+	}
+	return TERMINAL_DEFAULT_FG;
+}
+/** Resolve a 0xRRGGBB truecolor value to a hex colour. */
+function terminalRgbColor(value) {
+	return hex(value >> 16 & 255, value >> 8 & 255, value & 255);
+}
+function blend(color, toward, weight) {
+	const [red, green, blue] = parseHex(color);
+	const [targetRed, targetGreen, targetBlue] = parseHex(toward);
+	return hex(red * weight + targetRed * (1 - weight), green * weight + targetGreen * (1 - weight), blue * weight + targetBlue * (1 - weight));
+}
+function resolveForeground(cell) {
+	if (cell.isFgRGB()) return terminalRgbColor(cell.getFgColor());
+	if (cell.isFgPalette()) return terminalPaletteColor(cell.getFgColor());
+	return TERMINAL_DEFAULT_FG;
+}
+function resolveBackground(cell) {
+	if (cell.isBgRGB()) return terminalRgbColor(cell.getBgColor());
+	if (cell.isBgPalette()) return terminalPaletteColor(cell.getBgColor());
+	return TERMINAL_DEFAULT_BG;
+}
+/**
+* Resolve one cell's attributes into concrete colours.
+*
+* Inverse is applied by SWAPPING the already-resolved pair, so inverse over two
+* defaults is still a visible swap rather than a no-op — that is how a selected
+* or highlighted row in Glances reads. Invisible is then conceal-by-equality
+* (foreground painted in its own background): the cell keeps its columns, which
+* a dropped cell would not, and dropping it would shift the whole rest of the
+* row left.
+*/
+function resolveCellStyle(cell) {
+	const inverse = cell.isInverse() !== 0;
+	const plainFg = resolveForeground(cell);
+	const plainBg = resolveBackground(cell);
+	const background = inverse ? plainFg : plainBg;
+	let foreground = inverse ? plainBg : plainFg;
+	if (cell.isDim() !== 0) foreground = blend(foreground, background, TERMINAL_DIM_WEIGHT);
+	if (cell.isInvisible() !== 0) foreground = background;
+	return {
+		fg: foreground === "#d7dce2" ? null : foreground,
+		bg: background === "#0b0d10" ? null : background,
+		bold: cell.isBold() !== 0
+	};
+}
+function sameStyle(left, right) {
+	return left.fg === right.fg && left.bg === right.bg && left.bold === right.bold;
+}
+/**
+* Merge adjacent same-style cells into runs, then drop the trailing run of
+* default-styled whitespace so a row costs what it draws — the same trim
+* `translateToString(true)` performs. Whitespace carrying a BACKGROUND is kept:
+* a green bar of spaces out to the right margin is a pixel Glances drew.
+*/
+function buildCellRuns(cells) {
+	const runs = [];
+	let text = "";
+	let style = null;
+	for (const cell of cells) {
+		if (style !== null && sameStyle(style, cell.style)) {
+			text += cell.text;
+			continue;
+		}
+		if (style !== null) runs.push({
+			text,
+			...style
+		});
+		text = cell.text;
+		style = cell.style;
+	}
+	if (style !== null) runs.push({
+		text,
+		...style
+	});
+	while (runs.length > 0) {
+		const last = runs[runs.length - 1];
+		if (last === void 0 || last.bg !== null) break;
+		const trimmed = last.text.replace(/\s+$/u, "");
+		if (trimmed === last.text) break;
+		if (trimmed === "") {
+			runs.pop();
+			continue;
+		}
+		runs[runs.length - 1] = {
+			...last,
+			text: trimmed
+		};
+		break;
+	}
+	return runs;
+}
+/**
+* Monospace families to try, in order — NOT one family and a generic.
+*
+* A terminal screen is mostly box-drawing and block characters, and a font
+* without them renders the frame as noise rather than as missing detail.
+* `DejaVu Sans Mono` covers them and ships in the hub image; macOS has neither
+* DejaVu nor fontconfig, so the Mac agent fell through to a generic whose
+* coverage is not, and its Glances camera came out unreadable while the hub's
+* was pixel-perfect (measured 2026-08-11, same Glances, two nodes).
+*
+* `Menlo` is the fix rather than a guess: it is macOS's default terminal face,
+* present on every install, and derived from DejaVu Sans Mono — the same glyph
+* coverage by ancestry. Monaco and Courier New follow as older fallbacks; the
+* generic stays last so a host with none of them still draws something.
+*/
+var TERMINAL_FONT_STACK = "DejaVu Sans Mono,Menlo,Monaco,Courier New,monospace";
+var TERMINAL_FONT_SIZE = 13;
+var TERMINAL_TEXT_MARGIN_X = 8;
+var TERMINAL_ROW_HEIGHT = 15;
+var TERMINAL_BASELINE_Y = 18;
+/**
+* Distance from a row's baseline up to the top of its cell box. Chosen so
+* consecutive rows tile exactly: row N's box runs from `baseline - this` for
+* `TERMINAL_ROW_HEIGHT`, and row N+1's box starts where it ends. A background
+* bar that stopped short would draw as stripes across a `CSI 42m` panel.
+*/
+var TERMINAL_CELL_ASCENT = 11.5;
+var TERMINAL_CELL_WIDTH = TERMINAL_FONT_SIZE * (1233 / 2048);
+/** Two decimals is under a tenth of a pixel and keeps the SVG small. */
+function coordinate(value) {
+	return String(Number(value.toFixed(2)));
+}
+function escapeXml(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&apos;");
+}
+/**
+* Render already-interpreted terminal rows into a compact MJPEG frame.
+*
+* `xml:space="preserve"` is load-bearing, not tidiness. SVG `<text>` collapses
+* runs of whitespace by default, and a terminal's entire column alignment IS
+* runs of whitespace — Glances pads every field with spaces. Without it the
+* frame drew each line at roughly half its true width, crammed into the
+* top-left of a mostly-black image, while the SAME session over `attach`
+* looked perfect — which is exactly how the operator reported it. Measured in
+* the hub's own rasterizer 2026-08-11: `AAA<10 spaces>BBB<3>CCC` drew 92 px
+* collapsed against 178 px preserved.
+*
+* Every run is anchored at its OWN column (`x = margin + startCol * cellW`),
+* never appended to the one before it, so the background rects and the glyphs
+* are placed off the same grid and cannot drift apart. `textLength` is emitted
+* with it because it is the correct declaration and renderers that honour it
+* get an exact grid — but it is not what makes this work: librsvg, which sharp
+* uses, ignores it outright (measured 2026-08-12, a 120-glyph run pinned to
+* 600 px still drew its natural 937 px). The anchoring is the guarantee.
+*/
+function renderTerminalSvg(rows) {
+	const backgrounds = [];
+	const texts = [];
+	rows.slice(0, 40).forEach((row, index) => {
+		const baseline = TERMINAL_BASELINE_Y + index * TERMINAL_ROW_HEIGHT;
+		const top = baseline - TERMINAL_CELL_ASCENT;
+		let column = 0;
+		for (const run of row) {
+			if (column >= 120) break;
+			const clipped = clipRun(run, 120 - column);
+			const columns = [...clipped].length;
+			if (columns === 0) continue;
+			const x = TERMINAL_TEXT_MARGIN_X + column * TERMINAL_CELL_WIDTH;
+			const width = columns * TERMINAL_CELL_WIDTH;
+			if (run.bg !== null) backgrounds.push(`<rect x="${coordinate(x)}" y="${coordinate(top)}" width="${coordinate(width)}" height="${String(TERMINAL_ROW_HEIGHT)}" fill="${run.bg}"/>`);
+			if (clipped.trim() !== "") {
+				const fill = run.fg === null ? "" : ` fill="${run.fg}"`;
+				const weight = run.bold ? " font-weight=\"bold\"" : "";
+				texts.push(`<text xml:space="preserve" x="${coordinate(x)}" y="${coordinate(baseline)}" textLength="${coordinate(width)}" lengthAdjust="spacingAndGlyphs"${fill}${weight}>${escapeXml(clipped)}</text>`);
+			}
+			column += columns;
+		}
+	});
+	return `<svg xmlns="http://www.w3.org/2000/svg" width="${String(960)}" height="${String(640)}"><rect width="100%" height="100%" fill="${TERMINAL_DEFAULT_BG}"/>${backgrounds.join("")}<g fill="${TERMINAL_DEFAULT_FG}" font-family="${TERMINAL_FONT_STACK}" font-size="${String(TERMINAL_FONT_SIZE)}">${texts.join("")}</g></svg>`;
+}
+/** Cut a run to the columns still left in the row, by code point not unit. */
+function clipRun(run, remaining) {
+	const points = [...run.text];
+	return points.length <= remaining ? run.text : points.slice(0, remaining).join("");
+}
+async function renderTerminalJpeg(rows) {
+	return (0, sharp.default)(Buffer.from(renderTerminalSvg(rows))).jpeg({
+		quality: 82,
+		chromaSubsampling: "4:2:0"
+	}).toBuffer();
+}
+//#endregion
+//#region src/terminal-camera-device.ts
+var terminalCameraSchema = object({
+	instanceId: string().min(1).optional(),
+	nodeId: string().min(1),
+	profileId: string().min(1).default("monitor"),
+	profileLabel: string().min(1).default("BTM")
+});
+var relay = null;
+function installTerminalCameraRelay(next) {
+	relay = next;
+}
+var TerminalCameraDevice = class extends BaseDevice {
+	features = [DeviceFeature.NativeSnapshot];
+	constructor(ctx) {
+		super(ctx, terminalCameraSchema, { type: ctx.deviceMeta.type });
+		this.ctx.registerNativeCap(streamCatalogCapability, { getCatalog: async ({ deviceId }) => {
+			if (deviceId !== this.id) return [];
+			return this.catalog();
+		} });
+		this.ctx.registerNativeCap(snapshotCapability, {
+			getSnapshot: async ({ deviceId }) => {
+				if (deviceId !== this.id) throw new Error(`TerminalCameraDevice: deviceId mismatch, expected ${String(this.id)}, got ${String(deviceId)}`);
+				const activeRelay = relay;
+				if (!activeRelay) throw new Error("terminal camera relay is unavailable");
+				return {
+					base64: (await activeRelay.snapshot(this.relayInstanceId(), this.config.get("nodeId"), this.config.get("profileId"))).toString("base64"),
+					contentType: "image/jpeg"
+				};
+			},
+			invalidateCache: async () => {}
+		});
+		this.markOnline(true);
+	}
+	async catalog() {
+		const activeRelay = relay;
+		if (!activeRelay) throw new Error("terminal camera relay is unavailable");
+		const nodeId = this.config.get("nodeId");
+		const profileId = this.config.get("profileId");
+		const instanceId = this.relayInstanceId();
+		return [{
+			camStreamId: profileId,
+			kind: "pull-http",
+			url: activeRelay.streamUrl(instanceId, nodeId, profileId),
+			codec: "h264",
+			resolution: {
+				width: 960,
+				height: 640
+			},
+			fps: 2,
+			label: this.config.get("profileLabel")
+		}];
+	}
+	setNodeOnline(online) {
+		this.markOnline(online);
+		if (!online) relay?.closeInstance(this.relayInstanceId());
+	}
+	async removeDevice() {
+		await relay?.closeInstance(this.relayInstanceId());
+	}
+	relayInstanceId() {
+		return this.config.get("instanceId") ?? `legacy:${this.stableId}`;
+	}
+};
+//#endregion
 //#region ../../node_modules/@xterm/addon-serialize/lib/addon-serialize.js
 var require_addon_serialize = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	(function(e, t) {
@@ -45479,174 +46250,9 @@ var require_xterm_headless = /* @__PURE__ */ __commonJSMin(((exports) => {
 	})();
 }));
 //#endregion
-//#region src/terminal-cell-runs.ts
+//#region src/xterm-screen.ts
 var import_addon_serialize = require_addon_serialize();
 var import_xterm_headless = require_xterm_headless();
-var TERMINAL_DEFAULT_FG = "#d7dce2";
-var TERMINAL_DEFAULT_BG = "#0b0d10";
-/**
-* The 16 ANSI colours, in a dark-theme variant chosen to sit with the existing
-* frame (`#0b0d10` ground, `#d7dce2` text) rather than the raw xterm defaults,
-* whose pure `#0000ff` blue and `#008000` green are close to unreadable on a
-* near-black background at 13px. Index 7 IS the default foreground, so plain
-* `CSI 37m` text renders identically to unstyled text.
-*/
-var TERMINAL_ANSI_PALETTE = [
-	"#282c34",
-	"#e06c75",
-	"#98c379",
-	"#e5c07b",
-	"#61afef",
-	"#c678dd",
-	"#56b6c2",
-	TERMINAL_DEFAULT_FG,
-	"#5c6370",
-	"#ef596f",
-	"#89ca78",
-	"#f0c674",
-	"#6cb6ff",
-	"#d55fde",
-	"#2bbac5",
-	"#ffffff"
-];
-/** The six levels of the xterm 6×6×6 colour cube (indices 16-231). */
-var TERMINAL_CUBE_LEVELS = [
-	0,
-	95,
-	135,
-	175,
-	215,
-	255
-];
-var TERMINAL_CUBE_FIRST = 16;
-var TERMINAL_GRAYSCALE_FIRST = 232;
-var TERMINAL_GRAYSCALE_BASE = 8;
-var TERMINAL_GRAYSCALE_STEP = 10;
-/** SGR 2 keeps the foreground legible; it must not become the background. */
-var TERMINAL_DIM_WEIGHT = .6;
-function channel(value) {
-	return Math.max(0, Math.min(255, Math.round(value))).toString(16).padStart(2, "0");
-}
-function hex(red, green, blue) {
-	return `#${channel(red)}${channel(green)}${channel(blue)}`;
-}
-function parseHex(color) {
-	return [
-		Number.parseInt(color.slice(1, 3), 16),
-		Number.parseInt(color.slice(3, 5), 16),
-		Number.parseInt(color.slice(5, 7), 16)
-	];
-}
-/** Resolve an xterm palette index (0-255) to a hex colour. */
-function terminalPaletteColor(index) {
-	const ansi = TERMINAL_ANSI_PALETTE[index];
-	if (ansi !== void 0) return ansi;
-	if (index >= TERMINAL_GRAYSCALE_FIRST) {
-		const level = TERMINAL_GRAYSCALE_BASE + (index - TERMINAL_GRAYSCALE_FIRST) * TERMINAL_GRAYSCALE_STEP;
-		return hex(level, level, level);
-	}
-	if (index >= TERMINAL_CUBE_FIRST) {
-		const offset = index - TERMINAL_CUBE_FIRST;
-		return hex(TERMINAL_CUBE_LEVELS[Math.floor(offset / 36) % 6] ?? 0, TERMINAL_CUBE_LEVELS[Math.floor(offset / 6) % 6] ?? 0, TERMINAL_CUBE_LEVELS[offset % 6] ?? 0);
-	}
-	return TERMINAL_DEFAULT_FG;
-}
-/** Resolve a 0xRRGGBB truecolor value to a hex colour. */
-function terminalRgbColor(value) {
-	return hex(value >> 16 & 255, value >> 8 & 255, value & 255);
-}
-function blend(color, toward, weight) {
-	const [red, green, blue] = parseHex(color);
-	const [targetRed, targetGreen, targetBlue] = parseHex(toward);
-	return hex(red * weight + targetRed * (1 - weight), green * weight + targetGreen * (1 - weight), blue * weight + targetBlue * (1 - weight));
-}
-function resolveForeground(cell) {
-	if (cell.isFgRGB()) return terminalRgbColor(cell.getFgColor());
-	if (cell.isFgPalette()) return terminalPaletteColor(cell.getFgColor());
-	return TERMINAL_DEFAULT_FG;
-}
-function resolveBackground(cell) {
-	if (cell.isBgRGB()) return terminalRgbColor(cell.getBgColor());
-	if (cell.isBgPalette()) return terminalPaletteColor(cell.getBgColor());
-	return TERMINAL_DEFAULT_BG;
-}
-/**
-* Resolve one cell's attributes into concrete colours.
-*
-* Inverse is applied by SWAPPING the already-resolved pair, so inverse over two
-* defaults is still a visible swap rather than a no-op — that is how a selected
-* or highlighted row in Glances reads. Invisible is then conceal-by-equality
-* (foreground painted in its own background): the cell keeps its columns, which
-* a dropped cell would not, and dropping it would shift the whole rest of the
-* row left.
-*/
-function resolveCellStyle(cell) {
-	const inverse = cell.isInverse() !== 0;
-	const plainFg = resolveForeground(cell);
-	const plainBg = resolveBackground(cell);
-	const background = inverse ? plainFg : plainBg;
-	let foreground = inverse ? plainBg : plainFg;
-	if (cell.isDim() !== 0) foreground = blend(foreground, background, TERMINAL_DIM_WEIGHT);
-	if (cell.isInvisible() !== 0) foreground = background;
-	return {
-		fg: foreground === "#d7dce2" ? null : foreground,
-		bg: background === "#0b0d10" ? null : background,
-		bold: cell.isBold() !== 0
-	};
-}
-function sameStyle(left, right) {
-	return left.fg === right.fg && left.bg === right.bg && left.bold === right.bold;
-}
-/**
-* Merge adjacent same-style cells into runs, then drop the trailing run of
-* default-styled whitespace so a row costs what it draws — the same trim
-* `translateToString(true)` performs. Whitespace carrying a BACKGROUND is kept:
-* a green bar of spaces out to the right margin is a pixel Glances drew.
-*/
-function buildCellRuns(cells) {
-	const runs = [];
-	let text = "";
-	let style = null;
-	for (const cell of cells) {
-		if (style !== null && sameStyle(style, cell.style)) {
-			text += cell.text;
-			continue;
-		}
-		if (style !== null) runs.push({
-			text,
-			...style
-		});
-		text = cell.text;
-		style = cell.style;
-	}
-	if (style !== null) runs.push({
-		text,
-		...style
-	});
-	while (runs.length > 0) {
-		const last = runs[runs.length - 1];
-		if (last === void 0 || last.bg !== null) break;
-		const trimmed = last.text.replace(/\s+$/u, "");
-		if (trimmed === last.text) break;
-		if (trimmed === "") {
-			runs.pop();
-			continue;
-		}
-		runs[runs.length - 1] = {
-			...last,
-			text: trimmed
-		};
-		break;
-	}
-	return runs;
-}
-//#endregion
-//#region src/xterm-screen.ts
-/**
-* Real {@link ScreenBuffer} backed by `@xterm/headless` — the DOM-less xterm
-* build — plus the serialize addon, which turns the current buffer into a
-* self-contained repaint escape sequence for reconnecting clients.
-*/
 var SCROLLBACK_LINES = 2e3;
 function createXtermScreen(cols, rows) {
 	const term = new import_xterm_headless.Terminal({
@@ -45713,196 +46319,6 @@ function createXtermScreen(cols, rows) {
 	};
 }
 //#endregion
-//#region src/terminal-camera-declarations.ts
-/**
-* Feed DeclaredDevices every live declaration plus one deterministic orphan
-* batch. The generic sweep intentionally refuses an over-limit set; selecting
-* a batch here drains large historical Terminal orphan sets across convergence
-* passes without weakening that global safety guard.
-*/
-function terminalCameraReconciliationIndex(rows, integrationId, declarations, managedStableIds = /* @__PURE__ */ new Set()) {
-	if (!integrationId) return [];
-	const declared = new Set(declarations.map((camera) => camera.stableId));
-	const owned = rows.filter((row) => row.integrationId === integrationId && (declared.has(row.stableId) || managedStableIds.has(row.stableId) || row.stableId.startsWith("terminal-camera-instance-")));
-	return [...owned.filter((row) => declared.has(row.stableId)), ...owned.filter((row) => !declared.has(row.stableId)).sort((left, right) => left.id - right.id).slice(0, 32)];
-}
-/** Explicit persisted instances, never the node × profile template matrix. */
-function buildTerminalInstanceCameraDeclarations(instances) {
-	return instances.filter((instance) => instance.enabled).map((instance) => ({
-		stableId: instance.cameraStableId,
-		name: instance.name,
-		config: {
-			instanceId: instance.id,
-			nodeId: instance.nodeId,
-			profileId: instance.profileId,
-			profileLabel: instance.profileLabel
-		}
-	}));
-}
-/**
-* `DeviceConfig` materializes schema defaults in memory, so comparing
-* `config.get()` cannot detect a legacy `{ nodeId }` row. Reconciliation must
-* inspect the raw persisted blob to make the profile migration durable.
-*/
-function needsTerminalCameraConfigMigration(persistedConfig, declaration) {
-	return persistedConfig.instanceId !== declaration.config.instanceId || persistedConfig.nodeId !== declaration.config.nodeId || persistedConfig.profileId !== declaration.config.profileId || persistedConfig.profileLabel !== declaration.config.profileLabel;
-}
-/**
-* Monospace families to try, in order — NOT one family and a generic.
-*
-* A terminal screen is mostly box-drawing and block characters, and a font
-* without them renders the frame as noise rather than as missing detail.
-* `DejaVu Sans Mono` covers them and ships in the hub image; macOS has neither
-* DejaVu nor fontconfig, so the Mac agent fell through to a generic whose
-* coverage is not, and its Glances camera came out unreadable while the hub's
-* was pixel-perfect (measured 2026-08-11, same Glances, two nodes).
-*
-* `Menlo` is the fix rather than a guess: it is macOS's default terminal face,
-* present on every install, and derived from DejaVu Sans Mono — the same glyph
-* coverage by ancestry. Monaco and Courier New follow as older fallbacks; the
-* generic stays last so a host with none of them still draws something.
-*/
-var TERMINAL_FONT_STACK = "DejaVu Sans Mono,Menlo,Monaco,Courier New,monospace";
-var TERMINAL_FONT_SIZE = 13;
-var TERMINAL_TEXT_MARGIN_X = 8;
-var TERMINAL_ROW_HEIGHT = 15;
-var TERMINAL_BASELINE_Y = 18;
-/**
-* Distance from a row's baseline up to the top of its cell box. Chosen so
-* consecutive rows tile exactly: row N's box runs from `baseline - this` for
-* `TERMINAL_ROW_HEIGHT`, and row N+1's box starts where it ends. A background
-* bar that stopped short would draw as stripes across a `CSI 42m` panel.
-*/
-var TERMINAL_CELL_ASCENT = 11.5;
-var TERMINAL_CELL_WIDTH = TERMINAL_FONT_SIZE * (1233 / 2048);
-/** Two decimals is under a tenth of a pixel and keeps the SVG small. */
-function coordinate(value) {
-	return String(Number(value.toFixed(2)));
-}
-function escapeXml(value) {
-	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&apos;");
-}
-/**
-* Render already-interpreted terminal rows into a compact MJPEG frame.
-*
-* `xml:space="preserve"` is load-bearing, not tidiness. SVG `<text>` collapses
-* runs of whitespace by default, and a terminal's entire column alignment IS
-* runs of whitespace — Glances pads every field with spaces. Without it the
-* frame drew each line at roughly half its true width, crammed into the
-* top-left of a mostly-black image, while the SAME session over `attach`
-* looked perfect — which is exactly how the operator reported it. Measured in
-* the hub's own rasterizer 2026-08-11: `AAA<10 spaces>BBB<3>CCC` drew 92 px
-* collapsed against 178 px preserved.
-*
-* Every run is anchored at its OWN column (`x = margin + startCol * cellW`),
-* never appended to the one before it, so the background rects and the glyphs
-* are placed off the same grid and cannot drift apart. `textLength` is emitted
-* with it because it is the correct declaration and renderers that honour it
-* get an exact grid — but it is not what makes this work: librsvg, which sharp
-* uses, ignores it outright (measured 2026-08-12, a 120-glyph run pinned to
-* 600 px still drew its natural 937 px). The anchoring is the guarantee.
-*/
-function renderTerminalSvg(rows) {
-	const backgrounds = [];
-	const texts = [];
-	rows.slice(0, 40).forEach((row, index) => {
-		const baseline = TERMINAL_BASELINE_Y + index * TERMINAL_ROW_HEIGHT;
-		const top = baseline - TERMINAL_CELL_ASCENT;
-		let column = 0;
-		for (const run of row) {
-			if (column >= 120) break;
-			const clipped = clipRun(run, 120 - column);
-			const columns = [...clipped].length;
-			if (columns === 0) continue;
-			const x = TERMINAL_TEXT_MARGIN_X + column * TERMINAL_CELL_WIDTH;
-			const width = columns * TERMINAL_CELL_WIDTH;
-			if (run.bg !== null) backgrounds.push(`<rect x="${coordinate(x)}" y="${coordinate(top)}" width="${coordinate(width)}" height="${String(TERMINAL_ROW_HEIGHT)}" fill="${run.bg}"/>`);
-			if (clipped.trim() !== "") {
-				const fill = run.fg === null ? "" : ` fill="${run.fg}"`;
-				const weight = run.bold ? " font-weight=\"bold\"" : "";
-				texts.push(`<text xml:space="preserve" x="${coordinate(x)}" y="${coordinate(baseline)}" textLength="${coordinate(width)}" lengthAdjust="spacingAndGlyphs"${fill}${weight}>${escapeXml(clipped)}</text>`);
-			}
-			column += columns;
-		}
-	});
-	return `<svg xmlns="http://www.w3.org/2000/svg" width="${String(960)}" height="${String(640)}"><rect width="100%" height="100%" fill="${TERMINAL_DEFAULT_BG}"/>${backgrounds.join("")}<g fill="${TERMINAL_DEFAULT_FG}" font-family="${TERMINAL_FONT_STACK}" font-size="${String(TERMINAL_FONT_SIZE)}">${texts.join("")}</g></svg>`;
-}
-/** Cut a run to the columns still left in the row, by code point not unit. */
-function clipRun(run, remaining) {
-	const points = [...run.text];
-	return points.length <= remaining ? run.text : points.slice(0, remaining).join("");
-}
-async function renderTerminalJpeg(rows) {
-	return (0, sharp.default)(Buffer.from(renderTerminalSvg(rows))).jpeg({
-		quality: 82,
-		chromaSubsampling: "4:2:0"
-	}).toBuffer();
-}
-//#endregion
-//#region src/terminal-camera-device.ts
-var terminalCameraSchema = object({
-	instanceId: string().min(1).optional(),
-	nodeId: string().min(1),
-	profileId: string().min(1).default("monitor"),
-	profileLabel: string().min(1).default("BTM")
-});
-var relay = null;
-function installTerminalCameraRelay(next) {
-	relay = next;
-}
-var TerminalCameraDevice = class extends BaseDevice {
-	features = [DeviceFeature.NativeSnapshot];
-	constructor(ctx) {
-		super(ctx, terminalCameraSchema, { type: ctx.deviceMeta.type });
-		this.ctx.registerNativeCap(streamCatalogCapability, { getCatalog: async ({ deviceId }) => {
-			if (deviceId !== this.id) return [];
-			return this.catalog();
-		} });
-		this.ctx.registerNativeCap(snapshotCapability, {
-			getSnapshot: async ({ deviceId }) => {
-				if (deviceId !== this.id) throw new Error(`TerminalCameraDevice: deviceId mismatch, expected ${String(this.id)}, got ${String(deviceId)}`);
-				const activeRelay = relay;
-				if (!activeRelay) throw new Error("terminal camera relay is unavailable");
-				return {
-					base64: (await activeRelay.snapshot(this.relayInstanceId(), this.config.get("nodeId"), this.config.get("profileId"))).toString("base64"),
-					contentType: "image/jpeg"
-				};
-			},
-			invalidateCache: async () => {}
-		});
-		this.markOnline(true);
-	}
-	async catalog() {
-		const activeRelay = relay;
-		if (!activeRelay) throw new Error("terminal camera relay is unavailable");
-		const nodeId = this.config.get("nodeId");
-		const profileId = this.config.get("profileId");
-		const instanceId = this.relayInstanceId();
-		return [{
-			camStreamId: profileId,
-			kind: "pull-http",
-			url: activeRelay.streamUrl(instanceId, nodeId, profileId),
-			codec: "h264",
-			resolution: {
-				width: 960,
-				height: 640
-			},
-			fps: 2,
-			label: this.config.get("profileLabel")
-		}];
-	}
-	setNodeOnline(online) {
-		this.markOnline(online);
-		if (!online) relay?.closeInstance(this.relayInstanceId());
-	}
-	async removeDevice() {
-		await relay?.closeInstance(this.relayInstanceId());
-	}
-	relayInstanceId() {
-		return this.config.get("instanceId") ?? `legacy:${this.stableId}`;
-	}
-};
-//#endregion
 //#region src/terminal-camera-relay.ts
 var MJPEG_BOUNDARY = "camstack-terminal-frame";
 var SESSION_IDLE_MS = 3e4;
@@ -46453,13 +46869,34 @@ function newTerminalCameraStableId(instanceId) {
 * Legacy automatic cameras are migration candidates only. A tombstone is
 * durable deletion intent, so a lingering failed device removal must never
 * make that camera adoptable again.
+*
+* ## `config` is load-bearing — this read can never be `projection: 'slim'`
+*
+* `nodeId`, `profileId` and `profileLabel` all live in the device's `config`,
+* and a row without `nodeId` is skipped. The slim projection returns
+* `config: {}` for every row, so a slim answer here is shape-identical to a
+* fleet that has no legacy cameras — the whole migration section disappears
+* and nothing says why. `legacy-camera-read-shape.spec.ts` is the arm on that.
+*
+* `onSkipped` is why the disappearance would now be visible: a row that LOOKS
+* like a legacy camera (`terminal-camera-*`, not an instance camera, not
+* tombstoned, not already adopted) but carries no `nodeId` is reported with
+* its numeric device id, so the caller can log it per-camera. Rows that are
+* not candidates at all are silent — a fleet of 1 017 devices must not
+* produce 1 017 lines to say none of them is a Terminal monitor.
 */
-function listLegacyTerminalCameraCandidates(rows, instanceStableIds, tombstones) {
+function listLegacyTerminalCameraCandidates(rows, instanceStableIds, tombstones, onSkipped) {
 	const legacy = [];
 	for (const row of rows) {
 		if (tombstones.has(row.stableId) || instanceStableIds.has(row.stableId) || row.stableId.startsWith("terminal-camera-instance-") || !row.stableId.startsWith("terminal-camera-")) continue;
 		const nodeId = typeof row.config.nodeId === "string" ? row.config.nodeId : null;
-		if (!nodeId) continue;
+		if (!nodeId) {
+			onSkipped?.({
+				deviceId: row.id,
+				stableId: row.stableId
+			});
+			continue;
+		}
 		const profileId = typeof row.config.profileId === "string" ? row.config.profileId : "monitor";
 		const profileLabel = typeof row.config.profileLabel === "string" ? row.config.profileLabel : profileId === "monitor" ? "BTM" : profileId;
 		legacy.push({
@@ -46620,111 +47057,6 @@ function findProfile(profiles, profileId) {
 	return profiles.find((p) => p.profileId === profileId);
 }
 //#endregion
-//#region src/profile-settings.ts
-var GLANCES_PLUGINS = [
-	{
-		key: "showCpu",
-		plugin: "cpu",
-		label: "CPU"
-	},
-	{
-		key: "showMem",
-		plugin: "mem",
-		label: "Memory"
-	},
-	{
-		key: "showLoad",
-		plugin: "load",
-		label: "Load"
-	},
-	{
-		key: "showNetwork",
-		plugin: "network",
-		label: "Network"
-	},
-	{
-		key: "showDiskIo",
-		plugin: "diskio",
-		label: "Disk I/O"
-	},
-	{
-		key: "showFs",
-		plugin: "fs",
-		label: "Filesystems"
-	},
-	{
-		key: "showProcessList",
-		plugin: "processlist",
-		label: "Process list"
-	},
-	{
-		key: "showContainers",
-		plugin: "containers",
-		label: "Containers"
-	},
-	{
-		key: "showSensors",
-		plugin: "sensors",
-		label: "Sensors"
-	}
-];
-function glancesBooleanField(key, label) {
-	return {
-		type: "boolean",
-		key,
-		label,
-		default: true,
-		style: "switch"
-	};
-}
-function glancesSettingsSchema() {
-	return { sections: [{
-		id: "glances-panels",
-		title: "Glances panels",
-		description: "Turn off a panel to pass --disable-plugin to this Terminal only. All on is the measured default (~1% of one core at the camera grid).",
-		columns: 2,
-		fields: GLANCES_PLUGINS.map((plugin) => glancesBooleanField(plugin.key, plugin.label))
-	}] };
-}
-function settingsSchemaForProfile(profileId) {
-	if (profileId === "glances") return glancesSettingsSchema();
-	return null;
-}
-function glancesSettingsToArgs(settings) {
-	const disabled = GLANCES_PLUGINS.filter((plugin) => settings[plugin.key] === false).map((plugin) => plugin.plugin);
-	if (disabled.length === 0) return [];
-	return ["--disable-plugin", disabled.join(",")];
-}
-function sanitizeProfileSettings(profileId, raw) {
-	if (profileId !== "glances") return {};
-	const bag = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
-	const out = {
-		showCpu: true,
-		showMem: true,
-		showLoad: true,
-		showNetwork: true,
-		showDiskIo: true,
-		showFs: true,
-		showProcessList: true,
-		showContainers: true,
-		showSensors: true
-	};
-	for (const plugin of GLANCES_PLUGINS) {
-		const value = bag[plugin.key];
-		if (typeof value === "boolean") out[plugin.key] = value;
-	}
-	return out;
-}
-function profileSettingsToArgs(profileId, settings) {
-	if (profileId !== "glances") return [];
-	return glancesSettingsToArgs(sanitizeProfileSettings(profileId, settings));
-}
-function spawnArgsForInstance(input) {
-	const extra = profileSettingsToArgs(input.profileId, input.profileSettings);
-	if (input.instanceArgs.length > 0) return [...input.instanceArgs, ...extra];
-	if (extra.length > 0) return [...input.profileArgs, ...extra];
-}
-//#endregion
 //#region src/terminal-session-manager.ts
 var MIN_GRID = 1;
 var MAX_COLS = 1e3;
@@ -47546,7 +47878,12 @@ var TerminalAddon = class extends BaseAddon {
 	async listLegacyTerminalCameras() {
 		const instances = this.terminalInstances();
 		const instanceStableIds = new Set(instances.map((instance) => instance.cameraStableId));
-		return listLegacyTerminalCameraCandidates(await this.ctx.api.deviceManager.listAll.query({ addonId: this.ctx.id }), instanceStableIds, this.terminalCameraTombstones);
+		return listLegacyTerminalCameraCandidates(await this.ctx.api.deviceManager.listAll.query({ addonId: this.ctx.id }), instanceStableIds, this.terminalCameraTombstones, ({ deviceId, stableId }) => {
+			this.ctx.logger.warn("legacy Terminal camera skipped — its device config carries no nodeId, so it cannot be offered for adoption", {
+				tags: { deviceId },
+				meta: { stableId }
+			});
+		});
 	}
 	async adoptLegacyMonitor(stableId, requestedName) {
 		const instance = await this.instanceMutationQueue.run(() => this.adoptLegacyMonitorUnlocked(stableId, requestedName));