@camstack/addon-provider-rademacher 0.2.157 → 0.2.158

package/dist/addon.js

@@ -788,7 +788,7 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	return EventCategory;
 }({});
 //#endregion
-//#region ../types/dist/device-type-CfHw_quR.mjs
+//#region ../types/dist/device-type-D1fH5kaC.mjs
 /**
 import { errMsg } from '@camstack/types'
 * Extract a human-readable message from an unknown error value.
@@ -1019,6 +1019,12 @@ var DeviceFeature = /* @__PURE__ */ function(DeviceFeature) {
 	DeviceFeature["MediaPlayerPrevious"] = "media-player-previous";
 	/** Media player exposes stop distinct from pause. */
 	DeviceFeature["MediaPlayerStop"] = "media-player-stop";
+	/** Media player exposes volume up / down in steps (an infrared TV has no level). */
+	DeviceFeature["MediaPlayerVolumeStep"] = "media-player-volume-step";
+	/** Media player exposes channel up / down in steps. */
+	DeviceFeature["MediaPlayerChannelStep"] = "media-player-channel-step";
+	/** Media player exposes power on / off. */
+	DeviceFeature["MediaPlayerPower"] = "media-player-power";
 	/** Alarm panel requires a PIN code on arm/disarm. */
 	DeviceFeature["AlarmPinRequired"] = "alarm-pin-required";
 	/** Presence device carries GPS coordinates (lat/lng/accuracy) in
@@ -4555,6 +4561,12 @@ var numberProcessor = (schema, ctx, _json, _params) => {
 var booleanProcessor = (_schema, _ctx, json, _params) => {
 	json.type = "boolean";
 };
+var bigintProcessor = (_schema, ctx, _json, _params) => {
+	if (ctx.unrepresentable === "throw") throw new Error("BigInt cannot be represented in JSON Schema");
+};
+var symbolProcessor = (_schema, ctx, _json, _params) => {
+	if (ctx.unrepresentable === "throw") throw new Error("Symbols cannot be represented in JSON Schema");
+};
 var nullProcessor = (_schema, ctx, json, _params) => {
 	if (ctx.target === "openapi-3.0") {
 		json.type = "string";
@@ -4562,12 +4574,17 @@ var nullProcessor = (_schema, ctx, json, _params) => {
 		json.enum = [null];
 	} else json.type = "null";
 };
+var undefinedProcessor = (_schema, ctx, _json, _params) => {
+	if (ctx.unrepresentable === "throw") throw new Error("Undefined cannot be represented in JSON Schema");
+};
 var voidProcessor = (_schema, ctx, _json, _params) => {
 	if (ctx.unrepresentable === "throw") throw new Error("Void cannot be represented in JSON Schema");
 };
 var neverProcessor = (_schema, _ctx, json, _params) => {
 	json.not = {};
 };
+var anyProcessor = (_schema, _ctx, _json, _params) => {};
+var unknownProcessor = (_schema, _ctx, _json, _params) => {};
 var dateProcessor = (_schema, ctx, _json, _params) => {
 	if (ctx.unrepresentable === "throw") throw new Error("Date cannot be represented in JSON Schema");
 };
@@ -4599,12 +4616,53 @@ var literalProcessor = (schema, ctx, json, _params) => {
 		json.enum = vals;
 	}
 };
+var nanProcessor = (_schema, ctx, _json, _params) => {
+	if (ctx.unrepresentable === "throw") throw new Error("NaN cannot be represented in JSON Schema");
+};
+var templateLiteralProcessor = (schema, _ctx, json, _params) => {
+	const _json = json;
+	const pattern = schema._zod.pattern;
+	if (!pattern) throw new Error("Pattern not found in template literal");
+	_json.type = "string";
+	_json.pattern = pattern.source;
+};
+var fileProcessor = (schema, _ctx, json, _params) => {
+	const _json = json;
+	const file = {
+		type: "string",
+		format: "binary",
+		contentEncoding: "binary"
+	};
+	const { minimum, maximum, mime } = schema._zod.bag;
+	if (minimum !== void 0) file.minLength = minimum;
+	if (maximum !== void 0) file.maxLength = maximum;
+	if (mime) if (mime.length === 1) {
+		file.contentMediaType = mime[0];
+		Object.assign(_json, file);
+	} else {
+		Object.assign(_json, file);
+		_json.anyOf = mime.map((m) => ({ contentMediaType: m }));
+	}
+	else Object.assign(_json, file);
+};
+var successProcessor = (_schema, _ctx, json, _params) => {
+	json.type = "boolean";
+};
 var customProcessor = (_schema, ctx, _json, _params) => {
 	if (ctx.unrepresentable === "throw") throw new Error("Custom types cannot be represented in JSON Schema");
 };
+var functionProcessor = (_schema, ctx, _json, _params) => {
+	if (ctx.unrepresentable === "throw") throw new Error("Function types cannot be represented in JSON Schema");
+};
 var transformProcessor = (_schema, ctx, _json, _params) => {
 	if (ctx.unrepresentable === "throw") throw new Error("Transforms cannot be represented in JSON Schema");
 };
+var mapProcessor = (_schema, ctx, _json, _params) => {
+	if (ctx.unrepresentable === "throw") throw new Error("Map cannot be represented in JSON Schema");
+};
+var setProcessor = (_schema, ctx, _json, _params) => {
+	if (ctx.unrepresentable === "throw") throw new Error("Set cannot be represented in JSON Schema");
+};
 var arrayProcessor = (schema, ctx, _json, params) => {
 	const json = _json;
 	const def = schema._zod.def;
@@ -4809,6 +4867,12 @@ var readonlyProcessor = (schema, ctx, json, params) => {
 	seen.ref = def.innerType;
 	json.readOnly = true;
 };
+var promiseProcessor = (schema, ctx, _json, params) => {
+	const def = schema._zod.def;
+	process(def.innerType, ctx, params);
+	const seen = ctx.seen.get(schema);
+	seen.ref = def.innerType;
+};
 var optionalProcessor = (schema, ctx, _json, params) => {
 	const def = schema._zod.def;
 	process(def.innerType, ctx, params);
@@ -4821,6 +4885,81 @@ var lazyProcessor = (schema, ctx, _json, params) => {
 	const seen = ctx.seen.get(schema);
 	seen.ref = innerType;
 };
+var allProcessors = {
+	string: stringProcessor,
+	number: numberProcessor,
+	boolean: booleanProcessor,
+	bigint: bigintProcessor,
+	symbol: symbolProcessor,
+	null: nullProcessor,
+	undefined: undefinedProcessor,
+	void: voidProcessor,
+	never: neverProcessor,
+	any: anyProcessor,
+	unknown: unknownProcessor,
+	date: dateProcessor,
+	enum: enumProcessor,
+	literal: literalProcessor,
+	nan: nanProcessor,
+	template_literal: templateLiteralProcessor,
+	file: fileProcessor,
+	success: successProcessor,
+	custom: customProcessor,
+	function: functionProcessor,
+	transform: transformProcessor,
+	map: mapProcessor,
+	set: setProcessor,
+	array: arrayProcessor,
+	object: objectProcessor,
+	union: unionProcessor,
+	intersection: intersectionProcessor,
+	tuple: tupleProcessor,
+	record: recordProcessor,
+	nullable: nullableProcessor,
+	nonoptional: nonoptionalProcessor,
+	default: defaultProcessor,
+	prefault: prefaultProcessor,
+	catch: catchProcessor,
+	pipe: pipeProcessor,
+	readonly: readonlyProcessor,
+	promise: promiseProcessor,
+	optional: optionalProcessor,
+	lazy: lazyProcessor
+};
+function toJSONSchema(input, params) {
+	if ("_idmap" in input) {
+		const registry = input;
+		const ctx = initializeContext({
+			...params,
+			processors: allProcessors
+		});
+		const defs = {};
+		for (const entry of registry._idmap.entries()) {
+			const [_, schema] = entry;
+			process(schema, ctx);
+		}
+		const schemas = {};
+		ctx.external = {
+			registry,
+			uri: params?.uri,
+			defs
+		};
+		for (const entry of registry._idmap.entries()) {
+			const [key, schema] = entry;
+			extractDefs(ctx, schema);
+			schemas[key] = finalize(ctx, schema);
+		}
+		if (Object.keys(defs).length > 0) schemas.__shared = { [ctx.target === "draft-2020-12" ? "$defs" : "definitions"]: defs };
+		return { schemas };
+	}
+	const ctx = initializeContext({
+		...params,
+		processors: allProcessors
+	});
+	process(input, ctx);
+	extractDefs(ctx, input);
+	return finalize(ctx, input);
+}
 //#endregion
 //#region ../../node_modules/zod/v4/classic/iso.js
 var ZodISODateTime = /*@__PURE__*/ $constructor("ZodISODateTime", (inst, def) => {
@@ -5845,7 +5984,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-QsoHs66J.mjs
+//#region ../types/dist/sleep-D1jjWAr8.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -5924,6 +6063,22 @@ function buildAlawTable() {
 }
 buildUlawTable();
 buildAlawTable();
+/**
+* An addon whose own migrations did not apply refuses to initialise (D987). The error is typed
+* so a runner hosting several addons can tell "this addon is blocked" from a crash and keep its
+* co-located siblings running. Recognised by NAME and shape, never `instanceof`: a forked addon
+* bundles its own copy of this module, so the class the runner sees is not the one that threw.
+*/
+var MIGRATIONS_BLOCKED_ERROR_NAME = "AddonMigrationsBlockedError";
+var AddonMigrationsBlockedError = class extends Error {
+	/** The ledger ids that did not apply and block the owner. */
+	migrationIds;
+	constructor(migrationIds) {
+		super(`migration(s) ${migrationIds.join(", ")} did not apply and block this addon — fix or retry them (migrations.retry), then restart it`);
+		this.name = MIGRATIONS_BLOCKED_ERROR_NAME;
+		this.migrationIds = migrationIds;
+	}
+};
 /** Is this field's stored value a credential? */
 function isSecretConfigField(field) {
 	if (field.type === "password") return true;
@@ -5977,9 +6132,16 @@ function isSecretMarker(value) {
 	const ref = value["$secret"];
 	return typeof ref === "string" && ref.length > 0;
 }
+/** Anything carrying a `$secret` key — a stored marker or a UI view of one. */
+function isSecretMarkerLike(value) {
+	return isRecord$7(value) && Object.prototype.hasOwnProperty.call(value, "$secret");
+}
 function isSecretClear(value) {
 	return isRecord$7(value) && value["$secretClear"] === true;
 }
+function isSecretFieldView(value) {
+	return isRecord$7(value) && value["set"] === true && isSecretMarkerLike(value);
+}
 /**
 * The UI view of a stored secret field value: a marker becomes "set", inline
 * plaintext becomes "set (inline)", nothing becomes `null`. A value never
@@ -6361,6 +6523,53 @@ function emitReadiness(bus, params) {
 		ts
 	}));
 }
+/** Why a catalogue entry is not a runnable body of its declared kind. */
+var AddonMigrationDefinitionError = class extends Error {
+	id;
+	constructor(id, message) {
+		super(`${id}: ${message}`);
+		this.id = id;
+		this.name = "AddonMigrationDefinitionError";
+	}
+};
+/**
+* Bind a catalogue to the addon's ports. Throws {@link AddonMigrationDefinitionError} when
+* an entry's `bodyKind` does not match the body it carries, or is `sql` (a hub-only
+* body). A throwing body never escapes `execute`: it is reported as a failed result.
+*/
+function defineAddonMigrations(catalogue, ports) {
+	return catalogue.map((entry) => {
+		const { meta } = entry;
+		if ("plan" in entry) {
+			if (meta.bodyKind !== "plan") throw new AddonMigrationDefinitionError(meta.id, `carries a plan body but declares "${meta.bodyKind}"`);
+			return {
+				meta,
+				execute: () => guarded(async () => ({
+					kind: "plan",
+					plan: await entry.plan(ports)
+				}))
+			};
+		}
+		if (meta.bodyKind !== "procedure") throw new AddonMigrationDefinitionError(meta.id, `carries a procedure body but declares "${meta.bodyKind}"`);
+		return {
+			meta,
+			execute: () => guarded(async () => ({
+				kind: "procedure",
+				result: await entry.procedure(ports)
+			}))
+		};
+	});
+}
+async function guarded(work) {
+	try {
+		return await work();
+	} catch (err) {
+		return {
+			kind: "failed",
+			error: errMsg(err)
+		};
+	}
+}
 var NOT_RUN = {
 	declared: false,
 	snapshot: null,
@@ -6375,7 +6584,7 @@ var NOT_RUN = {
 * throws: an unreachable or refusing engine is logged and reported `declared: false`,
 * because the hub (and this addon's boot) must not hang on a migration.
 */
-async function runAddonMigrations(host, migrations, logger) {
+async function runAddonMigrations(host, migrations, logger, options = {}) {
 	const first = migrations[0];
 	if (first === void 0) return NOT_RUN;
 	const owner = first.meta.owner;
@@ -6404,7 +6613,9 @@ async function runAddonMigrations(host, migrations, logger) {
 		else if (status === "blocked") blocked.push(id);
 		else skipped.push(id);
 	};
+	const selected = options.only === void 0 ? null : new Set(options.only);
 	for (const step of declaration.steps) {
+		if (selected !== null && !selected.has(step.id)) continue;
 		const bound = byId.get(step.id);
 		if (bound === void 0 || step.action === "skip") {
 			skipped.push(step.id);
@@ -6582,11 +6793,36 @@ function projectStore(store, perNodeKeys, nodeId) {
 	}
 	return out;
 }
+/**
+* The address of one keychain value: `secret://<owner>/<scope>/<fieldPath>`.
+*
+* A ref is DETERMINISTIC from where the value lives — the owner addon, the
+* scope (global, one node, one device, one integration, one row of a business
+* collection) and the field path inside that scope — so saving the same field
+* twice updates the same ref, and the ref itself says which settings blob
+* points at it. It is also the AAD of the value's ciphertext: a ciphertext
+* copied onto another ref does not decrypt.
+*
+* Array items are addressed by ITEM ID, never by index
+* (`providers[authentik].clientSecret`), so reordering a list keeps every ref.
+*
+* Pure and browser-safe: no node builtins, no I/O.
+*/
+/** The URI scheme of every keychain ref. */
+var SECRET_REF_SCHEME = "secret://";
 var GLOBAL_SCOPE = { kind: "global" };
 /** The scope every addon-wide (not per-node, not per-device) setting lives in. */
 function globalSecretScope() {
 	return GLOBAL_SCOPE;
 }
+/**
+* An addon id as a ref owner. A hub in-process builtin's context id is
+* `addon:<id>`; the owner of its secrets is `<id>`, exactly as for the same
+* addon running forked.
+*/
+function normalizeSecretOwner(addonId) {
+	return addonId.startsWith("addon:") ? addonId.slice(6) : addonId;
+}
 function encodeSegment(value) {
 	return encodeURIComponent(value);
 }
@@ -6597,6 +6833,16 @@ function decodeSegment(value) {
 		return null;
 	}
 }
+/** The scope as it appears inside a ref (`global`, `node/<id>`, …). */
+function formatSecretScope(scope) {
+	switch (scope.kind) {
+		case "global": return "global";
+		case "node": return `node/${encodeSegment(scope.nodeId)}`;
+		case "device": return `device/${scope.deviceId}`;
+		case "integration": return `integration/${encodeSegment(scope.integrationId)}`;
+		case "row": return `row/${encodeSegment(scope.collection)}/${encodeSegment(scope.rowId)}`;
+	}
+}
 /**
 * The field path of a value inside an array item, addressed by the item's id:
 * `arrayItemFieldPath('providers', 'authentik', 'clientSecret')` →
@@ -6605,6 +6851,13 @@ function decodeSegment(value) {
 function arrayItemFieldPath(arrayKey, itemId, fieldKey) {
 	return `${arrayKey}[${encodeSegment(itemId)}].${fieldKey}`;
 }
+/** Build a ref. Throws on an empty owner or field path — both are bugs. */
+function buildSecretRef(parts) {
+	const owner = normalizeSecretOwner(parts.owner);
+	if (owner.length === 0) throw new Error("buildSecretRef: owner is empty");
+	if (parts.fieldPath.length === 0) throw new Error("buildSecretRef: fieldPath is empty");
+	return `${SECRET_REF_SCHEME}${encodeSegment(owner)}/${formatSecretScope(parts.scope)}/${parts.fieldPath}`;
+}
 function parseScope(segments) {
 	switch (segments[0]) {
 		case "global": return {
@@ -7522,15 +7775,19 @@ var BaseAddon = class {
 	* nothing; the boot continues. A migration that FAILED (or was blocked by one)
 	* and declares `onFailure: 'block-owner'` makes this throw, so the addon does not
 	* serve data whose shape it cannot trust; `tolerate` migrations never do.
+	*
+	* ALWAYS pass the whole catalogue; a phase that must run only some of it passes
+	* `{ only: [ids] }` — never a filtered catalogue (the engine would judge the
+	* omitted applied ids "newer").
 	*/
-	async runMigrations(migrations) {
+	async runMigrations(migrations, options) {
 		const api = this.ctx.api.migrations;
 		const report = await runAddonMigrations({
 			declareOwner: (input) => api.declareOwner.mutate(input),
 			startMigration: (input) => api.startMigration.mutate(input),
 			finishMigration: (input) => api.finishMigration.mutate(input)
-		}, migrations, this.ctx.logger);
-		if (report.blockOwner.length > 0) throw new Error(`migration(s) ${report.blockOwner.join(", ")} did not apply and block this addon — fix or retry them (migrations.retry), then restart it`);
+		}, migrations, this.ctx.logger, options);
+		if (report.blockOwner.length > 0) throw new AddonMigrationsBlockedError(report.blockOwner);
 		return report;
 	}
 	/**
@@ -7870,6 +8127,10 @@ var BaseAddon = class {
 		const stored = keychain ? await this.readAddonStoreWithRetry() : {};
 		const patch = {};
 		for (const key of keys) {
+			if (tree.get(key)?.kind === "array") {
+				patch[key] = [];
+				continue;
+			}
 			const keychainStored = tree.has(key) || collectSecretMarkerRefs(stored[key]).length > 0;
 			patch[key] = keychain && keychainStored ? SECRET_CLEAR : "";
 		}
@@ -8509,6 +8770,45 @@ function normalizeAddonInitResult(result) {
 	if (Array.isArray(result)) return { providers: result };
 	return result;
 }
+var PREFIX = "records/";
+/** The base of every records failure. `detail` is the human part of the message. */
+var RecordsError = class extends Error {
+	code;
+	detail;
+	constructor(code, detail) {
+		super(`${PREFIX}${code}: ${detail}`);
+		this.name = "RecordsError";
+		this.code = code;
+		this.detail = detail;
+	}
+};
+/** A write guarded by `ifRev` found another revision (or an existing row for `ifRev: 0`). */
+var RevConflictError = class extends RecordsError {
+	constructor(detail) {
+		super("rev-conflict", detail);
+		this.name = "RevConflictError";
+	}
+};
+/** The keychain could not store or serve a value: explicit, never an empty string. */
+var RecordSecretUnavailableError = class extends RecordsError {
+	constructor(detail) {
+		super("secret-unavailable", detail);
+		this.name = "RecordSecretUnavailableError";
+	}
+};
+var InvalidRecordError = class extends RecordsError {
+	constructor(detail) {
+		super("invalid-record", detail);
+		this.name = "InvalidRecordError";
+	}
+};
+/** A kind declaration the engine refuses (non-additive change, bad shape, wrong file). */
+var DeclarationRefusedError = class extends RecordsError {
+	constructor(detail) {
+		super("declaration-refused", detail);
+		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"];
@@ -8524,6 +8824,183 @@ 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;
+/** The `Column`-free proof prefix: a ref collection for a kind's secret fields. */
+var RECORD_SECRET_COLLECTION_PREFIX = "records:";
+/**
+* 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`).
+*
+* `{}` after a key means "each value of this map" (`applianceSecrets{}`): the map's own key
+* names the value (`applianceSecrets{fridge}`), so no id key is declared and a body that drops a
+* key releases exactly that key's secret.
+*
+* 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 map = raw.endsWith("{}");
+		const key = each || map ? raw.slice(0, -2) : raw;
+		if (key.length === 0) throw new InvalidRecordError(`secret path "${path}" has an empty segment`);
+		return {
+			key,
+			each,
+			map
+		};
+	});
+}
+/** 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;
+}
+function isRecord$4(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function elementId(element, idKey, declared, prefix) {
+	const id = isRecord$4(element) ? element[idKey] : void 0;
+	if (typeof id !== "string" || id.length === 0) throw new InvalidRecordError(`"${declared}": every element of "${prefix}" needs a non-empty string "${idKey}" to carry a secret`);
+	return id;
+}
+/**
+* Visit every secret leaf PRESENT in `data` (an absent branch has nothing to
+* visit). `replace` returns the new leaf value, or {@link REMOVE_LEAF}; the
+* result is a new body, `data` is untouched.
+*/
+var REMOVE_LEAF = Symbol("remove-leaf");
+function mapAt(node, segments, index, walkedKeys, concretePrefix, declared, arrayKeys, visit) {
+	if (!isRecord$4(node)) return node;
+	const segment = segments[index];
+	if (segment === void 0) return node;
+	if (!Object.prototype.hasOwnProperty.call(node, segment.key)) return node;
+	const child = node[segment.key];
+	const keys = [...walkedKeys, segment.key];
+	const last = index === segments.length - 1;
+	if (segment.each) {
+		if (!Array.isArray(child)) return node;
+		const prefix = keys.join(".");
+		const idKey = arrayKeys[prefix];
+		if (idKey === void 0) throw new InvalidRecordError(`"${declared}": no id key declared for the array "${prefix}"`);
+		const mapped = child.map((element) => {
+			const id = elementId(element, idKey, declared, prefix);
+			const concrete = `${concretePrefix}${concretePrefix.length > 0 ? "." : ""}${segment.key}[${encodeURIComponent(id)}]`;
+			return last ? element : mapAt(element, segments, index + 1, keys, concrete, declared, arrayKeys, visit);
+		});
+		return {
+			...node,
+			[segment.key]: mapped
+		};
+	}
+	if (segment.map) {
+		if (!isRecord$4(child)) return node;
+		const kept = Object.entries(child).map(([mapKey, value]) => {
+			const concrete = `${concretePrefix}${concretePrefix.length > 0 ? "." : ""}${segment.key}{${encodeURIComponent(mapKey)}}`;
+			if (!last) return [mapKey, mapAt(value, segments, index + 1, keys, concrete, declared, arrayKeys, visit)];
+			return [mapKey, visit({
+				declared,
+				concrete,
+				value
+			})];
+		}).filter(([, value]) => value !== REMOVE_LEAF);
+		return {
+			...node,
+			[segment.key]: Object.fromEntries(kept)
+		};
+	}
+	const concrete = `${concretePrefix}${concretePrefix.length > 0 ? "." : ""}${segment.key}`;
+	if (last) {
+		const replacement = visit({
+			declared,
+			concrete,
+			value: child
+		});
+		if (replacement === REMOVE_LEAF) return Object.fromEntries(Object.entries(node).filter(([key]) => key !== segment.key));
+		return {
+			...node,
+			[segment.key]: replacement
+		};
+	}
+	return {
+		...node,
+		[segment.key]: mapAt(child, segments, index + 1, keys, concrete, declared, arrayKeys, visit)
+	};
+}
+/** Replace/remove every present secret leaf; returns a NEW body. */
+function mapSecretLeaves(data, paths, arrayKeys, visit) {
+	let current = data;
+	for (const declared of paths) current = mapAt(current, parseSecretPath(declared), 0, [], "", declared, arrayKeys, visit);
+	return current;
+}
+/** Every present secret leaf, read-only. */
+function collectSecretLeaves(data, paths, arrayKeys) {
+	const found = [];
+	mapSecretLeaves(data, paths, arrayKeys, (leaf) => {
+		found.push(leaf);
+		return leaf.value;
+	});
+	return found;
+}
+/**
+* The keychain collection name a kind's secrets live under. Prefixed so a
+* record's refs never collide with the refs a legacy collection of the same name
+* already holds during an adoption.
+*/
+function recordSecretCollection(kind) {
+	return `${RECORD_SECRET_COLLECTION_PREFIX}${kind}`;
+}
+/** The ONE ref a row's secret field may carry: the engine and the facade both build it here. */
+function recordSecretRef(owner, kind, rowId, concretePath) {
+	return buildSecretRef({
+		owner,
+		scope: {
+			kind: "row",
+			collection: recordSecretCollection(kind),
+			rowId
+		},
+		fieldPath: concretePath
+	});
+}
+/**
+* A stored secret, as an admin read shows it: a VIEW naming the row's own
+* keychain ref (`set: true`), never the value and no longer the bare redaction
+* token. The form hands it to the secret field, which reveals the value by ref
+* through the audited `keychain-admin.reveal`; sent back untouched it keeps the
+* stored secret (the records door reads a view as KEEP).
+*
+* ONE implementation for the entries service and for every addon that serves
+* its own instances (`RecordIntegrationInstances`).
+*/
+function isRecord$3(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function secretViewsOf(owner, kind, id, decl, data) {
+	if (decl.secretPaths.length === 0) return data;
+	const shown = mapSecretLeaves(data, decl.secretPaths, decl.secretArrayKeys, (leaf) => {
+		if (leaf.value !== "__camstack_redacted__") return leaf.value;
+		return {
+			$secret: recordSecretRef(owner, kind, id, leaf.concrete),
+			v: 1,
+			set: true
+		};
+	});
+	return isRecord$3(shown) ? shown : data;
+}
 /**
 * The share-view scope kinds a share-link token can carry. The hub mints
 * and validates them (`ShareViewGrantSchema` builds its
@@ -8596,7 +9073,8 @@ function isZodSecret(schema) {
 }
 /**
 * Every declared secret path in a config schema: dotted keys, `[]` for "each
-* element of this array" (`connection.password`, `rows[].token`). A declared
+* element of this array" (`connection.password`, `rows[].token`), `{}` for "each value of this
+* map" (`applianceSecrets{}`). A declared
 * object or array is reported as one path and not descended into — everything
 * under it is secret.
 */
@@ -8607,6 +9085,7 @@ function collectZodSecretPaths(schema, prefix = "") {
 		const def = defOf(layer);
 		if (def.type === "object" && def.shape) for (const [key, child] of Object.entries(def.shape)) paths.push(...collectZodSecretPaths(child, prefix ? `${prefix}.${key}` : key));
 		else if (def.type === "array" && def.element) paths.push(...collectZodSecretPaths(def.element, `${prefix}[]`));
+		else if (def.type === "record" && def.valueType) paths.push(...collectZodSecretPaths(def.valueType, `${prefix}{}`));
 		else if (def.type === "union" && def.options) for (const option of def.options) paths.push(...collectZodSecretPaths(option, prefix));
 		else if (def.type === "intersection") {
 			if (def.left) paths.push(...collectZodSecretPaths(def.left, prefix));
@@ -8681,6 +9160,126 @@ var RecordKindDeclarationSchema = object({
 }).strict();
 /** The kind names: lower-case, dash separated, short enough for an index name. */
 var RecordKindNameSchema = string().regex(/^[a-z][a-z0-9-]{0,47}$/);
+/** Cross-field rules a declaration must satisfy. Throws {@link DeclarationRefusedError}. */
+function assertValidDeclaration(name, decl) {
+	const refuse = (why) => {
+		throw new DeclarationRefusedError(`kind "${name}": ${why}`);
+	};
+	if (!RecordKindNameSchema.safeParse(name).success) refuse("the name must be lower-case-dashed");
+	const seen = /* @__PURE__ */ new Set();
+	for (const index of decl.indexes) {
+		if (seen.has(index.name)) refuse(`index name "${index.name}" is declared twice`);
+		seen.add(index.name);
+	}
+	const { retention } = decl;
+	const hasSecrets = decl.secretPaths.length > 0;
+	if ("ttlMs" in retention) {
+		if (retention.from === "at" && decl.at !== "required") refuse("a ttl from \"at\" needs at: \"required\"");
+		if (hasSecrets) refuse("a kind with secret fields cannot use engine TTL (its keychain values would be orphaned)");
+	}
+	if ("maxRows" in retention || "maxRowsPerDevice" in retention) {
+		if (retention.maxRowsPerDevice !== void 0 && decl.device !== "required") refuse("maxRowsPerDevice needs device: \"required\"");
+		if (decl.at !== "required") refuse("a row bound trims the oldest \"at\": it needs at: \"required\"");
+		if (hasSecrets) refuse("a kind with secret fields cannot use an engine row bound");
+		const bound = Math.max(retention.maxRows ?? 0, retention.maxRowsPerDevice ?? 0);
+		if (decl.database === "settings" && bound > 5e4) refuse(`a row bound above ${RECORD_SETTINGS_MAX_ROWS} belongs in database: "events" (a big delete on the settings thread stalls every configuration read)`);
+	}
+	if (decl.deviceRemoval === "delete" && decl.device === "none") refuse("deviceRemoval: \"delete\" needs a device: \"required\" or \"optional\"");
+	for (const path of decl.secretPaths) for (const prefix of secretArrayPrefixes(path)) if (decl.secretArrayKeys[prefix] === void 0) refuse(`secret path "${path}" crosses the array "${prefix}": declare its id key in secretArrayKeys`);
+}
+function bodyFieldsOf(schema) {
+	return { ...toJSONSchema(schema, {
+		unrepresentable: "any",
+		io: "input"
+	}) };
+}
+function isRecordLike(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Does every branch of the body schema carry `field`? (A discriminated union has several.) */
+function hasNameField(json, field) {
+	const branches = json["oneOf"] ?? json["anyOf"];
+	if (Array.isArray(branches)) return branches.length > 0 && branches.every((b) => isRecordLike(b) && hasNameField(b, field));
+	const properties = json["properties"];
+	return isRecordLike(properties) && Object.prototype.hasOwnProperty.call(properties, field);
+}
+/**
+* Declare the kinds of a package. The keys are the kind names. The result is
+* what `ctx.records.declare` sends to the engine and what `ctx.records.kind`
+* types its handle from.
+*/
+function defineRecordKinds(specs) {
+	const out = {};
+	for (const [name, spec] of Object.entries(specs)) {
+		const secretPaths = collectZodSecretPaths(spec.schema);
+		const nameField = spec.entry?.nameField ?? "name";
+		const fields = bodyFieldsOf(spec.schema);
+		if (spec.entry !== void 0 && !hasNameField(fields, nameField)) throw new DeclarationRefusedError(`kind "${name}": an entry kind's schema needs a "${nameField}" field`);
+		const parsed = RecordKindDeclarationSchema.parse({
+			database: spec.database,
+			class: spec.class,
+			writeTrigger: spec.writeTrigger,
+			device: spec.device,
+			at: spec.at,
+			indexes: spec.indexes === void 0 ? void 0 : [...spec.indexes],
+			retention: spec.retention,
+			deviceRemoval: spec.deviceRemoval,
+			maxDataBytes: spec.maxDataBytes,
+			secretPaths: [...new Set([...secretPaths, ...spec.retiredSecretPaths ?? []])],
+			secretArrayKeys: spec.secretArrayKeys === void 0 ? void 0 : { ...spec.secretArrayKeys },
+			transactFamily: spec.transactFamily,
+			entry: spec.entry === void 0 ? void 0 : {
+				title: spec.entry.title,
+				nameField,
+				fields
+			}
+		});
+		assertValidDeclaration(name, parsed);
+		out[name] = {
+			name,
+			schema: spec.schema,
+			declaration: parsed
+		};
+	}
+	return out;
+}
+/**
+* Entry kinds (D881): every list of user-created entries (notification
+* targets, brokers, LLM profiles) is ONE record kind with an id, a name and a
+* kind-specific body, and the admin UI lists/adds/edits/deletes all of them
+* through the `record-entries` capability with password fields derived from
+* the schema (`.meta({ secret: true })`).
+*/
+/** The body of a plain entry: a name and the fields the kind adds. */
+function entryBody(shape) {
+	return object({
+		name: string().min(1),
+		...shape
+	});
+}
+/**
+* Declare one entry kind. An entry is configuration: never trimmed by the
+* engine, never aged, belonging to no device.
+*/
+function defineEntryKind(name, spec) {
+	const defined = defineRecordKinds({ [name]: {
+		schema: spec.schema,
+		class: "config",
+		writeTrigger: spec.writeTrigger ?? "an operator adds or edits an entry in the entries UI",
+		retention: { none: "an entry goes only when the operator deletes it" },
+		...spec.maxDataBytes === void 0 ? {} : { maxDataBytes: spec.maxDataBytes },
+		...spec.database === void 0 ? {} : { database: spec.database },
+		...spec.indexes === void 0 ? {} : { indexes: spec.indexes },
+		...spec.secretArrayKeys === void 0 ? {} : { secretArrayKeys: spec.secretArrayKeys },
+		...spec.retiredSecretPaths === void 0 ? {} : { retiredSecretPaths: spec.retiredSecretPaths },
+		entry: {
+			title: spec.title,
+			...spec.nameField === void 0 ? {} : { nameField: spec.nameField }
+		}
+	} })[name];
+	if (defined === void 0) throw new DeclarationRefusedError(`entry kind "${name}" was not built`);
+	return defined;
+}
 object({
 	field: string().min(1),
 	on: literal("advance")
@@ -9337,6 +9936,7 @@ var CAP_NAMES = Object.freeze([
 	"backup",
 	"battery",
 	"binary",
+	"board-key-source",
 	"brightness",
 	"broker",
 	"button",
@@ -9458,6 +10058,7 @@ var CAP_NAMES = Object.freeze([
 	"privacy-mask",
 	"ptz",
 	"ptz-autotrack",
+	"pump-cycle",
 	"reboot",
 	"record-entries",
 	"recording",
@@ -10750,18 +11351,6 @@ Object.freeze({
 			"path": "pumpRunning",
 			"valueType": "boolean"
 		},
-		{
-			"path": "pumpIntervalEnabled",
-			"valueType": "boolean"
-		},
-		{
-			"path": "pumpOnTime",
-			"valueType": "number"
-		},
-		{
-			"path": "pumpOffTime",
-			"valueType": "number"
-		},
 		{
 			"path": "lastDrink",
 			"valueType": "number"
@@ -10885,6 +11474,20 @@ Object.freeze({
 			"valueType": "number"
 		}
 	],
+	"pump-cycle": [
+		{
+			"path": "enabled",
+			"valueType": "boolean"
+		},
+		{
+			"path": "onTime",
+			"valueType": "number"
+		},
+		{
+			"path": "offTime",
+			"valueType": "number"
+		}
+	],
 	"recording-archive": [
 		{
 			"path": "deviceId",
@@ -11334,7 +11937,7 @@ object({
 	params: record(string(), union([string(), number()])).optional()
 });
 //#endregion
-//#region ../types/dist/composition-Dh3RfMx5.mjs
+//#region ../types/dist/composition-CRNwcFYY.mjs
 /**
 * The ffmpeg build every CamStack node downloads, per platform and arch.
 *
@@ -12097,38 +12700,6 @@ function validateExpressionSource(src) {
 	return null;
 }
 /**
-* One power reading becomes a washer, dryer or dishwasher (D944 helper).
-*
-* Standby of the control board is under 5 W; a motor or a heater is far
-* above that, so 5 W is the line. A door lock or a short pump spike is not
-* a cycle, so running starts only after 30 s above the line.
-*
-* A wash, dry or dishwasher pause (soak, heat-wait, heater off between
-* bursts) lasts several minutes. Ending the cycle on the first dip would
-* report "finished" in the middle of the program, so the stop dwell is
-* 10 minutes on every type. The number is stored per type so one machine
-* can move later without moving the others.
-*/
-var APPLIANCE_TEMPLATE_ID = "appliance";
-var APPLIANCE_KINDS = [
-	"washer",
-	"dryer",
-	"dishwasher"
-];
-DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher;
-/**
-* A dumb plug-in stove or heater, built from a smart plug (a `Heater`).
-*
-* The plug is the actuator: `switch.setState` is a FORWARD to the plug's own
-* (D967), so the heater switches exactly as the plug does. Running is the
-* plug being on; when a power reading is also named, running is the draw
-* staying above the line instead (a plug left on with the stove's own
-* thermostat open is not heating). 50 W is far above any standby and below
-* the smallest radiator.
-*/
-var HEATER_TEMPLATE_ID = "heater";
-DeviceType.Heater;
-/**
 * Statistics and integrals over a history read (D944).
 *
 * Pure: the same points always give the same answer, so a restart recomputes
@@ -12272,34 +12843,6 @@ var HelperSpecSchema = discriminatedUnion("kind", [
 		/** Actuator groups only. Readings leave this unset. */
 		active: ActiveCriterionSchema.optional()
 	}),
-	object({
-		kind: literal("appliance"),
-		templateId: literal(APPLIANCE_TEMPLATE_ID),
-		appliance: _enum(APPLIANCE_KINDS),
-		thresholdWatts: number().positive(),
-		startDwellMs: number().int().nonnegative(),
-		stopDwellMs: number().int().nonnegative(),
-		member: HelperMemberSchema,
-		/**
-		* The plug that powers the appliance (`switch.on`). Optional: when set, the
-		* composition carries a `power-source` feature, so the hub can cut and restore
-		* that plug (power-source link of a NEW-target composition).
-		*/
-		powerSwitch: HelperMemberSchema.optional(),
-		/** How long a forced restart keeps the plug off; the cap's default when unset. */
-		offSeconds: number().optional()
-	}),
-	object({
-		kind: literal("heater"),
-		templateId: literal(HEATER_TEMPLATE_ID),
-		/** The plug, read and commanded at `switch.on`. */
-		plug: HelperMemberSchema,
-		/** The plug's power reading, when it has one: running is then the draw, not the switch. */
-		meter: HelperMemberSchema.optional(),
-		thresholdWatts: number().positive(),
-		startDwellMs: number().int().nonnegative(),
-		stopDwellMs: number().int().nonnegative()
-	}),
 	object({
 		kind: literal("statistic"),
 		stat: _enum(STATISTIC_STATS),
@@ -12471,7 +13014,14 @@ var CompositionForwardCommandSchema = object({
 	method: string().min(1),
 	args: record(string().min(1), CompositionForwardArgSchema).optional()
 });
-var CompositionCommandTargetSchema = discriminatedUnion("kind", [CompositionForwardCommandSchema, CompositionCodeSourceSchema]);
+var CompositionCommandTargetSchema = discriminatedUnion("kind", [
+	CompositionForwardCommandSchema,
+	CompositionCodeSourceSchema,
+	object({
+		kind: literal("extension"),
+		target: literal("remote")
+	})
+]);
 /** An item key inside an item-array cap (`consumables.items[<key>]`). */
 var COMPOSITION_ITEM_KEY_RE = /^[a-z0-9][a-z0-9-]{0,47}$/;
 /**
@@ -12516,7 +13066,7 @@ var CompositionSchema = object({
 		kind: literal("existing"),
 		device: CompositionSourceRefSchema
 	})]),
-	features: array(CompositionFeatureSchema).min(1).max(16),
+	features: array(CompositionFeatureSchema).min(0).max(16),
 	/**
 	* Present when the block is a helper template. Absent on a free
 	* composition (the room example, device 4603). The editor reads this,
@@ -12548,6 +13098,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().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().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().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().int().positive(),
+	messageId: string(),
+	receivedAt: number().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().int().nonnegative(),
+	/** The oldest seq still retained; messages below it are gone. */
+	oldestSeq: number().int().nonnegative(),
+	messages: array(object({
+		key: string(),
+		message: SmtpInboundMessageSchema
+	}))
+});
 new Set([
 	"track",
 	"face",
@@ -12667,6 +13284,205 @@ var IntegrationInstanceRefSchema = object({
 	]),
 	candidateStableId: string().optional()
 });
+/**
+* `RecordIntegrationInstances` - the `integration-instances` provider over ONE
+* entry kind, so an addon that holds a connection serves it in ~30 lines.
+*
+* Every instance is one record of the addon's own kind, keyed by the
+* `integrations` registry id. The records door does the secret work: a field the
+* kind marks `.meta({ secret: true })` is a keychain marker bound to the row, so
+* deleting the row deletes the secret, and one row's value is never another's.
+*
+* Patch rules for a secret (`updateInstance`): omitted, `''`, the redaction
+* token or the view the form was given KEEP the stored secret;
+* `{ $secretClear: true }` clears it; any other string replaces it.
+*/
+/** The most instances one addon lists (an integrations page, not a table). */
+var INSTANCES_LIST_MAX = 1e3;
+/** The keys of the kind's secret fields that sit at the top level of the body. */
+function topLevelSecretKeys(paths) {
+	return new Set(paths.filter((p) => !p.includes(".") && !p.includes("[") && !p.includes("{")));
+}
+/** The keys of the kind's top-level MAPS whose values are secrets (`applianceSecrets{}`). */
+function secretMapKeys(paths) {
+	return new Set(paths.filter((p) => p.endsWith("{}") && !p.slice(0, -2).match(/[.[{]/)).map((p) => p.slice(0, -2)));
+}
+/**
+* A patch value for a map of secrets: an entry that is omitted, `''`, the redaction token or the
+* view the form was given KEEPS its stored secret (it is left out of the merge); `{ $secretClear }`
+* or `null` removes the entry; any other string replaces it. Null when nothing is left to merge.
+*/
+function secretMapPatch(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+	const out = {};
+	for (const [key, entry] of Object.entries(value)) if (entry === null || isSecretClear(entry)) out[key] = null;
+	else if (typeof entry === "string" && entry !== "" && entry !== "__camstack_redacted__" && !isSecretFieldView(entry)) out[key] = entry;
+	return Object.keys(out).length > 0 ? out : null;
+}
+/** Does the kind's body schema carry an `enabled` field? */
+function declaresEnabled(kind) {
+	const json = toJSONSchema(kind.schema, {
+		unrepresentable: "any",
+		io: "input"
+	});
+	const properties = Reflect.get(json, "properties");
+	return typeof properties === "object" && properties !== null && "enabled" in properties;
+}
+var RecordIntegrationInstances = class {
+	records;
+	kind;
+	hooks;
+	handle;
+	secretKeys;
+	secretMaps;
+	nameField;
+	/** The `integrations` registry owns the on/off switch (`role: devices`); the body has none. */
+	registryOwnsEnabled;
+	constructor(records, kind, hooks) {
+		this.records = records;
+		this.kind = kind;
+		this.hooks = hooks;
+		this.handle = records.kind(kind);
+		this.secretKeys = topLevelSecretKeys(kind.declaration.secretPaths);
+		this.secretMaps = secretMapKeys(kind.declaration.secretPaths);
+		this.nameField = kind.declaration.entry?.nameField ?? "name";
+		this.registryOwnsEnabled = hooks.description.role === "devices";
+		if (this.registryOwnsEnabled && declaresEnabled(kind)) throw new Error(`kind "${kind.name}": the integrations registry owns the on/off switch of a role "devices" addon, so the body must not declare "enabled"`);
+	}
+	/**
+	* One instance read for the addon's own runtime; null when absent. When the keychain is
+	* locked the row is served WITHOUT its secrets and says so (`secrets: 'unavailable'`), so the
+	* caller can keep what it had instead of reconfiguring with an empty secret (D49).
+	*/
+	async readResolved(id) {
+		try {
+			const record = await this.handle.getResolved(id);
+			return record === null ? null : {
+				id,
+				body: record.data,
+				enabled: record.data.enabled !== false,
+				secrets: "resolved"
+			};
+		} catch (err) {
+			if (!(err instanceof RecordSecretUnavailableError)) throw err;
+			const stored = await this.handle.get(id);
+			if (stored === null) return null;
+			return {
+				id,
+				body: Object.fromEntries(Object.entries(stored.data).filter(([key]) => !this.secretKeys.has(key))),
+				enabled: stored.data.enabled !== false,
+				secrets: "unavailable"
+			};
+		}
+	}
+	/** The body of {@link readResolved} alone; a locked keychain yields the row without secrets. */
+	async getResolved(id) {
+		return (await this.readResolved(id))?.body ?? null;
+	}
+	/** Every instance, secrets resolved where the keychain allows; an absent one is skipped. */
+	async listResolved() {
+		const page = await this.handle.query({ limit: INSTANCES_LIST_MAX });
+		const out = [];
+		for (const record of page.records) {
+			const read = await this.readResolved(record.id);
+			if (read !== null) out.push(read);
+		}
+		return out;
+	}
+	viewOf(record) {
+		const shown = secretViewsOf(this.records.owner, this.kind.name, record.id, this.kind.declaration, record.data);
+		const rawName = record.data[this.nameField];
+		const kind = this.hooks.kindOf?.(record.data);
+		const health = this.hooks.health?.(record.data, record.id);
+		return {
+			id: record.id,
+			name: typeof rawName === "string" ? rawName : record.id,
+			configured: this.hooks.configured(record.data),
+			...this.registryOwnsEnabled ? {} : { enabled: record.data.enabled !== false },
+			formValues: shown,
+			...kind !== void 0 ? { kind } : {},
+			...health?.status !== void 0 ? { status: health.status } : {},
+			...health?.lastCheckedAt !== void 0 ? { lastCheckedAt: health.lastCheckedAt } : {}
+		};
+	}
+	describe = async () => this.hooks.mintId === void 0 ? this.hooks.description : {
+		...this.hooks.description,
+		mintsId: true
+	};
+	instanceFormSchema = async ({ id }) => this.hooks.formSchema(id);
+	listInstances = async () => {
+		return (await this.handle.query({ limit: INSTANCES_LIST_MAX })).records.map((record) => this.viewOf(record));
+	};
+	getInstance = async ({ id }) => {
+		const record = await this.handle.get(id);
+		return record === null ? null : this.viewOf(record);
+	};
+	/** Insert ONE row (`ifRev: 0`: an existing id is refused, never overwritten). */
+	createInstance = async ({ id, name, kind }) => {
+		const minted = id ?? this.hooks.mintId?.({
+			name,
+			...kind !== void 0 ? { kind } : {}
+		});
+		if (minted === void 0) throw new Error("createInstance needs an id: this provider does not mint one");
+		await this.handle.put({
+			id: minted,
+			data: this.hooks.initialBody(name, kind)
+		}, { ifRev: 0 });
+		await this.hooks.onChanged?.(minted, "created");
+		return { id: minted };
+	};
+	updateInstance = async ({ id, name, values }) => {
+		const patch = {};
+		for (const [key, value] of Object.entries(values)) {
+			if (value === void 0) continue;
+			if (this.secretMaps.has(key)) {
+				const entries = secretMapPatch(value);
+				if (entries !== null) patch[key] = entries;
+			} else if (!this.secretKeys.has(key)) patch[key] = value;
+			else if (isSecretClear(value)) patch[key] = null;
+			else if (typeof value === "string" && value !== "" && value !== "__camstack_redacted__" && !isSecretFieldView(value)) patch[key] = value;
+		}
+		if (name !== void 0) patch[this.nameField] = name;
+		await this.handle.patch(id, patch);
+		await this.hooks.onChanged?.(id, "updated");
+		return { ok: true };
+	};
+	/** The switch lives in the record body; the addon is told so it applies it (D996). */
+	setInstanceEnabled = async ({ id, enabled }) => {
+		if (this.registryOwnsEnabled) throw new Error(`instance "${id}": the integrations registry owns the on/off switch of this addon; set it with integrations.update`);
+		await this.handle.patch(id, { enabled });
+		await this.hooks.onChanged?.(id, "enabled");
+		return { ok: true };
+	};
+	/** The row and its keychain refs go together (the records door). */
+	deleteInstance = async ({ id }) => {
+		await this.handle.delete(id);
+		await this.hooks.onChanged?.(id, "deleted");
+		return { ok: true };
+	};
+	testInstance = async (input) => {
+		if (this.hooks.test === void 0) return {
+			success: false,
+			status: "unsupported",
+			error: "This integration declares no connection test"
+		};
+		return this.hooks.test(input);
+	};
+	/** The flat provider object to hand to `registerProvider`. */
+	toProvider() {
+		return {
+			describe: this.describe,
+			instanceFormSchema: this.instanceFormSchema,
+			listInstances: this.listInstances,
+			getInstance: this.getInstance,
+			createInstance: this.createInstance,
+			updateInstance: this.updateInstance,
+			setInstanceEnabled: this.setInstanceEnabled,
+			deleteInstance: this.deleteInstance,
+			testInstance: this.testInstance
+		};
+	}
+};
 var EncodeProfileSchema = object({
 	video: object({
 		codec: _enum([
@@ -13702,7 +14518,13 @@ var MigrationLedgerEntrySchema = object({
 	* joined by the engine from the catalogues it knows this boot. Absent when no
 	* catalogue lists the id (a newer database).
 	*/
-	meta: MigrationMetaSchema.optional()
+	meta: MigrationMetaSchema.optional(),
+	/**
+	* Set when this is an applied row of an addon owner whose catalogue the answering
+	* process has not loaded (the owner has not declared yet): the row is applied, the
+	* process just cannot judge it. Never `skipped-newer` — that needs the owner loaded.
+	*/
+	ownerNotLoaded: boolean().optional()
 });
 /** A catalogued migration that is not applied, with where it stands. */
 var MigrationPendingEntrySchema = object({
@@ -13736,6 +14558,149 @@ var MigrationOwnerStepSchema = object({
 	state: union([literal("pending"), MigrationStatusSchema])
 });
 /**
+* Move an integration's legacy `integration_settings` rows into a typed record of the addon's own
+* kind (planning#416, the one store). The record is keyed by the `integrations` registry id, so
+* the integration id, the devices stamped with it and the automations that name it do not change.
+*
+* Order, so a crash or a locked keychain is safe at every point:
+*
+*  1. Phase A, read only: every row of every integration of the addon is read with its secrets
+*     resolved. One that cannot be read (a locked keychain) throws, naming the integration, before
+*     anything is written; `block-owner` then holds the addon.
+*  2. Phase B, per integration: the addon's `bodyFrom` builds the body; the record is put with
+*     `ifRev: 0` (an existing record is never overwritten). A record this pass CREATED is read back
+*     and every secret leaf must equal what the rows held, else the record is deleted and the pass
+*     throws; an EXISTING record must hold every secret the rows carry, else the rows are kept and
+*     a warning names the path. Only then are the rows (and their keychain values) cleared.
+*
+* Idempotent: an integration whose rows are gone and whose record exists is skipped, so a rerun is
+* a no-op. A default integration with no rows still gets its record (an empty body, D985).
+* Never logs or throws a secret value; messages name integration ids and secret PATHS only.
+*/
+function secretLeavesOf(body, spec) {
+	const out = /* @__PURE__ */ new Map();
+	for (const leaf of collectSecretLeaves(body, spec.secretPaths, spec.secretArrayKeys ?? {})) if (typeof leaf.value === "string" && leaf.value.length > 0) out.set(leaf.concrete, leaf.value);
+	return out;
+}
+function why(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+async function moveIntegrationRowsToRecords(ports, spec) {
+	const integrations = await ports.listIntegrations(spec.addonId);
+	if (integrations.length === 0) return {
+		outcome: "already-done",
+		summary: { integrations: 0 }
+	};
+	const rowsOf = /* @__PURE__ */ new Map();
+	for (const integration of integrations) try {
+		rowsOf.set(integration.id, await ports.readRows(integration.id));
+	} catch (err) {
+		throw new Error(`integration '${integration.id}': the legacy settings cannot be read with their secrets (${why(err)}) - nothing moved`, { cause: err });
+	}
+	let created = 0;
+	let cleared = 0;
+	let kept = 0;
+	for (const integration of integrations) {
+		const values = rowsOf.get(integration.id) ?? {};
+		const hasRows = Object.keys(values).length > 0;
+		const body = spec.bodyFrom(values, ports, integration);
+		const put = await ports.putRecord(integration.id, body);
+		if (put === "created") created += 1;
+		if (!hasRows) continue;
+		const wanted = secretLeavesOf(body, spec);
+		const back = await ports.readRecord(integration.id);
+		if (back === null) throw new Error(`integration '${integration.id}': the record is gone after it was put`);
+		const held = secretLeavesOf(back, spec);
+		if (put === "created") {
+			const wrong = [...wanted].filter(([path, value]) => held.get(path) !== value).map(([p]) => p);
+			if (wrong.length > 0) {
+				await ports.deleteRecord(integration.id);
+				throw new Error(`integration '${integration.id}': ${wrong.join(", ")} did not read back from the record - the record was removed and the legacy settings are kept`);
+			}
+		} else {
+			const missing = [...wanted].filter(([path]) => !held.has(path)).map(([p]) => p);
+			if (missing.length > 0) {
+				ports.warn(`integration '${integration.id}': the existing record holds no ${missing.join(", ")}; the legacy settings are kept, not cleared`);
+				kept += 1;
+				continue;
+			}
+		}
+		await ports.clearRows(integration.id);
+		cleared += 1;
+	}
+	return created === 0 && cleared === 0 ? {
+		outcome: "already-done",
+		summary: {
+			integrations: integrations.length,
+			kept
+		}
+	} : {
+		outcome: "done",
+		summary: {
+			integrations: integrations.length,
+			created,
+			cleared,
+			kept
+		}
+	};
+}
+/**
+* The addon-side ports of `moveIntegrationRowsToRecords` (planning#416): an addon runs the move
+* from its own process, so the legacy rows are reached through the hub (`ctx.api.integrations`:
+* `list`, `getSettings` - which answers the OWNER its secrets resolved - and `clearSettings`) and
+* the new record through the addon's own records handle. The hub deletes the rows and their
+* keychain values; the addon never touches the registry.
+*/
+function integrationRowsPortsOverApi(deps) {
+	return {
+		warn: (message) => deps.log.warn(message),
+		listIntegrations: async (addonId) => (await deps.api.list()).filter((i) => i.addonId === addonId).map((i) => ({
+			id: i.id,
+			name: i.name
+		})),
+		readRows: (integrationId) => deps.api.getSettings({ id: integrationId }),
+		putRecord: async (id, body) => {
+			if (await deps.records.get(id) !== null) return "exists";
+			try {
+				await deps.records.put({
+					id,
+					data: body
+				}, { ifRev: 0 });
+			} catch (err) {
+				if (err instanceof RevConflictError) return "exists";
+				throw err;
+			}
+			return "created";
+		},
+		readRecord: async (id) => (await deps.records.getResolved(id))?.data ?? null,
+		deleteRecord: async (id) => {
+			await deps.records.delete(id);
+		},
+		clearRows: async (integrationId) => {
+			await deps.api.clearSettings({ id: integrationId });
+		}
+	};
+}
+function defaultIntegrationApiOver(api) {
+	return {
+		list: () => api.integrations.list.query(),
+		getSettings: (input) => api.integrations.getSettings.query(input),
+		clearSettings: (input) => api.integrations.clearSettings.mutate(input),
+		listDevices: (addonId) => api.deviceManager.listAll.query({
+			addonId,
+			projection: "slim"
+		}),
+		setDeviceIntegrationId: async (deviceId, integrationId) => {
+			await api.deviceManager.setIntegrationId.mutate({
+				deviceId,
+				integrationId
+			});
+		},
+		readDeviceHasConfig: async (deviceId) => Object.keys((await api.deviceManager.getDevice.query({ deviceId }))?.config ?? {}).length > 0,
+		readDeviceIntegrationId: async (deviceId) => (await api.deviceManager.getDevice.query({ deviceId }))?.integrationId ?? null
+	};
+}
+/**
 * The trainer contract — what the hub hands the cloud trainer and what it
 * gets back (cloud training, D805+).
 *
@@ -18820,24 +19785,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",
@@ -18853,8 +19846,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",
@@ -18868,35 +19861,63 @@ 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": {
 		scope: "device",
 		noun: t("Media player", "Lettore multimediale"),
 		actions: [
+			{
+				id: "media.turnOn",
+				method: "turnOn",
+				label: t("Turn on", "Accendi"),
+				phrase: t("Turn on {device}", "Accendi {device}"),
+				icon: "power"
+			},
+			{
+				id: "media.turnOff",
+				method: "turnOff",
+				label: t("Turn off", "Spegni"),
+				phrase: t("Turn off {device}", "Spegni {device}"),
+				icon: "power"
+			},
+			{
+				id: "media.volumeUp",
+				method: "volumeUp",
+				label: t("Volume up", "Alza il volume"),
+				phrase: t("Raise the volume of {device}", "Alza il volume di {device}"),
+				icon: "volume-2"
+			},
+			{
+				id: "media.volumeDown",
+				method: "volumeDown",
+				label: t("Volume down", "Abbassa il volume"),
+				phrase: t("Lower the volume of {device}", "Abbassa il volume di {device}"),
+				icon: "volume-2"
+			},
+			{
+				id: "media.channelUp",
+				method: "channelUp",
+				label: t("Channel up", "Canale successivo"),
+				phrase: t("Go to the next channel on {device}", "Passa al canale successivo su {device}"),
+				icon: "skip-forward"
+			},
+			{
+				id: "media.channelDown",
+				method: "channelDown",
+				label: t("Channel down", "Canale precedente"),
+				phrase: t("Go to the previous channel on {device}", "Torna al canale precedente su {device}"),
+				icon: "skip-back"
+			},
 			{
 				id: "media.play",
 				method: "play",
@@ -20783,6 +21804,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),
@@ -45692,6 +46714,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
@@ -48381,6 +49446,244 @@ var controlCapability = {
 	*/
 	history: "none"
 };
+/**
+* Media-player cap. Models HA `media_player.*` (Sonos, Chromecast,
+* Apple TV, Spotify, Roku, generic OTT receivers, …) on
+* `DeviceType.MediaPlayer`. Disjoint from the camera streaming
+* surface — those use `DeviceType.Camera` + the broker pipeline.
+*
+* The cap declares a wide method surface; not every backend supports
+* every method. Drivers signal sub-capability via the
+* `DeviceFeature.MediaPlayerXxx` flags (paired one-to-one with the
+* corresponding method) so the UI gates buttons without a slice
+* fetch — same pattern as `PanTiltZoom` for cameras.
+*/
+var MediaPlayerStateSchema = _enum([
+	"off",
+	"on",
+	"idle",
+	"playing",
+	"paused",
+	"buffering",
+	"standby"
+]);
+var MediaPlayerRepeatSchema = _enum([
+	"off",
+	"all",
+	"one"
+]);
+var MediaInfoSchema = object({
+	/** Free-form media kind (`music`, `tvshow`, `movie`, `app`, `channel`,
+	*  `podcast`, …). */
+	type: string(),
+	/** Human-readable title. */
+	title: string(),
+	/** Optional artist / channel / station label. */
+	artist: string().optional(),
+	/** Optional album / season / show name. */
+	album: string().optional(),
+	/** Optional cover-art / thumbnail URL. */
+	imageUrl: string().optional()
+});
+/**
+* Where `state`, `volumeLevel`, `isMuted` and `source` come from. `reported`:
+* the device said so. `assumed`: the driver has no feedback (infrared) and
+* tracks what it last SENT; it moves only after a send was accepted, and a
+* human at the real remote makes it wrong. A UI shows an assumed value as a
+* guess, never as a reading.
+*/
+var MediaPlayerStateSourceSchema = _enum(["reported", "assumed"]);
+/** The fields of a media-player status a driver can only guess. */
+var MediaPlayerAssumedFieldSchema = _enum([
+	"state",
+	"volumeLevel",
+	"isMuted",
+	"source"
+]);
+var MediaPlayerStatusSchema = object({
+	/** Playback lifecycle state. */
+	state: MediaPlayerStateSchema,
+	/**
+	* Whether the state fields are readings or the driver's own bookkeeping.
+	* A slice written before this field existed parses as `reported`.
+	*/
+	stateSource: MediaPlayerStateSourceSchema.default("reported"),
+	/**
+	* Which fields are the driver's own guess. `stateSource` is `assumed` when
+	* this is not empty; a field not listed here is a reading even then (power
+	* from a running-state source, mute guessed from the last send).
+	*/
+	assumedFields: array(MediaPlayerAssumedFieldSchema).default([]),
+	/** Volume as 0..100 inclusive. Null when the device has no volume
+	*  surface. Pair with `DeviceFeature.MediaPlayerVolume`. */
+	volumeLevel: number().min(0).max(100).nullable().meta(readingMeta("percentage")),
+	/** Mute toggle distinct from volume=0. Null when no mute surface.
+	*  Pair with `DeviceFeature.MediaPlayerMute`. */
+	isMuted: boolean().nullable(),
+	/** Active source / input. Empty when no source surface. */
+	source: string(),
+	/** Selectable sources. Empty when no source surface.
+	*  Pair with `DeviceFeature.MediaPlayerSelectSource`. */
+	availableSources: array(string()),
+	/** Currently-playing media info. Null when nothing is playing. */
+	currentMedia: MediaInfoSchema.nullable(),
+	/** Current playback position in ms. Null when not seekable or
+	*  nothing is playing. Pair with `DeviceFeature.MediaPlayerSeek`. */
+	position: number().int().nonnegative().nullable().meta(readingMeta("duration-ms")),
+	/** Total duration of the current media in ms. Null when unknown
+	*  (live stream) or nothing is playing. */
+	duration: number().int().nonnegative().nullable().meta(readingMeta("duration-ms")),
+	/** Shuffle toggle. Null when no shuffle surface.
+	*  Pair with `DeviceFeature.MediaPlayerShuffle`. */
+	shuffle: boolean().nullable(),
+	/** Repeat mode. Null when no repeat surface.
+	*  Pair with `DeviceFeature.MediaPlayerRepeat`. */
+	repeat: MediaPlayerRepeatSchema.nullable(),
+	/** Ms epoch when the slice was last updated. */
+	lastChangedAt: number()
+});
+var stepInput = object({
+	deviceId: number().int().nonnegative(),
+	/** How many presses: the caller's count (Alexa `volumeSteps`, `channelCount`). */
+	steps: number().int().min(1).max(50).default(1)
+});
+var deviceOnly = object({ deviceId: number().int().nonnegative() });
+var mediaPlayerCapability = {
+	name: "media-player",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: [DeviceType.MediaPlayer],
+	methods: {
+		turnOn: method(deviceOnly, _void(), {
+			kind: "mutation",
+			auth: "protected"
+		}),
+		turnOff: method(deviceOnly, _void(), {
+			kind: "mutation",
+			auth: "protected"
+		}),
+		volumeUp: method(stepInput, _void(), {
+			kind: "mutation",
+			auth: "protected"
+		}),
+		volumeDown: method(stepInput, _void(), {
+			kind: "mutation",
+			auth: "protected"
+		}),
+		channelUp: method(stepInput, _void(), {
+			kind: "mutation",
+			auth: "protected"
+		}),
+		channelDown: method(stepInput, _void(), {
+			kind: "mutation",
+			auth: "protected"
+		}),
+		play: method(object({ deviceId: number().int().nonnegative() }), _void(), {
+			kind: "mutation",
+			auth: "protected"
+		}),
+		pause: method(object({ deviceId: number().int().nonnegative() }), _void(), {
+			kind: "mutation",
+			auth: "protected"
+		}),
+		stop: method(object({ deviceId: number().int().nonnegative() }), _void(), {
+			kind: "mutation",
+			auth: "protected"
+		}),
+		next: method(object({ deviceId: number().int().nonnegative() }), _void(), {
+			kind: "mutation",
+			auth: "protected"
+		}),
+		previous: method(object({ deviceId: number().int().nonnegative() }), _void(), {
+			kind: "mutation",
+			auth: "protected"
+		}),
+		seek: method(object({
+			deviceId: number().int().nonnegative(),
+			position: number().int().nonnegative()
+		}), _void(), {
+			kind: "mutation",
+			auth: "protected"
+		}),
+		setVolume: method(object({
+			deviceId: number().int().nonnegative(),
+			volumeLevel: number().min(0).max(100)
+		}), _void(), {
+			kind: "mutation",
+			auth: "protected"
+		}),
+		setMute: method(object({
+			deviceId: number().int().nonnegative(),
+			muted: boolean()
+		}), _void(), {
+			kind: "mutation",
+			auth: "protected"
+		}),
+		setShuffle: method(object({
+			deviceId: number().int().nonnegative(),
+			shuffle: boolean()
+		}), _void(), {
+			kind: "mutation",
+			auth: "protected"
+		}),
+		setRepeat: method(object({
+			deviceId: number().int().nonnegative(),
+			repeat: MediaPlayerRepeatSchema
+		}), _void(), {
+			kind: "mutation",
+			auth: "protected"
+		}),
+		selectSource: method(object({
+			deviceId: number().int().nonnegative(),
+			source: string().min(1)
+		}), _void(), {
+			kind: "mutation",
+			auth: "protected"
+		}),
+		playMedia: method(object({
+			deviceId: number().int().nonnegative(),
+			/** Media identifier / URL. */
+			mediaId: string().min(1),
+			/** Media kind (`music`, `tvshow`, `movie`, `app`, …) — provider
+			*  passes it through to the upstream service. */
+			mediaType: string().min(1)
+		}), _void(), {
+			kind: "mutation",
+			auth: "protected"
+		})
+	},
+	status: {
+		schema: MediaPlayerStatusSchema,
+		kind: "push"
+	},
+	/**
+	* Runtime-state slice — mirrored by the kernel. UI players read the
+	* full slice for live now-playing, volume, and progress updates
+	* without polling.
+	*/
+	runtimeState: MediaPlayerStatusSchema,
+	/**
+	* Runtime-state durability: **session** — a restored transport position describes a playback that stopped when the hub did.
+	*
+	* See `RuntimeStateDurability`. Enforced by
+	* `scripts/check-runtime-state-durability.ts`.
+	*/
+	durability: "session",
+	/**
+	* History (D850): volume (a level an operator or an automation sets; the
+	* default 10 s floor folds a slider drag into its end value) and mute.
+	* `position` is not recorded: it moves continuously while playing.
+	*/
+	history: { fields: {
+		volumeLevel: {
+			kind: "gauge",
+			unit: "%",
+			deadband: 1
+		},
+		isMuted: { kind: "boolean" }
+	} }
+};
 DeviceType.Camera, DeviceType.Sensor, DeviceType.Button, DeviceType.Switch, DeviceType.PetFeeder, DeviceType.Container, DeviceType.Thermostat, DeviceType.EventEmitter, DeviceType.Camera, DeviceType.Hub, DeviceType.Light, DeviceType.Siren, DeviceType.Switch, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.Fan, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder, DeviceType.PetFountain, DeviceType.Dishwasher, DeviceType.Washer, DeviceType.Heater, DeviceType.Dryer, DeviceType.Gateway, DeviceType.Camera, DeviceType.Fan, DeviceType.Lock, DeviceType.Camera, DeviceType.Switch, DeviceType.Light, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.MediaPlayer, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.PetFeeder, DeviceType.Heater, DeviceType.Switch, DeviceType.Light, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.MediaPlayer, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.PetFeeder, DeviceType.Heater, DeviceType.Switch, DeviceType.Light, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.MediaPlayer, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.PetFeeder, DeviceType.Heater, DeviceType.Switch, DeviceType.Light, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.MediaPlayer, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.PetFeeder, DeviceType.Heater, DeviceType.Gateway, DeviceType.Hub, DeviceType.Camera, DeviceType.Sensor, DeviceType.MediaPlayer, DeviceType.Vacuum, DeviceType.Generic, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.PetFountain, DeviceType.Fan, DeviceType.Humidifier, DeviceType.Climate, DeviceType.WaterHeater, DeviceType.MediaPlayer, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.MediaPlayer, DeviceType.WaterHeater, DeviceType.Humidifier, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.PetFeeder, DeviceType.Heater;
 var NUMBER = {
 	kind: "fixed",
@@ -48828,117 +50131,6 @@ function actuator(input) {
 	};
 }
 new Map(GROUP_TEMPLATES.map((template) => [template.id, template]));
-var PowerSourceRefusalReasonSchema = _enum([
-	"no-power-source",
-	"switch-missing",
-	"switch-offline",
-	"switch-unknown",
-	"restart-in-progress",
-	"switch-call-failed"
-]);
-var PowerSourceActionResultSchema = discriminatedUnion("accepted", [object({ accepted: literal(true) }), object({
-	accepted: literal(false),
-	reason: PowerSourceRefusalReasonSchema,
-	/** One line for the operator, naming the switch. */
-	message: string()
-})]);
-var PowerSourceInfoSchema = object({
-	/** False when the device has no power source linked; the rest is then empty. */
-	linked: boolean(),
-	switchDeviceId: number().nullable(),
-	switchName: string().nullable(),
-	/** The switch's on/off state, or null when it is unknown. Never false for unknown (D393). */
-	switchOn: boolean().nullable(),
-	switchOnline: boolean().nullable(),
-	restartInProgress: boolean(),
-	offSeconds: number().int()
-});
-/** The composed slice: the switch state the link mirrors, plus the stored off time. */
-var PowerSourceStateSchema = object({
-	/** Null while the switch has not reported: unknown is never `false` (D393). */
-	switchOn: boolean().nullable(),
-	offSeconds: number().int(),
-	lastFetchedAt: number()
-});
-var POWER_SOURCE_DEVICE_TYPES = [
-	DeviceType.Gateway,
-	DeviceType.Hub,
-	DeviceType.Camera,
-	DeviceType.Sensor,
-	DeviceType.MediaPlayer,
-	DeviceType.Vacuum,
-	DeviceType.Generic,
-	DeviceType.Washer,
-	DeviceType.Dryer,
-	DeviceType.Dishwasher,
-	DeviceType.PetFountain,
-	DeviceType.Fan,
-	DeviceType.Humidifier,
-	DeviceType.Climate,
-	DeviceType.WaterHeater
-];
-var powerSourceCustomize = {
-	version: 1,
-	targets: [{
-		id: "switch",
-		cardinality: "scalar",
-		vocabulary: {
-			cap: "power-source",
-			stateField: "switchOn"
-		},
-		deviceTypes: POWER_SOURCE_DEVICE_TYPES,
-		apply: "add",
-		path: "switchOn",
-		sources: [{
-			kind: "switch",
-			transforms: [{ kind: "identity" }]
-		}],
-		companions: [{
-			kind: "constant",
-			path: "offSeconds",
-			value: 10,
-			when: "add"
-		}, {
-			kind: "clock",
-			path: "lastFetchedAt",
-			when: "always"
-		}],
-		sourceReport: { status: "assignment-status" }
-	}]
-};
-var deviceInput$2 = object({ deviceId: number().int().nonnegative() });
-var powerSourceCapability = {
-	name: "power-source",
-	scope: "device",
-	mode: "singleton",
-	deviceTypes: POWER_SOURCE_DEVICE_TYPES,
-	methods: {
-		getStatus: systemMethod(deviceInput$2, PowerSourceInfoSchema, { auth: "admin" }),
-		powerOn: systemMethod(deviceInput$2, PowerSourceActionResultSchema, {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		powerOff: systemMethod(deviceInput$2, PowerSourceActionResultSchema, {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		forceRestart: systemMethod(deviceInput$2, PowerSourceActionResultSchema, {
-			kind: "mutation",
-			auth: "admin"
-		})
-	},
-	runtimeState: PowerSourceStateSchema,
-	customize: powerSourceCustomize,
-	/**
-	* Runtime-state durability: **session** — mirrored from the linked switch on
-	* its next report; a restored value would outlive the reading it names.
-	*
-	* See `RuntimeStateDurability`. Enforced by
-	* `scripts/check-runtime-state-durability.ts`.
-	*/
-	durability: "session",
-	history: "none"
-};
 DeviceFeature.LightColorRgb, DeviceFeature.LightColorHsv, DeviceFeature.LightColorMired;
 DeviceType.Camera;
 `${COMPOSED_DEVICE_STABLE_ID_PREFIX}`;
@@ -48966,6 +50158,165 @@ var ComposableCapabilitiesSchema = object({ caps: array(object({
 	}).optional()
 })) });
 /**
+* A saved Customize assignment (D936). The schema is the type: callers use
+* `z.infer`, they do not restate the shape.
+*/
+var OverrideSourceSchema = object({
+	addonId: string().min(1),
+	stableId: string().min(1),
+	cap: string().min(1),
+	fieldPath: string().min(1)
+});
+var IdentityTransformDraftSchema = object({ kind: literal("identity") });
+var InvertTransformDraftSchema = object({ kind: literal("invert") });
+var ThresholdTransformDraftSchema = object({
+	kind: literal("threshold"),
+	comparison: _enum(["gte", "lte"]),
+	threshold: number(),
+	startDwellMs: number().nonnegative(),
+	stopDwellMs: number().nonnegative()
+});
+var CustomizeTransformDraftSchema = discriminatedUnion("kind", [
+	IdentityTransformDraftSchema,
+	InvertTransformDraftSchema,
+	ThresholdTransformDraftSchema,
+	object({
+		kind: literal("linear"),
+		scale: number(),
+		offset: number(),
+		clampMin: number().optional(),
+		clampMax: number().optional()
+	}),
+	object({
+		kind: literal("enum-map"),
+		mapping: record(string(), string().nullable())
+	}),
+	object({ kind: literal("number") })
+]);
+var ScalarOverrideDraftSchema = object({
+	kind: literal("scalar"),
+	cap: string().min(1),
+	targetId: string().min(1),
+	source: OverrideSourceSchema,
+	transform: CustomizeTransformDraftSchema
+});
+var KeyedArrayOverrideDraftSchema = object({
+	kind: literal("keyedArray"),
+	cap: string().min(1),
+	targetId: string().min(1),
+	key: string().min(1),
+	label: string().min(1),
+	fieldPath: string().min(1),
+	source: OverrideSourceSchema,
+	transform: CustomizeTransformDraftSchema
+});
+var PulseOverrideDraftSchema = object({
+	kind: literal("pulse"),
+	cap: string().min(1),
+	targetId: string().min(1),
+	enabled: boolean(),
+	debounceMs: number().nonnegative(),
+	edges: array(_enum([
+		"rising",
+		"button",
+		"native-event"
+	])).min(1).optional(),
+	sources: array(OverrideSourceSchema).min(1)
+});
+var SpanSourceDraftSchema = OverrideSourceSchema.extend({ mode: _enum([
+	"in-addition",
+	"confirm",
+	"replace"
+]).optional() });
+discriminatedUnion("kind", [
+	ScalarOverrideDraftSchema,
+	KeyedArrayOverrideDraftSchema,
+	PulseOverrideDraftSchema,
+	object({
+		kind: literal("span"),
+		cap: string().min(1),
+		targetId: string().min(1),
+		timeoutMs: number().nonnegative(),
+		cooldownMs: number().nonnegative().optional(),
+		sources: array(SpanSourceDraftSchema)
+	})
+]);
+object({
+	targetId: string().min(1),
+	configured: boolean(),
+	source: _enum(["native", "assigned"]),
+	state: _enum([
+		"active",
+		"stale",
+		"released",
+		"unavailable"
+	]),
+	reason: string().nullable()
+});
+/**
+* What a running-threshold proposal says (planning#405). The schema is the
+* type: the algorithm, the capability method and the UI all read `z.infer`.
+*
+* A proposal is read-only advice: it carries the numbers it was derived from
+* (`evidence`) so the operator can judge it, and an `insufficient` answer names
+* WHY with a typed reason and the catalog defaults, never an invented number.
+*/
+var RunningProposalTierSchema = _enum(["raw", "5m"]);
+var RunningProposalConfidenceSchema = _enum([
+	"high",
+	"medium",
+	"low"
+]);
+var RunningProposalInsufficientReasonSchema = _enum([
+	"no-history",
+	"span-too-short",
+	"truncated",
+	"no-idle-floor",
+	"no-runs",
+	"no-separation"
+]);
+var RunningProposalReplaySchema = object({
+	/** Intervals the real dwell expression held true over the window. */
+	intervals: number().int().nonnegative(),
+	/** Intervals outside every run, or a second interval inside one. */
+	extra: number().int().nonnegative(),
+	/** Runs without an interval of their own (none, or merged into a neighbour). */
+	missed: number().int().nonnegative()
+});
+var RunningProposalEvidenceSchema = object({
+	tier: RunningProposalTierSchema,
+	spanMs: number().nonnegative(),
+	from: number(),
+	to: number(),
+	points: number().int().nonnegative(),
+	runsFound: number().int().nonnegative(),
+	pausesFound: number().int().nonnegative(),
+	longestPauseMs: number().nonnegative(),
+	idleFloorW: number(),
+	noiseCeilingW: number(),
+	plateauW: number(),
+	replay: RunningProposalReplaySchema
+});
+var RunningProposalInsufficientEvidenceSchema = object({
+	spanMs: number().nonnegative(),
+	points: number().int().nonnegative(),
+	runsFound: number().int().nonnegative()
+});
+var RunningThresholdProposalSchema = discriminatedUnion("state", [object({
+	state: literal("proposal"),
+	transform: ThresholdTransformDraftSchema,
+	evidence: RunningProposalEvidenceSchema,
+	confidence: RunningProposalConfidenceSchema,
+	/** Why the confidence is not higher; empty when nothing held it back. */
+	notes: array(string())
+}), object({
+	state: literal("insufficient"),
+	reason: RunningProposalInsufficientReasonSchema,
+	evidence: RunningProposalInsufficientEvidenceSchema,
+	/** The catalog defaults, offered as what stands when nothing better is known. */
+	fallback: ThresholdTransformDraftSchema
+})]);
+/**
 * The report of a one-shot "move this owner's plaintext secrets into the
 * keychain" run (D878). COUNTS only - never a value, never a ref.
 *
@@ -49255,6 +50606,14 @@ method(object({}), object({ blocks: array(CoreBlockSchema) }), { auth: "admin" }
 	kind: "mutation",
 	auth: "admin",
 	access: "view"
+}), method(object({
+	deviceId: number().int(),
+	cap: string().min(1),
+	fieldPath: string().min(1),
+	deviceType: _enum(DeviceType).optional()
+}), RunningThresholdProposalSchema, {
+	auth: "admin",
+	access: "view"
 }), method(object({
 	blockId: string().min(1),
 	trace: AutomationRunTraceSchema.optional(),
@@ -50231,7 +51590,27 @@ method(object({
 * exposes only the COMMON surface: link state, supported device
 * kinds (so the UI can filter the device picker), and per-device
 * expose/unexpose.
-*/
+*
+* INSTANCES. One export addon can serve several independent targets (a
+* HomeKit bridge, a Home Assistant broker). `listInstances` names them.
+* `instanceId` on a READ is optional: absent = the whole addon (linked if any
+* enabled instance is, `exposedDeviceCount` = distinct devices, `setup` = the
+* default instance's); present = that instance; an id the provider does not
+* serve is refused with `ExportInstanceUnknownError` (`export-instance-unknown`),
+* never answered empty. `instanceId` on a WRITE is REQUIRED: a membership
+* change always names the target it changes. A single-instance provider
+* accepts an absent id on a read or its own id, and refuses any other.
+*/
+/** Which instance of an export addon a call addresses. Absent on a read = the whole addon. */
+var InstanceIdSchema$1 = string().min(1);
+var InstancePinSchema = object({ instanceId: InstanceIdSchema$1.optional() });
+/** One independent export target of an addon. */
+var ExportInstanceSchema = object({
+	instanceId: InstanceIdSchema$1,
+	name: string(),
+	enabled: boolean(),
+	kind: string().optional()
+});
 var LinkStateSchema = _enum([
 	"unlinked",
 	"linked",
@@ -50282,10 +51661,14 @@ var ExposedDeviceSchema = object({
 	capabilities: array(string()).optional()
 });
 var ExposeInputSchema = object({
+	instanceId: InstanceIdSchema$1,
 	deviceId: string(),
 	capabilities: array(string()).optional()
 });
-var UnexposeInputSchema = object({ deviceId: string() });
+var UnexposeInputSchema = object({
+	instanceId: InstanceIdSchema$1,
+	deviceId: string()
+});
 /**
 * What an exporter may expose besides devices (D968). An action and a
 * notification target are LIST ENTRIES, never devices (D954): they enter an
@@ -50314,15 +51697,21 @@ var ExposedEntitySchema = object({
 	entity: ExportEntityRefSchema,
 	exposedAs: string().optional()
 });
-var ExposeEntityInputSchema = object({ entity: ExportEntityRefSchema });
-var UnexposeEntityInputSchema = object({ entity: ExportEntityRefSchema });
-method(_void(), DeviceExportStatusSchema), method(_void(), array(DeviceKindSchema)), method(_void(), array(ExposedDeviceSchema)), method(ExposeInputSchema, _void(), {
+var ExposeEntityInputSchema = object({
+	instanceId: InstanceIdSchema$1,
+	entity: ExportEntityRefSchema
+});
+var UnexposeEntityInputSchema = object({
+	instanceId: InstanceIdSchema$1,
+	entity: ExportEntityRefSchema
+});
+method(InstancePinSchema, DeviceExportStatusSchema), method(_void(), array(ExportInstanceSchema)), method(InstancePinSchema, array(DeviceKindSchema)), method(InstancePinSchema, array(ExposedDeviceSchema)), method(ExposeInputSchema, _void(), {
 	kind: "mutation",
 	auth: "admin"
 }), method(UnexposeInputSchema, _void(), {
 	kind: "mutation",
 	auth: "admin"
-}), optionalMethod(_void(), array(ExportEntityKindSchema)), optionalMethod(_void(), array(ExposedEntitySchema)), optionalMethod(ExposeEntityInputSchema, _void(), {
+}), optionalMethod(_void(), array(ExportEntityKindSchema)), optionalMethod(InstancePinSchema, array(ExposedEntitySchema)), optionalMethod(ExposeEntityInputSchema, _void(), {
 	kind: "mutation",
 	auth: "admin"
 }), optionalMethod(UnexposeEntityInputSchema, _void(), {
@@ -52324,7 +53713,7 @@ var DishwasherStatusSchema = object({
 	/** Ms epoch of the last value received from the appliance; 0 = never. */
 	lastFetchedAt: number()
 });
-var DeviceIdSchema$1 = number().int().nonnegative();
+var DeviceIdSchema$2 = number().int().nonnegative();
 /** A value a program option or setting can take. */
 var DishwasherValueSchema = union([
 	boolean(),
@@ -52399,77 +53788,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",
@@ -52481,7 +53870,7 @@ var dishwasherCapability = {
 		* its declared range / members.
 		*/
 		setOption: method(object({
-			deviceId: DeviceIdSchema$1,
+			deviceId: DeviceIdSchema$2,
 			key: string().min(1),
 			value: DishwasherValueSchema
 		}), _void(), {
@@ -52489,7 +53878,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,
@@ -53913,15 +55302,15 @@ var FanPresetCaptureResultSchema = object({
 	items: array(FanCaptureItemSchema),
 	omitted: array(FanCaptureOmissionSchema)
 });
-var deviceInput$1 = object({ deviceId: number().int().nonnegative() });
+var deviceInput$2 = object({ deviceId: number().int().nonnegative() });
 DeviceType.Fan;
-method(deviceInput$1, array(FanPresetSchema), { auth: "protected" }), method(deviceInput$1.extend({ presets: array(FanPresetSchema).max(12) }), FanPresetsSetResultSchema, {
+method(deviceInput$2, array(FanPresetSchema), { auth: "protected" }), method(deviceInput$2.extend({ presets: array(FanPresetSchema).max(12) }), FanPresetsSetResultSchema, {
 	kind: "mutation",
 	auth: "admin"
-}), method(deviceInput$1.extend({ presetId: string().min(1) }), FanPresetApplyResultSchema, {
+}), method(deviceInput$2.extend({ presetId: string().min(1) }), FanPresetApplyResultSchema, {
 	kind: "mutation",
 	auth: "protected"
-}), method(deviceInput$1.extend({
+}), method(deviceInput$2.extend({
 	fields: array(FanCaptureFieldSchema).optional(),
 	steps: array(ActionStepSchema).max(20).default([])
 }), FanPresetCaptureResultSchema, { auth: "protected" });
@@ -54804,6 +56193,12 @@ method(_void(), array(IntegrationWithStateSchema)), method(object({ id: string()
 }), object({ success: boolean() }), {
 	kind: "mutation",
 	auth: "admin"
+}), method(object({ id: string() }), object({
+	rows: number().int().nonnegative(),
+	secrets: number().int().nonnegative()
+}), {
+	kind: "mutation",
+	auth: "admin"
 }), method(_void(), array(AvailableIntegrationTypeSchema), { auth: "admin" }), method(object({
 	addonId: string(),
 	settings: record(string(), unknown())
@@ -54832,13 +56227,65 @@ method(_void(), array(IntegrationWithStateSchema)), method(object({ id: string()
 */
 var ConfigSchemaPassthrough$3 = custom();
 var IntegrationInstanceIdSchema = string().min(1);
+var IntegrationInstanceModeSchema = _enum(["single", "multiple"]);
+/**
+* One kind of instance a provider can create (an adapter, an account type). The sign-in and
+* connect fields follow the `broker` contract (`broker.cap.ts`): `signIn.basePath` is a
+* hub-relative route set speaking the sign-in contract, `connectPath` / `disconnectPath` open an
+* interactive account link (popup) and may carry `{{brokerId}}`, which the UI replaces with the
+* instance id.
+*/
+var IntegrationInstanceKindSchema = object({
+	/** Stable id of the kind, sent back as `createInstance.kind`. */
+	id: string().min(1),
+	label: string().min(1),
+	/** The kind signs in through a server-held interactive session. */
+	signIn: object({
+		basePath: string().min(1),
+		methods: array(_enum(["device-code", "proxy"])).optional()
+	}).optional(),
+	/** Relative hub path to start an interactive account link of an instance of this kind. */
+	connectPath: string().min(1).optional(),
+	/** Relative hub path to disconnect that account. */
+	disconnectPath: string().min(1).optional()
+});
 var IntegrationInstanceDescriptionSchema = object({
+	/** What the instances are for the Integrations page; see {@link IntegrationInstanceRoleSchema}. */
+	role: _enum([
+		"devices",
+		"services",
+		"both"
+	]),
+	/** How the devices of an instance are found; absent means `{ mode: 'none' }`. */
+	discovery: object({
+		mode: _enum([
+			"none",
+			"lan",
+			"account"
+		]),
+		scopedToInstance: boolean()
+	}).optional(),
 	/** `single`: at most one instance can exist (Loki). `multiple`: an account each. */
-	instanceMode: _enum(["single", "multiple"]),
+	instanceMode: IntegrationInstanceModeSchema,
 	/** What the instance is, for the UI (`destination`, `relay`, `account`). */
 	kind: string(),
 	/** True when `testInstance` really probes the remote. */
-	canTest: boolean()
+	canTest: boolean(),
+	/**
+	* The kinds an instance can be of. Absent or one entry: nothing to choose; more than one: the
+	* Add flow asks which first and sends it as `createInstance.kind`.
+	*/
+	kinds: array(IntegrationInstanceKindSchema).optional(),
+	/**
+	* The provider accepts `createInstance.id` for an id that once existed (an adopted id, because
+	* devices carry it). The UI then offers "restore under its old id" on Add. Absent means no.
+	*/
+	allowRestoreId: boolean().optional(),
+	/**
+	* `createInstance` without an `id` works: the provider mints it. Absent means the caller must
+	* send an id (the UI then mints an opaque one).
+	*/
+	mintsId: boolean().optional()
 });
 var IntegrationInstanceStatusSchema = object({
 	state: _enum([
@@ -54847,16 +56294,28 @@ var IntegrationInstanceStatusSchema = object({
 		"error",
 		"unknown"
 	]),
-	detail: string().optional()
+	detail: string().optional(),
+	/** A short human word for the state ("Signed in", "Token expired"); shown instead of `state`. */
+	label: string().optional()
 });
 var IntegrationInstanceSchema = object({
 	id: IntegrationInstanceIdSchema,
 	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), derived from the record body (`enabled !== false`,
+	* so a row written before the field existed is on). Absent when the `integrations` registry
+	* owns the switch (`describe().role` is `devices`): read it from the registry row.
+	*/
+	enabled: boolean().optional(),
+	/** The kind of this instance (one of `describe().kinds[].id`), when the provider has kinds. */
+	kind: string().optional(),
 	/** Values for the instance form; a secret is a `SecretFieldView`, never text. */
 	formValues: record(string(), unknown()),
-	status: IntegrationInstanceStatusSchema.optional()
+	status: IntegrationInstanceStatusSchema.optional(),
+	/** Epoch ms of the last probe of the remote that produced `status`; absent when never checked. */
+	lastCheckedAt: number().optional()
 });
 var IntegrationInstancePatchSchema = object({
 	id: IntegrationInstanceIdSchema,
@@ -54864,25 +56323,57 @@ var IntegrationInstancePatchSchema = object({
 	/** 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 }), object({ ok: literal(true) }), {
-	kind: "mutation",
-	auth: "admin"
-}), optionalMethod(object({
-	id: IntegrationInstanceIdSchema.nullable(),
-	values: record(string(), unknown())
-}), TestConnectionResultSchema$1, {
-	kind: "mutation",
-	auth: "admin"
-});
+var integrationInstancesCapability = {
+	name: "integration-instances",
+	scope: "system",
+	mode: "collection",
+	methods: {
+		describe: method(_void(), IntegrationInstanceDescriptionSchema, { auth: "admin" }),
+		/** The form; `id: null` is the create form. */
+		instanceFormSchema: method(object({ id: IntegrationInstanceIdSchema.nullable() }), ConfigSchemaPassthrough$3, { auth: "admin" }),
+		listInstances: method(_void(), array(IntegrationInstanceSchema).readonly(), { auth: "admin" }),
+		getInstance: method(object({ id: IntegrationInstanceIdSchema }), IntegrationInstanceSchema.nullable(), { auth: "admin" }),
+		/**
+		* Insert the typed record. With `id` it is stored under that id (a duplicate id is refused);
+		* without one the PROVIDER mints it and answers it. `kind` picks one of `describe().kinds`.
+		*/
+		createInstance: method(object({
+			id: IntegrationInstanceIdSchema.optional(),
+			name: string().min(1),
+			kind: string().min(1).optional()
+		}), object({ id: string() }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		updateInstance: method(IntegrationInstancePatchSchema, object({ ok: literal(true) }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
+		* Switch ONE instance on or off. A row control, not a form field: `updateInstance.values` is the
+		* form patch (D62, D996). An off instance keeps its record and secrets and does no work.
+		*/
+		setInstanceEnabled: method(object({
+			id: IntegrationInstanceIdSchema,
+			enabled: boolean()
+		}), object({ ok: literal(true) }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/** Delete the record and its keychain refs together. */
+		deleteInstance: method(object({ id: IntegrationInstanceIdSchema }), object({ ok: literal(true) }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		testInstance: 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
@@ -56900,6 +58391,11 @@ var LogEntrySchema = object({
 * flight, and not asking for the next slice ends the scan.
 */
 var LogReadQuerySchema = object({
+	/**
+	* Which destination INSTANCE answers (a destination addon may hold several records). Absent ⇒
+	* the provider's first readable one, so a caller written before instances existed is unchanged.
+	*/
+	instanceId: string().min(1).max(200).optional(),
 	/** Correlates `cancelRead`. Caller-chosen, unique per in-flight read. */
 	requestId: string().min(1).max(64).optional(),
 	/** The device the line is about (`tags.deviceId`, numeric). */
@@ -56962,6 +58458,8 @@ var LogReadResultSchema = object({
 	/** True when `cancelRead` ended this slice early. */
 	cancelled: boolean().optional()
 });
+/** Names one destination instance; absent ⇒ the provider's first readable one. */
+var LogInstanceSelectorSchema = object({ instanceId: string().min(1).max(200).optional() });
 var LogReadCapabilitiesSchema = object({
 	/** False ⇒ this destination only ships lines (console, forwarder, an unconfigured Loki). */
 	readable: boolean(),
@@ -56980,7 +58478,7 @@ var LogReadCapabilitiesSchema = object({
 	/** How far back the store reaches, when the provider knows (days). */
 	retentionDays: number().nullable()
 });
-method(LogEntrySchema, _void(), { kind: "mutation" }), optionalMethod(_void(), LogReadCapabilitiesSchema, { auth: "admin" }), optionalMethod(LogReadQuerySchema, LogReadResultSchema, { auth: "admin" }), optionalMethod(object({ requestId: string().min(1).max(64) }), object({ cancelled: boolean() }), {
+method(LogEntrySchema, _void(), { kind: "mutation" }), optionalMethod(LogInstanceSelectorSchema, LogReadCapabilitiesSchema, { auth: "admin" }), optionalMethod(LogReadQuerySchema, LogReadResultSchema, { auth: "admin" }), optionalMethod(object({ requestId: string().min(1).max(64) }), object({ cancelled: boolean() }), {
 	kind: "mutation",
 	auth: "admin"
 });
@@ -57084,214 +58582,6 @@ var LoginMethodContributionSchema = discriminatedUnion("kind", [
 ]);
 method(_void(), array(LoginMethodContributionSchema).readonly());
 /**
-* Media-player cap. Models HA `media_player.*` (Sonos, Chromecast,
-* Apple TV, Spotify, Roku, generic OTT receivers, …) on
-* `DeviceType.MediaPlayer`. Disjoint from the camera streaming
-* surface — those use `DeviceType.Camera` + the broker pipeline.
-*
-* The cap declares a wide method surface; not every backend supports
-* every method. Drivers signal sub-capability via the
-* `DeviceFeature.MediaPlayerXxx` flags (paired one-to-one with the
-* corresponding method) so the UI gates buttons without a slice
-* fetch — same pattern as `PanTiltZoom` for cameras.
-*/
-var MediaPlayerStateSchema = _enum([
-	"off",
-	"on",
-	"idle",
-	"playing",
-	"paused",
-	"buffering",
-	"standby"
-]);
-var MediaPlayerRepeatSchema = _enum([
-	"off",
-	"all",
-	"one"
-]);
-var MediaInfoSchema = object({
-	/** Free-form media kind (`music`, `tvshow`, `movie`, `app`, `channel`,
-	*  `podcast`, …). */
-	type: string(),
-	/** Human-readable title. */
-	title: string(),
-	/** Optional artist / channel / station label. */
-	artist: string().optional(),
-	/** Optional album / season / show name. */
-	album: string().optional(),
-	/** Optional cover-art / thumbnail URL. */
-	imageUrl: string().optional()
-});
-/**
-* Where `state`, `volumeLevel`, `isMuted` and `source` come from. `reported`:
-* the device said so. `assumed`: the driver has no feedback (infrared) and
-* tracks what it last SENT; it moves only after a send was accepted, and a
-* human at the real remote makes it wrong. A UI shows an assumed value as a
-* guess, never as a reading.
-*/
-var MediaPlayerStateSourceSchema = _enum(["reported", "assumed"]);
-/** The fields of a media-player status a driver can only guess. */
-var MediaPlayerAssumedFieldSchema = _enum([
-	"state",
-	"volumeLevel",
-	"isMuted",
-	"source"
-]);
-var MediaPlayerStatusSchema = object({
-	/** Playback lifecycle state. */
-	state: MediaPlayerStateSchema,
-	/**
-	* Whether the state fields are readings or the driver's own bookkeeping.
-	* A slice written before this field existed parses as `reported`.
-	*/
-	stateSource: MediaPlayerStateSourceSchema.default("reported"),
-	/**
-	* Which fields are the driver's own guess. `stateSource` is `assumed` when
-	* this is not empty; a field not listed here is a reading even then (power
-	* from a running-state source, mute guessed from the last send).
-	*/
-	assumedFields: array(MediaPlayerAssumedFieldSchema).default([]),
-	/** Volume as 0..100 inclusive. Null when the device has no volume
-	*  surface. Pair with `DeviceFeature.MediaPlayerVolume`. */
-	volumeLevel: number().min(0).max(100).nullable().meta(readingMeta("percentage")),
-	/** Mute toggle distinct from volume=0. Null when no mute surface.
-	*  Pair with `DeviceFeature.MediaPlayerMute`. */
-	isMuted: boolean().nullable(),
-	/** Active source / input. Empty when no source surface. */
-	source: string(),
-	/** Selectable sources. Empty when no source surface.
-	*  Pair with `DeviceFeature.MediaPlayerSelectSource`. */
-	availableSources: array(string()),
-	/** Currently-playing media info. Null when nothing is playing. */
-	currentMedia: MediaInfoSchema.nullable(),
-	/** Current playback position in ms. Null when not seekable or
-	*  nothing is playing. Pair with `DeviceFeature.MediaPlayerSeek`. */
-	position: number().int().nonnegative().nullable().meta(readingMeta("duration-ms")),
-	/** Total duration of the current media in ms. Null when unknown
-	*  (live stream) or nothing is playing. */
-	duration: number().int().nonnegative().nullable().meta(readingMeta("duration-ms")),
-	/** Shuffle toggle. Null when no shuffle surface.
-	*  Pair with `DeviceFeature.MediaPlayerShuffle`. */
-	shuffle: boolean().nullable(),
-	/** Repeat mode. Null when no repeat surface.
-	*  Pair with `DeviceFeature.MediaPlayerRepeat`. */
-	repeat: MediaPlayerRepeatSchema.nullable(),
-	/** Ms epoch when the slice was last updated. */
-	lastChangedAt: number()
-});
-var mediaPlayerCapability = {
-	name: "media-player",
-	scope: "device",
-	deviceNative: true,
-	mode: "singleton",
-	deviceTypes: [DeviceType.MediaPlayer],
-	methods: {
-		play: method(object({ deviceId: number().int().nonnegative() }), _void(), {
-			kind: "mutation",
-			auth: "protected"
-		}),
-		pause: method(object({ deviceId: number().int().nonnegative() }), _void(), {
-			kind: "mutation",
-			auth: "protected"
-		}),
-		stop: method(object({ deviceId: number().int().nonnegative() }), _void(), {
-			kind: "mutation",
-			auth: "protected"
-		}),
-		next: method(object({ deviceId: number().int().nonnegative() }), _void(), {
-			kind: "mutation",
-			auth: "protected"
-		}),
-		previous: method(object({ deviceId: number().int().nonnegative() }), _void(), {
-			kind: "mutation",
-			auth: "protected"
-		}),
-		seek: method(object({
-			deviceId: number().int().nonnegative(),
-			position: number().int().nonnegative()
-		}), _void(), {
-			kind: "mutation",
-			auth: "protected"
-		}),
-		setVolume: method(object({
-			deviceId: number().int().nonnegative(),
-			volumeLevel: number().min(0).max(100)
-		}), _void(), {
-			kind: "mutation",
-			auth: "protected"
-		}),
-		setMute: method(object({
-			deviceId: number().int().nonnegative(),
-			muted: boolean()
-		}), _void(), {
-			kind: "mutation",
-			auth: "protected"
-		}),
-		setShuffle: method(object({
-			deviceId: number().int().nonnegative(),
-			shuffle: boolean()
-		}), _void(), {
-			kind: "mutation",
-			auth: "protected"
-		}),
-		setRepeat: method(object({
-			deviceId: number().int().nonnegative(),
-			repeat: MediaPlayerRepeatSchema
-		}), _void(), {
-			kind: "mutation",
-			auth: "protected"
-		}),
-		selectSource: method(object({
-			deviceId: number().int().nonnegative(),
-			source: string().min(1)
-		}), _void(), {
-			kind: "mutation",
-			auth: "protected"
-		}),
-		playMedia: method(object({
-			deviceId: number().int().nonnegative(),
-			/** Media identifier / URL. */
-			mediaId: string().min(1),
-			/** Media kind (`music`, `tvshow`, `movie`, `app`, …) — provider
-			*  passes it through to the upstream service. */
-			mediaType: string().min(1)
-		}), _void(), {
-			kind: "mutation",
-			auth: "protected"
-		})
-	},
-	status: {
-		schema: MediaPlayerStatusSchema,
-		kind: "push"
-	},
-	/**
-	* Runtime-state slice — mirrored by the kernel. UI players read the
-	* full slice for live now-playing, volume, and progress updates
-	* without polling.
-	*/
-	runtimeState: MediaPlayerStatusSchema,
-	/**
-	* Runtime-state durability: **session** — a restored transport position describes a playback that stopped when the hub did.
-	*
-	* See `RuntimeStateDurability`. Enforced by
-	* `scripts/check-runtime-state-durability.ts`.
-	*/
-	durability: "session",
-	/**
-	* History (D850): volume (a level an operator or an automation sets; the
-	* default 10 s floor folds a slider drag into its end value) and mute.
-	* `position` is not recorded: it moves continuously while playing.
-	*/
-	history: { fields: {
-		volumeLevel: {
-			kind: "gauge",
-			unit: "%",
-			deadband: 1
-		},
-		isMuted: { kind: "boolean" }
-	} }
-};
-/**
 * mesh-network — collection cap for mesh-VPN providers.
 *
 * Different shape from `network-access` (public tunnels):
@@ -66050,6 +67340,21 @@ var NcTemplateVarKindSchema = _enum([
 	"sound",
 	"system"
 ]);
+/**
+* The default title/body a rule of one SITUATION is delivered with when the
+* operator wrote no template — served so an editor can pre-fill it (and the
+* operator can rebuild it from placeholders) instead of starting from a blank
+* box that, once saved, silently replaces it. `id` names the situation inside
+* a rule `kind`: `appliance-cycle` is a `sensor` rule whose device is an
+* appliance finishing a cycle. Texts are raw templates (`{{var}}` intact), in
+* the hub's current language and with its overrides applied.
+*/
+var NcTemplateDefaultSchema = object({
+	id: _enum(["appliance-cycle"]),
+	kind: NcRuleKindSchema,
+	title: string(),
+	body: string()
+});
 /** Which producer renders a template: an ordinary rule, a timelapse, a digest. */
 var NcTemplateFamilySchema = _enum([
 	"rule",
@@ -66905,7 +68210,11 @@ method(object({}), object({ rules: array(NcRuleSchema) }), { auth: "admin" }), m
 }), method(object({}), object({
 	catalog: array(NcConditionDescriptorSchema),
 	taxonomy: NcTaxonomySchema.optional()
-})), method(object({}), object({ vars: array(NcTemplateVarDescriptorSchema) })), method(NcTemplatePreviewInputSchema, NcTemplatePreviewSchema, {
+})), method(object({}), object({
+	vars: array(NcTemplateVarDescriptorSchema),
+	/** Per-situation default texts; absent on a hub that predates them. */
+	defaults: array(NcTemplateDefaultSchema)
+})), method(NcTemplatePreviewInputSchema, NcTemplatePreviewSchema, {
 	kind: "mutation",
 	access: "view"
 }), method(object({ filter: NcHistoryFilterSchema.default({ limit: 100 }) }), object({ entries: array(NcHistoryEntrySchema) }), { auth: "admin" }), method(object({}), NcRuleLastRunsSchema, { auth: "admin" }), method(object({ artifactId: string().min(1) }), object({ url: string().nullable() }), { auth: "admin" }), method(object({}), object({ snoozes: array(NcSnoozeSchema) }), { caller: "required" }), method(object({ snooze: NcSnoozeInputSchema }), object({ snooze: NcSnoozeSchema }), {
@@ -67801,7 +69110,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
@@ -67817,8 +69126,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. */
@@ -67829,27 +69140,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().min(0).nullable().meta(readingMeta("duration")),
-	/** How long the pump rests per cycle, in seconds. */
-	pumpOffTime: number().min(0).nullable().meta(readingMeta("duration")),
 	/** Water drunk in the last drink, in litres. */
 	lastDrink: number().min(0).nullable().meta(readingMeta("volume")),
 	/** Water drunk in the current hour, in litres. */
 	currentHourDrink: number().min(0).nullable().meta(readingMeta("volume")),
 	/** Water drunk over the last 24 hours (rolling), in litres. */
 	last24hDrink: number().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().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()
 });
-var DeviceIdSchema = number().int().nonnegative();
-var MinutesSchema = number().int().min(0);
+var DeviceIdSchema$1 = number().int().nonnegative();
 var petFountainCapability = {
 	name: "pet-fountain",
 	scope: "device",
@@ -67859,38 +69163,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"
 		})
@@ -69525,6 +70805,14 @@ var powerMeterCapability = {
 	deviceNative: true,
 	mode: "singleton",
 	deviceTypes: POWER_METER_DEVICE_TYPES,
+	deviceConfig: { ui: {
+		kind: "widget",
+		widgetId: "host/power-meter-line",
+		tab: "power",
+		placement: "hero",
+		label: "Power",
+		order: 4
+	} },
 	methods: {},
 	status: {
 		schema: PowerMeterStatusSchema,
@@ -69584,6 +70872,117 @@ var powerMeterCapability = {
 	volatileStateFields: ["lastFetchedAt"],
 	customize: powerMeterCustomize
 };
+var PowerSourceRefusalReasonSchema = _enum([
+	"no-power-source",
+	"switch-missing",
+	"switch-offline",
+	"switch-unknown",
+	"restart-in-progress",
+	"switch-call-failed"
+]);
+var PowerSourceActionResultSchema = discriminatedUnion("accepted", [object({ accepted: literal(true) }), object({
+	accepted: literal(false),
+	reason: PowerSourceRefusalReasonSchema,
+	/** One line for the operator, naming the switch. */
+	message: string()
+})]);
+var PowerSourceInfoSchema = object({
+	/** False when the device has no power source linked; the rest is then empty. */
+	linked: boolean(),
+	switchDeviceId: number().nullable(),
+	switchName: string().nullable(),
+	/** The switch's on/off state, or null when it is unknown. Never false for unknown (D393). */
+	switchOn: boolean().nullable(),
+	switchOnline: boolean().nullable(),
+	restartInProgress: boolean(),
+	offSeconds: number().int()
+});
+/** The composed slice: the switch state the link mirrors, plus the stored off time. */
+var PowerSourceStateSchema = object({
+	/** Null while the switch has not reported: unknown is never `false` (D393). */
+	switchOn: boolean().nullable(),
+	offSeconds: number().int(),
+	lastFetchedAt: number()
+});
+var POWER_SOURCE_DEVICE_TYPES = [
+	DeviceType.Gateway,
+	DeviceType.Hub,
+	DeviceType.Camera,
+	DeviceType.Sensor,
+	DeviceType.MediaPlayer,
+	DeviceType.Vacuum,
+	DeviceType.Generic,
+	DeviceType.Washer,
+	DeviceType.Dryer,
+	DeviceType.Dishwasher,
+	DeviceType.PetFountain,
+	DeviceType.Fan,
+	DeviceType.Humidifier,
+	DeviceType.Climate,
+	DeviceType.WaterHeater
+];
+var powerSourceCustomize = {
+	version: 1,
+	targets: [{
+		id: "switch",
+		cardinality: "scalar",
+		vocabulary: {
+			cap: "power-source",
+			stateField: "switchOn"
+		},
+		deviceTypes: POWER_SOURCE_DEVICE_TYPES,
+		apply: "add",
+		path: "switchOn",
+		sources: [{
+			kind: "switch",
+			transforms: [{ kind: "identity" }]
+		}],
+		companions: [{
+			kind: "constant",
+			path: "offSeconds",
+			value: 10,
+			when: "add"
+		}, {
+			kind: "clock",
+			path: "lastFetchedAt",
+			when: "always"
+		}],
+		sourceReport: { status: "assignment-status" }
+	}]
+};
+var deviceInput$1 = object({ deviceId: number().int().nonnegative() });
+var powerSourceCapability = {
+	name: "power-source",
+	scope: "device",
+	mode: "singleton",
+	deviceTypes: POWER_SOURCE_DEVICE_TYPES,
+	methods: {
+		getStatus: systemMethod(deviceInput$1, PowerSourceInfoSchema, { auth: "admin" }),
+		powerOn: systemMethod(deviceInput$1, PowerSourceActionResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		powerOff: systemMethod(deviceInput$1, PowerSourceActionResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		forceRestart: systemMethod(deviceInput$1, PowerSourceActionResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		})
+	},
+	runtimeState: PowerSourceStateSchema,
+	customize: powerSourceCustomize,
+	/**
+	* Runtime-state durability: **session** — mirrored from the linked switch on
+	* its next report; a restored value would outlive the reading it names.
+	*
+	* See `RuntimeStateDurability`. Enforced by
+	* `scripts/check-runtime-state-durability.ts`.
+	*/
+	durability: "session",
+	history: "none"
+};
 /**
 * Presence cap. Models HA `person.*` and `device_tracker.*` entities
 * on `DeviceType.Presence`. Read-only — no setters: presence is
@@ -70223,6 +71622,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().min(0).nullable().meta(readingMeta("duration")),
+	/** How long the pump rests per cycle, in seconds. Null while unknown. */
+	offTime: number().min(0).nullable().meta(readingMeta("duration")),
+	/** Ms epoch when the slice was last refreshed. */
+	lastFetchedAt: number()
+});
+var DeviceIdSchema = number().int().nonnegative();
+var MinutesSchema = number().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().int().nonnegative() }), object({ success: literal(true) }), {
 	kind: "mutation",
 	auth: "admin"
@@ -73013,7 +74485,13 @@ var RemoteMediaCommandSchema = _enum([
 	"next",
 	"previous",
 	"setMute",
-	"selectSource"
+	"selectSource",
+	"turnOn",
+	"turnOff",
+	"volumeUp",
+	"volumeDown",
+	"channelUp",
+	"channelDown"
 ]);
 /** A send result, or `not-routed`: the role is not bound, so the native cap answers. */
 var RemoteMediaCommandResultSchema = discriminatedUnion("status", [...RemoteSendResultSchema.options, object({ status: literal("not-routed") })]);
@@ -73034,7 +74512,7 @@ method(deviceInput, RemoteConfigSchema, { auth: "admin" }), method(deviceInput.e
 }), RemoteSendResultSchema, {
 	kind: "mutation",
 	auth: "protected"
-}), method(deviceInput.extend({
+}), method(deviceInput, MediaPlayerStatusSchema.nullable(), { auth: "protected" }), method(deviceInput.extend({
 	command: RemoteMediaCommandSchema,
 	muted: boolean().optional(),
 	source: string().optional(),
@@ -75280,7 +76758,11 @@ listSignals: method(_void(), array(StreamSignalSchema).readonly()) }
 * `getSettingsUISchema()` surface.
 */
 var SwitchStatusSchema = object({
-	on: boolean().meta({ label: "On" }),
+	/**
+	* `null` = the device has never reported its state (a measurement that
+	* has not happened is unknown, never `false`).
+	*/
+	on: boolean().nullable().meta({ label: "On" }),
 	/** Ms epoch of the last state change. Useful for UI "X minutes ago". */
 	lastChangedAt: number()
 });
@@ -75305,7 +76787,7 @@ var switchCapability = {
 	}) },
 	events: { onStateChanged: { data: object({
 		deviceId: number(),
-		on: boolean(),
+		on: boolean().nullable(),
 		lastChangedAt: number()
 	}) } },
 	status: {
@@ -78954,6 +80436,26 @@ function buildDescriptor(capName, kind) {
 * contributes one entry per bound cap present in this map.
 */
 var EVENT_KIND_BY_CAP = Object.freeze(Object.fromEntries(Object.entries(CAP_TO_KIND).map(([capName, kind]) => [capName, buildDescriptor(capName, kind)])));
+/**
+* What a remote key is CALLED and what it LOOKS like, for every role (D963),
+* shared by the admin UI and the viewer. A role is data on the wire; each
+* client resolves its name from `label` (English and Italian side by side) and
+* its glyph from `icon`, a lucide id from the shared icon catalogue — the
+* server sends an id, a client maps it to its own icon set.
+*
+* `legend` is text printed on the key INSTEAD of a glyph (a digit has no
+* pictogram): a client that can draw text shows it, one that cannot falls back
+* to `icon`.
+*/
+function digit(n) {
+	return {
+		label: t(n, n),
+		icon: "hash",
+		legend: n
+	};
+}
+digit("0"), digit("1"), digit("2"), digit("3"), digit("4"), digit("5"), digit("6"), digit("7"), digit("8"), digit("9");
+DeviceFeature.MediaPlayerPower, DeviceFeature.MediaPlayerVolumeStep, DeviceFeature.MediaPlayerChannelStep, DeviceFeature.MediaPlayerMute, DeviceFeature.MediaPlayerStop, DeviceFeature.MediaPlayerNext, DeviceFeature.MediaPlayerPrevious;
 var btn = (idSuffix, row, col, init) => ({
 	idSuffix,
 	row,
@@ -79080,6 +80582,34 @@ discriminatedUnion("kind", [object({
 	kind: literal("pronto"),
 	code: string()
 })]);
+/**
+* Propose a running threshold from a device's own power history (planning#405).
+*
+* Pure and deterministic: the same series gives the same answer. The series is
+* a HELD-VALUE step series — a point's value stands until the next point — which
+* is how device-history stores a gauge, so "time at a level" is exact, not a
+* count of samples.
+*
+*  1. idle floor F = time-weighted median; noise ceiling N = highest value seen
+*     near F. A device that is not near one level most of the time has no floor.
+*  2. coarse activity = above max(2N, N + 5 W); consecutive stretches are episodes.
+*  3. gaps between episodes split in two by the largest log-scale jump (>= 3x):
+*     the short ones are pauses INSIDE a run (a soak), the long ones separate runs.
+*  4. T = geometric mean of N and the plateau's 10th percentile, snapped to a
+*     grid a person would type; stop dwell covers the longest pause; start dwell
+*     covers the longest standby blip above T.
+*  5. the numbers are proved by REPLAY through the real `dwell` evaluation: each
+*     run must hold exactly one true interval and nothing may flap outside.
+*/
+var SECOND_MS = 1e3;
+var MINUTE_MS$1 = 60 * SECOND_MS;
+24 * (60 * MINUTE_MS$1);
+10 * MINUTE_MS$1;
+30 * SECOND_MS;
+60 * SECOND_MS;
+20 * MINUTE_MS$1;
+10 * SECOND_MS;
+10 * SECOND_MS;
 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+)?)\)`;
@@ -79440,6 +80970,7 @@ var DEVICE_LOCAL_STATE_CAPS = {
 	pressureSensor: pressureSensorCapability,
 	privacyMask: privacyMaskCapability,
 	ptzAutotrack: ptzAutotrackCapability,
+	pumpCycle: pumpCycleCapability,
 	recordingOnboard: recordingOnboardCapability,
 	recordingSignal: recordingSignalCapability,
 	runningState: runningStateCapability,
@@ -81624,6 +83155,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",
@@ -82163,6 +83715,13 @@ Object.freeze({
 		access: "create",
 		role: "admin"
 	},
+	"coreBlocks.proposeRunningThreshold": {
+		capName: "core-blocks",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
 	"coreBlocks.reportAutomationRun": {
 		capName: "core-blocks",
 		capScope: "system",
@@ -82674,6 +84233,13 @@ Object.freeze({
 		access: "view",
 		role: "admin"
 	},
+	"deviceExport.listInstances": {
+		capName: "device-export",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
 	"deviceExport.listSupportedDeviceKinds": {
 		capName: "device-export",
 		capScope: "system",
@@ -84305,6 +85871,13 @@ Object.freeze({
 		access: "view",
 		role: "admin"
 	},
+	"integrationInstances.setInstanceEnabled": {
+		capName: "integration-instances",
+		capScope: "system",
+		addonId: null,
+		access: "create",
+		role: "admin"
+	},
 	"integrationInstances.testInstance": {
 		capName: "integration-instances",
 		capScope: "system",
@@ -84319,6 +85892,13 @@ Object.freeze({
 		access: "create",
 		role: "admin"
 	},
+	"integrations.clearSettings": {
+		capName: "integrations",
+		capScope: "system",
+		addonId: null,
+		access: "delete",
+		role: "admin"
+	},
 	"integrations.create": {
 		capName: "integrations",
 		capScope: "system",
@@ -85103,6 +86683,20 @@ Object.freeze({
 		access: "view",
 		role: "admin"
 	},
+	"mediaPlayer.channelDown": {
+		capName: "media-player",
+		capScope: "device",
+		addonId: null,
+		access: "create",
+		role: "viewer"
+	},
+	"mediaPlayer.channelUp": {
+		capName: "media-player",
+		capScope: "device",
+		addonId: null,
+		access: "create",
+		role: "viewer"
+	},
 	"mediaPlayer.getStatus": {
 		capName: "media-player",
 		capScope: "device",
@@ -85194,6 +86788,34 @@ Object.freeze({
 		access: "create",
 		role: "viewer"
 	},
+	"mediaPlayer.turnOff": {
+		capName: "media-player",
+		capScope: "device",
+		addonId: null,
+		access: "create",
+		role: "viewer"
+	},
+	"mediaPlayer.turnOn": {
+		capName: "media-player",
+		capScope: "device",
+		addonId: null,
+		access: "create",
+		role: "viewer"
+	},
+	"mediaPlayer.volumeDown": {
+		capName: "media-player",
+		capScope: "device",
+		addonId: null,
+		access: "create",
+		role: "viewer"
+	},
+	"mediaPlayer.volumeUp": {
+		capName: "media-player",
+		capScope: "device",
+		addonId: null,
+		access: "create",
+		role: "viewer"
+	},
 	"meshNetwork.getStatus": {
 		capName: "mesh-network",
 		capScope: "system",
@@ -86440,27 +88062,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",
@@ -88239,6 +89840,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",
@@ -88743,6 +90372,13 @@ Object.freeze({
 		access: "create",
 		role: "admin"
 	},
+	"remote.getAssumedStatus": {
+		capName: "remote",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
 	"remote.getConfig": {
 		capName: "remote",
 		capScope: "system",
@@ -91558,6 +93194,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"coreBlocks.proposeRunningThreshold": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"cover.close": [{
 		name: "deviceId",
 		form: "single",
@@ -92409,6 +94050,16 @@ Object.freeze({
 		form: "single",
 		optional: true
 	}],
+	"mediaPlayer.channelDown": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"mediaPlayer.channelUp": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"mediaPlayer.getStatus": [{
 		name: "deviceId",
 		form: "single",
@@ -92474,6 +94125,26 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"mediaPlayer.turnOff": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"mediaPlayer.turnOn": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"mediaPlayer.volumeDown": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"mediaPlayer.volumeUp": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"meter.getStatus": [{
 		name: "deviceId",
 		form: "single",
@@ -92783,21 +94454,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",
@@ -93433,6 +95089,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",
@@ -93634,6 +95310,11 @@ Object.freeze({
 		form: "single",
 		optional: true
 	}],
+	"remote.getAssumedStatus": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"remote.getConfig": [{
 		name: "deviceId",
 		form: "single",
@@ -94181,99 +95862,6 @@ Object.freeze({
 	"network-access": "ingress",
 	"smtp-provider": "email"
 });
-/**
-* A saved Customize assignment (D936). The schema is the type: callers use
-* `z.infer`, they do not restate the shape.
-*/
-var OverrideSourceSchema = object({
-	addonId: string().min(1),
-	stableId: string().min(1),
-	cap: string().min(1),
-	fieldPath: string().min(1)
-});
-var CustomizeTransformDraftSchema = discriminatedUnion("kind", [
-	object({ kind: literal("identity") }),
-	object({ kind: literal("invert") }),
-	object({
-		kind: literal("threshold"),
-		comparison: _enum(["gte", "lte"]),
-		threshold: number(),
-		startDwellMs: number().nonnegative(),
-		stopDwellMs: number().nonnegative()
-	}),
-	object({
-		kind: literal("linear"),
-		scale: number(),
-		offset: number(),
-		clampMin: number().optional(),
-		clampMax: number().optional()
-	}),
-	object({
-		kind: literal("enum-map"),
-		mapping: record(string(), string().nullable())
-	}),
-	object({ kind: literal("number") })
-]);
-var ScalarOverrideDraftSchema = object({
-	kind: literal("scalar"),
-	cap: string().min(1),
-	targetId: string().min(1),
-	source: OverrideSourceSchema,
-	transform: CustomizeTransformDraftSchema
-});
-var KeyedArrayOverrideDraftSchema = object({
-	kind: literal("keyedArray"),
-	cap: string().min(1),
-	targetId: string().min(1),
-	key: string().min(1),
-	label: string().min(1),
-	fieldPath: string().min(1),
-	source: OverrideSourceSchema,
-	transform: CustomizeTransformDraftSchema
-});
-var PulseOverrideDraftSchema = object({
-	kind: literal("pulse"),
-	cap: string().min(1),
-	targetId: string().min(1),
-	enabled: boolean(),
-	debounceMs: number().nonnegative(),
-	edges: array(_enum([
-		"rising",
-		"button",
-		"native-event"
-	])).min(1).optional(),
-	sources: array(OverrideSourceSchema).min(1)
-});
-var SpanSourceDraftSchema = OverrideSourceSchema.extend({ mode: _enum([
-	"in-addition",
-	"confirm",
-	"replace"
-]).optional() });
-discriminatedUnion("kind", [
-	ScalarOverrideDraftSchema,
-	KeyedArrayOverrideDraftSchema,
-	PulseOverrideDraftSchema,
-	object({
-		kind: literal("span"),
-		cap: string().min(1),
-		targetId: string().min(1),
-		timeoutMs: number().nonnegative(),
-		cooldownMs: number().nonnegative().optional(),
-		sources: array(SpanSourceDraftSchema)
-	})
-]);
-object({
-	targetId: string().min(1),
-	configured: boolean(),
-	source: _enum(["native", "assigned"]),
-	state: _enum([
-		"active",
-		"stale",
-		"released",
-		"unavailable"
-	]),
-	reason: string().nullable()
-});
 var G711_SCALE_CORRECTION_DB = {
 	PCMU: 20 * Math.log10(4),
 	PCMA: 20 * Math.log10(8)
@@ -94889,6 +96477,7 @@ var STATE_SUMMARY_VARS = [
 	[...RULE_TEXT],
 	([...RULE_TEXT], [...DEVICE_EVENTS]),
 	([...RULE_TEXT], [...COMBINED_ALARM]),
+	([...RULE_TEXT], [...COMBINED_ALARM]),
 	([...RULE_TEXT], [...DEVICE_EVENTS]),
 	([...RULE_TEXT], [...BATTERY, ...CONSUMABLE]),
 	([...RULE_TEXT], [...CONSUMABLE]),
@@ -95876,6 +97465,140 @@ function buildConnectionFormSchema() {
 	}] };
 }
 //#endregion
+//#region src/rademacher-instances.ts
+/**
+* Rademacher integrations as `integration-instances` (planning#416, D985, D1007): one
+* `connections` record per HomePilot / Start2Smart hub under the `integrations` registry id. The
+* body IS the connection (host, password in the keychain, base path, poll interval), so the form
+* the instances page edits is the stored shape and the addon reads nothing else.
+*/
+var rademacherConnectionsEntryKind = defineEntryKind("connections", {
+	title: "Rademacher hubs",
+	schema: entryBody({
+		host: string().optional(),
+		password: string().optional().meta({ secret: true }),
+		basePath: string().optional(),
+		pollIntervalMs: number().optional()
+	}),
+	writeTrigger: "an operator adds, edits or removes a Rademacher hub connection"
+});
+/** Every kind this addon declares, keyed by its name. */
+var rademacherRecordKinds = { connections: rademacherConnectionsEntryKind };
+/** The legacy row keys the record carries over; any other key is dropped and named. */
+var LEGACY_KEYS = [
+	"host",
+	"password",
+	"basePath",
+	"pollIntervalMs"
+];
+function text(value) {
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function whole(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	const parsed = typeof value === "string" && value.trim() !== "" ? Number(value) : NaN;
+	return Number.isFinite(parsed) ? parsed : void 0;
+}
+/** The record body of one integration, from its legacy rows (secrets resolved). */
+function rademacherBodyFromRows(values, log, integration) {
+	const dropped = Object.keys(values).filter((key) => !LEGACY_KEYS.includes(key));
+	if (dropped.length > 0) log.warn(`integration '${integration.id}': legacy settings nothing reads any more are dropped: ${dropped.join(", ")}`);
+	const host = text(values["host"]);
+	const password = text(values["password"]);
+	const basePath = text(values["basePath"]);
+	const pollIntervalMs = whole(values["pollIntervalMs"]);
+	return {
+		name: integration.name,
+		...host !== void 0 ? { host } : {},
+		...password !== void 0 ? { password } : {},
+		...basePath !== void 0 ? { basePath } : {},
+		...pollIntervalMs !== void 0 ? { pollIntervalMs } : {}
+	};
+}
+/** The whole `provider-rademacher` catalogue (D987): offered to the engine at `onInitialize`. */
+var RADEMACHER_MIGRATIONS = [{
+	meta: {
+		id: "provider-rademacher/2026-11-05-integration-rows-to-record",
+		owner: "provider-rademacher",
+		level: "addon-state",
+		seq: 1,
+		dependsOn: [],
+		store: "settings",
+		scope: "cluster",
+		onFailure: "block-owner",
+		bodyKind: "procedure",
+		description: "Move every Rademacher hub connection into a typed instance record keyed by its registry id, then clear the legacy integration settings rows and their keychain values",
+		fixtureMark: "a legacy setting key the migration does not know"
+	},
+	procedure: (ports) => moveIntegrationRowsToRecords(ports, {
+		addonId: "provider-rademacher",
+		secretPaths: rademacherConnectionsEntryKind.declaration.secretPaths,
+		bodyFrom: rademacherBodyFromRows
+	})
+}];
+/** The hub side and the records side of the move, over `ctx.api` and `ctx.records`. */
+function rademacherRowsPorts(deps) {
+	return integrationRowsPortsOverApi({
+		api: deps.api,
+		records: deps.records.kind({
+			name: rademacherConnectionsEntryKind.name,
+			declaration: rademacherConnectionsEntryKind.declaration,
+			schema: record(string(), unknown())
+		}),
+		log: { warn: deps.warn }
+	});
+}
+/**
+* The live connection of one instance, read from its record. null while the host is missing; a
+* locked keychain throws so the caller keeps the client it has instead of reconfiguring it with an
+* empty password (D49).
+*/
+async function rademacherConnectionOf(instances, id) {
+	const read = await instances.readResolved(id);
+	if (read === null) return null;
+	if (read.secrets === "unavailable") throw new Error("the keychain is locked, the saved password cannot be read");
+	return connectionFromSettings(read.body);
+}
+function typedPassword(value) {
+	return typeof value === "string" && value !== "" && value !== "__camstack_redacted__" ? value : void 0;
+}
+function buildRademacherInstances(records, deps) {
+	const handle = records.kind(rademacherConnectionsEntryKind);
+	return new RecordIntegrationInstances(records, rademacherConnectionsEntryKind, {
+		description: {
+			role: "devices",
+			instanceMode: "multiple",
+			kind: "connection",
+			canTest: true
+		},
+		formSchema: () => buildConnectionFormSchema(),
+		initialBody: (name) => ({ name }),
+		configured: (body) => connectionFromSettings(body) !== null,
+		onChanged: async (_id, change) => {
+			if (change !== "deleted") await deps.onChanged();
+		},
+		test: async ({ id, values }) => {
+			const stored = id === null ? null : (await handle.getResolved(id))?.data.password ?? null;
+			const password = typedPassword(values["password"]) ?? stored ?? "";
+			const outcome = await deps.tester.testSettings({ settings: {
+				...values,
+				password
+			} });
+			if (outcome.outcome === "validated") return {
+				success: true,
+				status: "validated",
+				...outcome.latencyMs !== void 0 ? { latencyMs: outcome.latencyMs } : {},
+				...outcome.detail !== void 0 ? { detail: outcome.detail } : {}
+			};
+			return {
+				success: false,
+				status: outcome.outcome,
+				error: outcome.error
+			};
+		}
+	});
+}
+//#endregion
 //#region src/cover-mapping.ts
 /** Clamp a raw percentage to the cap's `0..100` integer domain. */
 function clampPercent(value) {
@@ -97930,11 +99653,25 @@ var RademacherProviderAddon = class extends BaseDeviceProvider {
 	};
 	integrationReconciler = null;
 	clients = null;
+	instances = null;
 	constructor() {
 		super({});
 	}
 	async onInitialize() {
 		const regs = this.providerRegistrationsFromSuper(await super.onInitialize());
+		const records = this.ctx.records;
+		if (records === void 0) throw new Error("provider-rademacher: ctx.records is required (hub-only addon)");
+		await records.declare(rademacherRecordKinds);
+		await this.runMigrations(defineAddonMigrations(RADEMACHER_MIGRATIONS, rademacherRowsPorts({
+			api: defaultIntegrationApiOver(this.ctx.api),
+			records,
+			warn: (message) => this.ctx.logger.warn(message)
+		})));
+		const instances = buildRademacherInstances(records, {
+			onChanged: () => this.reconcileIntegrations(),
+			tester: this.buildConnectionTestProvider()
+		});
+		this.instances = instances;
 		this.clients = new RademacherClientRegistry(this.ctx.logger);
 		this.clients.setOnConnected((integrationId) => {
 			this.setIntegrationDevicesOnline(integrationId, true);
@@ -97953,6 +99690,10 @@ var RademacherProviderAddon = class extends BaseDeviceProvider {
 			{
 				capability: connectionTestCapability,
 				provider: this.buildConnectionTestProvider()
+			},
+			{
+				capability: integrationInstancesCapability,
+				provider: instances.toProvider()
 			}
 		] };
 	}
@@ -97965,11 +99706,9 @@ var RademacherProviderAddon = class extends BaseDeviceProvider {
 		this.clients = null;
 		this.integrationReconciler?.dispose();
 		this.integrationReconciler = null;
+		this.instances = null;
 		await super.onShutdown();
 	}
-	globalSettingsSchema() {
-		return buildConnectionFormSchema();
-	}
 	async supportsManualCreation() {
 		return false;
 	}
@@ -97985,6 +99724,10 @@ var RademacherProviderAddon = class extends BaseDeviceProvider {
 		if (typeof nativeId !== "string" || nativeId.length === 0) throw new Error("provider-rademacher generateStableId: nativeId required");
 		return `rademacher:${nativeId}`;
 	}
+	requireInstances() {
+		if (!this.instances) throw new Error("Rademacher provider not initialised");
+		return this.instances;
+	}
 	requireClients() {
 		if (!this.clients) throw new Error("Rademacher provider not initialised");
 		return this.clients;
@@ -98001,7 +99744,7 @@ var RademacherProviderAddon = class extends BaseDeviceProvider {
 			},
 			listIntegrations: () => this.ctx.api.integrations.list.query(),
 			applySettings: async (integration) => {
-				const connection = connectionFromSettings(await this.ctx.api.integrations.getSettings.query({ id: integration.id }));
+				const connection = await rademacherConnectionOf(this.requireInstances(), integration.id);
 				if (!connection) return false;
 				await this.requireClients().upsert(integration.id, integration.name, connection);
 				return true;