@camstack/addon-provider-homeassistant 1.2.658 → 1.2.659

package/dist/ha-export/ha-export.addon.js

@@ -5239,6 +5239,246 @@ async function planDropPerBrokerFlags(ports) {
 	}] };
 }
 //#endregion
+//#region src/ha-export/target-records.ts
+/**
+* An export target (#422): one `ha-export-targets` record per place the export reaches. It names
+* the Home Assistant connection it pushes to (`connectionId`, a broker id), which hub address
+* role its image links use, how often it re-announces, and the devices exported to it.
+*
+* The record is the integration instance itself (`integration-instances`, role `services`): the
+* operator creates, edits, switches and deletes targets from the Connectivity page, and the ids
+* are minted here (`hae_001`, ...). Several targets may reference one connection.
+*
+* This addon is the only writer of `devices`; the instance door writes the rest. Both go through
+* `patch` (a merge), so neither overwrites the other, and the in-memory copy here is the
+* synchronous read the event path needs, reloaded after every change.
+*/
+var HA_EXPORT_TARGETS_KIND_NAME = "ha-export-targets";
+var HA_TARGET_KIND = "ha-target";
+var TARGET_ID_PREFIX = "hae_";
+/** The schema is checked against the interface by its annotation: a drifted field fails the typecheck. */
+var HaExportTargetBodySchema = require_ha_instance_settings.object({
+	name: require_ha_instance_settings.string().min(1),
+	connectionId: require_ha_instance_settings.string(),
+	mediaRole: require_ha_instance_settings._enum(HA_MEDIA_ROLES),
+	reconcileIntervalSec: require_ha_instance_settings.number(),
+	devices: require_ha_instance_settings.array(require_ha_instance_settings.string()),
+	enabled: require_ha_instance_settings.boolean().optional()
+});
+var haExportTargetsKind = require_ha_instance_settings.defineEntryKind(HA_EXPORT_TARGETS_KIND_NAME, {
+	title: "Home Assistant export targets",
+	nameField: "name",
+	schema: HaExportTargetBodySchema,
+	writeTrigger: "an operator adds, edits, switches or deletes an export target, or exports a device to it"
+});
+/** What a target starts as: on, public endpoint, five-minute cadence, no device, no connection yet. */
+function newTargetBody(name) {
+	return {
+		name,
+		connectionId: "",
+		mediaRole: "publicEndpoint",
+		reconcileIntervalSec: 300,
+		devices: [],
+		enabled: true
+	};
+}
+/** The id after the highest `hae_NNN` among `existing`. */
+function nextTargetId(existing) {
+	let highest = 0;
+	for (const id of existing) {
+		if (!id.startsWith("hae_")) continue;
+		const n = Number(id.slice(4));
+		if (Number.isInteger(n) && n > highest) highest = n;
+	}
+	return `${TARGET_ID_PREFIX}${String(highest + 1).padStart(3, "0")}`;
+}
+/** Every record of the kind, once; a failed read throws (the caller must not serve "nothing"). */
+async function readAllTargets(handle) {
+	const rows = /* @__PURE__ */ new Map();
+	let cursor;
+	do {
+		const page = await handle.query({
+			limit: 1e3,
+			...cursor === void 0 ? {} : { cursor }
+		});
+		for (const row of page.records) rows.set(row.id, row.data);
+		cursor = page.nextCursor ?? void 0;
+	} while (cursor !== void 0);
+	return rows;
+}
+function membershipOf$1(rows) {
+	const out = {};
+	for (const [id, row] of rows) if (row.devices.length > 0) out[id] = row.devices;
+	return out;
+}
+function sameList(a, b) {
+	return a.length === b.length && a.every((value, index) => value === b[index]);
+}
+/**
+* The in-memory copy of the target records. `membership()` keeps its identity until a device
+* list changes.
+*/
+var ExportTargets = class ExportTargets {
+	handle;
+	rows;
+	memberships;
+	constructor(handle, rows) {
+		this.handle = handle;
+		this.rows = rows;
+		this.memberships = membershipOf$1(rows);
+	}
+	/** A failed read throws: serving an empty set would unexport every device on the next pass. */
+	static async load(handle) {
+		return new ExportTargets(handle, await readAllTargets(handle));
+	}
+	/** Re-read the records after the instance door changed one; a failed read keeps the old copy. */
+	async reload() {
+		this.adopt(await readAllTargets(this.handle));
+	}
+	ids() {
+		return [...this.rows.keys()];
+	}
+	has(id) {
+		return this.rows.has(id);
+	}
+	get(id) {
+		return this.rows.get(id);
+	}
+	name(id) {
+		return this.rows.get(id)?.name ?? id;
+	}
+	/** The target's own switch; an absent field means on. */
+	isEnabled(id) {
+		const row = this.rows.get(id);
+		return row !== void 0 && row.enabled !== false;
+	}
+	connectionId(id) {
+		return this.rows.get(id)?.connectionId ?? "";
+	}
+	mediaRole(id) {
+		return this.rows.get(id)?.mediaRole ?? "publicEndpoint";
+	}
+	/** The cadence of the quickest enabled target (the addon runs one timer); the default when none. */
+	reconcileIntervalSec() {
+		const seconds = [...this.rows.values()].filter((row) => row.enabled !== false).map((row) => row.reconcileIntervalSec);
+		if (seconds.length === 0) return 300;
+		return Math.max(30, Math.min(...seconds));
+	}
+	/** targetId → exported device ids, for the targets that export at least one. */
+	membership() {
+		return this.memberships;
+	}
+	/**
+	* Persist the device lists that differ from the held ones. A target that does not exist is
+	* never created here (an id the records do not hold is refused by the caller).
+	*/
+	async setMembership(next) {
+		let rows = this.rows;
+		for (const id of new Set([...Object.keys(next), ...Object.keys(this.memberships)])) {
+			const current = rows.get(id);
+			if (current === void 0) continue;
+			const devices = next[id] ?? [];
+			if (sameList(current.devices, devices)) continue;
+			await this.handle.patch(id, { devices: [...devices] });
+			rows = new Map(rows).set(id, {
+				...current,
+				devices: [...devices]
+			});
+			this.adopt(rows);
+		}
+	}
+	adopt(rows) {
+		const devicesChanged = [...new Set([...rows.keys(), ...this.rows.keys()])].some((id) => !sameList(rows.get(id)?.devices ?? [], this.rows.get(id)?.devices ?? []));
+		this.rows = rows;
+		if (devicesChanged) this.memberships = membershipOf$1(rows);
+	}
+};
+//#endregion
+//#region src/ha-export/migrations/targets-from-links.ts
+var RECONCILE_INTERVAL_KEY = "reconcileIntervalSec";
+var KNOWN_BROKERS_KEY = "knownBrokers";
+var sameDevices$1 = (a, b) => a.length === b.length && a.every((device, index) => device === b[index]);
+function intervalOf(stored) {
+	const value = stored[RECONCILE_INTERVAL_KEY];
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 300;
+}
+function matches(target, expected) {
+	return target.name === expected.name && target.connectionId === expected.connectionId && target.mediaRole === expected.mediaRole && target.reconcileIntervalSec === expected.reconcileIntervalSec && target.enabled === expected.enabled && sameDevices$1(target.devices, expected.devices);
+}
+async function moveLinksToTargets(ports) {
+	const links = await ports.readLinks();
+	if (links.size === 0) return {
+		outcome: "already-done",
+		summary: { moved: 0 }
+	};
+	const targets = await ports.readTargets();
+	const reconcileIntervalSec = intervalOf(await ports.readStored());
+	const taken = new Set([...targets.values()].map((target) => target.connectionId));
+	const ids = new Set(targets.keys());
+	const created = /* @__PURE__ */ new Map();
+	for (const brokerId of [...links.keys()].sort()) {
+		if (taken.has(brokerId)) continue;
+		const link = links.get(brokerId);
+		if (link === void 0) continue;
+		const body = {
+			name: link.name,
+			connectionId: brokerId,
+			mediaRole: link.mediaRole,
+			reconcileIntervalSec,
+			devices: [...link.devices],
+			enabled: link.exportTo
+		};
+		const id = nextTargetId(ids);
+		if (await ports.putTarget(id, body) === "exists") throw new Error(`the export target id ${id} is already taken; nothing was cleared`);
+		ids.add(id);
+		created.set(id, body);
+	}
+	if (created.size === 0) return {
+		outcome: "already-done",
+		summary: { moved: 0 }
+	};
+	const held = await ports.readTargets();
+	for (const [id, expected] of created) {
+		const row = held.get(id);
+		if (row === void 0 || !matches(row, expected)) throw new Error(`the export target ${id} of connection ${expected.connectionId} does not match its link record; nothing was cleared`);
+	}
+	return {
+		outcome: "done",
+		summary: {
+			moved: created.size,
+			devices: [...created.values()].reduce((sum, target) => sum + target.devices.length, 0)
+		}
+	};
+}
+async function dropLinksAndCache(ports) {
+	const links = await ports.readLinks();
+	const stored = await ports.readStored();
+	const targets = await ports.readTargets();
+	const movable = [];
+	const parked = [];
+	for (const [brokerId, link] of links) {
+		const target = [...targets.values()].find((candidate) => candidate.connectionId === brokerId);
+		if (target !== void 0 && sameDevices$1(target.devices, link.devices)) movable.push(brokerId);
+		else parked.push(brokerId);
+	}
+	if (parked.length > 0) ports.warn(`homeassistant-export: the link records of ${parked.join(", ")} are kept: no export target holds the same devices`);
+	if (movable.length > 0) await ports.deleteLinks(movable);
+	const keys = parked.length > 0 ? [] : [RECONCILE_INTERVAL_KEY, KNOWN_BROKERS_KEY].filter((key) => key in stored);
+	if (keys.length > 0) await ports.clearSettingKeys(keys);
+	if (movable.length === 0 && keys.length === 0) return {
+		outcome: "already-done",
+		summary: { parked: parked.length }
+	};
+	return {
+		outcome: "done",
+		summary: {
+			deleted: movable.length,
+			parked: parked.length,
+			keys: keys.length
+		}
+	};
+}
+//#endregion
 //#region src/ha-export/migrations/links-to-record.ts
 /**
 * What the export carries to a Home Assistant instance moves into the instance's
@@ -5263,7 +5503,7 @@ var MEMBERSHIP_KEY = "membership";
 var EXPORT_PREFIX = "exportTo:";
 var ROLE_PREFIX = "mediaRole:";
 var roleOf = (value) => HA_MEDIA_ROLES.find((role) => role === value);
-function membershipOf$1(value) {
+function membershipOf(value) {
 	const out = /* @__PURE__ */ new Map();
 	if (typeof value !== "object" || value === null || Array.isArray(value)) return out;
 	for (const [brokerId, devices] of Object.entries(value)) {
@@ -5286,7 +5526,7 @@ function integrationByBroker(rows, warn) {
 }
 /** Every broker the old shape has something for, with the value the old reader would have used. */
 function legacyLinks(stored, rows, warn) {
-	const membership = membershipOf$1(stored[MEMBERSHIP_KEY]);
+	const membership = membershipOf(stored[MEMBERSHIP_KEY]);
 	const unreadable = rows.find((row) => Object.keys(row.settings).length === 0);
 	if (unreadable !== void 0 && membership.size > 0) throw new Error(`the settings of integration ${unreadable.integrationId} read as empty; the export switch cannot be carried from an unreadable source, nothing was written`);
 	const integrations = integrationByBroker(rows, warn);
@@ -5374,6 +5614,8 @@ async function planDropMovedLinks(ports) {
 //#endregion
 //#region src/ha-export/migrations/index.ts
 var LINKS_TO_RECORD_ID = "homeassistant-export/2026-11-04-links-to-record";
+var DROP_MOVED_LINKS_ID = "homeassistant-export/2026-11-04-drop-moved-links";
+var TARGETS_FROM_LINKS_ID = "homeassistant-export/2026-11-04-targets-from-links";
 /** The `homeassistant-export` catalogue (D987): offered to the engine when the addon initialises. */
 var ADDON_MIGRATIONS = [
 	{
@@ -5442,7 +5684,7 @@ var ADDON_MIGRATIONS = [
 	},
 	{
 		meta: {
-			id: "homeassistant-export/2026-11-04-drop-moved-links",
+			id: DROP_MOVED_LINKS_ID,
 			owner: "homeassistant-export",
 			level: "addon-state",
 			seq: 5,
@@ -5455,19 +5697,47 @@ var ADDON_MIGRATIONS = [
 			fixtureMark: "the reconcile interval the migration does not know"
 		},
 		plan: planDropMovedLinks
+	},
+	{
+		meta: {
+			id: TARGETS_FROM_LINKS_ID,
+			owner: "homeassistant-export",
+			level: "addon-state",
+			seq: 6,
+			dependsOn: [LINKS_TO_RECORD_ID],
+			store: "settings",
+			scope: "cluster",
+			onFailure: "block-owner",
+			bodyKind: "procedure",
+			description: "Turn each ha-export-links record into an export target under a minted id that names its Home Assistant connection, carrying the switch, media role, devices and reconcile interval; read back before anything is deleted",
+			fixtureMark: "the exported entities the migration does not touch"
+		},
+		procedure: moveLinksToTargets
+	},
+	{
+		meta: {
+			id: "homeassistant-export/2026-11-04-drop-links-and-cache",
+			owner: "homeassistant-export",
+			level: "addon-state",
+			seq: 7,
+			dependsOn: [TARGETS_FROM_LINKS_ID],
+			store: "settings",
+			scope: "cluster",
+			onFailure: "block-owner",
+			bodyKind: "procedure",
+			description: "Delete each ha-export-links record whose target holds the same devices, then the reconcileIntervalSec and knownBrokers settings",
+			fixtureMark: "the exported entities the migration does not touch"
+		},
+		procedure: dropLinksAndCache
 	}
 ];
 //#endregion
-//#region src/ha-export/link-records.ts
+//#region src/ha-export/migrations/legacy-links-kind.ts
 /**
-* What the export carries to one Home Assistant instance (planning#408 P4): an `ha-export-links`
-* record per instance, under the id of the Home Assistant broker it belongs to. It holds the
-* three facts of the link: whether the export reaches the instance, which hub address role its
-* image links use, and the devices exported to it.
-*
-* It replaces the `membership` setting, the `exportTo:<brokerId>` / `mediaRole:<brokerId>` keys
-* and the `exportTo` / `mediaRole` values of the instance's integration. The migration moved
-* them; the addon reads this record and nothing else.
+* The `ha-export-links` record kind (planning#408 P4): one record per Home Assistant broker with
+* its export switch, media role and devices. Export targets (`ha-export-targets`) replaced it;
+* the kind is declared ONLY so the migrations can read it and delete its rows. No runtime code
+* outside `migrations/` names it (`no-legacy-links-reader.spec.ts`).
 */
 var HA_EXPORT_LINKS_KIND_NAME = "ha-export-links";
 var HaExportLinksBodySchema = require_ha_instance_settings.object({
@@ -5477,19 +5747,15 @@ var HaExportLinksBodySchema = require_ha_instance_settings.object({
 	devices: require_ha_instance_settings.array(require_ha_instance_settings.string())
 });
 var haExportLinksKind = require_ha_instance_settings.defineEntryKind(HA_EXPORT_LINKS_KIND_NAME, {
-	title: "Home Assistant export links",
+	title: "Home Assistant export links (retired)",
 	nameField: "name",
 	schema: HaExportLinksBodySchema,
-	writeTrigger: "an operator switches the export of a Home Assistant instance, picks its image-link address, or exports a device to it"
+	writeTrigger: "only the migrations that move the links into export targets write it"
 });
-/** A link the operator has not touched: off, on the public endpoint, no device. */
-function defaultLinks(name) {
-	return {
-		name,
-		exportTo: false,
-		mediaRole: "publicEndpoint",
-		devices: []
-	};
+/** Declare the retired kind and hand back its handle, for the migration ports. */
+async function declareLegacyLinks(records) {
+	await records.declare({ [HA_EXPORT_LINKS_KIND_NAME]: haExportLinksKind });
+	return records.kind(haExportLinksKind);
 }
 /** Every record of the kind, once; a failed read throws (the caller must not serve "nothing"). */
 async function readAllLinks(handle) {
@@ -5505,123 +5771,12 @@ async function readAllLinks(handle) {
 	} while (cursor !== void 0);
 	return rows;
 }
-function membershipOf(rows) {
-	const out = {};
-	for (const [brokerId, row] of rows) if (row.devices.length > 0) out[brokerId] = row.devices;
-	return out;
-}
-/**
-* The in-memory copy of the records. This addon is their only writer, so the copy is the
-* synchronous read the event path needs; a write lands in the record first and in the copy
-* after it. `membership()` keeps its identity until a device list changes.
-*/
-var ExportLinks = class ExportLinks {
-	handle;
-	rows;
-	memberships;
-	constructor(handle, rows) {
-		this.handle = handle;
-		this.rows = rows;
-		this.memberships = membershipOf(rows);
-	}
-	static async load(handle) {
-		return new ExportLinks(handle, await readAllLinks(handle));
-	}
-	isEnabled(brokerId) {
-		return this.rows.get(brokerId)?.exportTo === true;
-	}
-	mediaRole(brokerId) {
-		return this.rows.get(brokerId)?.mediaRole ?? "publicEndpoint";
-	}
-	/** brokerId → exported device ids, for the brokers that export at least one. */
-	membership() {
-		return this.memberships;
-	}
-	brokerIds() {
-		return [...this.rows.keys()];
-	}
-	/** Change the switch and / or the role of one instance; creates the record on first use. */
-	async setFlags(brokerId, name, patch) {
-		const current = this.rows.get(brokerId) ?? defaultLinks(name);
-		const next = {
-			...current,
-			exportTo: patch.exportTo ?? current.exportTo,
-			mediaRole: patch.mediaRole ?? current.mediaRole
-		};
-		if (this.rows.has(brokerId) && sameLinks(current, next)) return;
-		await this.write(brokerId, next);
-	}
-	/** Persist the device lists that differ from the held ones; returns nothing to do as a no-op. */
-	async setMembership(next, nameOf) {
-		for (const brokerId of new Set([...Object.keys(next), ...Object.keys(this.memberships)])) {
-			const devices = next[brokerId] ?? [];
-			const current = this.rows.get(brokerId);
-			if (sameList(current?.devices ?? [], devices)) continue;
-			await this.write(brokerId, {
-				...current ?? defaultLinks(nameOf(brokerId)),
-				devices: [...devices]
-			});
-		}
-	}
-	/** Forget the instances that no longer exist; returns the ids it removed. */
-	async prune(knownBrokerIds) {
-		const known = new Set(knownBrokerIds);
-		const gone = [...this.rows.keys()].filter((id) => !known.has(id));
-		for (const id of gone) await this.handle.delete(id);
-		if (gone.length > 0) this.adopt(new Map([...this.rows].filter(([id]) => known.has(id))));
-		return gone;
-	}
-	async write(brokerId, body) {
-		await this.handle.put({
-			id: brokerId,
-			data: body
-		});
-		this.adopt(new Map(this.rows).set(brokerId, body));
-	}
-	adopt(rows) {
-		const devicesChanged = [...new Set([...rows.keys(), ...this.rows.keys()])].some((id) => !sameList(rows.get(id)?.devices ?? [], this.rows.get(id)?.devices ?? []));
-		this.rows = rows;
-		if (devicesChanged) this.memberships = membershipOf(rows);
-	}
-};
-function sameList(a, b) {
-	return a.length === b.length && a.every((value, index) => value === b[index]);
-}
-function sameLinks(a, b) {
-	return a.exportTo === b.exportTo && a.mediaRole === b.mediaRole && sameList(a.devices, b.devices);
-}
-/**
-* The settings form names an instance's two facts as the dynamic keys `exportTo:<brokerId>` and
-* `mediaRole:<brokerId>`. They are form fields, not stored keys: a read overlays them from the
-* records and a write is routed to the record of the broker they name.
-*/
-var exportToFormKey = (brokerId) => `exportTo:${brokerId}`;
-var mediaRoleFormKey = (brokerId) => `mediaRole:${brokerId}`;
-function parseLinkFormKey(key) {
-	for (const flag of ["exportTo", "mediaRole"]) {
-		const prefix = `${flag}:`;
-		if (key.startsWith(prefix) && key.length > prefix.length) return {
-			flag,
-			brokerId: key.slice(prefix.length)
-		};
-	}
-	return null;
-}
-/** The form's dynamic keys carrying each instance's own value. */
-function linkFormOverlay(links) {
-	const overlay = {};
-	for (const brokerId of links.brokerIds()) {
-		overlay[exportToFormKey(brokerId)] = links.isEnabled(brokerId);
-		overlay[mediaRoleFormKey(brokerId)] = links.mediaRole(brokerId);
-	}
-	return overlay;
-}
 //#endregion
 //#region src/ha-export/migrations/bind-ports.ts
 /**
 * Binds the `homeassistant-export` catalogue to the addon's stores: the settings, the hub's
-* `integrations` capability (the old home of the two flags, read by the migrations only) and the
-* `ha-export-links` kind.
+* `integrations` capability (the old home of the two flags, read by the migrations only), the
+* retired `ha-export-links` kind and the `ha-export-targets` kind the links move into.
 */
 function haExportMigrationPorts(deps) {
 	return {
@@ -5641,10 +5796,118 @@ function haExportMigrationPorts(deps) {
 			}
 			return "created";
 		},
-		readLinks: () => readAllLinks(deps.links)
+		readLinks: () => readAllLinks(deps.links),
+		readTargets: () => readAllTargets(deps.targets),
+		putTarget: async (id, body) => {
+			try {
+				await deps.targets.put({
+					id,
+					data: body
+				}, { ifRev: 0 });
+			} catch (err) {
+				if (err instanceof require_ha_instance_settings.RevConflictError) return "exists";
+				throw err;
+			}
+			return "created";
+		},
+		deleteLinks: async (brokerIds) => {
+			await deps.links.deleteMany(brokerIds);
+		},
+		clearSettingKeys: deps.clearSettingKeys
 	};
 }
 //#endregion
+//#region src/ha-export/target-form.ts
+var NS = "provider-homeassistant:globalSettings";
+function buildTargetForm() {
+	return { sections: [{
+		id: "ha-export-target",
+		title: "Home Assistant target",
+		titleKey: `${NS}.s_ha-export-target.title`,
+		description: "Where the export pushes devices. A target with no existing connection pushes nothing and keeps its devices. Export needs the CamStack custom component installed in Home Assistant (HACS).",
+		descriptionKey: `${NS}.s_ha-export-target.description`,
+		columns: 1,
+		fields: [
+			{
+				type: "text",
+				key: "name",
+				label: "Name",
+				labelKey: `${NS}.s_ha-export-target.name.label`
+			},
+			{
+				type: "broker-select",
+				key: "connectionId",
+				label: "Home Assistant connection",
+				labelKey: `${NS}.s_ha-export-target.connectionId.label`,
+				description: "The Home Assistant instance this target pushes to.",
+				descriptionKey: `${NS}.s_ha-export-target.connectionId.description`,
+				brokerKind: "home-assistant"
+			},
+			{
+				type: "select",
+				key: "mediaRole",
+				label: "Image links",
+				labelKey: `${NS}.s_ha-export-target.mediaRole.label`,
+				description: "The hub address this Home Assistant fetches image links from. Public endpoint is the default, so notifications show images away from home; when none is set the internal address is used.",
+				descriptionKey: `${NS}.s_ha-export-target.mediaRole.description`,
+				options: [{
+					value: "internal",
+					label: "Internal (LAN address)"
+				}, {
+					value: "publicEndpoint",
+					label: "Public endpoint (reachable from outside)"
+				}],
+				default: "publicEndpoint"
+			}
+		]
+	}, {
+		id: "ha-export-advanced",
+		title: "Advanced",
+		titleKey: `${NS}.s_ha-export-advanced.title`,
+		style: "accordion",
+		defaultCollapsed: true,
+		columns: 1,
+		fields: [{
+			type: "number",
+			key: "reconcileIntervalSec",
+			label: "Reconcile interval (s)",
+			labelKey: `${NS}.s_ha-export-advanced.reconcileIntervalSec.label`,
+			description: `Full re-announce and re-push cadence; at least 30 s.`,
+			descriptionKey: `${NS}.s_ha-export-advanced.reconcileIntervalSec.description`,
+			default: 300
+		}]
+	}] };
+}
+//#endregion
+//#region src/ha-export/target-instances.ts
+/**
+* The export targets as `integration-instances` (role `services`, D996): the operator adds,
+* edits, switches and deletes targets from the Connectivity page. A target's id is MINTED
+* (`hae_001`, ...) and names its Home Assistant connection as a reference, so several targets
+* may push to one Home Assistant.
+*/
+function openTargetInstances(records, deps) {
+	return new require_ha_instance_settings.RecordIntegrationInstances(records, haExportTargetsKind, {
+		description: {
+			role: "services",
+			instanceMode: "multiple",
+			kind: "target",
+			canTest: false,
+			kinds: [{
+				id: HA_TARGET_KIND,
+				label: "Home Assistant"
+			}]
+		},
+		formSchema: () => buildTargetForm(),
+		initialBody: (name) => newTargetBody(name),
+		mintId: () => nextTargetId(deps.book().ids()),
+		kindOf: () => HA_TARGET_KIND,
+		health: (body, id) => ({ status: deps.health(id, body) }),
+		configured: (body) => deps.connectionExists(body.connectionId),
+		onChanged: deps.onChanged
+	});
+}
+//#endregion
 //#region src/ha-export/membership.ts
 function devicesForBroker(membership, brokerId) {
 	return membership[brokerId] ?? [];
@@ -5671,14 +5934,6 @@ function setExposed(membership, brokerId, deviceId, exposed) {
 		[brokerId]: next
 	};
 }
-/** Same brokers, same order, same names — nothing for the form to re-render. */
-function sameBrokers(a, b) {
-	if (a.length !== b.length) return false;
-	return a.every((broker, index) => {
-		const other = b[index];
-		return other !== void 0 && other.id === broker.id && other.name === broker.name;
-	});
-}
 //#endregion
 //#region src/ha-export/node-reads.ts
 var UNREAD = {
@@ -7732,16 +7987,15 @@ var PTZ_MOVE_BY_DIRECTION = {
 	zoom_in: { zoom: .1 },
 	zoom_out: { zoom: -.1 }
 };
-var DEFAULT_CONFIG = {
-	reconcileIntervalSec: 300,
-	knownBrokers: [],
-	exportedEntities: {
-		actions: [],
-		targets: []
-	}
-};
+var DEFAULT_CONFIG = { exportedEntities: {
+	actions: [],
+	targets: []
+} };
 var HaExportAddon = class extends require_ha_instance_settings.BaseAddon {
 	links = /* @__PURE__ */ new Map();
+	instances = null;
+	/** The Home Assistant connections (broker ids) the last `broker.list` answered. */
+	connections = /* @__PURE__ */ new Set();
 	/** deviceKey → the device it addresses. Rebuilt on every reconcile. */
 	exported = /* @__PURE__ */ new Map();
 	/** numeric deviceId → deviceKey, for the event path. */
@@ -7848,15 +8102,26 @@ var HaExportAddon = class extends require_ha_instance_settings.BaseAddon {
 	async onInitialize() {
 		const records = this.ctx.records;
 		if (records === void 0) throw new Error("ha-export: records are not available");
-		await records.declare({ "ha-export-links": haExportLinksKind });
-		const linksHandle = records.kind(haExportLinksKind);
+		await records.declare({ "ha-export-targets": haExportTargetsKind });
+		const targetsHandle = records.kind(haExportTargetsKind);
+		const legacyLinks = await declareLegacyLinks(records);
 		await this.runMigrations(require_ha_instance_settings.defineAddonMigrations(ADDON_MIGRATIONS, haExportMigrationPorts({
 			readStored: async () => this.resolveGlobalStore(),
 			api: this.ctx.api,
-			links: linksHandle,
+			links: legacyLinks,
+			targets: targetsHandle,
+			clearSettingKeys: async (keys) => {
+				await this.updateGlobalSettingsAsOperator(Object.fromEntries(keys.map((key) => [key, null])));
+			},
 			warn: (message) => this.ctx.logger.warn(message)
 		})));
-		this.linkBook = await ExportLinks.load(linksHandle);
+		this.targetBook = await ExportTargets.load(targetsHandle);
+		this.instances = openTargetInstances(records, {
+			book: () => this.book(),
+			connectionExists: (connectionId) => this.connectionExists(connectionId),
+			health: (id, body) => this.targetHealth(id, body),
+			onChanged: (id, change) => this.onTargetChanged(id, change)
+		});
 		const secret = this.state("haExportMediaSecret", require_ha_instance_settings.string(), "");
 		const existing = await secret.get();
 		if (existing.length === 0) {
@@ -7892,27 +8157,27 @@ var HaExportAddon = class extends require_ha_instance_settings.BaseAddon {
 			{
 				capability: require_ha_instance_settings.deviceExportCapability,
 				provider: {
-					getStatus: async (input) => this.buildStatus(this.brokerScope(require_ha_instance_settings.statusInstanceOf(input))),
-					listInstances: async () => this.config.knownBrokers.map((broker) => ({
-						instanceId: broker.id,
-						name: broker.name,
-						enabled: this.enabledBrokerIds().includes(broker.id),
-						kind: "home-assistant"
+					getStatus: async (input) => this.buildStatus(this.targetScope(require_ha_instance_settings.statusInstanceOf(input))),
+					listInstances: async () => this.book().ids().map((id) => ({
+						instanceId: id,
+						name: this.book().name(id),
+						enabled: this.book().isEnabled(id),
+						kind: HA_TARGET_KIND
 					})),
 					listSupportedDeviceKinds: async ({ instanceId }) => {
-						this.brokerScope(instanceId);
+						this.targetScope(instanceId);
 						return [...SUPPORTED_DEVICE_KINDS];
 					},
-					listExposedDevices: async ({ instanceId }) => this.exposedDeviceRows(this.brokerScope(instanceId)),
-					exposeDevice: async ({ instanceId, deviceId }) => this.setBrokerMembership(instanceId, deviceId, true),
-					unexposeDevice: async ({ instanceId, deviceId }) => this.setBrokerMembership(instanceId, deviceId, false),
+					listExposedDevices: async ({ instanceId }) => this.exposedDeviceRows(this.targetScope(instanceId)),
+					exposeDevice: async ({ instanceId, deviceId }) => this.setTargetMembership(instanceId, deviceId, true),
+					unexposeDevice: async ({ instanceId, deviceId }) => this.setTargetMembership(instanceId, deviceId, false),
 					listSupportedEntityKinds: async () => [
 						"device",
 						"action",
 						"notifier"
 					],
 					listExposedEntities: async ({ instanceId }) => {
-						const scope = this.brokerScope(instanceId);
+						const scope = this.targetScope(instanceId);
 						await exportedEntities.pruneDeleted();
 						return [...this.exposedDeviceRows(scope).map((row) => ({
 							entity: {
@@ -7923,13 +8188,13 @@ var HaExportAddon = class extends require_ha_instance_settings.BaseAddon {
 						})), ...exportedEntities.list()];
 					},
 					exposeEntity: async ({ instanceId, entity }) => {
-						if (entity.kind === "device") return this.setBrokerMembership(instanceId, entity.deviceId, true);
-						this.brokerScope(instanceId);
+						if (entity.kind === "device") return this.setTargetMembership(instanceId, entity.deviceId, true);
+						this.targetScope(instanceId);
 						return exportedEntities.expose(entity);
 					},
 					unexposeEntity: async ({ instanceId, entity }) => {
-						if (entity.kind === "device") return this.setBrokerMembership(instanceId, entity.deviceId, false);
-						this.brokerScope(instanceId);
+						if (entity.kind === "device") return this.setTargetMembership(instanceId, entity.deviceId, false);
+						this.targetScope(instanceId);
 						return exportedEntities.unexpose(entity);
 					},
 					getDeviceSettingsContribution: async ({ deviceId }) => this.buildContribution(deviceId),
@@ -7937,6 +8202,10 @@ var HaExportAddon = class extends require_ha_instance_settings.BaseAddon {
 					applyDeviceSettingsPatch: async ({ deviceId, patch }) => this.applyDeviceSettingsPatch(deviceId, patch)
 				}
 			},
+			{
+				capability: require_ha_instance_settings.integrationInstancesCapability,
+				provider: this.requireInstances().toProvider()
+			},
 			{
 				capability: require_ha_instance_settings.addonRoutesCapability,
 				provider: require_ha_instance_settings.buildAddonRouteProvider(ADDON_ID, [{
@@ -7955,53 +8224,28 @@ var HaExportAddon = class extends require_ha_instance_settings.BaseAddon {
 			}
 		];
 	}
-	/**
-	* The form of the addon shows each instance's own switch and media role. They are not settings
-	* of this addon: the values come from the instance's `ha-export-links` record.
-	*/
-	async getGlobalSettings(overlay, cap, nodeId) {
-		return super.getGlobalSettings({
-			...overlay,
-			...linkFormOverlay(this.book())
-		}, cap, nodeId);
+	async onConfigChanged() {
+		if (this.targetBook === null) return;
+		for (const link of this.links.values()) link.client.resetBackoff();
+		await this.reconcile("config-changed");
+		this.startTimer();
 	}
 	/**
-	* An operator write: the `exportTo:` / `mediaRole:` keys go to the record of their broker,
-	* everything else to the addon store as before. A key naming a broker this addon does not know
-	* is refused, never parked.
+	* A target was created, edited, switched or deleted through `integration-instances`: reload
+	* the records, then apply them (a new connection opens, a removed one closes, a changed
+	* cadence restarts the timer). A deleted target's devices simply stop being exported.
 	*/
-	async updateGlobalSettingsAsOperator(patch, nodeId) {
-		const rest = {};
-		const flags = /* @__PURE__ */ new Map();
-		for (const [key, value] of Object.entries(patch)) {
-			const field = parseLinkFormKey(key);
-			if (field === null) {
-				rest[key] = value;
-				continue;
-			}
-			this.brokerScope(field.brokerId);
-			const entry = flags.get(field.brokerId) ?? {};
-			if (field.flag === "exportTo") {
-				if (typeof value !== "boolean") throw new Error(`ha-export: ${key} must be true or false`);
-				entry.exportTo = value;
-			} else {
-				const role = HA_MEDIA_ROLES.find((candidate) => candidate === value);
-				if (role === void 0) throw new Error(`ha-export: ${key} is not a known address role`);
-				entry.mediaRole = role;
-			}
-			flags.set(field.brokerId, entry);
-		}
-		for (const [brokerId, change] of flags) await this.book().setFlags(brokerId, this.brokerName(brokerId), change);
-		if (Object.keys(rest).length > 0 || flags.size === 0) {
-			await super.updateGlobalSettingsAsOperator(rest, nodeId);
-			return;
-		}
+	async onTargetChanged(id, change) {
+		await this.book().reload();
+		this.ctx.logger.info("ha-export: an export target changed", { meta: {
+			targetId: id,
+			change
+		} });
 		await this.onConfigChanged();
 	}
-	async onConfigChanged() {
-		for (const link of this.links.values()) link.client.resetBackoff();
-		await this.reconcile("config-changed");
-		this.startTimer();
+	requireInstances() {
+		if (this.instances === null) throw new Error("ha-export: the target instances are not open");
+		return this.instances;
 	}
 	wireListeners() {
 		this.subscribe({ category: require_ha_instance_settings.EventCategory.DeviceStateChanged }, (event) => {
@@ -8494,7 +8738,7 @@ var HaExportAddon = class extends require_ha_instance_settings.BaseAddon {
 			const fullResync = this.resync.take(reason);
 			let readsHeld = false;
 			await this.refreshComponentSupport();
-			const enabled = this.enabledBrokerIds();
+			const enabled = this.enabledTargetIds();
 			const devices = await this.ctx.api.deviceManager.listAll.query({});
 			const snapshots = await this.ctx.api.deviceState.getAllSnapshots.query({});
 			const byId = new Map(devices.map((device) => [device.id, device]));
@@ -9440,71 +9684,63 @@ var HaExportAddon = class extends require_ha_instance_settings.BaseAddon {
 	*/
 	async refreshBrokers() {
 		const haBrokers = await require_ha_instance_settings.listHomeAssistantBrokers((input) => this.ctx.api.broker.list.query(input));
-		const known = haBrokers.map((broker) => ({
-			id: broker.id,
-			name: broker.name
-		}));
 		/**
-		* NEVER prune on an empty enumeration.
-		*
-		* `broker.list` is a fan-out union, so it answers `[]` for the whole window
-		* in which `provider-homeassistant` has not finished registering — and it
-		* registers its caps only at the END of an `initialize()` that restores 239
-		* devices. An empty list there means "I do not know yet", never "the
-		* operator deleted their instance", and the two were indistinguishable to
-		* this code: every boot pruned the membership to nothing and PERSISTED it,
-		* so the operator's exported cameras silently switched themselves off. Seen
-		* live on 2026-08-09 — two cameras exposed, `devices=4`, addon redeployed,
-		* `devices=2` and both switches back to `false` with no line anywhere.
+		* NEVER treat an empty enumeration as "the connections are gone".
 		*
-		* This is D49 exactly: a destructive step gated on a fallible read must not
-		* fire on the reading that destroys work. A broker that really was deleted
-		* is pruned on the next pass that returns a NON-empty list without it,
-		* which costs one interval and cannot cost the operator their config.
+		* `broker.list` is a fan-out union, so it answers `[]` for the whole window in which
+		* `provider-homeassistant` has not finished registering. An empty list there means "I do not
+		* know yet", never "the operator deleted their instance". A target whose connection is not in
+		* the list is UNCONFIGURED for this pass: it pushes nothing, and its devices stay in its
+		* record, so the next pass that sees the connection resumes them. Nothing is ever pruned or
+		* unexposed from here (D49; 2026-08-09, 2026-08-24).
 		*/
-		if (haBrokers.length === 0) {
-			if (this.book().brokerIds().length > 0) this.ctx.logger.warn("ha-export: no Home Assistant broker answered — keeping the export links rather than pruning them", { meta: { brokers: this.book().brokerIds() } });
-		} else {
-			const gone = await this.book().prune(haBrokers.map((broker) => broker.id));
-			if (gone.length > 0) this.ctx.logger.info("ha-export: forgot the export links of removed instances", { meta: { brokers: gone } });
+		this.connections = new Set(haBrokers.map((broker) => broker.id));
+		this.refreshEnabledTargets();
+		for (const id of this.book().ids()) {
+			const target = this.book().get(id);
+			if (target === void 0 || !this.book().isEnabled(id)) continue;
+			if (!this.connectionExists(target.connectionId)) this.ctx.logger.warn(haBrokers.length === 0 ? "ha-export: no Home Assistant connection answered, so this export target is unconfigured for now; its devices stay in place" : "ha-export: the Home Assistant connection of this export target does not exist, so it is unconfigured; its devices stay in place", { meta: {
+				targetId: id,
+				connectionId: target.connectionId
+			} });
 		}
-		/**
-		* Only the roster is a setting; the membership is not, so a boot-window read that answers
-		* empty can no longer erase it (2026-08-24: a refresh wrote `membership: {}` over the
-		* operator's export list). The records are read at boot and a failed read stops it.
-		*/
-		if (!sameBrokers(known, this.config.knownBrokers)) await this.updateGlobalSettings({ knownBrokers: known });
-		this.refreshEnabledBrokers(known);
-		const wanted = new Set(this.enabledBrokerIds());
-		for (const [brokerId, link] of this.links) {
-			if (wanted.has(brokerId)) continue;
+		const wanted = new Set(this.enabledTargetIds());
+		for (const [targetId, link] of this.links) {
+			if (wanted.has(targetId) && link.connectionId === this.book().connectionId(targetId)) continue;
 			await link.client.dispose();
-			this.links.delete(brokerId);
-			this.componentSupport.forget(brokerId);
-			this.ctx.logger.info("ha-export: stopped exporting to a broker", { meta: { brokerId } });
-		}
-		for (const broker of haBrokers) {
-			if (!wanted.has(broker.id)) continue;
-			if (this.links.has(broker.id)) continue;
-			const resolved = await this.resolveBrokerConnection(broker.id, broker.addonId);
+			this.links.delete(targetId);
+			this.componentSupport.forget(targetId);
+			this.ctx.logger.info("ha-export: stopped exporting to a target", { meta: {
+				targetId,
+				connectionId: link.connectionId
+			} });
+		}
+		for (const targetId of wanted) {
+			if (this.links.has(targetId)) continue;
+			const connectionId = this.book().connectionId(targetId);
+			const broker = haBrokers.find((candidate) => candidate.id === connectionId);
+			if (broker === void 0) continue;
+			const resolved = await this.resolveBrokerConnection(connectionId, broker.addonId);
 			if (resolved === null) continue;
 			const client = new PushClient({
 				transport: (message) => postToHomeAssistant(resolved.baseUrl, resolved.token, message),
 				logger: this.ctx.logger,
-				brokerId: broker.id,
-				onLinkRestored: (brokerId) => this.reachability.request(brokerId)
+				brokerId: targetId,
+				onLinkRestored: (restoredId) => this.reachability.request(restoredId)
 			});
 			client.start();
 			this.resync.markGap("broker-connected");
-			this.links.set(broker.id, {
-				brokerId: broker.id,
-				name: broker.name,
+			this.links.set(targetId, {
+				brokerId: targetId,
+				connectionId,
+				name: this.book().name(targetId),
 				baseUrl: resolved.baseUrl,
 				token: resolved.token,
 				client
 			});
 			this.ctx.logger.info("ha-export: exporting to Home Assistant", { meta: {
-				brokerId: broker.id,
+				targetId,
+				connectionId,
 				baseUrl: resolved.baseUrl
 			} });
 		}
@@ -9618,35 +9854,62 @@ var HaExportAddon = class extends require_ha_instance_settings.BaseAddon {
 		}
 	}
 	/**
-	* The brokers switched on, as of the last {@link refreshEnabledBrokers}.
-	*
-	* NOT read from `this.config`: the switch is a fact of the instance's `ha-export-links`
+	* The targets that push, as of the last {@link refreshEnabledTargets}: switched on AND with a
+	* connection the hub knows. NOT read from `this.config`: the switch is a fact of the target's
 	* record, and this is a read-through cache of it, refreshed at the top of every reconcile pass
 	* and before the per-device panel renders, never written to.
 	*/
 	enabled = [];
-	/** The `ha-export-links` records, loaded at boot after the migrations. */
-	linkBook = null;
+	/** The `ha-export-targets` records, loaded at boot after the migrations. */
+	targetBook = null;
 	book() {
-		if (this.linkBook === null) throw new Error("ha-export: the export links are not loaded yet");
-		return this.linkBook;
+		if (this.targetBook === null) throw new Error("ha-export: the export targets are not loaded yet");
+		return this.targetBook;
 	}
-	/** brokerId → exported device ids, from the records. */
+	/** targetId → exported device ids, from the records. */
 	membership() {
 		return this.book().membership();
 	}
-	/** Persist a membership change: each instance's record first, the in-memory copy after it. */
+	/** Persist a membership change: each target's record first, the in-memory copy after it. */
 	async persistMembership(next) {
-		await this.book().setMembership(next, (brokerId) => this.brokerName(brokerId));
+		await this.book().setMembership(next);
 	}
-	refreshEnabledBrokers(known) {
-		this.enabled = known.map((broker) => broker.id).filter((id) => this.book().isEnabled(id));
+	connectionExists(connectionId) {
+		return connectionId.length > 0 && this.connections.has(connectionId);
 	}
-	enabledBrokerIds() {
+	refreshEnabledTargets() {
+		this.enabled = this.book().ids().filter((id) => this.book().isEnabled(id) && this.connectionExists(this.book().connectionId(id)));
+	}
+	enabledTargetIds() {
 		return this.enabled;
 	}
-	brokerName(brokerId) {
-		return this.config.knownBrokers.find((broker) => broker.id === brokerId)?.name ?? brokerId;
+	targetName(targetId) {
+		return this.book().name(targetId);
+	}
+	/** The Status column of the instances table: why a target is, or is not, pushing. */
+	targetHealth(id, body) {
+		if (body.enabled === false) return {
+			state: "off",
+			label: "Off"
+		};
+		if (!this.connectionExists(body.connectionId)) return {
+			state: "error",
+			label: "Unconfigured",
+			detail: body.connectionId.length === 0 ? "Pick the Home Assistant connection this target pushes to" : "The Home Assistant connection of this target does not exist"
+		};
+		const link = this.links.get(id);
+		if (link === void 0) return {
+			state: "unknown",
+			label: "Not connected yet"
+		};
+		return link.client.healthy ? {
+			state: "ok",
+			label: "Connected"
+		} : {
+			state: "error",
+			label: "Unreachable",
+			detail: link.client.failure?.text ?? "unreachable"
+		};
 	}
 	async handleCommandRoute(body, reply) {
 		const topic = readString(body, "topic");
@@ -10034,7 +10297,7 @@ var HaExportAddon = class extends require_ha_instance_settings.BaseAddon {
 	}
 	/**
 	* Each broker's media base, read per use: the palette's role the broker chose
-	* (the `ha-export-links` record's `mediaRole`, `publicEndpoint` by default, internal when none is set). A role that resolves to nothing
+	* (the export target record's `mediaRole`, `publicEndpoint` by default, internal when none is set). A role that resolves to nothing
 	* is `null` and says so — the image entities then carry no value, which reads as
 	* empty rather than as a broken link.
 	*/
@@ -10069,27 +10332,26 @@ var HaExportAddon = class extends require_ha_instance_settings.BaseAddon {
 		return bases;
 	}
 	/**
-	* Every broker this addon knows, enabled or not: a membership write may
-	* target a broker that is switched off (its devices resume when it is turned
-	* back on). A cold `knownBrokers` still counts the enabled ids.
+	* Every target this addon holds, enabled or not: a membership write may target one that is
+	* switched off or unconfigured (its devices resume when it is turned back on).
 	*/
-	knownBrokerIds() {
-		return new Set([...this.config.knownBrokers.map((b) => b.id), ...this.enabledBrokerIds()]);
+	knownTargetIds() {
+		return new Set(this.book().ids());
 	}
 	/**
 	* The brokers a `device-export` read answers over: the named instance, or
 	* (absent) every enabled broker. A broker this addon does not know is
 	* refused, never answered empty.
 	*/
-	brokerScope(instanceId) {
-		if (instanceId === void 0) return this.enabledBrokerIds();
-		if (!this.knownBrokerIds().has(instanceId)) throw new require_ha_instance_settings.ExportInstanceUnknownError("provider-homeassistant", instanceId);
+	targetScope(instanceId) {
+		if (instanceId === void 0) return this.enabledTargetIds();
+		if (!this.knownTargetIds().has(instanceId)) throw new require_ha_instance_settings.ExportInstanceUnknownError("provider-homeassistant", instanceId);
 		return [instanceId];
 	}
 	exposedDeviceRows(scope) {
 		return exposedDeviceIds(this.membership(), scope).map((deviceId) => ({
 			deviceId,
-			exposedAs: brokersExposing(this.membership(), deviceId).map((brokerId) => this.brokerName(brokerId)).join(", ")
+			exposedAs: brokersExposing(this.membership(), deviceId).map((brokerId) => this.targetName(brokerId)).join(", ")
 		}));
 	}
 	/**
@@ -10097,15 +10359,15 @@ var HaExportAddon = class extends require_ha_instance_settings.BaseAddon {
 	* instance. There is no write without a target and no "everywhere": the
 	* other brokers' membership is not touched.
 	*/
-	async setBrokerMembership(instanceId, deviceId, exposed) {
-		this.brokerScope(instanceId);
+	async setTargetMembership(instanceId, deviceId, exposed) {
+		this.targetScope(instanceId);
 		const next = setExposed(this.membership(), instanceId, deviceId, exposed);
 		if (next === this.membership()) {
 			this.ctx.logger.debug("ha-export: membership already in that state, nothing to do", {
 				tags: { deviceId: Number(deviceId) },
 				meta: {
 					exposed,
-					brokerId: instanceId
+					targetId: instanceId
 				}
 			});
 			return;
@@ -10115,93 +10377,29 @@ var HaExportAddon = class extends require_ha_instance_settings.BaseAddon {
 			tags: { deviceId: Number(deviceId) },
 			meta: {
 				exposed,
-				brokerId: instanceId
+				targetId: instanceId
 			}
 		});
 		await this.reconcile(exposed ? "expose" : "unexpose");
 	}
-	globalSettingsSchema() {
-		const brokerFields = this.config.knownBrokers.map((broker) => ({
-			type: "boolean",
-			key: exportToFormKey(broker.id),
-			label: broker.name,
-			style: "switch",
-			default: false
-		}));
-		return { sections: [
-			{
-				id: "ha-export-brokers",
-				title: "Home Assistant instances",
-				titleKey: "provider-homeassistant:globalSettings.s_ha-export-brokers.title",
-				description: brokerFields.length > 0 ? "An instance that is off receives nothing; its exported devices resume when it is turned back on. Export needs the CamStack custom component installed in Home Assistant (HACS)." : "No Home Assistant broker is registered yet.",
-				columns: 1,
-				fields: brokerFields.length > 0 ? brokerFields : [{
-					type: "info",
-					key: "ha-export:__no-brokers",
-					label: "No brokers",
-					labelKey: "provider-homeassistant:globalSettings.s_ha-export-brokers.ha-export___no-brokers.label",
-					content: "Register a Home Assistant broker to enable the export.",
-					variant: "warning"
-				}]
-			},
-			...this.config.knownBrokers.length > 0 ? [{
-				id: "ha-export-transport",
-				title: "Connection",
-				titleKey: "provider-homeassistant:globalSettings.s_ha-export-transport.title",
-				description: "The hub address each Home Assistant instance fetches image links from. Public endpoint is the default, so notifications show images away from home; when none is set the internal address is used. Choose Internal to never use the public endpoint.",
-				columns: 1,
-				fields: this.config.knownBrokers.map((broker) => ({
-					type: "select",
-					key: mediaRoleFormKey(broker.id),
-					label: `Image links for ${broker.name}`,
-					options: [{
-						value: "internal",
-						label: "Internal (LAN address)"
-					}, {
-						value: "publicEndpoint",
-						label: "Public endpoint (reachable from outside)"
-					}],
-					default: "publicEndpoint"
-				}))
-			}] : [],
-			{
-				id: "ha-export-advanced",
-				title: "Advanced",
-				titleKey: "provider-homeassistant:globalSettings.s_ha-export-advanced.title",
-				style: "accordion",
-				defaultCollapsed: true,
-				columns: 1,
-				fields: [{
-					type: "number",
-					key: "reconcileIntervalSec",
-					label: "Reconcile interval (s)",
-					labelKey: "provider-homeassistant:globalSettings.s_ha-export-advanced.reconcileIntervalSec.label",
-					description: "Full re-announce and re-push cadence.",
-					descriptionKey: "provider-homeassistant:globalSettings.s_ha-export-advanced.reconcileIntervalSec.description",
-					default: DEFAULT_CONFIG.reconcileIntervalSec
-				}]
-			}
-		] };
-	}
 	/**
 	* Per-device Export panel — one switch PER BROKER.
 	*
-	* Field keys are namespaced `haExport:<deviceId>:<brokerId>`: the
+	* Field keys are namespaced `haExport:<deviceId>:<targetId>`: the
 	* device-details form flattens fields by key across every contributing
 	* section, so a bare `enabled` collides with the Alexa and HomeKit
 	* exporters' identically-named fields and the operator sees another
 	* exporter's value in this one's toggle.
 	*/
 	async buildContribution(deviceId) {
-		this.refreshEnabledBrokers(this.config.knownBrokers);
 		const idStr = String(deviceId);
-		const enabled = this.enabledBrokerIds();
-		const fields = enabled.map((brokerId) => ({
+		const enabled = this.book().ids().filter((id) => this.book().isEnabled(id));
+		const fields = enabled.map((targetId) => ({
 			type: "boolean",
-			key: `haExport:${deviceId}:${brokerId}`,
-			label: `Export to ${this.brokerName(brokerId)}`,
+			key: `haExport:${deviceId}:${targetId}`,
+			label: `Export to ${this.targetName(targetId)}`,
 			style: "switch",
-			value: isExposed(this.membership(), brokerId, idStr),
+			value: isExposed(this.membership(), targetId, idStr),
 			immediate: true
 		}));
 		return {
@@ -10215,7 +10413,7 @@ var HaExportAddon = class extends require_ha_instance_settings.BaseAddon {
 				id: "ha-export",
 				title: "Home Assistant",
 				titleKey: "provider-homeassistant:contribution.s_ha-export.title",
-				description: enabled.length > 0 ? "Each instance receives only the devices switched on for it." : "No Home Assistant instance is enabled for export.",
+				description: enabled.length > 0 ? "Each target receives only the devices switched on for it." : "No Home Assistant export target is enabled.",
 				tab: "export",
 				columns: 1,
 				order: 30,
@@ -10223,7 +10421,7 @@ var HaExportAddon = class extends require_ha_instance_settings.BaseAddon {
 					type: "info",
 					key: `haExport:${deviceId}:__none`,
 					label: "Not configured",
-					content: "Enable a Home Assistant instance in the addon settings first.",
+					content: "Add an export target on the Connectivity page first.",
 					variant: "info"
 				}]
 			}]
@@ -10236,10 +10434,10 @@ var HaExportAddon = class extends require_ha_instance_settings.BaseAddon {
 		/**
 		* Driven by the PATCH KEYS, not by the enabled-broker list.
 		*
-		* The key already carries the broker (`haExport:<deviceId>:<brokerId>`) —
+		* The key already carries the broker (`haExport:<deviceId>:<targetId>`) —
 		* the operator could not have been shown the switch otherwise — so reading
 		* the broker from it needs no other state to be warm. Iterating
-		* `enabledBrokerIds()` instead made this depend on a read-through cache,
+		* `enabledTargetIds()` instead made this depend on a read-through cache,
 		* and when that cache was cold the loop matched nothing, `touched` stayed
 		* false, and the method returned `{success: true}` HAVING DONE NOTHING.
 		* The admin UI showed the switch flip and it silently did not persist;
@@ -10249,9 +10447,16 @@ var HaExportAddon = class extends require_ha_instance_settings.BaseAddon {
 		const prefix = `haExport:${deviceId}:`;
 		for (const [key, value] of Object.entries(patch)) {
 			if (!key.startsWith(prefix)) continue;
-			const brokerId = key.slice(prefix.length);
-			if (brokerId.length === 0) continue;
-			next = setExposed(next, brokerId, idStr, value === true);
+			const targetId = key.slice(prefix.length);
+			if (targetId.length === 0) continue;
+			if (!this.book().has(targetId)) {
+				this.ctx.logger.warn("ha-export: a device patch names an export target that does not exist", {
+					tags: { deviceId },
+					meta: { targetId }
+				});
+				continue;
+			}
+			next = setExposed(next, targetId, idStr, value === true);
 			touched = true;
 		}
 		if (!touched) {
@@ -10262,9 +10467,9 @@ var HaExportAddon = class extends require_ha_instance_settings.BaseAddon {
 			return { success: true };
 		}
 		await this.persistMembership(next);
-		this.ctx.logger.info("ha-export: per-broker export membership changed", {
+		this.ctx.logger.info("ha-export: per-target export membership changed", {
 			tags: { deviceId },
-			meta: { brokers: brokersExposing(next, idStr) }
+			meta: { targets: brokersExposing(next, idStr) }
 		});
 		await this.reconcile("device-panel");
 		return { success: true };
@@ -10273,15 +10478,17 @@ var HaExportAddon = class extends require_ha_instance_settings.BaseAddon {
 		const enabled = scope;
 		const links = [...this.links.entries()].filter(([brokerId]) => scope.includes(brokerId)).map(([, link]) => link);
 		const healthy = links.filter((link) => link.client.healthy).length;
-		const linkFailure = links.map((link) => link.client.failure).filter((failure) => failure !== null)[0]?.text;
+		const failures = links.map((link) => link.client.failure).filter((failure) => failure !== null);
+		const unconfigured = scope.filter((id) => this.book().isEnabled(id) && !this.connectionExists(this.book().connectionId(id)));
+		const linkFailure = failures[0]?.text ?? (unconfigured.length > 0 ? `The Home Assistant connection of ${unconfigured.map((id) => this.targetName(id)).join(", ")} is not set or does not exist` : void 0);
 		return {
-			linkState: enabled.length === 0 ? "unlinked" : healthy === links.length ? "linked" : "error",
+			linkState: links.length === 0 ? "unlinked" : healthy === links.length ? "linked" : "error",
 			exposedDeviceCount: exposedDeviceIds(this.membership(), enabled).length,
 			...linkFailure !== void 0 ? { error: linkFailure } : this.lastError !== void 0 ? { error: this.lastError } : {},
 			setup: {
 				fields: [
 					{
-						label: "Home Assistant instances",
+						label: "Export targets",
 						value: `${healthy} / ${links.length} reachable`
 					},
 					{
@@ -10307,7 +10514,7 @@ var HaExportAddon = class extends require_ha_instance_settings.BaseAddon {
 	}
 	startTimer() {
 		this.stopTimer();
-		const ms = Math.max(30, this.config.reconcileIntervalSec) * 1e3;
+		const ms = this.book().reconcileIntervalSec() * 1e3;
 		this.reconcileTimer = setInterval(() => void this.reconcile("periodic"), ms);
 	}
 	stopTimer() {