@camstack/addon-import-alexa 0.2.177 → 0.2.179

package/dist/addon.js

@@ -834,7 +834,7 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	return EventCategory;
 }({});
 //#endregion
-//#region ../types/dist/device-type-BOWLtoOt.mjs
+//#region ../types/dist/device-type-CfHw_quR.mjs
 /**
 import { errMsg } from '@camstack/types'
 * Extract a human-readable message from an unknown error value.
@@ -1023,6 +1023,9 @@ var DeviceFeature = /* @__PURE__ */ function(DeviceFeature) {
 	DeviceFeature["CoverPositionable"] = "cover-positionable";
 	/** Cover exposes slat-tilt control. Gates the tilt slider UI. */
 	DeviceFeature["CoverTilt"] = "cover-tilt";
+	/** Cover has a real stop: `stop` halts the travel in place. Gates the stop
+	*  control in exporters; a provider whose `stop` is a no-op never declares it. */
+	DeviceFeature["CoverStoppable"] = "cover-stoppable";
 	/** Valve exposes intermediate position control (0..100). Gates the
 	*  position slider / drag surface UI. */
 	DeviceFeature["ValvePositionable"] = "valve-positionable";
@@ -6035,7 +6038,7 @@ function number(params) {
 	return /* @__PURE__ */ _coercedNumber(ZodNumber, params);
 }
 //#endregion
-//#region ../types/dist/sleep-_4vKNWxb.mjs
+//#region ../types/dist/sleep-hmSP-eJt.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -6152,7 +6155,7 @@ function isKeychainStoredField(field) {
 var SECRET_CLEAR = { $secretClear: true };
 /** The `'***'` token D634 redaction writes for non-admins. */
 var LEGACY_DEVICE_REDACTION = "***";
-function isRecord$6(value) {
+function isRecord$7(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function makeSecretMarker(ref) {
@@ -6163,12 +6166,12 @@ function makeSecretMarker(ref) {
 }
 /** A stored marker: an object whose `$secret` is a non-empty string. */
 function isSecretMarker(value) {
-	if (!isRecord$6(value)) return false;
+	if (!isRecord$7(value)) return false;
 	const ref = value["$secret"];
 	return typeof ref === "string" && ref.length > 0;
 }
 function isSecretClear(value) {
-	return isRecord$6(value) && value["$secretClear"] === true;
+	return isRecord$7(value) && value["$secretClear"] === true;
 }
 /**
 * The UI view of a stored secret field value: a marker becomes "set", inline
@@ -6921,7 +6924,7 @@ var KeychainWriteRefusedError = class extends Error {
 	}
 };
 var KEEP = { kind: "keep" };
-function isRecord$5(value) {
+function isRecord$6(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function defaultMintId() {
@@ -6934,7 +6937,7 @@ function collectSecretMarkerRefs(value, out = []) {
 		return out;
 	}
 	if (Array.isArray(value)) for (const item of value) collectSecretMarkerRefs(item, out);
-	else if (isRecord$5(value)) for (const child of Object.values(value)) collectSecretMarkerRefs(child, out);
+	else if (isRecord$6(value)) for (const child of Object.values(value)) collectSecretMarkerRefs(child, out);
 	return out;
 }
 async function storedValueEquals(secrets, marker, candidate) {
@@ -6989,7 +6992,7 @@ function rowId(row, idKey) {
 	return null;
 }
 async function writeArray(ctx, node, incoming, stored, fieldPath) {
-	const storedRows = Array.isArray(stored) ? stored.filter(isRecord$5) : [];
+	const storedRows = Array.isArray(stored) ? stored.filter(isRecord$6) : [];
 	if (!Array.isArray(incoming)) {
 		ctx.deletes.push(...collectSecretMarkerRefs(storedRows));
 		return {
@@ -7005,7 +7008,7 @@ async function writeArray(ctx, node, incoming, stored, fieldPath) {
 	const kept = /* @__PURE__ */ new Set();
 	const rows = [];
 	for (const row of incoming) {
-		if (!isRecord$5(row)) {
+		if (!isRecord$6(row)) {
 			rows.push(row);
 			continue;
 		}
@@ -7030,7 +7033,7 @@ async function writeNode(ctx, node, incoming, stored, fieldPath) {
 		case "leaf": return writeLeaf(ctx, incoming, stored, fieldPath);
 		case "array": return writeArray(ctx, node, incoming, stored, fieldPath);
 		case "object": {
-			if (!isRecord$5(incoming)) {
+			if (!isRecord$6(incoming)) {
 				if (incoming === void 0) return KEEP;
 				ctx.deletes.push(...collectSecretMarkerRefs(stored));
 				return {
@@ -7038,7 +7041,7 @@ async function writeNode(ctx, node, incoming, stored, fieldPath) {
 					value: incoming
 				};
 			}
-			const storedObj = isRecord$5(stored) ? stored : {};
+			const storedObj = isRecord$6(stored) ? stored : {};
 			return {
 				kind: "value",
 				value: await writeMembers(ctx, node.children, incoming, storedObj, (m) => `${fieldPath}.${m}`)
@@ -7161,7 +7164,7 @@ async function resolveSecretMarkers(value, secrets, options = {}) {
 				value: items
 			};
 		}
-		if (isRecord$5(v)) {
+		if (isRecord$6(v)) {
 			const out = {};
 			for (const [k, child] of Object.entries(v)) {
 				const s = substitute(child);
@@ -7193,7 +7196,7 @@ var SecretOverwriteRefusedError = class extends Error {
 		this.name = "SecretOverwriteRefusedError";
 	}
 };
-function isRecord$4$1(value) {
+function isRecord$5(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function resolvedValue(pass, marker) {
@@ -7222,7 +7225,7 @@ function inArray(pass, incoming, stored) {
 	return incoming.map((item, index) => {
 		const twin = stored[index];
 		if (isSecretMarker(twin)) return typeof item === "string" && item === resolvedValue(pass, twin) ? twin : item;
-		if (isRecord$4$1(item) && isRecord$4$1(twin)) return inArrayRow(pass, item, twin);
+		if (isRecord$5(item) && isRecord$5(twin)) return inArrayRow(pass, item, twin);
 		if (Array.isArray(item) && Array.isArray(twin)) return inArray(pass, item, twin);
 		return item;
 	});
@@ -7233,7 +7236,7 @@ function inArrayRow(pass, incoming, stored) {
 		const twin = stored[key];
 		if (isSecretMarker(twin)) {
 			if (typeof value === "string" && value === resolvedValue(pass, twin)) out[key] = twin;
-		} else if (isRecord$4$1(value) && isRecord$4$1(twin)) out[key] = inArrayRow(pass, value, twin);
+		} else if (isRecord$5(value) && isRecord$5(twin)) out[key] = inArrayRow(pass, value, twin);
 		else if (Array.isArray(value) && Array.isArray(twin)) out[key] = inArray(pass, value, twin);
 	}
 	return out;
@@ -7241,7 +7244,7 @@ function inArrayRow(pass, incoming, stored) {
 async function walk(pass, incoming, stored) {
 	if (isSecretMarker(stored)) return atMarker(pass, incoming, stored);
 	if (Array.isArray(incoming) && Array.isArray(stored)) return inArray(pass, incoming, stored);
-	if (!isRecord$4$1(incoming) || !isRecord$4$1(stored)) return incoming;
+	if (!isRecord$5(incoming) || !isRecord$5(stored)) return incoming;
 	const out = { ...incoming };
 	for (const [key, value] of Object.entries(incoming)) out[key] = await walk(pass, value, stored[key]);
 	return out;
@@ -7272,7 +7275,7 @@ async function restoreUnchangedSecrets(input) {
 function isJsonEqual(a, b) {
 	if (Object.is(a, b)) return true;
 	if (Array.isArray(a)) return Array.isArray(b) && a.length === b.length && a.every((v, i) => isJsonEqual(v, b[i]));
-	if (isRecord$4$1(a) && isRecord$4$1(b)) {
+	if (isRecord$5(a) && isRecord$5(b)) {
 		const keys = Object.keys(a);
 		if (keys.length !== Object.keys(b).length) return false;
 		return keys.every((k) => Object.prototype.hasOwnProperty.call(b, k) && isJsonEqual(a[k], b[k]));
@@ -7296,7 +7299,7 @@ function markerKeysOf(blob, owner) {
 }
 function nodeFromStored(value, owner) {
 	if (isSecretMarker(value)) return isSecretRefOwnedBy(value.$secret, owner) ? { kind: "leaf" } : null;
-	if (!isRecord$4$1(value)) return null;
+	if (!isRecord$5(value)) return null;
 	const children = /* @__PURE__ */ new Map();
 	for (const [key, child] of Object.entries(value)) {
 		const node = nodeFromStored(child, owner);
@@ -7915,6 +7918,44 @@ var BaseAddon = class {
 		return null;
 	}
 	/**
+	* D986 scoped settings: the form shape of the CLUSTER-wide settings one capability this addon
+	* provides owns, or `null` when it has none. `cap` is a capability name the addon's manifest
+	* declares. Stored as `addon-settings` rows `<addonId>.<field>`. The keys of this schema, of
+	* {@link nodeSettingsSchema} and of {@link deviceDefaultsSchema} are disjoint, and a key never
+	* contains `@` (guard `check-scoped-settings-declared`). SHAPE only: values are read by scope.
+	*/
+	async clusterSettingsSchema(_cap) {
+		return null;
+	}
+	/**
+	* D986: the form shape of the settings one capability owns PER NODE, or `null`. Stored as
+	* `addon-settings` rows `<addonId>.<field>@<nodeId>` carrying `nodeId` in the row data, so a
+	* forgotten node's rows go in one central delete.
+	*/
+	async nodeSettingsSchema(_cap) {
+		return null;
+	}
+	/**
+	* D986: the form shape of the FLEET DEFAULTS of the per-device settings one capability owns,
+	* or `null`. Stored as `addon-settings` rows `<addonId>.<field>`; a device resolves its value
+	* as device row, then this default, then the schema default (`resolveDeviceSettings`).
+	*/
+	async deviceDefaultsSchema(_cap) {
+		return null;
+	}
+	/**
+	* The host's read of the scoped declarations: the schema one capability declares for `scope`,
+	* or `null`. Beside {@link getIntegrationFormSchema}, the same shape: the hook is protected, the
+	* host asks this method.
+	*/
+	async getScopedSettingsSchema(scope, cap) {
+		switch (scope) {
+			case "cluster": return this.clusterSettingsSchema(cap);
+			case "node": return this.nodeSettingsSchema(cap);
+			case "device-defaults": return this.deviceDefaultsSchema(cap);
+		}
+	}
+	/**
 	* What the create wizard and the integration edit page render for one instance: the addon's
 	* per-instance schema when it declares one, else its global schema (what they always showed).
 	*/
@@ -8708,47 +8749,6 @@ function normalizeAddonInitResult(result) {
 	if (Array.isArray(result)) return { providers: result };
 	return result;
 }
-/**
-* The share-view scope kinds a share-link token can carry. The hub mints
-* and validates them (`ShareViewGrantSchema` builds its
-* enum from this list); a data plane names the kinds it ACCEPTS in `share`.
-*/
-var SHARE_VIEW_KINDS = ["grid-view", "events-view"];
-/** The wire shape of {@link PeerBytesTicket} — see the type for what it is. */
-var PeerBytesTicketSchema = object({
-	/** `http://127.0.0.1:<port>/<token>`. One `GET` takes it. */
-	url: string().min(1),
-	/**
-	* The HOST node this URL means something on — the hub or a named agent,
-	* never a runner. {@link AddonPeerBytes.open} compares it to its own and
-	* refuses `cross-node` by name when they differ, without dialling.
-	*/
-	hostNodeId: string().min(1),
-	expiresAtMs: number$1().int().nonnegative(),
-	/**
-	* What the producer DECLARED the body to be, when it knows — `null` when it
-	* does not. Never `0` for unknown (D393): a consumer sizing a bound off this
-	* must be able to tell "the producer did not say" from "the body is empty".
-	*/
-	declaredBytes: number$1().int().nonnegative().nullable()
-});
-/** Limits and names of `ctx.records` (D881). One authority; the engine and the facade read it. */
-/** The files a kind may live in. `history` is device-history's (D850), never records. */
-var RECORD_DATABASES = ["settings", "events"];
-/** The classes of a kind: the `@durable` vocabulary, one authority (replaces the annotation). */
-var RECORD_CLASSES = [
-	"config",
-	"ledger",
-	"audit",
-	"mirror",
-	"ephemeral"
-];
-var RECORD_DEFAULT_MAX_DATA_BYTES = 64 * 1024;
-var RECORD_MAX_DATA_BYTES = 1024 * 1024;
-var RECORD_BATCH_MAX = 1e3;
-var RECORD_QUERY_MAX = 1e3;
-/** A kind in the `settings` file may not bound itself above this (D447: high volume is `events`). */
-var RECORD_SETTINGS_MAX_ROWS = 5e4;
 var PREFIX = "records/";
 /** The base of every records failure. `detail` is the human part of the message. */
 var RecordsError = class extends Error {
@@ -8781,6 +8781,83 @@ var DeclarationRefusedError = class extends RecordsError {
 		this.name = "DeclarationRefusedError";
 	}
 };
+/** Limits and names of `ctx.records` (D881). One authority; the engine and the facade read it. */
+/** The files a kind may live in. `history` is device-history's (D850), never records. */
+var RECORD_DATABASES = ["settings", "events"];
+/** The classes of a kind: the `@durable` vocabulary, one authority (replaces the annotation). */
+var RECORD_CLASSES = [
+	"config",
+	"ledger",
+	"audit",
+	"mirror",
+	"ephemeral"
+];
+var RECORD_DEFAULT_MAX_DATA_BYTES = 64 * 1024;
+var RECORD_MAX_DATA_BYTES = 1024 * 1024;
+var RECORD_BATCH_MAX = 1e3;
+var RECORD_QUERY_MAX = 1e3;
+/** A kind in the `settings` file may not bound itself above this (D447: high volume is `events`). */
+var RECORD_SETTINGS_MAX_ROWS = 5e4;
+/**
+* Secret fields of a record, addressed the way a Zod schema declares them
+* (`collectZodSecretPaths`): dotted keys, `[]` for "each element of this array"
+* (`auth.accessToken`, `headers[].value`).
+*
+* Array elements are matched by a DECLARED id key (`secretArrayKeys`:
+* `{ headers: 'name' }`), never by index, so reordering a list keeps every
+* keychain ref (the same rule as `arrayItemFieldPath`). The concrete path of a
+* leaf names its element: `headers[X-Api].value`.
+*
+* Pure and browser-safe. Nothing here mutates: every transform returns a new value.
+*/
+/** The array prefixes (declared form, e.g. `headers` or `a.headers`) of a path. */
+function parseSecretPath(path) {
+	if (path.length === 0) throw new InvalidRecordError("an empty secret path");
+	return path.split(".").map((raw) => {
+		const each = raw.endsWith("[]");
+		const key = each ? raw.slice(0, -2) : raw;
+		if (key.length === 0) throw new InvalidRecordError(`secret path "${path}" has an empty segment`);
+		return {
+			key,
+			each
+		};
+	});
+}
+/** The declared array prefixes of `path` that need an id key (`headers`, `a.rows`). */
+function secretArrayPrefixes(path) {
+	const segments = parseSecretPath(path);
+	const prefixes = [];
+	const walked = [];
+	for (const segment of segments) {
+		walked.push(segment.key);
+		if (segment.each) prefixes.push(walked.join("."));
+	}
+	return prefixes;
+}
+/**
+* The share-view scope kinds a share-link token can carry. The hub mints
+* and validates them (`ShareViewGrantSchema` builds its
+* enum from this list); a data plane names the kinds it ACCEPTS in `share`.
+*/
+var SHARE_VIEW_KINDS = ["grid-view", "events-view"];
+/** The wire shape of {@link PeerBytesTicket} — see the type for what it is. */
+var PeerBytesTicketSchema = object({
+	/** `http://127.0.0.1:<port>/<token>`. One `GET` takes it. */
+	url: string().min(1),
+	/**
+	* The HOST node this URL means something on — the hub or a named agent,
+	* never a runner. {@link AddonPeerBytes.open} compares it to its own and
+	* refuses `cross-node` by name when they differ, without dialling.
+	*/
+	hostNodeId: string().min(1),
+	expiresAtMs: number$1().int().nonnegative(),
+	/**
+	* What the producer DECLARED the body to be, when it knows — `null` when it
+	* does not. Never `0` for unknown (D393): a consumer sizing a bound off this
+	* must be able to tell "the producer did not say" from "the body is empty".
+	*/
+	declaredBytes: number$1().int().nonnegative().nullable()
+});
 function defOf(schema) {
 	const zodBag = Reflect.get(schema, "_zod");
 	if (typeof zodBag !== "object" || zodBag === null) return {};
@@ -8849,42 +8926,6 @@ function collectZodSecretPaths(schema, prefix = "") {
 	return [...new Set(paths)];
 }
 /**
-* Secret fields of a record, addressed the way a Zod schema declares them
-* (`collectZodSecretPaths`): dotted keys, `[]` for "each element of this array"
-* (`auth.accessToken`, `headers[].value`).
-*
-* Array elements are matched by a DECLARED id key (`secretArrayKeys`:
-* `{ headers: 'name' }`), never by index, so reordering a list keeps every
-* keychain ref (the same rule as `arrayItemFieldPath`). The concrete path of a
-* leaf names its element: `headers[X-Api].value`.
-*
-* Pure and browser-safe. Nothing here mutates: every transform returns a new value.
-*/
-/** The array prefixes (declared form, e.g. `headers` or `a.headers`) of a path. */
-function parseSecretPath(path) {
-	if (path.length === 0) throw new InvalidRecordError("an empty secret path");
-	return path.split(".").map((raw) => {
-		const each = raw.endsWith("[]");
-		const key = each ? raw.slice(0, -2) : raw;
-		if (key.length === 0) throw new InvalidRecordError(`secret path "${path}" has an empty segment`);
-		return {
-			key,
-			each
-		};
-	});
-}
-/** The declared array prefixes of `path` that need an id key (`headers`, `a.rows`). */
-function secretArrayPrefixes(path) {
-	const segments = parseSecretPath(path);
-	const prefixes = [];
-	const walked = [];
-	for (const segment of segments) {
-		walked.push(segment.key);
-		if (segment.each) prefixes.push(walked.join("."));
-	}
-	return prefixes;
-}
-/**
 * Record kinds (D881): the declaration an addon makes of one kind of fact, the
 * Zod row schema that describes it, and the helper that turns the two into the
 * JSON the engine stores.
@@ -9724,6 +9765,7 @@ var CAP_NAMES = Object.freeze([
 	"backup",
 	"battery",
 	"binary",
+	"board-key-source",
 	"brightness",
 	"broker",
 	"button",
@@ -9766,6 +9808,7 @@ var CAP_NAMES = Object.freeze([
 	"device-status",
 	"dishwasher",
 	"display-palette",
+	"do-not-disturb",
 	"doorbell",
 	"embedding-encoder",
 	"enum-sensor",
@@ -9786,6 +9829,7 @@ var CAP_NAMES = Object.freeze([
 	"humidity-sensor",
 	"image",
 	"image-settings",
+	"integration-instances",
 	"integrations",
 	"intercom",
 	"ir-transmitter",
@@ -9843,6 +9887,7 @@ var CAP_NAMES = Object.freeze([
 	"privacy-mask",
 	"ptz",
 	"ptz-autotrack",
+	"pump-cycle",
 	"reboot",
 	"record-entries",
 	"recording",
@@ -10525,6 +10570,10 @@ Object.freeze({
 			"valueType": "string"
 		}
 	],
+	"do-not-disturb": [{
+		"path": "enabled",
+		"valueType": "boolean"
+	}],
 	"doorbell": [{
 		"path": "lastPressedAt",
 		"valueType": "number"
@@ -11131,18 +11180,6 @@ Object.freeze({
 			"path": "pumpRunning",
 			"valueType": "boolean"
 		},
-		{
-			"path": "pumpIntervalEnabled",
-			"valueType": "boolean"
-		},
-		{
-			"path": "pumpOnTime",
-			"valueType": "number"
-		},
-		{
-			"path": "pumpOffTime",
-			"valueType": "number"
-		},
 		{
 			"path": "lastDrink",
 			"valueType": "number"
@@ -11266,6 +11303,20 @@ Object.freeze({
 			"valueType": "number"
 		}
 	],
+	"pump-cycle": [
+		{
+			"path": "enabled",
+			"valueType": "boolean"
+		},
+		{
+			"path": "onTime",
+			"valueType": "number"
+		},
+		{
+			"path": "offTime",
+			"valueType": "number"
+		}
+	],
 	"recording-archive": [
 		{
 			"path": "deviceId",
@@ -11715,7 +11766,7 @@ object({
 	params: record(string(), union([string(), number$1()])).optional()
 });
 //#endregion
-//#region ../types/dist/composition-kKKOdFIG.mjs
+//#region ../types/dist/composition-Dh3RfMx5.mjs
 /**
 * The ffmpeg build every CamStack node downloads, per platform and arch.
 *
@@ -12929,6 +12980,73 @@ var NodeColorIdSchema = _enum([
 	"node-g",
 	"node-h"
 ]);
+//#endregion
+//#region ../types/dist/index.mjs
+var SMTP_INBOUND_DEFAULT_PORT = 2525;
+var SMTP_INBOUND_DEFAULT_DOMAIN = "camstack.local";
+var SMTP_INBOUND_DEFAULT_MAX_MESSAGE_BYTES = 25 * 1024 * 1024;
+/** The text excerpt a message carries on the bus. */
+var SMTP_INBOUND_TEXT_MAX_CHARS = 4096;
+var PortSchema = number$1().int().min(1).max(65535);
+/** A recipient local-part: what stands before the `@`. */
+var SmtpRecipientSchema = string().min(1).max(64).regex(/^[A-Za-z0-9._+-]+$/);
+object({
+	port: PortSchema.default(SMTP_INBOUND_DEFAULT_PORT),
+	bindHost: string().min(1).default("0.0.0.0"),
+	domain: string().min(1).default(SMTP_INBOUND_DEFAULT_DOMAIN),
+	requireAuth: boolean().default(true),
+	username: string().default(""),
+	password: string().default("").meta({ secret: true }),
+	starttls: boolean().default(false),
+	maxMessageBytes: number$1().int().positive().default(SMTP_INBOUND_DEFAULT_MAX_MESSAGE_BYTES)
+});
+object({
+	host: string().min(1).nullable(),
+	hostReason: string().nullable(),
+	port: PortSchema,
+	domain: string().min(1),
+	requireAuth: boolean(),
+	username: string(),
+	password: string(),
+	starttls: boolean()
+});
+object({
+	recipients: array(SmtpRecipientSchema).min(1),
+	/**
+	* Who is subscribing. A second `subscribe` with the same id REPLACES that subscriber's
+	* recipients (the way a consumer that restarted, or lost a device, declares its set again);
+	* a recipient held by another subscriber is refused with `smtp-inbound/recipient-claimed`.
+	* Absent, the subscriber is anonymous and unique.
+	*/
+	subscriberId: string().min(1).max(64).optional()
+});
+var SmtpInboundAttachmentSchema = object({
+	filename: string(),
+	contentType: string(),
+	bytes: number$1().int().nonnegative()
+});
+/** The payload of one `broker.message` (the key is the recipient local-part). */
+var SmtpInboundMessageSchema = object({
+	/** Monotonic per mailbox; a gap tells a consumer it missed an event. */
+	seq: number$1().int().positive(),
+	messageId: string(),
+	receivedAt: number$1().int().nonnegative(),
+	from: string(),
+	to: string(),
+	subject: string(),
+	text: string().max(SMTP_INBOUND_TEXT_MAX_CHARS),
+	attachments: array(SmtpInboundAttachmentSchema)
+});
+object({
+	/** The newest seq issued so far (0 before any mail). */
+	lastSeq: number$1().int().nonnegative(),
+	/** The oldest seq still retained; messages below it are gone. */
+	oldestSeq: number$1().int().nonnegative(),
+	messages: array(object({
+		key: string(),
+		message: SmtpInboundMessageSchema
+	}))
+});
 new Set([
 	"track",
 	"face",
@@ -16088,8 +16206,18 @@ var LogChannelDescriptorSchema = object({
 	* the operator narrows to one camera, sees nothing, and concludes the code
 	* path was never taken.
 	*/
-	perDevice: boolean()
-});
+	perDevice: boolean(),
+	/**
+	* What the channel is FOR, so the UI can list the channels an addon offers.
+	*
+	* - `diagnostic` (the default): a per-component diagnostic armed from the
+	*   Levels page, emitted at its declared level.
+	* - `debug`: a `debug.<channel>` dump watched live for a short window
+	*   (`ctx.debug`). Always per-device, and its lines are denied by the log
+	*   ring unless somebody is watching that device.
+	*/
+	kind: _enum(["diagnostic", "debug"]).default("diagnostic")
+}).refine((d) => d.kind !== "debug" || d.name.startsWith("debug.") && d.perDevice, { message: "a debug channel is named debug.<channel> and is per-device" });
 /**
 * An armed window over one channel, as the document hands it to a mirror.
 *
@@ -19308,24 +19436,52 @@ var APPLIANCE_CAP_VOCABULARY = {
 				args: { on: false }
 			},
 			{
-				id: "petFountain.intervalOn",
-				method: "setPumpInterval",
+				id: "petFountain.resetDailyConsumption",
+				method: "resetDailyConsumption",
+				label: t("Clear daily consumption", "Azzera il consumo giornaliero"),
+				phrase: t("Clear the daily water consumption of {device}", "Azzera il consumo giornaliero di acqua di {device}"),
+				icon: "rotate-ccw"
+			}
+		],
+		state: [{
+			kind: "boolean",
+			field: "empty",
+			label: t("Tank empty", "Serbatoio vuoto"),
+			whenTrue: t("When the tank of {device} is empty", "Quando il serbatoio di {device} è vuoto"),
+			whenFalse: t("When the tank of {device} is refilled", "Quando il serbatoio di {device} viene riempito"),
+			icon: "droplet"
+		}, {
+			kind: "numeric",
+			field: "waterLevel",
+			quantity: t("the water level", "il livello dell’acqua"),
+			label: t("Water level", "Livello dell’acqua"),
+			unit: "%",
+			icon: "droplets"
+		}]
+	},
+	"pump-cycle": {
+		scope: "device",
+		noun: t("Pump cycle", "Ciclo della pompa"),
+		actions: [
+			{
+				id: "pumpCycle.on",
+				method: "setEnabled",
 				label: t("Pump cycle on", "Ciclo pompa attivo"),
 				phrase: t("Run the pump of {device} on its on/off cycle", "Fai lavorare la pompa di {device} a ciclo acceso/spento"),
 				icon: "timer",
 				args: { on: true }
 			},
 			{
-				id: "petFountain.intervalOff",
-				method: "setPumpInterval",
+				id: "pumpCycle.off",
+				method: "setEnabled",
 				label: t("Pump cycle off", "Ciclo pompa spento"),
 				phrase: t("Run the pump of {device} continuously", "Fai lavorare la pompa di {device} in continuo"),
 				icon: "timer-off",
 				args: { on: false }
 			},
 			{
-				id: "petFountain.pumpOnMinutes",
-				method: "setPumpOnMinutes",
+				id: "pumpCycle.onMinutes",
+				method: "setOnMinutes",
 				label: t("Set pump run time", "Imposta il tempo di lavoro della pompa"),
 				phrase: t("Set the pump of {device} to run {minutes} minutes per cycle", "Imposta la pompa di {device} a lavorare {minutes} minuti per ciclo"),
 				icon: "timer",
@@ -19341,8 +19497,8 @@ var APPLIANCE_CAP_VOCABULARY = {
 				}]
 			},
 			{
-				id: "petFountain.pumpOffMinutes",
-				method: "setPumpOffMinutes",
+				id: "pumpCycle.offMinutes",
+				method: "setOffMinutes",
 				label: t("Set pump rest time", "Imposta il tempo di riposo della pompa"),
 				phrase: t("Set the pump of {device} to rest {minutes} minutes per cycle", "Imposta la pompa di {device} a riposare {minutes} minuti per ciclo"),
 				icon: "timer-off",
@@ -19356,29 +19512,15 @@ var APPLIANCE_CAP_VOCABULARY = {
 						unit: "min"
 					}
 				}]
-			},
-			{
-				id: "petFountain.resetDailyConsumption",
-				method: "resetDailyConsumption",
-				label: t("Clear daily consumption", "Azzera il consumo giornaliero"),
-				phrase: t("Clear the daily water consumption of {device}", "Azzera il consumo giornaliero di acqua di {device}"),
-				icon: "rotate-ccw"
 			}
 		],
 		state: [{
 			kind: "boolean",
-			field: "empty",
-			label: t("Tank empty", "Serbatoio vuoto"),
-			whenTrue: t("When the tank of {device} is empty", "Quando il serbatoio di {device} è vuoto"),
-			whenFalse: t("When the tank of {device} is refilled", "Quando il serbatoio di {device} viene riempito"),
-			icon: "droplet"
-		}, {
-			kind: "numeric",
-			field: "waterLevel",
-			quantity: t("the water level", "il livello dell’acqua"),
-			label: t("Water level", "Livello dell’acqua"),
-			unit: "%",
-			icon: "droplets"
+			field: "enabled",
+			label: t("Pump cycle", "Ciclo pompa"),
+			whenTrue: t("When {device} starts running its pump on a cycle", "Quando {device} inizia a far lavorare la pompa a ciclo"),
+			whenFalse: t("When {device} runs its pump continuously", "Quando {device} fa lavorare la pompa in continuo"),
+			icon: "timer"
 		}]
 	},
 	"media-player": {
@@ -20064,6 +20206,33 @@ var APPLIANCE_CAP_VOCABULARY = {
 			}
 		]
 	},
+	"do-not-disturb": {
+		scope: "device",
+		noun: t("Do not disturb", "Non disturbare"),
+		actions: [{
+			id: "dnd.on",
+			method: "setEnabled",
+			label: t("Do not disturb on", "Attiva Non disturbare"),
+			phrase: t("Turn on Do not disturb on {device}", "Attiva Non disturbare su {device}"),
+			icon: "bell-off",
+			args: { enabled: true }
+		}, {
+			id: "dnd.off",
+			method: "setEnabled",
+			label: t("Do not disturb off", "Disattiva Non disturbare"),
+			phrase: t("Turn off Do not disturb on {device}", "Disattiva Non disturbare su {device}"),
+			icon: "bell",
+			args: { enabled: false }
+		}],
+		state: [{
+			kind: "boolean",
+			field: "enabled",
+			label: t("Do not disturb", "Non disturbare"),
+			whenTrue: t("When Do not disturb turns on on {device}", "Quando {device} attiva Non disturbare"),
+			whenFalse: t("When Do not disturb turns off on {device}", "Quando {device} disattiva Non disturbare"),
+			icon: "bell-off"
+		}]
+	},
 	update: {
 		scope: "device",
 		noun: t("Firmware update", "Aggiornamento firmware"),
@@ -21244,6 +21413,7 @@ var SYSTEM_CAP_VOCABULARY = {
 	"audio-analyzer": system(PIPELINE),
 	"audio-codec": system(INTERNAL),
 	"auth-provider": system(IDENTITY),
+	"board-key-source": system(INTERNAL),
 	backup: system("system backups — run and restored from the Backups page"),
 	broker: system("message-broker connections — configured, not actuated"),
 	"calendar-source": system(INTERNAL),
@@ -21278,6 +21448,7 @@ var SYSTEM_CAP_VOCABULARY = {
 	"load-contribution": system(INTERNAL),
 	"local-network": system(NETWORK),
 	"log-channels": system(INTERNAL),
+	"integration-instances": system(INTERNAL),
 	"log-destination": system(INTERNAL),
 	"login-method": system(IDENTITY),
 	"mesh-network": system(NETWORK),
@@ -42180,14 +42351,16 @@ var DeviceIsLeafSchema = object({
 });
 /**
 * True when the camera currently has a PARKED object matching `subjects` in at
-* least one of `zones`. Reads the zone-analytics snapshot through the same
+* least one of `zones` (`minCount` of them, default one). Reads the zone-analytics snapshot through the same
 * mirror as every other state leaf, so a dropped event never decides it (D49).
 */
 var StationaryPresentLeafSchema = object({
 	kind: literal("stationary-present"),
 	deviceId: number$1().int().nonnegative(),
 	subjects: array(StationarySubjectSchema).min(1).optional(),
-	zones: array(string().min(1)).min(1).optional()
+	zones: array(string().min(1)).min(1).optional(),
+	/** How many matching parked objects must be there; absent means one. */
+	minCount: number$1().int().positive().optional()
 });
 /**
 * The escape hatch: the bounded expression engine over named device bindings.
@@ -42699,6 +42872,28 @@ function convertLegacyRecipe(legacy) {
 * it. The output type is always the new one.
 */
 var AutomationRecipeSchema = union([CurrentAutomationRecipeSchema, LegacyAutomationRecipeSchema.transform(convertLegacyRecipe)]);
+var DETECTION_DESCRIPTIONS = {
+	deviceId: "the camera that saw it",
+	className: "what it saw",
+	trackId: "the track",
+	score: "how sure the detector was",
+	label: "the label it matched (a name, a plate), empty when none"
+};
+var STATIONARY_DESCRIPTIONS = {
+	deviceId: "the camera that saw it",
+	className: "what it saw",
+	zones: "the zones it is in",
+	phase: "appeared or departed",
+	entryId: "the stopped object"
+};
+function describe$1(descriptions) {
+	return Object.entries(descriptions).map(([name, description]) => ({
+		name,
+		description
+	}));
+}
+describe$1(DETECTION_DESCRIPTIONS);
+describe$1(STATIONARY_DESCRIPTIONS);
 new Set(Object.values(COCO_TO_MACRO.mapping));
 /**
 * Schedulers (D983) — an entity that performs actions over the day.
@@ -43460,7 +43655,7 @@ var TargetKindCapsSchema = object({
 * the union is large and not meant for runtime validation here; the exported
 * `TargetKind` type re-tightens `configSchema` to `ConfigUISchema`.
 */
-var ConfigSchemaPassthrough$3 = unknown();
+var ConfigSchemaPassthrough$4 = unknown();
 var TargetKindSchema = object({
 	kind: string(),
 	label: string(),
@@ -43497,7 +43692,7 @@ var TargetKindSchema = object({
 	* its raster path, which is the safe default for an unknown image.
 	*/
 	iconMediaType: string().optional(),
-	configSchema: ConfigSchemaPassthrough$3,
+	configSchema: ConfigSchemaPassthrough$4,
 	/**
 	* The config keys that decide WHERE this kind's secrets are sent (server,
 	* base URL, instance, chat, recipient). A save that changes any of them
@@ -46169,6 +46364,49 @@ var binaryCapability = {
 	volatileStateFields: ["lastChangedAt"]
 };
 /**
+* Why a board key could not be read. Typed so a caller reports the cause and
+* never treats "could not read" as "has no key" (D49).
+*/
+var BoardKeyFailureReasonSchema = _enum([
+	"unknown-source",
+	"not-admin",
+	"no-builder",
+	"no-ingress-url",
+	"unreachable",
+	"unknown-board",
+	"no-encryption-key",
+	"unreadable-config"
+]);
+var BoardKeySourceSchema = object({
+	sourceId: string(),
+	name: string()
+});
+var BoardKeyBoardSchema = object({
+	/** The builder's file name, e.g. `kitchen.yaml`: the handle `getBoardKey` takes. */
+	configuration: string(),
+	/** The node name the builder gives the board. */
+	name: string(),
+	/** The address the builder knows the board by, when it has one. */
+	address: string().nullable()
+});
+var BoardKeyFailureSchema = object({
+	ok: literal(false),
+	reason: BoardKeyFailureReasonSchema,
+	detail: string().optional()
+});
+var ListBoardsResultSchema = discriminatedUnion("ok", [object({
+	ok: literal(true),
+	boards: array(BoardKeyBoardSchema).readonly()
+}), BoardKeyFailureSchema]);
+var GetBoardKeyResultSchema = discriminatedUnion("ok", [object({
+	ok: literal(true),
+	key: string()
+}), BoardKeyFailureSchema]);
+method(_void(), array(BoardKeySourceSchema).readonly(), { auth: "admin" }), method(object({ sourceId: string().min(1) }), ListBoardsResultSchema, { auth: "admin" }), method(object({
+	sourceId: string().min(1),
+	configuration: string().min(1)
+}), GetBoardKeyResultSchema, { auth: "admin" });
+/**
 * Dimmable-light brightness control. Co-exists with `switch` on the
 * same device — the switch toggles on/off, this cap sets the level
 * applied when the light is on. Drivers map their per-vendor dim
@@ -51202,6 +51440,45 @@ var deviceProviderCapability = {
 	}
 };
 /**
+* What the passive listener of `local-network` saw on the wire, before any
+* provider classified it. Device-manager turns an observation into the hits
+* of the providers whose declared discovery modes it matches.
+*/
+var DiscoveryObservationSchema = discriminatedUnion("kind", [object({
+	kind: literal("mdns"),
+	/** Normalised DNS-SD service type, e.g. `_esphomelib._tcp`. */
+	serviceType: string(),
+	instance: string(),
+	host: string(),
+	/** The A record address when the announcement carried one. */
+	address: string().nullable(),
+	port: number$1().int(),
+	txt: record(string(), string())
+}), object({
+	kind: literal("ssdp"),
+	/** Sender address of the datagram. */
+	host: string(),
+	port: number$1().int(),
+	/** `NT` of a NOTIFY, `ST` of a search response. */
+	target: string(),
+	headers: record(string(), string())
+})]);
+object({
+	addonId: string(),
+	candidate: DiscoveryCandidateSchema,
+	firstSeenAt: number$1(),
+	lastSeenAt: number$1(),
+	dismissed: boolean()
+});
+var DiscoveryProposalSchema = object({
+	id: string(),
+	addonId: string(),
+	candidate: DiscoveryCandidateSchema,
+	firstSeenAt: number$1(),
+	lastSeenAt: number$1(),
+	dismissed: boolean()
+});
+/**
 * Device Manager capability — hub-side singleton that unifies device persistence,
 * live registry access, and all management operations into a single tRPC surface.
 *
@@ -51930,6 +52207,19 @@ method(object({
 }), object({ candidates: array(DiscoveryCandidateSchema).readonly() }), {
 	kind: "mutation",
 	auth: "admin"
+}), method(object({}), object({ proposals: array(DiscoveryProposalSchema).readonly() }), { auth: "admin" }), method(object({ id: string() }), object({ dismissed: boolean() }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ observations: array(DiscoveryObservationSchema).max(512) }), object({ proposed: number$1().int() }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({}), object({
+	providers: number$1().int(),
+	proposed: number$1().int()
+}), {
+	kind: "mutation",
+	auth: "admin",
+	timeoutMs: 12e4
 }), method(object({ addonId: string() }), object({ deviceType: _enum(DeviceType).nullable() }), { auth: "admin" }), method(object({ addonId: string() }), unknown(), { auth: "admin" }), method(object({
 	deviceId: number$1(),
 	key: string(),
@@ -52786,7 +53076,7 @@ var DishwasherStatusSchema = object({
 	/** Ms epoch of the last value received from the appliance; 0 = never. */
 	lastFetchedAt: number$1()
 });
-var DeviceIdSchema$1 = number$1().int().nonnegative();
+var DeviceIdSchema$2 = number$1().int().nonnegative();
 /** A value a program option or setting can take. */
 var DishwasherValueSchema = union([
 	boolean(),
@@ -52861,77 +53151,77 @@ var dishwasherCapability = {
 		* option feature keys; each is checked against the program's constraints.
 		*/
 		start: method(object({
-			deviceId: DeviceIdSchema$1,
+			deviceId: DeviceIdSchema$2,
 			program: string().min(1).optional(),
 			options: record(string(), DishwasherValueSchema).optional()
 		}), _void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
-		pause: method(object({ deviceId: DeviceIdSchema$1 }), _void(), {
+		pause: method(object({ deviceId: DeviceIdSchema$2 }), _void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
-		resume: method(object({ deviceId: DeviceIdSchema$1 }), _void(), {
+		resume: method(object({ deviceId: DeviceIdSchema$2 }), _void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
-		stop: method(object({ deviceId: DeviceIdSchema$1 }), _void(), {
+		stop: method(object({ deviceId: DeviceIdSchema$2 }), _void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
 		/** Select (not start) a program; refused when the appliance does not offer it. */
 		setProgram: method(object({
-			deviceId: DeviceIdSchema$1,
+			deviceId: DeviceIdSchema$2,
 			program: string().min(1)
 		}), _void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
 		setPower: method(object({
-			deviceId: DeviceIdSchema$1,
+			deviceId: DeviceIdSchema$2,
 			on: boolean()
 		}), _void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
 		setHalfLoad: method(object({
-			deviceId: DeviceIdSchema$1,
+			deviceId: DeviceIdSchema$2,
 			on: boolean()
 		}), _void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
 		setHygienePlus: method(object({
-			deviceId: DeviceIdSchema$1,
+			deviceId: DeviceIdSchema$2,
 			on: boolean()
 		}), _void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
 		setExtraDry: method(object({
-			deviceId: DeviceIdSchema$1,
+			deviceId: DeviceIdSchema$2,
 			on: boolean()
 		}), _void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
 		setIntensiveZone: method(object({
-			deviceId: DeviceIdSchema$1,
+			deviceId: DeviceIdSchema$2,
 			on: boolean()
 		}), _void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
 		setVarioSpeedPlus: method(object({
-			deviceId: DeviceIdSchema$1,
+			deviceId: DeviceIdSchema$2,
 			on: boolean()
 		}), _void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
 		setChildLock: method(object({
-			deviceId: DeviceIdSchema$1,
+			deviceId: DeviceIdSchema$2,
 			on: boolean()
 		}), _void(), {
 			kind: "mutation",
@@ -52943,7 +53233,7 @@ var dishwasherCapability = {
 		* its declared range / members.
 		*/
 		setOption: method(object({
-			deviceId: DeviceIdSchema$1,
+			deviceId: DeviceIdSchema$2,
 			key: string().min(1),
 			value: DishwasherValueSchema
 		}), _void(), {
@@ -52951,7 +53241,7 @@ var dishwasherCapability = {
 			auth: "protected"
 		}),
 		/** What this appliance can do, from its own description — the UI is derived from it. */
-		getOptions: method(object({ deviceId: DeviceIdSchema$1 }), DishwasherOptionsSchema, { auth: "protected" })
+		getOptions: method(object({ deviceId: DeviceIdSchema$2 }), DishwasherOptionsSchema, { auth: "protected" })
 	},
 	status: {
 		schema: DishwasherStatusSchema,
@@ -53379,6 +53669,49 @@ method(_void(), paletteResultSchema, {
 	kind: "mutation",
 	auth: "admin"
 });
+/**
+* do-not-disturb - whether a speaker or display holds back its own sounds
+* (announcements, notifications, alarms) until the operator lets it speak again.
+*
+* It is NOT part of `media-player`: a player is about what it plays and how
+* loud, while Do Not Disturb is a household switch the vendor keeps per device.
+* `enabled` is null when the vendor has not said (never a guess of `false`).
+*/
+var DoNotDisturbStatusSchema = object({
+	/** True while Do Not Disturb is on; null when unknown. */
+	enabled: boolean().nullable().meta({ label: "Do not disturb" }),
+	/** Ms epoch of the last read or write that set `enabled`. */
+	lastChangedAt: number$1()
+});
+var doNotDisturbCapability = {
+	name: "do-not-disturb",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: [DeviceType.MediaPlayer],
+	methods: { setEnabled: method(object({
+		deviceId: number$1().int(),
+		enabled: boolean()
+	}), _void(), {
+		kind: "mutation",
+		auth: "protected"
+	}) },
+	status: {
+		schema: DoNotDisturbStatusSchema,
+		kind: "push"
+	},
+	runtimeState: DoNotDisturbStatusSchema,
+	/**
+	* Runtime-state durability: **session** - the vendor owns the switch and the
+	* device re-reads it on the next poll, so a restored value would only be stale.
+	*
+	* See `RuntimeStateDurability`. Enforced by
+	* `scripts/check-runtime-state-durability.ts`.
+	*/
+	durability: "session",
+	/** History (D850): when Do Not Disturb was switched on and off. */
+	history: { fields: { enabled: { kind: "boolean" } } }
+};
 /** Pulse override: a rising edge advances `lastPressedAt` and the press count. */
 var doorbellCustomize = {
 	version: 1,
@@ -55231,6 +55564,89 @@ method(_void(), array(IntegrationWithStateSchema)), method(object({ id: string()
 	auth: "admin"
 });
 /**
+* `integration-instances` - the connection of an addon that holds ONE or SEVERAL
+* (an account, a relay, a destination) as typed records (D985, D986). The addon's
+* own function page reads and writes them (Logging for Loki); the Integrations
+* page lists only the integrations that bring devices (D996).
+*
+* A collection of providers: each addon that holds connections registers one and a
+* caller reaches a provider with the pinned `addonId`.
+*
+* Identity: the instance id is immutable and opaque to the caller. A record the
+* Loki migration made keeps the `integrations` registry id it was created under
+* (`int_NNNN`); a single instance made by its function page takes the addon id.
+* `name` is the editable label.
+*
+* Secrets: every field the instance kind marks `.meta({ secret: true })` reaches
+* the form as a `SecretFieldView`, never text (D789). A patch value omitted, `''`
+* or the redaction token KEEPS the stored secret; `{ $secretClear: true }`
+* clears it.
+*/
+var ConfigSchemaPassthrough$3 = custom();
+var IntegrationInstanceIdSchema = string().min(1);
+var IntegrationInstanceDescriptionSchema = object({
+	/** `single`: at most one instance can exist (Loki). `multiple`: an account each. */
+	instanceMode: _enum(["single", "multiple"]),
+	/** What the instance is, for the UI (`destination`, `relay`, `account`). */
+	kind: string(),
+	/** True when `testInstance` really probes the remote. */
+	canTest: boolean()
+});
+var IntegrationInstanceStatusSchema = object({
+	state: _enum([
+		"ok",
+		"off",
+		"error",
+		"unknown"
+	]),
+	detail: string().optional()
+});
+var IntegrationInstanceSchema = object({
+	id: IntegrationInstanceIdSchema,
+	name: string(),
+	/** 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).
+	*/
+	enabled: boolean(),
+	/** Values for the instance form; a secret is a `SecretFieldView`, never text. */
+	formValues: record(string(), unknown()),
+	status: IntegrationInstanceStatusSchema.optional()
+});
+var IntegrationInstancePatchSchema = object({
+	id: IntegrationInstanceIdSchema,
+	name: string().min(1).optional(),
+	/** Omitted / '' / redaction token keeps a secret; `{ $secretClear: true }` clears it. */
+	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)
+}), object({ id: string() }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(IntegrationInstancePatchSchema, object({ ok: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	id: IntegrationInstanceIdSchema,
+	enabled: boolean()
+}), object({ ok: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ id: IntegrationInstanceIdSchema }), object({ ok: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
+}), optionalMethod(object({
+	id: IntegrationInstanceIdSchema.nullable(),
+	values: record(string(), unknown())
+}), TestConnectionResultSchema$1, {
+	kind: "mutation",
+	auth: "admin"
+});
+/**
 * Two-way audio / talk-back cap. Clients open a WebRTC audio-only
 * session (server-initiated offer pattern, identical to the main
 * video WebRTC flow) and the browser captures the mic; the server
@@ -55970,6 +56386,14 @@ var LlmGenerateBaseInputSchema = object({
 	topP: number$1().min(0).max(1).optional(),
 	/** Per-call override of the profile default (top-k sampling). */
 	topK: number$1().int().positive().optional(),
+	/** Per-call override of `profile.reasoningEffort`. Sent only to a kind whose
+	*  descriptor offers the field; a kind that does not never sends it. */
+	reasoningEffort: _enum([
+		"off",
+		"low",
+		"medium",
+		"high"
+	]).optional(),
 	/** Per-call override of `profile.timeoutMs` — the total generation bound. */
 	timeoutMs: number$1().int().positive().optional(),
 	/** Per-call override; beats both the consumer table and the profile. */
@@ -56261,7 +56685,10 @@ var LlmProfileKindSchema = string().regex(/^[a-z0-9][a-z0-9-]{0,63}$/, "a kind i
 var LlmModelFeaturesSchema = object({
 	vision: boolean(),
 	tools: boolean(),
-	streaming: boolean()
+	streaming: boolean(),
+	/** Whether the model thinks before it answers. `null` = the endpoint does not
+	*  say; an editor then still offers the switch (unknown is not "no"). */
+	reasoning: boolean().nullable().optional()
 });
 /** One model a provider offers. `features` overrides the kind's defaults, per field. */
 var LlmModelInfoSchema = object({
@@ -65987,7 +66414,14 @@ var NcMediaPolicySchema = object({
 	*/
 	profile: CamProfileSchema.optional(),
 	/** See {@link NcLinkedCameraModeSchema}. */
-	linkedCameras: NcLinkedCameraModeSchema.optional()
+	linkedCameras: NcLinkedCameraModeSchema.optional(),
+	/**
+	* Sensor rules only: may this rule wake a SLEEPING battery camera to take
+	* the linked still it attaches (D998)? Absent means yes, an explicit `false`
+	* opts out. Deliberately not a Zod default: a rule that never chose keeps
+	* following the hub's. One bounded wake per event; nothing is attached later.
+	*/
+	wakeSleepingCamera: boolean().optional()
 });
 /**
 * Cooldown GRANULARITY over the subject's class — how much a fired
@@ -68130,7 +68564,7 @@ var petFeederCapability = {
 /**
 * Pet water-fountain cap. Models the telemetry and the control surface of a
 * circulating drinking fountain: how much water is in the tank, how much the
-* pet drank, whether the pump runs and on what duty cycle.
+* pet drank, whether the pump runs.
 *
 * It has no native vendor provider of its own: a fountain reaches CamStack as
 * a container of loose entities (a pump switch, two number boxes, a "filter
@@ -68146,8 +68580,10 @@ var petFeederCapability = {
 * never here. Every reading may be `null`: a source that is offline or does
 * not report is unknown, never zero.
 *
-* The filter is not a field of this cap: it is an item of the `consumables`
-* cap on the same device (kind `wear`), reset by the same forward mechanism.
+* The pump's on/off duty cycle is model-specific and lives in the optional
+* `pump-cycle` cap. The filter, the cleaning and the water change are not
+* fields of this cap: they are items of the `consumables` cap on the same
+* device (kind `wear`), reset by the same forward mechanism.
 */
 var PetFountainStatusSchema = object({
 	/** Water in the tank, 0..100 (%). Null while the source has not reported. */
@@ -68158,27 +68594,20 @@ var PetFountainStatusSchema = object({
 	empty: boolean().nullable(),
 	/** True while the pump is running. Null while unknown. */
 	pumpRunning: boolean().nullable(),
-	/** True when the pump works on an on/off duty cycle rather than continuously. */
-	pumpIntervalEnabled: boolean().nullable(),
-	/** How long the pump runs per cycle, in seconds. */
-	pumpOnTime: number$1().min(0).nullable().meta(readingMeta("duration")),
-	/** How long the pump rests per cycle, in seconds. */
-	pumpOffTime: number$1().min(0).nullable().meta(readingMeta("duration")),
 	/** Water drunk in the last drink, in litres. */
 	lastDrink: number$1().min(0).nullable().meta(readingMeta("volume")),
 	/** Water drunk in the current hour, in litres. */
 	currentHourDrink: number$1().min(0).nullable().meta(readingMeta("volume")),
 	/** Water drunk over the last 24 hours (rolling), in litres. */
 	last24hDrink: number$1().min(0).nullable().meta(readingMeta("volume")),
-	/** Water drunk since local midnight, in litres. */
+	/** Water drunk since local midnight, in litres. Null when the fountain has no such sensor. */
 	todayDrink: number$1().min(0).nullable().meta(readingMeta("volume")),
 	/** Decoded fault message. Null means healthy; a non-null string is an active fault. */
 	error: string().nullable(),
 	/** Ms epoch when the slice was last refreshed. */
 	lastFetchedAt: number$1()
 });
-var DeviceIdSchema = number$1().int().nonnegative();
-var MinutesSchema = number$1().int().min(0);
+var DeviceIdSchema$1 = number$1().int().nonnegative();
 var petFountainCapability = {
 	name: "pet-fountain",
 	scope: "device",
@@ -68188,38 +68617,14 @@ var petFountainCapability = {
 	methods: {
 		/** Start or stop the pump. */
 		setPump: method(object({
-			deviceId: DeviceIdSchema,
-			on: boolean()
-		}), _void(), {
-			kind: "mutation",
-			auth: "protected"
-		}),
-		/** Switch the on/off duty cycle on or off (off = the pump runs continuously). */
-		setPumpInterval: method(object({
-			deviceId: DeviceIdSchema,
+			deviceId: DeviceIdSchema$1,
 			on: boolean()
 		}), _void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
-		/** Set how many minutes the pump runs per cycle. */
-		setPumpOnMinutes: method(object({
-			deviceId: DeviceIdSchema,
-			minutes: MinutesSchema
-		}), _void(), {
-			kind: "mutation",
-			auth: "protected"
-		}),
-		/** Set how many minutes the pump rests per cycle. */
-		setPumpOffMinutes: method(object({
-			deviceId: DeviceIdSchema,
-			minutes: MinutesSchema
-		}), _void(), {
-			kind: "mutation",
-			auth: "protected"
-		}),
 		/** Clear the rolling daily consumption counters on the device. */
-		resetDailyConsumption: method(object({ deviceId: DeviceIdSchema }), _void(), {
+		resetDailyConsumption: method(object({ deviceId: DeviceIdSchema$1 }), _void(), {
 			kind: "mutation",
 			auth: "protected"
 		})
@@ -70552,6 +70957,79 @@ var ptzAutotrackCapability = {
 	*/
 	history: "none"
 };
+/**
+* The on/off duty cycle of a pet fountain's pump. Some models run the pump
+* continuously and have nothing to configure; others can alternate a run time
+* and a rest time. That is model-specific, so it is its own optional cap on the
+* fountain device: a fountain without cycle entities simply never composes it
+* (planning#366), and the `pet-fountain` cap stays the model-independent core.
+*
+* Like `pet-fountain` it has no native vendor provider: an operator BUILDS the
+* cycle from loose entities (a cycle switch and two number boxes) and every
+* method is a forward to one source entity (D659, D967). Durations are stored
+* in SECONDS (D944); a number box that cannot be read back leaves them `null`
+* — unknown, never zero (D393).
+*/
+var PumpCycleStatusSchema = object({
+	/** True when the pump works on the on/off cycle, false when it runs continuously. Null while unknown. */
+	enabled: boolean().nullable(),
+	/** How long the pump runs per cycle, in seconds. Null while unknown. */
+	onTime: number$1().min(0).nullable().meta(readingMeta("duration")),
+	/** How long the pump rests per cycle, in seconds. Null while unknown. */
+	offTime: number$1().min(0).nullable().meta(readingMeta("duration")),
+	/** Ms epoch when the slice was last refreshed. */
+	lastFetchedAt: number$1()
+});
+var DeviceIdSchema = number$1().int().nonnegative();
+var MinutesSchema = number$1().int().min(0);
+var pumpCycleCapability = {
+	name: "pump-cycle",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: [DeviceType.PetFountain],
+	methods: {
+		/** Switch the on/off duty cycle on or off (off = the pump runs continuously). */
+		setEnabled: method(object({
+			deviceId: DeviceIdSchema,
+			on: boolean()
+		}), _void(), {
+			kind: "mutation",
+			auth: "protected"
+		}),
+		/** Set how many minutes the pump runs per cycle. */
+		setOnMinutes: method(object({
+			deviceId: DeviceIdSchema,
+			minutes: MinutesSchema
+		}), _void(), {
+			kind: "mutation",
+			auth: "protected"
+		}),
+		/** Set how many minutes the pump rests per cycle. */
+		setOffMinutes: method(object({
+			deviceId: DeviceIdSchema,
+			minutes: MinutesSchema
+		}), _void(), {
+			kind: "mutation",
+			auth: "protected"
+		})
+	},
+	status: {
+		schema: PumpCycleStatusSchema,
+		kind: "push"
+	},
+	/** Runtime-state slice — mirrored by the kernel; the hero card reads it whole. */
+	runtimeState: PumpCycleStatusSchema,
+	/**
+	* Runtime-state durability: **session** — live appliance state re-published on connect.
+	*
+	* See `RuntimeStateDurability`. Enforced by
+	* `scripts/check-runtime-state-durability.ts`.
+	*/
+	durability: "session",
+	/** History (D850): a duty-cycle setting is not a series worth recording. */
+	history: "none"
+};
 DeviceType.Camera, DeviceType.Sensor, DeviceType.Switch, DeviceType.Gateway, method(object({ deviceId: number$1().int().nonnegative() }), object({ success: literal(true) }), {
 	kind: "mutation",
 	auth: "admin"
@@ -74447,9 +74925,17 @@ var ServerUpdateActionResultSchema = object({
 	*/
 	requiredAddonUpdates: array(RequiredAddonUpdateSchema).optional()
 });
-var LaunchOverridesSchema = object({ 
-/** The persisted heap ceiling in MB, or `null` when none is set. */
-heapMb: number$1().int().nullable() });
+var LaunchOverridesSchema = object({
+	/** The persisted heap ceiling in MB, or `null` when none is set. */
+	heapMb: number$1().int().nullable(),
+	/** The persisted hub-main RSS budget in MB, or `null` when none is set. */
+	rssBudgetMb: number$1().int().nullable()
+});
+var SetLaunchOverridesInputSchema = object({
+	heapMb: number$1().int().min(512).max(65536).nullable(),
+	/** Omitted keeps the stored budget; `null` clears it. */
+	rssBudgetMb: number$1().int().min(512).max(65536).nullable().optional()
+});
 var SetLaunchOverridesResultSchema = LaunchOverridesSchema.extend({ 
 /** Always true: the override is read at launch, not by the running process. */
 restartRequired: boolean() });
@@ -74478,7 +74964,7 @@ method(_void(), ServerPackageStatusSchema, { auth: "admin" }), method(_void(), S
 }), method(_void(), ServerUpdateActionResultSchema, {
 	kind: "mutation",
 	auth: "admin"
-}), method(_void(), LaunchOverridesSchema, { auth: "admin" }), method(object({ heapMb: number$1().int().min(512).max(65536).nullable() }), SetLaunchOverridesResultSchema, {
+}), method(_void(), LaunchOverridesSchema, { auth: "admin" }), method(SetLaunchOverridesInputSchema, SetLaunchOverridesResultSchema, {
 	kind: "mutation",
 	auth: "admin"
 });
@@ -74536,7 +75022,16 @@ var smokeCapability = {
 * future fields without breaking the existing call sites.
 */
 var EmailAddressSchema = email();
+/**
+* Which relay of a multi-relay provider answers (D996). Absent = the provider's first / default
+* relay, so a caller written before relays existed keeps working unchanged. A provider with one
+* fixed relay ignores it. This is the integration instance id (`int_NNNN`), NOT the addon id: the
+* collection pin `addonId` still picks the provider, `instanceId` picks the relay inside it.
+*/
+var InstanceIdSchema = string().min(1).optional();
+var RelayPinSchema = object({ instanceId: InstanceIdSchema });
 var SendEmailInputSchema = object({
+	instanceId: InstanceIdSchema,
 	to: union([EmailAddressSchema, array(EmailAddressSchema).min(1)]),
 	cc: array(EmailAddressSchema).optional(),
 	bcc: array(EmailAddressSchema).optional(),
@@ -74572,11 +75067,11 @@ method(SendEmailInputSchema, SendEmailResultSchema, {
 	kind: "mutation",
 	auth: "admin",
 	access: "create"
-}), method(_void(), SmtpStatusSchema, {
+}), method(RelayPinSchema, SmtpStatusSchema, {
 	kind: "mutation",
 	auth: "admin",
 	access: "view"
-}), method(_void(), SmtpStatusSchema, { auth: "admin" });
+}), method(RelayPinSchema, SmtpStatusSchema, { auth: "admin" });
 /**
 * A single device snapshot returned as base64 JPEG/PNG.
 *
@@ -74608,10 +75103,12 @@ DeviceType.Camera, method(object({
 	* even when the cache is well within the device's
 	* `snapshotMaxAgeS` window.
 	*
-	* **`force` is an OPERATOR signal, not a freshness preference.** On a
+	* **`force` is a demand with a named principal, not a freshness
+	* preference** — an operator button, the scheduled refresh (D847), or a
+	* notification rule that left the camera's wake allowed (D998). On a
 	* battery camera it is the one thing that walks past the wrapper's
-	* sleep gate and wakes the camera, so a background caller — a poller,
-	* an event handler, a thumbnail — must NEVER set it. Every such caller
+	* sleep gate and wakes the camera, so a poller, a thumbnail or a
+	* prestream must NEVER set it. Every such caller
 	* gets the cached frame, which on a sleeping battery camera is the
 	* correct answer: stale but honest beats woken.
 	*/
@@ -76181,6 +76678,40 @@ var LoggingSettingsStateSchema = object({
 	opsLogRetentionDays: number$1().int().min(0),
 	persisted: boolean()
 });
+/**
+* Debug WATCH — a short, per-device window over `debug.<channel>` lines.
+*
+* `start` opens (or re-arms) a 10 minute window; `rearm` extends a LIVE one
+* and never revives a lapsed one; `stop` closes it; `list` only reads. No
+* chain of re-arms outlives 60 minutes from the first start. The hub holds the
+* watches in memory and pushes the interest to every node, so a watch lapses
+* by itself and survives nothing — a restart is a stop.
+*/
+var DebugWatchInputSchema = object({
+	action: _enum([
+		"list",
+		"start",
+		"rearm",
+		"stop"
+	]),
+	/** Full channel names, `debug.<channel>`, each declared with `kind: 'debug'`. */
+	channels: array(string().min(1)).readonly().default([]),
+	/** Numeric device ids. Required (non-empty) for `start`. */
+	deviceIds: array(number$1().int()).readonly().default([])
+});
+var DebugWatchStateSchema = object({
+	channel: string(),
+	deviceIds: array(number$1().int()).readonly(),
+	startedAtMs: number$1(),
+	untilMs: number$1(),
+	capAtMs: number$1()
+});
+var DebugWatchResultSchema = object({
+	nowMs: number$1(),
+	watches: array(DebugWatchStateSchema).readonly(),
+	/** Channels a `rearm` found already lapsed: nothing was revived. */
+	lapsed: array(string()).readonly()
+});
 method(_void(), SystemInfoSchema), method(_void(), HealthStatusSchema), method(_void(), FeatureManifestSchema), method(_void(), array(NetworkAddressSchema).readonly()), method(_void(), unknown().nullable(), { auth: "admin" }), method(record(string(), unknown()), _null(), {
 	kind: "mutation",
 	auth: "admin"
@@ -76196,6 +76727,9 @@ method(_void(), SystemInfoSchema), method(_void(), HealthStatusSchema), method(_
 }), method(_void(), RequestCensusStatusSchema, { auth: "admin" }), method(_void(), array(ReportedLoadContributionSchema).readonly(), { auth: "admin" }), method(_void(), array(ReportedFailureContributionSchema).readonly(), { auth: "admin" }), method(GetLoggingSettingsInputSchema, LoggingSettingsStateSchema, { auth: "admin" }), method(SetLoggingSettingsInputSchema, LoggingSettingsStateSchema, {
 	kind: "mutation",
 	auth: "admin"
+}), method(DebugWatchInputSchema, DebugWatchResultSchema, {
+	kind: "mutation",
+	auth: "admin"
 });
 /**
 * Tamper / case-open detection sensor. Drives Home Assistant
@@ -79261,7 +79795,7 @@ discriminatedUnion("kind", [object({
 	kind: literal("pronto"),
 	code: string()
 })]);
-DeviceFeature.FanSpeed, DeviceFeature.FanPreset, DeviceFeature.FanDirection, DeviceFeature.FanOscillating, DeviceFeature.CoverPositionable, DeviceFeature.CoverTilt, DeviceFeature.ValvePositionable, DeviceFeature.MediaPlayerVolume, DeviceFeature.ClimateFanMode;
+DeviceFeature.FanSpeed, DeviceFeature.FanPreset, DeviceFeature.FanDirection, DeviceFeature.FanOscillating, DeviceFeature.CoverStoppable, DeviceFeature.CoverPositionable, DeviceFeature.CoverTilt, DeviceFeature.ValvePositionable, DeviceFeature.MediaPlayerVolume, DeviceFeature.ClimateFanMode;
 SOURCE_CAPS.filter((cap) => cap !== "switch" && cap !== "motion");
 String.raw`rose\(active(\d+), changed(\d+), (\d+(?:\.\d+)?)\)`;
 DeviceRole.BinarySensor, DeviceRole.MotionSensor;
@@ -79584,6 +80118,7 @@ var DEVICE_LOCAL_STATE_CAPS = {
 	deviceDiscovery: deviceDiscoveryCapability,
 	deviceStatus: deviceStatusCapability,
 	dishwasher: dishwasherCapability,
+	doNotDisturb: doNotDisturbCapability,
 	doorbell: doorbellCapability,
 	enumSensor: enumSensorCapability,
 	eventEmitter: eventEmitterCapability,
@@ -79620,6 +80155,7 @@ var DEVICE_LOCAL_STATE_CAPS = {
 	pressureSensor: pressureSensorCapability,
 	privacyMask: privacyMaskCapability,
 	ptzAutotrack: ptzAutotrackCapability,
+	pumpCycle: pumpCycleCapability,
 	recordingOnboard: recordingOnboardCapability,
 	recordingSignal: recordingSignalCapability,
 	runningState: runningStateCapability,
@@ -81804,6 +82340,27 @@ Object.freeze({
 		access: "view",
 		role: "viewer"
 	},
+	"boardKeySource.getBoardKey": {
+		capName: "board-key-source",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
+	"boardKeySource.listBoards": {
+		capName: "board-key-source",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
+	"boardKeySource.listSources": {
+		capName: "board-key-source",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
 	"brightness.getStatus": {
 		capName: "brightness",
 		capScope: "device",
@@ -83141,6 +83698,13 @@ Object.freeze({
 		access: "view",
 		role: "admin"
 	},
+	"deviceManager.dismissDiscoveryProposal": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "create",
+		role: "admin"
+	},
 	"deviceManager.enable": {
 		capName: "device-manager",
 		capScope: "system",
@@ -83323,6 +83887,13 @@ Object.freeze({
 		access: "view",
 		role: "viewer"
 	},
+	"deviceManager.listDiscoveryProposals": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
 	"deviceManager.listLocationDescriptions": {
 		capName: "device-manager",
 		capScope: "system",
@@ -83477,6 +84048,13 @@ Object.freeze({
 		access: "create",
 		role: "admin"
 	},
+	"deviceManager.reportDiscoveryObservations": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "create",
+		role: "admin"
+	},
 	"deviceManager.runDeviceAction": {
 		capName: "device-manager",
 		capScope: "system",
@@ -83484,6 +84062,13 @@ Object.freeze({
 		access: "create",
 		role: "admin"
 	},
+	"deviceManager.runDiscoverySweep": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "create",
+		role: "admin"
+	},
 	"deviceManager.setChildLayout": {
 		capName: "device-manager",
 		capScope: "system",
@@ -84037,6 +84622,20 @@ Object.freeze({
 		access: "create",
 		role: "admin"
 	},
+	"doNotDisturb.getStatus": {
+		capName: "do-not-disturb",
+		capScope: "device",
+		addonId: null,
+		access: "view",
+		role: "viewer"
+	},
+	"doNotDisturb.setEnabled": {
+		capName: "do-not-disturb",
+		capScope: "device",
+		addonId: null,
+		access: "create",
+		role: "viewer"
+	},
 	"doorbell.getStatus": {
 		capName: "doorbell",
 		capScope: "device",
@@ -84401,6 +85000,69 @@ Object.freeze({
 		access: "create",
 		role: "admin"
 	},
+	"integrationInstances.createInstance": {
+		capName: "integration-instances",
+		capScope: "system",
+		addonId: null,
+		access: "create",
+		role: "admin"
+	},
+	"integrationInstances.deleteInstance": {
+		capName: "integration-instances",
+		capScope: "system",
+		addonId: null,
+		access: "delete",
+		role: "admin"
+	},
+	"integrationInstances.describe": {
+		capName: "integration-instances",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
+	"integrationInstances.getInstance": {
+		capName: "integration-instances",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
+	"integrationInstances.instanceFormSchema": {
+		capName: "integration-instances",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
+	"integrationInstances.listInstances": {
+		capName: "integration-instances",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
+	"integrationInstances.setInstanceEnabled": {
+		capName: "integration-instances",
+		capScope: "system",
+		addonId: null,
+		access: "create",
+		role: "admin"
+	},
+	"integrationInstances.testInstance": {
+		capName: "integration-instances",
+		capScope: "system",
+		addonId: null,
+		access: "create",
+		role: "admin"
+	},
+	"integrationInstances.updateInstance": {
+		capName: "integration-instances",
+		capScope: "system",
+		addonId: null,
+		access: "create",
+		role: "admin"
+	},
 	"integrations.create": {
 		capName: "integrations",
 		capScope: "system",
@@ -86522,27 +87184,6 @@ Object.freeze({
 		access: "create",
 		role: "viewer"
 	},
-	"petFountain.setPumpInterval": {
-		capName: "pet-fountain",
-		capScope: "device",
-		addonId: null,
-		access: "create",
-		role: "viewer"
-	},
-	"petFountain.setPumpOffMinutes": {
-		capName: "pet-fountain",
-		capScope: "device",
-		addonId: null,
-		access: "create",
-		role: "viewer"
-	},
-	"petFountain.setPumpOnMinutes": {
-		capName: "pet-fountain",
-		capScope: "device",
-		addonId: null,
-		access: "create",
-		role: "viewer"
-	},
 	"pipelineAnalytics.addRetrainFrameFromRecording": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -88321,6 +88962,34 @@ Object.freeze({
 		access: "create",
 		role: "admin"
 	},
+	"pumpCycle.getStatus": {
+		capName: "pump-cycle",
+		capScope: "device",
+		addonId: null,
+		access: "view",
+		role: "viewer"
+	},
+	"pumpCycle.setEnabled": {
+		capName: "pump-cycle",
+		capScope: "device",
+		addonId: null,
+		access: "create",
+		role: "viewer"
+	},
+	"pumpCycle.setOffMinutes": {
+		capName: "pump-cycle",
+		capScope: "device",
+		addonId: null,
+		access: "create",
+		role: "viewer"
+	},
+	"pumpCycle.setOnMinutes": {
+		capName: "pump-cycle",
+		capScope: "device",
+		addonId: null,
+		access: "create",
+		role: "viewer"
+	},
 	"reboot.reboot": {
 		capName: "reboot",
 		capScope: "device",
@@ -90057,6 +90726,13 @@ Object.freeze({
 		access: "create",
 		role: "viewer"
 	},
+	"system.debugWatch": {
+		capName: "system",
+		capScope: "system",
+		addonId: null,
+		access: "create",
+		role: "admin"
+	},
 	"system.detectSiteLocation": {
 		capName: "system",
 		capScope: "system",
@@ -92225,6 +92901,16 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"doNotDisturb.getStatus": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"doNotDisturb.setEnabled": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"doorbell.getStatus": [{
 		name: "deviceId",
 		form: "single",
@@ -92848,21 +93534,6 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
-	"petFountain.setPumpInterval": [{
-		name: "deviceId",
-		form: "single",
-		optional: false
-	}],
-	"petFountain.setPumpOffMinutes": [{
-		name: "deviceId",
-		form: "single",
-		optional: false
-	}],
-	"petFountain.setPumpOnMinutes": [{
-		name: "deviceId",
-		form: "single",
-		optional: false
-	}],
 	"pipelineAnalytics.addRetrainFrameFromRecording": [{
 		name: "deviceId",
 		form: "single",
@@ -93498,6 +94169,26 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"pumpCycle.getStatus": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pumpCycle.setEnabled": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pumpCycle.setOffMinutes": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"pumpCycle.setOnMinutes": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"reboot.reboot": [{
 		name: "deviceId",
 		form: "single",
@@ -93965,6 +94656,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"system.debugWatch": [{
+		name: "deviceIds",
+		form: "array",
+		optional: true
+	}],
 	"tamper.getStatus": [{
 		name: "deviceId",
 		form: "single",
@@ -140380,6 +141076,13 @@ var ALEXA_BROKER_KIND = "alexa";
 var DEVICE_REFRESH_MS = 5 * 6e4;
 /** Where the addon serves the Alexa mark; `listTargetKinds` stamps it as `iconUrl`. */
 var ALEXA_SPEAK_ICON_URL = `/addon/${ALEXA_SPEAK_ADDON_ID}/icons/${ALEXA_SPEAK_KIND}`;
+/** How often an adopted Echo's player state is read (a push channel is a later phase). */
+var ECHO_POLL_MS = 3e4;
+/** One more read after a command, once Amazon has had time to apply it. */
+var ECHO_REREAD_MS = 1500;
+/** After a 429 the account is left alone for this long, doubling up to the cap. */
+var ECHO_RATE_BACKOFF_BASE_MS = 3e4;
+var ECHO_RATE_BACKOFF_MAX_MS = 5 * 6e4;
 //#endregion
 //#region src/alexa-broker-provider.ts
 /**
@@ -140419,7 +141122,7 @@ function buildAlexaBrokerProvider(deps) {
 				label: "Alexa",
 				signIn: {
 					basePath: "/addon/import-alexa/login",
-					methods: ["device-code"]
+					methods: ["device-code", "proxy"]
 				}
 			}]
 		}],
@@ -140609,6 +141312,37 @@ function buildAlexaApplianceCandidate(input) {
 function mappableAppliance(appliance) {
 	return mapAlexaCapabilitiesToCamStack(appliance.interfaces).capabilities.length > 0;
 }
+/** `echo:<serial>`: how an Echo is named among an account's adoption candidates. */
+var ECHO_NATIVE_ID_PREFIX = "echo:";
+function echoNativeId(serial) {
+	return `${ECHO_NATIVE_ID_PREFIX}${serial}`;
+}
+/** The serial an Echo candidate id names, or null when the id is not an Echo's. */
+function echoSerialOf(childNativeId) {
+	if (!childNativeId.startsWith("echo:")) return null;
+	const serial = childNativeId.slice(5);
+	return serial === "" ? null : serial;
+}
+/** An Echo the adoption list offers: a media player, a flat sibling under the Alexa integration. */
+function isAdoptableEcho(device) {
+	return device.kind === "device";
+}
+function buildAlexaEchoCandidate(input) {
+	const { device, adoptedDeviceId } = input;
+	return {
+		childNativeId: echoNativeId(device.id),
+		name: device.name.length > 0 ? device.name : device.id,
+		type: DeviceType.MediaPlayer,
+		status: device.online ? "online" : "offline",
+		metadata: {
+			manufacturer: "Amazon",
+			...device.room !== void 0 ? { externalLocation: device.room } : {}
+		},
+		alreadyAdopted: adoptedDeviceId !== null,
+		adoptedDeviceId,
+		capabilities: ["media-player", "do-not-disturb"]
+	};
+}
 //#endregion
 //#region src/alexa-adoption-provider.ts
 /** Single granularity: each Alexa appliance adopts as one device. */
@@ -140622,6 +141356,11 @@ async function adoptedApplianceId(brokerId, applianceId, listAdoptedAlexa) {
 	for (const d of await listAdoptedAlexa()) if (d.config["system"] === "alexa" && d.config["brokerId"] === brokerId && d.config["applianceId"] === applianceId) return d.id;
 	return null;
 }
+/** Resolve the adopted CamStack device id for a (broker, Echo serial), or null. */
+async function adoptedEchoId(brokerId, serial, listAdoptedAlexa) {
+	for (const d of await listAdoptedAlexa()) if (d.config["system"] === "alexa" && d.config["brokerId"] === brokerId && d.config["serial"] === serial) return d.id;
+	return null;
+}
 /**
 * Construct the `device-adoption` cap provider for the Alexa import addon. Pure
 * builder. One broker = one Amazon account; each mappable appliance is a flat
@@ -140629,7 +141368,7 @@ async function adoptedApplianceId(brokerId, applianceId, listAdoptedAlexa) {
 * Container fan-out — Alexa appliances are standalone devices).
 */
 function buildAlexaAdoptionProvider(deps) {
-	const { registry, getBrokerIdForIntegration, listAdoptedAlexa, adoptAppliance, removeDevice, findDeviceConfig, logger } = deps;
+	const { registry, getBrokerIdForIntegration, listAdoptedAlexa, adoptAppliance, adoptEcho, removeDevice, findDeviceConfig, logger } = deps;
 	async function candidatesForBroker(brokerId) {
 		const appliances = registry.getAppliancesForBroker(brokerId).filter(mappableAppliance);
 		const out = [];
@@ -140640,6 +141379,13 @@ function buildAlexaAdoptionProvider(deps) {
 				adoptedDeviceId
 			}));
 		}
+		for (const device of registry.getEchoesForBroker(brokerId).filter(isAdoptableEcho)) {
+			const adoptedDeviceId = await adoptedEchoId(brokerId, device.id, listAdoptedAlexa);
+			out.push(buildAlexaEchoCandidate({
+				device,
+				adoptedDeviceId
+			}));
+		}
 		return out;
 	}
 	return {
@@ -140694,7 +141440,41 @@ function buildAlexaAdoptionProvider(deps) {
 			const appliances = registry.getAppliancesForBroker(brokerId);
 			const adopted = [];
 			let failures = 0;
+			const echoes = registry.getEchoesForBroker(brokerId);
 			for (const nativeId of childNativeIds) {
+				const echoSerial = echoSerialOf(nativeId);
+				if (echoSerial !== null) {
+					const echo = echoes.find((device) => device.id === echoSerial && isAdoptableEcho(device));
+					if (echo === void 0) {
+						logger.warn("alexa adopt: Echo not found in the account — skipping", { meta: {
+							nativeId,
+							brokerId
+						} });
+						failures++;
+						continue;
+					}
+					try {
+						const { deviceId } = await adoptEcho({
+							brokerId,
+							echo,
+							integrationId,
+							name: perCandidate?.[nativeId]?.name ?? echo.name
+						});
+						adopted.push({
+							childNativeId: nativeId,
+							parentDeviceId: deviceId,
+							accessoryDeviceIds: []
+						});
+					} catch (err) {
+						logger.warn("alexa adopt: failed to adopt Echo", { meta: {
+							brokerId,
+							serial: echoSerial,
+							error: errMsg(err)
+						} });
+						failures++;
+					}
+					continue;
+				}
 				const appliance = appliances.find((a) => a.applianceId === nativeId);
 				if (appliance === void 0) {
 					logger.warn("alexa adopt: appliance not found in inventory — skipping", { meta: {
@@ -140787,6 +141567,7 @@ function setBrokerDevicesOnline(devices, brokerId, online) {
 	for (const dev of devices) {
 		if (dev.config.get("system") !== "alexa") continue;
 		if (dev.config.get("brokerId") !== brokerId) continue;
+		if (typeof dev.config.get("serial") === "string") continue;
 		if (dev.online === online) continue;
 		dev.markOnline(online);
 		count += 1;
@@ -141194,6 +141975,421 @@ var AlexaDevice = class extends BaseDevice {
 function isKnownCap(cap) {
 	return KNOWN_CAPS.has(cap);
 }
+var EchoSessionRegistry = class {
+	#resolve = null;
+	#dnd = /* @__PURE__ */ new Map();
+	setResolver(fn) {
+		this.#resolve = fn;
+	}
+	get(brokerId) {
+		return this.#resolve === null ? null : this.#resolve(brokerId);
+	}
+	/** Do Not Disturb of every device of the account. A failed read is not kept for the next device. */
+	dnd(brokerId, now) {
+		const shared = this.#dnd.get(brokerId);
+		if (shared !== void 0 && now - shared.at < 25e3) return shared.pending;
+		const session = this.get(brokerId);
+		if (session === null) return Promise.reject(/* @__PURE__ */ new Error("no Echo session for this account"));
+		const pending = session.dndState();
+		this.#dnd.set(brokerId, {
+			at: now,
+			pending
+		});
+		pending.catch(() => {
+			if (this.#dnd.get(brokerId)?.pending === pending) this.#dnd.delete(brokerId);
+		});
+		return pending;
+	}
+	clear() {
+		this.#resolve = null;
+		this.#dnd.clear();
+	}
+};
+/** The single in-process registry shared across the addon. */
+var alexaEchoSessions = new EchoSessionRegistry();
+//#endregion
+//#region src/alexa-echo-state-to-cap.ts
+/** The slice of an Echo that cannot be read: every reading null, the state as given. */
+function emptyEchoStatus(state, now) {
+	return {
+		state,
+		stateSource: "reported",
+		assumedFields: [],
+		volumeLevel: null,
+		isMuted: null,
+		source: "",
+		availableSources: [],
+		currentMedia: null,
+		position: null,
+		duration: null,
+		shuffle: null,
+		repeat: null,
+		lastChangedAt: now
+	};
+}
+function mapEchoPlaybackState(value) {
+	switch (value) {
+		case "PLAYING": return "playing";
+		case "PAUSED": return "paused";
+		case "BUFFERING": return "buffering";
+		default: return "idle";
+	}
+}
+function percent(value) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return null;
+	return Math.round(Math.max(0, Math.min(100, value)));
+}
+function secondsToMs(value) {
+	if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return null;
+	return Math.round(value * 1e3);
+}
+function nonEmpty(value) {
+	return typeof value === "string" && value !== "" ? value : null;
+}
+/** `SELECTED` is on, `UNSELECTED` is off; `HIDDEN` and `DISABLED` mean the surface does not exist. */
+function shuffleOf(value) {
+	if (value === "SELECTED") return true;
+	if (value === "UNSELECTED") return false;
+	return null;
+}
+function repeatOf(value) {
+	if (value === "SELECTED") return "all";
+	if (value === "UNSELECTED") return "off";
+	return null;
+}
+function currentMediaOf(info) {
+	const title = nonEmpty(info.infoText?.title);
+	if (title === null) return null;
+	const artist = nonEmpty(info.infoText?.subText1);
+	const album = nonEmpty(info.infoText?.subText2);
+	const imageUrl = nonEmpty(info.mainArt?.url);
+	return {
+		type: "unknown",
+		title,
+		...artist !== null ? { artist } : {},
+		...album !== null ? { album } : {},
+		...imageUrl !== null ? { imageUrl } : {}
+	};
+}
+function mapPlayerInfoToStatus(info, input) {
+	if (!input.online) return emptyEchoStatus("off", input.now);
+	const length = secondsToMs(info.progress?.mediaLength);
+	return {
+		...emptyEchoStatus(mapEchoPlaybackState(info.state), input.now),
+		volumeLevel: percent(info.volume?.volume),
+		isMuted: typeof info.volume?.muted === "boolean" ? info.volume.muted : null,
+		currentMedia: currentMediaOf(info),
+		position: secondsToMs(info.progress?.mediaProgress),
+		duration: length === 0 ? null : length,
+		shuffle: shuffleOf(info.transport?.shuffle),
+		repeat: repeatOf(info.transport?.repeat)
+	};
+}
+//#endregion
+//#region src/speak/worker-protocol.ts
+/** Line-delimited JSON the long-lived Python worker speaks. One object per line. */
+var EchoDeviceSchema = object({
+	id: string().min(1),
+	name: string(),
+	family: string(),
+	online: boolean(),
+	kind: _enum(["device", "group"]),
+	dnd: boolean(),
+	deviceType: string(),
+	/** The room the account files the device under, when Amazon names one. */
+	room: string().optional()
+});
+var LoginStatusSchema = _enum(["ok", "failed"]);
+var SessionStatusSchema = object({
+	loggedIn: boolean(),
+	ageSec: number$1().int().nonnegative(),
+	lastSuccessAt: number$1().int().nullable()
+});
+var TargetDeliverySchema = object({
+	targetId: string(),
+	ok: boolean(),
+	error: string().optional()
+});
+var WorkerLineSchema = union([object({
+	id: string(),
+	ok: literal(true),
+	result: unknown().optional()
+}), object({
+	id: string(),
+	ok: literal(false),
+	error: string(),
+	/** A typed reason the worker names; `rate-limited` is Amazon's 429. */
+	code: string().optional()
+})]);
+var RATE_LIMITED_CODE = "rate-limited";
+/** Amazon answered 429. Never an empty answer: the caller backs off and keeps what it had. */
+var RateLimitedError = class extends Error {
+	code = RATE_LIMITED_CODE;
+	constructor(message) {
+		super(message);
+		this.name = "RateLimitedError";
+	}
+};
+function requestLine(id, request) {
+	return `${JSON.stringify({
+		id,
+		...request
+	})}\n`;
+}
+function parseLoginResult(result) {
+	const parsed = object({
+		status: LoginStatusSchema,
+		error: string().optional()
+	}).safeParse(result);
+	if (!parsed.success) return {
+		status: "failed",
+		error: "worker returned an unexpected login result"
+	};
+	return parsed.data;
+}
+function parseDevices(result) {
+	const parsed = object({ devices: array(EchoDeviceSchema) }).safeParse(result);
+	if (!parsed.success) throw new Error("worker returned an unexpected device list");
+	return parsed.data.devices;
+}
+function parseDeliveries(result) {
+	const parsed = object({ outcomes: array(TargetDeliverySchema) }).safeParse(result);
+	if (!parsed.success) throw new Error("worker returned an unexpected delivery list");
+	return parsed.data.outcomes;
+}
+function parseSessionStatus(result) {
+	const parsed = SessionStatusSchema.safeParse(result);
+	if (!parsed.success) throw new Error("worker returned an unexpected session status");
+	return parsed.data;
+}
+/**
+* The raw `playerInfo` of `/api/np/player`. Amazon omits what it does not know,
+* so every field is nullable; the mapping to the media-player cap turns a missing
+* value into null, never into 0 (D393).
+*/
+var PlayerInfoSchema = object({
+	state: string().nullish(),
+	volume: object({
+		volume: number$1().nullish(),
+		muted: boolean().nullish()
+	}).nullish(),
+	infoText: object({
+		title: string().nullish(),
+		subText1: string().nullish(),
+		subText2: string().nullish()
+	}).nullish(),
+	mainArt: object({ url: string().nullish() }).nullish(),
+	progress: object({
+		mediaLength: number$1().nullish(),
+		mediaProgress: number$1().nullish()
+	}).nullish(),
+	transport: object({
+		shuffle: string().nullish(),
+		repeat: string().nullish()
+	}).nullish()
+});
+function parsePlayerState(result) {
+	const parsed = object({ playerInfo: PlayerInfoSchema.nullish() }).safeParse(result);
+	if (!parsed.success) throw new Error("worker returned an unexpected player state");
+	return parsed.data.playerInfo ?? {};
+}
+var DndEntrySchema = object({
+	serial: string().min(1),
+	enabled: boolean()
+});
+function parseDndState(result) {
+	const parsed = object({ devices: array(DndEntrySchema) }).safeParse(result);
+	if (!parsed.success) throw new Error("worker returned an unexpected Do Not Disturb list");
+	return new Map(parsed.data.devices.map((entry) => [entry.serial, entry.enabled]));
+}
+//#endregion
+//#region src/devices/alexa-echo-device.ts
+/**
+* An Echo is a media-player device. Identity only: the account (`brokerId`) and
+* the Echo's serial. The Echo's notification target is a separate record linked
+* by the same (brokerId, serial); nothing here sets or reads a notification.
+*/
+var alexaEchoDeviceSchema = object({
+	brokerId: string().min(1).describe("Registry broker id"),
+	serial: string().min(1).describe("The Echo serial number"),
+	deviceType: string().default("").describe("Amazon device type id"),
+	system: literal("alexa").optional(),
+	integrationId: string().optional()
+});
+var COLD_DND = {
+	enabled: null,
+	lastChangedAt: 0
+};
+function unsupported(what) {
+	throw new Error(`${what} is not available on an Echo`);
+}
+var AlexaEchoDevice = class extends BaseDevice {
+	features = [
+		DeviceFeature.MediaPlayerVolume,
+		DeviceFeature.MediaPlayerNext,
+		DeviceFeature.MediaPlayerPrevious
+	];
+	brokerId;
+	serial;
+	amazonDeviceType;
+	timer = null;
+	rereadTimer = null;
+	polling = false;
+	failureLogged = false;
+	health = "ok";
+	constructor(ctx) {
+		const persisted = alexaEchoDeviceSchema.parse(ctx.persistedConfig ?? {});
+		super(ctx, alexaEchoDeviceSchema, { type: DeviceType.MediaPlayer });
+		this.brokerId = persisted.brokerId;
+		this.serial = persisted.serial;
+		this.amazonDeviceType = persisted.deviceType;
+	}
+	/** The outcome of the last read, for the broker status and the specs. */
+	get pollHealth() {
+		return this.health;
+	}
+	async onActivate() {
+		await super.onActivate();
+		this.registerMediaPlayer();
+		this.registerDoNotDisturb();
+		this.runtimeState.setCapState("media-player", emptyEchoStatus("off", 0));
+		this.runtimeState.setCapState("do-not-disturb", COLD_DND);
+		this.poll();
+		this.timer = setInterval(() => void this.poll(), ECHO_POLL_MS);
+		this.timer.unref();
+	}
+	async removeDevice() {
+		if (this.timer !== null) clearInterval(this.timer);
+		if (this.rereadTimer !== null) clearTimeout(this.rereadTimer);
+		this.timer = null;
+		this.rereadTimer = null;
+		await super.removeDevice();
+	}
+	session() {
+		const session = alexaEchoSessions.get(this.brokerId);
+		if (session === null) throw new Error("the Amazon account of this Echo is not connected");
+		return session;
+	}
+	/** One re-read shortly after a command, once Amazon has applied it. */
+	rereadSoon() {
+		if (this.rereadTimer !== null) clearTimeout(this.rereadTimer);
+		this.rereadTimer = setTimeout(() => {
+			this.rereadTimer = null;
+			this.poll();
+		}, ECHO_REREAD_MS);
+		this.rereadTimer.unref();
+	}
+	/**
+	* Read the player and Do Not Disturb. A failed read leaves both slices as they
+	* were and marks the device degraded; a 429 is a pause, not a fault. Never throws.
+	*/
+	async poll() {
+		if (this.polling) return;
+		this.polling = true;
+		try {
+			await this.readOnce();
+		} finally {
+			this.polling = false;
+		}
+	}
+	async readOnce() {
+		const session = alexaEchoSessions.get(this.brokerId);
+		if (session === null || session.state !== "ready") return;
+		if (session.rateLimitedUntil !== null) {
+			this.health = "rate-limited";
+			return;
+		}
+		const listed = session.devices.find((device) => device.id === this.serial);
+		if (listed !== void 0 && !listed.online) {
+			this.runtimeState.setCapState("media-player", emptyEchoStatus("off", Date.now()));
+			this.markOnline(false);
+			this.health = "ok";
+			return;
+		}
+		const deviceType = this.amazonDeviceType !== "" ? this.amazonDeviceType : listed?.deviceType ?? "";
+		try {
+			const info = await session.playerState(this.serial, deviceType);
+			const now = Date.now();
+			this.runtimeState.setCapState("media-player", mapPlayerInfoToStatus(info, {
+				online: true,
+				now
+			}));
+			this.markOnline(true);
+			this.noteRecovered();
+		} catch (err) {
+			this.noteReadFailure(err);
+			return;
+		}
+		await this.readDoNotDisturb();
+	}
+	async readDoNotDisturb() {
+		try {
+			const enabled = (await alexaEchoSessions.dnd(this.brokerId, Date.now())).get(this.serial);
+			if (enabled === void 0) return;
+			this.runtimeState.setCapState("do-not-disturb", {
+				enabled,
+				lastChangedAt: Date.now()
+			});
+		} catch (err) {
+			this.noteReadFailure(err);
+		}
+	}
+	noteRecovered() {
+		if (this.failureLogged) this.ctx.logger.info("alexa echo: reads are working again", { tags: { deviceId: this.id } });
+		this.failureLogged = false;
+		this.health = "ok";
+	}
+	noteReadFailure(err) {
+		if (err instanceof RateLimitedError) {
+			this.health = "rate-limited";
+			this.ctx.logger.info("alexa echo: amazon asked for a pause, keeping the last state", { tags: { deviceId: this.id } });
+			return;
+		}
+		this.health = "degraded";
+		if (this.failureLogged) return;
+		this.failureLogged = true;
+		this.ctx.logger.warn("alexa echo: could not read the player, keeping the last state", {
+			tags: { deviceId: this.id },
+			meta: { error: err instanceof Error ? err.message : String(err) }
+		});
+	}
+	async command(command) {
+		await this.session().npCommand(this.serial, command);
+		this.rereadSoon();
+	}
+	registerMediaPlayer() {
+		this.ctx.registerNativeCap(mediaPlayerCapability, {
+			getStatus: async () => this.runtimeState.getCapState("media-player") ?? emptyEchoStatus("off", 0),
+			play: () => this.command("play"),
+			pause: () => this.command("pause"),
+			next: () => this.command("next"),
+			previous: () => this.command("previous"),
+			setVolume: async ({ volumeLevel }) => {
+				await this.session().setVolume(this.serial, Math.round(volumeLevel));
+				this.rereadSoon();
+			},
+			stop: async () => unsupported("stop"),
+			seek: async () => unsupported("seek"),
+			setMute: async () => unsupported("mute"),
+			setShuffle: async () => unsupported("shuffle"),
+			setRepeat: async () => unsupported("repeat"),
+			selectSource: async () => unsupported("source selection"),
+			playMedia: async () => unsupported("playing media")
+		});
+	}
+	registerDoNotDisturb() {
+		this.ctx.registerNativeCap(doNotDisturbCapability, {
+			getStatus: async () => this.runtimeState.getCapState("do-not-disturb") ?? COLD_DND,
+			setEnabled: async ({ enabled }) => {
+				await this.session().setDnd(this.serial, enabled);
+				this.runtimeState.setCapState("do-not-disturb", {
+					enabled,
+					lastChangedAt: Date.now()
+				});
+			}
+		});
+	}
+};
 var alexaBrokersEntryKind = defineEntryKind("brokers", {
 	title: "Alexa import brokers",
 	schema: entryBody({
@@ -141502,78 +142698,14 @@ function scrubSecrets(text, secrets) {
 	return out;
 }
 //#endregion
-//#region src/speak/worker-protocol.ts
-/** Line-delimited JSON the long-lived Python worker speaks. One object per line. */
-var EchoDeviceSchema = object({
-	id: string().min(1),
-	name: string(),
-	family: string(),
-	online: boolean(),
-	kind: _enum(["device", "group"]),
-	dnd: boolean(),
-	deviceType: string(),
-	/** The room the account files the device under, when Amazon names one. */
-	room: string().optional()
-});
-var LoginStatusSchema = _enum(["ok", "failed"]);
-var SessionStatusSchema = object({
-	loggedIn: boolean(),
-	ageSec: number$1().int().nonnegative(),
-	lastSuccessAt: number$1().int().nullable()
-});
-var TargetDeliverySchema = object({
-	targetId: string(),
-	ok: boolean(),
-	error: string().optional()
-});
-var WorkerLineSchema = union([object({
-	id: string(),
-	ok: literal(true),
-	result: unknown().optional()
-}), object({
-	id: string(),
-	ok: literal(false),
-	error: string()
-})]);
-function requestLine(id, request) {
-	return `${JSON.stringify({
-		id,
-		...request
-	})}\n`;
-}
-function parseLoginResult(result) {
-	const parsed = object({
-		status: LoginStatusSchema,
-		error: string().optional()
-	}).safeParse(result);
-	if (!parsed.success) return {
-		status: "failed",
-		error: "worker returned an unexpected login result"
-	};
-	return parsed.data;
-}
-function parseDevices(result) {
-	const parsed = object({ devices: array(EchoDeviceSchema) }).safeParse(result);
-	if (!parsed.success) throw new Error("worker returned an unexpected device list");
-	return parsed.data.devices;
-}
-function parseDeliveries(result) {
-	const parsed = object({ outcomes: array(TargetDeliverySchema) }).safeParse(result);
-	if (!parsed.success) throw new Error("worker returned an unexpected delivery list");
-	return parsed.data.outcomes;
-}
-function parseSessionStatus(result) {
-	const parsed = SessionStatusSchema.safeParse(result);
-	if (!parsed.success) throw new Error("worker returned an unexpected session status");
-	return parsed.data;
-}
-//#endregion
 //#region src/speak/broker-echo.ts
 var BrokerEcho = class {
 	deps;
 	currentState = "starting";
 	currentError = null;
 	currentDevices = [];
+	backoffMs = 0;
+	limitedUntil = 0;
 	constructor(deps) {
 		this.deps = deps;
 	}
@@ -141592,6 +142724,13 @@ var BrokerEcho = class {
 	get devices() {
 		return this.currentDevices;
 	}
+	/** Ms epoch until which Amazon asked us to wait (429), or null when the account is free. */
+	get rateLimitedUntil() {
+		return this.limitedUntil > this.nowMs() ? this.limitedUntil : null;
+	}
+	nowMs() {
+		return (this.deps.now ?? Date.now)();
+	}
 	stop() {
 		this.deps.worker.stop();
 	}
@@ -141682,6 +142821,69 @@ var BrokerEcho = class {
 			text
 		}));
 	}
+	/**
+	* Run one worker call. A 429 starts (or doubles) the account's back-off and is
+	* rethrown as is; any answer ends it. Rate limiting is a status, not a failure.
+	*/
+	async limited(call) {
+		try {
+			const result = await call();
+			this.backoffMs = 0;
+			this.limitedUntil = 0;
+			return result;
+		} catch (err) {
+			if (err instanceof RateLimitedError) {
+				this.backoffMs = this.backoffMs === 0 ? ECHO_RATE_BACKOFF_BASE_MS : Math.min(this.backoffMs * 2, ECHO_RATE_BACKOFF_MAX_MS);
+				this.limitedUntil = this.nowMs() + this.backoffMs;
+				this.deps.logger.info("alexa echo: amazon asked for a pause (429)", {
+					tags: { brokerId: this.deps.brokerId },
+					meta: { backoffMs: this.backoffMs }
+				});
+			}
+			throw err;
+		}
+	}
+	/** The raw player state of one Echo. Throws on any failure, a 429 included: never an empty answer. */
+	async playerState(serial, deviceType) {
+		await this.requireReady();
+		return this.limited(async () => parsePlayerState(await this.deps.worker.request({
+			op: "player_state",
+			serial,
+			deviceType
+		})));
+	}
+	async npCommand(serial, command) {
+		await this.requireReady();
+		await this.limited(() => this.deps.worker.request({
+			op: "np_command",
+			serial,
+			command
+		}));
+	}
+	async setVolume(serial, level) {
+		await this.requireReady();
+		await this.limited(() => this.deps.worker.request({
+			op: "set_volume",
+			serial,
+			level
+		}));
+	}
+	/** Do Not Disturb of every device of the account, by serial, in one call. */
+	async dndState() {
+		await this.requireReady();
+		return this.limited(async () => parseDndState(await this.deps.worker.request({ op: "dnd_state" })));
+	}
+	async setDnd(serial, enabled) {
+		await this.requireReady();
+		await this.limited(() => this.deps.worker.request({
+			op: "set_dnd",
+			serial,
+			enabled
+		}));
+	}
+	async requireReady() {
+		if (!await this.ensureReady()) throw new Error(this.notReadyReason());
+	}
 	async session() {
 		if (this.deps.worker.failed) return {
 			loggedIn: false,
@@ -142404,6 +143606,7 @@ function startAlexaWorker(deps) {
 		const current = pending;
 		pending = null;
 		if (message.ok) current.resolve(message.result);
+		else if (message.code === "rate-limited") current.reject(new RateLimitedError(scrub(message.error)));
 		else current.reject(new Error(scrub(message.error)));
 		pump();
 	}
@@ -142557,6 +143760,10 @@ var AlexaSpeakController = class {
 		this.queue = this.queue.then(() => this.reconcile()).catch(() => void 0);
 		return this.queue;
 	}
+	/** The live session of one account, for the Echo devices that poll it. */
+	echoFor(brokerId) {
+		return this.echoes.get(brokerId) ?? null;
+	}
 	brokerViews() {
 		return this.host.listBrokers().map((ref) => {
 			const echo = this.echoes.get(ref.id);
@@ -142564,7 +143771,8 @@ var AlexaSpeakController = class {
 				id: ref.id,
 				name: ref.name,
 				ready: echo?.state === "ready",
-				devices: echo?.devices ?? []
+				devices: echo?.devices ?? [],
+				rateLimitedUntil: echo?.rateLimitedUntil ?? null
 			};
 		});
 	}
@@ -142608,7 +143816,8 @@ var AlexaSpeakController = class {
 			worker: this.makeWorker(ref.id, pythonPath),
 			readSeed: () => this.host.readSeed(ref.id),
 			sessions: this.host.sessions,
-			logger: this.host.logger
+			logger: this.host.logger,
+			now: this.now
 		}));
 		await Promise.all(refs.map(async (ref) => {
 			const echo = this.echoes.get(ref.id);
@@ -142767,7 +143976,10 @@ var ALEXA_DEVICE_TYPES = [
 var AlexaImportAddon = class extends BaseDeviceProvider {
 	addonId = "import-alexa";
 	providerName = "Alexa";
-	deviceClasses = Object.fromEntries(ALEXA_DEVICE_TYPES.map((t) => [t, AlexaDevice]));
+	deviceClasses = {
+		...Object.fromEntries(ALEXA_DEVICE_TYPES.map((t) => [t, AlexaDevice])),
+		[DeviceType.MediaPlayer]: AlexaEchoDevice
+	};
 	registry = null;
 	proxyLogin = null;
 	deviceCodeLogin = null;
@@ -142854,6 +144066,7 @@ var AlexaImportAddon = class extends BaseDeviceProvider {
 			ensurePython: () => this.ctx.deps.ensurePython()
 		});
 		this.speak = speak;
+		alexaEchoSessions.setResolver((brokerId) => speak.echoFor(brokerId));
 		speak.start().catch((err) => {
 			this.ctx.logger.warn("alexa speak: worker did not start", { meta: { error: err instanceof Error ? err.message : String(err) } });
 		});
@@ -142958,6 +144171,7 @@ var AlexaImportAddon = class extends BaseDeviceProvider {
 	async onShutdown() {
 		this.speak?.stop();
 		this.speak = null;
+		alexaEchoSessions.clear();
 		alexaCommands.clear();
 		try {
 			await this.proxyLogin?.dispose();
@@ -142981,7 +144195,10 @@ var AlexaImportAddon = class extends BaseDeviceProvider {
 	}
 	/** One broker = one account; the appliance id distinguishes devices within it. */
 	generateStableId(_type, config) {
-		return `alexa:${String(config?.["brokerId"] ?? "unknown")}:${String(config?.["applianceId"] ?? "unknown")}`;
+		const brokerId = String(config?.["brokerId"] ?? "unknown");
+		const serial = config?.["serial"];
+		if (typeof serial === "string") return `alexa:${brokerId}:echo:${serial}`;
+		return `alexa:${brokerId}:${String(config?.["applianceId"] ?? "unknown")}`;
 	}
 	/**
 	* Re-derive every adopted Alexa device's `capabilities[]` from the live
@@ -143144,7 +144361,8 @@ var AlexaImportAddon = class extends BaseDeviceProvider {
 					id: b.id,
 					name: b.name
 				})),
-				has: (id) => this.requireRegistry().get(id) !== null
+				has: (id) => this.requireRegistry().get(id) !== null,
+				getEchoesForBroker: (id) => this.speak?.echoFor(id)?.devices ?? []
 			},
 			logger: this.ctx.logger,
 			getBrokerIdForIntegration: async (id) => {
@@ -143186,6 +144404,23 @@ var AlexaImportAddon = class extends BaseDeviceProvider {
 					integrationId
 				})).id };
 			},
+			adoptEcho: async ({ brokerId, echo, integrationId, name }) => {
+				const devices = this.ctx.kernel.devices;
+				if (!devices) throw new Error("alexa adopt: kernel.devices unavailable");
+				const config = {
+					brokerId,
+					serial: echo.id,
+					deviceType: echo.deviceType,
+					system: "alexa",
+					integrationId,
+					name
+				};
+				return { deviceId: (await devices.create(this.generateStableId(DeviceType.MediaPlayer, config), AlexaEchoDevice, config, null, {
+					type: DeviceType.MediaPlayer,
+					name,
+					integrationId
+				})).id };
+			},
 			removeDevice: async (id) => {
 				await this.ctx.kernel.devices?.remove(id);
 			},