@camstack/addon-provider-reolink 1.2.221 → 1.2.222

package/dist/addon.mjs

@@ -106536,7 +106536,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-BKClVk0K.mjs
+//#region ../types/dist/sleep-Cv4Zmie9.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -107133,7 +107133,7 @@ var NOT_RUN = {
 * throws: an unreachable or refusing engine is logged and reported `declared: false`,
 * because the hub (and this addon's boot) must not hang on a migration.
 */
-async function runAddonMigrations(host, migrations, logger) {
+async function runAddonMigrations(host, migrations, logger, options = {}) {
 	const first = migrations[0];
 	if (first === void 0) return NOT_RUN;
 	const owner = first.meta.owner;
@@ -107162,7 +107162,9 @@ async function runAddonMigrations(host, migrations, logger) {
 		else if (status === "blocked") blocked.push(id);
 		else skipped.push(id);
 	};
+	const selected = options.only === void 0 ? null : new Set(options.only);
 	for (const step of declaration.steps) {
+		if (selected !== null && !selected.has(step.id)) continue;
 		const bound = byId.get(step.id);
 		if (bound === void 0 || step.action === "skip") {
 			skipped.push(step.id);
@@ -108280,14 +108282,18 @@ var BaseAddon = class {
 	* nothing; the boot continues. A migration that FAILED (or was blocked by one)
 	* and declares `onFailure: 'block-owner'` makes this throw, so the addon does not
 	* serve data whose shape it cannot trust; `tolerate` migrations never do.
+	*
+	* ALWAYS pass the whole catalogue; a phase that must run only some of it passes
+	* `{ only: [ids] }` — never a filtered catalogue (the engine would judge the
+	* omitted applied ids "newer").
 	*/
-	async runMigrations(migrations) {
+	async runMigrations(migrations, options) {
 		const api = this.ctx.api.migrations;
 		const report = await runAddonMigrations({
 			declareOwner: (input) => api.declareOwner.mutate(input),
 			startMigration: (input) => api.startMigration.mutate(input),
 			finishMigration: (input) => api.finishMigration.mutate(input)
-		}, migrations, this.ctx.logger);
+		}, migrations, this.ctx.logger, options);
 		if (report.blockOwner.length > 0) throw new AddonMigrationsBlockedError(report.blockOwner);
 		return report;
 	}
@@ -108628,6 +108634,10 @@ var BaseAddon = class {
 		const stored = keychain ? await this.readAddonStoreWithRetry() : {};
 		const patch = {};
 		for (const key of keys) {
+			if (tree.get(key)?.kind === "array") {
+				patch[key] = [];
+				continue;
+			}
 			const keychainStored = tree.has(key) || collectSecretMarkerRefs(stored[key]).length > 0;
 			patch[key] = keychain && keychainStored ? SECRET_CLEAR : "";
 		}
@@ -109354,7 +109364,8 @@ function isZodSecret(schema) {
 }
 /**
 * Every declared secret path in a config schema: dotted keys, `[]` for "each
-* element of this array" (`connection.password`, `rows[].token`). A declared
+* element of this array" (`connection.password`, `rows[].token`), `{}` for "each value of this
+* map" (`applianceSecrets{}`). A declared
 * object or array is reported as one path and not descended into — everything
 * under it is secret.
 */
@@ -109365,6 +109376,7 @@ function collectZodSecretPaths(schema, prefix = "") {
 		const def = defOf(layer);
 		if (def.type === "object" && def.shape) for (const [key, child] of Object.entries(def.shape)) paths.push(...collectZodSecretPaths(child, prefix ? `${prefix}.${key}` : key));
 		else if (def.type === "array" && def.element) paths.push(...collectZodSecretPaths(def.element, `${prefix}[]`));
+		else if (def.type === "record" && def.valueType) paths.push(...collectZodSecretPaths(def.valueType, `${prefix}{}`));
 		else if (def.type === "union" && def.options) for (const option of def.options) paths.push(...collectZodSecretPaths(option, prefix));
 		else if (def.type === "intersection") {
 			if (def.left) paths.push(...collectZodSecretPaths(def.left, prefix));
@@ -112243,7 +112255,7 @@ function sleep(ms) {
 	return new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
 }
 //#endregion
-//#region ../types/dist/composition-BodkvOV0.mjs
+//#region ../types/dist/composition-CRNwcFYY.mjs
 /**
 * The ffmpeg build every CamStack node downloads, per platform and arch.
 *
@@ -113006,38 +113018,6 @@ function validateExpressionSource(src) {
 	return null;
 }
 /**
-* One power reading becomes a washer, dryer or dishwasher (D944 helper).
-*
-* Standby of the control board is under 5 W; a motor or a heater is far
-* above that, so 5 W is the line. A door lock or a short pump spike is not
-* a cycle, so running starts only after 30 s above the line.
-*
-* A wash, dry or dishwasher pause (soak, heat-wait, heater off between
-* bursts) lasts several minutes. Ending the cycle on the first dip would
-* report "finished" in the middle of the program, so the stop dwell is
-* 10 minutes on every type. The number is stored per type so one machine
-* can move later without moving the others.
-*/
-var APPLIANCE_TEMPLATE_ID = "appliance";
-var APPLIANCE_KINDS = [
-	"washer",
-	"dryer",
-	"dishwasher"
-];
-DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher;
-/**
-* A dumb plug-in stove or heater, built from a smart plug (a `Heater`).
-*
-* The plug is the actuator: `switch.setState` is a FORWARD to the plug's own
-* (D967), so the heater switches exactly as the plug does. Running is the
-* plug being on; when a power reading is also named, running is the draw
-* staying above the line instead (a plug left on with the stove's own
-* thermostat open is not heating). 50 W is far above any standby and below
-* the smallest radiator.
-*/
-var HEATER_TEMPLATE_ID = "heater";
-DeviceType.Heater;
-/**
 * Statistics and integrals over a history read (D944).
 *
 * Pure: the same points always give the same answer, so a restart recomputes
@@ -113181,34 +113161,6 @@ var HelperSpecSchema = discriminatedUnion("kind", [
 		/** Actuator groups only. Readings leave this unset. */
 		active: ActiveCriterionSchema.optional()
 	}),
-	object({
-		kind: literal("appliance"),
-		templateId: literal(APPLIANCE_TEMPLATE_ID),
-		appliance: _enum(APPLIANCE_KINDS),
-		thresholdWatts: number().positive(),
-		startDwellMs: number().int().nonnegative(),
-		stopDwellMs: number().int().nonnegative(),
-		member: HelperMemberSchema,
-		/**
-		* The plug that powers the appliance (`switch.on`). Optional: when set, the
-		* composition carries a `power-source` feature, so the hub can cut and restore
-		* that plug (power-source link of a NEW-target composition).
-		*/
-		powerSwitch: HelperMemberSchema.optional(),
-		/** How long a forced restart keeps the plug off; the cap's default when unset. */
-		offSeconds: number().optional()
-	}),
-	object({
-		kind: literal("heater"),
-		templateId: literal(HEATER_TEMPLATE_ID),
-		/** The plug, read and commanded at `switch.on`. */
-		plug: HelperMemberSchema,
-		/** The plug's power reading, when it has one: running is then the draw, not the switch. */
-		meter: HelperMemberSchema.optional(),
-		thresholdWatts: number().positive(),
-		startDwellMs: number().int().nonnegative(),
-		stopDwellMs: number().int().nonnegative()
-	}),
 	object({
 		kind: literal("statistic"),
 		stat: _enum(STATISTIC_STATS),
@@ -113432,7 +113384,7 @@ var CompositionSchema = object({
 		kind: literal("existing"),
 		device: CompositionSourceRefSchema
 	})]),
-	features: array(CompositionFeatureSchema).min(1).max(16),
+	features: array(CompositionFeatureSchema).min(0).max(16),
 	/**
 	* Present when the block is a helper template. Absent on a free
 	* composition (the room example, device 4603). The editor reads this,
@@ -114736,7 +114688,13 @@ var MigrationLedgerEntrySchema = object({
 	* joined by the engine from the catalogues it knows this boot. Absent when no
 	* catalogue lists the id (a newer database).
 	*/
-	meta: MigrationMetaSchema.optional()
+	meta: MigrationMetaSchema.optional(),
+	/**
+	* Set when this is an applied row of an addon owner whose catalogue the answering
+	* process has not loaded (the owner has not declared yet): the row is applied, the
+	* process just cannot judge it. Never `skipped-newer` — that needs the owner loaded.
+	*/
+	ownerNotLoaded: boolean().optional()
 });
 /** A catalogued migration that is not applied, with where it stands. */
 var MigrationPendingEntrySchema = object({
@@ -114769,6 +114727,146 @@ var MigrationOwnerStepSchema = object({
 	/** The ledger state the engine found: `pending` has no row yet. */
 	state: union([literal("pending"), MigrationStatusSchema])
 });
+function ordinalOf(id) {
+	const digits = id.replace(/\D+/g, "");
+	return digits.length > 0 ? Number(digits) : Number.POSITIVE_INFINITY;
+}
+/** The lowest-numbered eligible integration, or null. */
+function defaultIntegrationOf(integrations, eligible) {
+	return [...eligible === void 0 ? integrations : integrations.filter(eligible)].sort((a, b) => ordinalOf(a.id) - ordinalOf(b.id) || (a.id < b.id ? -1 : 1))[0] ?? null;
+}
+function unstamped(device) {
+	return device.integrationId === void 0 || device.integrationId === null || device.integrationId === "";
+}
+/**
+* An allocation reservation is not a device (D376): `allocateDeviceId` writes a row of type
+* `generic`, named by its stable id, that is not registered and holds no configuration. The hub
+* listing does not carry the `registered` bit, so the shape picks the candidates and the missing
+* configuration decides.
+*/
+async function isReservation(ports, device) {
+	if (device.type !== "generic" || device.name === void 0 || device.name !== device.stableId) return false;
+	return !await ports.hasConfig(device.id);
+}
+async function claimDevicesToDefaultIntegration(ports, spec) {
+	const all = await ports.listDevices(spec.addonId);
+	const byId = new Map(all.map((d) => [d.id, d]));
+	const reservations = /* @__PURE__ */ new Set();
+	for (const device of all) if (unstamped(device) && await isReservation(ports, device)) reservations.add(device.id);
+	const orphans = all.filter((d) => unstamped(d) && !reservations.has(d.id));
+	const summaryBase = { reservations: reservations.size };
+	if (orphans.length === 0) return {
+		outcome: "already-done",
+		summary: {
+			claimed: 0,
+			unresolved: 0,
+			...summaryBase
+		}
+	};
+	const fallback = defaultIntegrationOf(await ports.listIntegrations(spec.addonId), spec.eligible);
+	const plan = /* @__PURE__ */ new Map();
+	const unresolved = /* @__PURE__ */ new Set();
+	const failed = /* @__PURE__ */ new Set();
+	const resolve = (device, seen) => {
+		if (!unstamped(device)) return device.integrationId ?? null;
+		const planned = plan.get(device.id);
+		if (planned !== void 0) return planned;
+		if (failed.has(device.id)) return null;
+		let target = null;
+		const parentId = device.parentDeviceId ?? null;
+		if (parentId === null) target = fallback?.id ?? null;
+		else {
+			const parent = byId.get(parentId);
+			if (parent !== void 0 && !reservations.has(parentId) && !seen.has(parentId)) target = resolve(parent, new Set([...seen, device.id]));
+		}
+		if (target === null) failed.add(device.id);
+		else plan.set(device.id, target);
+		return target;
+	};
+	if (orphans.some((d) => (d.parentDeviceId ?? null) === null) && fallback === null) throw new Error(`${orphans.length} device(s) of '${spec.addonId}' carry no integration and the addon has no integration to claim them to`);
+	for (const device of orphans) if (resolve(device, new Set([device.id])) === null) unresolved.add(device.id);
+	for (const id of unresolved) ports.warnDevice(`device ${id} of '${spec.addonId}' carries no integration and its owner chain does not resolve to one: left unstamped`, id);
+	for (const [deviceId, integrationId] of plan) await ports.setIntegrationId(deviceId, integrationId);
+	const wrong = [];
+	for (const [deviceId, integrationId] of plan) if (await ports.readIntegrationId(deviceId) !== integrationId) wrong.push(deviceId);
+	if (wrong.length > 0) throw new Error(`device(s) ${wrong.join(", ")} did not read back their integration after the claim`);
+	const claimed = plan.size;
+	ports.info(`${claimed} device(s) of '${spec.addonId}' claimed to their owner's integration or the default; ${unresolved.size} unresolved, ${reservations.size} reservation(s) skipped`);
+	return {
+		outcome: claimed > 0 ? "done" : "already-done",
+		summary: {
+			claimed,
+			unresolved: unresolved.size,
+			...summaryBase
+		}
+	};
+}
+/** The hub side of the device claim, over `ctx.api`. */
+function claimDevicesPortsOver(deps) {
+	return {
+		listIntegrations: async (addonId) => (await deps.api.list()).filter((i) => i.addonId === addonId).map((i) => ({
+			id: i.id,
+			name: i.name,
+			info: i.info ?? {}
+		})),
+		listDevices: (addonId) => deps.api.listDevices(addonId),
+		hasConfig: (deviceId) => deps.api.readDeviceHasConfig(deviceId),
+		setIntegrationId: (deviceId, integrationId) => deps.api.setDeviceIntegrationId(deviceId, integrationId),
+		readIntegrationId: (deviceId) => deps.api.readDeviceIntegrationId(deviceId),
+		info: deps.info,
+		warnDevice: deps.warnDevice
+	};
+}
+function defaultIntegrationMigrationIds(addonId, date) {
+	return {
+		rowsToRecord: `${addonId}/${date}-integration-rows-to-record`,
+		claimDevices: `${addonId}/${date}-claim-devices-to-default-integration`
+	};
+}
+/**
+* The device claim alone, for an addon that keeps its integration settings where they are for now
+* (its own wave moves them) but whose persisted devices must name their default integration.
+*/
+function claimDevicesMigration(spec) {
+	return {
+		meta: {
+			id: defaultIntegrationMigrationIds(spec.addonId, spec.date).claimDevices,
+			owner: spec.addonId,
+			level: "addon-state",
+			seq: spec.seq,
+			dependsOn: [...spec.dependsOn],
+			store: "settings",
+			scope: "cluster",
+			onFailure: "tolerate",
+			bodyKind: "procedure",
+			description: "Claim the persisted devices that carry no integration to the addon's default integration, keeping their device and stable ids",
+			fixtureMark: "a device config field the claim does not know"
+		},
+		procedure: (ports) => claimDevicesToDefaultIntegration(ports, {
+			addonId: spec.addonId,
+			...spec.eligible !== void 0 ? { eligible: spec.eligible } : {}
+		})
+	};
+}
+function defaultIntegrationApiOver(api) {
+	return {
+		list: () => api.integrations.list.query(),
+		getSettings: (input) => api.integrations.getSettings.query(input),
+		clearSettings: (input) => api.integrations.clearSettings.mutate(input),
+		listDevices: (addonId) => api.deviceManager.listAll.query({
+			addonId,
+			projection: "slim"
+		}),
+		setDeviceIntegrationId: async (deviceId, integrationId) => {
+			await api.deviceManager.setIntegrationId.mutate({
+				deviceId,
+				integrationId
+			});
+		},
+		readDeviceHasConfig: async (deviceId) => Object.keys((await api.deviceManager.getDevice.query({ deviceId }))?.config ?? {}).length > 0,
+		readDeviceIntegrationId: async (deviceId) => (await api.deviceManager.getDevice.query({ deviceId }))?.integrationId ?? null
+	};
+}
 /**
 * The trainer contract — what the hub hands the cloud trainer and what it
 * gets back (cloud training, D805+).
@@ -150744,117 +150842,6 @@ function actuator(input) {
 	};
 }
 new Map(GROUP_TEMPLATES.map((template) => [template.id, template]));
-var PowerSourceRefusalReasonSchema = _enum([
-	"no-power-source",
-	"switch-missing",
-	"switch-offline",
-	"switch-unknown",
-	"restart-in-progress",
-	"switch-call-failed"
-]);
-var PowerSourceActionResultSchema = discriminatedUnion("accepted", [object({ accepted: literal(true) }), object({
-	accepted: literal(false),
-	reason: PowerSourceRefusalReasonSchema,
-	/** One line for the operator, naming the switch. */
-	message: string()
-})]);
-var PowerSourceInfoSchema = object({
-	/** False when the device has no power source linked; the rest is then empty. */
-	linked: boolean(),
-	switchDeviceId: number().nullable(),
-	switchName: string().nullable(),
-	/** The switch's on/off state, or null when it is unknown. Never false for unknown (D393). */
-	switchOn: boolean().nullable(),
-	switchOnline: boolean().nullable(),
-	restartInProgress: boolean(),
-	offSeconds: number().int()
-});
-/** The composed slice: the switch state the link mirrors, plus the stored off time. */
-var PowerSourceStateSchema = object({
-	/** Null while the switch has not reported: unknown is never `false` (D393). */
-	switchOn: boolean().nullable(),
-	offSeconds: number().int(),
-	lastFetchedAt: number()
-});
-var POWER_SOURCE_DEVICE_TYPES = [
-	DeviceType.Gateway,
-	DeviceType.Hub,
-	DeviceType.Camera,
-	DeviceType.Sensor,
-	DeviceType.MediaPlayer,
-	DeviceType.Vacuum,
-	DeviceType.Generic,
-	DeviceType.Washer,
-	DeviceType.Dryer,
-	DeviceType.Dishwasher,
-	DeviceType.PetFountain,
-	DeviceType.Fan,
-	DeviceType.Humidifier,
-	DeviceType.Climate,
-	DeviceType.WaterHeater
-];
-var powerSourceCustomize = {
-	version: 1,
-	targets: [{
-		id: "switch",
-		cardinality: "scalar",
-		vocabulary: {
-			cap: "power-source",
-			stateField: "switchOn"
-		},
-		deviceTypes: POWER_SOURCE_DEVICE_TYPES,
-		apply: "add",
-		path: "switchOn",
-		sources: [{
-			kind: "switch",
-			transforms: [{ kind: "identity" }]
-		}],
-		companions: [{
-			kind: "constant",
-			path: "offSeconds",
-			value: 10,
-			when: "add"
-		}, {
-			kind: "clock",
-			path: "lastFetchedAt",
-			when: "always"
-		}],
-		sourceReport: { status: "assignment-status" }
-	}]
-};
-var deviceInput$2 = object({ deviceId: number().int().nonnegative() });
-var powerSourceCapability = {
-	name: "power-source",
-	scope: "device",
-	mode: "singleton",
-	deviceTypes: POWER_SOURCE_DEVICE_TYPES,
-	methods: {
-		getStatus: systemMethod(deviceInput$2, PowerSourceInfoSchema, { auth: "admin" }),
-		powerOn: systemMethod(deviceInput$2, PowerSourceActionResultSchema, {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		powerOff: systemMethod(deviceInput$2, PowerSourceActionResultSchema, {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		forceRestart: systemMethod(deviceInput$2, PowerSourceActionResultSchema, {
-			kind: "mutation",
-			auth: "admin"
-		})
-	},
-	runtimeState: PowerSourceStateSchema,
-	customize: powerSourceCustomize,
-	/**
-	* Runtime-state durability: **session** — mirrored from the linked switch on
-	* its next report; a restored value would outlive the reading it names.
-	*
-	* See `RuntimeStateDurability`. Enforced by
-	* `scripts/check-runtime-state-durability.ts`.
-	*/
-	durability: "session",
-	history: "none"
-};
 DeviceFeature.LightColorRgb, DeviceFeature.LightColorHsv, DeviceFeature.LightColorMired;
 DeviceType.Camera;
 `${COMPOSED_DEVICE_STABLE_ID_PREFIX}`;
@@ -150882,6 +150869,165 @@ var ComposableCapabilitiesSchema = object({ caps: array(object({
 	}).optional()
 })) });
 /**
+* A saved Customize assignment (D936). The schema is the type: callers use
+* `z.infer`, they do not restate the shape.
+*/
+var OverrideSourceSchema = object({
+	addonId: string().min(1),
+	stableId: string().min(1),
+	cap: string().min(1),
+	fieldPath: string().min(1)
+});
+var IdentityTransformDraftSchema = object({ kind: literal("identity") });
+var InvertTransformDraftSchema = object({ kind: literal("invert") });
+var ThresholdTransformDraftSchema = object({
+	kind: literal("threshold"),
+	comparison: _enum(["gte", "lte"]),
+	threshold: number(),
+	startDwellMs: number().nonnegative(),
+	stopDwellMs: number().nonnegative()
+});
+var CustomizeTransformDraftSchema = discriminatedUnion("kind", [
+	IdentityTransformDraftSchema,
+	InvertTransformDraftSchema,
+	ThresholdTransformDraftSchema,
+	object({
+		kind: literal("linear"),
+		scale: number(),
+		offset: number(),
+		clampMin: number().optional(),
+		clampMax: number().optional()
+	}),
+	object({
+		kind: literal("enum-map"),
+		mapping: record(string(), string().nullable())
+	}),
+	object({ kind: literal("number") })
+]);
+var ScalarOverrideDraftSchema = object({
+	kind: literal("scalar"),
+	cap: string().min(1),
+	targetId: string().min(1),
+	source: OverrideSourceSchema,
+	transform: CustomizeTransformDraftSchema
+});
+var KeyedArrayOverrideDraftSchema = object({
+	kind: literal("keyedArray"),
+	cap: string().min(1),
+	targetId: string().min(1),
+	key: string().min(1),
+	label: string().min(1),
+	fieldPath: string().min(1),
+	source: OverrideSourceSchema,
+	transform: CustomizeTransformDraftSchema
+});
+var PulseOverrideDraftSchema = object({
+	kind: literal("pulse"),
+	cap: string().min(1),
+	targetId: string().min(1),
+	enabled: boolean(),
+	debounceMs: number().nonnegative(),
+	edges: array(_enum([
+		"rising",
+		"button",
+		"native-event"
+	])).min(1).optional(),
+	sources: array(OverrideSourceSchema).min(1)
+});
+var SpanSourceDraftSchema = OverrideSourceSchema.extend({ mode: _enum([
+	"in-addition",
+	"confirm",
+	"replace"
+]).optional() });
+discriminatedUnion("kind", [
+	ScalarOverrideDraftSchema,
+	KeyedArrayOverrideDraftSchema,
+	PulseOverrideDraftSchema,
+	object({
+		kind: literal("span"),
+		cap: string().min(1),
+		targetId: string().min(1),
+		timeoutMs: number().nonnegative(),
+		cooldownMs: number().nonnegative().optional(),
+		sources: array(SpanSourceDraftSchema)
+	})
+]);
+object({
+	targetId: string().min(1),
+	configured: boolean(),
+	source: _enum(["native", "assigned"]),
+	state: _enum([
+		"active",
+		"stale",
+		"released",
+		"unavailable"
+	]),
+	reason: string().nullable()
+});
+/**
+* What a running-threshold proposal says (planning#405). The schema is the
+* type: the algorithm, the capability method and the UI all read `z.infer`.
+*
+* A proposal is read-only advice: it carries the numbers it was derived from
+* (`evidence`) so the operator can judge it, and an `insufficient` answer names
+* WHY with a typed reason and the catalog defaults, never an invented number.
+*/
+var RunningProposalTierSchema = _enum(["raw", "5m"]);
+var RunningProposalConfidenceSchema = _enum([
+	"high",
+	"medium",
+	"low"
+]);
+var RunningProposalInsufficientReasonSchema = _enum([
+	"no-history",
+	"span-too-short",
+	"truncated",
+	"no-idle-floor",
+	"no-runs",
+	"no-separation"
+]);
+var RunningProposalReplaySchema = object({
+	/** Intervals the real dwell expression held true over the window. */
+	intervals: number().int().nonnegative(),
+	/** Intervals outside every run, or a second interval inside one. */
+	extra: number().int().nonnegative(),
+	/** Runs without an interval of their own (none, or merged into a neighbour). */
+	missed: number().int().nonnegative()
+});
+var RunningProposalEvidenceSchema = object({
+	tier: RunningProposalTierSchema,
+	spanMs: number().nonnegative(),
+	from: number(),
+	to: number(),
+	points: number().int().nonnegative(),
+	runsFound: number().int().nonnegative(),
+	pausesFound: number().int().nonnegative(),
+	longestPauseMs: number().nonnegative(),
+	idleFloorW: number(),
+	noiseCeilingW: number(),
+	plateauW: number(),
+	replay: RunningProposalReplaySchema
+});
+var RunningProposalInsufficientEvidenceSchema = object({
+	spanMs: number().nonnegative(),
+	points: number().int().nonnegative(),
+	runsFound: number().int().nonnegative()
+});
+var RunningThresholdProposalSchema = discriminatedUnion("state", [object({
+	state: literal("proposal"),
+	transform: ThresholdTransformDraftSchema,
+	evidence: RunningProposalEvidenceSchema,
+	confidence: RunningProposalConfidenceSchema,
+	/** Why the confidence is not higher; empty when nothing held it back. */
+	notes: array(string())
+}), object({
+	state: literal("insufficient"),
+	reason: RunningProposalInsufficientReasonSchema,
+	evidence: RunningProposalInsufficientEvidenceSchema,
+	/** The catalog defaults, offered as what stands when nothing better is known. */
+	fallback: ThresholdTransformDraftSchema
+})]);
+/**
 * The report of a one-shot "move this owner's plaintext secrets into the
 * keychain" run (D878). COUNTS only - never a value, never a ref.
 *
@@ -151171,6 +151317,14 @@ method(object({}), object({ blocks: array(CoreBlockSchema) }), { auth: "admin" }
 	kind: "mutation",
 	auth: "admin",
 	access: "view"
+}), method(object({
+	deviceId: number().int(),
+	cap: string().min(1),
+	fieldPath: string().min(1),
+	deviceType: _enum(DeviceType).optional()
+}), RunningThresholdProposalSchema, {
+	auth: "admin",
+	access: "view"
 }), method(object({
 	blockId: string().min(1),
 	trace: AutomationRunTraceSchema.optional(),
@@ -152147,7 +152301,27 @@ method(object({
 * exposes only the COMMON surface: link state, supported device
 * kinds (so the UI can filter the device picker), and per-device
 * expose/unexpose.
-*/
+*
+* INSTANCES. One export addon can serve several independent targets (a
+* HomeKit bridge, a Home Assistant broker). `listInstances` names them.
+* `instanceId` on a READ is optional: absent = the whole addon (linked if any
+* enabled instance is, `exposedDeviceCount` = distinct devices, `setup` = the
+* default instance's); present = that instance; an id the provider does not
+* serve is refused with `ExportInstanceUnknownError` (`export-instance-unknown`),
+* never answered empty. `instanceId` on a WRITE is REQUIRED: a membership
+* change always names the target it changes. A single-instance provider
+* accepts an absent id on a read or its own id, and refuses any other.
+*/
+/** Which instance of an export addon a call addresses. Absent on a read = the whole addon. */
+var InstanceIdSchema$1 = string().min(1);
+var InstancePinSchema = object({ instanceId: InstanceIdSchema$1.optional() });
+/** One independent export target of an addon. */
+var ExportInstanceSchema = object({
+	instanceId: InstanceIdSchema$1,
+	name: string(),
+	enabled: boolean(),
+	kind: string().optional()
+});
 var LinkStateSchema = _enum([
 	"unlinked",
 	"linked",
@@ -152198,10 +152372,14 @@ var ExposedDeviceSchema = object({
 	capabilities: array(string()).optional()
 });
 var ExposeInputSchema = object({
+	instanceId: InstanceIdSchema$1,
 	deviceId: string(),
 	capabilities: array(string()).optional()
 });
-var UnexposeInputSchema = object({ deviceId: string() });
+var UnexposeInputSchema = object({
+	instanceId: InstanceIdSchema$1,
+	deviceId: string()
+});
 /**
 * What an exporter may expose besides devices (D968). An action and a
 * notification target are LIST ENTRIES, never devices (D954): they enter an
@@ -152230,15 +152408,21 @@ var ExposedEntitySchema = object({
 	entity: ExportEntityRefSchema,
 	exposedAs: string().optional()
 });
-var ExposeEntityInputSchema = object({ entity: ExportEntityRefSchema });
-var UnexposeEntityInputSchema = object({ entity: ExportEntityRefSchema });
-method(_void(), DeviceExportStatusSchema), method(_void(), array(DeviceKindSchema)), method(_void(), array(ExposedDeviceSchema)), method(ExposeInputSchema, _void(), {
+var ExposeEntityInputSchema = object({
+	instanceId: InstanceIdSchema$1,
+	entity: ExportEntityRefSchema
+});
+var UnexposeEntityInputSchema = object({
+	instanceId: InstanceIdSchema$1,
+	entity: ExportEntityRefSchema
+});
+method(InstancePinSchema, DeviceExportStatusSchema), method(_void(), array(ExportInstanceSchema)), method(InstancePinSchema, array(DeviceKindSchema)), method(InstancePinSchema, array(ExposedDeviceSchema)), method(ExposeInputSchema, _void(), {
 	kind: "mutation",
 	auth: "admin"
 }), method(UnexposeInputSchema, _void(), {
 	kind: "mutation",
 	auth: "admin"
-}), optionalMethod(_void(), array(ExportEntityKindSchema)), optionalMethod(_void(), array(ExposedEntitySchema)), optionalMethod(ExposeEntityInputSchema, _void(), {
+}), optionalMethod(_void(), array(ExportEntityKindSchema)), optionalMethod(InstancePinSchema, array(ExposedEntitySchema)), optionalMethod(ExposeEntityInputSchema, _void(), {
 	kind: "mutation",
 	auth: "admin"
 }), optionalMethod(UnexposeEntityInputSchema, _void(), {
@@ -155861,15 +156045,15 @@ var FanPresetCaptureResultSchema = object({
 	items: array(FanCaptureItemSchema),
 	omitted: array(FanCaptureOmissionSchema)
 });
-var deviceInput$1 = object({ deviceId: number().int().nonnegative() });
+var deviceInput$2 = object({ deviceId: number().int().nonnegative() });
 DeviceType.Fan;
-method(deviceInput$1, array(FanPresetSchema), { auth: "protected" }), method(deviceInput$1.extend({ presets: array(FanPresetSchema).max(12) }), FanPresetsSetResultSchema, {
+method(deviceInput$2, array(FanPresetSchema), { auth: "protected" }), method(deviceInput$2.extend({ presets: array(FanPresetSchema).max(12) }), FanPresetsSetResultSchema, {
 	kind: "mutation",
 	auth: "admin"
-}), method(deviceInput$1.extend({ presetId: string().min(1) }), FanPresetApplyResultSchema, {
+}), method(deviceInput$2.extend({ presetId: string().min(1) }), FanPresetApplyResultSchema, {
 	kind: "mutation",
 	auth: "protected"
-}), method(deviceInput$1.extend({
+}), method(deviceInput$2.extend({
 	fields: array(FanCaptureFieldSchema).optional(),
 	steps: array(ActionStepSchema).max(20).default([])
 }), FanPresetCaptureResultSchema, { auth: "protected" });
@@ -156752,6 +156936,12 @@ method(_void(), array(IntegrationWithStateSchema)), method(object({ id: string()
 }), object({ success: boolean() }), {
 	kind: "mutation",
 	auth: "admin"
+}), method(object({ id: string() }), object({
+	rows: number().int().nonnegative(),
+	secrets: number().int().nonnegative()
+}), {
+	kind: "mutation",
+	auth: "admin"
 }), method(_void(), array(AvailableIntegrationTypeSchema), { auth: "admin" }), method(object({
 	addonId: string(),
 	settings: record(string(), unknown())
@@ -156780,13 +156970,65 @@ method(_void(), array(IntegrationWithStateSchema)), method(object({ id: string()
 */
 var ConfigSchemaPassthrough$3 = custom();
 var IntegrationInstanceIdSchema = string().min(1);
+var IntegrationInstanceModeSchema = _enum(["single", "multiple"]);
+/**
+* One kind of instance a provider can create (an adapter, an account type). The sign-in and
+* connect fields follow the `broker` contract (`broker.cap.ts`): `signIn.basePath` is a
+* hub-relative route set speaking the sign-in contract, `connectPath` / `disconnectPath` open an
+* interactive account link (popup) and may carry `{{brokerId}}`, which the UI replaces with the
+* instance id.
+*/
+var IntegrationInstanceKindSchema = object({
+	/** Stable id of the kind, sent back as `createInstance.kind`. */
+	id: string().min(1),
+	label: string().min(1),
+	/** The kind signs in through a server-held interactive session. */
+	signIn: object({
+		basePath: string().min(1),
+		methods: array(_enum(["device-code", "proxy"])).optional()
+	}).optional(),
+	/** Relative hub path to start an interactive account link of an instance of this kind. */
+	connectPath: string().min(1).optional(),
+	/** Relative hub path to disconnect that account. */
+	disconnectPath: string().min(1).optional()
+});
 var IntegrationInstanceDescriptionSchema = object({
+	/** What the instances are for the Integrations page; see {@link IntegrationInstanceRoleSchema}. */
+	role: _enum([
+		"devices",
+		"services",
+		"both"
+	]),
+	/** How the devices of an instance are found; absent means `{ mode: 'none' }`. */
+	discovery: object({
+		mode: _enum([
+			"none",
+			"lan",
+			"account"
+		]),
+		scopedToInstance: boolean()
+	}).optional(),
 	/** `single`: at most one instance can exist (Loki). `multiple`: an account each. */
-	instanceMode: _enum(["single", "multiple"]),
+	instanceMode: IntegrationInstanceModeSchema,
 	/** What the instance is, for the UI (`destination`, `relay`, `account`). */
 	kind: string(),
 	/** True when `testInstance` really probes the remote. */
-	canTest: boolean()
+	canTest: boolean(),
+	/**
+	* The kinds an instance can be of. Absent or one entry: nothing to choose; more than one: the
+	* Add flow asks which first and sends it as `createInstance.kind`.
+	*/
+	kinds: array(IntegrationInstanceKindSchema).optional(),
+	/**
+	* The provider accepts `createInstance.id` for an id that once existed (an adopted id, because
+	* devices carry it). The UI then offers "restore under its old id" on Add. Absent means no.
+	*/
+	allowRestoreId: boolean().optional(),
+	/**
+	* `createInstance` without an `id` works: the provider mints it. Absent means the caller must
+	* send an id (the UI then mints an opaque one).
+	*/
+	mintsId: boolean().optional()
 });
 var IntegrationInstanceStatusSchema = object({
 	state: _enum([
@@ -156795,7 +157037,9 @@ var IntegrationInstanceStatusSchema = object({
 		"error",
 		"unknown"
 	]),
-	detail: string().optional()
+	detail: string().optional(),
+	/** A short human word for the state ("Signed in", "Token expired"); shown instead of `state`. */
+	label: string().optional()
 });
 var IntegrationInstanceSchema = object({
 	id: IntegrationInstanceIdSchema,
@@ -156803,13 +157047,18 @@ var IntegrationInstanceSchema = object({
 	/** The addon's own rule (an URL is present, a client id is present...). */
 	configured: boolean(),
 	/**
-	* The instance's own on/off switch (D996): always present, derived from the record body
-	* (`enabled !== false`, so a row written before the field existed is on).
+	* The instance's own on/off switch (D996), derived from the record body (`enabled !== false`,
+	* so a row written before the field existed is on). Absent when the `integrations` registry
+	* owns the switch (`describe().role` is `devices`): read it from the registry row.
 	*/
-	enabled: boolean(),
+	enabled: boolean().optional(),
+	/** The kind of this instance (one of `describe().kinds[].id`), when the provider has kinds. */
+	kind: string().optional(),
 	/** Values for the instance form; a secret is a `SecretFieldView`, never text. */
 	formValues: record(string(), unknown()),
-	status: IntegrationInstanceStatusSchema.optional()
+	status: IntegrationInstanceStatusSchema.optional(),
+	/** Epoch ms of the last probe of the remote that produced `status`; absent when never checked. */
+	lastCheckedAt: number().optional()
 });
 var IntegrationInstancePatchSchema = object({
 	id: IntegrationInstanceIdSchema,
@@ -156818,8 +157067,9 @@ var IntegrationInstancePatchSchema = object({
 	values: record(string(), unknown())
 });
 method(_void(), IntegrationInstanceDescriptionSchema, { auth: "admin" }), method(object({ id: IntegrationInstanceIdSchema.nullable() }), ConfigSchemaPassthrough$3, { auth: "admin" }), method(_void(), array(IntegrationInstanceSchema).readonly(), { auth: "admin" }), method(object({ id: IntegrationInstanceIdSchema }), IntegrationInstanceSchema.nullable(), { auth: "admin" }), method(object({
-	id: IntegrationInstanceIdSchema,
-	name: string().min(1)
+	id: IntegrationInstanceIdSchema.optional(),
+	name: string().min(1),
+	kind: string().min(1).optional()
 }), object({ id: string() }), {
 	kind: "mutation",
 	auth: "admin"
@@ -158880,6 +159130,11 @@ var LogEntrySchema = object({
 * flight, and not asking for the next slice ends the scan.
 */
 var LogReadQuerySchema = object({
+	/**
+	* Which destination INSTANCE answers (a destination addon may hold several records). Absent ⇒
+	* the provider's first readable one, so a caller written before instances existed is unchanged.
+	*/
+	instanceId: string().min(1).max(200).optional(),
 	/** Correlates `cancelRead`. Caller-chosen, unique per in-flight read. */
 	requestId: string().min(1).max(64).optional(),
 	/** The device the line is about (`tags.deviceId`, numeric). */
@@ -158942,6 +159197,8 @@ var LogReadResultSchema = object({
 	/** True when `cancelRead` ended this slice early. */
 	cancelled: boolean().optional()
 });
+/** Names one destination instance; absent ⇒ the provider's first readable one. */
+var LogInstanceSelectorSchema = object({ instanceId: string().min(1).max(200).optional() });
 var LogReadCapabilitiesSchema = object({
 	/** False ⇒ this destination only ships lines (console, forwarder, an unconfigured Loki). */
 	readable: boolean(),
@@ -158960,7 +159217,7 @@ var LogReadCapabilitiesSchema = object({
 	/** How far back the store reaches, when the provider knows (days). */
 	retentionDays: number().nullable()
 });
-method(LogEntrySchema, _void(), { kind: "mutation" }), optionalMethod(_void(), LogReadCapabilitiesSchema, { auth: "admin" }), optionalMethod(LogReadQuerySchema, LogReadResultSchema, { auth: "admin" }), optionalMethod(object({ requestId: string().min(1).max(64) }), object({ cancelled: boolean() }), {
+method(LogEntrySchema, _void(), { kind: "mutation" }), optionalMethod(LogInstanceSelectorSchema, LogReadCapabilitiesSchema, { auth: "admin" }), optionalMethod(LogReadQuerySchema, LogReadResultSchema, { auth: "admin" }), optionalMethod(object({ requestId: string().min(1).max(64) }), object({ cancelled: boolean() }), {
 	kind: "mutation",
 	auth: "admin"
 });
@@ -171353,6 +171610,14 @@ var powerMeterCapability = {
 	deviceNative: true,
 	mode: "singleton",
 	deviceTypes: POWER_METER_DEVICE_TYPES,
+	deviceConfig: { ui: {
+		kind: "widget",
+		widgetId: "host/power-meter-line",
+		tab: "power",
+		placement: "hero",
+		label: "Power",
+		order: 4
+	} },
 	methods: {},
 	status: {
 		schema: PowerMeterStatusSchema,
@@ -171412,6 +171677,117 @@ var powerMeterCapability = {
 	volatileStateFields: ["lastFetchedAt"],
 	customize: powerMeterCustomize
 };
+var PowerSourceRefusalReasonSchema = _enum([
+	"no-power-source",
+	"switch-missing",
+	"switch-offline",
+	"switch-unknown",
+	"restart-in-progress",
+	"switch-call-failed"
+]);
+var PowerSourceActionResultSchema = discriminatedUnion("accepted", [object({ accepted: literal(true) }), object({
+	accepted: literal(false),
+	reason: PowerSourceRefusalReasonSchema,
+	/** One line for the operator, naming the switch. */
+	message: string()
+})]);
+var PowerSourceInfoSchema = object({
+	/** False when the device has no power source linked; the rest is then empty. */
+	linked: boolean(),
+	switchDeviceId: number().nullable(),
+	switchName: string().nullable(),
+	/** The switch's on/off state, or null when it is unknown. Never false for unknown (D393). */
+	switchOn: boolean().nullable(),
+	switchOnline: boolean().nullable(),
+	restartInProgress: boolean(),
+	offSeconds: number().int()
+});
+/** The composed slice: the switch state the link mirrors, plus the stored off time. */
+var PowerSourceStateSchema = object({
+	/** Null while the switch has not reported: unknown is never `false` (D393). */
+	switchOn: boolean().nullable(),
+	offSeconds: number().int(),
+	lastFetchedAt: number()
+});
+var POWER_SOURCE_DEVICE_TYPES = [
+	DeviceType.Gateway,
+	DeviceType.Hub,
+	DeviceType.Camera,
+	DeviceType.Sensor,
+	DeviceType.MediaPlayer,
+	DeviceType.Vacuum,
+	DeviceType.Generic,
+	DeviceType.Washer,
+	DeviceType.Dryer,
+	DeviceType.Dishwasher,
+	DeviceType.PetFountain,
+	DeviceType.Fan,
+	DeviceType.Humidifier,
+	DeviceType.Climate,
+	DeviceType.WaterHeater
+];
+var powerSourceCustomize = {
+	version: 1,
+	targets: [{
+		id: "switch",
+		cardinality: "scalar",
+		vocabulary: {
+			cap: "power-source",
+			stateField: "switchOn"
+		},
+		deviceTypes: POWER_SOURCE_DEVICE_TYPES,
+		apply: "add",
+		path: "switchOn",
+		sources: [{
+			kind: "switch",
+			transforms: [{ kind: "identity" }]
+		}],
+		companions: [{
+			kind: "constant",
+			path: "offSeconds",
+			value: 10,
+			when: "add"
+		}, {
+			kind: "clock",
+			path: "lastFetchedAt",
+			when: "always"
+		}],
+		sourceReport: { status: "assignment-status" }
+	}]
+};
+var deviceInput$1 = object({ deviceId: number().int().nonnegative() });
+var powerSourceCapability = {
+	name: "power-source",
+	scope: "device",
+	mode: "singleton",
+	deviceTypes: POWER_SOURCE_DEVICE_TYPES,
+	methods: {
+		getStatus: systemMethod(deviceInput$1, PowerSourceInfoSchema, { auth: "admin" }),
+		powerOn: systemMethod(deviceInput$1, PowerSourceActionResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		powerOff: systemMethod(deviceInput$1, PowerSourceActionResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		forceRestart: systemMethod(deviceInput$1, PowerSourceActionResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		})
+	},
+	runtimeState: PowerSourceStateSchema,
+	customize: powerSourceCustomize,
+	/**
+	* Runtime-state durability: **session** — mirrored from the linked switch on
+	* its next report; a restored value would outlive the reading it names.
+	*
+	* See `RuntimeStateDurability`. Enforced by
+	* `scripts/check-runtime-state-durability.ts`.
+	*/
+	durability: "session",
+	history: "none"
+};
 /**
 * Presence cap. Models HA `person.*` and `device_tracker.*` entities
 * on `DeviceType.Presence`. Read-only — no setters: presence is
@@ -181892,6 +182268,25 @@ function buildStreamParamsConfigSchema(options, status) {
 	if (sections.length === 0) return null;
 	return { sections };
 }
+/**
+* What a remote key is CALLED and what it LOOKS like, for every role (D963),
+* shared by the admin UI and the viewer. A role is data on the wire; each
+* client resolves its name from `label` (English and Italian side by side) and
+* its glyph from `icon`, a lucide id from the shared icon catalogue — the
+* server sends an id, a client maps it to its own icon set.
+*
+* `legend` is text printed on the key INSTEAD of a glyph (a digit has no
+* pictogram): a client that can draw text shows it, one that cannot falls back
+* to `icon`.
+*/
+function digit(n) {
+	return {
+		label: t(n, n),
+		icon: "hash",
+		legend: n
+	};
+}
+digit("0"), digit("1"), digit("2"), digit("3"), digit("4"), digit("5"), digit("6"), digit("7"), digit("8"), digit("9");
 DeviceFeature.MediaPlayerPower, DeviceFeature.MediaPlayerVolumeStep, DeviceFeature.MediaPlayerChannelStep, DeviceFeature.MediaPlayerMute, DeviceFeature.MediaPlayerStop, DeviceFeature.MediaPlayerNext, DeviceFeature.MediaPlayerPrevious;
 var btn = (idSuffix, row, col, init) => ({
 	idSuffix,
@@ -182020,6 +182415,34 @@ discriminatedUnion("kind", [object({
 	code: string()
 })]);
 /**
+* Propose a running threshold from a device's own power history (planning#405).
+*
+* Pure and deterministic: the same series gives the same answer. The series is
+* a HELD-VALUE step series — a point's value stands until the next point — which
+* is how device-history stores a gauge, so "time at a level" is exact, not a
+* count of samples.
+*
+*  1. idle floor F = time-weighted median; noise ceiling N = highest value seen
+*     near F. A device that is not near one level most of the time has no floor.
+*  2. coarse activity = above max(2N, N + 5 W); consecutive stretches are episodes.
+*  3. gaps between episodes split in two by the largest log-scale jump (>= 3x):
+*     the short ones are pauses INSIDE a run (a soak), the long ones separate runs.
+*  4. T = geometric mean of N and the plateau's 10th percentile, snapped to a
+*     grid a person would type; stop dwell covers the longest pause; start dwell
+*     covers the longest standby blip above T.
+*  5. the numbers are proved by REPLAY through the real `dwell` evaluation: each
+*     run must hold exactly one true interval and nothing may flap outside.
+*/
+var SECOND_MS = 1e3;
+var MINUTE_MS$1 = 60 * SECOND_MS;
+24 * (60 * MINUTE_MS$1);
+10 * MINUTE_MS$1;
+30 * SECOND_MS;
+60 * SECOND_MS;
+20 * MINUTE_MS$1;
+10 * SECOND_MS;
+10 * SECOND_MS;
+/**
 * Which of OUR object detections a clip window holds — the ONE overlap rule
 * and the ONE label ranking, for every clip source (D923).
 *
@@ -185272,6 +185695,13 @@ Object.freeze({
 		access: "create",
 		role: "admin"
 	},
+	"coreBlocks.proposeRunningThreshold": {
+		capName: "core-blocks",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
 	"coreBlocks.reportAutomationRun": {
 		capName: "core-blocks",
 		capScope: "system",
@@ -185783,6 +186213,13 @@ Object.freeze({
 		access: "view",
 		role: "admin"
 	},
+	"deviceExport.listInstances": {
+		capName: "device-export",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
 	"deviceExport.listSupportedDeviceKinds": {
 		capName: "device-export",
 		capScope: "system",
@@ -187435,6 +187872,13 @@ Object.freeze({
 		access: "create",
 		role: "admin"
 	},
+	"integrations.clearSettings": {
+		capName: "integrations",
+		capScope: "system",
+		addonId: null,
+		access: "delete",
+		role: "admin"
+	},
 	"integrations.create": {
 		capName: "integrations",
 		capScope: "system",
@@ -194882,6 +195326,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"coreBlocks.proposeRunningThreshold": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"cover.close": [{
 		name: "deviceId",
 		form: "single",
@@ -197545,99 +197994,6 @@ Object.freeze({
 	"network-access": "ingress",
 	"smtp-provider": "email"
 });
-/**
-* A saved Customize assignment (D936). The schema is the type: callers use
-* `z.infer`, they do not restate the shape.
-*/
-var OverrideSourceSchema = object({
-	addonId: string().min(1),
-	stableId: string().min(1),
-	cap: string().min(1),
-	fieldPath: string().min(1)
-});
-var CustomizeTransformDraftSchema = discriminatedUnion("kind", [
-	object({ kind: literal("identity") }),
-	object({ kind: literal("invert") }),
-	object({
-		kind: literal("threshold"),
-		comparison: _enum(["gte", "lte"]),
-		threshold: number(),
-		startDwellMs: number().nonnegative(),
-		stopDwellMs: number().nonnegative()
-	}),
-	object({
-		kind: literal("linear"),
-		scale: number(),
-		offset: number(),
-		clampMin: number().optional(),
-		clampMax: number().optional()
-	}),
-	object({
-		kind: literal("enum-map"),
-		mapping: record(string(), string().nullable())
-	}),
-	object({ kind: literal("number") })
-]);
-var ScalarOverrideDraftSchema = object({
-	kind: literal("scalar"),
-	cap: string().min(1),
-	targetId: string().min(1),
-	source: OverrideSourceSchema,
-	transform: CustomizeTransformDraftSchema
-});
-var KeyedArrayOverrideDraftSchema = object({
-	kind: literal("keyedArray"),
-	cap: string().min(1),
-	targetId: string().min(1),
-	key: string().min(1),
-	label: string().min(1),
-	fieldPath: string().min(1),
-	source: OverrideSourceSchema,
-	transform: CustomizeTransformDraftSchema
-});
-var PulseOverrideDraftSchema = object({
-	kind: literal("pulse"),
-	cap: string().min(1),
-	targetId: string().min(1),
-	enabled: boolean(),
-	debounceMs: number().nonnegative(),
-	edges: array(_enum([
-		"rising",
-		"button",
-		"native-event"
-	])).min(1).optional(),
-	sources: array(OverrideSourceSchema).min(1)
-});
-var SpanSourceDraftSchema = OverrideSourceSchema.extend({ mode: _enum([
-	"in-addition",
-	"confirm",
-	"replace"
-]).optional() });
-discriminatedUnion("kind", [
-	ScalarOverrideDraftSchema,
-	KeyedArrayOverrideDraftSchema,
-	PulseOverrideDraftSchema,
-	object({
-		kind: literal("span"),
-		cap: string().min(1),
-		targetId: string().min(1),
-		timeoutMs: number().nonnegative(),
-		cooldownMs: number().nonnegative().optional(),
-		sources: array(SpanSourceDraftSchema)
-	})
-]);
-object({
-	targetId: string().min(1),
-	configured: boolean(),
-	source: _enum(["native", "assigned"]),
-	state: _enum([
-		"active",
-		"stale",
-		"released",
-		"unavailable"
-	]),
-	reason: string().nullable()
-});
 var G711_SCALE_CORRECTION_DB = {
 	PCMU: 20 * Math.log10(4),
 	PCMA: 20 * Math.log10(8)
@@ -219649,6 +220005,285 @@ async function startLegacyWebhookIntake(deps) {
 	};
 }
 //#endregion
+//#region src/reolink-discovery-map.ts
+/**
+* Flatten a host (IP / hostname) into a flat row-key slug — shared by `generateStableId` and the
+* discovery candidate mapping so a host-keyed camera is detected as already onboarded on re-scan.
+*/
+function slugifyReolinkHost(host) {
+	return host.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+/**
+* Decide whether a discovered host is a device this provider already owns.
+*
+* Matching is by UID first (stable across a DHCP lease change) and by host second. A UID match
+* wins even when the host differs, because the address is the thing that moves.
+*/
+function findOnboardedMatch(discovered, onboarded) {
+	if (discovered.uid !== void 0 && discovered.uid !== "") {
+		const byUid = onboarded.find((o) => o.uid === discovered.uid);
+		if (byUid !== void 0) return byUid;
+	}
+	return onboarded.find((o) => o.host !== void 0 && o.host === discovered.host);
+}
+/** Baichuan control port of an NVR / Home Hub (the scan only ever reports the HTTP/ONVIF one). */
+var HUB_BAICHUAN_PORT = 9e3;
+/**
+* `true` for a model string that names an NVR or a Home Hub: a device that fronts channels
+* rather than being one camera. Such a device is offered as an INTEGRATION to set up (D985), never
+* as a camera to add.
+*/
+function looksLikeReolinkHub(model) {
+	if (model === void 0) return false;
+	return /\b(nvr|rln\d*|home\s*hub|hub)\b/i.test(model);
+}
+/**
+* The stableId of an NVR / Home Hub candidate. UID first (it survives a DHCP lease change), host
+* second. The boot migration derives the SAME id for an old Hub device, so the integration it
+* creates hides this candidate through `originStableId`.
+*/
+function reolinkHubStableId(identity) {
+	const uid = identity.uid?.trim() ?? "";
+	if (uid !== "") return `reolink-hub-uid-${slugifyReolinkHost(uid)}`;
+	return `reolink-hub-host-${slugifyReolinkHost(identity.host)}`;
+}
+function isKnownHub(d, known) {
+	return known.some((k) => k.uid !== void 0 && k.uid !== "" && k.uid === d.uid || k.host !== void 0 && k.host !== "" && k.host === d.host);
+}
+/**
+* Map discovered Reolink hosts to adoption {@link DiscoveryCandidate}s, de-duplicated by host (the
+* same camera can answer on more than one discovery method — UDP broadcast, ONVIF, HTTP scan). The
+* first responder for a host wins. Pure: no I/O.
+*
+* **The scan never supplies `port`.** `port` in the Reolink config schema is the BAICHUAN port
+* (default 9000). Discovery reports `httpPort`, the HTTP/ONVIF listener — on a Reolink Home Hub
+* that is 8000, while Baichuan lives on `mediaPort` 9000. Writing the discovered value into `port`
+* pointed every Baichuan login at the ONVIF listener, which accepts the TCP connection and then
+* closes it: `Baichuan socket closed`, 316 times in 12 hours, taking the hub and all three of its
+* child cameras offline. The default is correct; a non-default Baichuan port is an operator edit,
+* never a scan result.
+*
+* The authoritative stableId is `mac-<mac>` (learned during autodetect at adopt time), which discovery
+* can't produce — so candidates carry `alreadyOnboarded` rather than relying on a stableId match,
+* which never fires for a MAC-keyed device. Re-adding an owned device is how the port got clobbered
+* in the first place, so a scan says so instead of offering it again.
+*/
+function mapReolinkDiscoveryToCandidates(devices, credentials, onboarded = [], hubIntegrations = []) {
+	const username = credentials.username?.trim() ?? "";
+	const password = credentials.password ?? "";
+	const byHost = /* @__PURE__ */ new Map();
+	for (const d of devices) if (!byHost.has(d.host)) byHost.set(d.host, d);
+	return [...byHost.values()].flatMap((d) => {
+		const displayName = d.name ?? d.model ?? d.host;
+		if (looksLikeReolinkHub(d.model)) {
+			if (isKnownHub(d, hubIntegrations)) return [];
+			return [{
+				stableId: reolinkHubStableId(d),
+				type: DeviceType.Gateway,
+				suggestedName: displayName,
+				prefilledConfig: {
+					host: d.host,
+					port: HUB_BAICHUAN_PORT,
+					...d.uid ? { uid: d.uid } : {},
+					...username ? { username } : {}
+				},
+				setupIntegration: true
+			}];
+		}
+		const match = findOnboardedMatch(d, onboarded);
+		return [{
+			stableId: `host-${slugifyReolinkHost(d.host)}`,
+			type: DeviceType.Camera,
+			suggestedName: displayName,
+			prefilledConfig: {
+				name: displayName,
+				host: d.host,
+				transport: "auto",
+				...d.uid ? { uid: d.uid } : {},
+				...username ? { username } : {},
+				...password ? { password } : {}
+			},
+			...match !== void 0 ? {
+				alreadyOnboarded: true,
+				onboardedDeviceId: match.deviceId,
+				onboardedName: match.name
+			} : {}
+		}];
+	});
+}
+//#endregion
+//#region src/reolink-hub-migration.ts
+/**
+* D985 — boot migration of the old Reolink Hub DEVICE into an INTEGRATION.
+*
+* A Hub used to be a device with the NVR's credentials in its config and its channels as
+* parented child cameras. Now the NVR is an integration (credentials in its keychain-backed
+* settings) and the channels are top-level cameras stamped with its id. For every Hub row:
+*
+*   1. create (or reuse) an integration named after it, config + password moved as settings;
+*   2. keep every child's deviceId and stableId, stamp it with the integrationId, un-parent it
+*      and make sure its persisted blob can be restored on its own;
+*   3. only AFTER the children restored and the hub has none left, retire the hub by tombstone.
+*
+* Idempotent (a second run finds no Hub rows) and all-or-nothing per hub: a step that throws
+* leaves the hub device and its children's parentage exactly as they were, and the next boot
+* starts over. A locked secret is never read as an empty password and no replacement is minted.
+*/
+/** The marker an integration carries so a re-run reuses it instead of minting a second one. */
+var MIGRATED_FROM_HUB_KEY = "migratedFromHubDeviceId";
+function positivePort(value) {
+	return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : void 0;
+}
+var CONNECTION_FIELDS = [
+	"host",
+	"port",
+	"username",
+	"transport"
+];
+function str(value) {
+	return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+}
+function migratedChildConfig(child, hub, integrationId) {
+	const filled = {};
+	for (const key of CONNECTION_FIELDS) {
+		const own = child[key];
+		const inherited = hub[key];
+		if ((own === void 0 || own === null || own === "") && inherited !== void 0) filled[key] = inherited;
+	}
+	return {
+		...child,
+		...filled,
+		integrationId
+	};
+}
+async function migrateOneHub(hub, children, integrations, ports) {
+	const read = readHubConnection(hub.config);
+	if (read.kind !== "ok") throw new Error(`hub connection unusable (${read.kind}) — left in place`);
+	const { connection } = read;
+	const uid = str(hub.config["uid"]);
+	const integrationId = integrations.find((i) => i.addonId === ports.addonId && i.info["migratedFromHubDeviceId"] === hub.id)?.id ?? (await ports.createIntegration({
+		addonId: ports.addonId,
+		name: hub.name,
+		info: { ["migratedFromHubDeviceId"]: hub.id },
+		originStableId: reolinkHubStableId({
+			...uid !== void 0 ? { uid } : {},
+			host: connection.host
+		}),
+		settings: {
+			host: connection.host,
+			port: connection.port,
+			rtspPort: positivePort(hub.config["rtspPort"]) ?? connection.rtspPort,
+			username: connection.username,
+			password: connection.password,
+			transport: connection.transport,
+			...uid !== void 0 ? { uid } : {},
+			debugGeneral: connection.debugGeneral,
+			debugSocketLogs: connection.debugSocketLogs
+		},
+		secretKeys: ["password"]
+	})).id;
+	const rewritten = [];
+	for (const child of children) {
+		const config = migratedChildConfig(child.config, hub.config, integrationId);
+		await ports.persistConfig(child.stableId, config);
+		await ports.setIntegrationId(child.id, integrationId);
+		rewritten.push({
+			...child,
+			config,
+			parentDeviceId: null
+		});
+	}
+	return {
+		rows: rewritten,
+		retirement: {
+			hubDeviceId: hub.id,
+			hubName: hub.name,
+			integrationId
+		}
+	};
+}
+/** Plan and persist the migration of every Hub row in `saved`. Never throws. */
+async function planHubMigration(saved, ports) {
+	const hubs = saved.filter((row) => row.type === DeviceType.Hub);
+	if (hubs.length === 0) return {
+		rows: saved,
+		retirements: []
+	};
+	let integrations;
+	try {
+		integrations = await ports.listIntegrations();
+	} catch (err) {
+		ports.logger.warn("Reolink hub migration: integrations unreadable — hubs left in place", { meta: { error: errMsg$3(err) } });
+		return {
+			rows: saved.filter((row) => row.type !== DeviceType.Hub),
+			retirements: []
+		};
+	}
+	const hubIds = new Set(hubs.map((h) => h.id));
+	const rewrittenById = /* @__PURE__ */ new Map();
+	const retirements = [];
+	for (const hub of hubs) {
+		const children = saved.filter((row) => row.parentDeviceId === hub.id);
+		try {
+			const done = await migrateOneHub(hub, children, integrations, ports);
+			for (const row of done.rows) rewrittenById.set(row.id, row);
+			retirements.push(done.retirement);
+			ports.logger.info("Reolink hub migrated to an integration", {
+				tags: { deviceId: hub.id },
+				meta: {
+					integrationId: done.retirement.integrationId,
+					children: children.length,
+					name: hub.name
+				}
+			});
+		} catch (err) {
+			ports.logger.warn("Reolink hub migration failed — the hub device is left in place", {
+				tags: { deviceId: hub.id },
+				meta: {
+					error: errMsg$3(err),
+					name: hub.name
+				}
+			});
+		}
+	}
+	return {
+		rows: saved.filter((row) => !hubIds.has(row.id)).map((row) => rewrittenById.get(row.id) ?? row),
+		retirements
+	};
+}
+/**
+* Retire the hubs whose children all restored. A hub that still has a child in the store is left
+* and named: removing it would cascade the camera away with it.
+*/
+async function retireMigratedHubs(retirements, ports) {
+	let retired = 0;
+	for (const r of retirements) try {
+		const remaining = await ports.childIdsOf(r.hubDeviceId);
+		if (remaining.length > 0) {
+			ports.logger.warn("Reolink hub kept — a child did not restore, retiring it would remove it", {
+				tags: { deviceId: r.hubDeviceId },
+				meta: {
+					remaining: [...remaining],
+					integrationId: r.integrationId
+				}
+			});
+			continue;
+		}
+		await ports.removeDevice(r.hubDeviceId);
+		retired++;
+		ports.logger.info("Reolink hub device retired", {
+			tags: { deviceId: r.hubDeviceId },
+			meta: { integrationId: r.integrationId }
+		});
+	} catch (err) {
+		ports.logger.warn("Reolink hub retirement failed — retried next boot", {
+			tags: { deviceId: r.hubDeviceId },
+			meta: { error: errMsg$3(err) }
+		});
+	}
+	return retired;
+}
+//#endregion
 //#region src/migrations/drop-webhook-intake-settings.ts
 /**
 * The camera webhook is a plane of the addon's HTTP data plane, not a private listener
@@ -219773,6 +220408,18 @@ var REOLINK_MIGRATIONS = [{
 	},
 	plan: planDropWebhookIntakeSettings
 }];
+/**
+* Every persisted camera that names no integration is claimed to the addon's default one. The
+* integration a hub migration created is never the default, so it is not eligible. The integration
+* settings themselves stay where they are until this addon's own wave moves them.
+*/
+var REOLINK_CLAIM_MIGRATION = claimDevicesMigration({
+	addonId: "provider-reolink",
+	date: "2026-11-04",
+	seq: 3,
+	dependsOn: [],
+	eligible: (integration) => integration.info[MIGRATED_FROM_HUB_KEY] === void 0
+});
 //#endregion
 //#region src/reolink-adoption-provider.ts
 var DEVICES_FILTER = {
@@ -219938,113 +220585,6 @@ function buildReolinkAdoptionProvider(deps) {
 	};
 }
 //#endregion
-//#region src/reolink-discovery-map.ts
-/**
-* Flatten a host (IP / hostname) into a flat row-key slug — shared by `generateStableId` and the
-* discovery candidate mapping so a host-keyed camera is detected as already onboarded on re-scan.
-*/
-function slugifyReolinkHost(host) {
-	return host.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-}
-/**
-* Decide whether a discovered host is a device this provider already owns.
-*
-* Matching is by UID first (stable across a DHCP lease change) and by host second. A UID match
-* wins even when the host differs, because the address is the thing that moves.
-*/
-function findOnboardedMatch(discovered, onboarded) {
-	if (discovered.uid !== void 0 && discovered.uid !== "") {
-		const byUid = onboarded.find((o) => o.uid === discovered.uid);
-		if (byUid !== void 0) return byUid;
-	}
-	return onboarded.find((o) => o.host !== void 0 && o.host === discovered.host);
-}
-/** Baichuan control port of an NVR / Home Hub (the scan only ever reports the HTTP/ONVIF one). */
-var HUB_BAICHUAN_PORT = 9e3;
-/**
-* `true` for a model string that names an NVR or a Home Hub: a device that fronts channels
-* rather than being one camera. Such a device is offered as an INTEGRATION to set up (D985), never
-* as a camera to add.
-*/
-function looksLikeReolinkHub(model) {
-	if (model === void 0) return false;
-	return /\b(nvr|rln\d*|home\s*hub|hub)\b/i.test(model);
-}
-/**
-* The stableId of an NVR / Home Hub candidate. UID first (it survives a DHCP lease change), host
-* second. The boot migration derives the SAME id for an old Hub device, so the integration it
-* creates hides this candidate through `originStableId`.
-*/
-function reolinkHubStableId(identity) {
-	const uid = identity.uid?.trim() ?? "";
-	if (uid !== "") return `reolink-hub-uid-${slugifyReolinkHost(uid)}`;
-	return `reolink-hub-host-${slugifyReolinkHost(identity.host)}`;
-}
-function isKnownHub(d, known) {
-	return known.some((k) => k.uid !== void 0 && k.uid !== "" && k.uid === d.uid || k.host !== void 0 && k.host !== "" && k.host === d.host);
-}
-/**
-* Map discovered Reolink hosts to adoption {@link DiscoveryCandidate}s, de-duplicated by host (the
-* same camera can answer on more than one discovery method — UDP broadcast, ONVIF, HTTP scan). The
-* first responder for a host wins. Pure: no I/O.
-*
-* **The scan never supplies `port`.** `port` in the Reolink config schema is the BAICHUAN port
-* (default 9000). Discovery reports `httpPort`, the HTTP/ONVIF listener — on a Reolink Home Hub
-* that is 8000, while Baichuan lives on `mediaPort` 9000. Writing the discovered value into `port`
-* pointed every Baichuan login at the ONVIF listener, which accepts the TCP connection and then
-* closes it: `Baichuan socket closed`, 316 times in 12 hours, taking the hub and all three of its
-* child cameras offline. The default is correct; a non-default Baichuan port is an operator edit,
-* never a scan result.
-*
-* The authoritative stableId is `mac-<mac>` (learned during autodetect at adopt time), which discovery
-* can't produce — so candidates carry `alreadyOnboarded` rather than relying on a stableId match,
-* which never fires for a MAC-keyed device. Re-adding an owned device is how the port got clobbered
-* in the first place, so a scan says so instead of offering it again.
-*/
-function mapReolinkDiscoveryToCandidates(devices, credentials, onboarded = [], hubIntegrations = []) {
-	const username = credentials.username?.trim() ?? "";
-	const password = credentials.password ?? "";
-	const byHost = /* @__PURE__ */ new Map();
-	for (const d of devices) if (!byHost.has(d.host)) byHost.set(d.host, d);
-	return [...byHost.values()].flatMap((d) => {
-		const displayName = d.name ?? d.model ?? d.host;
-		if (looksLikeReolinkHub(d.model)) {
-			if (isKnownHub(d, hubIntegrations)) return [];
-			return [{
-				stableId: reolinkHubStableId(d),
-				type: DeviceType.Gateway,
-				suggestedName: displayName,
-				prefilledConfig: {
-					host: d.host,
-					port: HUB_BAICHUAN_PORT,
-					...d.uid ? { uid: d.uid } : {},
-					...username ? { username } : {}
-				},
-				setupIntegration: true
-			}];
-		}
-		const match = findOnboardedMatch(d, onboarded);
-		return [{
-			stableId: `host-${slugifyReolinkHost(d.host)}`,
-			type: DeviceType.Camera,
-			suggestedName: displayName,
-			prefilledConfig: {
-				name: displayName,
-				host: d.host,
-				transport: "auto",
-				...d.uid ? { uid: d.uid } : {},
-				...username ? { username } : {},
-				...password ? { password } : {}
-			},
-			...match !== void 0 ? {
-				alreadyOnboarded: true,
-				onboardedDeviceId: match.deviceId,
-				onboardedName: match.name
-			} : {}
-		}];
-	});
-}
-//#endregion
 //#region src/reolink-gateway-device.ts
 var reolinkGatewayDeviceSchema = object({
 	integrationId: string().min(1).describe("Integration (hub session) the device belongs to"),
@@ -220201,158 +220741,6 @@ function createReolinkHubManager(deps, registry) {
 		connect: connectReolinkHub
 	});
 }
-function positivePort(value) {
-	return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : void 0;
-}
-var CONNECTION_FIELDS = [
-	"host",
-	"port",
-	"username",
-	"transport"
-];
-function str(value) {
-	return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
-}
-function migratedChildConfig(child, hub, integrationId) {
-	const filled = {};
-	for (const key of CONNECTION_FIELDS) {
-		const own = child[key];
-		const inherited = hub[key];
-		if ((own === void 0 || own === null || own === "") && inherited !== void 0) filled[key] = inherited;
-	}
-	return {
-		...child,
-		...filled,
-		integrationId
-	};
-}
-async function migrateOneHub(hub, children, integrations, ports) {
-	const read = readHubConnection(hub.config);
-	if (read.kind !== "ok") throw new Error(`hub connection unusable (${read.kind}) — left in place`);
-	const { connection } = read;
-	const uid = str(hub.config["uid"]);
-	const integrationId = integrations.find((i) => i.addonId === ports.addonId && i.info["migratedFromHubDeviceId"] === hub.id)?.id ?? (await ports.createIntegration({
-		addonId: ports.addonId,
-		name: hub.name,
-		info: { ["migratedFromHubDeviceId"]: hub.id },
-		originStableId: reolinkHubStableId({
-			...uid !== void 0 ? { uid } : {},
-			host: connection.host
-		}),
-		settings: {
-			host: connection.host,
-			port: connection.port,
-			rtspPort: positivePort(hub.config["rtspPort"]) ?? connection.rtspPort,
-			username: connection.username,
-			password: connection.password,
-			transport: connection.transport,
-			...uid !== void 0 ? { uid } : {},
-			debugGeneral: connection.debugGeneral,
-			debugSocketLogs: connection.debugSocketLogs
-		},
-		secretKeys: ["password"]
-	})).id;
-	const rewritten = [];
-	for (const child of children) {
-		const config = migratedChildConfig(child.config, hub.config, integrationId);
-		await ports.persistConfig(child.stableId, config);
-		await ports.setIntegrationId(child.id, integrationId);
-		rewritten.push({
-			...child,
-			config,
-			parentDeviceId: null
-		});
-	}
-	return {
-		rows: rewritten,
-		retirement: {
-			hubDeviceId: hub.id,
-			hubName: hub.name,
-			integrationId
-		}
-	};
-}
-/** Plan and persist the migration of every Hub row in `saved`. Never throws. */
-async function planHubMigration(saved, ports) {
-	const hubs = saved.filter((row) => row.type === DeviceType.Hub);
-	if (hubs.length === 0) return {
-		rows: saved,
-		retirements: []
-	};
-	let integrations;
-	try {
-		integrations = await ports.listIntegrations();
-	} catch (err) {
-		ports.logger.warn("Reolink hub migration: integrations unreadable — hubs left in place", { meta: { error: errMsg$3(err) } });
-		return {
-			rows: saved.filter((row) => row.type !== DeviceType.Hub),
-			retirements: []
-		};
-	}
-	const hubIds = new Set(hubs.map((h) => h.id));
-	const rewrittenById = /* @__PURE__ */ new Map();
-	const retirements = [];
-	for (const hub of hubs) {
-		const children = saved.filter((row) => row.parentDeviceId === hub.id);
-		try {
-			const done = await migrateOneHub(hub, children, integrations, ports);
-			for (const row of done.rows) rewrittenById.set(row.id, row);
-			retirements.push(done.retirement);
-			ports.logger.info("Reolink hub migrated to an integration", {
-				tags: { deviceId: hub.id },
-				meta: {
-					integrationId: done.retirement.integrationId,
-					children: children.length,
-					name: hub.name
-				}
-			});
-		} catch (err) {
-			ports.logger.warn("Reolink hub migration failed — the hub device is left in place", {
-				tags: { deviceId: hub.id },
-				meta: {
-					error: errMsg$3(err),
-					name: hub.name
-				}
-			});
-		}
-	}
-	return {
-		rows: saved.filter((row) => !hubIds.has(row.id)).map((row) => rewrittenById.get(row.id) ?? row),
-		retirements
-	};
-}
-/**
-* Retire the hubs whose children all restored. A hub that still has a child in the store is left
-* and named: removing it would cascade the camera away with it.
-*/
-async function retireMigratedHubs(retirements, ports) {
-	let retired = 0;
-	for (const r of retirements) try {
-		const remaining = await ports.childIdsOf(r.hubDeviceId);
-		if (remaining.length > 0) {
-			ports.logger.warn("Reolink hub kept — a child did not restore, retiring it would remove it", {
-				tags: { deviceId: r.hubDeviceId },
-				meta: {
-					remaining: [...remaining],
-					integrationId: r.integrationId
-				}
-			});
-			continue;
-		}
-		await ports.removeDevice(r.hubDeviceId);
-		retired++;
-		ports.logger.info("Reolink hub device retired", {
-			tags: { deviceId: r.hubDeviceId },
-			meta: { integrationId: r.integrationId }
-		});
-	} catch (err) {
-		ports.logger.warn("Reolink hub retirement failed — retried next boot", {
-			tags: { deviceId: r.hubDeviceId },
-			meta: { error: errMsg$3(err) }
-		});
-	}
-	return retired;
-}
 //#endregion
 //#region src/reolink-subnet-scan.ts
 /**
@@ -221171,7 +221559,11 @@ var ReolinkProviderAddon = class extends BaseDeviceProvider {
 		this.wireClipCatalogRefreshers();
 		await this.serveClipPlanes(this.clipService);
 		await this.serveWebhookPlane();
-		await this.runMigrations(defineAddonMigrations(REOLINK_MIGRATIONS, this.migrationPorts()));
+		await this.runMigrations([...defineAddonMigrations(REOLINK_MIGRATIONS, this.migrationPorts()), ...defineAddonMigrations([REOLINK_CLAIM_MIGRATION], claimDevicesPortsOver({
+			api: defaultIntegrationApiOver(this.ctx.api),
+			info: (message) => this.ctx.logger.info(message),
+			warnDevice: (message, deviceId) => this.ctx.logger.warn(message, { tags: { deviceId } })
+		}))]);
 		this.wireEmailBridge();
 		const wireSleepPushResolvers = (event, via) => {
 			const data = event.data;