@camstack/addon-terminal 0.1.11 → 0.1.12

package/dist/addon.mjs

@@ -7605,12 +7605,11 @@ var RecordingConfigSchema = object({
 /**
 * Entity-relocation job state (storage entity-routing spec, Phase 4).
 *
-* One shape shared by the recorder's `relocateFootage` (segments) and
-* pipeline-analytics' `relocateMedia` (event media blobs) so the admin Data
-* page renders both movers with one component. Jobs are in-RAM (a restart
-* forgets them — re-running is safe by construction: copy-if-absent, delete
-* after verify) and each completed/failed run also lands one durable ops-log
-* row on the owning addon's surface.
+* One shape shared by the recorder and pipeline-analytics internal movers.
+* The public admin surface is `storage-migration`; child jobs remain in RAM
+* because copy-if-absent, verify, delete and index/row repoint are resumable.
+* Each completed/failed run also lands one durable ops-log row on its owning
+* addon surface.
 */
 var RelocateJobStateSchema = _enum([
 	"running",
@@ -7637,19 +7636,100 @@ var RelocateJobSchema = object({
 	finishedAt: number().nullable(),
 	error: string().nullable()
 });
+/** Profile-derived footage selection used only by the migration coordinator:
+* `recordings` owns high+mid; `recordingsLow` owns low. */
+var RelocateFootageClassSchema = _enum(["recordings", "recordingsLow"]);
 var RelocateFootageInputSchema = object({
-	deviceId: number().optional(),
 	fromLocationId: string(),
 	toLocationId: string(),
 	entities: array(_enum(["segments"])).optional(),
+	/** Limits relocation to the logical profile class. Omit only for the
+	* pre-orchestration compatibility path. */
+	footageClass: RelocateFootageClassSchema.optional(),
 	/** Copy throttle in MB/s (default 40) — the drain is a background chore,
 	*  never allowed to starve live writers. */
 	throttleMbps: number().min(1).max(1e3).optional()
 });
-var RelocateMediaInputSchema = object({
-	deviceId: number().optional(),
+/** Internal, lease-scoped participant operation. It is intentionally separate
+* from persistent recording settings: a migration never changes
+* `RecordingConfig.enabled` or camera wrapper bindings. */
+var StorageMigrationLeaseInputSchema = object({ leaseId: string().min(1) });
+var StorageMigrationFootageMoveInputSchema = RelocateFootageInputSchema.extend({ leaseId: string().min(1) });
+var StorageMigrationMediaMoveInputSchema = object({
 	toLocationId: string(),
 	throttleMbps: number().min(1).max(1e3).optional()
+}).extend({ leaseId: string().min(1) });
+/** The independently selectable logical storage classes. `recordings`
+* encompasses the high and mid segment profiles; `recordingsLow` is low
+* segments; `eventMedia` is post-analysis blobs. */
+var StorageMigrationClassSchema = _enum([
+	"recordings",
+	"recordingsLow",
+	"eventMedia"
+]);
+/** A destination is always an existing, fully-qualified location id. The
+* migration API intentionally never changes a source location's `basePath`:
+* callers create a new `<type>:<slug>` location, then select it here. */
+var StorageMigrationDestinationsSchema = object({
+	recordings: string().min(1).optional(),
+	recordingsLow: string().min(1).optional(),
+	eventMedia: string().min(1).optional()
+}).refine((value) => Object.keys(value).length > 0, { message: "select at least one storage class" });
+/** Shared input for planning and starting an orchestrated storage migration. */
+var StorageMigrationInputSchema = object({
+	destinations: StorageMigrationDestinationsSchema,
+	throttleMbps: number().min(1).max(1e3).optional()
+});
+/** The durable coordinator state machine. The only phase that changes default
+* locations is `repointing`, after every selected mover has completed and been
+* verified. */
+var StorageMigrationPhaseSchema = _enum([
+	"planning",
+	"pausing",
+	"moving",
+	"verifying",
+	"repointing",
+	"refreshing",
+	"resuming",
+	"done",
+	"failed",
+	"cancelled"
+]);
+var StorageMigrationParticipantSchema = _enum([
+	"pipeline",
+	"recorder",
+	"analytics"
+]);
+var StorageMigrationMoveSchema = object({
+	storageClass: StorageMigrationClassSchema,
+	fromLocationId: string(),
+	toLocationId: string(),
+	moverJobId: string().nullable(),
+	state: RelocateJobStateSchema.nullable(),
+	error: string().nullable()
+});
+var StorageMigrationJobSchema = object({
+	jobId: string(),
+	phase: StorageMigrationPhaseSchema,
+	destinations: StorageMigrationDestinationsSchema,
+	throttleMbps: number(),
+	moves: array(StorageMigrationMoveSchema),
+	pauseLeaseId: string().nullable(),
+	pausedParticipants: array(StorageMigrationParticipantSchema),
+	repointed: boolean(),
+	cancelRequested: boolean(),
+	startedAt: number(),
+	updatedAt: number(),
+	finishedAt: number().nullable(),
+	error: string().nullable()
+});
+var StorageMigrationPlanSchema = object({
+	destinations: StorageMigrationDestinationsSchema,
+	moves: array(object({
+		storageClass: StorageMigrationClassSchema,
+		fromLocationId: string(),
+		toLocationId: string()
+	}))
 });
 /**
 * `StorageLocationType` — an addon-declared id that identifies the *kind* of
@@ -16248,13 +16328,19 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
 }), method(object({ deviceId: number() }), EventPruneCountsSchema, {
 	kind: "mutation",
 	auth: "admin"
-}), method(RelocateMediaInputSchema, object({ jobId: string() }), {
+}), method(StorageMigrationLeaseInputSchema, object({ paused: literal(true) }), {
 	kind: "mutation",
 	auth: "admin"
-}), method(object({}), array(RelocateJobSchema).readonly(), {
-	kind: "query",
+}), method(StorageMigrationLeaseInputSchema, object({ resumed: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(StorageMigrationLeaseInputSchema, object({ refreshed: literal(true) }), {
+	kind: "mutation",
 	auth: "admin"
-}), method(object({ jobId: string() }), object({ cancelled: boolean() }), {
+}), method(StorageMigrationMediaMoveInputSchema, object({ jobId: string() }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ jobId: string() }), RelocateJobSchema.nullable(), { auth: "admin" }), method(object({ jobId: string() }), object({ cancelled: boolean() }), {
 	kind: "mutation",
 	auth: "admin"
 }), method(OpsLogQueryInputSchema, array(OpsLogEntrySchema).readonly(), {
@@ -17784,7 +17870,13 @@ var NodeInferenceDevicesSchema = object({
 	reachable: boolean(),
 	devices: array(NodeInferenceDeviceSchema).readonly()
 });
-method(object({
+method(StorageMigrationLeaseInputSchema, object({ paused: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(StorageMigrationLeaseInputSchema, object({ resumed: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
 	deviceId: number(),
 	agentNodeId: string()
 }), object({ success: literal(true) }), {
@@ -18224,7 +18316,33 @@ var SnapshotImageSchema = object({
 	base64: string(),
 	contentType: string()
 });
-object({
+/**
+* snapshot — device-scoped capability for camera image capture.
+*
+* Two kinds of providers coexist behind this cap name:
+*
+*   - **Native** providers (kind:'native'): registered per-device by
+*     device-driver addons (RtspCamera, OnvifCamera, …) via
+*     `DeviceContext.registerNativeCap`. Each knows how to fetch a frame
+*     straight from the camera (HTTP snapshot URL, ONVIF action, etc.).
+*
+*   - **Wrapper** providers (kind:'wrapper'): register as a system
+*     provider (SnapshotAddon in `@camstack/system/builtins/snapshot`). The
+*     wrapper owns the cache and invokes the native via
+*     `ctx.getNativeProvider(snapshotCapability, deviceId)` on miss.
+*
+* Device-scoped routing: callers use `ctx.fetchDevice(id).snapshot.*`;
+* the DeviceProxy auto-injects `deviceId` + `nodeId` and dispatches to
+* the provider currently active for that device (wrapper wins when
+* activated via `setWrapperActive`, otherwise the native).
+*/
+/**
+* Live readable snapshot state — diagnostic info that a consumer can
+* pull to know when the last image was captured, how stale the cache
+* is, and which stream was used. Distinct from `getSnapshot` which
+* returns the JPEG itself.
+*/
+var SnapshotStatusSchema = object({
 	/** Ms epoch of the last successful capture. Null if none yet. */
 	lastCapturedAt: number().nullable(),
 	/** Age of the cached image in ms. Null if no cache. */
@@ -18234,64 +18352,129 @@ object({
 	/** Stream id used for the last capture ('high'|'mid'|'low' or custom). Null if via HTTP endpoint. */
 	lastStreamId: string().nullable()
 });
-DeviceType.Camera, method(object({
-	deviceId: number(),
-	streamId: string().optional(),
-	/**
-	* Bypass the cache freshness check and fetch directly from the
-	* native (or stream-broker fallback). Triggered by the UI's
-	* "refresh" button so an operator can force a fresh frame
-	* even when the cache is well within the device's
-	* `snapshotMaxAgeS` window.
-	*
-	* **`force` is an OPERATOR signal, not a freshness preference.** On a
-	* battery camera it is the one thing that walks past the wrapper's
-	* sleep gate and wakes the camera, so a background caller — a poller,
-	* an event handler, a thumbnail — must NEVER set it. Every such caller
-	* gets the cached frame, which on a sleeping battery camera is the
-	* correct answer: stale but honest beats woken.
-	*/
-	force: boolean().optional()
-}), SnapshotImageSchema.nullable()), method(object({ deviceId: number() }), _void(), {
-	kind: "mutation",
-	auth: "admin"
-}), systemMethod(object({ deviceIds: array(number()).min(1).max(200) }), array(object({
-	deviceId: number(),
-	lastCapturedAt: number().nullable(),
-	cacheAgeMs: number().nullable(),
-	etag: string().nullable()
-}))), systemMethod(object({ 
-/** The tiles a surface is actually rendering. One entry per (device,
-*  width) the caller will paint — the width is snapped to the server's
-*  ladder and becomes part of the link's SIGNED identity. */
+var snapshotCapability = {
+	name: "snapshot",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	kind: "wrapper",
+	defaultActive: true,
+	deviceTypes: [DeviceType.Camera],
+	exposesDeviceSettings: true,
+	methods: {
+		getSnapshot: method(object({
+			deviceId: number(),
+			streamId: string().optional(),
+			/**
+			* Bypass the cache freshness check and fetch directly from the
+			* native (or stream-broker fallback). Triggered by the UI's
+			* "refresh" button so an operator can force a fresh frame
+			* even when the cache is well within the device's
+			* `snapshotMaxAgeS` window.
+			*
+			* **`force` is an OPERATOR signal, not a freshness preference.** On a
+			* battery camera it is the one thing that walks past the wrapper's
+			* sleep gate and wakes the camera, so a background caller — a poller,
+			* an event handler, a thumbnail — must NEVER set it. Every such caller
+			* gets the cached frame, which on a sleeping battery camera is the
+			* correct answer: stale but honest beats woken.
+			*/
+			force: boolean().optional()
+		}), SnapshotImageSchema.nullable()),
+		invalidateCache: method(object({ deviceId: number() }), _void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
+		* Cache-only batch overview — answers from the wrapper's in-memory cache in
+		* O(n) and NEVER triggers a capture. Lets a grid skip requesting images for
+		* devices that never produced a frame, and gives it an ETag per device for
+		* conditional (304-able) image fetches. `lastCapturedAt`/`cacheAgeMs`/`etag`
+		* are null for a device with no cached frame.
+		*/
+		getSnapshotOverview: systemMethod(object({ deviceIds: array(number()).min(1).max(200) }), array(object({
+			deviceId: number(),
+			lastCapturedAt: number().nullable(),
+			cacheAgeMs: number().nullable(),
+			etag: string().nullable()
+		}))),
+		/**
+		* Signed, expiring links to a CLIENT-SIZED frame — and the demand signal
+		* that makes those frames current.
+		*
+		* ## The problem it replaces
+		*
+		* `getSnapshotOverview` is cache-only by contract: it answers from whatever
+		* the wrapper happens to hold and never captures. Under D93 the client
+		* versions its image URL on that answer, and an image REQUEST is what enrols
+		* a camera in the keep-warm loop. Both of those are satisfiable by the
+		* client's own image cache — `expo-image` is URL-keyed and never revalidates
+		* — so a URL painted in a previous session comes off disk with no network,
+		* no enrolment, and nothing warming. Measured on the live hub: reopening
+		* after two minutes idle painted 15 of 16 tiles at **168 s old** with zero
+		* HTTP requests, and the fleet only recovered because a later poll happened
+		* to observe a different identity.
+		*
+		* ## The two properties that fix it
+		*
+		* **It is an RPC, so no client cache can answer it.** The demand signal
+		* always reaches the wrapper. This method therefore MAY create keep-warm
+		* subscriptions, where `getSnapshotOverview` must never (D93) — the
+		* distinction is not "one is newer" but that the overview poll is app-wide
+		* (a creating overview would warm every camera on the install) while this is
+		* called by a rendered surface naming the tiles it is actually painting, at
+		* the width it is painting them.
+		*
+		* **It waits, briefly and boundedly, for the capture it triggered.** The
+		* returned `capturedAt` is the frame the link will serve, not the frame the
+		* cache held when the client asked, so a first paint is honest and current
+		* instead of a generation behind. A device that does not settle inside the
+		* bound still gets a link and its real (older) `capturedAt` — the next poll
+		* carries it forward.
+		*
+		* `force` is never set on behalf of a client here. A sleeping battery camera
+		* is reported with `sleeping: true` and the last frame it produced, however
+		* old; the wrapper's existing sleep gate owns that decision and this method
+		* adds no second one.
+		*/
+		getSnapshotLinks: systemMethod(object({ 
+		/** The tiles a surface is actually rendering. One entry per (device,
+		*  width) the caller will paint — the width is snapped to the server's
+		*  ladder and becomes part of the link's SIGNED identity. */
 targets: array(object({
-	deviceId: number(),
-	/** Target width in px. Omit for the frame as captured — correct
-	*  for a full-bleed surface, wrong (and expensive) for a grid. */
-	width: number().int().positive().optional()
-})).min(1).max(200) }), array(object({
-	deviceId: number(),
-	/** Root-relative signed path, or null when the link plane is not
-	*  served (no data-plane facility). Present even for a device that has
-	*  never captured — the request is what triggers the first one (D94). */
-	url: string().nullable(),
-	/** Epoch ms of the frame this link serves. Null = never captured.
-	*  THE honest age: the tRPC path carried none before this. */
-	capturedAt: number().nullable(),
-	/** Age of that frame at the moment the answer was built. */
-	ageMs: number().nullable(),
-	/** Epoch ms after which `url` stops verifying. */
-	expiresAt: number().nullable(),
-	/** Ladder rung the bytes are at; null = the frame as captured. */
-	width: number().nullable(),
-	/** The device has never produced a frame. An empty state, not a
-	*  failure — and never a reason to withhold the link (D94). */
-	neverCaptured: boolean(),
-	/** A sleeping battery camera: the frame is deliberately stale and will
-	*  NOT refresh in the background. A surface should say so rather than
-	*  present it as current. */
-	sleeping: boolean()
-})));
+			deviceId: number(),
+			/** Target width in px. Omit for the frame as captured — correct
+			*  for a full-bleed surface, wrong (and expensive) for a grid. */
+			width: number().int().positive().optional()
+		})).min(1).max(200) }), array(object({
+			deviceId: number(),
+			/** Root-relative signed path, or null when the link plane is not
+			*  served (no data-plane facility). Present even for a device that has
+			*  never captured — the request is what triggers the first one (D94). */
+			url: string().nullable(),
+			/** Epoch ms of the frame this link serves. Null = never captured.
+			*  THE honest age: the tRPC path carried none before this. */
+			capturedAt: number().nullable(),
+			/** Age of that frame at the moment the answer was built. */
+			ageMs: number().nullable(),
+			/** Epoch ms after which `url` stops verifying. */
+			expiresAt: number().nullable(),
+			/** Ladder rung the bytes are at; null = the frame as captured. */
+			width: number().nullable(),
+			/** The device has never produced a frame. An empty state, not a
+			*  failure — and never a reason to withhold the link (D94). */
+			neverCaptured: boolean(),
+			/** A sleeping battery camera: the frame is deliberately stale and will
+			*  NOT refresh in the background. A surface should say so rather than
+			*  present it as current. */
+			sleeping: boolean()
+		})))
+	},
+	status: {
+		schema: SnapshotStatusSchema,
+		kind: "poll"
+	}
+};
 /**
 * `sso-bridge` — internal hub-only cap that lets SSO-style auth
 * providers (OIDC, SAML, magic-link, …) mint an HMAC-signed token
@@ -18458,6 +18641,13 @@ method(object({ locationId: string() }), EvictableUsageSchema), method(object({
 	locationId: string(),
 	targetBytes: number().int().positive()
 }), EvictResultSchema, { kind: "mutation" });
+method(StorageMigrationInputSchema, StorageMigrationPlanSchema, { auth: "admin" }), method(StorageMigrationInputSchema, object({ jobId: string() }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ jobId: string().optional() }), StorageMigrationJobSchema.nullable(), { auth: "admin" }), method(object({ jobId: string() }), object({ cancelled: boolean() }), {
+	kind: "mutation",
+	auth: "admin"
+});
 var ProviderInfoSchema = discriminatedUnion("shouldSaveDiskSpace", [object({
 	providerId: string().min(1),
 	displayName: string().min(1),
@@ -18561,6 +18751,28 @@ var TerminalProfileInfoSchema = object({
 	label: string(),
 	description: string().optional()
 });
+/**
+* A durable operator-created Terminal instance. Profiles are templates; only
+* an instance declares a camera.
+*/
+var TerminalInstanceInfoSchema = object({
+	instanceId: string(),
+	cameraStableId: string(),
+	nodeId: string(),
+	profileId: string(),
+	profileLabel: string(),
+	name: string(),
+	enabled: boolean()
+});
+var TerminalLegacyCameraSchema = object({
+	stableId: string(),
+	nodeId: string(),
+	profileId: string(),
+	profileLabel: string(),
+	name: string(),
+	/** Only legacy monitor cameras can retain their historic stable identity. */
+	adoptable: boolean()
+});
 var TerminalOutputEventSchema = discriminatedUnion("kind", [object({
 	seq: number().int().positive(),
 	kind: literal("data"),
@@ -18580,10 +18792,9 @@ var TerminalOutputBatchSchema = object({
 /**
 * terminal-session — singleton system capability for interactive TTY sessions.
 *
-* Phase 1 (this cap): open/resize/close/list a pty running an allowlisted
-* profile, streamed to xterm.js over the data plane. Phase 2 (streaming a
-* session as a camera) is a separate device-provider concern and does not
-* change this contract.
+* Owns both live PTY lifecycle and durable Terminal instance management.
+* Profiles are allowlisted templates; an explicit instance is the only path
+* that declares a camera.
 */
 var terminalSessionCapability = {
 	name: "terminal-session",
@@ -18592,6 +18803,37 @@ var terminalSessionCapability = {
 	methods: {
 		/** Pre-declared profiles the operator may open. */
 		listProfiles: method(_void(), array(TerminalProfileInfoSchema).readonly(), { auth: "admin" }),
+		/** Explicit durable Terminal instances, managed centrally on the hub. */
+		listInstances: method(_void(), array(TerminalInstanceInfoSchema).readonly(), { auth: "admin" }),
+		createInstance: method(object({
+			targetNodeId: string().min(1),
+			profileId: string().min(1),
+			name: string().trim().min(1).max(160).optional()
+		}), TerminalInstanceInfoSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		deleteInstance: method(object({ instanceId: string().min(1) }), _void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		setInstanceEnabled: method(object({
+			instanceId: string().min(1),
+			enabled: boolean()
+		}), TerminalInstanceInfoSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/** Existing automatic cameras are shown for explicit migration only. */
+		listLegacyCameras: method(_void(), array(TerminalLegacyCameraSchema).readonly(), { auth: "admin" }),
+		/** Explicitly adopt one legacy monitor camera, retaining its stable id. */
+		adoptLegacyMonitor: method(object({
+			stableId: string().min(1),
+			name: string().trim().min(1).max(160).optional()
+		}), TerminalInstanceInfoSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** Live sessions currently hosted by the provider. */
 		listSessions: method(_void(), array(TerminalSessionInfoSchema).readonly(), { auth: "admin" }),
 		/**
@@ -18623,7 +18865,13 @@ var terminalSessionCapability = {
 		pullOutput: method(object({
 			sessionId: string(),
 			afterSeq: number().int().nonnegative(),
-			waitMs: number().int().min(0).max(2e3).default(0)
+			waitMs: number().int().min(0).max(2e3).default(0),
+			/**
+			* Wait when a just-opened session has no output yet. Kept opt-in so a
+			* browser's initial repaint remains immediate; the camera snapshot
+			* relay uses it to avoid encoding a blank startup frame.
+			*/
+			waitForOutput: boolean().optional()
 		}), TerminalOutputBatchSchema, {
 			kind: "mutation",
 			auth: "admin",
@@ -24602,13 +24850,19 @@ method(object({
 }), {
 	kind: "mutation",
 	auth: "admin"
-}), method(RelocateFootageInputSchema, object({ jobId: string() }), {
+}), method(StorageMigrationLeaseInputSchema, object({ paused: literal(true) }), {
 	kind: "mutation",
 	auth: "admin"
-}), method(object({}), array(RelocateJobSchema).readonly(), {
-	kind: "query",
+}), method(StorageMigrationLeaseInputSchema, object({ resumed: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(StorageMigrationLeaseInputSchema, object({ refreshed: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(StorageMigrationFootageMoveInputSchema, object({ jobId: string() }), {
+	kind: "mutation",
 	auth: "admin"
-}), method(object({ jobId: string() }), object({ cancelled: boolean() }), {
+}), method(object({ jobId: string() }), RelocateJobSchema.nullable(), { auth: "admin" }), method(object({ jobId: string() }), object({ cancelled: boolean() }), {
 	kind: "mutation",
 	auth: "admin"
 });
@@ -30300,7 +30554,7 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"pipelineAnalytics.cancelMediaRelocate": {
+	"pipelineAnalytics.cancelStorageMigrationMove": {
 		capName: "pipeline-analytics",
 		capScope: "device",
 		addonId: null,
@@ -30372,12 +30626,6 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
-	"pipelineAnalytics.getMediaRelocateStatus": {
-		capName: "pipeline-analytics",
-		capScope: "device",
-		addonId: null,
-		access: "view"
-	},
 	"pipelineAnalytics.getMotionEvents": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -30414,6 +30662,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineAnalytics.getStorageMigrationMoveStatus": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.getTrack": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -30492,6 +30746,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineAnalytics.pauseForStorageMigration": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineAnalytics.proposeRetrainAnnotations": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -30522,7 +30782,7 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"pipelineAnalytics.relocateMedia": {
+	"pipelineAnalytics.refreshStorageLocationsForMigration": {
 		capName: "pipeline-analytics",
 		capScope: "device",
 		addonId: null,
@@ -30534,6 +30794,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineAnalytics.resumeForStorageMigration": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineAnalytics.saveRetrainAnnotations": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -30558,6 +30824,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineAnalytics.startStorageMigrationMove": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineAnalytics.wipeAllAnalytics": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -30924,6 +31196,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineOrchestrator.pauseForStorageMigration": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineOrchestrator.rebalance": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -30948,6 +31226,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineOrchestrator.resumeForStorageMigration": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineOrchestrator.saveTemplate": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -31344,7 +31628,7 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"recording.cancelRelocate": {
+	"recording.cancelStorageMigrationMove": {
 		capName: "recording",
 		capScope: "system",
 		addonId: null,
@@ -31380,7 +31664,7 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
-	"recording.getRelocateStatus": {
+	"recording.getStorageMigrationMoveStatus": {
 		capName: "recording",
 		capScope: "system",
 		addonId: null,
@@ -31404,6 +31688,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"recording.pauseForStorageMigration": {
+		capName: "recording",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"recording.pruneFootage": {
 		capName: "recording",
 		capScope: "system",
@@ -31422,7 +31712,7 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
-	"recording.relocateFootage": {
+	"recording.refreshStorageLocationsForMigration": {
 		capName: "recording",
 		capScope: "system",
 		addonId: null,
@@ -31446,12 +31736,24 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"recording.resumeForStorageMigration": {
+		capName: "recording",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"recording.setDeviceConfig": {
 		capName: "recording",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
+	"recording.startStorageMigrationMove": {
+		capName: "recording",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"recordingExport.cancelExport": {
 		capName: "recordingExport",
 		capScope: "system",
@@ -31842,6 +32144,30 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"storageMigration.cancel": {
+		capName: "storage-migration",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"storageMigration.plan": {
+		capName: "storage-migration",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"storageMigration.start": {
+		capName: "storage-migration",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"storageMigration.status": {
+		capName: "storage-migration",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"storageProvider.abortUpload": {
 		capName: "storage-provider",
 		capScope: "system",
@@ -32220,12 +32546,42 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"terminalSession.adoptLegacyMonitor": {
+		capName: "terminal-session",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"terminalSession.close": {
 		capName: "terminal-session",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
+	"terminalSession.createInstance": {
+		capName: "terminal-session",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"terminalSession.deleteInstance": {
+		capName: "terminal-session",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"terminalSession.listInstances": {
+		capName: "terminal-session",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"terminalSession.listLegacyCameras": {
+		capName: "terminal-session",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"terminalSession.listProfiles": {
 		capName: "terminal-session",
 		capScope: "system",
@@ -32256,6 +32612,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"terminalSession.setInstanceEnabled": {
+		capName: "terminal-session",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"terminalSession.writeInput": {
 		capName: "terminal-session",
 		capScope: "system",
@@ -33058,19 +33420,38 @@ async function warmNodePty() {
 }
 //#endregion
 //#region src/terminal-camera-declarations.ts
-function buildTerminalCameraDeclarations(nodes, profilesByNode) {
-	return nodes.flatMap((node) => {
-		const nodeLabel = node.isHub ? "Hub" : node.name;
-		return (profilesByNode.get(node.id) ?? []).map((profile) => ({
-			stableId: profile.profileId === "monitor" ? `terminal-camera-${node.id}` : `terminal-camera-${node.id}-${profile.profileId}`,
-			name: `Terminal ${profile.label} - ${nodeLabel}`,
-			config: {
-				nodeId: node.id,
-				profileId: profile.profileId,
-				profileLabel: profile.label
-			}
-		}));
-	});
+/**
+* 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;
 }
 function escapeXml(value) {
 	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&apos;");
@@ -33087,22 +33468,35 @@ async function renderTerminalJpeg(lines) {
 //#endregion
 //#region src/terminal-camera-device.ts
 var terminalCameraSchema = object({
+	instanceId: string().min(1).optional(),
 	nodeId: string().min(1),
-	profileId: string().min(1),
-	profileLabel: 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 = [];
+	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() {
@@ -33110,10 +33504,11 @@ var TerminalCameraDevice = class extends BaseDevice {
 		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(nodeId, profileId),
+			url: activeRelay.streamUrl(instanceId, nodeId, profileId),
 			codec: "h264",
 			resolution: {
 				width: 960,
@@ -33125,6 +33520,13 @@ var TerminalCameraDevice = class extends BaseDevice {
 	}
 	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
@@ -37973,18 +38375,24 @@ function createXtermScreen(cols, rows) {
 //#region src/terminal-camera-relay.ts
 var MJPEG_BOUNDARY = "camstack-terminal-frame";
 var SESSION_IDLE_MS = 3e4;
-function relayKey(nodeId, profileId) {
-	return `${nodeId}\0${profileId}`;
+var SNAPSHOT_STARTUP_WAIT_MS = 1500;
+var CLOSE_RETRY_BASE_MS = 50;
+var CLOSE_RETRY_MAX_MS = 1e3;
+var CLOSE_ATTEMPTS_PER_PASS = 3;
+function relayKey(instanceId) {
+	return instanceId;
 }
 function parseStreamPath(url) {
 	const parts = ((url ?? "").split("?")[0] ?? "").split("/").filter(Boolean);
-	if (parts.length !== 3 || parts[0] !== "stream") return null;
+	if (parts.length !== 4 || parts[0] !== "stream") return null;
 	try {
-		const nodeId = decodeURIComponent(parts[1] ?? "");
-		const profilePart = parts[2] ?? "";
+		const instanceId = decodeURIComponent(parts[1] ?? "");
+		const nodeId = decodeURIComponent(parts[2] ?? "");
+		const profilePart = parts[3] ?? "";
 		if (!profilePart.endsWith(".mjpeg")) return null;
 		const profileId = decodeURIComponent(profilePart.slice(0, -6));
-		return nodeId && profileId ? {
+		return instanceId && nodeId && profileId ? {
+			instanceId,
 			nodeId,
 			profileId
 		} : null;
@@ -38011,7 +38419,7 @@ var TerminalCameraRelay = class {
 				res.writeHead(404).end();
 				return;
 			}
-			this.serve(target.nodeId, target.profileId, res);
+			this.serve(target.instanceId, target.nodeId, target.profileId, res);
 		});
 		await new Promise((resolve, reject) => {
 			server.once("error", reject);
@@ -38025,55 +38433,105 @@ var TerminalCameraRelay = class {
 		this.server = server;
 		this.baseUrl = `http://127.0.0.1:${String(address.port)}`;
 	}
-	streamUrl(nodeId, profileId) {
+	streamUrl(instanceId, nodeId, profileId) {
 		if (!this.baseUrl) throw new Error("terminal camera relay is not started");
-		return `${this.baseUrl}/stream/${encodeURIComponent(nodeId)}/${encodeURIComponent(profileId)}.mjpeg`;
+		return `${this.baseUrl}/stream/${encodeURIComponent(instanceId)}/${encodeURIComponent(nodeId)}/${encodeURIComponent(profileId)}.mjpeg`;
 	}
 	async listProfiles(nodeId) {
 		return this.api.listProfiles(nodeId);
 	}
-	state(nodeId, profileId) {
-		const key = relayKey(nodeId, profileId);
+	state(instanceId, nodeId, profileId) {
+		const key = relayKey(instanceId);
 		const existing = this.states.get(key);
 		if (existing) return existing;
 		const created = {
+			instanceId,
 			nodeId,
 			profileId,
 			screen: createXtermScreen(120, 40),
 			sessionId: null,
 			cursor: 0,
 			clients: 0,
+			leases: 0,
 			jpeg: null,
 			renderedCursor: -1,
 			framePromise: null,
-			idleTimer: null
+			openPromise: null,
+			idleTimer: null,
+			closing: false,
+			closePromise: null,
+			closeRetryTimer: null,
+			closeAttempts: 0,
+			closed: false,
+			responses: /* @__PURE__ */ new Set()
 		};
 		this.states.set(key, created);
 		return created;
 	}
 	async ensureSession(state) {
+		if (state.closed || state.closing) throw new Error("terminal camera relay is waiting for prior session cleanup");
 		if (state.sessionId) return state.sessionId;
-		const opened = await this.api.openSession(state.nodeId, {
+		if (state.openPromise) {
+			const opened = await state.openPromise;
+			if (state.closed || state.closing) throw new Error("terminal camera relay state closed while opening its session");
+			return opened.sessionId;
+		}
+		const opening = this.api.openSession(state.nodeId, {
 			profileId: state.profileId,
 			cols: 120,
 			rows: 40
 		});
-		state.sessionId = opened.sessionId;
-		state.cursor = 0;
-		return opened.sessionId;
+		state.openPromise = opening;
+		try {
+			const opened = await opening;
+			state.openPromise = null;
+			if (state.closed || state.closing) {
+				state.sessionId = opened.sessionId;
+				await this.closeState(state);
+				throw new Error("terminal camera relay state closed while opening its session");
+			}
+			state.sessionId = opened.sessionId;
+			state.cursor = 0;
+			return opened.sessionId;
+		} catch (error) {
+			if (state.closing && !state.sessionId) this.finishClose(state);
+			throw error;
+		} finally {
+			if (state.openPromise === opening) state.openPromise = null;
+		}
 	}
-	async nextFrame(state) {
-		if (state.framePromise) return state.framePromise;
+	async nextFrame(state, forceRender = false, waitForInitialOutput = false) {
+		if (state.framePromise) {
+			await state.framePromise;
+			return forceRender ? this.nextFrame(state, true, waitForInitialOutput) : state.jpeg ?? this.nextFrame(state, false, waitForInitialOutput);
+		}
 		const render = async () => {
+			const openingSession = state.sessionId === null;
 			const sessionId = await this.ensureSession(state);
 			let batch;
 			try {
 				batch = await this.api.pullOutput(state.nodeId, {
 					sessionId,
-					afterSeq: state.cursor
+					afterSeq: state.cursor,
+					...openingSession && waitForInitialOutput ? {
+						waitMs: SNAPSHOT_STARTUP_WAIT_MS,
+						waitForOutput: true
+					} : {}
 				});
 			} catch (error) {
-				state.sessionId = null;
+				if (state.sessionId === sessionId) {
+					let closed = false;
+					await this.api.closeSession(state.nodeId, sessionId).then(() => {
+						closed = true;
+					}).catch((closeError) => {
+						this.logger.warn("terminal camera session cleanup after output failure failed", { meta: {
+							nodeId: state.nodeId,
+							sessionId,
+							error: closeError instanceof Error ? closeError.message : String(closeError)
+						} });
+					});
+					if (closed) state.sessionId = null;
+				}
 				state.cursor = 0;
 				throw error;
 			}
@@ -38090,7 +38548,7 @@ var TerminalCameraRelay = class {
 			}
 			state.cursor = exited ? 0 : batch.cursor;
 			await state.screen.flush();
-			if (state.jpeg === null || state.renderedCursor !== state.cursor) {
+			if (forceRender || state.jpeg === null || state.renderedCursor !== state.cursor) {
 				state.jpeg = await renderTerminalJpeg(state.screen.lines());
 				state.renderedCursor = state.cursor;
 			}
@@ -38101,14 +38559,15 @@ var TerminalCameraRelay = class {
 		});
 		return state.framePromise;
 	}
-	async serve(nodeId, profileId, res) {
+	async serve(instanceId, nodeId, profileId, res) {
 		this.responses.add(res);
-		const state = this.state(nodeId, profileId);
+		const state = this.state(instanceId, nodeId, profileId);
 		if (state.idleTimer) clearTimeout(state.idleTimer);
 		state.idleTimer = null;
 		state.clients += 1;
+		state.responses.add(res);
 		try {
-			const first = await this.nextFrame(state);
+			const first = await this.nextFrame(state, false, true);
 			res.writeHead(200, {
 				"content-type": `multipart/x-mixed-replace; boundary=${MJPEG_BOUNDARY}`,
 				"cache-control": "no-store",
@@ -38136,11 +38595,13 @@ var TerminalCameraRelay = class {
 			res.end("terminal camera unavailable");
 		} finally {
 			this.responses.delete(res);
+			state.responses.delete(res);
 			state.clients = Math.max(0, state.clients - 1);
-			if (state.clients === 0) this.scheduleIdleClose(state);
+			if (state.clients === 0 && state.leases === 0) this.scheduleIdleClose(state);
 		}
 	}
 	scheduleIdleClose(state) {
+		if (state.closed || state.closing || state.clients > 0 || state.leases > 0) return;
 		if (state.idleTimer) clearTimeout(state.idleTimer);
 		state.idleTimer = setTimeout(() => {
 			this.closeState(state);
@@ -38148,26 +38609,116 @@ var TerminalCameraRelay = class {
 		state.idleTimer.unref?.();
 	}
 	async closeState(state) {
-		if (state.clients > 0) return;
-		if (state.sessionId) await this.api.closeSession(state.nodeId, state.sessionId).catch((error) => {
+		if (state.closed) return;
+		if (state.clients > 0 || state.leases > 0) return;
+		if (state.closePromise) {
+			await state.closePromise;
+			return;
+		}
+		if (state.openPromise && !state.sessionId) {
+			state.closing = true;
+			if (state.idleTimer) clearTimeout(state.idleTimer);
+			state.idleTimer = null;
+			return;
+		}
+		if (state.closing && !state.sessionId) return;
+		state.closing = true;
+		if (state.idleTimer) clearTimeout(state.idleTimer);
+		state.idleTimer = null;
+		state.closePromise = this.closeWithRetries(state).finally(() => {
+			state.closePromise = null;
+		});
+		await state.closePromise;
+	}
+	async closeWithRetries(state) {
+		const sessionId = state.sessionId;
+		if (!sessionId) {
+			this.finishClose(state);
+			return;
+		}
+		for (let attempt = 0; attempt < CLOSE_ATTEMPTS_PER_PASS; attempt += 1) try {
+			await this.api.closeSession(state.nodeId, sessionId);
+			if (state.sessionId === sessionId) this.finishClose(state);
+			return;
+		} catch (error) {
+			state.closeAttempts += 1;
 			this.logger.warn("terminal camera session close failed", { meta: {
 				nodeId: state.nodeId,
-				sessionId: state.sessionId,
+				sessionId,
+				attempt: state.closeAttempts,
 				error: error instanceof Error ? error.message : String(error)
 			} });
-		});
+			if (attempt + 1 < CLOSE_ATTEMPTS_PER_PASS) await new Promise((resolve) => setTimeout(resolve, this.closeRetryDelay(state.closeAttempts)));
+		}
+		this.scheduleCloseRetry(state);
+	}
+	scheduleCloseRetry(state) {
+		if (state.closeRetryTimer || !state.sessionId) return;
+		state.closeRetryTimer = setTimeout(() => {
+			state.closeRetryTimer = null;
+			state.closing = false;
+			this.closeState(state);
+		}, this.closeRetryDelay(state.closeAttempts));
+		state.closeRetryTimer.unref?.();
+	}
+	closeRetryDelay(attempt) {
+		return Math.min(CLOSE_RETRY_BASE_MS * 2 ** Math.min(attempt - 1, 5), CLOSE_RETRY_MAX_MS);
+	}
+	finishClose(state) {
+		if (state.closed) return;
+		state.closed = true;
+		if (state.closeRetryTimer) clearTimeout(state.closeRetryTimer);
+		state.closeRetryTimer = null;
+		state.sessionId = null;
+		state.closeAttempts = 0;
+		state.closing = false;
+		if (this.states.get(relayKey(state.instanceId)) === state) this.states.delete(relayKey(state.instanceId));
 		state.screen.dispose();
-		this.states.delete(relayKey(state.nodeId, state.profileId));
+	}
+	/**
+	* Capture one fresh JPEG using the same xterm renderer as the MJPEG relay.
+	* A snapshot-only caller owns a short lease and tears the state down as soon
+	* as the image is rendered, so snapshots never leave a monitor PTY running.
+	*/
+	async snapshot(instanceId, nodeId, profileId) {
+		const state = this.state(instanceId, nodeId, profileId);
+		if (state.idleTimer) clearTimeout(state.idleTimer);
+		state.idleTimer = null;
+		state.leases += 1;
+		try {
+			return await this.nextFrame(state, true, true);
+		} finally {
+			state.leases = Math.max(0, state.leases - 1);
+			if (state.clients === 0 && state.leases === 0) await this.closeState(state);
+		}
+	}
+	/** Stop a withdrawn/offline camera's relay, including active HTTP readers. */
+	async closeInstance(instanceId) {
+		const state = this.states.get(relayKey(instanceId));
+		if (!state) return;
+		for (const response of state.responses) response.destroy();
+		state.responses.clear();
+		state.clients = 0;
+		state.leases = 0;
+		await this.closeState(state);
+		if (state.openPromise) {
+			await state.openPromise.catch(() => {});
+			await this.closeState(state);
+		}
 	}
 	async dispose() {
 		for (const response of this.responses) response.destroy();
 		this.responses.clear();
-		for (const state of this.states.values()) {
+		for (const state of [...this.states.values()]) {
 			if (state.idleTimer) clearTimeout(state.idleTimer);
 			state.clients = 0;
+			state.leases = 0;
 			await this.closeState(state);
+			if (state.openPromise) {
+				await state.openPromise.catch(() => {});
+				await this.closeState(state);
+			}
 		}
-		this.states.clear();
 		if (this.server) {
 			const server = this.server;
 			this.server = null;
@@ -38283,6 +38834,113 @@ function createTerminalDataPlaneHandler(manager) {
 	};
 }
 //#endregion
+//#region src/terminal-instances.ts
+var TerminalInstanceSchema = object({
+	id: string().uuid(),
+	cameraStableId: string().min(1).max(256),
+	nodeId: string().min(1).max(256),
+	profileId: string().min(1).max(64),
+	profileLabel: string().min(1).max(120),
+	name: string().min(1).max(160),
+	enabled: boolean()
+});
+/**
+* Config is operator-writable, so malformed or duplicate rows are ignored
+* rather than allowed to make declaration reconciliation destructive.
+*/
+function readTerminalInstances(raw, onInvalid) {
+	const ids = /* @__PURE__ */ new Set();
+	const stableIds = /* @__PURE__ */ new Set();
+	const instances = [];
+	for (const value of raw) {
+		const parsed = TerminalInstanceSchema.safeParse(value);
+		if (!parsed.success) {
+			onInvalid?.("Ignoring malformed Terminal instance configuration");
+			continue;
+		}
+		const instance = parsed.data;
+		if (ids.has(instance.id) || stableIds.has(instance.cameraStableId)) {
+			onInvalid?.(`Ignoring duplicate Terminal instance ${instance.id}`);
+			continue;
+		}
+		ids.add(instance.id);
+		stableIds.add(instance.cameraStableId);
+		instances.push(instance);
+	}
+	return instances;
+}
+function newTerminalCameraStableId(instanceId) {
+	return `terminal-camera-instance-${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.
+*/
+function listLegacyTerminalCameraCandidates(rows, instanceStableIds, tombstones) {
+	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;
+		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({
+			stableId: row.stableId,
+			nodeId,
+			profileId,
+			profileLabel,
+			name: row.name,
+			adoptable: profileId === "monitor" && row.stableId === `terminal-camera-${nodeId}`
+		});
+	}
+	return legacy;
+}
+/** Serializes config read-modify-write operations and their reconciliation. */
+var TerminalInstanceMutationQueue = class {
+	tail = Promise.resolve();
+	async run(mutation) {
+		const previous = this.tail;
+		let release;
+		this.tail = new Promise((resolve) => {
+			release = resolve;
+		});
+		await previous;
+		try {
+			return await mutation();
+		} finally {
+			release?.();
+		}
+	}
+};
+/**
+* Coalesces periodic/config reconciliation requests onto the same serialized
+* lane as instance mutations. A pass never applies a declaration snapshot
+* concurrently with a create/delete/enable write.
+*/
+var TerminalInstanceReconcileCoordinator = class {
+	queue;
+	dirty = false;
+	running = null;
+	constructor(queue) {
+		this.queue = queue;
+	}
+	request(apply) {
+		this.dirty = true;
+		if (this.running) return this.running;
+		const running = this.queue.run(async () => {
+			while (this.dirty) {
+				this.dirty = false;
+				await apply();
+			}
+		});
+		this.running = running.finally(() => {
+			this.running = null;
+		});
+		return this.running;
+	}
+};
+//#endregion
 //#region src/profiles.ts
 /**
 * The allowlist of programs an operator may open. The capability accepts a
@@ -38411,6 +39069,7 @@ var TerminalSessionManager = class {
 	now;
 	resolveBinary;
 	maxSessions;
+	instanceControl = null;
 	constructor(opts) {
 		this.opts = opts;
 		this.profiles = buildProfiles({
@@ -38449,6 +39108,27 @@ var TerminalSessionManager = class {
 			...p.description !== void 0 ? { description: p.description } : {}
 		}));
 	}
+	setInstanceControl(control) {
+		this.instanceControl = control;
+	}
+	async listInstances() {
+		return this.instanceControl?.listInstances() ?? [];
+	}
+	async createInstance(input) {
+		return this.requireInstanceControl().createInstance(input);
+	}
+	async deleteInstance(input) {
+		await this.requireInstanceControl().deleteInstance(input);
+	}
+	async setInstanceEnabled(input) {
+		return this.requireInstanceControl().setInstanceEnabled(input);
+	}
+	async listLegacyCameras() {
+		return this.instanceControl?.listLegacyCameras() ?? [];
+	}
+	async adoptLegacyMonitor(input) {
+		return this.requireInstanceControl().adoptLegacyMonitor(input);
+	}
 	async listSessions() {
 		return [...this.sessions.values()].filter((s) => !s.exited).map((s) => s.info);
 	}
@@ -38496,10 +39176,12 @@ var TerminalSessionManager = class {
 			outputWaiters: /* @__PURE__ */ new Set(),
 			outputChars: 0,
 			nextSeq: 1,
-			exited: false
+			exited: false,
+			disposed: false
 		};
 		this.sessions.set(sessionId, session);
 		pty.onData((data) => {
+			if (session.exited) return;
 			session.screen.write(data);
 			this.appendOutput(session, {
 				kind: "data",
@@ -38513,27 +39195,7 @@ var TerminalSessionManager = class {
 			} catch {}
 		});
 		pty.onExit((event) => {
-			session.exited = true;
-			session.lastExit = event;
-			this.appendOutput(session, {
-				kind: "exit",
-				exitCode: event.exitCode,
-				...event.signal !== void 0 ? { signal: event.signal } : {}
-			});
-			for (const sink of session.sinks) try {
-				sink({
-					kind: "exit",
-					exitCode: event.exitCode,
-					signal: event.signal
-				});
-			} catch {}
-			session.sinks.clear();
-			const retire = setTimeout(() => {
-				session.screen.dispose();
-				this.sessions.delete(sessionId);
-			}, EXITED_RETENTION_MS);
-			retire.unref?.();
-			session.retireTimer = retire;
+			this.finishSession(sessionId, session, event, true);
 		});
 		this.opts.logger.info("terminal: session opened", { meta: {
 			sessionId,
@@ -38564,6 +39226,7 @@ var TerminalSessionManager = class {
 	async close(input) {
 		const session = this.sessions.get(input.sessionId);
 		if (!session) return;
+		this.finishSession(input.sessionId, session, { exitCode: 0 }, false);
 		try {
 			session.pty.kill();
 		} catch {}
@@ -38572,7 +39235,7 @@ var TerminalSessionManager = class {
 	async pullOutput(input) {
 		const session = this.sessions.get(input.sessionId);
 		if (!session) throw new Error(`No such terminal session: ${input.sessionId}`);
-		if (input.afterSeq > 0 && input.afterSeq === session.nextSeq - 1 && !session.exited && (input.waitMs ?? 0) > 0) await new Promise((resolve) => {
+		if ((input.afterSeq > 0 || input.waitForOutput === true) && input.afterSeq === session.nextSeq - 1 && !session.exited && (input.waitMs ?? 0) > 0) await new Promise((resolve) => {
 			const wake = () => {
 				clearTimeout(timer);
 				session.outputWaiters.delete(wake);
@@ -38583,6 +39246,11 @@ var TerminalSessionManager = class {
 			session.outputWaiters.add(wake);
 		});
 		const cursor = session.nextSeq - 1;
+		if (session.disposed) return {
+			cursor,
+			reset: false,
+			events: session.output.filter((event) => event.seq > input.afterSeq)
+		};
 		const oldestSeq = session.output[0]?.seq ?? session.nextSeq;
 		if (input.afterSeq === 0 || input.afterSeq < oldestSeq - 1 || input.afterSeq > cursor) {
 			await session.screen.flush();
@@ -38663,14 +39331,51 @@ var TerminalSessionManager = class {
 	}
 	/** Kill every live session — called on addon shutdown. */
 	disposeAll() {
-		for (const session of this.sessions.values()) {
-			if (session.retireTimer !== void 0) clearTimeout(session.retireTimer);
+		for (const [sessionId, session] of this.sessions) {
+			this.finishSession(sessionId, session, { exitCode: 0 }, false);
 			try {
 				session.pty.kill();
 			} catch {}
-			session.screen.dispose();
 		}
-		this.sessions.clear();
+	}
+	finishSession(sessionId, session, exit, retainForLateExit) {
+		if (session.exited) return;
+		session.exited = true;
+		session.lastExit = exit;
+		this.appendOutput(session, {
+			kind: "exit",
+			exitCode: exit.exitCode,
+			...exit.signal !== void 0 ? { signal: exit.signal } : {}
+		});
+		for (const sink of session.sinks) try {
+			sink({
+				kind: "exit",
+				exitCode: exit.exitCode,
+				...exit.signal !== void 0 ? { signal: exit.signal } : {}
+			});
+		} catch {}
+		session.sinks.clear();
+		if (!retainForLateExit) {
+			this.disposeSession(session);
+			this.sessions.delete(sessionId);
+			return;
+		}
+		const retire = setTimeout(() => {
+			this.disposeSession(session);
+			this.sessions.delete(sessionId);
+		}, EXITED_RETENTION_MS);
+		retire.unref?.();
+		session.retireTimer = retire;
+	}
+	disposeSession(session) {
+		if (session.retireTimer !== void 0) clearTimeout(session.retireTimer);
+		if (session.disposed) return;
+		session.disposed = true;
+		session.screen.dispose();
+	}
+	requireInstanceControl() {
+		if (!this.instanceControl) throw new Error("Terminal instances are managed on the hub");
+		return this.instanceControl;
 	}
 };
 //#endregion
@@ -38688,7 +39393,9 @@ var DEFAULTS = {
 	allowShell: false,
 	shellPath: "",
 	maxSessions: 4,
-	customProfiles: []
+	customProfiles: [],
+	terminalInstances: [],
+	terminalCameraTombstones: []
 };
 var DATA_PLANE_PREFIX = "io";
 var CAMERA_RECONCILE_MS = 6e4;
@@ -38699,6 +39406,11 @@ var TerminalAddon = class extends BaseAddon {
 	cameraRelay = null;
 	cameraReconcileTimer = null;
 	cameraProfilesByNode = /* @__PURE__ */ new Map();
+	/** Prevent repeat writes when a legacy device stays live after migration. */
+	migratedTerminalCameraConfigIds = /* @__PURE__ */ new Set();
+	terminalCameraTombstones = /* @__PURE__ */ new Set();
+	instanceMutationQueue = new TerminalInstanceMutationQueue();
+	terminalReconcileCoordinator = new TerminalInstanceReconcileCoordinator(this.instanceMutationQueue);
 	glancesPythonPath = "";
 	constructor() {
 		super({ ...DEFAULTS });
@@ -38727,18 +39439,22 @@ var TerminalAddon = class extends BaseAddon {
 			customProfiles: this.config.customProfiles
 		});
 		this.manager = manager;
+		this.replaceTerminalCameraTombstones(this.config.terminalCameraTombstones);
 		if (declarationOwnerNodeId(this.ctx.kernel.localNodeId) === "hub") {
+			const localNodeId = declarationOwnerNodeId(this.ctx.kernel.localNodeId);
 			const cameraRelay = new TerminalCameraRelay({
-				listProfiles: (nodeId) => this.ctx.api.terminalSession.listProfiles.query(void 0, nodePin(nodeId)),
-				openSession: (nodeId, input) => this.ctx.api.terminalSession.openSession.mutate(input, nodePin(nodeId)),
-				pullOutput: (nodeId, input) => this.ctx.api.terminalSession.pullOutput.mutate(input, nodePin(nodeId)),
+				listProfiles: (nodeId) => nodeId === localNodeId ? manager.listProfiles() : this.ctx.api.terminalSession.listProfiles.query(void 0, nodePin(nodeId)),
+				openSession: (nodeId, input) => nodeId === localNodeId ? manager.openSession(input) : this.ctx.api.terminalSession.openSession.mutate(input, nodePin(nodeId)),
+				pullOutput: (nodeId, input) => nodeId === localNodeId ? manager.pullOutput(input) : this.ctx.api.terminalSession.pullOutput.mutate(input, nodePin(nodeId)),
 				closeSession: async (nodeId, sessionId) => {
-					await this.ctx.api.terminalSession.close.mutate({ sessionId }, nodePin(nodeId));
+					if (nodeId === localNodeId) await manager.close({ sessionId });
+					else await this.ctx.api.terminalSession.close.mutate({ sessionId }, nodePin(nodeId));
 				}
 			}, this.ctx.logger.child("camera"));
 			await cameraRelay.start();
 			this.cameraRelay = cameraRelay;
 			installTerminalCameraRelay(cameraRelay);
+			manager.setInstanceControl(this.terminalInstanceControl());
 			await this.reconcileTerminalCameras().catch((error) => {
 				this.ctx.logger.warn("initial terminal camera reconciliation failed — will retry", { meta: { error: error instanceof Error ? error.message : String(error) } });
 			});
@@ -38763,6 +39479,7 @@ var TerminalAddon = class extends BaseAddon {
 		}];
 	}
 	async onConfigChanged() {
+		this.replaceTerminalCameraTombstones(this.config.terminalCameraTombstones);
 		this.manager?.reconfigureProfiles({
 			btmPath: this.config.btmPath,
 			btmEnabled: this.config.btmEnabled,
@@ -38779,6 +39496,9 @@ var TerminalAddon = class extends BaseAddon {
 			maxSessions: this.config.maxSessions,
 			customProfiles: this.config.customProfiles
 		});
+		if (this.cameraRelay) this.reconcileTerminalCameras().catch((error) => {
+			this.ctx.logger.warn("terminal camera reconciliation after config change failed", { meta: { error: error instanceof Error ? error.message : String(error) } });
+		});
 	}
 	async onShutdown() {
 		if (this.cameraReconcileTimer) clearInterval(this.cameraReconcileTimer);
@@ -38794,55 +39514,46 @@ var TerminalAddon = class extends BaseAddon {
 		this.manager = null;
 	}
 	async reconcileTerminalCameras() {
+		return this.terminalReconcileCoordinator.request(() => this.applyTerminalCameraReconciliation());
+	}
+	async applyTerminalCameraReconciliation() {
 		if (!this.cameraRelay) return;
+		let terminalIntegrationId;
 		const topology = await this.ctx.api.nodes.topology.query();
 		if (topology.length === 0) throw new Error("cluster topology returned no nodes; refusing to withdraw declared cameras");
 		const nodes = topology.filter((node) => typeof node.id === "string" && node.id.length > 0);
+		const nodeIds = new Set(nodes.map((node) => node.id));
+		for (const cachedNodeId of this.cameraProfilesByNode.keys()) if (!nodeIds.has(cachedNodeId)) this.cameraProfilesByNode.delete(cachedNodeId);
 		const unavailableNodeIds = /* @__PURE__ */ new Set();
 		await Promise.all(nodes.map(async (node) => {
 			try {
 				this.cameraProfilesByNode.set(node.id, await this.cameraRelay.listProfiles(node.id));
 			} catch (error) {
-				if (!this.cameraProfilesByNode.has(node.id)) {
-					unavailableNodeIds.add(node.id);
-					this.ctx.logger.warn("terminal profiles unavailable — preserving existing cameras for this node", { meta: {
-						nodeId: node.id,
-						error: error instanceof Error ? error.message : String(error)
-					} });
-				}
+				unavailableNodeIds.add(node.id);
+				this.ctx.logger.warn("terminal profiles unavailable — keeping Terminal instance cameras offline", { meta: {
+					nodeId: node.id,
+					cachedProfiles: this.cameraProfilesByNode.has(node.id),
+					error: error instanceof Error ? error.message : String(error)
+				} });
 			}
 		}));
-		const cameraDeclarations = [...buildTerminalCameraDeclarations(nodes, this.cameraProfilesByNode)];
-		if (unavailableNodeIds.size > 0) {
-			const existing = await this.ctx.api.deviceManager.listAll.query({ addonId: this.ctx.id });
-			const unavailableNodes = nodes.filter((node) => unavailableNodeIds.has(node.id)).sort((left, right) => right.id.length - left.id.length);
-			for (const row of existing) {
-				const node = unavailableNodes.find((candidate) => {
-					const base = `terminal-camera-${candidate.id}`;
-					return row.stableId === base || row.stableId.startsWith(`${base}-`);
-				});
-				if (!node || cameraDeclarations.some((camera) => camera.stableId === row.stableId)) continue;
-				const base = `terminal-camera-${node.id}`;
-				const profileId = row.stableId === base ? "monitor" : row.stableId.slice(base.length + 1);
-				const profileLabel = profileId === "monitor" ? "BTM" : profileId;
-				cameraDeclarations.push({
-					stableId: row.stableId,
-					name: `Terminal ${profileLabel} - ${node.isHub ? "Hub" : node.name}`,
-					config: {
-						nodeId: node.id,
-						profileId,
-						profileLabel
-					}
-				});
-			}
-		}
+		const cameraDeclarations = buildTerminalInstanceCameraDeclarations(this.terminalInstances());
+		const declarationsByStableId = new Map(cameraDeclarations.map((camera) => [camera.stableId, camera]));
 		const result = await new DeclaredDevices({
 			logger: this.ctx.logger.child("camera-declaration"),
 			addonId: this.ctx.id,
 			devices: this.ctx.kernel.devices,
 			localNodeId: this.ctx.kernel.localNodeId,
-			getIntegration: async (addonId) => this.ctx.api.integrations.getByAddonId.query({ addonId }),
-			createIntegration: async (input) => this.ctx.api.integrations.create.mutate(input),
+			getIntegration: async (addonId) => {
+				const integration = await this.ctx.api.integrations.getByAddonId.query({ addonId });
+				terminalIntegrationId = integration?.id ?? null;
+				return integration;
+			},
+			createIntegration: async (input) => {
+				const integration = await this.ctx.api.integrations.create.mutate(input);
+				terminalIntegrationId = integration.id;
+				return integration;
+			},
 			updateIntegration: async ({ id, info }) => {
 				await this.ctx.api.integrations.update.mutate({
 					id,
@@ -38850,7 +39561,9 @@ var TerminalAddon = class extends BaseAddon {
 					skipRestart: true
 				});
 			},
-			listOwnDevices: async () => this.ctx.api.deviceManager.listAll.query({ addonId: this.ctx.id })
+			listOwnDevices: async () => {
+				return terminalCameraReconciliationIndex(await this.ctx.api.deviceManager.listAll.query({ addonId: this.ctx.id }), terminalIntegrationId, cameraDeclarations, this.terminalCameraTombstones);
+			}
 		}).reconcile({
 			integrationName: TERMINAL_CAMERA_INTEGRATION,
 			placement: "hub",
@@ -38863,12 +39576,142 @@ var TerminalAddon = class extends BaseAddon {
 				role: "terminal-camera"
 			}))
 		});
-		const onlineByNode = new Map(nodes.map((node) => [node.id, node.isOnline]));
+		const onlineByNode = new Map(nodes.map((node) => [node.id, node.isOnline && !unavailableNodeIds.has(node.id)]));
 		for (const outcome of result.devices) if (outcome.device instanceof TerminalCameraDevice) {
+			const declaration = declarationsByStableId.get(outcome.stableId);
+			if (declaration) {
+				const config = outcome.device.config;
+				if (!(config.get("instanceId") === declaration.config.instanceId && config.get("nodeId") === declaration.config.nodeId && config.get("profileId") === declaration.config.profileId && config.get("profileLabel") === declaration.config.profileLabel) || !this.migratedTerminalCameraConfigIds.has(outcome.device.id) && needsTerminalCameraConfigMigration(outcome.device.ctx.persistedConfig ?? {}, declaration)) {
+					await config.setAll(declaration.config);
+					this.migratedTerminalCameraConfigIds.add(outcome.device.id);
+				}
+			}
 			const nodeId = outcome.device.config.get("nodeId");
-			outcome.device.setNodeOnline(onlineByNode.get(nodeId) ?? false);
+			const profileId = outcome.device.config.get("profileId");
+			const profileAvailable = this.cameraProfilesByNode.get(nodeId)?.some((profile) => profile.profileId === profileId) ?? false;
+			outcome.device.setNodeOnline((onlineByNode.get(nodeId) ?? false) && profileAvailable);
 		}
 	}
+	terminalInstanceControl() {
+		return {
+			listInstances: async () => this.terminalInstances().map((instance) => this.instanceInfo(instance)),
+			createInstance: async (input) => this.createTerminalInstance(input),
+			deleteInstance: async ({ instanceId }) => this.deleteTerminalInstance(instanceId),
+			setInstanceEnabled: async ({ instanceId, enabled }) => this.setTerminalInstanceEnabled(instanceId, enabled),
+			listLegacyCameras: async () => this.listLegacyTerminalCameras(),
+			adoptLegacyMonitor: async ({ stableId, name }) => this.adoptLegacyMonitor(stableId, name)
+		};
+	}
+	terminalInstances() {
+		return readTerminalInstances(this.config.terminalInstances, (message) => {
+			this.ctx.logger.warn(message);
+		});
+	}
+	instanceInfo(instance) {
+		return {
+			instanceId: instance.id,
+			cameraStableId: instance.cameraStableId,
+			nodeId: instance.nodeId,
+			profileId: instance.profileId,
+			profileLabel: instance.profileLabel,
+			name: instance.name,
+			enabled: instance.enabled
+		};
+	}
+	replaceTerminalCameraTombstones(stableIds) {
+		this.terminalCameraTombstones.clear();
+		for (const stableId of stableIds) if (typeof stableId === "string" && stableId.length > 0) this.terminalCameraTombstones.add(stableId);
+	}
+	async createTerminalInstance(input) {
+		const instance = await this.instanceMutationQueue.run(() => this.createTerminalInstanceUnlocked(input));
+		await this.reconcileTerminalCameras();
+		return instance;
+	}
+	async createTerminalInstanceUnlocked(input) {
+		const relay = this.cameraRelay;
+		if (!relay) throw new Error("Terminal instances are managed on the hub");
+		const profile = (await relay.listProfiles(input.targetNodeId)).find((candidate) => candidate.profileId === input.profileId);
+		if (!profile) throw new Error(`Terminal profile '${input.profileId}' is not available on ${input.targetNodeId}`);
+		const node = (await this.ctx.api.nodes.topology.query()).find((candidate) => candidate.id === input.targetNodeId);
+		if (!node) throw new Error(`Terminal node '${input.targetNodeId}' no longer exists`);
+		const id = crypto.randomUUID();
+		const name = input.name?.trim() || `Terminal ${profile.label} - ${node.isHub ? "Hub" : node.name}`;
+		const instance = {
+			id,
+			cameraStableId: newTerminalCameraStableId(id),
+			nodeId: input.targetNodeId,
+			profileId: profile.profileId,
+			profileLabel: profile.label,
+			name,
+			enabled: true
+		};
+		await this.updateGlobalSettings({ terminalInstances: [...this.config.terminalInstances, instance] });
+		return this.instanceInfo(instance);
+	}
+	async deleteTerminalInstance(instanceId) {
+		await this.instanceMutationQueue.run(() => this.deleteTerminalInstanceUnlocked(instanceId));
+		await this.reconcileTerminalCameras();
+	}
+	async deleteTerminalInstanceUnlocked(instanceId) {
+		const instance = this.terminalInstances().find((candidate) => candidate.id === instanceId);
+		if (!instance) return;
+		this.terminalCameraTombstones.add(instance.cameraStableId);
+		await this.cameraRelay?.closeInstance(instance.id);
+		await this.updateGlobalSettings({
+			terminalInstances: this.config.terminalInstances.filter((candidate) => candidate.id !== instanceId),
+			terminalCameraTombstones: [...new Set([...this.config.terminalCameraTombstones, instance.cameraStableId])]
+		});
+	}
+	async setTerminalInstanceEnabled(instanceId, enabled) {
+		const instance = await this.instanceMutationQueue.run(() => this.setTerminalInstanceEnabledUnlocked(instanceId, enabled));
+		await this.reconcileTerminalCameras();
+		return instance;
+	}
+	async setTerminalInstanceEnabledUnlocked(instanceId, enabled) {
+		const instance = this.terminalInstances().find((candidate) => candidate.id === instanceId);
+		if (!instance) throw new Error(`No such Terminal instance: ${instanceId}`);
+		if (!enabled) {
+			this.terminalCameraTombstones.add(instance.cameraStableId);
+			await this.cameraRelay?.closeInstance(instance.id);
+		}
+		const updated = {
+			...instance,
+			enabled
+		};
+		const terminalInstances = this.config.terminalInstances.map((candidate) => candidate.id === instanceId ? updated : candidate);
+		const terminalCameraTombstones = enabled ? this.config.terminalCameraTombstones.filter((stableId) => stableId !== instance.cameraStableId) : [...new Set([...this.config.terminalCameraTombstones, instance.cameraStableId])];
+		await this.updateGlobalSettings({
+			terminalInstances,
+			terminalCameraTombstones
+		});
+		return this.instanceInfo(updated);
+	}
+	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);
+	}
+	async adoptLegacyMonitor(stableId, requestedName) {
+		const instance = await this.instanceMutationQueue.run(() => this.adoptLegacyMonitorUnlocked(stableId, requestedName));
+		await this.reconcileTerminalCameras();
+		return instance;
+	}
+	async adoptLegacyMonitorUnlocked(stableId, requestedName) {
+		if (this.terminalCameraTombstones.has(stableId)) throw new Error("This legacy Terminal camera was deleted and cannot be adopted");
+		const legacy = (await this.listLegacyTerminalCameras()).find((camera) => camera.stableId === stableId);
+		if (!legacy?.adoptable) throw new Error("Only a legacy monitor camera with its original stable id can be adopted");
+		const instance = {
+			id: crypto.randomUUID(),
+			cameraStableId: legacy.stableId,
+			nodeId: legacy.nodeId,
+			profileId: "monitor",
+			profileLabel: legacy.profileLabel,
+			name: requestedName?.trim() || legacy.name,
+			enabled: true
+		};
+		await this.updateGlobalSettings({ terminalInstances: [...this.config.terminalInstances, instance] });
+		return this.instanceInfo(instance);
+	}
 	globalSettingsSchema() {
 		return this.schema({ sections: [{
 			id: "terminal",
@@ -38979,7 +39822,7 @@ var TerminalAddon = class extends BaseAddon {
 		}, {
 			id: "terminal-profiles",
 			title: "Custom profiles",
-			description: "Each enabled profile creates its own Terminal camera on this node and is available from the Terminal page. Session requests only carry the profile ID; commands cannot be overridden by clients.",
+			description: "Enabled profiles are available templates on this node. Create a Terminal instance on the Terminal page to declare a camera; session requests only carry the profile ID and commands cannot be overridden by clients.",
 			columns: 1,
 			fields: [this.field({
 				type: "editable-array",