@camstack/addon-import-alexa 0.2.192 → 0.2.193

package/dist/addon.mjs

@@ -1,5 +1,5 @@
 import { createRequire } from "node:module";
-import { createHash, randomBytes } from "node:crypto";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
 import https from "node:https";
 import * as fs$1 from "node:fs/promises";
 import * as path from "node:path";
@@ -6042,7 +6042,7 @@ function number(params) {
 	return /* @__PURE__ */ _coercedNumber(ZodNumber, params);
 }
 //#endregion
-//#region ../types/dist/sleep-CmjWurK5.mjs
+//#region ../types/dist/sleep-CdKka2ri.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -6798,6 +6798,13 @@ var DeclarationRefusedError = class extends RecordsError {
 function linkField(target) {
 	return string().meta({ link: target });
 }
+/**
+* A link that may stay empty (absent): for a link the addon fills itself, or one an instance does not
+* always need. The meta rides on the optional wrapper, where {@link linksOfKind} reads it.
+*/
+function optionalLinkField(target) {
+	return string().optional().meta({ link: target });
+}
 function linkTargetOf(meta) {
 	if (typeof meta !== "object" || meta === null) return void 0;
 	const link = Reflect.get(meta, "link");
@@ -9589,286 +9596,6 @@ function normalizeAddonInitResult(result) {
 	if (Array.isArray(result)) return { providers: result };
 	return result;
 }
-/**
-* The share-view scope kinds a share-link token can carry. The hub mints
-* and validates them (`ShareViewGrantSchema` builds its
-* enum from this list); a data plane names the kinds it ACCEPTS in `share`.
-*/
-var SHARE_VIEW_KINDS = ["grid-view", "events-view"];
-/** The wire shape of {@link PeerBytesTicket} — see the type for what it is. */
-var PeerBytesTicketSchema = object({
-	/** `http://127.0.0.1:<port>/<token>`. One `GET` takes it. */
-	url: string().min(1),
-	/**
-	* The HOST node this URL means something on — the hub or a named agent,
-	* never a runner. {@link AddonPeerBytes.open} compares it to its own and
-	* refuses `cross-node` by name when they differ, without dialling.
-	*/
-	hostNodeId: string().min(1),
-	expiresAtMs: number$1().int().nonnegative(),
-	/**
-	* What the producer DECLARED the body to be, when it knows — `null` when it
-	* does not. Never `0` for unknown (D393): a consumer sizing a bound off this
-	* must be able to tell "the producer did not say" from "the body is empty".
-	*/
-	declaredBytes: number$1().int().nonnegative().nullable()
-});
-function defOf(schema) {
-	const zodBag = Reflect.get(schema, "_zod");
-	if (typeof zodBag !== "object" || zodBag === null) return {};
-	const def = Reflect.get(zodBag, "def");
-	if (typeof def !== "object" || def === null) return {};
-	return def;
-}
-function declaredHere(schema) {
-	return globalRegistry.get(schema)?.secret === true;
-}
-/** Wrapper kinds whose `innerType` is the field itself. */
-var WRAPPERS = new Set([
-	"optional",
-	"nullable",
-	"default",
-	"prefault",
-	"catch",
-	"readonly",
-	"nonoptional"
-]);
-/**
-* The schema layers that make up ONE field: the schema itself and every
-* wrapper below it (optional / default / nullable / readonly / catch), plus
-* both sides of a pipe (`z.preprocess` puts the real schema on `out`,
-* `.transform` on `in`).
-*/
-function layersOf(schema) {
-	const out = [];
-	const queue = [schema];
-	while (queue.length > 0) {
-		const s = queue.shift();
-		if (!s || out.includes(s)) continue;
-		out.push(s);
-		const def = defOf(s);
-		if (def.type !== void 0 && WRAPPERS.has(def.type) && def.innerType) queue.push(def.innerType);
-		if (def.type === "pipe") {
-			if (def.in) queue.push(def.in);
-			if (def.out) queue.push(def.out);
-		}
-	}
-	return out;
-}
-/** True when any layer of this field declares `.meta({ secret: true })`. */
-function isZodSecret(schema) {
-	return layersOf(schema).some(declaredHere);
-}
-/**
-* Every declared secret path in a config schema: dotted keys, `[]` for "each
-* 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.
-*/
-function collectZodSecretPaths(schema, prefix = "") {
-	if (isZodSecret(schema)) return prefix.length > 0 ? [prefix] : [];
-	const paths = [];
-	for (const layer of layersOf(schema)) {
-		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));
-			if (def.right) paths.push(...collectZodSecretPaths(def.right, prefix));
-		}
-	}
-	return [...new Set(paths)];
-}
-/**
-* Record kinds (D881): the declaration an addon makes of one kind of fact, the
-* Zod row schema that describes it, and the helper that turns the two into the
-* JSON the engine stores.
-*
-* A kind is declared ONCE, next to the code that owns it, and the engine's
-* reconciler creates its indexes - nothing creates DDL at runtime from a write.
-* Everything the generic machinery needs (secret fields, the entry descriptor)
-* is DERIVED from the Zod schema: `.meta({ secret: true })` marks a credential,
-* never a field name (D879).
-*/
-/** A JSON field path: `trackId`, `auth.accessToken`. Charset-restricted: it is rendered into DDL. */
-var RecordFieldPathSchema = string().regex(/^[A-Za-z_][A-Za-z0-9_]{0,63}(\.[A-Za-z_][A-Za-z0-9_]{0,63}){0,3}$/);
-var RecordIndexSchema = object({
-	name: string().regex(/^[a-z][a-z0-9_]{0,31}$/),
-	fields: array(RecordFieldPathSchema).min(1).max(4),
-	unique: boolean().optional()
-}).strict();
-var RecordRetentionSchema = union([
-	object({
-		ttlMs: number$1().int().positive(),
-		from: _enum(["at", "write"])
-	}).strict(),
-	object({
-		maxRows: number$1().int().positive().optional(),
-		maxRowsPerDevice: number$1().int().positive().optional()
-	}).strict().refine((r) => r.maxRows !== void 0 || r.maxRowsPerDevice !== void 0, { message: "name maxRows, maxRowsPerDevice or both" }),
-	object({
-		owner: string().min(1),
-		reason: string().min(1)
-	}).strict(),
-	object({ none: string().min(1) }).strict()
-]);
-/** The descriptor a generic entries UI reads (D881 "generic entries"). */
-var EntryDescriptorSchema = object({
-	title: string().min(1),
-	/** The record body field shown as the entry's name. */
-	nameField: string().min(1),
-	/** JSON Schema of the entry body; `secret: true` marks a password field. */
-	fields: record(string(), unknown())
-}).strict();
-/** What crosses the wire from an addon: JSON only, no Zod. An unknown key is refused. */
-var RecordKindDeclarationSchema = object({
-	database: _enum(RECORD_DATABASES).default("settings"),
-	class: _enum(RECORD_CLASSES),
-	writeTrigger: string().min(1),
-	device: _enum([
-		"required",
-		"optional",
-		"none"
-	]).default("none"),
-	at: _enum(["required", "none"]).default("none"),
-	indexes: array(RecordIndexSchema).max(8).default([]),
-	retention: RecordRetentionSchema,
-	deviceRemoval: _enum(["delete", "none"]).default("none"),
-	maxDataBytes: number$1().int().positive().max(RECORD_MAX_DATA_BYTES).default(RECORD_DEFAULT_MAX_DATA_BYTES),
-	/** Derived from the Zod schema; never written by hand. */
-	secretPaths: array(string().min(1)).default([]),
-	/** The id key of each array that carries a secret (`{ headers: 'name' }`). */
-	secretArrayKeys: record(string(), string()).default({}),
-	/** Kinds that must agree through `transact` sit in one file under one family name. */
-	transactFamily: string().min(1).optional(),
-	entry: EntryDescriptorSchema.optional()
-}).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),
-		enabled: boolean().optional(),
-		...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")
@@ -9961,6 +9688,286 @@ function optionalMethod(input, output, options) {
 function event(data) {
 	return { data };
 }
+function defOf(schema) {
+	const zodBag = Reflect.get(schema, "_zod");
+	if (typeof zodBag !== "object" || zodBag === null) return {};
+	const def = Reflect.get(zodBag, "def");
+	if (typeof def !== "object" || def === null) return {};
+	return def;
+}
+function declaredHere(schema) {
+	return globalRegistry.get(schema)?.secret === true;
+}
+/** Wrapper kinds whose `innerType` is the field itself. */
+var WRAPPERS = new Set([
+	"optional",
+	"nullable",
+	"default",
+	"prefault",
+	"catch",
+	"readonly",
+	"nonoptional"
+]);
+/**
+* The schema layers that make up ONE field: the schema itself and every
+* wrapper below it (optional / default / nullable / readonly / catch), plus
+* both sides of a pipe (`z.preprocess` puts the real schema on `out`,
+* `.transform` on `in`).
+*/
+function layersOf(schema) {
+	const out = [];
+	const queue = [schema];
+	while (queue.length > 0) {
+		const s = queue.shift();
+		if (!s || out.includes(s)) continue;
+		out.push(s);
+		const def = defOf(s);
+		if (def.type !== void 0 && WRAPPERS.has(def.type) && def.innerType) queue.push(def.innerType);
+		if (def.type === "pipe") {
+			if (def.in) queue.push(def.in);
+			if (def.out) queue.push(def.out);
+		}
+	}
+	return out;
+}
+/** True when any layer of this field declares `.meta({ secret: true })`. */
+function isZodSecret(schema) {
+	return layersOf(schema).some(declaredHere);
+}
+/**
+* Every declared secret path in a config schema: dotted keys, `[]` for "each
+* 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.
+*/
+function collectZodSecretPaths(schema, prefix = "") {
+	if (isZodSecret(schema)) return prefix.length > 0 ? [prefix] : [];
+	const paths = [];
+	for (const layer of layersOf(schema)) {
+		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));
+			if (def.right) paths.push(...collectZodSecretPaths(def.right, prefix));
+		}
+	}
+	return [...new Set(paths)];
+}
+/**
+* Record kinds (D881): the declaration an addon makes of one kind of fact, the
+* Zod row schema that describes it, and the helper that turns the two into the
+* JSON the engine stores.
+*
+* A kind is declared ONCE, next to the code that owns it, and the engine's
+* reconciler creates its indexes - nothing creates DDL at runtime from a write.
+* Everything the generic machinery needs (secret fields, the entry descriptor)
+* is DERIVED from the Zod schema: `.meta({ secret: true })` marks a credential,
+* never a field name (D879).
+*/
+/** A JSON field path: `trackId`, `auth.accessToken`. Charset-restricted: it is rendered into DDL. */
+var RecordFieldPathSchema = string().regex(/^[A-Za-z_][A-Za-z0-9_]{0,63}(\.[A-Za-z_][A-Za-z0-9_]{0,63}){0,3}$/);
+var RecordIndexSchema = object({
+	name: string().regex(/^[a-z][a-z0-9_]{0,31}$/),
+	fields: array(RecordFieldPathSchema).min(1).max(4),
+	unique: boolean().optional()
+}).strict();
+var RecordRetentionSchema = union([
+	object({
+		ttlMs: number$1().int().positive(),
+		from: _enum(["at", "write"])
+	}).strict(),
+	object({
+		maxRows: number$1().int().positive().optional(),
+		maxRowsPerDevice: number$1().int().positive().optional()
+	}).strict().refine((r) => r.maxRows !== void 0 || r.maxRowsPerDevice !== void 0, { message: "name maxRows, maxRowsPerDevice or both" }),
+	object({
+		owner: string().min(1),
+		reason: string().min(1)
+	}).strict(),
+	object({ none: string().min(1) }).strict()
+]);
+/** The descriptor a generic entries UI reads (D881 "generic entries"). */
+var EntryDescriptorSchema = object({
+	title: string().min(1),
+	/** The record body field shown as the entry's name. */
+	nameField: string().min(1),
+	/** JSON Schema of the entry body; `secret: true` marks a password field. */
+	fields: record(string(), unknown())
+}).strict();
+/** What crosses the wire from an addon: JSON only, no Zod. An unknown key is refused. */
+var RecordKindDeclarationSchema = object({
+	database: _enum(RECORD_DATABASES).default("settings"),
+	class: _enum(RECORD_CLASSES),
+	writeTrigger: string().min(1),
+	device: _enum([
+		"required",
+		"optional",
+		"none"
+	]).default("none"),
+	at: _enum(["required", "none"]).default("none"),
+	indexes: array(RecordIndexSchema).max(8).default([]),
+	retention: RecordRetentionSchema,
+	deviceRemoval: _enum(["delete", "none"]).default("none"),
+	maxDataBytes: number$1().int().positive().max(RECORD_MAX_DATA_BYTES).default(RECORD_DEFAULT_MAX_DATA_BYTES),
+	/** Derived from the Zod schema; never written by hand. */
+	secretPaths: array(string().min(1)).default([]),
+	/** The id key of each array that carries a secret (`{ headers: 'name' }`). */
+	secretArrayKeys: record(string(), string()).default({}),
+	/** Kinds that must agree through `transact` sit in one file under one family name. */
+	transactFamily: string().min(1).optional(),
+	entry: EntryDescriptorSchema.optional()
+}).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),
+		enabled: boolean().optional(),
+		...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;
+}
+/**
+* The share-view scope kinds a share-link token can carry. The hub mints
+* and validates them (`ShareViewGrantSchema` builds its
+* enum from this list); a data plane names the kinds it ACCEPTS in `share`.
+*/
+var SHARE_VIEW_KINDS = ["grid-view", "events-view"];
+/** The wire shape of {@link PeerBytesTicket} — see the type for what it is. */
+var PeerBytesTicketSchema = object({
+	/** `http://127.0.0.1:<port>/<token>`. One `GET` takes it. */
+	url: string().min(1),
+	/**
+	* The HOST node this URL means something on — the hub or a named agent,
+	* never a runner. {@link AddonPeerBytes.open} compares it to its own and
+	* refuses `cross-node` by name when they differ, without dialling.
+	*/
+	hostNodeId: string().min(1),
+	expiresAtMs: number$1().int().nonnegative(),
+	/**
+	* What the producer DECLARED the body to be, when it knows — `null` when it
+	* does not. Never `0` for unknown (D393): a consumer sizing a bound off this
+	* must be able to tell "the producer did not say" from "the body is empty".
+	*/
+	declaredBytes: number$1().int().nonnegative().nullable()
+});
 var READING_QUANTITIES = [
 	"temperature",
 	"pressure",
@@ -10539,7 +10546,6 @@ var CAP_NAMES = Object.freeze([
 	"climate-control",
 	"color",
 	"composer",
-	"connection-test",
 	"connectivity",
 	"consumables",
 	"contact",
@@ -12559,8 +12565,7 @@ Object.freeze({
 		"offerArtifact": 3e5,
 		"readResult": 3e5,
 		"submitJob": 18e5,
-		"uploadDataset": 72e5,
-		"validateCredentials": 3e4
+		"uploadDataset": 72e5
 	}
 });
 object({
@@ -14061,6 +14066,17 @@ function composeInstanceKinds(parts, base) {
 		if (part === void 0) throw new UnknownInstanceKindError(kindId);
 		return part;
 	};
+	/**
+	* The part a DRAFT test runs on. A named kind is that kind; an unnamed one is the provider's only
+	* testable kind. Several testable kinds and none named is a typed refusal that lists them, never a throw.
+	*/
+	const draftPart = (kindId) => {
+		if (kindId !== void 0) return parts.find((candidate) => candidate.kind.id === kindId) ?? { error: `Unknown instance kind '${kindId}'` };
+		const testable = parts.filter((part) => part.kind.canTest !== false);
+		const only = testable.length === 1 ? testable[0] : parts.length === 1 ? parts[0] : void 0;
+		if (only !== void 0) return only;
+		return { error: `This provider has several kinds: name one of ${(testable.length > 0 ? testable : parts).map((part) => part.kind.id).join(", ")}` };
+	};
 	const holderOf = async (id) => {
 		for (const part of parts) if (await part.provider.getInstance({ id }) !== null) return part;
 		throw new UnknownInstanceError(id);
@@ -14096,7 +14112,13 @@ function composeInstanceKinds(parts, base) {
 		setInstanceEnabled: async (input) => (await holderOf(input.id)).provider.setInstanceEnabled(input),
 		deleteInstance: async (input) => (await holderOf(input.id)).provider.deleteInstance(input),
 		testInstance: async (input) => {
-			const test = (input.id === null ? byKind(input.kind) : await holderOf(input.id)).provider.testInstance;
+			const resolved = input.id === null ? draftPart(input.kind) : await holderOf(input.id);
+			if ("error" in resolved) return {
+				success: false,
+				status: "inconclusive",
+				error: resolved.error
+			};
+			const test = resolved.provider.testInstance;
 			if (test === void 0) return {
 				success: false,
 				status: "inconclusive",
@@ -14106,6 +14128,745 @@ function composeInstanceKinds(parts, base) {
 		}
 	};
 }
+/**
+* notification-output — canonical, capability-gated notification delivery.
+*
+* Apprise-derived model (see
+* `docs/superpowers/specs/2026-07-03-notification-output-notifier-matrix.md`):
+* callers emit ONE canonical `Notification`; each provider declares a
+* per-kind capability descriptor (`TargetKind`), and the pure degrade
+* engine (`@camstack/types` `prepareNotification`) transcodes / degrades the
+* message to what the kind supports — callers never special-case a service.
+*
+* DESIGN DECISIONS (locked):
+*  - Target CRUD lives on THIS cap (`upsertTarget` / `deleteTarget` /
+*    `setTargetEnabled`), each provider persisting via the `settings-store`
+*    cap. Rationale: the admin UI needs one uniform surface across the
+*    notifiers addon AND the HA addon; the addon-`globalSettingsSchema`-array
+*    alternative would fork the UI per addon and cannot host the
+*    discovery→adopt flow.
+*  - `listTargetKinds` / `listTargets` / `discoverTargets` return arrays →
+*    the generated cap-mount auto-`concatCollection`-fans them across every
+*    registered provider (notifiers addon + HA addon) so one catalog is
+*    routable. `send` / `testTarget` / CRUD route to ONE provider by the
+*    `addonId` the generated collection router extracts from the call input.
+*  - `Attachment.bytes` is `Uint8Array`. Transport-safe: superjson (the tRPC
+*    transformer) + UDS MsgPack both round-trip typed arrays — already used by
+*    `storage` / `storage-provider` / `recording` caps over the same path. No
+*    base64 fallback needed.
+*
+* TODO (deferred, closed-set change — separate decision): add
+* `providerKind: 'notify'` so notification providers surface on the unified
+* admin "Integrations" page.
+*/
+/**
+* Zentik-derived typed-media enum — the superset across every kind. Each
+* adapter picks what it supports and the degrade engine filters the rest.
+*/
+var AttachmentMediaTypeSchema = _enum([
+	"image",
+	"video",
+	"gif",
+	"audio",
+	"icon"
+]);
+/**
+* A single attachment. Exactly one of `url` (remote source, most adapters
+* prefer this) or `bytes` (inline source; required for Pushover-style
+* bytes-only kinds) MUST be present — the degrade engine expresses a
+* url→bytes fetch as a `needsFetch` directive the adapter executes.
+*/
+var AttachmentSchema = object({
+	mediaType: AttachmentMediaTypeSchema,
+	url: string().optional(),
+	bytes: _instanceof(Uint8Array).optional(),
+	mime: string().optional(),
+	name: string().optional()
+}).refine((a) => a.url !== void 0 || a.bytes !== void 0, { message: "Attachment requires either `url` or `bytes`" });
+var NotificationFormatSchema = _enum([
+	"text",
+	"markdown",
+	"html"
+]);
+/**
+* The CLOSED icon vocabulary an action button may use.
+*
+* A closed set, not a free string, and that is the whole point: an arbitrary
+* icon name is one that ntfy renders, zentik silently drops, and nobody
+* notices — the same class of gap as a zone vocabulary nothing produced
+* ([D35](../../../docs/decisions/adr-0035.md)). Every adapter maps this set or
+* declares `actionIcons: false` and the degrade engine strips the field.
+*
+* Named by INTENT, never by glyph. "check" would tie the vocabulary to one
+* renderer's icon set; "acknowledge" survives an adapter that draws it
+* differently.
+*
+* ── A TOKEN IS NOT A WIRE VALUE ─────────────────────────────────────
+*
+* These names are for US. **No adapter may forward one verbatim.** Each maps
+* the whole set onto its own renderer's vocabulary through a
+* `Record<NotificationActionIcon, string>` — a Record, never a lookup with a
+* fallback, so adding a member here fails every adapter's build until someone
+* decides its glyph, which is the only place that decision can be made
+* honestly.
+*
+* This paragraph is the bug. Zentik declared `actionIcons: true` and passed
+* `disarm` straight through; iOS feeds that string to
+* `UNNotificationActionIcon(systemImageName:)`, `disarm` is not an SF Symbol,
+* and every snooze and alarm button arrived BLANK. A pass-through is not a
+* mapping, and "the field is documented" is not "the value renders".
+*
+* Adding a member is TRAIN-BOUND. The enum lives in the published
+* `@camstack/server` closure and the cap seam validates against the HUB's copy,
+* so an addon that emits a token the running hub does not know does not lose an
+* icon — its whole `send` fails Zod validation and the notification never
+* arrives. Never emit a new token from an addon before the train carrying it.
+*/
+var NotificationActionIconSchema = _enum([
+	"acknowledge",
+	"dismiss",
+	"silence",
+	"snooze",
+	"view",
+	"play",
+	"open",
+	"close",
+	"lock",
+	"unlock",
+	"arm",
+	"arm-home",
+	"arm-away",
+	"arm-night",
+	"disarm",
+	"light",
+	"alert",
+	"camera"
+]);
+/** A single tap-through action button. */
+var NotificationActionSchema = object({
+	id: string(),
+	label: string(),
+	url: string().optional(),
+	/** Dropped by the degrade engine for a kind with `caps.actionIcons: false`. */
+	icon: NotificationActionIconSchema.optional(),
+	/**
+	* Renders in a warning style where the notifier supports it.
+	*
+	* A HINT, never a gate. The callback's authority is its token and nothing
+	* else — see `notification-center/action-token.ts` for what that does and
+	* does not buy.
+	*/
+	destructive: boolean().optional(),
+	/**
+	* How the tap should REACH the url.
+	*
+	* `navigate` (absent, and every button authored before this field) opens it:
+	* the phone leaves the notification and shows whatever the callback returns.
+	* That is right for a button whose answer the operator wants to read.
+	*
+	* `background` fires it as a POST and stays put. It exists for the buttons
+	* whose whole point is not to interrupt — "silence this for 30 minutes" is
+	* an answer to the notification, and being thrown into a browser tab to
+	* confirm it costs more attention than the notification did. A backend that
+	* cannot do a background call renders it as an ordinary link (the adapters
+	* fall back rather than dropping the button), so this is a preference, never
+	* a requirement.
+	*/
+	mode: _enum(["navigate", "background"]).optional()
+});
+/** A delivery parameter value: what a notifier declared it takes. */
+var DeliveryParamValueSchema = union([
+	string(),
+	number$1(),
+	boolean()
+]);
+/**
+* One extra delivery parameter a notifier KIND declares (D938). A rule that
+* addresses a target of that kind may set it; a kind that declares nothing is
+* never handed one. The admin UI derives its control from this descriptor —
+* no editor knows a service by name.
+*
+* Optional fields are `.optional()`, never `.default()` (a Zod default does not
+* run on the addon cap path).
+*/
+var DeliveryParamSchema = object({
+	key: string().min(1),
+	label: string(),
+	/** i18n key of the label, resolved by the declaring addon's namespace. */
+	labelKey: string().optional(),
+	type: _enum([
+		"enum",
+		"number",
+		"boolean",
+		"string"
+	]),
+	/** `enum` only: the closed set of accepted values. */
+	options: array(object({
+		value: string(),
+		label: string()
+	})).optional(),
+	/** `number` only. */
+	min: number$1().optional(),
+	max: number$1().optional(),
+	/** What the notifier does when the rule sets nothing; shown as the placeholder. */
+	default: DeliveryParamValueSchema.optional()
+});
+/**
+* The canonical notification. `body` is the only hard field (Apprise model).
+* `priority` is a 5-level ORDINAL (1=lowest … 3=normal(default) … 5=urgent),
+* NOT a fixed severity enum — each kind declares its own `caps.levels` and
+* the adapter maps this ordinal onto its native level. `level?` is an
+* optional kind-native level id (`emergency`, `silent`, …) that overrides
+* `priority` for that one target.
+*/
+var NotificationSchema = object({
+	body: string(),
+	title: string().optional(),
+	format: NotificationFormatSchema.default("text"),
+	priority: number$1().int().min(1).max(5).default(3),
+	level: string().optional(),
+	attachments: array(AttachmentSchema).optional(),
+	clickUrl: string().optional(),
+	actions: array(NotificationActionSchema).optional(),
+	sound: string().optional(),
+	ttl: number$1().optional(),
+	tag: string().optional(),
+	deviceId: number$1().optional(),
+	eventId: string().optional(),
+	metadata: record(string(), unknown()).optional(),
+	/**
+	* Values for the parameters the target's kind DECLARES in
+	* {@link TargetKindSchema} `deliveryParams`. Already validated against the
+	* declaration by the sender; a notifier reads only the keys it declared.
+	*/
+	delivery: record(string(), DeliveryParamValueSchema).optional()
+});
+/** One declared native severity/priority level for a kind. */
+var TargetKindLevelSchema = object({
+	id: string(),
+	label: string(),
+	/** Which canonical priority (1..5) this level maps to. `null` = qualitative-only. */
+	ordinal: number$1().int().min(1).max(5).nullable(),
+	flags: object({
+		critical: boolean().optional(),
+		silent: boolean().optional(),
+		noPush: boolean().optional()
+	}).optional(),
+	/** e.g. Pushover `emergency` requires `retry` / `expire`. */
+	requires: array(string()).optional(),
+	description: string().optional()
+});
+/** The full capability block consulted before dispatch. */
+var TargetKindCapsSchema = object({
+	attachments: object({
+		mediaTypes: array(AttachmentMediaTypeSchema),
+		mode: _enum([
+			"url",
+			"bytes",
+			"both"
+		]),
+		max: number$1().int().nonnegative(),
+		maxBytes: number$1().int().positive().optional()
+	}),
+	/** Max action buttons (0 = none). */
+	actions: number$1().int().nonnegative(),
+	/**
+	* Whether this kind renders a per-action ICON.
+	*
+	* `.optional()`, deliberately NOT `.default(false)`: a Zod default does not
+	* run on the addon cap path — three production failures in one day taught
+	* this repo that once. Absent is read as false by the degrade engine, which
+	* is the safe direction: an icon that is not rendered costs nothing, an icon
+	* assumed and dropped costs the operator's trust in the field.
+	*/
+	actionIcons: boolean().optional(),
+	levels: array(TargetKindLevelSchema),
+	format: array(NotificationFormatSchema),
+	clickUrl: boolean(),
+	sound: boolean(),
+	ttl: boolean(),
+	bodyMaxLen: number$1().int().positive()
+});
+/**
+* `configSchema` is a `ConfigUISchema` tree passed through to the admin
+* FormBuilder. Stored as `z.unknown()` at the cap seam (mirrors
+* `device-provider.getChildCreationSchema` `CreationSchemaOutputSchema`) —
+* the union is large and not meant for runtime validation here; the exported
+* `TargetKind` type re-tightens `configSchema` to `ConfigUISchema`.
+*/
+var ConfigSchemaPassthrough$4 = unknown();
+var TargetKindSchema = object({
+	kind: string(),
+	label: string(),
+	icon: string(),
+	/** Stamped by each provider so the concat-fanned catalog stays routable. */
+	addonId: string(),
+	/**
+	* URL of the kind's bundled BRAND icon, served by the providing addon over
+	* its own `addon-routes` surface (`/addon/<addonId>/icons/<kind>`). Absent
+	* when the addon bundles no icon for that kind — the client then falls back
+	* to a neutral glyph rather than rendering the raw `icon` NAME as text.
+	*
+	* Root-relative on purpose: it resolves against whatever origin serves a web
+	* client, and a native client joins it onto its own hub base.
+	*
+	* DECLARED here deliberately. It used to travel as an undeclared passthrough
+	* field that survived only because the runtime cap-router forwards provider
+	* output verbatim — so every consumer had to re-declare it by hand to stop
+	* its own Zod parse from stripping it, and the whole arrangement would have
+	* broken silently the moment output validation was tightened anywhere.
+	*/
+	iconUrl: string().optional(),
+	/**
+	* Media type of {@link iconUrl} (`image/svg+xml`, `image/png`, …).
+	*
+	* The server knows this and therefore says it, because the client cannot
+	* safely guess: a React-Native client renders SVG and raster through two
+	* DIFFERENT components (`react-native-svg` vs `expo-image` — expo-image does
+	* not decode SVG on iOS/Android), so without this it silently fell back to a
+	* placeholder glyph for every vector icon while the web build looked fine.
+	*
+	* Absent when {@link iconUrl} is absent, or for a legacy provider that has
+	* not been updated — a client that cannot determine the type should prefer
+	* its raster path, which is the safe default for an unknown image.
+	*/
+	iconMediaType: string().optional(),
+	configSchema: ConfigSchemaPassthrough$4,
+	/**
+	* The config keys that decide WHERE this kind's secrets are sent (server,
+	* base URL, instance, chat, recipient). A save that changes any of them
+	* while leaving a secret redacted is refused by the provider (D634), so an
+	* editor uses this to ask for the secret on exactly those edits instead of
+	* on every edit.
+	*
+	* Optional: absent from a provider that holds no secret (the Home Assistant
+	* kinds) and from a provider older than this field — an editor that finds
+	* it absent must assume ANY edit may need the secret.
+	*/
+	destinationKeys: array(string()).optional(),
+	supportsDiscovery: boolean(),
+	/**
+	* Extra delivery parameters a rule may set for a target of this kind (D938).
+	* Absent = none; the rule editor then offers nothing.
+	*/
+	deliveryParams: array(DeliveryParamSchema).optional(),
+	caps: TargetKindCapsSchema
+});
+/**
+* A persisted target. `config` holds secrets; providers REDACT secret fields
+* (return a presence marker only) when serving `listTargets` — never
+* round-trip a stored secret to the UI.
+*/
+var TargetSchema = object({
+	id: string(),
+	name: string(),
+	kind: string(),
+	addonId: string(),
+	enabled: boolean(),
+	config: record(string(), unknown())
+});
+/** A discovery-surfaced candidate (config is partial + non-secret). */
+var DiscoveredTargetSchema = object({
+	kind: string(),
+	suggestedName: string(),
+	config: record(string(), unknown())
+});
+/** The degrade engine's report — what was resolved / dropped / degraded. */
+var RenderedAsSchema = object({
+	level: string(),
+	format: NotificationFormatSchema,
+	attachmentsSent: number$1().int().nonnegative(),
+	actionsSent: number$1().int().nonnegative(),
+	truncated: boolean(),
+	dropped: array(string())
+});
+var SendResultSchema = object({
+	success: boolean(),
+	error: string().optional(),
+	renderedAs: RenderedAsSchema.optional()
+});
+/** Same shape as SendResult — kept as a distinct name for the test panel. */
+var TestResultSchema = SendResultSchema;
+/**
+* Pre-save credential probe against a partial (unsaved) target config.
+* `resolvedUrl` never includes secrets (token stripped from path).
+*/
+var ProbeTargetConfigResultSchema = object({
+	ok: boolean(),
+	resolvedUrl: string(),
+	httpStatus: number$1().int().optional(),
+	stateInstance: string().optional(),
+	error: string().optional()
+});
+var notificationOutputCapability = {
+	name: "notification-output",
+	scope: "system",
+	mode: "collection",
+	methods: {
+		listTargetKinds: method(object({}), array(TargetKindSchema)),
+		listTargets: method(object({}), array(TargetSchema), { auth: "admin" }),
+		/**
+		* One target WITH secrets — admin edit / duplicate hydration only.
+		* `listTargets` stays redacted; the editor loads this so password fields
+		* are filled (masked in the input) and a save can round-trip the token
+		* when a destination changes (Duplicate with a new chatId, etc.).
+		*/
+		getTarget: method(object({ targetId: string() }), TargetSchema, { auth: "admin" }),
+		discoverTargets: method(object({
+			kind: string(),
+			config: record(string(), unknown()).optional(),
+			/**
+			* When editing / duplicating, the blank password field never round-trips
+			* the stored token. Pass the source target id so the provider can restore
+			* secrets server-side before dialling (same merge as upsert).
+			*/
+			targetId: string().optional()
+		}), array(DiscoveredTargetSchema), { auth: "admin" }),
+		probeTargetConfig: method(object({
+			kind: string(),
+			config: record(string(), unknown()),
+			/** See `discoverTargets.targetId` — restore stored secrets for a blank password. */
+			targetId: string().optional()
+		}), ProbeTargetConfigResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		send: method(object({
+			targetId: string(),
+			notification: NotificationSchema
+		}), SendResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		testTarget: method(object({
+			targetId: string(),
+			sample: NotificationSchema.optional()
+		}), TestResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		upsertTarget: method(object({
+			target: TargetSchema,
+			/**
+			* Duplicate flow: create a NEW target id while copying secrets from an
+			* existing row. The UI never holds the stored token; blank / redacted
+			* password fields are restored from this source (D634 still applies if
+			* destinations diverge without a re-typed secret).
+			*/
+			cloneSecretsFrom: string().optional()
+		}), TargetSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		deleteTarget: method(object({ targetId: string() }), _void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		setTargetEnabled: method(object({
+			targetId: string(),
+			enabled: boolean()
+		}), _void(), {
+			kind: "mutation",
+			auth: "admin"
+		})
+	}
+};
+/**
+* Notification targets as instances of the function cap `notification-output` (epic #440, step 6).
+*
+* A notification target used to be one row of one record kind (`{ name, kind, addonId, enabled,
+* config }`) with a free-form `config` blob whose secrets nobody could name. Now every target KIND
+* the provider offers (ntfy, telegram, webhook, ...) is a record kind of its own whose flat body IS
+* that kind's form: the adapter's `configSchema` lifted into a Zod object, a `password` field marked
+* `.meta({ secret: true })` so the records door keeps it in the keychain, an `instance-select` field
+* declared as a link so the hub refuses to delete what a target points at.
+*
+* Three providers (notifiers, Home Assistant, Alexa) serve the same shape, so the pieces are shared:
+*  - {@link defineNotificationTargetKind}: the record kind of one `TargetKind` descriptor;
+*  - {@link NotificationTargetStore}: the `Target`-shaped facade the existing provider code keeps
+*    using, over one handle per kind (the old `notification-output` CRUD keeps working on it);
+*  - {@link buildNotificationTargetInstances}: the `integration-instances` provider, one kind each;
+*  - {@link moveTargetRows}: the D987 procedure that flattens the old `config` blobs into the bodies.
+*/
+/** The function cap every notification target is an instance of. */
+var NOTIFICATION_OUTPUT_CAP = "notification-output";
+/** The most targets one provider lists (a settings page, not a table). */
+var TARGETS_LIST_MAX = 1e3;
+/** The record kind name of one target kind: `telegram` is stored under `notify-telegram`. */
+function notificationTargetKindName(kind) {
+	return `notify-${kind}`;
+}
+/** The body schema of a target kind: the entry's name and switch plus the adapter's fields. */
+var TargetBodyBaseSchema = looseObject({
+	name: string().min(1),
+	enabled: boolean().optional()
+});
+/** The shape of one `editable-array` row: the item fields, a `password` one a secret. */
+function rowSchemaOf(itemFields) {
+	const shape = {};
+	let idKey = null;
+	let hasSecret = false;
+	for (const item of itemFields) {
+		if (item.type === "password") {
+			shape[item.key] = string().optional().meta({ secret: true });
+			hasSecret = true;
+			continue;
+		}
+		shape[item.key] = unknown().optional();
+		idKey ??= item.key;
+	}
+	return {
+		row: looseObject(shape),
+		idKey,
+		hasSecret
+	};
+}
+/**
+* The Zod fields of a descriptor's form. A `password` field is a secret; an `instance-select` field is
+* a link to an instance of its function cap; an `editable-array` keeps its rows (a password inside a
+* row is a secret matched by the row's first plain field); every other field keeps whatever the
+* adapter's own parse accepts, because the form already validated its shape. The body is loose, so a key
+* the schema does not know (the owner of a personal target) survives a write.
+*/
+function fieldsOf(descriptor) {
+	const shape = {};
+	const secretArrayKeys = {};
+	for (const section of descriptor.configSchema.sections) for (const field of section.fields) switch (field.type) {
+		case "info": break;
+		case "password":
+			shape[field.key] = string().optional().meta({ secret: true });
+			break;
+		case "instance-select":
+			shape[field.key] = optionalLinkField({
+				cap: field.functionCap,
+				...field.kind !== void 0 ? { kind: field.kind } : {}
+			});
+			break;
+		case "editable-array": {
+			const { row, idKey, hasSecret } = rowSchemaOf(field.itemFields);
+			shape[field.key] = array(row).optional();
+			if (hasSecret && idKey !== null) secretArrayKeys[field.key] = idKey;
+			break;
+		}
+		default: shape[field.key] = unknown().optional();
+	}
+	return {
+		shape,
+		secretArrayKeys
+	};
+}
+/** The record kind of one target kind, derived from its descriptor. */
+function defineNotificationTargetKind(descriptor) {
+	const { shape, secretArrayKeys } = fieldsOf(descriptor);
+	return defineEntryKind(notificationTargetKindName(descriptor.kind), {
+		title: `${descriptor.label} notification targets`,
+		schema: TargetBodyBaseSchema.extend(shape),
+		writeTrigger: `an operator adds, edits, switches or removes a ${descriptor.label} notification target`,
+		...Object.keys(secretArrayKeys).length > 0 ? { secretArrayKeys } : {}
+	});
+}
+/** The record kinds of a provider's descriptors, keyed by the record kind name (for `records.declare`). */
+function notificationTargetKinds(descriptors) {
+	return Object.fromEntries(descriptors.map((descriptor) => {
+		const defined = defineNotificationTargetKind(descriptor);
+		return [defined.name, defined];
+	}));
+}
+/** The body a stored target becomes: the switch and the name, and the config fields flat beside them. */
+function targetBody(target) {
+	return {
+		...target.config,
+		name: target.name.length > 0 ? target.name : target.id,
+		enabled: target.enabled
+	};
+}
+/** The `Target` a record of a kind is; null when the row is not a target. */
+function targetOfRecord(addonId, kind, id, data) {
+	const { name, enabled: _enabled, ...config } = data;
+	const parsed = TargetSchema.safeParse({
+		id,
+		name,
+		kind,
+		addonId,
+		enabled: isInstanceEnabled(data),
+		config
+	});
+	return parsed.success ? parsed.data : null;
+}
+function targetOfOld(addonId, row) {
+	return {
+		id: row.id,
+		name: row.name,
+		kind: row.kind,
+		addonId,
+		enabled: row.enabled,
+		config: { ...row.config }
+	};
+}
+/**
+* The `Target`-shaped facade over one record kind per target kind. `list` returns the stored form (a
+* secret is a keychain marker: every reader redacts it anyway); `getById` returns the target with its
+* secrets resolved, which is what a send, a probe and an edit's secret merge need. A keychain that
+* cannot answer throws: a write never goes ahead with a secret it could not read (D49).
+*/
+var NotificationTargetStore = class NotificationTargetStore {
+	addonId;
+	handles;
+	options;
+	constructor(addonId, handles, options) {
+		this.addonId = addonId;
+		this.handles = handles;
+		this.options = options;
+	}
+	static of(records, addonId, kinds, descriptors, options = {}) {
+		const handles = [];
+		for (const descriptor of descriptors) {
+			const defined = kinds[notificationTargetKindName(descriptor.kind)];
+			if (defined === void 0) continue;
+			handles.push({
+				kind: descriptor.kind,
+				handle: records.kind(defined)
+			});
+		}
+		return new NotificationTargetStore(addonId, handles, options);
+	}
+	/** The record handle of each kind, for the migration ports. */
+	handlesByKind() {
+		return new Map(this.handles.map((entry) => [entry.kind, entry.handle]));
+	}
+	async list() {
+		const out = [];
+		for (const { kind, handle } of this.handles) {
+			const page = await handle.query({ limit: TARGETS_LIST_MAX });
+			for (const record of page.records) {
+				const target = targetOfRecord(this.addonId, kind, record.id, record.data);
+				if (target !== null) {
+					out.push(target);
+					continue;
+				}
+				this.options.logger?.warn("notification target record is not a valid target; left out of the list", { meta: {
+					targetId: record.id,
+					kind
+				} });
+			}
+		}
+		const held = new Set(out.map((target) => target.id));
+		for (const row of await this.legacyRows()) if (!held.has(row.id)) out.push(targetOfOld(this.addonId, row));
+		return out;
+	}
+	/** The legacy rows of a kind this provider serves (the others are not ours to show). */
+	async legacyRows() {
+		const legacy = this.options.legacy;
+		if (legacy === void 0) return [];
+		const served = new Set(this.handles.map((entry) => entry.kind));
+		return (await legacy.list()).filter((row) => served.has(row.kind));
+	}
+	async getById(id) {
+		for (const { kind, handle } of this.handles) {
+			const row = await handle.getResolved(id);
+			if (row !== null) return targetOfRecord(this.addonId, kind, row.id, row.data);
+		}
+		const old = (await this.legacyRows()).find((row) => row.id === id);
+		return old === void 0 ? null : targetOfOld(this.addonId, old);
+	}
+	/** Insert or replace by id; a target whose kind changed leaves the record of its old kind. */
+	async upsert(target) {
+		const own = this.handles.find((entry) => entry.kind === target.kind);
+		if (own === void 0) throw new Error(`invalid target '${target.id}': unknown kind '${target.kind}'`);
+		await own.handle.put({
+			id: target.id,
+			data: targetBody(target)
+		});
+		for (const other of this.handles) if (other !== own) await other.handle.delete(target.id);
+		await this.options.legacy?.delete(target.id);
+	}
+	async delete(id) {
+		for (const { handle } of this.handles) await handle.delete(id);
+		await this.options.legacy?.delete(id);
+	}
+	/** Flip the switch on an existing target; null when it does not exist. */
+	async setEnabled(id, enabled) {
+		for (const { kind, handle } of this.handles) {
+			if (await handle.get(id) === null) continue;
+			await handle.patch(id, { enabled });
+			const row = await handle.get(id);
+			return row === null ? null : targetOfRecord(this.addonId, kind, row.id, row.data);
+		}
+		const old = (await this.legacyRows()).find((row) => row.id === id);
+		if (old === void 0) return null;
+		const moved = {
+			...targetOfOld(this.addonId, old),
+			enabled
+		};
+		await this.upsert(moved);
+		return moved;
+	}
+};
+/**
+* A probe's answer as the tri-state of `testInstance`: `ok` validated; a refusal that carries an HTTP
+* status is the remote saying no (`rejected`); a failure with no answer at all (the network, a missing
+* field) proves nothing about the credentials (`inconclusive`).
+*/
+function probeToTestResult(probed) {
+	if (probed.ok) return {
+		success: true,
+		status: "validated",
+		...probed.stateInstance !== void 0 ? { detail: probed.stateInstance } : {}
+	};
+	const error = probed.error ?? "the probe failed";
+	return {
+		success: false,
+		status: probed.httpStatus !== void 0 ? "rejected" : "inconclusive",
+		error
+	};
+}
+/** The form of a kind: the adapter's own sections. */
+function formOf(descriptor) {
+	return descriptor.configSchema;
+}
+/** The instance kinds of a notification provider, one per target kind: a part a composition can take. */
+function notificationTargetParts(records, spec) {
+	return spec.descriptors.flatMap((descriptor) => {
+		const defined = spec.kinds[notificationTargetKindName(descriptor.kind)];
+		if (defined === void 0) return [];
+		const canTest = spec.probe !== void 0 && spec.canProbe(descriptor.kind);
+		const instances = new RecordIntegrationInstances(records, defined, {
+			description: {
+				role: "services",
+				instanceMode: "multiple",
+				kind: "target",
+				canTest
+			},
+			formSchema: () => formOf(descriptor),
+			initialBody: (name) => ({ name }),
+			mintId: () => spec.mintId(),
+			configured: () => true,
+			test: async ({ id, values }) => {
+				if (spec.probe === void 0 || !canTest) return {
+					success: false,
+					status: "unsupported",
+					error: "This kind cannot be tested"
+				};
+				return probeToTestResult(await spec.probe({
+					kind: descriptor.kind,
+					config: values,
+					targetId: id ?? void 0
+				}));
+			}
+		});
+		return [{
+			kind: {
+				id: descriptor.kind,
+				label: descriptor.label,
+				functionCap: NOTIFICATION_OUTPUT_CAP,
+				role: "services",
+				canTest
+			},
+			provider: instances.toProvider()
+		}];
+	});
+}
+TargetSchema.omit({ id: true });
 var EncodeProfileSchema = object({
 	video: object({
 		codec: _enum([
@@ -22431,7 +23192,6 @@ var SYSTEM_CAP_VOCABULARY = {
 	"calendar-source": system(INTERNAL),
 	calendars: system("calendars feed schedules and conditions, not device actions"),
 	composer: system("device composition — an authoring tool, not an action"),
-	"connection-test": system(INTERNAL),
 	"core-blocks": system(INTERNAL),
 	"custom-model-registry": system(ML),
 	"data-store-provider": system(INTERNAL),
@@ -44408,449 +45168,6 @@ var UnitWarningSchema = object({
 	assumedUnit: string(),
 	message: string()
 });
-/**
-* notification-output — canonical, capability-gated notification delivery.
-*
-* Apprise-derived model (see
-* `docs/superpowers/specs/2026-07-03-notification-output-notifier-matrix.md`):
-* callers emit ONE canonical `Notification`; each provider declares a
-* per-kind capability descriptor (`TargetKind`), and the pure degrade
-* engine (`@camstack/types` `prepareNotification`) transcodes / degrades the
-* message to what the kind supports — callers never special-case a service.
-*
-* DESIGN DECISIONS (locked):
-*  - Target CRUD lives on THIS cap (`upsertTarget` / `deleteTarget` /
-*    `setTargetEnabled`), each provider persisting via the `settings-store`
-*    cap. Rationale: the admin UI needs one uniform surface across the
-*    notifiers addon AND the HA addon; the addon-`globalSettingsSchema`-array
-*    alternative would fork the UI per addon and cannot host the
-*    discovery→adopt flow.
-*  - `listTargetKinds` / `listTargets` / `discoverTargets` return arrays →
-*    the generated cap-mount auto-`concatCollection`-fans them across every
-*    registered provider (notifiers addon + HA addon) so one catalog is
-*    routable. `send` / `testTarget` / CRUD route to ONE provider by the
-*    `addonId` the generated collection router extracts from the call input.
-*  - `Attachment.bytes` is `Uint8Array`. Transport-safe: superjson (the tRPC
-*    transformer) + UDS MsgPack both round-trip typed arrays — already used by
-*    `storage` / `storage-provider` / `recording` caps over the same path. No
-*    base64 fallback needed.
-*
-* TODO (deferred, closed-set change — separate decision): add
-* `providerKind: 'notify'` so notification providers surface on the unified
-* admin "Integrations" page.
-*/
-/**
-* Zentik-derived typed-media enum — the superset across every kind. Each
-* adapter picks what it supports and the degrade engine filters the rest.
-*/
-var AttachmentMediaTypeSchema = _enum([
-	"image",
-	"video",
-	"gif",
-	"audio",
-	"icon"
-]);
-/**
-* A single attachment. Exactly one of `url` (remote source, most adapters
-* prefer this) or `bytes` (inline source; required for Pushover-style
-* bytes-only kinds) MUST be present — the degrade engine expresses a
-* url→bytes fetch as a `needsFetch` directive the adapter executes.
-*/
-var AttachmentSchema = object({
-	mediaType: AttachmentMediaTypeSchema,
-	url: string().optional(),
-	bytes: _instanceof(Uint8Array).optional(),
-	mime: string().optional(),
-	name: string().optional()
-}).refine((a) => a.url !== void 0 || a.bytes !== void 0, { message: "Attachment requires either `url` or `bytes`" });
-var NotificationFormatSchema = _enum([
-	"text",
-	"markdown",
-	"html"
-]);
-/**
-* The CLOSED icon vocabulary an action button may use.
-*
-* A closed set, not a free string, and that is the whole point: an arbitrary
-* icon name is one that ntfy renders, zentik silently drops, and nobody
-* notices — the same class of gap as a zone vocabulary nothing produced
-* ([D35](../../../docs/decisions/adr-0035.md)). Every adapter maps this set or
-* declares `actionIcons: false` and the degrade engine strips the field.
-*
-* Named by INTENT, never by glyph. "check" would tie the vocabulary to one
-* renderer's icon set; "acknowledge" survives an adapter that draws it
-* differently.
-*
-* ── A TOKEN IS NOT A WIRE VALUE ─────────────────────────────────────
-*
-* These names are for US. **No adapter may forward one verbatim.** Each maps
-* the whole set onto its own renderer's vocabulary through a
-* `Record<NotificationActionIcon, string>` — a Record, never a lookup with a
-* fallback, so adding a member here fails every adapter's build until someone
-* decides its glyph, which is the only place that decision can be made
-* honestly.
-*
-* This paragraph is the bug. Zentik declared `actionIcons: true` and passed
-* `disarm` straight through; iOS feeds that string to
-* `UNNotificationActionIcon(systemImageName:)`, `disarm` is not an SF Symbol,
-* and every snooze and alarm button arrived BLANK. A pass-through is not a
-* mapping, and "the field is documented" is not "the value renders".
-*
-* Adding a member is TRAIN-BOUND. The enum lives in the published
-* `@camstack/server` closure and the cap seam validates against the HUB's copy,
-* so an addon that emits a token the running hub does not know does not lose an
-* icon — its whole `send` fails Zod validation and the notification never
-* arrives. Never emit a new token from an addon before the train carrying it.
-*/
-var NotificationActionIconSchema = _enum([
-	"acknowledge",
-	"dismiss",
-	"silence",
-	"snooze",
-	"view",
-	"play",
-	"open",
-	"close",
-	"lock",
-	"unlock",
-	"arm",
-	"arm-home",
-	"arm-away",
-	"arm-night",
-	"disarm",
-	"light",
-	"alert",
-	"camera"
-]);
-/** A single tap-through action button. */
-var NotificationActionSchema = object({
-	id: string(),
-	label: string(),
-	url: string().optional(),
-	/** Dropped by the degrade engine for a kind with `caps.actionIcons: false`. */
-	icon: NotificationActionIconSchema.optional(),
-	/**
-	* Renders in a warning style where the notifier supports it.
-	*
-	* A HINT, never a gate. The callback's authority is its token and nothing
-	* else — see `notification-center/action-token.ts` for what that does and
-	* does not buy.
-	*/
-	destructive: boolean().optional(),
-	/**
-	* How the tap should REACH the url.
-	*
-	* `navigate` (absent, and every button authored before this field) opens it:
-	* the phone leaves the notification and shows whatever the callback returns.
-	* That is right for a button whose answer the operator wants to read.
-	*
-	* `background` fires it as a POST and stays put. It exists for the buttons
-	* whose whole point is not to interrupt — "silence this for 30 minutes" is
-	* an answer to the notification, and being thrown into a browser tab to
-	* confirm it costs more attention than the notification did. A backend that
-	* cannot do a background call renders it as an ordinary link (the adapters
-	* fall back rather than dropping the button), so this is a preference, never
-	* a requirement.
-	*/
-	mode: _enum(["navigate", "background"]).optional()
-});
-/** A delivery parameter value: what a notifier declared it takes. */
-var DeliveryParamValueSchema = union([
-	string(),
-	number$1(),
-	boolean()
-]);
-/**
-* One extra delivery parameter a notifier KIND declares (D938). A rule that
-* addresses a target of that kind may set it; a kind that declares nothing is
-* never handed one. The admin UI derives its control from this descriptor —
-* no editor knows a service by name.
-*
-* Optional fields are `.optional()`, never `.default()` (a Zod default does not
-* run on the addon cap path).
-*/
-var DeliveryParamSchema = object({
-	key: string().min(1),
-	label: string(),
-	/** i18n key of the label, resolved by the declaring addon's namespace. */
-	labelKey: string().optional(),
-	type: _enum([
-		"enum",
-		"number",
-		"boolean",
-		"string"
-	]),
-	/** `enum` only: the closed set of accepted values. */
-	options: array(object({
-		value: string(),
-		label: string()
-	})).optional(),
-	/** `number` only. */
-	min: number$1().optional(),
-	max: number$1().optional(),
-	/** What the notifier does when the rule sets nothing; shown as the placeholder. */
-	default: DeliveryParamValueSchema.optional()
-});
-/**
-* The canonical notification. `body` is the only hard field (Apprise model).
-* `priority` is a 5-level ORDINAL (1=lowest … 3=normal(default) … 5=urgent),
-* NOT a fixed severity enum — each kind declares its own `caps.levels` and
-* the adapter maps this ordinal onto its native level. `level?` is an
-* optional kind-native level id (`emergency`, `silent`, …) that overrides
-* `priority` for that one target.
-*/
-var NotificationSchema = object({
-	body: string(),
-	title: string().optional(),
-	format: NotificationFormatSchema.default("text"),
-	priority: number$1().int().min(1).max(5).default(3),
-	level: string().optional(),
-	attachments: array(AttachmentSchema).optional(),
-	clickUrl: string().optional(),
-	actions: array(NotificationActionSchema).optional(),
-	sound: string().optional(),
-	ttl: number$1().optional(),
-	tag: string().optional(),
-	deviceId: number$1().optional(),
-	eventId: string().optional(),
-	metadata: record(string(), unknown()).optional(),
-	/**
-	* Values for the parameters the target's kind DECLARES in
-	* {@link TargetKindSchema} `deliveryParams`. Already validated against the
-	* declaration by the sender; a notifier reads only the keys it declared.
-	*/
-	delivery: record(string(), DeliveryParamValueSchema).optional()
-});
-/** One declared native severity/priority level for a kind. */
-var TargetKindLevelSchema = object({
-	id: string(),
-	label: string(),
-	/** Which canonical priority (1..5) this level maps to. `null` = qualitative-only. */
-	ordinal: number$1().int().min(1).max(5).nullable(),
-	flags: object({
-		critical: boolean().optional(),
-		silent: boolean().optional(),
-		noPush: boolean().optional()
-	}).optional(),
-	/** e.g. Pushover `emergency` requires `retry` / `expire`. */
-	requires: array(string()).optional(),
-	description: string().optional()
-});
-/** The full capability block consulted before dispatch. */
-var TargetKindCapsSchema = object({
-	attachments: object({
-		mediaTypes: array(AttachmentMediaTypeSchema),
-		mode: _enum([
-			"url",
-			"bytes",
-			"both"
-		]),
-		max: number$1().int().nonnegative(),
-		maxBytes: number$1().int().positive().optional()
-	}),
-	/** Max action buttons (0 = none). */
-	actions: number$1().int().nonnegative(),
-	/**
-	* Whether this kind renders a per-action ICON.
-	*
-	* `.optional()`, deliberately NOT `.default(false)`: a Zod default does not
-	* run on the addon cap path — three production failures in one day taught
-	* this repo that once. Absent is read as false by the degrade engine, which
-	* is the safe direction: an icon that is not rendered costs nothing, an icon
-	* assumed and dropped costs the operator's trust in the field.
-	*/
-	actionIcons: boolean().optional(),
-	levels: array(TargetKindLevelSchema),
-	format: array(NotificationFormatSchema),
-	clickUrl: boolean(),
-	sound: boolean(),
-	ttl: boolean(),
-	bodyMaxLen: number$1().int().positive()
-});
-/**
-* `configSchema` is a `ConfigUISchema` tree passed through to the admin
-* FormBuilder. Stored as `z.unknown()` at the cap seam (mirrors
-* `device-provider.getChildCreationSchema` `CreationSchemaOutputSchema`) —
-* the union is large and not meant for runtime validation here; the exported
-* `TargetKind` type re-tightens `configSchema` to `ConfigUISchema`.
-*/
-var ConfigSchemaPassthrough$4 = unknown();
-var TargetKindSchema = object({
-	kind: string(),
-	label: string(),
-	icon: string(),
-	/** Stamped by each provider so the concat-fanned catalog stays routable. */
-	addonId: string(),
-	/**
-	* URL of the kind's bundled BRAND icon, served by the providing addon over
-	* its own `addon-routes` surface (`/addon/<addonId>/icons/<kind>`). Absent
-	* when the addon bundles no icon for that kind — the client then falls back
-	* to a neutral glyph rather than rendering the raw `icon` NAME as text.
-	*
-	* Root-relative on purpose: it resolves against whatever origin serves a web
-	* client, and a native client joins it onto its own hub base.
-	*
-	* DECLARED here deliberately. It used to travel as an undeclared passthrough
-	* field that survived only because the runtime cap-router forwards provider
-	* output verbatim — so every consumer had to re-declare it by hand to stop
-	* its own Zod parse from stripping it, and the whole arrangement would have
-	* broken silently the moment output validation was tightened anywhere.
-	*/
-	iconUrl: string().optional(),
-	/**
-	* Media type of {@link iconUrl} (`image/svg+xml`, `image/png`, …).
-	*
-	* The server knows this and therefore says it, because the client cannot
-	* safely guess: a React-Native client renders SVG and raster through two
-	* DIFFERENT components (`react-native-svg` vs `expo-image` — expo-image does
-	* not decode SVG on iOS/Android), so without this it silently fell back to a
-	* placeholder glyph for every vector icon while the web build looked fine.
-	*
-	* Absent when {@link iconUrl} is absent, or for a legacy provider that has
-	* not been updated — a client that cannot determine the type should prefer
-	* its raster path, which is the safe default for an unknown image.
-	*/
-	iconMediaType: string().optional(),
-	configSchema: ConfigSchemaPassthrough$4,
-	/**
-	* The config keys that decide WHERE this kind's secrets are sent (server,
-	* base URL, instance, chat, recipient). A save that changes any of them
-	* while leaving a secret redacted is refused by the provider (D634), so an
-	* editor uses this to ask for the secret on exactly those edits instead of
-	* on every edit.
-	*
-	* Optional: absent from a provider that holds no secret (the Home Assistant
-	* kinds) and from a provider older than this field — an editor that finds
-	* it absent must assume ANY edit may need the secret.
-	*/
-	destinationKeys: array(string()).optional(),
-	supportsDiscovery: boolean(),
-	/**
-	* Extra delivery parameters a rule may set for a target of this kind (D938).
-	* Absent = none; the rule editor then offers nothing.
-	*/
-	deliveryParams: array(DeliveryParamSchema).optional(),
-	caps: TargetKindCapsSchema
-});
-/**
-* A persisted target. `config` holds secrets; providers REDACT secret fields
-* (return a presence marker only) when serving `listTargets` — never
-* round-trip a stored secret to the UI.
-*/
-var TargetSchema = object({
-	id: string(),
-	name: string(),
-	kind: string(),
-	addonId: string(),
-	enabled: boolean(),
-	config: record(string(), unknown())
-});
-/** A discovery-surfaced candidate (config is partial + non-secret). */
-var DiscoveredTargetSchema = object({
-	kind: string(),
-	suggestedName: string(),
-	config: record(string(), unknown())
-});
-/** The degrade engine's report — what was resolved / dropped / degraded. */
-var RenderedAsSchema = object({
-	level: string(),
-	format: NotificationFormatSchema,
-	attachmentsSent: number$1().int().nonnegative(),
-	actionsSent: number$1().int().nonnegative(),
-	truncated: boolean(),
-	dropped: array(string())
-});
-var SendResultSchema = object({
-	success: boolean(),
-	error: string().optional(),
-	renderedAs: RenderedAsSchema.optional()
-});
-/** Same shape as SendResult — kept as a distinct name for the test panel. */
-var TestResultSchema = SendResultSchema;
-/**
-* Pre-save credential probe against a partial (unsaved) target config.
-* `resolvedUrl` never includes secrets (token stripped from path).
-*/
-var ProbeTargetConfigResultSchema = object({
-	ok: boolean(),
-	resolvedUrl: string(),
-	httpStatus: number$1().int().optional(),
-	stateInstance: string().optional(),
-	error: string().optional()
-});
-var notificationOutputCapability = {
-	name: "notification-output",
-	scope: "system",
-	mode: "collection",
-	methods: {
-		listTargetKinds: method(object({}), array(TargetKindSchema)),
-		listTargets: method(object({}), array(TargetSchema), { auth: "admin" }),
-		/**
-		* One target WITH secrets — admin edit / duplicate hydration only.
-		* `listTargets` stays redacted; the editor loads this so password fields
-		* are filled (masked in the input) and a save can round-trip the token
-		* when a destination changes (Duplicate with a new chatId, etc.).
-		*/
-		getTarget: method(object({ targetId: string() }), TargetSchema, { auth: "admin" }),
-		discoverTargets: method(object({
-			kind: string(),
-			config: record(string(), unknown()).optional(),
-			/**
-			* When editing / duplicating, the blank password field never round-trips
-			* the stored token. Pass the source target id so the provider can restore
-			* secrets server-side before dialling (same merge as upsert).
-			*/
-			targetId: string().optional()
-		}), array(DiscoveredTargetSchema), { auth: "admin" }),
-		probeTargetConfig: method(object({
-			kind: string(),
-			config: record(string(), unknown()),
-			/** See `discoverTargets.targetId` — restore stored secrets for a blank password. */
-			targetId: string().optional()
-		}), ProbeTargetConfigResultSchema, {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		send: method(object({
-			targetId: string(),
-			notification: NotificationSchema
-		}), SendResultSchema, {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		testTarget: method(object({
-			targetId: string(),
-			sample: NotificationSchema.optional()
-		}), TestResultSchema, {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		upsertTarget: method(object({
-			target: TargetSchema,
-			/**
-			* Duplicate flow: create a NEW target id while copying secrets from an
-			* existing row. The UI never holds the stored token; blank / redacted
-			* password fields are restored from this source (D634 still applies if
-			* destinations diverge without a re-typed secret).
-			*/
-			cloneSecretsFrom: string().optional()
-		}), TargetSchema, {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		deleteTarget: method(object({ targetId: string() }), _void(), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		setTargetEnabled: method(object({
-			targetId: string(),
-			enabled: boolean()
-		}), _void(), {
-			kind: "mutation",
-			auth: "admin"
-		})
-	}
-};
 _enum([
 	"automation",
 	"action",
@@ -49454,37 +49771,6 @@ method(object({
 	kind: "mutation",
 	auth: "admin"
 }), method(object({ blockIds: array(string()) }), object({ states: array(CompositionBlockStateSchema) }), { auth: "admin" });
-var ConnectionTestOutcomeSchema = discriminatedUnion("outcome", [
-	object({
-		outcome: literal("validated"),
-		/** Round-trip of the sign-in, when the provider measured it. */
-		latencyMs: number$1().nonnegative().optional(),
-		/** Optional human detail worth showing next to the tick
-		*  ("3 devices visible on this account"). */
-		detail: string().optional()
-	}).strict(),
-	object({
-		outcome: literal("rejected"),
-		error: string()
-	}).strict(),
-	object({
-		outcome: literal("inconclusive"),
-		error: string()
-	}).strict()
-]);
-var ConnectionTestInputSchema = object({ 
-/** Candidate integration settings, exactly as the create form collected them. */
-settings: record(string(), unknown()) });
-/**
-* What the provider's test actually DOES, so the UI can say it in words before
-* the operator presses the button ("Signs in to the Dreo cloud"). Purely
-* descriptive — it never changes routing.
-*/
-var ConnectionTestDescriptorSchema = object({ label: string() });
-method(ConnectionTestInputSchema, ConnectionTestOutcomeSchema, {
-	kind: "mutation",
-	auth: "admin"
-}), method(_void(), ConnectionTestDescriptorSchema, { auth: "admin" });
 /**
 * Upstream-system connectivity sensor — distinct from `device-status`,
 * which is the kernel-managed online/offline flag for the device's
@@ -56638,10 +56924,9 @@ var AvailableIntegrationTypeSchema = object({
 	*  locations" checkbox. Provider-declared in the addon manifest. */
 	supportsLocationImport: boolean(),
 	/**
-	* True when this integration DECLARES a pre-creation test (the
-	* `connection-test` cap, or a broker whose settings it stores). Drives the
-	* Test button: an integration that cannot be tested must say so up front
-	* rather than offering a button that always answers the same nonsense.
+	* True when this integration's instances declare a Test (`integration-instances.describe().canTest`,
+	* D1016). An integration that cannot be tested must say so up front rather than offering a
+	* button that always answers the same nonsense.
 	*/
 	canTest: boolean(),
 	existingInstances: array(object({
@@ -56695,7 +56980,9 @@ var CreateIntegrationInputSchema = object({
 	info: record(string(), unknown()).optional(),
 	/** `stableId` of the discovery candidate the form was seeded from (D984). */
 	originStableId: string().optional(),
-	settings: record(string(), unknown()).optional()
+	settings: record(string(), unknown()).optional(),
+	/** The instance kind being created, for a provider with several; omitted = its only testable kind. */
+	kind: string().min(1).optional()
 });
 var UpdateIntegrationInputSchema = object({
 	id: string(),
@@ -56721,13 +57008,7 @@ method(_void(), array(IntegrationWithStateSchema)), method(object({ id: string()
 }), method(object({ id: string() }), DeleteIntegrationResultSchema, {
 	kind: "mutation",
 	auth: "admin"
-}), method(_void(), array(AvailableIntegrationTypeSchema), { auth: "admin" }), method(object({
-	addonId: string(),
-	settings: record(string(), unknown())
-}), TestConnectionResultSchema, {
-	kind: "mutation",
-	auth: "admin"
-});
+}), method(_void(), array(AvailableIntegrationTypeSchema), { auth: "admin" });
 /**
 * `integration-instances` - the connection of an addon that holds ONE or SEVERAL
 * (an account, a relay, a destination) as typed records (D985, D986). The addon's
@@ -65470,13 +65751,6 @@ var AddBrokerInputSchema = object({
 });
 var AddBrokerResultSchema = object({ id: string() });
 var IdInputSchema = object({ id: string() });
-var TestResultSchema$1 = discriminatedUnion("ok", [object({
-	ok: literal(true),
-	latencyMs: number$1()
-}), object({
-	ok: literal(false),
-	error: string()
-})]);
 var StartEmbeddedInputSchema = object({
 	port: number$1().int().min(1).max(65535).default(1883),
 	/** Allow anonymous connect (no username/password). Default: false. */
@@ -65499,9 +65773,6 @@ method(_void(), array(BrokerInfoSchema)), method(IdInputSchema, BrokerConnection
 }), method(IdInputSchema, _void(), {
 	kind: "mutation",
 	auth: "admin"
-}), method(IdInputSchema, TestResultSchema$1, {
-	kind: "mutation",
-	auth: "admin"
 }), method(StartEmbeddedInputSchema, StartEmbeddedResultSchema, {
 	kind: "mutation",
 	auth: "admin"
@@ -78608,7 +78879,7 @@ var TrainingProviderTypeSchema = object({
 	label: string(),
 	/** Path under the addon package (e.g. `assets/training-modal/icon.svg`). */
 	iconAsset: string(),
-	/** Owning `training-provider` addon — collection selector for createEntry. */
+	/** Owning `training-provider` addon. */
 	addonId: string(),
 	/**
 	* Fields for one entry of this type (credentials + defaults). Absent on a
@@ -78653,36 +78924,6 @@ var TrainingProviderDescriptorSchema = object({
 	*/
 	formValues: record(string(), unknown()).optional()
 });
-/**
-* Patch one entry's name, credentials and defaults. Pin with owning `{ addonId }`.
-* An omitted or empty `tokenSecret` means KEEP the stored secret (D787).
-* `{ $secretClear: true }` clears it.
-*/
-var TrainingProviderUpdateEntryInputSchema = object({
-	entryId: string().min(1),
-	name: string().min(1),
-	tokenId: string().optional(),
-	tokenSecret: union([string(), object({ $secretClear: literal(true) })]).optional(),
-	environment: string().optional(),
-	gpuType: string().optional(),
-	region: string().optional(),
-	costCapUsd: number$1().nonnegative().optional(),
-	maxRuntimeSec: number$1().int().positive().optional(),
-	failedDatasetGraceHours: number$1().nonnegative().optional()
-});
-var TrainingCredentialCheckSchema = object({
-	ok: boolean(),
-	/** Workspace / account name, when the provider says. */
-	account: string().optional(),
-	reason: _enum([
-		"missing",
-		"invalid",
-		"forbidden",
-		"network",
-		"quota"
-	]).optional(),
-	detail: string().optional()
-});
 var ProviderJobStateSchema = _enum([
 	"pending",
 	"starting",
@@ -78730,22 +78971,6 @@ var TrainingLogLineSchema = object({
 	text: string()
 });
 method(object({}), array(TrainingProviderDescriptorSchema).readonly(), { auth: "admin" }), method(object({}), array(TrainingProviderTypeSchema).readonly(), { auth: "admin" }), method(object({}), array(TrainingProviderEntrySchema).readonly(), { auth: "admin" }), method(object({
-	typeId: string().min(1),
-	name: string().min(1)
-}), object({ entryId: string() }), {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({ entryId: string().min(1) }), object({ ok: literal(true) }), {
-	kind: "mutation",
-	auth: "admin"
-}), method(TrainingProviderUpdateEntryInputSchema, object({ ok: literal(true) }), {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({ entryId: string().min(1) }), TrainingCredentialCheckSchema, {
-	kind: "mutation",
-	auth: "admin",
-	timeoutMs: 3e4
-}), method(object({
 	entryId: string().min(1),
 	gpuType: string(),
 	region: string(),
@@ -84106,20 +84331,6 @@ Object.freeze({
 		access: "view",
 		role: "admin"
 	},
-	"connectionTest.describeTest": {
-		capName: "connection-test",
-		capScope: "system",
-		addonId: null,
-		access: "view",
-		role: "admin"
-	},
-	"connectionTest.testSettings": {
-		capName: "connection-test",
-		capScope: "system",
-		addonId: null,
-		access: "create",
-		role: "admin"
-	},
 	"connectivity.getStatus": {
 		capName: "connectivity",
 		capScope: "device",
@@ -86486,13 +86697,6 @@ Object.freeze({
 		access: "view",
 		role: "admin"
 	},
-	"integrations.testConnection": {
-		capName: "integrations",
-		capScope: "system",
-		addonId: null,
-		access: "create",
-		role: "admin"
-	},
 	"integrations.update": {
 		capName: "integrations",
 		capScope: "system",
@@ -87725,13 +87929,6 @@ Object.freeze({
 		access: "create",
 		role: "admin"
 	},
-	"mqttBroker.testConnection": {
-		capName: "mqtt-broker",
-		capScope: "system",
-		addonId: null,
-		access: "create",
-		role: "admin"
-	},
 	"nativeObjectDetection.getOptions": {
 		capName: "native-object-detection",
 		capScope: "device",
@@ -92562,20 +92759,6 @@ Object.freeze({
 		access: "create",
 		role: "admin"
 	},
-	"trainingProvider.createEntry": {
-		capName: "training-provider",
-		capScope: "system",
-		addonId: null,
-		access: "create",
-		role: "admin"
-	},
-	"trainingProvider.deleteEntry": {
-		capName: "training-provider",
-		capScope: "system",
-		addonId: null,
-		access: "delete",
-		role: "admin"
-	},
 	"trainingProvider.describe": {
 		capName: "training-provider",
 		capScope: "system",
@@ -92646,13 +92829,6 @@ Object.freeze({
 		access: "create",
 		role: "admin"
 	},
-	"trainingProvider.updateEntry": {
-		capName: "training-provider",
-		capScope: "system",
-		addonId: null,
-		access: "create",
-		role: "admin"
-	},
 	"trainingProvider.uploadDataset": {
 		capName: "training-provider",
 		capScope: "system",
@@ -92660,13 +92836,6 @@ Object.freeze({
 		access: "create",
 		role: "admin"
 	},
-	"trainingProvider.validateCredentials": {
-		capName: "training-provider",
-		capScope: "system",
-		addonId: null,
-		access: "create",
-		role: "admin"
-	},
 	"turnProvider.getTurnServers": {
 		capName: "turn-provider",
 		capScope: "system",
@@ -145216,452 +145385,6 @@ function regionOfDomain(domain) {
 	if (tail === "amazon.co.jp" || tail === "amazon.com.au" || tail === "amazon.in") return "FE";
 	return "EU";
 }
-process.platform, process.env["SystemRoot"];
-/**
-* Files only their owner may read: the one place a secret-bearing file is
-* restricted, on every OS.
-*
-* `mode: 0o600` is a POSIX idea. On Windows Node maps it to the read-only
-* attribute and nothing else, and `chmod` is a no-op for permissions, so a
-* "0600" `agent.json` (the mesh private key) would have
-* been readable by every local user. Windows has its own tool for this:
-* `icacls`. This module removes the inherited ACL entries and grants access to
-* the current user and SYSTEM only — the Windows reading of "0600".
-*
-* ZERO imports beyond Node built-ins, on purpose: the Electron shell bundles
-* this single file (see `packages/desktop/tsup.config.ts`) instead of the
-* whole `@camstack/types` barrel.
-*
-* Failure is NOT swallowed. A secret file that could not be restricted is a
-* secret file the caller must know about, so `OwnerOnlyError` propagates; the
-* write order below makes sure nothing sensitive is in the file yet when that
-* happens (the temp file is empty until it has been restricted).
-*
-* Out of scope on purpose: files that are only tidy, not secret (the job
-* journal, the addon manifest) keep a plain `mode`, since one `icacls` per
-* write would be a process spawn on a hot path.
-*/
-/** `*S-1-5-18` is SYSTEM in every locale — a name like "SYSTEM" is not. */
-var WINDOWS_SYSTEM_SID = "*S-1-5-18";
-var FILE_MODE = 384;
-var DIR_MODE = 448;
-var OwnerOnlyError = class extends Error {
-	target;
-	constructor(target, detail) {
-		super(`could not restrict ${target} to its owner: ${detail}`);
-		this.target = target;
-		this.name = "OwnerOnlyError";
-	}
-};
-function currentPrincipal() {
-	const user = process.env["USERNAME"] ?? userInfo().username;
-	const domain = process.env["USERDOMAIN"];
-	return domain !== void 0 && domain.length > 0 ? `${domain}\\${user}` : user;
-}
-/** Resolved per call, not at import: a platform stubbed by a test must be seen. */
-function resolveDeps(overrides) {
-	return {
-		platform: process.platform,
-		exec: (file, args) => {
-			execFileSync(file, [...args], {
-				stdio: "pipe",
-				windowsHide: true
-			});
-		},
-		principal: currentPrincipal,
-		systemRoot: process.env["SystemRoot"],
-		...overrides
-	};
-}
-/** The icacls argv for one path: no inheritance, owner + SYSTEM only. */
-function icaclsArgs(target, principal, isDirectory) {
-	const inherit = isDirectory ? "(OI)(CI)" : "";
-	return [
-		target,
-		"/inheritance:r",
-		"/grant:r",
-		`${principal}:${inherit}F`,
-		"/grant:r",
-		`${WINDOWS_SYSTEM_SID}:${inherit}F`
-	];
-}
-function restrictWindows(target, isDirectory, deps) {
-	const icacls = path.win32.join(deps.systemRoot ?? "C:\\Windows", "System32", "icacls.exe");
-	try {
-		deps.exec(icacls, icaclsArgs(target, deps.principal(), isDirectory));
-	} catch (err) {
-		throw new OwnerOnlyError(target, err instanceof Error ? err.message : String(err));
-	}
-}
-/** Restrict an existing file to its owner (chmod 0600 / owner+SYSTEM ACL). */
-function restrictFileToOwnerSync(target, overrides = {}) {
-	const deps = resolveDeps(overrides);
-	if (deps.platform === "win32") {
-		restrictWindows(target, false, deps);
-		return;
-	}
-	fs.chmodSync(target, FILE_MODE);
-}
-/** Restrict an existing directory to its owner (chmod 0700 / owner+SYSTEM, inherited). */
-function restrictDirToOwnerSync(target, overrides = {}) {
-	const deps = resolveDeps(overrides);
-	if (deps.platform === "win32") {
-		restrictWindows(target, true, deps);
-		return;
-	}
-	fs.chmodSync(target, DIR_MODE);
-}
-/**
-* Atomically write a secret-bearing file that only its owner can read.
-*
-* Order matters: the temp file is created EMPTY, restricted, and only then
-* given its content, so there is no moment at which the secret exists under a
-* permissive ACL. The rename carries the (already restricted) ACL with it.
-*/
-function writeOwnerOnlyFileSync(target, data, overrides = {}) {
-	fs.mkdirSync(path.dirname(target), { recursive: true });
-	const tmp = `${target}.tmp.${process.pid}`;
-	fs.writeFileSync(tmp, "", { mode: FILE_MODE });
-	try {
-		restrictFileToOwnerSync(tmp, overrides);
-		fs.writeFileSync(tmp, data);
-		fs.renameSync(tmp, target);
-	} catch (err) {
-		fs.rmSync(tmp, { force: true });
-		throw err;
-	}
-}
-//#endregion
-//#region src/speak/secret-file.ts
-/**
-* Hand a refresh token or a saved Amazon session to the Python worker as an
-* owner-only file. The path travels on stdin. The bytes never travel on
-* argv or in the environment, and they are removed when the call settles.
-*/
-var REDACTED = "‹redacted›";
-function decodeSession(sessionB64) {
-	if (sessionB64.length === 0) return Buffer.alloc(0);
-	return Buffer.from(sessionB64, "base64");
-}
-async function readSessionB64(sessionPath) {
-	const bytes = await fs$1.readFile(sessionPath);
-	if (bytes.length === 0) return "";
-	return bytes.toString("base64");
-}
-/**
-* Create a 0700 directory, write the refresh token and the session 0600, run
-* `body`, then delete the directory whether `body` succeeded or threw.
-* Returns the session file as base64 so the caller can store it in the keychain.
-*/
-async function withSpeakSecretFiles(input, body) {
-	const dir = await fs$1.mkdtemp(path.join(os.tmpdir(), "camstack-alexa-"));
-	const paths = {
-		dir,
-		refreshTokenPath: path.join(dir, "refresh-token"),
-		sessionPath: path.join(dir, "session")
-	};
-	try {
-		restrictDirToOwnerSync(dir);
-		writeOwnerOnlyFileSync(paths.refreshTokenPath, input.refreshToken);
-		writeOwnerOnlyFileSync(paths.sessionPath, decodeSession(input.sessionB64));
-		await body(paths);
-		return { sessionB64: await readSessionB64(paths.sessionPath) };
-	} finally {
-		await fs$1.rm(dir, {
-			recursive: true,
-			force: true
-		});
-	}
-}
-/** Replace every occurrence of each non-empty secret. Used before a log line is emitted. */
-function scrubSecrets(text, secrets) {
-	let out = text;
-	for (const secret of secrets) {
-		if (secret.length === 0) continue;
-		out = out.split(secret).join(REDACTED);
-	}
-	return out;
-}
-//#endregion
-//#region src/speak/broker-echo.ts
-function withDevice(deviceId) {
-	return deviceId === void 0 ? {} : { deviceId };
-}
-var BrokerEcho = class {
-	deps;
-	currentState = "starting";
-	currentError = null;
-	currentDevices = [];
-	backoffMs = 0;
-	limitedUntil = 0;
-	channelState = "down";
-	channelWasUp = false;
-	secrets = [];
-	unknownPushLogged = /* @__PURE__ */ new Set();
-	constructor(deps) {
-		this.deps = deps;
-		deps.worker.onPush((push) => this.onPush(push));
-	}
-	/** Whether Amazon's push channel is open for this account right now. */
-	get pushChannel() {
-		return this.channelState;
-	}
-	/** A reason is text from the library: capped, then scrubbed of the secrets in play. */
-	safeReason(reason) {
-		return scrubSecrets(reason.slice(0, 200), this.secrets);
-	}
-	onPush(push) {
-		const tags = { tags: { brokerId: this.deps.brokerId } };
-		if (push.push === "channel") {
-			if (push.state === this.channelState) {
-				if (push.state === "down") this.deps.logger.debug("alexa echo: push channel still down", {
-					...tags,
-					meta: {
-						reason: this.safeReason(push.reason),
-						retryInMs: push.retryInMs
-					}
-				});
-				return;
-			}
-			this.channelState = push.state;
-			if (push.state === "up") {
-				this.deps.logger.info(this.channelWasUp ? "alexa echo: push channel reconnected, polling slows down" : "alexa echo: push channel connected, polling slows down", tags);
-				this.channelWasUp = true;
-			} else this.deps.logger.warn("alexa echo: push channel down, polling at the normal pace", {
-				...tags,
-				meta: {
-					reason: this.safeReason(push.reason),
-					retryInMs: push.retryInMs
-				}
-			});
-			this.deps.push?.channel(this.deps.brokerId, push.state);
-			return;
-		}
-		if (PUSH_READ_COMMANDS.has(push.command)) {
-			if (push.serial === null) {
-				this.deps.logger.debug("alexa echo: push event without an Echo, ignored", {
-					...tags,
-					meta: { command: push.command }
-				});
-				return;
-			}
-			this.deps.push?.event(this.deps.brokerId, push.serial);
-			return;
-		}
-		if (PUSH_IGNORED_COMMANDS.has(push.command)) return;
-		if (this.unknownPushLogged.has(push.command)) return;
-		this.unknownPushLogged.add(push.command);
-		this.deps.logger.info("alexa echo: unknown push event, ignored (logged once)", {
-			...tags,
-			meta: { command: push.command }
-		});
-	}
-	get id() {
-		return this.deps.brokerId;
-	}
-	get name() {
-		return this.deps.brokerName;
-	}
-	get state() {
-		return this.currentState;
-	}
-	get error() {
-		return this.currentError;
-	}
-	get devices() {
-		return this.currentDevices;
-	}
-	/** Ms epoch until which Amazon asked us to wait (429), or null when the account is free. */
-	get rateLimitedUntil() {
-		return this.limitedUntil > this.nowMs() ? this.limitedUntil : null;
-	}
-	nowMs() {
-		return (this.deps.now ?? Date.now)();
-	}
-	stop() {
-		this.deps.worker.stop();
-		if (this.channelState === "up") {
-			this.channelState = "down";
-			this.deps.push?.channel(this.deps.brokerId, "down");
-		}
-	}
-	/** Sign the worker in as the broker's account. Never throws; the outcome is `state`. */
-	async signIn() {
-		const { brokerId, worker, sessions, logger } = this.deps;
-		const tags = { tags: { brokerId } };
-		let secrets = [];
-		try {
-			const seed = await this.deps.readSeed();
-			const stored = await sessions.get(brokerId);
-			logger.info("alexa speak: broker sign-in material", {
-				...tags,
-				meta: {
-					seedFound: seed !== null,
-					hasRefreshToken: seed !== null && seed.refreshToken.length > 0,
-					hasDeviceAppName: seed !== null && seed.deviceAppName.length > 0,
-					hasStoredSession: stored.length > 0
-				}
-			});
-			if (seed === null && stored.length === 0) {
-				this.currentState = "broker-not-signed-in";
-				this.currentError = null;
-				logger.warn("alexa speak: the broker has no sign-in to share yet", tags);
-				return;
-			}
-			secrets = seed === null ? [] : [seed.refreshToken];
-			worker.noteSecrets(secrets);
-			this.secrets = secrets;
-			let outcome = parseLoginResult({
-				status: "failed",
-				error: "worker gave no answer"
-			});
-			const held = await withSpeakSecretFiles({
-				refreshToken: seed?.refreshToken ?? "",
-				sessionB64: stored
-			}, async (paths) => {
-				outcome = parseLoginResult(await worker.request({
-					op: "login_broker",
-					label: brokerId,
-					refreshTokenPath: seed === null ? "" : paths.refreshTokenPath,
-					deviceAppName: seed?.deviceAppName ?? "",
-					domain: this.deps.domain,
-					sessionPath: paths.sessionPath,
-					region: regionOfDomain(this.deps.domain)
-				}));
-			});
-			if (held.sessionB64.length > 0 && held.sessionB64 !== stored) await sessions.put(brokerId, held.sessionB64);
-			this.currentError = outcome.status === "ok" ? null : outcome.error ?? "sign-in failed";
-			this.currentState = outcome.status === "ok" ? "ready" : "failed";
-			if (outcome.status !== "ok") {
-				logger.warn("alexa speak: sign-in as the broker failed", {
-					...tags,
-					meta: { error: this.currentError }
-				});
-				return;
-			}
-			await this.refreshDevices();
-		} catch (err) {
-			this.currentState = "failed";
-			this.currentError = scrubSecrets(err instanceof Error ? err.message : String(err), secrets);
-			logger.warn("alexa speak: sign-in as the broker failed", {
-				...tags,
-				meta: { error: this.currentError }
-			});
-		}
-	}
-	/** A session that is not ready tries to sign in again before it gives up. */
-	async ensureReady() {
-		if (this.currentState !== "ready") await this.signIn();
-		return this.currentState === "ready";
-	}
-	async refreshDevices() {
-		if (this.currentState !== "ready") return;
-		try {
-			this.currentDevices = [...parseDevices(await this.deps.worker.request({ op: "devices" }))];
-		} catch (err) {
-			this.deps.logger.warn("alexa speak: step 3 of 3, device list failed after a good sign-in", {
-				tags: { brokerId: this.deps.brokerId },
-				meta: { error: err instanceof Error ? err.message : String(err) }
-			});
-		}
-	}
-	async utter(op, targets, text) {
-		if (!await this.ensureReady()) throw new Error(this.notReadyReason());
-		return parseDeliveries(await this.deps.worker.request({
-			op,
-			targets,
-			text
-		}));
-	}
-	/**
-	* Run one worker call. A 429 starts (or doubles) the account's back-off and is
-	* rethrown as is; any answer ends it. Rate limiting is a status, not a failure.
-	*/
-	async limited(call) {
-		try {
-			const result = await call();
-			this.backoffMs = 0;
-			this.limitedUntil = 0;
-			return result;
-		} catch (err) {
-			if (err instanceof RateLimitedError) {
-				this.backoffMs = this.backoffMs === 0 ? ECHO_RATE_BACKOFF_BASE_MS : Math.min(this.backoffMs * 2, ECHO_RATE_BACKOFF_MAX_MS);
-				this.limitedUntil = this.nowMs() + this.backoffMs;
-				this.deps.logger.info("alexa echo: amazon asked for a pause (429)", {
-					tags: { brokerId: this.deps.brokerId },
-					meta: { backoffMs: this.backoffMs }
-				});
-			}
-			throw err;
-		}
-	}
-	/** The raw player state of one Echo. Throws on any failure, a 429 included: never an empty answer. */
-	async playerState(serial, deviceType, deviceId) {
-		await this.requireReady();
-		return this.limited(async () => parsePlayerState(await this.deps.worker.request({
-			op: "player_state",
-			serial,
-			deviceType
-		}, withDevice(deviceId))));
-	}
-	async npCommand(serial, command, deviceId) {
-		await this.requireReady();
-		await this.limited(() => this.deps.worker.request({
-			op: "np_command",
-			serial,
-			command
-		}, withDevice(deviceId)));
-	}
-	async setVolume(serial, level, deviceId) {
-		await this.requireReady();
-		await this.limited(() => this.deps.worker.request({
-			op: "set_volume",
-			serial,
-			level
-		}, withDevice(deviceId)));
-	}
-	/** Do Not Disturb of every device of the account, by serial, in one call. */
-	async dndState() {
-		await this.requireReady();
-		return this.limited(async () => parseDndState(await this.deps.worker.request({ op: "dnd_state" })));
-	}
-	/** Speaker volume and mute of every device of the account, by serial, in one call. */
-	async deviceVolumes() {
-		await this.requireReady();
-		return this.limited(async () => parseDeviceVolumes(await this.deps.worker.request({ op: "device_volumes" })));
-	}
-	async setDnd(serial, enabled, deviceId) {
-		await this.requireReady();
-		await this.limited(() => this.deps.worker.request({
-			op: "set_dnd",
-			serial,
-			enabled
-		}, withDevice(deviceId)));
-	}
-	async requireReady() {
-		if (!await this.ensureReady()) throw new Error(this.notReadyReason());
-	}
-	async session() {
-		if (this.deps.worker.failed) return {
-			loggedIn: false,
-			ageSec: 0,
-			lastSuccessAt: null
-		};
-		try {
-			return parseSessionStatus(await this.deps.worker.request({ op: "session_status" }));
-		} catch {
-			return {
-				loggedIn: this.currentState === "ready",
-				ageSec: 0,
-				lastSuccessAt: null
-			};
-		}
-	}
-	notReadyReason() {
-		if (this.currentState === "broker-not-signed-in") return `account '${this.deps.brokerName}' is not signed in on its broker`;
-		return this.currentError ?? "alexa session is not ready";
-	}
-};
 //#endregion
 //#region src/speak/rate-limit.ts
 /**
@@ -145885,7 +145608,6 @@ function discoveredFrom(broker, device) {
 }
 function createAlexaNotificationProvider(ports) {
 	const logger = ports.logger ?? quietLogger$1();
-	let targets = ports.loadTargets();
 	let ledger = emptySpeechLedger();
 	let deliveries = [];
 	function record(row) {
@@ -145904,10 +145626,6 @@ function createAlexaNotificationProvider(ports) {
 		const owners = all.filter((broker) => broker.devices.some((device) => device.id === echoId));
 		return owners.length === 1 ? owners[0] : void 0;
 	}
-	function persist(next) {
-		targets = next;
-		ports.saveTargets(next);
-	}
 	async function deliver(target, notification) {
 		const speech = speechFromNotification(notification);
 		const echoId = readString(target.config, "echoId");
@@ -146109,10 +145827,10 @@ function createAlexaNotificationProvider(ports) {
 			return [alexaTargetKind()];
 		},
 		async listTargets() {
-			return [...targets];
+			return [...await ports.loadTargets()];
 		},
 		async getTarget(input) {
-			const found = targets.find((target) => target.id === input.targetId);
+			const found = (await ports.loadTargets()).find((target) => target.id === input.targetId);
 			if (found === void 0) throw new Error(`target not found: ${input.targetId}`);
 			return found;
 		},
@@ -146131,7 +145849,7 @@ function createAlexaNotificationProvider(ports) {
 					suggestedName: echoOptionLabel(device)
 				}));
 			}
-			const taken = new Set(targets.flatMap((row) => {
+			const taken = new Set((await ports.loadTargets()).flatMap((row) => {
 				const owner = brokerFor(row.config);
 				return owner === void 0 ? [] : [`${owner.id}/${readString(row.config, "echoId")}`];
 			}));
@@ -146149,7 +145867,7 @@ function createAlexaNotificationProvider(ports) {
 			};
 		},
 		async send(input) {
-			const target = targets.find((row) => row.id === input.targetId);
+			const target = (await ports.loadTargets()).find((row) => row.id === input.targetId);
 			if (target === void 0) return {
 				success: false,
 				error: `target not found: ${input.targetId}`
@@ -146161,7 +145879,7 @@ function createAlexaNotificationProvider(ports) {
 			return deliver(target, input.notification);
 		},
 		async testTarget(input) {
-			const found = targets.find((row) => row.id === input.targetId);
+			const found = (await ports.loadTargets()).find((row) => row.id === input.targetId);
 			if (found === void 0) return {
 				success: false,
 				error: `target not found: ${input.targetId}`
@@ -146191,20 +145909,554 @@ function createAlexaNotificationProvider(ports) {
 				addonId: ALEXA_SPEAK_ADDON_ID,
 				kind: ALEXA_SPEAK_KIND
 			};
-			persist([...targets.filter((row) => row.id !== target.id), target]);
+			await ports.putTarget(target);
 			return target;
 		},
 		async deleteTarget(input) {
-			persist(targets.filter((row) => row.id !== input.targetId));
+			await ports.removeTarget(input.targetId);
 		},
 		async setTargetEnabled(input) {
-			persist(targets.map((row) => row.id === input.targetId ? {
-				...row,
+			const found = (await ports.loadTargets()).find((row) => row.id === input.targetId);
+			if (found !== void 0) await ports.putTarget({
+				...found,
 				enabled: input.enabled
-			} : row));
+			});
+		}
+	};
+}
+//#endregion
+//#region src/speak/echo-store.ts
+/**
+* The Echo targets as records: one `notify-alexa-echo` record per target (an instance of the function
+* cap `notification-output`), the id the one a notification rule names. The records are the one source:
+* the controller reads them on every use and writes only the row it changes.
+*/
+var alexaNotifyRecordKinds = notificationTargetKinds([alexaTargetKind()]);
+function echoTargetStoreOver(records, options = {}) {
+	return NotificationTargetStore.of(records, ALEXA_SPEAK_ADDON_ID, alexaNotifyRecordKinds, [alexaTargetKind()], options);
+}
+/** The `echoTargets` setting as the legacy source: a row the migration left there is still served. */
+function legacyEchoTargetsOver(setting) {
+	return {
+		list: async () => readEchoTargets({ echoTargets: setting.readRows() }).map((row) => ({
+			id: row.id,
+			name: row.name,
+			kind: alexaTargetKind().kind,
+			enabled: row.enabled,
+			config: {
+				...row.brokerId.length > 0 ? { brokerId: row.brokerId } : {},
+				echoId: row.echoId,
+				respectDnd: row.respectDnd
+			}
+		})),
+		delete: async (id) => {
+			const rest = setting.readRows().filter((row) => {
+				const parsed = alexaEchoTargetSchema.safeParse(row);
+				return !(parsed.success && parsed.data.id === id);
+			});
+			if (rest.length !== setting.readRows().length) await setting.writeRows(rest);
+		}
+	};
+}
+/** The row a stored target is for the settings page: the account link is '' until one is chosen. */
+function echoRowOf(target) {
+	return {
+		id: target.id,
+		name: target.name,
+		enabled: target.enabled,
+		brokerId: typeof target.config["brokerId"] === "string" ? target.config["brokerId"] : "",
+		echoId: typeof target.config["echoId"] === "string" ? target.config["echoId"] : "",
+		respectDnd: target.config["respectDnd"] !== false
+	};
+}
+/** The migration's ports over the `notify-alexa-echo` record kind. */
+function echoRecordPortsOver(records, logger) {
+	const handle = echoTargetStoreOver(records).handlesByKind().get(alexaTargetKind().kind);
+	if (handle === void 0) throw new Error("import-alexa: the Echo target record kind is not declared");
+	return {
+		readEchoRecord: async (id) => (await handle.getResolved(id))?.data ?? null,
+		writeEchoRecord: async (id, body) => {
+			await handle.put({
+				id,
+				data: body
+			});
+		},
+		dropEchoRecord: async (id) => {
+			await handle.delete(id);
+		},
+		echoSkipped: (row) => {
+			logger.warn("Echo target left in the echoTargets setting; it keeps being served", { meta: {
+				targetId: row.id,
+				reason: row.reason
+			} });
 		}
 	};
 }
+/**
+* The Echo instance's test: the old probe (is the Amazon account of the target signed in on its
+* broker?) as the tri-state of `testInstance`. Speech not running yet answers `inconclusive` through
+* the same mapping (a failure with no HTTP status), never `unsupported`.
+*/
+function echoTargetProbe(speak) {
+	return async (input) => {
+		const source = speak();
+		if (source === null) return {
+			ok: false,
+			resolvedUrl: "alexa://session",
+			error: "Echo speech is not running"
+		};
+		return source.provider.probeTargetConfig({
+			kind: input.kind,
+			config: input.config
+		});
+	};
+}
+process.platform, process.env["SystemRoot"];
+/**
+* Files only their owner may read: the one place a secret-bearing file is
+* restricted, on every OS.
+*
+* `mode: 0o600` is a POSIX idea. On Windows Node maps it to the read-only
+* attribute and nothing else, and `chmod` is a no-op for permissions, so a
+* "0600" `agent.json` (the mesh private key) would have
+* been readable by every local user. Windows has its own tool for this:
+* `icacls`. This module removes the inherited ACL entries and grants access to
+* the current user and SYSTEM only — the Windows reading of "0600".
+*
+* ZERO imports beyond Node built-ins, on purpose: the Electron shell bundles
+* this single file (see `packages/desktop/tsup.config.ts`) instead of the
+* whole `@camstack/types` barrel.
+*
+* Failure is NOT swallowed. A secret file that could not be restricted is a
+* secret file the caller must know about, so `OwnerOnlyError` propagates; the
+* write order below makes sure nothing sensitive is in the file yet when that
+* happens (the temp file is empty until it has been restricted).
+*
+* Out of scope on purpose: files that are only tidy, not secret (the job
+* journal, the addon manifest) keep a plain `mode`, since one `icacls` per
+* write would be a process spawn on a hot path.
+*/
+/** `*S-1-5-18` is SYSTEM in every locale — a name like "SYSTEM" is not. */
+var WINDOWS_SYSTEM_SID = "*S-1-5-18";
+var FILE_MODE = 384;
+var DIR_MODE = 448;
+var OwnerOnlyError = class extends Error {
+	target;
+	constructor(target, detail) {
+		super(`could not restrict ${target} to its owner: ${detail}`);
+		this.target = target;
+		this.name = "OwnerOnlyError";
+	}
+};
+function currentPrincipal() {
+	const user = process.env["USERNAME"] ?? userInfo().username;
+	const domain = process.env["USERDOMAIN"];
+	return domain !== void 0 && domain.length > 0 ? `${domain}\\${user}` : user;
+}
+/** Resolved per call, not at import: a platform stubbed by a test must be seen. */
+function resolveDeps(overrides) {
+	return {
+		platform: process.platform,
+		exec: (file, args) => {
+			execFileSync(file, [...args], {
+				stdio: "pipe",
+				windowsHide: true
+			});
+		},
+		principal: currentPrincipal,
+		systemRoot: process.env["SystemRoot"],
+		...overrides
+	};
+}
+/** The icacls argv for one path: no inheritance, owner + SYSTEM only. */
+function icaclsArgs(target, principal, isDirectory) {
+	const inherit = isDirectory ? "(OI)(CI)" : "";
+	return [
+		target,
+		"/inheritance:r",
+		"/grant:r",
+		`${principal}:${inherit}F`,
+		"/grant:r",
+		`${WINDOWS_SYSTEM_SID}:${inherit}F`
+	];
+}
+function restrictWindows(target, isDirectory, deps) {
+	const icacls = path.win32.join(deps.systemRoot ?? "C:\\Windows", "System32", "icacls.exe");
+	try {
+		deps.exec(icacls, icaclsArgs(target, deps.principal(), isDirectory));
+	} catch (err) {
+		throw new OwnerOnlyError(target, err instanceof Error ? err.message : String(err));
+	}
+}
+/** Restrict an existing file to its owner (chmod 0600 / owner+SYSTEM ACL). */
+function restrictFileToOwnerSync(target, overrides = {}) {
+	const deps = resolveDeps(overrides);
+	if (deps.platform === "win32") {
+		restrictWindows(target, false, deps);
+		return;
+	}
+	fs.chmodSync(target, FILE_MODE);
+}
+/** Restrict an existing directory to its owner (chmod 0700 / owner+SYSTEM, inherited). */
+function restrictDirToOwnerSync(target, overrides = {}) {
+	const deps = resolveDeps(overrides);
+	if (deps.platform === "win32") {
+		restrictWindows(target, true, deps);
+		return;
+	}
+	fs.chmodSync(target, DIR_MODE);
+}
+/**
+* Atomically write a secret-bearing file that only its owner can read.
+*
+* Order matters: the temp file is created EMPTY, restricted, and only then
+* given its content, so there is no moment at which the secret exists under a
+* permissive ACL. The rename carries the (already restricted) ACL with it.
+*/
+function writeOwnerOnlyFileSync(target, data, overrides = {}) {
+	fs.mkdirSync(path.dirname(target), { recursive: true });
+	const tmp = `${target}.tmp.${process.pid}`;
+	fs.writeFileSync(tmp, "", { mode: FILE_MODE });
+	try {
+		restrictFileToOwnerSync(tmp, overrides);
+		fs.writeFileSync(tmp, data);
+		fs.renameSync(tmp, target);
+	} catch (err) {
+		fs.rmSync(tmp, { force: true });
+		throw err;
+	}
+}
+//#endregion
+//#region src/speak/secret-file.ts
+/**
+* Hand a refresh token or a saved Amazon session to the Python worker as an
+* owner-only file. The path travels on stdin. The bytes never travel on
+* argv or in the environment, and they are removed when the call settles.
+*/
+var REDACTED = "‹redacted›";
+function decodeSession(sessionB64) {
+	if (sessionB64.length === 0) return Buffer.alloc(0);
+	return Buffer.from(sessionB64, "base64");
+}
+async function readSessionB64(sessionPath) {
+	const bytes = await fs$1.readFile(sessionPath);
+	if (bytes.length === 0) return "";
+	return bytes.toString("base64");
+}
+/**
+* Create a 0700 directory, write the refresh token and the session 0600, run
+* `body`, then delete the directory whether `body` succeeded or threw.
+* Returns the session file as base64 so the caller can store it in the keychain.
+*/
+async function withSpeakSecretFiles(input, body) {
+	const dir = await fs$1.mkdtemp(path.join(os.tmpdir(), "camstack-alexa-"));
+	const paths = {
+		dir,
+		refreshTokenPath: path.join(dir, "refresh-token"),
+		sessionPath: path.join(dir, "session")
+	};
+	try {
+		restrictDirToOwnerSync(dir);
+		writeOwnerOnlyFileSync(paths.refreshTokenPath, input.refreshToken);
+		writeOwnerOnlyFileSync(paths.sessionPath, decodeSession(input.sessionB64));
+		await body(paths);
+		return { sessionB64: await readSessionB64(paths.sessionPath) };
+	} finally {
+		await fs$1.rm(dir, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+/** Replace every occurrence of each non-empty secret. Used before a log line is emitted. */
+function scrubSecrets(text, secrets) {
+	let out = text;
+	for (const secret of secrets) {
+		if (secret.length === 0) continue;
+		out = out.split(secret).join(REDACTED);
+	}
+	return out;
+}
+//#endregion
+//#region src/speak/broker-echo.ts
+function withDevice(deviceId) {
+	return deviceId === void 0 ? {} : { deviceId };
+}
+var BrokerEcho = class {
+	deps;
+	currentState = "starting";
+	currentError = null;
+	currentDevices = [];
+	backoffMs = 0;
+	limitedUntil = 0;
+	channelState = "down";
+	channelWasUp = false;
+	secrets = [];
+	unknownPushLogged = /* @__PURE__ */ new Set();
+	constructor(deps) {
+		this.deps = deps;
+		deps.worker.onPush((push) => this.onPush(push));
+	}
+	/** Whether Amazon's push channel is open for this account right now. */
+	get pushChannel() {
+		return this.channelState;
+	}
+	/** A reason is text from the library: capped, then scrubbed of the secrets in play. */
+	safeReason(reason) {
+		return scrubSecrets(reason.slice(0, 200), this.secrets);
+	}
+	onPush(push) {
+		const tags = { tags: { brokerId: this.deps.brokerId } };
+		if (push.push === "channel") {
+			if (push.state === this.channelState) {
+				if (push.state === "down") this.deps.logger.debug("alexa echo: push channel still down", {
+					...tags,
+					meta: {
+						reason: this.safeReason(push.reason),
+						retryInMs: push.retryInMs
+					}
+				});
+				return;
+			}
+			this.channelState = push.state;
+			if (push.state === "up") {
+				this.deps.logger.info(this.channelWasUp ? "alexa echo: push channel reconnected, polling slows down" : "alexa echo: push channel connected, polling slows down", tags);
+				this.channelWasUp = true;
+			} else this.deps.logger.warn("alexa echo: push channel down, polling at the normal pace", {
+				...tags,
+				meta: {
+					reason: this.safeReason(push.reason),
+					retryInMs: push.retryInMs
+				}
+			});
+			this.deps.push?.channel(this.deps.brokerId, push.state);
+			return;
+		}
+		if (PUSH_READ_COMMANDS.has(push.command)) {
+			if (push.serial === null) {
+				this.deps.logger.debug("alexa echo: push event without an Echo, ignored", {
+					...tags,
+					meta: { command: push.command }
+				});
+				return;
+			}
+			this.deps.push?.event(this.deps.brokerId, push.serial);
+			return;
+		}
+		if (PUSH_IGNORED_COMMANDS.has(push.command)) return;
+		if (this.unknownPushLogged.has(push.command)) return;
+		this.unknownPushLogged.add(push.command);
+		this.deps.logger.info("alexa echo: unknown push event, ignored (logged once)", {
+			...tags,
+			meta: { command: push.command }
+		});
+	}
+	get id() {
+		return this.deps.brokerId;
+	}
+	get name() {
+		return this.deps.brokerName;
+	}
+	get state() {
+		return this.currentState;
+	}
+	get error() {
+		return this.currentError;
+	}
+	get devices() {
+		return this.currentDevices;
+	}
+	/** Ms epoch until which Amazon asked us to wait (429), or null when the account is free. */
+	get rateLimitedUntil() {
+		return this.limitedUntil > this.nowMs() ? this.limitedUntil : null;
+	}
+	nowMs() {
+		return (this.deps.now ?? Date.now)();
+	}
+	stop() {
+		this.deps.worker.stop();
+		if (this.channelState === "up") {
+			this.channelState = "down";
+			this.deps.push?.channel(this.deps.brokerId, "down");
+		}
+	}
+	/** Sign the worker in as the broker's account. Never throws; the outcome is `state`. */
+	async signIn() {
+		const { brokerId, worker, sessions, logger } = this.deps;
+		const tags = { tags: { brokerId } };
+		let secrets = [];
+		try {
+			const seed = await this.deps.readSeed();
+			const stored = await sessions.get(brokerId);
+			logger.info("alexa speak: broker sign-in material", {
+				...tags,
+				meta: {
+					seedFound: seed !== null,
+					hasRefreshToken: seed !== null && seed.refreshToken.length > 0,
+					hasDeviceAppName: seed !== null && seed.deviceAppName.length > 0,
+					hasStoredSession: stored.length > 0
+				}
+			});
+			if (seed === null && stored.length === 0) {
+				this.currentState = "broker-not-signed-in";
+				this.currentError = null;
+				logger.warn("alexa speak: the broker has no sign-in to share yet", tags);
+				return;
+			}
+			secrets = seed === null ? [] : [seed.refreshToken];
+			worker.noteSecrets(secrets);
+			this.secrets = secrets;
+			let outcome = parseLoginResult({
+				status: "failed",
+				error: "worker gave no answer"
+			});
+			const held = await withSpeakSecretFiles({
+				refreshToken: seed?.refreshToken ?? "",
+				sessionB64: stored
+			}, async (paths) => {
+				outcome = parseLoginResult(await worker.request({
+					op: "login_broker",
+					label: brokerId,
+					refreshTokenPath: seed === null ? "" : paths.refreshTokenPath,
+					deviceAppName: seed?.deviceAppName ?? "",
+					domain: this.deps.domain,
+					sessionPath: paths.sessionPath,
+					region: regionOfDomain(this.deps.domain)
+				}));
+			});
+			if (held.sessionB64.length > 0 && held.sessionB64 !== stored) await sessions.put(brokerId, held.sessionB64);
+			this.currentError = outcome.status === "ok" ? null : outcome.error ?? "sign-in failed";
+			this.currentState = outcome.status === "ok" ? "ready" : "failed";
+			if (outcome.status !== "ok") {
+				logger.warn("alexa speak: sign-in as the broker failed", {
+					...tags,
+					meta: { error: this.currentError }
+				});
+				return;
+			}
+			await this.refreshDevices();
+		} catch (err) {
+			this.currentState = "failed";
+			this.currentError = scrubSecrets(err instanceof Error ? err.message : String(err), secrets);
+			logger.warn("alexa speak: sign-in as the broker failed", {
+				...tags,
+				meta: { error: this.currentError }
+			});
+		}
+	}
+	/** A session that is not ready tries to sign in again before it gives up. */
+	async ensureReady() {
+		if (this.currentState !== "ready") await this.signIn();
+		return this.currentState === "ready";
+	}
+	async refreshDevices() {
+		if (this.currentState !== "ready") return;
+		try {
+			this.currentDevices = [...parseDevices(await this.deps.worker.request({ op: "devices" }))];
+		} catch (err) {
+			this.deps.logger.warn("alexa speak: step 3 of 3, device list failed after a good sign-in", {
+				tags: { brokerId: this.deps.brokerId },
+				meta: { error: err instanceof Error ? err.message : String(err) }
+			});
+		}
+	}
+	async utter(op, targets, text) {
+		if (!await this.ensureReady()) throw new Error(this.notReadyReason());
+		return parseDeliveries(await this.deps.worker.request({
+			op,
+			targets,
+			text
+		}));
+	}
+	/**
+	* Run one worker call. A 429 starts (or doubles) the account's back-off and is
+	* rethrown as is; any answer ends it. Rate limiting is a status, not a failure.
+	*/
+	async limited(call) {
+		try {
+			const result = await call();
+			this.backoffMs = 0;
+			this.limitedUntil = 0;
+			return result;
+		} catch (err) {
+			if (err instanceof RateLimitedError) {
+				this.backoffMs = this.backoffMs === 0 ? ECHO_RATE_BACKOFF_BASE_MS : Math.min(this.backoffMs * 2, ECHO_RATE_BACKOFF_MAX_MS);
+				this.limitedUntil = this.nowMs() + this.backoffMs;
+				this.deps.logger.info("alexa echo: amazon asked for a pause (429)", {
+					tags: { brokerId: this.deps.brokerId },
+					meta: { backoffMs: this.backoffMs }
+				});
+			}
+			throw err;
+		}
+	}
+	/** The raw player state of one Echo. Throws on any failure, a 429 included: never an empty answer. */
+	async playerState(serial, deviceType, deviceId) {
+		await this.requireReady();
+		return this.limited(async () => parsePlayerState(await this.deps.worker.request({
+			op: "player_state",
+			serial,
+			deviceType
+		}, withDevice(deviceId))));
+	}
+	async npCommand(serial, command, deviceId) {
+		await this.requireReady();
+		await this.limited(() => this.deps.worker.request({
+			op: "np_command",
+			serial,
+			command
+		}, withDevice(deviceId)));
+	}
+	async setVolume(serial, level, deviceId) {
+		await this.requireReady();
+		await this.limited(() => this.deps.worker.request({
+			op: "set_volume",
+			serial,
+			level
+		}, withDevice(deviceId)));
+	}
+	/** Do Not Disturb of every device of the account, by serial, in one call. */
+	async dndState() {
+		await this.requireReady();
+		return this.limited(async () => parseDndState(await this.deps.worker.request({ op: "dnd_state" })));
+	}
+	/** Speaker volume and mute of every device of the account, by serial, in one call. */
+	async deviceVolumes() {
+		await this.requireReady();
+		return this.limited(async () => parseDeviceVolumes(await this.deps.worker.request({ op: "device_volumes" })));
+	}
+	async setDnd(serial, enabled, deviceId) {
+		await this.requireReady();
+		await this.limited(() => this.deps.worker.request({
+			op: "set_dnd",
+			serial,
+			enabled
+		}, withDevice(deviceId)));
+	}
+	async requireReady() {
+		if (!await this.ensureReady()) throw new Error(this.notReadyReason());
+	}
+	async session() {
+		if (this.deps.worker.failed) return {
+			loggedIn: false,
+			ageSec: 0,
+			lastSuccessAt: null
+		};
+		try {
+			return parseSessionStatus(await this.deps.worker.request({ op: "session_status" }));
+		} catch {
+			return {
+				loggedIn: this.currentState === "ready",
+				ageSec: 0,
+				lastSuccessAt: null
+			};
+		}
+	}
+	notReadyReason() {
+		if (this.currentState === "broker-not-signed-in") return `account '${this.deps.brokerName}' is not signed in on its broker`;
+		return this.currentError ?? "alexa session is not ready";
+	}
+};
 //#endregion
 //#region src/speak/python-paths.ts
 /** Locate bundled `python/alexa_worker.py` from dist/ or from src/ under test. */
@@ -146583,34 +146835,9 @@ function startAlexaWorker(deps) {
 }
 //#endregion
 //#region src/speak/controller.ts
-function targetsFrom(rows) {
-	return rows.map((row) => ({
-		id: row.id,
-		name: row.name,
-		kind: ALEXA_SPEAK_KIND,
-		addonId: ALEXA_SPEAK_ADDON_ID,
-		enabled: row.enabled,
-		config: {
-			...row.brokerId.length > 0 ? { brokerId: row.brokerId } : {},
-			echoId: row.echoId,
-			respectDnd: row.respectDnd
-		}
-	}));
-}
-function rowsFrom(targets) {
-	return targets.map((target) => ({
-		id: target.id,
-		name: target.name,
-		enabled: target.enabled,
-		brokerId: typeof target.config["brokerId"] === "string" ? target.config["brokerId"] : "",
-		echoId: typeof target.config["echoId"] === "string" ? target.config["echoId"] : "",
-		respectDnd: target.config["respectDnd"] !== false
-	}));
-}
 var AlexaSpeakController = class {
 	host;
 	provider;
-	rows;
 	pythonPath = null;
 	echoes = /* @__PURE__ */ new Map();
 	timer = null;
@@ -146619,16 +146846,13 @@ var AlexaSpeakController = class {
 	constructor(host) {
 		this.host = host;
 		this.now = host.now ?? (() => Date.now());
-		this.rows = readEchoTargets(host.readConfig());
 		this.provider = createAlexaNotificationProvider({
 			brokers: () => this.brokerViews(),
 			now: this.now,
 			logger: host.logger,
-			loadTargets: () => targetsFrom(this.rows),
-			saveTargets: (targets) => {
-				this.rows = rowsFrom(targets);
-				this.persist();
-			},
+			loadTargets: () => host.readTargets(),
+			putTarget: (target) => host.putTarget(target),
+			removeTarget: (targetId) => host.removeTarget(targetId),
 			speak: (command) => this.utter(command.brokerId, command.mode, command.targets, command.text)
 		});
 	}
@@ -146670,13 +146894,6 @@ var AlexaSpeakController = class {
 			};
 		});
 	}
-	async persist() {
-		try {
-			await this.host.writeTargets(this.rows);
-		} catch (err) {
-			this.host.logger.warn("alexa speak: could not store targets", { meta: { error: err instanceof Error ? err.message : String(err) } });
-		}
-	}
 	makeWorker(brokerId, pythonPath) {
 		if (this.host.startWorker !== void 0) return this.host.startWorker(brokerId, pythonPath);
 		return startAlexaWorker({
@@ -146878,6 +147095,80 @@ async function stripEchoTargetVolumeAndMode(ports) {
 	};
 }
 //#endregion
+//#region src/migrations/echo-targets-to-records.ts
+/**
+* The Echo notification targets move from the `echoTargets` setting (one array in the addon's global
+* settings) to one `notify-alexa-echo` record each, under the SAME id so a notification rule naming it
+* still resolves (epic #440, step 6). The switch (`enabled`) is carried across, never reset.
+*
+* Each record is read back before its row leaves the setting. One bad row never aborts the others: a row
+* whose write or read-back fails is undone, reported with its id and reason, and stays in the setting,
+* where the Echo store keeps serving it. A record that already exists is never overwritten (an operator
+* may have edited it since). A row that does not parse is left where it is and keeps the setting in
+* place: nothing is destroyed on a guess (D49).
+*/
+var ECHO_TARGETS_TO_RECORDS_ID = "import-alexa/2026-11-06-echo-targets-to-records";
+async function moveEchoTargetsToRecords(ports) {
+	const rows = ports.readRows();
+	if (rows.length === 0) return {
+		outcome: "already-done",
+		summary: { converted: 0 }
+	};
+	let converted = 0;
+	let kept = 0;
+	let unparsed = 0;
+	const left = [];
+	for (const row of rows) {
+		const parsed = alexaEchoTargetSchema.safeParse(row);
+		if (!parsed.success) {
+			unparsed += 1;
+			continue;
+		}
+		const target = parsed.data;
+		try {
+			if (await ports.readEchoRecord(target.id) !== null) {
+				kept += 1;
+				continue;
+			}
+			const body = targetBody({
+				id: target.id,
+				name: target.name,
+				enabled: target.enabled,
+				config: {
+					...target.brokerId.length > 0 ? { brokerId: target.brokerId } : {},
+					echoId: target.echoId,
+					respectDnd: target.respectDnd
+				}
+			});
+			await ports.writeEchoRecord(target.id, body);
+			const back = await ports.readEchoRecord(target.id);
+			if (!(back !== null && back["name"] === body["name"] && back["enabled"] === body["enabled"] && back["echoId"] === body["echoId"] && back["respectDnd"] === body["respectDnd"] && back["brokerId"] === body["brokerId"])) {
+				await ports.dropEchoRecord(target.id);
+				throw new Error("the new record did not read back");
+			}
+			converted += 1;
+		} catch (err) {
+			await ports.dropEchoRecord(target.id).catch(() => void 0);
+			ports.echoSkipped({
+				id: target.id,
+				reason: err instanceof Error ? err.message : String(err)
+			});
+			left.push(row);
+		}
+	}
+	if (unparsed === 0) await ports.writeRows(left);
+	return {
+		outcome: converted > 0 || kept > 0 ? "done" : "already-done",
+		summary: {
+			converted,
+			kept,
+			unparsed,
+			skipped: left.length,
+			kind: ALEXA_SPEAK_KIND
+		}
+	};
+}
+//#endregion
 //#region src/migrations/index.ts
 /** The `import-alexa` catalogue (D987): offered to the engine when the addon initialises. */
 var ADDON_MIGRATIONS = [
@@ -146944,6 +147235,22 @@ var ADDON_MIGRATIONS = [
 			fixtureMark: "the name and the extra field of the account that keeps its record"
 		},
 		procedure: moveBrokerLinksToConnections
+	},
+	{
+		meta: {
+			id: ECHO_TARGETS_TO_RECORDS_ID,
+			owner: "import-alexa",
+			level: "addon-state",
+			seq: 5,
+			dependsOn: ["import-alexa/2026-11-01-strip-echo-target-volume-and-mode"],
+			store: "settings",
+			scope: "cluster",
+			onFailure: "tolerate",
+			bodyKind: "procedure",
+			description: "Move each Echo target from the echoTargets setting to a notify-alexa-echo record under the same id, the switch carried, read back before its row leaves the setting; a row that fails stays in the setting and is still served; a record that exists is never overwritten",
+			fixtureMark: "the switch (off) and the id of an Echo target"
+		},
+		procedure: moveEchoTargetsToRecords
 	}
 ];
 /** The migrations that rewrite the broker records: they run BEFORE anything reads or persists one. */
@@ -147053,6 +147360,7 @@ var AlexaImportAddon = class extends BaseDeviceProvider {
 	accountInstances = null;
 	activeBrokers = [];
 	speak = null;
+	echoStore = null;
 	constructor() {
 		super({ ...DEFAULTS });
 	}
@@ -147060,7 +147368,10 @@ var AlexaImportAddon = class extends BaseDeviceProvider {
 		const regs = this.providerRegistrationsFromSuper(await super.onInitialize());
 		const records = this.ctx.records;
 		if (records === void 0) throw new Error("import-alexa: ctx.records is required (hub-only addon)");
-		await records.declare(alexaRecordKinds);
+		await records.declare({
+			...alexaRecordKinds,
+			...alexaNotifyRecordKinds
+		});
 		this.brokerStore = AlexaBrokerStore.of(records);
 		this.instances = buildAlexaInstances(records);
 		this.accountInstances = buildAlexaAccountInstances(records, {
@@ -147110,12 +147421,16 @@ var AlexaImportAddon = class extends BaseDeviceProvider {
 			commitCookie: (input) => this.commitCapturedCookie(input)
 		}), ...speakIconRoutes()];
 		await this.runMigrations(defineAddonMigrations(ADDON_MIGRATIONS, this.migrationPorts(records)), { only: ADDON_MIGRATIONS.map((m) => m.meta.id).filter((id) => !BROKER_RECORD_MIGRATION_IDS.includes(id)) });
+		const echoStore = echoTargetStoreOver(records, {
+			logger: this.ctx.logger,
+			legacy: legacyEchoTargetsOver(this.echoSettingPorts())
+		});
+		this.echoStore = echoStore;
 		const speak = new AlexaSpeakController({
 			logger: this.ctx.logger.child("speak"),
-			readConfig: () => this.config,
-			writeTargets: async (next) => {
-				await this.updateGlobalSettings({ echoTargets: [...next] });
-			},
+			readTargets: () => echoStore.list(),
+			putTarget: (target) => echoStore.upsert(target),
+			removeTarget: (targetId) => echoStore.delete(targetId),
 			listBrokers: () => this.activeBrokers.map((entry) => ({
 				id: entry.id,
 				name: entry.name,
@@ -147158,16 +147473,23 @@ var AlexaImportAddon = class extends BaseDeviceProvider {
 			}
 		] };
 	}
-	migrationPorts(records) {
-		const secrets = this.ctx.secrets;
-		if (secrets === void 0) throw new Error("import-alexa: ctx.secrets is required");
+	/** The `echoTargets` setting, read and written as the migration and the legacy store see it. */
+	echoSettingPorts() {
 		return {
 			readRows: () => Array.isArray(this.config.echoTargets) ? this.config.echoTargets : [],
 			writeRows: async (rows) => {
 				await this.updateGlobalSettings({ echoTargets: [...readEchoTargets({ echoTargets: rows })] });
-			},
+			}
+		};
+	}
+	migrationPorts(records) {
+		const secrets = this.ctx.secrets;
+		if (secrets === void 0) throw new Error("import-alexa: ctx.secrets is required");
+		return {
+			...this.echoSettingPorts(),
 			...flattenPortsOver(records.kind(alexaBrokersEntryKind)),
 			...alexaBrokerLinkPorts(records, (message) => this.ctx.logger.warn(message)),
+			...echoRecordPortsOver(records, this.ctx.logger),
 			...alexaIntegrationRowsPorts({
 				api: defaultIntegrationApiOver(this.ctx.api),
 				records,
@@ -147179,28 +147501,40 @@ var AlexaImportAddon = class extends BaseDeviceProvider {
 	/** One provider over the two record kinds: the account (broker) and the integrations using it. */
 	buildInstancesProvider() {
 		if (this.accountInstances === null) throw new Error("import-alexa: account instances not ready");
-		return composeInstanceKinds([{
-			kind: {
-				id: "account",
-				label: "Alexa account",
-				functionCap: "broker",
-				brokerKind: ALEXA_BROKER_KIND,
-				role: "services",
-				signIn: {
-					basePath: ALEXA_SIGN_IN_PATH,
-					methods: ["device-code", "proxy"]
-				}
+		const records = this.ctx.records;
+		if (records === void 0) throw new Error("import-alexa: ctx.records is required");
+		return composeInstanceKinds([
+			{
+				kind: {
+					id: "account",
+					label: "Alexa account",
+					functionCap: "broker",
+					brokerKind: ALEXA_BROKER_KIND,
+					role: "services",
+					signIn: {
+						basePath: ALEXA_SIGN_IN_PATH,
+						methods: ["device-code", "proxy"]
+					}
+				},
+				provider: guardInstanceDelete(this.accountInstances.toProvider(), () => this.brokerUsers())
 			},
-			provider: guardInstanceDelete(this.accountInstances.toProvider(), () => this.brokerUsers())
-		}, {
-			kind: {
-				id: "integration",
-				label: "Alexa",
-				functionCap: "device-provider",
-				role: "devices"
+			{
+				kind: {
+					id: "integration",
+					label: "Alexa",
+					functionCap: "device-provider",
+					role: "devices"
+				},
+				provider: this.requireInstances().toProvider()
 			},
-			provider: this.requireInstances().toProvider()
-		}], {
+			...notificationTargetParts(records, {
+				descriptors: [alexaTargetKind()],
+				kinds: alexaNotifyRecordKinds,
+				mintId: () => randomUUID(),
+				probe: echoTargetProbe(() => this.speak),
+				canProbe: () => true
+			})
+		], {
 			role: "devices",
 			instanceMode: "multiple",
 			kind: "account",
@@ -147491,7 +147825,7 @@ var AlexaImportAddon = class extends BaseDeviceProvider {
 	}
 	/** Who still points at an Alexa account: its integrations and the Echo targets that speak through it. */
 	brokerUsers() {
-		return [linkUserFinder(this.requireInstances(), "brokerId"), { find: async (brokerId) => readEchoTargets(this.config).filter((target) => target.brokerId === brokerId).map((target) => ({
+		return [linkUserFinder(this.requireInstances(), "brokerId"), { find: async (brokerId) => (this.echoStore === null ? [] : (await this.echoStore.list()).map(echoRowOf)).filter((target) => target.brokerId === brokerId).map((target) => ({
 			kind: "notification-target",
 			id: target.id,
 			name: target.name