@camstack/addon-export-alexa 1.2.144 → 1.2.146

package/dist/export-alexa.addon.mjs

@@ -5,7 +5,7 @@ import "node:fs";
 import "node:path";
 import "node:child_process";
 import "node:zlib";
-//#region ../types/dist/event-category-C4hVnRo8.mjs
+//#region ../types/dist/event-category-BvOFi6PY.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
 	EventCategory["SystemAddonsReady"] = "system.addons-ready";
@@ -69,6 +69,24 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	* consumes this category and maps it to the `addon-crash-loop` kind.
 	*/
 	EventCategory["AddonRunnerFailed"] = "addon.runner-failed";
+	/**
+	* A runner whose addon refused to start with a typed reason (D877) - parked
+	* in `refused`, never counted by the crash breaker, retried on operator
+	* action. One event per refusal.
+	*/
+	EventCategory["AddonRunnerRefused"] = "addon.runner-refused";
+	/**
+	* A runner settled on a state (D877): `running` (READY), `crashed`, `failed` or
+	* `refused`. In-process telemetry for the boot check (re-evaluate while any
+	* runner is still pending) and the alert centre (close a recovered runner).
+	*/
+	EventCategory["ProcessStateChanged"] = "process.state-changed";
+	/**
+	* The node's one-shot runner boot check (D877): planned runners against the
+	* process service, `degraded` when any is failed, refused or missing. The
+	* alert centre turns it into one alert and a direct critical push.
+	*/
+	EventCategory["SystemRunnerCheck"] = "system.runner-check";
 	EventCategory["AddonError"] = "addon.error";
 	EventCategory["AddonPageReady"] = "addon.page-ready";
 	EventCategory["AddonWidgetReady"] = "addon.widget-ready";
@@ -5393,7 +5411,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-DRqxtc0C.mjs
+//#region ../types/dist/sleep-bZIhUvjd.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -5510,7 +5528,7 @@ function isKeychainStoredField(field) {
 var SECRET_CLEAR = { $secretClear: true };
 /** The `'***'` token D634 redaction writes for non-admins. */
 var LEGACY_DEVICE_REDACTION = "***";
-function isRecord$2(value) {
+function isRecord$5(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function makeSecretMarker(ref) {
@@ -5521,12 +5539,12 @@ function makeSecretMarker(ref) {
 }
 /** A stored marker: an object whose `$secret` is a non-empty string. */
 function isSecretMarker(value) {
-	if (!isRecord$2(value)) return false;
+	if (!isRecord$5(value)) return false;
 	const ref = value["$secret"];
 	return typeof ref === "string" && ref.length > 0;
 }
 function isSecretClear(value) {
-	return isRecord$2(value) && value["$secretClear"] === true;
+	return isRecord$5(value) && value["$secretClear"] === true;
 }
 /**
 * The UI view of a stored secret field value: a marker becomes "set", inline
@@ -6136,7 +6154,7 @@ var KeychainWriteRefusedError = class extends Error {
 	}
 };
 var KEEP = { kind: "keep" };
-function isRecord$1(value) {
+function isRecord$4(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function defaultMintId() {
@@ -6149,7 +6167,7 @@ function collectSecretMarkerRefs(value, out = []) {
 		return out;
 	}
 	if (Array.isArray(value)) for (const item of value) collectSecretMarkerRefs(item, out);
-	else if (isRecord$1(value)) for (const child of Object.values(value)) collectSecretMarkerRefs(child, out);
+	else if (isRecord$4(value)) for (const child of Object.values(value)) collectSecretMarkerRefs(child, out);
 	return out;
 }
 async function storedValueEquals(secrets, marker, candidate) {
@@ -6204,7 +6222,7 @@ function rowId(row, idKey) {
 	return null;
 }
 async function writeArray(ctx, node, incoming, stored, fieldPath) {
-	const storedRows = Array.isArray(stored) ? stored.filter(isRecord$1) : [];
+	const storedRows = Array.isArray(stored) ? stored.filter(isRecord$4) : [];
 	if (!Array.isArray(incoming)) {
 		ctx.deletes.push(...collectSecretMarkerRefs(storedRows));
 		return {
@@ -6220,7 +6238,7 @@ async function writeArray(ctx, node, incoming, stored, fieldPath) {
 	const kept = /* @__PURE__ */ new Set();
 	const rows = [];
 	for (const row of incoming) {
-		if (!isRecord$1(row)) {
+		if (!isRecord$4(row)) {
 			rows.push(row);
 			continue;
 		}
@@ -6245,7 +6263,7 @@ async function writeNode(ctx, node, incoming, stored, fieldPath) {
 		case "leaf": return writeLeaf(ctx, incoming, stored, fieldPath);
 		case "array": return writeArray(ctx, node, incoming, stored, fieldPath);
 		case "object": {
-			if (!isRecord$1(incoming)) {
+			if (!isRecord$4(incoming)) {
 				if (incoming === void 0) return KEEP;
 				ctx.deletes.push(...collectSecretMarkerRefs(stored));
 				return {
@@ -6253,7 +6271,7 @@ async function writeNode(ctx, node, incoming, stored, fieldPath) {
 					value: incoming
 				};
 			}
-			const storedObj = isRecord$1(stored) ? stored : {};
+			const storedObj = isRecord$4(stored) ? stored : {};
 			return {
 				kind: "value",
 				value: await writeMembers(ctx, node.children, incoming, storedObj, (m) => `${fieldPath}.${m}`)
@@ -6376,7 +6394,7 @@ async function resolveSecretMarkers(value, secrets, options = {}) {
 				value: items
 			};
 		}
-		if (isRecord$1(v)) {
+		if (isRecord$4(v)) {
 			const out = {};
 			for (const [k, child] of Object.entries(v)) {
 				const s = substitute(child);
@@ -6644,7 +6662,6 @@ function createHandle(raw, opts) {
 	const writeAddon = (patch) => write("addon", opts.addonTree(), void 0, patch, () => readStoredAddonBlob(raw), (p) => raw.writeAddonStore(p));
 	const readAddonStoreResult = raw.readAddonStoreResult;
 	const readAddonStoreKeyResult = raw.readAddonStoreKeyResult;
-	const readDeviceStoreBatch = raw.readDeviceStoreBatch;
 	const overrides = {
 		readAddonStore: async () => resolveRead("addon", await raw.readAddonStore()),
 		...readAddonStoreResult !== void 0 ? { readAddonStoreResult: async () => {
@@ -6668,12 +6685,12 @@ function createHandle(raw, opts) {
 			};
 		} } : {},
 		readDeviceStore: async (deviceId) => resolveRead(`device:${deviceId}`, await raw.readDeviceStore(deviceId)),
-		...readDeviceStoreBatch !== void 0 ? { readDeviceStoreBatch: async (deviceIds) => {
-			const rows = await readDeviceStoreBatch.call(raw, deviceIds);
+		readDeviceStoreBatch: async (deviceIds) => {
+			const rows = await raw.readDeviceStoreBatch(deviceIds);
 			const out = /* @__PURE__ */ new Map();
 			for (const [deviceId, blob] of rows) out.set(deviceId, await resolveRead(`device:${deviceId}`, blob));
 			return out;
-		} } : {},
+		},
 		writeAddonStore: async (patch) => {
 			await writeAddon(patch);
 		},
@@ -7300,7 +7317,7 @@ var BaseAddon = class {
 		if (!ctx) return;
 		const addonId = ctx.id;
 		setImmediate(() => {
-			ctx.api.addons?.restartAddon?.mutate({ addonId }).then(() => {
+			ctx.api.addons.restartAddon.mutate({ addonId }).then(() => {
 				ctx.logger.info("addon auto-restart triggered by restart-required setting change", { meta: { changedFields: patchKeys.filter((k) => restartKeys.has(k)) } });
 			}).catch((err) => {
 				ctx.logger.error("addon auto-restart failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
@@ -7500,7 +7517,7 @@ var BaseAddon = class {
 		return this._addonSecretTree;
 	}
 	deviceSecretTree() {
-		this._deviceSecretTree ??= secretTreeFromSchema(this.deviceSettingsSchema());
+		this._deviceSecretTree ??= mergeSecretStatePaths(secretTreeFromSchema(this.deviceSettingsSchema()), this.secretStatePaths);
 		return this._deviceSecretTree;
 	}
 	/**
@@ -7576,42 +7593,135 @@ var BaseAddon = class {
 		this[timerOf] = timer;
 	}
 	/**
-	* Wrap `ctx.settings.readAddonStore()` with a short retry budget so a
-	* transient settings-store outage (mid-restart of sqlite-settings, tsx-watch
-	* swap, or any race where the SqliteSettingsBackend is between shutdown and
-	* re-initialize) doesn't propagate up into `initialize()` and leave the
+	* Wrap `ctx.settings.readAddonStore()` with a retry budget so a transient
+	* settings-store outage doesn't propagate up into `initialize()` and leave the
 	* addon permanently broken.
 	*
-	* Retry only the two known infra fingerprints. Anything else propagates so
-	* real bugs surface immediately. After the budget expires we fall back to
-	* `{}` (defaults) — the addon's first successful patch will rehydrate.
+	* Two kinds of outage, two budgets:
+	*  - the store's own restart fingerprints (`SqliteSettingsBackend not
+	*    initialized`, `provider not available`): a short budget, then the addon
+	*    falls back to `{}` (defaults) - its first successful patch rehydrates;
+	*  - a TRANSPORT failure (the hub is restarting while this runner boots:
+	*    `discovery deadline exceeded`, `parent could not route`, a refused or
+	*    timed-out connection). Since D870 a runner's settings read THROWS instead
+	*    of answering `{}`, so without a budget a hub restart ends in a respawn
+	*    loop. A long, bounded budget; only after it the error propagates - the
+	*    addon never runs on defaults for a store it could not ask.
+	* Anything else propagates immediately so real bugs surface.
 	*/
 	async readAddonStoreWithRetry() {
 		const settings = this.rawSettings();
 		if (!settings) return {};
-		const delaysMs = [
-			150,
-			350,
-			600,
-			900
-		];
 		let lastErr;
-		for (let attempt = 0; attempt <= delaysMs.length; attempt++) try {
+		for (let attempt = 0;; attempt++) try {
 			const stored = await settings.readAddonStore() ?? {};
 			this.settingsStoreReady = true;
 			return stored;
 		} catch (err) {
 			lastErr = err;
-			const msg = err instanceof Error ? err.message : String(err);
-			if (!(msg.includes("SqliteSettingsBackend not initialized") || msg.includes("provider not available"))) throw err;
-			if (attempt === delaysMs.length) break;
-			await new Promise((r) => setTimeout(r, delaysMs[attempt]));
+			const kind = classifyStoreError(err);
+			if (kind === "permanent") throw err;
+			const delay = (kind === "transport" ? TRANSPORT_RETRY_DELAYS_MS : RESTART_RETRY_DELAYS_MS)[attempt];
+			if (delay === void 0) {
+				if (kind === "transport") throw err;
+				break;
+			}
+			await new Promise((r) => setTimeout(r, delay));
 		}
 		this.settingsStoreReady = false;
 		this._ctx?.logger?.warn?.("readAddonStore: settings-store unavailable after retries — using defaults", { meta: { error: lastErr instanceof Error ? lastErr.message : String(lastErr) } });
 		return {};
 	}
 };
+/** The settings store's own restart fingerprints. */
+var RESTART_RETRY_DELAYS_MS = [
+	150,
+	350,
+	600,
+	900
+];
+/** A hub restarting under a booting runner: ~100 s in total. */
+var TRANSPORT_RETRY_DELAYS_MS = [
+	150,
+	350,
+	600,
+	900,
+	2e3,
+	5e3,
+	1e4,
+	2e4,
+	3e4,
+	3e4
+];
+var RESTART_FINGERPRINTS = ["SqliteSettingsBackend not initialized", "provider not available"];
+/** Node / socket error codes of a connection that did not happen or broke. */
+var TRANSPORT_CODES = new Set([
+	"ECONNREFUSED",
+	"ECONNRESET",
+	"ETIMEDOUT",
+	"EPIPE",
+	"EHOSTUNREACH",
+	"ENETUNREACH"
+]);
+/** tRPC error codes that mean "the other side is not answering now", not "your call is wrong". */
+var UNAVAILABLE_TRPC_CODES = new Set([
+	"TIMEOUT",
+	"SERVICE_UNAVAILABLE",
+	"BAD_GATEWAY",
+	"GATEWAY_TIMEOUT"
+]);
+/** The exact phrases OUR transport raises when it cannot reach the hub. */
+var TRANSPORT_PHRASES = [
+	"discovery deadline exceeded",
+	"parent could not route child unowned cap call",
+	"UDS request timed out after",
+	"channel closed"
+];
+/** Moleculer error `type`s of a call that could not be served right now. */
+var MOLECULER_TRANSIENT_TYPES = new Set([
+	"REQUEST_TIMEOUT",
+	"SERVICE_NOT_FOUND",
+	"SERVICE_NOT_AVAILABLE",
+	"REQUEST_REJECTED",
+	"BROKER_DISCONNECTED"
+]);
+function stringProp(value, key) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const found = Reflect.get(value, key);
+	return typeof found === "string" ? found : void 0;
+}
+/** The code an error carries: its own, its cause's, or a tRPC `data.code`. */
+function errorCode(err) {
+	const out = {};
+	const cause = typeof err === "object" && err !== null ? Reflect.get(err, "cause") : void 0;
+	const data = typeof err === "object" && err !== null ? Reflect.get(err, "data") : void 0;
+	const node = stringProp(err, "code") ?? stringProp(cause, "code");
+	if (node !== void 0) out.node = node;
+	const trpc = stringProp(data, "code");
+	if (trpc !== void 0) out.trpc = trpc;
+	return out;
+}
+/**
+* Is a settings read failure worth retrying, and with which budget? Only
+* EXPLICIT signals count: a socket error code, a tRPC "unavailable" code, or
+* one of the exact phrases our own transport raises. A message that merely
+* contains "timed out" or "unreachable" is not evidence of anything, and
+* `settings store not wired` is a wiring bug that retrying cannot fix.
+*/
+function classifyStoreError(err) {
+	const message = err instanceof Error ? err.message : String(err);
+	if (RESTART_FINGERPRINTS.some((f) => message.includes(f))) return "restart";
+	const code = errorCode(err);
+	if (code.node !== void 0 && TRANSPORT_CODES.has(code.node)) return "transport";
+	if (code.trpc !== void 0 && UNAVAILABLE_TRPC_CODES.has(code.trpc)) return "transport";
+	if (typeof err === "object" && err !== null) {
+		if (Reflect.get(err, "retryable") === true) return "transport";
+		const type = stringProp(err, "type");
+		if (type !== void 0 && MOLECULER_TRANSIENT_TYPES.has(type)) return "transport";
+	}
+	if (TRANSPORT_PHRASES.some((f) => message.includes(f))) return "transport";
+	return "permanent";
+}
 /**
 * Collect the keys of every field marked `perNode: true`, recursing into
 * layout containers (`group` fields and `sub-tabs` tabs) the same way
@@ -7701,6 +7811,89 @@ var PeerBytesTicketSchema = object({
 	*/
 	declaredBytes: number().int().nonnegative().nullable()
 });
+/** Limits and names of `ctx.records` (D881). One authority; the engine and the facade read it. */
+/** The files a kind may live in. `history` is device-history's (D850), never records. */
+var RECORD_DATABASES = ["settings", "events"];
+/** The classes of a kind: the `@durable` vocabulary, one authority (replaces the annotation). */
+var RECORD_CLASSES = [
+	"config",
+	"ledger",
+	"audit",
+	"mirror",
+	"ephemeral"
+];
+var RECORD_DEFAULT_MAX_DATA_BYTES = 64 * 1024;
+var RECORD_MAX_DATA_BYTES = 1024 * 1024;
+var RECORD_BATCH_MAX = 1e3;
+var RECORD_QUERY_MAX = 1e3;
+/**
+* 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().int().positive(),
+		from: _enum(["at", "write"])
+	}).strict(),
+	object({
+		maxRows: number().int().positive().optional(),
+		maxRowsPerDevice: number().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 and sits in the engine's catalog: JSON only, no Zod. */
+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().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({}),
+	/** The legacy table this kind adopts from; the boot guard reads it (D853: no migration code). */
+	adoptsFrom: string().min(1).optional(),
+	/** 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}$/);
 /** Shared Zod schemas used across streaming capabilities. */
 var CamProfileSchema = _enum([
 	"high",
@@ -8188,7 +8381,7 @@ object({
 	params: record(string(), union([string(), number()])).optional()
 });
 //#endregion
-//#region ../types/dist/err-msg-DLerKiVO.mjs
+//#region ../types/dist/err-msg--2RrYiLO.mjs
 var DeviceType = /* @__PURE__ */ function(DeviceType) {
 	DeviceType["Camera"] = "camera";
 	DeviceType["Hub"] = "hub";
@@ -8457,6 +8650,9 @@ var DeviceRole = /* @__PURE__ */ function(DeviceRole) {
 	/** Virtual HA toggle (input_boolean.*) — distinguishable from a
 	*  real Switch device for UI rendering / export adapters. */
 	DeviceRole["BinaryHelper"] = "binary-helper";
+	/** A smart plug: a `switch` whose source says it is an outlet (HA
+	*  `device_class: outlet`). The Alexa export shows it as a SMARTPLUG. */
+	DeviceRole["Outlet"] = "outlet";
 	/** Generic motion / occupancy / moving event source. Distinct from
 	*  the camera accessory PirSensor role: that one is a camera child;
 	*  this is a standalone HA / 3rd-party motion sensor. */
@@ -8534,7 +8730,7 @@ function errMsg(err) {
 	return String(err);
 }
 //#endregion
-//#region ../types/dist/composition-EQ9Ok0Ee.mjs
+//#region ../types/dist/composition-DOwQB_Ua.mjs
 /**
 * The ffmpeg build every CamStack node downloads, per platform and arch.
 *
@@ -11995,11 +12191,10 @@ var ClipModelMetaSchema = object({
 	/**
 	* The `vector-store` index this model's vectors live in. ONE feature space
 	* per index: two models share an index only when their vectors are ranked
-	* against each other, which for CLIP means never across families. MobileCLIP
-	* S1 and S2 share `object-clip` for history (separated by the row's
-	* `modelId`); any other model gets its own.
+	* against each other, which for CLIP means never across families. Every
+	* model gets its own.
 	*/
-	vectorIndex: string().regex(/^object-clip(-[a-z0-9][a-z0-9-]*)?$/),
+	vectorIndex: string().regex(/^object-clip-[a-z0-9][a-z0-9-]*$/),
 	/**
 	* The text encoder's tokenizer, a declared SIBLING file of its onnx. The name
 	* must be unique per tokenizer: every model's siblings land in ONE flat
@@ -15652,6 +15847,41 @@ var ComposableCapabilitiesSchema = object({ caps: array(object({
 		keyField: string()
 	}).optional()
 })) });
+/**
+* The report of a one-shot "move this owner's plaintext secrets into the
+* keychain" run (D878). COUNTS only - never a value, never a ref.
+*
+* The owner runs it on its own rows, through its own write path; an operator
+* script (`scripts/hub/migrate-raw-secrets.ts`) calls the owner's cap method.
+* Dry run (`apply: false`) reports what WOULD move and changes nothing.
+*/
+var RawSecretMigrationInputSchema = object({ 
+/** `false` (the default of the script) = report only. */
+apply: boolean() });
+var RawSecretMigrationReportSchema = object({
+	apply: boolean(),
+	/** Rows that can carry a secret (a profile, an enrolment). */
+	rows: number().int(),
+	/** Rows whose secret was plaintext when the run started. */
+	raw: number().int(),
+	/** Rows that already held a keychain marker when the run started. */
+	markers: number().int(),
+	/** Plaintext rows moved by THIS run (always 0 on a dry run). */
+	migrated: number().int(),
+	/** Plaintext rows left in place because the move or its read-back failed. */
+	failed: number().int(),
+	/** After the run: rows still holding plaintext. */
+	remainingRaw: number().int(),
+	/** After the run: markers the keychain could not resolve right now. */
+	unresolvedMarkers: number().int(),
+	/**
+	* A second, redundant copy of the secrets' rows that the run found (and, on
+	* `apply`, deleted after verifying the first). Owners with a single copy omit it.
+	*/
+	redundantCopies: number().int().optional(),
+	/** True when nothing is raw and every marker resolves. */
+	verified: boolean()
+});
 /** Where a block runs. The operator chooses — a block driving a device on an
 *  agent is the reason placement is not fixed to the hub. */
 var CoreBlockPlacementSchema = union([literal("hub"), string().min(1)]);
@@ -15878,6 +16108,9 @@ method(object({}), object({ blocks: array(CoreBlockSchema) }), { auth: "admin" }
 }), SettingsUpdateResultSchema, {
 	kind: "mutation",
 	auth: "admin"
+}), method(RawSecretMigrationInputSchema, RawSecretMigrationReportSchema, {
+	kind: "mutation",
+	auth: "admin"
 }), method(object({}), object({ libs: array(object({
 	filePath: string(),
 	content: string()
@@ -16141,6 +16374,347 @@ id: union([string(), number()]) }), {
 	auth: "admin"
 });
 /**
+* records - an addon's own facts and documents (D881): ledgers, audit rows,
+* config documents, mirrors. The third storage API next to `ctx.settings`
+* (operator intent, D870) and device-history (numbers over time, D850).
+*
+* Who the OWNER is: `callerAddonId`, stamped by the transport on a call that
+* crossed a process and stated by a hub in-process caller (`ctx.records` does
+* that with the addon id closed over). It is deliberately NOT in any input
+* schema, so a session can never supply it, and a call with no stamp is refused
+* `records/no-caller`. A kind is readable and writable only by its owner; other
+* addons go through the owner's capability.
+*
+* Every read is three-way: a row, `null`, or the call THROWS. A failed read is
+* never `[]`. Secret fields are never on the wire: a read shows the
+* redaction token, `secretRefs` hands the owner's `ctx.secrets` the refs it
+* resolves itself, and a write may carry only a keychain marker bound to the
+* row's own ref.
+*
+* Internal: addons reach it through `ctx.records`, never directly.
+*/
+var RecordIdSchema = string().min(1).max(256);
+/** A JSON object body. Size is the engine's check (`maxDataBytes`), not a schema's. */
+var RecordBodySchema = record(string(), unknown());
+var RecordInputSchema = object({
+	id: RecordIdSchema,
+	/** The device this row belongs to (D865 removal, per-device reads). */
+	deviceId: number().int().optional(),
+	/** The domain clock, ms: observed / created / opened. */
+	at: number().int().optional(),
+	/** Producer-set expiry, ms. Refused on a kind whose retention is an engine TTL. */
+	expiresAt: number().int().optional(),
+	data: RecordBodySchema
+});
+var RecordViewSchema = object({
+	id: string(),
+	deviceId: number().int().nullable(),
+	at: number().nullable(),
+	expiresAt: number().nullable(),
+	rev: number().int(),
+	updatedAt: number(),
+	data: RecordBodySchema
+});
+/** Declared index fields only. Anything else does not compile, by design. */
+var RecordWhereSchema = record(RecordFieldPathSchema, union([
+	string(),
+	number(),
+	boolean(),
+	object({ in: array(union([
+		string(),
+		number(),
+		boolean()
+	])).min(1).max(RECORD_BATCH_MAX) }),
+	object({
+		gt: union([string(), number()]).optional(),
+		gte: union([string(), number()]).optional(),
+		lt: union([string(), number()]).optional(),
+		lte: union([string(), number()]).optional()
+	}).refine((r) => Object.keys(r).length > 0, { message: "name at least one bound" })
+]));
+var KindShape = { kind: RecordKindNameSchema };
+var TimeWindowShape = {
+	deviceId: number().int().optional(),
+	atFrom: number().optional(),
+	atTo: number().optional()
+};
+var RecordQueryInputSchema = object({
+	...KindShape,
+	...TimeWindowShape,
+	where: RecordWhereSchema.optional(),
+	/** Without `where`: `at` (default for a kind with a clock) or `id`. With `where` the order is the index's. */
+	order: _enum(["at", "id"]).optional(),
+	desc: boolean().optional(),
+	limit: number().int().min(1).max(RECORD_QUERY_MAX).default(100),
+	/** Opaque keyset cursor from a previous answer. There is no offset. */
+	cursor: string().min(1).optional()
+});
+var RecordQueryResultSchema = object({
+	records: array(RecordViewSchema),
+	nextCursor: string().nullable()
+});
+var RecordKindStateSchema = _enum([
+	"created",
+	"unchanged",
+	"updated"
+]);
+var DeclareKindResultSchema = object({
+	kindId: number().int(),
+	state: RecordKindStateSchema,
+	createdIndexes: array(string()),
+	/** The boot guard: the kind is empty while its legacy table still holds rows. */
+	adoptionPending: object({
+		legacyTable: string(),
+		legacyRows: number().int()
+	}).nullable()
+});
+/** Keychain refs a write released (the old marker is gone from the row): the owner deletes the values. */
+var SecretRefsList = array(string());
+var RecordSecretRefsSchema = record(string(), record(string(), string()));
+method(object({ kinds: record(RecordKindNameSchema, RecordKindDeclarationSchema) }), object({ kinds: record(string(), DeclareKindResultSchema) }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	...KindShape,
+	id: RecordIdSchema
+}), RecordViewSchema.nullable(), { auth: "admin" }), method(object({
+	...KindShape,
+	ids: array(RecordIdSchema).min(1).max(RECORD_BATCH_MAX)
+}), array(RecordViewSchema), { auth: "admin" }), method(object({
+	...KindShape,
+	ids: array(RecordIdSchema).min(1).max(RECORD_BATCH_MAX)
+}), RecordSecretRefsSchema, { auth: "admin" }), method(object({
+	...KindShape,
+	record: RecordInputSchema,
+	/** Compare-and-set. `0` means "the row must not exist". */
+	ifRev: number().int().min(0).optional()
+}), object({
+	rev: number().int(),
+	releasedRefs: SecretRefsList
+}), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	...KindShape,
+	records: array(RecordInputSchema).min(1).max(RECORD_BATCH_MAX)
+}), object({
+	count: number().int(),
+	releasedRefs: SecretRefsList
+}), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	...KindShape,
+	id: RecordIdSchema,
+	data: RecordBodySchema,
+	at: number().int().nullable().optional(),
+	expiresAt: number().int().nullable().optional(),
+	ifRev: number().int().min(1).optional()
+}), object({
+	rev: number().int(),
+	releasedRefs: SecretRefsList
+}), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	...KindShape,
+	id: RecordIdSchema
+}), object({
+	deleted: boolean(),
+	secretRefs: SecretRefsList
+}), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	...KindShape,
+	ids: array(RecordIdSchema).min(1).max(RECORD_BATCH_MAX)
+}), object({
+	deleted: number().int(),
+	secretRefs: SecretRefsList
+}), {
+	kind: "mutation",
+	auth: "admin"
+}), method(RecordQueryInputSchema, RecordQueryResultSchema, { auth: "admin" }), method(object({
+	...KindShape,
+	...TimeWindowShape,
+	where: RecordWhereSchema.optional()
+}), object({ count: number().int() }), { auth: "admin" }), method(object({
+	...KindShape,
+	deviceId: number().int().optional(),
+	from: number(),
+	to: number(),
+	bucketMs: number().int().positive()
+}), object({ buckets: array(object({
+	bucketStart: number(),
+	count: number().int()
+})) }), { auth: "admin" }), method(object({
+	...KindShape,
+	op: _enum([
+		"sum",
+		"min",
+		"max",
+		"count"
+	]),
+	field: RecordFieldPathSchema.optional(),
+	groupBy: RecordFieldPathSchema.optional(),
+	where: RecordWhereSchema.optional()
+}), object({ rows: array(object({
+	group: union([
+		string(),
+		number(),
+		_null()
+	]),
+	value: number().nullable()
+})) }), { auth: "admin" }), method(object({
+	...KindShape,
+	deviceId: number().int().optional(),
+	atBefore: number().optional(),
+	where: RecordWhereSchema.optional()
+}), object({
+	deleted: number().int(),
+	secretRefs: SecretRefsList
+}), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	deviceId: number().int(),
+	kinds: array(RecordKindNameSchema).optional()
+}), object({
+	deleted: record(string(), number().int()),
+	secretRefs: SecretRefsList
+}), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object(KindShape), object({ id: number().int() }), {
+	kind: "mutation",
+	auth: "admin"
+});
+/** One table of the settings database. */
+var StorageTableSchema = object({
+	/** The table's full name, e.g. `recorder:addon-settings` or `addon-device-settings`. */
+	name: string(),
+	/** The owner prefix of a scoped name (`recorder` for `recorder:addon-settings`), else null. */
+	owner: string().nullable(),
+	rows: number().int().nonnegative(),
+	/** Bytes the table's pages occupy (`dbstat`); null when the engine cannot measure. */
+	bytes: number().int().nonnegative().nullable(),
+	/** Declared by an addon since this engine process started (a running addon claims it). */
+	declaredThisBoot: boolean()
+});
+/** One declared record kind (D881) as System -> Data shows it. */
+var StorageKindSchema = object({
+	owner: string(),
+	kind: string(),
+	database: _enum(["settings", "events"]),
+	class: string(),
+	state: _enum([
+		"declared",
+		"orphaned",
+		"dropped"
+	]),
+	/** `null` when the caller asked for no counts (`counts: false`). */
+	rows: number().int().nonnegative().nullable(),
+	/** Rows x the average size of a sample; null for an empty kind. */
+	bytesEstimate: number().int().nonnegative().nullable(),
+	writeTrigger: string(),
+	retention: RecordRetentionSchema,
+	/** `true` when the kind is an entry kind (the generic entries UI lists it). */
+	entry: boolean(),
+	/** The whole declaration, secret paths and entry descriptor included (the entries service builds its handle from it). */
+	declaration: RecordKindDeclarationSchema
+});
+method(object({ ownerPrefix: string().min(1).optional() }), object({ tables: array(StorageTableSchema) }), { auth: "admin" }), method(object({
+	collection: string().min(1),
+	expectRows: number().int().nonnegative()
+}), object({
+	dropped: literal(true),
+	rows: number().int().nonnegative()
+}), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	owner: string().min(1).optional(),
+	/** `false` skips the per-kind row count (a catalog read only). Default true. */
+	counts: boolean().optional()
+}), object({ kinds: array(StorageKindSchema) }), { auth: "admin" }), method(RecordQueryInputSchema.extend({
+	owner: string().min(1),
+	kind: RecordKindNameSchema
+}), RecordQueryResultSchema, { auth: "admin" }), method(object({
+	owner: string().min(1),
+	kind: RecordKindNameSchema,
+	records: array(RecordInputSchema).max(RECORD_BATCH_MAX),
+	/** The LAST batch: the copy is complete, the boot guard stops asking. */
+	complete: boolean().optional()
+}).refine((input) => input.records.length > 0 || input.complete === true, { message: "records must be non-empty unless complete is true" }), object({ adopted: number().int() }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	collection: string().min(1),
+	cursor: string().optional(),
+	limit: number().int().min(1).max(1e3).optional()
+}), object({
+	rows: array(object({
+		id: string(),
+		data: record(string(), unknown())
+	})),
+	nextCursor: string().nullable()
+}), { auth: "admin" }), method(object({ collection: string().min(1) }), object({ adopted: boolean() }), { auth: "admin" });
+/**
+* record-entries - the ONE admin surface for every list of user-created entries
+* (D881): notification targets, brokers, LLM profiles, anything an addon
+* declares as an ENTRY kind (`entry: { title }` in `defineRecordKinds`).
+*
+* The UI is generic. `listEntryKinds` hands it, per kind, the JSON Schema of
+* the entry body with `secret: true` on every credential field, so a password
+* field is derived from the schema and never from a name. `putEntry` takes the
+* redaction token for an untouched secret (the stored value is kept), a string
+* for a new one, and the clear instruction to remove one. A read never carries
+* a secret value, and a locked keychain refuses the write with
+* `records/secret-unavailable` instead of storing plaintext.
+*
+* Hub-only, served in-process (it acts for each entry's owner on the keychain).
+*/
+var EntryKindInfoSchema = object({
+	owner: string(),
+	kind: RecordKindNameSchema,
+	title: string(),
+	nameField: string(),
+	/** JSON Schema of the body; `secret: true` marks a password field. */
+	fields: record(string(), unknown()),
+	secretPaths: array(string()),
+	rows: number().int().nonnegative()
+});
+var EntryViewSchema = object({
+	id: RecordIdSchema,
+	name: string(),
+	rev: number().int(),
+	updatedAt: number(),
+	/** Secret fields hold the redaction token. */
+	data: RecordBodySchema
+});
+var EntryAddress = {
+	owner: string().min(1),
+	kind: RecordKindNameSchema
+};
+method(object({}), object({ kinds: array(EntryKindInfoSchema) }), { auth: "admin" }), method(object({ ...EntryAddress }), object({ entries: array(EntryViewSchema) }), { auth: "admin" }), method(object({
+	...EntryAddress,
+	id: RecordIdSchema.optional(),
+	data: RecordBodySchema,
+	ifRev: number().int().min(1).optional()
+}), object({
+	id: string(),
+	rev: number().int()
+}), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	...EntryAddress,
+	id: RecordIdSchema
+}), object({ deleted: boolean() }), {
+	kind: "mutation",
+	auth: "admin"
+});
+/**
 * `keychain` — the hub's encrypted store of secret values (D787).
 *
 * Settings blobs never hold a secret: they hold a marker
@@ -16681,6 +17255,16 @@ method(object({}), KeychainStatusSchema, { auth: "admin" }), method(object({}),
 	kind: "mutation",
 	auth: "admin",
 	caller: "required"
+}), method(object({
+	ref: string().min(1),
+	value: string().min(1)
+}), object({
+	ref: string(),
+	version: number().int()
+}), {
+	kind: "mutation",
+	auth: "admin",
+	caller: "required"
 }), method(object({ refs: array(string().min(1)).max(1e3) }), object({
 	deleted: array(string()).readonly(),
 	kept: array(object({
@@ -39175,6 +39759,9 @@ method(LlmGenerateBaseInputSchema, LlmGenerateResultSchema, {
 }), _void(), { kind: "mutation" }), method(object({}), array(LlmProfileKindDescriptorSchema)), method(object({}), array(LlmProfileSchema)), method(object({ profile: LlmProfileSchema }), LlmProfileSchema, {
 	kind: "mutation",
 	auth: "admin"
+}), method(RawSecretMigrationInputSchema, RawSecretMigrationReportSchema, {
+	kind: "mutation",
+	auth: "admin"
 }), method(ProfileRefInputSchema, _void(), {
 	kind: "mutation",
 	auth: "admin"
@@ -49614,6 +50201,41 @@ var ServerRollbackInfoSchema = object({
 	atMs: number(),
 	reason: string()
 });
+/**
+* The runner boot check (D877): the runners this node PLANNED (hub: one per
+* `resolveRunnerId` over its forked addons; agent: the runners its process
+* service holds, because only the hub plans) against the states the process
+* service reports. Kept in memory, recomputed by the same one-shot check after
+* every boot, served on `getServerPackageStatus`.
+*
+* `failed` is the D6 breaker's terminal state, `refused` a deterministic Init
+* refusal (an addon that said "I will not start, and here is why"), `missing` a
+* planned runner the process service has no entry for.
+*/
+var RunnerRefusalSchema = object({
+	runnerId: string(),
+	addonIds: array(string()),
+	reason: string()
+});
+var RunnerBootCheckSchema = object({
+	checkedAtMs: number(),
+	/** Runners planned for this node. */
+	expected: number(),
+	/** Planned runners whose process is `running`. */
+	running: number(),
+	failed: array(string()),
+	refused: array(RunnerRefusalSchema),
+	missing: array(string()),
+	/**
+	* Runners still on their way: `starting`, or `crashed` waiting on a backoff
+	* respawn. The check is FINAL only when this is empty; until then nothing is
+	* pushed and the verdict is re-evaluated on the next runner state change.
+	* Optional for version skew (absent = settled).
+	*/
+	pending: array(string()).optional(),
+	/** True when the plan is the hub's (`missing` is then meaningful); false on an agent. */
+	planKnown: boolean()
+});
 var ServerPackageStatusSchema = object({
 	/** Root package name (`@camstack/server` on the hub). */
 	packageName: string(),
@@ -49676,7 +50298,14 @@ var ServerPackageStatusSchema = object({
 	* for version skew: an older provider's payload simply omits it, and an
 	* absent wrapper is unknown — never `native`.
 	*/
-	wrapper: WrapperIdentitySchema.optional()
+	wrapper: WrapperIdentitySchema.optional(),
+	/**
+	* What this node PLANNED to run against what its process service reports
+	* (D877). Absent until the one-shot boot check has run (~60 s after boot) and
+	* on a provider that predates it. Absent is "not checked yet", never "all
+	* well": a consumer that needs the answer treats it as pending.
+	*/
+	runners: RunnerBootCheckSchema.optional()
 });
 var ServerUpdateCheckResultSchema = object({
 	packageName: string(),
@@ -49727,6 +50356,13 @@ var ServerUpdateOutcomeSchema = _enum([
 	"refused",
 	"failed"
 ]);
+/** One addon the pre-flight found the target version would refuse (D877). */
+var UpdateBlockerSchema = object({
+	addonId: string(),
+	reason: string(),
+	/** What the operator does about it. */
+	remedy: string()
+});
 var ServerUpdateActionResultSchema = object({
 	accepted: boolean(),
 	targetVersion: string().nullable(),
@@ -49744,14 +50380,27 @@ var ServerUpdateActionResultSchema = object({
 	* The failure itself, verbatim enough to act on (the npm output for a
 	* staging install). Non-null only for `failed`.
 	*/
-	error: string().nullable().optional()
+	error: string().nullable().optional(),
+	/**
+	* The addons the target version would refuse to start on this node's live
+	* store (D877), present when the pre-flight refused the update
+	* (`reason: 'addon-would-refuse'`). Optional for version skew.
+	*/
+	blockers: array(UpdateBlockerSchema).optional()
 });
 method(_void(), ServerPackageStatusSchema, { auth: "admin" }), method(_void(), ServerUpdateCheckResultSchema, {
 	kind: "mutation",
 	auth: "admin"
-}), method(object({ 
-/** Explicit target version; omitted = latest from the registry. */
-version: string().optional() }), ServerUpdateActionResultSchema, {
+}), method(object({
+	/** Explicit target version; omitted = latest from the registry. */
+	version: string().optional(),
+	/**
+	* Apply even though the pre-flight (D877) found addons the target would
+	* refuse to start. Off by default: those addons stay down until the
+	* remedy is run, which is the incident this gate exists to prevent.
+	*/
+	acknowledgeRefusals: boolean().optional()
+}), ServerUpdateActionResultSchema, {
 	kind: "mutation",
 	auth: "admin",
 	timeoutMs: 16 * 6e4
@@ -52164,7 +52813,9 @@ var ManifestShapeSchema = object({
 var AddonProcessSchema = object({
 	pid: number().optional(),
 	mode: string(),
-	state: string()
+	state: string(),
+	/** Why the runner is `refused` (an addon's own words), when it is (D877). */
+	reason: string().optional()
 });
 /**
 * Per-addon health snapshot from the kernel's AddonHealthMonitor.
@@ -53138,7 +53789,7 @@ var HvacModeSchema = _enum([
 	"fan_only",
 	"dry"
 ]);
-object({
+var ClimateControlStatusSchema = object({
 	/** Active HVAC mode. */
 	mode: HvacModeSchema,
 	/** Available HVAC modes the device accepts. Subset of HvacMode. */
@@ -53179,6 +53830,12 @@ object({
 	/** Horizontal louver swing on/off. Null when the device has no
 	*  horizontal swing surface (gate with `DeviceFeature.ClimateSwingHorizontal`). */
 	swingHorizontal: boolean().nullable(),
+	/** Lowest setpoint the device accepts, Celsius. Absent / null = not reported. */
+	minTemp: number().nullable().optional(),
+	/** Highest setpoint the device accepts, Celsius. Absent / null = not reported. */
+	maxTemp: number().nullable().optional(),
+	/** Setpoint granularity, Celsius (0.5, 1). Absent / null = not reported. */
+	tempStep: number().positive().nullable().optional(),
 	/** Ms epoch when the slice was last updated (push or command). */
 	lastFetchedAt: number()
 });
@@ -55019,7 +55676,19 @@ var TlsStatusSchema = object({
 	sans: array(string()),
 	caCertPem: string().nullable(),
 	reissueError: string().nullable(),
-	restartRequired: boolean()
+	restartRequired: boolean(),
+	/** An uploaded certificate is served but no CA is kept for it and it is not publicly signed (D873). */
+	caMissing: boolean(),
+	/** Does the hub's own generated CA carry a critical name constraint? `null` while it has none. */
+	localCaConstrained: boolean().nullable(),
+	/** ISO time the generated CA was replaced by a constrained one; devices must re-download it. */
+	caReplacedAt: string().nullable(),
+	/** The uploaded certificate kept on disk, selectable again after "Revert to generated". */
+	storedUpload: object({
+		leafFingerprintSha256: string(),
+		validTo: string(),
+		hasCa: boolean()
+	}).nullable()
 });
 method(_void(), ListResultSchema), method(_void(), PreferredSchema), method(object({
 	/**
@@ -55075,6 +55744,9 @@ method(_void(), ListResultSchema), method(_void(), PreferredSchema), method(obje
 }), method(_void(), object({ pem: string() })), method(_void(), TlsStatusSchema, {
 	kind: "mutation",
 	auth: "admin"
+}), method(_void(), TlsStatusSchema, {
+	kind: "mutation",
+	auth: "admin"
 });
 var LockControlStatusSchema = object({
 	/** Lifecycle state of the lock. `jammed` means the motor reported
@@ -60227,7 +60899,11 @@ method(_void(), array(UserSummarySchema), { auth: "admin" }), method(CreateUserI
 	kind: "mutation",
 	auth: "admin",
 	access: "delete"
-}), method(object({ userId: string() }), TotpStatusSchema, { auth: "admin" }), method(object({
+}), method(object({ userId: string() }), TotpStatusSchema, { auth: "admin" }), method(RawSecretMigrationInputSchema, RawSecretMigrationReportSchema, {
+	kind: "mutation",
+	auth: "admin",
+	access: "create"
+}), method(object({
 	userId: string(),
 	code: string()
 }), object({ valid: boolean() }), {
@@ -62428,6 +63104,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"coreBlocks.migrateRawSecrets": {
+		capName: "core-blocks",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"coreBlocks.restart": {
 		capName: "core-blocks",
 		capScope: "system",
@@ -64114,6 +64796,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"keychainAdmin.importSecret": {
+		capName: "keychain-admin",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"keychainAdmin.listAudit": {
 		capName: "keychain-admin",
 		capScope: "system",
@@ -64282,6 +64970,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"llm.migrateRawSecrets": {
+		capName: "llm",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"llm.resolveModelRef": {
 		capName: "llm",
 		capScope: "system",
@@ -64510,6 +65204,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"localNetwork.useStoredUploadedCertificate": {
+		capName: "local-network",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"lockControl.getStatus": {
 		capName: "lock-control",
 		capScope: "device",
@@ -67162,6 +67862,30 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"recordEntries.deleteEntry": {
+		capName: "record-entries",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"recordEntries.listEntries": {
+		capName: "record-entries",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"recordEntries.listEntryKinds": {
+		capName: "record-entries",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"recordEntries.putEntry": {
+		capName: "record-entries",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"recording.getAvailability": {
 		capName: "recording",
 		capScope: "device",
@@ -67462,6 +68186,102 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"records.aggregate": {
+		capName: "records",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"records.allocateId": {
+		capName: "records",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"records.count": {
+		capName: "records",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"records.declareKinds": {
+		capName: "records",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"records.delete": {
+		capName: "records",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"records.deleteDevice": {
+		capName: "records",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"records.deleteMany": {
+		capName: "records",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"records.deleteWhere": {
+		capName: "records",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"records.get": {
+		capName: "records",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"records.getMany": {
+		capName: "records",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"records.histogram": {
+		capName: "records",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"records.patch": {
+		capName: "records",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"records.put": {
+		capName: "records",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"records.putMany": {
+		capName: "records",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"records.query": {
+		capName: "records",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"records.secretRefs": {
+		capName: "records",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"sceneMonitor.captureReference": {
 		capName: "scene-monitor",
 		capScope: "device",
@@ -67894,6 +68714,48 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"storageAdmin.adoptRecords": {
+		capName: "storage-admin",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"storageAdmin.dropCollection": {
+		capName: "storage-admin",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"storageAdmin.isAdoptedLegacyTable": {
+		capName: "storage-admin",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"storageAdmin.listKinds": {
+		capName: "storage-admin",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"storageAdmin.listTables": {
+		capName: "storage-admin",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"storageAdmin.readLegacyCollection": {
+		capName: "storage-admin",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"storageAdmin.readRecords": {
+		capName: "storage-admin",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"storageEvictable.evict": {
 		capName: "storage-evictable",
 		capScope: "system",
@@ -68806,6 +69668,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"userManagement.migrateRawSecrets": {
+		capName: "user-management",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"userManagement.oauthExchangeCode": {
 		capName: "user-management",
 		capScope: "system",
@@ -71482,6 +72350,37 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"records.count": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
+	"records.deleteDevice": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"records.deleteWhere": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
+	"records.histogram": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
+	"records.putMany": [{
+		name: "records",
+		form: "object-array",
+		optional: false,
+		itemField: "deviceId"
+	}],
+	"records.query": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
 	"sceneMonitor.captureReference": [{
 		name: "deviceId",
 		form: "single",
@@ -71598,6 +72497,17 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"storageAdmin.adoptRecords": [{
+		name: "records",
+		form: "object-array",
+		optional: false,
+		itemField: "deviceId"
+	}],
+	"storageAdmin.readRecords": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
 	"streamBroker.acquireEgressTranscode": [{
 		name: "deviceId",
 		form: "single",
@@ -73998,6 +74908,778 @@ async function revokeBrokerCredential(fetchImpl, brokerUrl, credential) {
 	await call(fetchImpl, brokerUrl, "/broker/revoke", { bearer: credential }, unknown());
 }
 //#endregion
+//#region src/endpoints/adapters/climate-model.ts
+/**
+* What a `climate-control` device is to Alexa (D874) — pure, so the discovery
+* shape, the slice mapping and the directive handlers share one definition.
+*
+*   `Alexa.ThermostatController` 3.1  targetSetpoint, lowerSetpoint /
+*                                     upperSetpoint (a device with a range),
+*                                     thermostatMode HEAT / COOL / AUTO / ECO /
+*                                     OFF
+*   `Alexa.TemperatureSensor`         the current temperature
+*   `Alexa.PowerController`           when the device can be turned off
+*   `Alexa.ModeController` Climate.Mode      only when the device has a mode
+*                                     Amazon's thermostat vocabulary lacks
+*                                     (dry, fan_only)
+*   `Alexa.ModeController` Climate.FanSpeed  the device's own fan modes
+*
+* Amazon's `thermostatMode` has no value for `dry` / `fan_only`, and a CUSTOM
+* mode is not a documented way to carry them: they travel through the
+* `Climate.Mode` ModeController, and `thermostatMode` is simply not reported
+* while the device is in one of them.
+*
+* Temperatures are Celsius throughout (the cap's contract); Alexa converts for
+* the account.
+*/
+var INSTANCE_MODE = "Climate.Mode";
+var INSTANCE_FAN = "Climate.FanSpeed";
+var FAN_PREFIX = "Fan.";
+var DEFAULT_TEMP_STEP = .5;
+var FEATURE_DUAL_SETPOINT = "climate-dual-setpoint";
+var ALEXA_ECO_PRESET = "eco";
+var SINGLE_SETPOINT_MODES = [
+	"heat",
+	"cool",
+	"auto",
+	"dry"
+];
+/** What TurnOn switches to, best first. */
+var TURN_ON_PREFERENCE = [
+	"auto",
+	"heat_cool",
+	"cool",
+	"heat"
+];
+var SliceShape$1 = ClimateControlStatusSchema.pick({
+	mode: true,
+	availableModes: true,
+	fanMode: true,
+	availableFanModes: true,
+	preset: true,
+	availablePresets: true,
+	target: true,
+	targetHigh: true,
+	targetLow: true,
+	currentTemp: true,
+	minTemp: true,
+	maxTemp: true,
+	tempStep: true
+});
+/** The slice fields the adapter reads, or null when the slice is not a climate one. */
+function readClimateSlice(slice) {
+	const parsed = SliceShape$1.safeParse(slice);
+	return parsed.success ? parsed.data : null;
+}
+function boundsOf(slice) {
+	const min = slice.minTemp ?? 7;
+	const max = slice.maxTemp ?? 35;
+	const step = slice.tempStep ?? .5;
+	return min < max ? {
+		min,
+		max,
+		step
+	} : {
+		min: 7,
+		max: 35,
+		step: DEFAULT_TEMP_STEP
+	};
+}
+/** One decimal, the precision Alexa's own conversions keep. */
+function round1(value) {
+	return Math.round(value * 10) / 10;
+}
+/**
+* Snap a setpoint to the device's step (anchored at its minimum), then clamp:
+* a maximum off the step grid (max 30.2, step 0.5) must not snap above itself.
+*/
+function snapToStep(value, bounds) {
+	const snapped = bounds.min + Math.round((value - bounds.min) / bounds.step) * bounds.step;
+	return round1(Math.min(bounds.max, Math.max(bounds.min, snapped)));
+}
+function temperatureValue(celsius) {
+	return {
+		value: round1(celsius),
+		scale: "CELSIUS"
+	};
+}
+function hasMode(slice, mode) {
+	return slice !== null && slice.availableModes.includes(mode);
+}
+/** Dual setpoints (a heat/cool range). */
+function supportsDual(slice, features) {
+	return slice === null ? features.includes(FEATURE_DUAL_SETPOINT) : hasMode(slice, "heat_cool");
+}
+/** A single setpoint (everything but a range-only device). */
+function supportsSingle(slice) {
+	return slice === null || slice.availableModes.length === 0 ? true : slice.availableModes.some((m) => SINGLE_SETPOINT_MODES.includes(m));
+}
+/** The device's own name for its `eco` preset, if it has one. */
+function ecoPresetOf(slice) {
+	return slice?.availablePresets.find((p) => p.toLowerCase() === ALEXA_ECO_PRESET) ?? null;
+}
+/** Amazon thermostat modes the device can be put in, in a stable order. */
+function supportedThermostatModes(slice) {
+	if (slice === null || slice.availableModes.length === 0) return [
+		"HEAT",
+		"COOL",
+		"AUTO",
+		"OFF"
+	];
+	const out = [];
+	if (hasMode(slice, "heat")) out.push("HEAT");
+	if (hasMode(slice, "cool")) out.push("COOL");
+	if (hasMode(slice, "auto") || hasMode(slice, "heat_cool")) out.push("AUTO");
+	if (ecoPresetOf(slice) !== null && out.length > 0) out.push("ECO");
+	if (hasMode(slice, "off")) out.push("OFF");
+	return out;
+}
+/** The HVAC mode TurnOn / leaving OFF switches to. */
+function onModeOf(slice) {
+	return TURN_ON_PREFERENCE.find((m) => hasMode(slice, m)) ?? null;
+}
+function canPowerOff(slice) {
+	return slice === null || slice.availableModes.length === 0 || hasMode(slice, "off");
+}
+/** A device with a mode Amazon's thermostat vocabulary lacks. */
+function hasExtraModes(slice) {
+	return hasMode(slice, "dry") || hasMode(slice, "fan_only");
+}
+var MODE_VALUE = {
+	heat: "Mode.Heat",
+	cool: "Mode.Cool",
+	auto: "Mode.Auto",
+	dry: "Mode.Dry",
+	fan_only: "Mode.Fan",
+	off: "Mode.Off"
+};
+var MODE_NAMES = {
+	"Mode.Heat": ["Riscaldamento", "Heating"],
+	"Mode.Cool": ["Raffrescamento", "Cooling"],
+	"Mode.Auto": ["Automatico", "Auto"],
+	"Mode.Dry": ["Deumidificazione", "Dry"],
+	"Mode.Fan": ["Ventilazione", "Fan only"],
+	"Mode.Off": ["Spento", "Off"]
+};
+/** The ModeController value a HVAC mode reports as (a range is "auto"). */
+function modeValueOf(mode) {
+	return mode === "heat_cool" ? MODE_VALUE.auto : MODE_VALUE[mode];
+}
+/** The HVAC mode a ModeController value asks for, among those the device has. */
+function hvacModeForValue(value, slice) {
+	if (value === MODE_VALUE.auto) return hasMode(slice, "auto") ? "auto" : hasMode(slice, "heat_cool") ? "heat_cool" : null;
+	const mode = Object.entries(MODE_VALUE).find(([, v]) => v === value)?.[0];
+	if (mode === void 0) return null;
+	const candidate = SliceShape$1.shape.mode.safeParse(mode);
+	return candidate.success && hasMode(slice, candidate.data) ? candidate.data : null;
+}
+/** The ModeController values the device offers, in a stable order. */
+function modeValuesOf(slice) {
+	return [
+		"heat",
+		"cool",
+		"auto",
+		"dry",
+		"fan_only",
+		"off"
+	].filter((m) => m === "auto" ? hasMode(slice, "auto") || hasMode(slice, "heat_cool") : hasMode(slice, m)).map((m) => MODE_VALUE[m]);
+}
+function textNames(it, en) {
+	return [{
+		"@type": "text",
+		value: {
+			text: it,
+			locale: "it-IT"
+		}
+	}, {
+		"@type": "text",
+		value: {
+			text: en,
+			locale: "en-US"
+		}
+	}];
+}
+function modeCapability(slice) {
+	const values = modeValuesOf(slice);
+	if (values.length < 2) return null;
+	return {
+		type: "AlexaInterface",
+		interface: "Alexa.ModeController",
+		version: "3",
+		instance: INSTANCE_MODE,
+		capabilityResources: { friendlyNames: [{
+			"@type": "asset",
+			value: { assetId: "Alexa.Setting.Mode" }
+		}, ...textNames("Modalità", "Mode")] },
+		properties: {
+			supported: [{ name: "mode" }],
+			proactivelyReported: true,
+			retrievable: true
+		},
+		configuration: {
+			ordered: false,
+			supportedModes: values.map((value) => {
+				const [it, en] = MODE_NAMES[value] ?? [value, value];
+				return {
+					value,
+					modeResources: { friendlyNames: textNames(it, en) }
+				};
+			})
+		}
+	};
+}
+var FAN_ASSETS = {
+	low: "Alexa.Value.Low",
+	medium: "Alexa.Value.Medium",
+	high: "Alexa.Value.High"
+};
+var FAN_TEXTS = {
+	auto: ["Automatico", "Auto"],
+	quiet: ["Silenzioso", "Quiet"],
+	turbo: ["Turbo", "Turbo"],
+	on: ["Acceso", "On"],
+	off: ["Spento", "Off"],
+	middle: ["Medio", "Medium"],
+	mediumlow: ["Medio basso", "Medium low"],
+	mediumhigh: ["Medio alto", "Medium high"],
+	medium_low: ["Medio basso", "Medium low"],
+	medium_high: ["Medio alto", "Medium high"]
+};
+function capitalize(word) {
+	return word.charAt(0).toUpperCase() + word.slice(1);
+}
+/** The ModeController value of a vendor fan mode (`medium_high` -> `Fan.MediumHigh`). */
+function fanValueOf(fanMode) {
+	const words = fanMode.split(/[^A-Za-z0-9]+/).filter((w) => w.length > 0);
+	return words.length === 0 ? null : `${FAN_PREFIX}${words.map(capitalize).join("")}`;
+}
+/** The fan modes with a usable, unique value: `[value, deviceFanMode]`. */
+function fanModesOf(slice) {
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const fanMode of slice.availableFanModes) {
+		const value = fanValueOf(fanMode);
+		if (value === null || seen.has(value)) continue;
+		seen.add(value);
+		out.push([value, fanMode]);
+	}
+	return out;
+}
+function hasFanModes(slice) {
+	return slice !== null && fanModesOf(slice).length >= 2;
+}
+function fanFriendlyNames(fanMode) {
+	const key = fanMode.toLowerCase();
+	const asset = FAN_ASSETS[key];
+	if (asset !== void 0) return [{
+		"@type": "asset",
+		value: { assetId: asset }
+	}];
+	const [it, en] = FAN_TEXTS[key] ?? [fanMode.replace(/_/g, " "), fanMode.replace(/_/g, " ")];
+	return textNames(it, en);
+}
+function fanCapability(slice) {
+	const modes = fanModesOf(slice);
+	if (modes.length < 2) return null;
+	return {
+		type: "AlexaInterface",
+		interface: "Alexa.ModeController",
+		version: "3",
+		instance: INSTANCE_FAN,
+		capabilityResources: { friendlyNames: [{
+			"@type": "asset",
+			value: { assetId: "Alexa.Setting.FanSpeed" }
+		}, ...textNames("Velocità ventola", "Fan speed")] },
+		properties: {
+			supported: [{ name: "mode" }],
+			proactivelyReported: true,
+			retrievable: true
+		},
+		configuration: {
+			ordered: false,
+			supportedModes: modes.map(([value, fanMode]) => ({
+				value,
+				modeResources: { friendlyNames: fanFriendlyNames(fanMode) }
+			}))
+		}
+	};
+}
+function propertiesBlock(names) {
+	return {
+		supported: names.map((name) => ({ name })),
+		proactivelyReported: true,
+		retrievable: true
+	};
+}
+function thermostatCapability(slice, modes, features) {
+	return {
+		type: "AlexaInterface",
+		interface: "Alexa.ThermostatController",
+		version: "3.1",
+		properties: propertiesBlock([
+			...supportsSingle(slice) ? ["targetSetpoint"] : [],
+			...supportsDual(slice, features) ? ["lowerSetpoint", "upperSetpoint"] : [],
+			"thermostatMode"
+		]),
+		configuration: {
+			supportedModes: modes,
+			supportsScheduling: false
+		}
+	};
+}
+/** A thermostat is a THERMOSTAT, any other climate device an air conditioner. */
+function climateCategoryFor(deviceType) {
+	return deviceType === "thermostat" ? "THERMOSTAT" : "AIR_CONDITIONER";
+}
+function describeClimate(device) {
+	const slice = readClimateSlice(device.slices["climate-control"]);
+	const modes = supportedThermostatModes(slice);
+	if (modes.length === 0) return {
+		kind: "skip",
+		reason: "climate: the device offers no mode Alexa has a thermostat value for"
+	};
+	const extras = [];
+	if (slice !== null) {
+		const mode = hasExtraModes(slice) ? modeCapability(slice) : null;
+		const fan = hasFanModes(slice) ? fanCapability(slice) : null;
+		if (mode !== null) extras.push(mode);
+		if (fan !== null) extras.push(fan);
+	}
+	return {
+		kind: "publish",
+		capabilities: [
+			thermostatCapability(slice, modes, device.features),
+			{
+				type: "AlexaInterface",
+				interface: "Alexa.TemperatureSensor",
+				version: "3",
+				properties: propertiesBlock(["temperature"])
+			},
+			...canPowerOff(slice) ? [{
+				type: "AlexaInterface",
+				interface: "Alexa.PowerController",
+				version: "3",
+				properties: propertiesBlock(["powerState"])
+			}] : [],
+			...extras
+		],
+		category: climateCategoryFor(device.type)
+	};
+}
+/** Amazon's `thermostatMode` for the state, or null while in a mode it lacks. */
+function thermostatModeOf(slice) {
+	if (slice.mode === "off") return "OFF";
+	const eco = ecoPresetOf(slice);
+	if (eco !== null && slice.preset === eco) return "ECO";
+	switch (slice.mode) {
+		case "heat": return "HEAT";
+		case "cool": return "COOL";
+		case "auto":
+		case "heat_cool": return "AUTO";
+		default: return null;
+	}
+}
+function climateProperties(slice) {
+	const s = readClimateSlice(slice);
+	if (s === null) return [];
+	const out = [];
+	const thermostat = (name, value) => {
+		out.push({
+			namespace: "Alexa.ThermostatController",
+			name,
+			value
+		});
+	};
+	if (hasMode(s, "heat_cool") && s.targetLow !== null && s.targetHigh !== null && s.mode === "heat_cool") {
+		thermostat("lowerSetpoint", temperatureValue(s.targetLow ?? 0));
+		thermostat("upperSetpoint", temperatureValue(s.targetHigh ?? 0));
+	} else if (s.target !== null && supportsSingle(s)) thermostat("targetSetpoint", temperatureValue(s.target));
+	const mode = thermostatModeOf(s);
+	if (mode !== null) thermostat("thermostatMode", mode);
+	if (s.currentTemp !== null) out.push({
+		namespace: "Alexa.TemperatureSensor",
+		name: "temperature",
+		value: temperatureValue(s.currentTemp)
+	});
+	if (canPowerOff(s)) out.push({
+		namespace: "Alexa.PowerController",
+		name: "powerState",
+		value: s.mode === "off" ? "OFF" : "ON"
+	});
+	if (hasExtraModes(s) && modeValuesOf(s).length >= 2) out.push({
+		namespace: "Alexa.ModeController",
+		instance: INSTANCE_MODE,
+		name: "mode",
+		value: modeValueOf(s.mode)
+	});
+	const fan = fanValueOf(s.fanMode);
+	if (hasFanModes(s) && fan !== null && fanModesOf(s).some(([value]) => value === fan)) out.push({
+		namespace: "Alexa.ModeController",
+		instance: INSTANCE_FAN,
+		name: "mode",
+		value: fan
+	});
+	return out;
+}
+//#endregion
+//#region src/handlers/climate-controller.ts
+var CAP_CLIMATE = "climate-control";
+var CAP_SWITCH$1 = "switch";
+var UNCERTAINTY_MS = 500;
+var PRESET_NONE = "none";
+var ScaleSchema = _enum([
+	"CELSIUS",
+	"FAHRENHEIT",
+	"KELVIN"
+]);
+var TemperatureSchema = object({
+	value: number(),
+	scale: ScaleSchema
+});
+var SetTemperaturePayload = object({
+	targetSetpoint: TemperatureSchema.optional(),
+	lowerSetpoint: TemperatureSchema.optional(),
+	upperSetpoint: TemperatureSchema.optional()
+});
+var AdjustTemperaturePayload = object({ targetSetpointDelta: TemperatureSchema });
+var ThermostatModePayload = object({ thermostatMode: union([string(), object({ value: string() })]) });
+var ModePayload = object({ mode: string() });
+function isRefusal(outcome) {
+	return "refusal" in outcome;
+}
+function toCelsius(t) {
+	if (t.scale === "FAHRENHEIT") return (t.value - 32) * 5 / 9;
+	if (t.scale === "KELVIN") return t.value - 273.15;
+	return t.value;
+}
+/** A DELTA converts without the scale's offset. */
+function deltaToCelsius(t) {
+	return t.scale === "FAHRENHEIT" ? t.value * 5 / 9 : t.value;
+}
+function withPayload(envelope, extra) {
+	return { event: {
+		...envelope.event,
+		payload: {
+			...envelope.event.payload,
+			...extra
+		}
+	} };
+}
+function outOfRange$1(header, bounds) {
+	return { refusal: withPayload(errorEnvelope(header, "TEMPERATURE_VALUE_OUT_OF_RANGE", `the setpoint must be between ${bounds.min} and ${bounds.max} C`), { validRange: {
+		minimumValue: temperatureValue(bounds.min),
+		maximumValue: temperatureValue(bounds.max)
+	} }) };
+}
+function tooClose(header, bounds) {
+	return { refusal: withPayload(errorEnvelope(header, "REQUESTED_SETPOINTS_TOO_CLOSE", "lowerSetpoint must be below upperSetpoint"), { minimumTemperatureDelta: temperatureValue(bounds.step) }) };
+}
+function refuse$1(header, type, message) {
+	return { refusal: errorEnvelope(header, type, message) };
+}
+function inRange(celsius, bounds) {
+	const v = round1(celsius);
+	return v >= bounds.min && v <= bounds.max;
+}
+var THERMOSTAT_PROPERTIES = new Set([
+	"targetSetpoint",
+	"lowerSetpoint",
+	"upperSetpoint",
+	"thermostatMode"
+]);
+function thermostatProperty(property) {
+	return property.namespace === "Alexa.ThermostatController" && THERMOSTAT_PROPERTIES.has(property.name);
+}
+function commandsFor(api, deviceId) {
+	return {
+		setMode: (mode) => api.climateControl.setMode.mutate({
+			deviceId,
+			mode
+		}),
+		setPreset: (preset) => api.climateControl.setPreset.mutate({
+			deviceId,
+			preset
+		}),
+		setFanMode: (fanMode) => api.climateControl.setFanMode.mutate({
+			deviceId,
+			fanMode
+		}),
+		setTarget: (target) => api.climateControl.setTarget.mutate({
+			deviceId,
+			target
+		}),
+		setTargetRange: (targetLow, targetHigh) => api.climateControl.setTargetRange.mutate({
+			deviceId,
+			targetLow,
+			targetHigh
+		})
+	};
+}
+function planRange(header, slice, cmd, low, high) {
+	const bounds = boundsOf(slice);
+	if (!supportsDual(slice, [])) return refuse$1(header, "DUAL_SETPOINTS_UNSUPPORTED", "this thermostat has a single setpoint");
+	if (!inRange(low, bounds) || !inRange(high, bounds)) return outOfRange$1(header, bounds);
+	const targetLow = snapToStep(low, bounds);
+	const targetHigh = snapToStep(high, bounds);
+	if (targetHigh - targetLow < bounds.step) return tooClose(header, bounds);
+	return {
+		commands: [...slice.mode === "heat_cool" ? [] : [() => cmd.setMode("heat_cool")], () => cmd.setTargetRange(targetLow, targetHigh)],
+		projected: {
+			...slice,
+			mode: "heat_cool",
+			targetLow,
+			targetHigh
+		},
+		keep: thermostatProperty
+	};
+}
+function planSingle(header, slice, cmd, celsius) {
+	const bounds = boundsOf(slice);
+	if (!supportsSingle(slice) || slice.mode === "heat_cool") return refuse$1(header, "UNWILLING_TO_SET_VALUE", "the thermostat is in range mode: set a lower and an upper setpoint");
+	if (!inRange(celsius, bounds)) return outOfRange$1(header, bounds);
+	const target = snapToStep(celsius, bounds);
+	return {
+		commands: [() => cmd.setTarget(target)],
+		projected: {
+			...slice,
+			target
+		},
+		keep: thermostatProperty
+	};
+}
+function planSetTemperature(c, slice, cmd) {
+	const parsed = SetTemperaturePayload.safeParse(c.payload);
+	if (!parsed.success) return refuse$1(c.header, "INVALID_DIRECTIVE", parsed.error.message);
+	const { targetSetpoint, lowerSetpoint, upperSetpoint } = parsed.data;
+	if (targetSetpoint !== void 0 && lowerSetpoint !== void 0 && upperSetpoint !== void 0) return refuse$1(c.header, "TRIPLE_SETPOINTS_UNSUPPORTED", "a target AND a range were requested");
+	if (lowerSetpoint !== void 0 && upperSetpoint !== void 0 && targetSetpoint === void 0) return planRange(c.header, slice, cmd, toCelsius(lowerSetpoint), toCelsius(upperSetpoint));
+	if (targetSetpoint !== void 0 && lowerSetpoint === void 0 && upperSetpoint === void 0) return planSingle(c.header, slice, cmd, toCelsius(targetSetpoint));
+	return refuse$1(c.header, "INVALID_DIRECTIVE", "give a targetSetpoint, or a lower and an upper");
+}
+function planAdjust(c, slice, cmd) {
+	const parsed = AdjustTemperaturePayload.safeParse(c.payload);
+	if (!parsed.success) return refuse$1(c.header, "INVALID_DIRECTIVE", parsed.error.message);
+	const delta = deltaToCelsius(parsed.data.targetSetpointDelta);
+	if (slice.mode === "heat_cool" && slice.targetLow !== null && slice.targetHigh !== null) return planRange(c.header, slice, cmd, slice.targetLow + delta, slice.targetHigh + delta);
+	if (slice.target === null) return refuse$1(c.header, "ENDPOINT_UNREACHABLE", "the current setpoint is unknown, so it cannot be adjusted");
+	return planSingle(c.header, slice, cmd, slice.target + delta);
+}
+var ECO_FROM_OFF_MESSAGE = "the thermostat has no mode to leave OFF into";
+function hvacModeFor(requested, slice) {
+	const has = (m) => slice.availableModes.includes(m);
+	switch (requested) {
+		case "HEAT": return has("heat") ? "heat" : null;
+		case "COOL": return has("cool") ? "cool" : null;
+		case "AUTO": return has("auto") ? "auto" : has("heat_cool") ? "heat_cool" : null;
+		case "OFF": return has("off") ? "off" : null;
+		default: return null;
+	}
+}
+/** The preset that clears `eco` (HA and Gree both call it `none`), if the device has one. */
+function presetClearing(slice) {
+	return slice.availablePresets.find((p) => p.toLowerCase() === PRESET_NONE) ?? null;
+}
+function planEco(c, slice, cmd) {
+	const eco = ecoPresetOf(slice);
+	if (eco === null) return refuse$1(c.header, "UNSUPPORTED_THERMOSTAT_MODE", "ECO is not supported");
+	const wake = slice.mode === "off" ? onModeOf(slice) : null;
+	if (slice.mode === "off" && wake === null) return refuse$1(c.header, "UNSUPPORTED_THERMOSTAT_MODE", ECO_FROM_OFF_MESSAGE);
+	return {
+		commands: [...wake === null ? [] : [() => cmd.setMode(wake)], () => cmd.setPreset(eco)],
+		projected: {
+			...slice,
+			mode: wake ?? slice.mode,
+			preset: eco
+		},
+		keep: thermostatProperty
+	};
+}
+function planSetThermostatMode(c, slice, cmd) {
+	const parsed = ThermostatModePayload.safeParse(c.payload);
+	if (!parsed.success) return refuse$1(c.header, "INVALID_DIRECTIVE", parsed.error.message);
+	const raw = parsed.data.thermostatMode;
+	const requested = (typeof raw === "string" ? raw : raw.value).toUpperCase();
+	if (requested === "ECO") return planEco(c, slice, cmd);
+	const mode = hvacModeFor(requested, slice);
+	if (mode === null) return refuse$1(c.header, "UNSUPPORTED_THERMOSTAT_MODE", `${requested} is not a mode this thermostat has`);
+	const eco = ecoPresetOf(slice);
+	const clear = eco !== null && slice.preset === eco ? presetClearing(slice) : null;
+	return {
+		commands: [...clear === null ? [] : [() => cmd.setPreset(clear)], () => cmd.setMode(mode)],
+		projected: {
+			...slice,
+			mode,
+			preset: clear ?? slice.preset
+		},
+		keep: thermostatProperty
+	};
+}
+function planPower(c, slice, cmd) {
+	const turnOn = c.header.name === "TurnOn";
+	const keep = (p) => p.namespace === "Alexa.PowerController";
+	if (turnOn) {
+		if (slice.mode !== "off") return {
+			commands: [],
+			projected: slice,
+			keep
+		};
+		const mode = onModeOf(slice);
+		if (mode === null) return refuse$1(c.header, "INVALID_DIRECTIVE", "no mode to turn on into");
+		return {
+			commands: [() => cmd.setMode(mode)],
+			projected: {
+				...slice,
+				mode
+			},
+			keep
+		};
+	}
+	if (!slice.availableModes.includes("off")) return refuse$1(c.header, "INVALID_DIRECTIVE", "this device cannot be turned off");
+	if (slice.mode === "off") return {
+		commands: [],
+		projected: slice,
+		keep
+	};
+	return {
+		commands: [() => cmd.setMode("off")],
+		projected: {
+			...slice,
+			mode: "off"
+		},
+		keep
+	};
+}
+function planModeController(c, slice, cmd) {
+	const parsed = ModePayload.safeParse(c.payload);
+	const instance = c.header.instance;
+	if (!parsed.success || instance === void 0) return refuse$1(c.header, "INVALID_DIRECTIVE", "a mode and an instance are required");
+	const keep = (p) => p.instance === instance;
+	if (instance === "Climate.Mode") {
+		const mode = hvacModeForValue(parsed.data.mode, slice);
+		if (mode === null) return refuse$1(c.header, "INVALID_VALUE", `unknown mode ${parsed.data.mode}`);
+		return {
+			commands: [() => cmd.setMode(mode)],
+			projected: {
+				...slice,
+				mode
+			},
+			keep
+		};
+	}
+	if (instance === "Climate.FanSpeed") {
+		const fan = fanModesOf(slice).find(([value]) => value === parsed.data.mode);
+		if (fan === void 0) return refuse$1(c.header, "INVALID_VALUE", `unknown fan mode ${parsed.data.mode}`);
+		return {
+			commands: [() => cmd.setFanMode(fan[1])],
+			projected: {
+				...slice,
+				fanMode: fan[1]
+			},
+			keep
+		};
+	}
+	return refuse$1(c.header, "INVALID_DIRECTIVE", `unknown instance ${instance}`);
+}
+function plan(c, slice, cmd) {
+	switch (`${c.header.namespace}/${c.header.name}`) {
+		case "Alexa.ThermostatController/SetTargetTemperature": return planSetTemperature(c, slice, cmd);
+		case "Alexa.ThermostatController/AdjustTargetTemperature": return planAdjust(c, slice, cmd);
+		case "Alexa.ThermostatController/SetThermostatMode": return planSetThermostatMode(c, slice, cmd);
+		case "Alexa.PowerController/TurnOn":
+		case "Alexa.PowerController/TurnOff": return planPower(c, slice, cmd);
+		case "Alexa.ModeController/SetMode": return planModeController(c, slice, cmd);
+		default: return refuse$1(c.header, "INVALID_DIRECTIVE", `${c.header.namespace}/${c.header.name}`);
+	}
+}
+async function readSlice$1(c, deps) {
+	try {
+		return readClimateSlice(await deps.ctx.api.deviceState.getCapSlice.query({
+			deviceId: c.deviceId,
+			capName: CAP_CLIMATE
+		}));
+	} catch (err) {
+		deps.logger.warn("alexa climate-controller: the climate state could not be read", {
+			tags: { deviceId: c.deviceId },
+			meta: { error: err instanceof Error ? err.message : String(err) }
+		});
+		return null;
+	}
+}
+function successResponse$1(c, properties) {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	return {
+		event: {
+			header: {
+				namespace: "Alexa",
+				name: "Response",
+				messageId: c.header.messageId,
+				...c.header.correlationToken !== void 0 ? { correlationToken: c.header.correlationToken } : {},
+				payloadVersion: "3"
+			},
+			endpoint: { endpointId: c.endpoint.endpointId },
+			payload: {}
+		},
+		context: { properties: properties.map((p) => ({
+			...p,
+			timeOfSample: now,
+			uncertaintyInMilliseconds: UNCERTAINTY_MS
+		})) }
+	};
+}
+/** The one handler behind every climate directive. */
+async function handleClimateDirective(c) {
+	const deps = c.deps.climateController;
+	const slice = await readSlice$1(c, deps);
+	if (slice === null) return errorEnvelope(c.header, "ENDPOINT_UNREACHABLE", "the climate state could not be read");
+	const outcome = plan(c, slice, commandsFor(deps.ctx.api, c.deviceId));
+	if (isRefusal(outcome)) return outcome.refusal;
+	try {
+		for (const command of outcome.commands) await command();
+	} catch (err) {
+		deps.logger.warn("alexa climate-controller: the climate command failed", {
+			tags: { deviceId: c.deviceId },
+			meta: {
+				directive: c.header.name,
+				error: err instanceof Error ? err.message : String(err)
+			}
+		});
+		return errorEnvelope(c.header, "ENDPOINT_UNREACHABLE", "the device did not accept the command");
+	}
+	deps.logger.info(`alexa climate-controller: ${c.header.name}`, {
+		tags: { deviceId: c.deviceId },
+		meta: { commands: outcome.commands.length }
+	});
+	return successResponse$1(c, climateProperties(outcome.projected).filter(outcome.keep));
+}
+/**
+* Last answer per device, per deps instance: a failed bindings read changes
+* nothing (AGENTS D49) — a thermostat's TurnOff must not fall through to the
+* switch handler because one `getBindings` call failed.
+*/
+var lastPowerClaim = /* @__PURE__ */ new WeakMap();
+/** PowerController on a climate endpoint, not on a switch: decided by the bound caps. */
+async function handlesPower(c) {
+	const deps = c.deps.climateController;
+	const known = lastPowerClaim.get(deps) ?? /* @__PURE__ */ new Map();
+	lastPowerClaim.set(deps, known);
+	try {
+		const caps = (await deps.ctx.api.deviceManager.getBindings.query({ deviceId: c.deviceId })).entries.map((e) => e.capName);
+		const claim = caps.includes(CAP_CLIMATE) && !caps.includes(CAP_SWITCH$1);
+		known.set(c.deviceId, claim);
+		return claim;
+	} catch (err) {
+		const previous = known.get(c.deviceId);
+		deps.logger.warn("alexa climate-controller: the bound caps could not be read", {
+			tags: { deviceId: c.deviceId },
+			meta: {
+				error: err instanceof Error ? err.message : String(err),
+				decidedFrom: previous === void 0 ? "no previous answer: not claimed" : "previous answer"
+			}
+		});
+		return previous ?? false;
+	}
+}
+//#endregion
 //#region src/endpoints/adapters/shared.ts
 /** The base `Alexa` interface every endpoint declares. */
 var BASE = {
@@ -74048,6 +75730,88 @@ function numericValueField(value) {
 	return typeof raw === "number" ? raw : null;
 }
 //#endregion
+//#region src/endpoints/adapters/temperature.ts
+/** A temperature change under half a degree is not worth a ChangeReport. */
+var TEMPERATURE_DEADBAND_CELSIUS = .5;
+/** A numeric sensor reports at most once a minute per property (D869). */
+var SENSOR_MIN_INTERVAL_MS = 6e4;
+/** `temperature-sensor` → `Alexa.TemperatureSensor` (TEMPERATURE_SENSOR). */
+var temperatureAdapter = {
+	cap: "temperature-sensor",
+	stateCaps: ["temperature-sensor"],
+	discoveryReads: [],
+	describe: () => ({
+		kind: "publish",
+		capabilities: [iface("Alexa.TemperatureSensor", "temperature")],
+		category: "TEMPERATURE_SENSOR"
+	}),
+	properties: (_cap, slice) => {
+		const p = TemperatureSensorStatusSchema.pick({ celsius: true }).safeParse(slice);
+		return p.success ? [{
+			namespace: "Alexa.TemperatureSensor",
+			name: "temperature",
+			value: {
+				value: Math.round(p.data.celsius * 10) / 10,
+				scale: "CELSIUS"
+			}
+		}] : [];
+	},
+	directives: [],
+	shaping: () => ({
+		deadband: TEMPERATURE_DEADBAND_CELSIUS,
+		minIntervalMs: SENSOR_MIN_INTERVAL_MS,
+		numericOf: numericValueField
+	})
+};
+//#endregion
+//#region src/endpoints/adapters/climate.ts
+var OWN_INSTANCES = new Set([INSTANCE_MODE, INSTANCE_FAN]);
+var THERMOSTAT_DIRECTIVES = [
+	"Alexa.ThermostatController/SetTargetTemperature",
+	"Alexa.ThermostatController/AdjustTargetTemperature",
+	"Alexa.ThermostatController/SetThermostatMode"
+].map((key) => ({
+	key,
+	needsReachableDevice: true,
+	handle: handleClimateDirective
+}));
+var POWER_DIRECTIVES$1 = ["Alexa.PowerController/TurnOn", "Alexa.PowerController/TurnOff"].map((key) => ({
+	key,
+	needsReachableDevice: true,
+	handle: handleClimateDirective,
+	claims: handlesPower
+}));
+var MODE_DIRECTIVE = {
+	key: "Alexa.ModeController/SetMode",
+	needsReachableDevice: true,
+	handle: handleClimateDirective,
+	claims: async (c) => c.header.instance !== void 0 && OWN_INSTANCES.has(c.header.instance)
+};
+/**
+* `climate-control` -> a thermostat (Home Assistant) or an air conditioner
+* (Gree) (D874): `Alexa.ThermostatController` 3.1 with the current temperature,
+* power, and the modes Amazon's vocabulary lacks and the fan mode as
+* ModeControllers. The current temperature is shaped like any temperature
+* sensor; setpoints, mode and fan report on every change.
+*/
+var climateAdapter = {
+	cap: "climate-control",
+	stateCaps: ["climate-control"],
+	discoveryReads: ["climate-control"],
+	describe: describeClimate,
+	properties: (_cap, slice) => climateProperties(slice),
+	directives: [
+		...THERMOSTAT_DIRECTIVES,
+		...POWER_DIRECTIVES$1,
+		MODE_DIRECTIVE
+	],
+	shaping: (property) => property.namespace === "Alexa.TemperatureSensor" ? {
+		deadband: TEMPERATURE_DEADBAND_CELSIUS,
+		minIntervalMs: SENSOR_MIN_INTERVAL_MS,
+		numericOf: numericValueField
+	} : null
+};
+//#endregion
 //#region src/endpoints/adapters/contact.ts
 /** `contact` → `Alexa.ContactSensor` (CONTACT_SENSOR). Amazon: DETECTED = open. */
 var contactAdapter = {
@@ -74712,7 +76476,8 @@ var coverAdapter = {
 	].map((key) => ({
 		key,
 		needsReachableDevice: true,
-		handle: handleCoverDirective
+		handle: handleCoverDirective,
+		claims: async (c) => c.header.instance?.startsWith("Blind.") ?? false
 	})),
 	shaping: (property) => property.namespace === "Alexa.RangeController" ? {
 		deadband: 1,
@@ -74720,40 +76485,6 @@ var coverAdapter = {
 		numericOf: plainNumber
 	} : { debounceMs: COVER_DEBOUNCE_MS }
 };
-//#endregion
-//#region src/endpoints/adapters/temperature.ts
-/** A temperature change under half a degree is not worth a ChangeReport. */
-var TEMPERATURE_DEADBAND_CELSIUS = .5;
-/** A numeric sensor reports at most once a minute per property (D869). */
-var SENSOR_MIN_INTERVAL_MS = 6e4;
-/** `temperature-sensor` → `Alexa.TemperatureSensor` (TEMPERATURE_SENSOR). */
-var temperatureAdapter = {
-	cap: "temperature-sensor",
-	stateCaps: ["temperature-sensor"],
-	discoveryReads: [],
-	describe: () => ({
-		kind: "publish",
-		capabilities: [iface("Alexa.TemperatureSensor", "temperature")],
-		category: "TEMPERATURE_SENSOR"
-	}),
-	properties: (_cap, slice) => {
-		const p = TemperatureSensorStatusSchema.pick({ celsius: true }).safeParse(slice);
-		return p.success ? [{
-			namespace: "Alexa.TemperatureSensor",
-			name: "temperature",
-			value: {
-				value: Math.round(p.data.celsius * 10) / 10,
-				scale: "CELSIUS"
-			}
-		}] : [];
-	},
-	directives: [],
-	shaping: () => ({
-		deadband: TEMPERATURE_DEADBAND_CELSIUS,
-		minIntervalMs: SENSOR_MIN_INTERVAL_MS,
-		numericOf: numericValueField
-	})
-};
 /** `humidity-sensor` → `Alexa.HumiditySensor` (TEMPERATURE_SENSOR). */
 var humidityAdapter = {
 	cap: "humidity-sensor",
@@ -75052,6 +76783,11 @@ var BRIGHTNESS_DIRECTIVE = {
 	needsReachableDevice: true,
 	handle: (c) => handleSetBrightness(c.header, c.endpoint, c.payload, c.deps.brightnessController, c.identity)
 };
+/** An outlet (D875: its source says so, e.g. HA `device_class: outlet`) is a
+*  smart plug; every other switch is a SWITCH. */
+function switchCategory(device) {
+	return device.role === DeviceRole.Outlet ? "SMARTPLUG" : "SWITCH";
+}
 //#endregion
 //#region src/endpoints/adapters/index.ts
 var GENERIC_ADAPTERS = [
@@ -75059,6 +76795,7 @@ var GENERIC_ADAPTERS = [
 	contactAdapter,
 	motionAdapter,
 	presenceAdapter,
+	climateAdapter,
 	temperatureAdapter,
 	humidityAdapter,
 	{
@@ -75070,7 +76807,7 @@ var GENERIC_ADAPTERS = [
 			return {
 				kind: "publish",
 				capabilities: [iface("Alexa.PowerController", "powerState"), ...dimmable ? [iface("Alexa.BrightnessController", "brightness")] : []],
-				category: dimmable || device.type === "light" ? "LIGHT" : "SWITCH"
+				category: dimmable || device.type === "light" ? "LIGHT" : switchCategory(device)
 			};
 		},
 		properties: (capName, slice) => {
@@ -75116,12 +76853,19 @@ function shapingFor(capName, property) {
 function discoveryReadCaps(capNames) {
 	return [...new Set(GENERIC_ADAPTERS.filter((a) => capNames.includes(a.cap)).flatMap((a) => a.discoveryReads))];
 }
-/** A directive an adapter handles on a generic endpoint, by `Namespace/Name`. */
-function genericDirective(key) {
-	for (const adapter of GENERIC_ADAPTERS) {
-		const found = adapter.directives.find((d) => d.key === key);
-		if (found !== void 0) return found;
-	}
+/** Every directive an adapter declares for `Namespace/Name`, in registry order. */
+function genericDirectives(key) {
+	return GENERIC_ADAPTERS.flatMap((a) => a.directives.filter((d) => d.key === key));
+}
+/**
+* The directive that serves this endpoint: of the adapters declaring the key,
+* in registry order, the first that claims it (two caps may answer one key -
+* power on a switch and on a thermostat). Null = nobody claims it.
+*/
+async function resolveGenericDirective(context) {
+	const key = `${context.header.namespace}/${context.header.name}`;
+	for (const directive of genericDirectives(key)) if (directive.claims === void 0 || await directive.claims(context)) return directive;
+	return null;
 }
 /** Every directive key the registry handles. */
 var GENERIC_DIRECTIVE_KEYS = [...new Set(GENERIC_ADAPTERS.flatMap((a) => a.directives.map((d) => d.key)))];
@@ -75163,9 +76907,9 @@ function planGenericDevice(device) {
 		category
 	};
 }
-/** Device types this export may publish as a generic endpoint. A `thermostat`
-*  is listed so discovery can say WHY it is not published (no climate adapter
-*  yet, D869) instead of calling it a device with no mappable cap. */
+/** Device types this export may publish as a generic endpoint. `thermostat`
+*  (Home Assistant) and `climate` (an air conditioner, e.g. Gree) both carry
+*  the `climate-control` cap (D874). */
 var GENERIC_DEVICE_TYPES = [
 	"light",
 	"switch",
@@ -75174,11 +76918,13 @@ var GENERIC_DEVICE_TYPES = [
 	"lock",
 	"presence",
 	"thermostat",
+	"climate",
 	"cover",
 	"generic"
 ];
 function toEndpoint(input, plan) {
-	const name = input.name.trim();
+	const override = input.alexaName?.trim() ?? "";
+	const name = override.length > 0 ? override : input.name.trim();
 	return {
 		endpointId: `${input.deviceId}__dev`,
 		manufacturerName: "camstack",
@@ -75189,13 +76935,7 @@ function toEndpoint(input, plan) {
 		cookie: { stableId: input.stableId }
 	};
 }
-/** Why a climate device is withheld until its adapter exists. */
-var THERMOSTAT_SKIP_REASON = "thermostat: Alexa climate control (Alexa.ThermostatController) has no adapter yet - not published until it does (D869, P3)";
 function planGenericEndpoint(input) {
-	if (input.type === "thermostat" && input.capNames.includes("climate-control")) return {
-		kind: "skip",
-		reasons: [THERMOSTAT_SKIP_REASON]
-	};
 	const plan = planGenericDevice({
 		deviceId: input.deviceId,
 		type: input.type,
@@ -75211,6 +76951,74 @@ function planGenericEndpoint(input) {
 	return plan;
 }
 //#endregion
+//#region src/endpoints/alexa-name.ts
+/**
+* The per-device "Alexa name" (D875): what Alexa calls the device, when it
+* should not be the device's own name.
+*
+* Stored under {@link ALEXA_NAME_KEY} in this addon's per-device settings store
+* (D870) and used as the endpoint `friendlyName`. It never reaches the endpoint
+* id (`<deviceId>__dev`), so renaming updates the SAME Alexa device on the next
+* AddOrUpdateReport instead of creating a duplicate.
+*
+* Amazon's friendlyName rule (Alexa.Discovery objects, endpoint object): "Up
+* to 256 alphanumeric characters and spaces. Don't include special characters
+* or punctuation." Letters of any script count as alphanumeric, so an Italian
+* name keeps its accents. The validator rejects what Amazon would reject, with
+* a message the operator can act on.
+*/
+/** Per-device store key of the saved Alexa name. */
+var ALEXA_NAME_KEY = "alexaName";
+/** The device-settings form field key, namespaced per exporter (see the addon). */
+function alexaNameKey(deviceId) {
+	return `alexa:${deviceId}:alexaName`;
+}
+/** Letters (any script, with their combining marks), digits and spaces. */
+var ALLOWED_PATTERN = /^[\p{L}\p{M}\p{N} ]+$/u;
+/**
+* Validate an operator-typed Alexa name. Blank clears the override
+* (`name: null`, the device name is used).
+*/
+function validateAlexaName(raw) {
+	if (raw === null || raw === void 0) return {
+		ok: true,
+		name: null
+	};
+	if (typeof raw !== "string") return {
+		ok: false,
+		error: "The Alexa name must be text."
+	};
+	const name = raw.trim().replace(/\s+/g, " ");
+	if (name.length === 0) return {
+		ok: true,
+		name: null
+	};
+	if (name.length > 256) return {
+		ok: false,
+		error: `The Alexa name is ${name.length} characters; Amazon allows at most 256.`
+	};
+	if (!ALLOWED_PATTERN.test(name)) return {
+		ok: false,
+		error: "The Alexa name may contain only letters, digits and spaces (Amazon rejects punctuation and special characters)."
+	};
+	return {
+		ok: true,
+		name
+	};
+}
+var StoredNameSchema = string();
+/**
+* The saved Alexa name in a per-device store blob, or null (never saved, or a
+* stored value that no longer validates: the device name is used rather than
+* pushing a name Amazon would refuse).
+*/
+function readAlexaName(store) {
+	const parsed = StoredNameSchema.safeParse(store[ALEXA_NAME_KEY]);
+	if (!parsed.success) return null;
+	const check = validateAlexaName(parsed.data);
+	return check.ok ? check.name : null;
+}
+//#endregion
 //#region src/handlers/security-panel-arm-state.ts
 /**
 * The panel modes behind each Alexa arm state, PRIMARY first — the mirror of
@@ -75884,6 +77692,7 @@ async function buildEndpointsForExposedDevice(deviceId, deps) {
 			deviceId: parentInfo.id,
 			stableId: parentInfo.stableId,
 			name: parentInfo.name,
+			alexaName: deps.alexaName === void 0 ? null : await deps.alexaName(parentInfo.id),
 			type: String(device.type),
 			capNames: parentInfo.capNames,
 			role: parentInfo.role,
@@ -75942,11 +77751,12 @@ async function buildEndpointsForExposedDevice(deviceId, deps) {
 		return [];
 	});
 	const objectDetectionClasses = deps.objectDetection === void 0 ? [] : await deps.objectDetection(parentInfo.id);
+	const cameraName = (deps.alexaName === void 0 ? null : await deps.alexaName(parentInfo.id)) ?? parentInfo.name;
 	const out = [];
 	out.push(buildParentCameraEndpoint({
 		deviceId: parentInfo.id,
 		stableId: parentInfo.stableId,
-		friendlyName: parentInfo.name,
+		friendlyName: cameraName,
 		isDoorbell,
 		hasIntercom,
 		hasMotion,
@@ -75960,7 +77770,7 @@ async function buildEndpointsForExposedDevice(deviceId, deps) {
 		for (const detectionClass of classes) out.push(buildDetectionSensorEndpoint({
 			deviceId: parentInfo.id,
 			stableId: parentInfo.stableId,
-			cameraName: parentInfo.name,
+			cameraName,
 			detectionClass
 		}));
 	}
@@ -76454,6 +78264,36 @@ function validateInstanced(c, push) {
 	if (c.semantics.stateMappings !== void 0) validateStateMappings(c, c.semantics.stateMappings, push, validMode);
 }
 //#endregion
+//#region src/endpoints/validate-thermostat.ts
+var PROPERTIES = new Set([
+	"targetSetpoint",
+	"lowerSetpoint",
+	"upperSetpoint",
+	"thermostatMode"
+]);
+var MODES = new Set([
+	"AUTO",
+	"COOL",
+	"HEAT",
+	"ECO",
+	"OFF"
+]);
+function validateThermostat(c, push) {
+	const supported = new Set((c.properties?.supported ?? []).map((p) => p.name));
+	for (const name of supported) if (!PROPERTIES.has(name)) push(`properties.supported ${name} is not a thermostat property`);
+	if (!supported.has("thermostatMode")) push("properties.supported must include thermostatMode");
+	if (supported.has("lowerSetpoint") !== supported.has("upperSetpoint")) push("lowerSetpoint and upperSetpoint are declared together");
+	if (!supported.has("targetSetpoint") && !supported.has("lowerSetpoint")) push("at least one setpoint property is required");
+	const modes = c.configuration?.["supportedModes"];
+	if (!Array.isArray(modes) || modes.length === 0) push("configuration.supportedModes must list at least one mode");
+	else {
+		for (const mode of modes) if (typeof mode !== "string" || !MODES.has(mode)) push(`supportedModes ${String(mode)} is not AUTO, COOL, HEAT, ECO or OFF`);
+		if (new Set(modes).size !== modes.length) push("supportedModes values must be unique");
+	}
+	const scheduling = c.configuration?.["supportsScheduling"];
+	if (scheduling !== void 0 && typeof scheduling !== "boolean") push("configuration.supportsScheduling must be a boolean");
+}
+//#endregion
 //#region src/endpoints/validate-endpoint.ts
 /**
 * Interfaces this skill may declare, with the version Amazon documents. An
@@ -76477,6 +78317,7 @@ var ALLOWED_INTERFACE_VERSIONS = {
 	"Alexa.RangeController": "3",
 	"Alexa.SecurityPanelController": "3",
 	"Alexa.LockController": "3",
+	"Alexa.ThermostatController": "3.1",
 	"Alexa.SmartVision.SnapshotProvider": "1.1",
 	"Alexa.SmartVision.ObjectDetectionSensor": "1.0",
 	"Alexa.DataController": "1.0"
@@ -76516,6 +78357,8 @@ var DISPLAY_CATEGORIES = new Set([
 	"SMARTLOCK",
 	"INTERIOR_BLIND",
 	"EXTERIOR_BLIND",
+	"THERMOSTAT",
+	"AIR_CONDITIONER",
 	"DOOR",
 	"GATE",
 	"GARAGE_DOOR",
@@ -76594,6 +78437,7 @@ function validateCapability(endpointId, c, out, declared) {
 		}
 	}
 	validateInstanced(c, push);
+	if (c.interface === "Alexa.ThermostatController") validateThermostat(c, push);
 	if (c.interface === "Alexa.SmartVision.ObjectDetectionSensor") validateObjectDetection(c, push);
 	if (c.interface === "Alexa.DataController") validateDataController(c, declared, push);
 	if (c.interface === "Alexa.SmartVision.SnapshotProvider") {
@@ -78524,20 +80368,27 @@ async function dispatchParsedDirective(rawBody, deps, callerIdentity) {
 			status: 200,
 			body: await handleSessionDisconnected(header, endpoint, payload, deps.rtcSession, callerIdentity)
 		};
-		const adapterDirective = genericDirective(key);
-		if (adapterDirective !== void 0 && endpoint !== void 0) {
+		if (genericDirectives(key).length > 0 && endpoint !== void 0) {
 			const target = parseCameraEndpointId(endpoint.endpointId);
-			if (target.kind === "generic") return {
-				status: 200,
-				body: await adapterDirective.handle({
+			if (target.kind === "generic") {
+				const directiveContext = {
 					header,
 					endpoint,
 					payload,
 					deviceId: target.deviceId,
 					deps,
 					identity: callerIdentity
-				})
-			};
+				};
+				const adapterDirective = await resolveGenericDirective(directiveContext);
+				if (adapterDirective === null) return {
+					status: 200,
+					body: errorEnvelope(header, "INVALID_DIRECTIVE", `${key}: no handler for this endpoint`)
+				};
+				return {
+					status: 200,
+					body: await adapterDirective.handle(directiveContext)
+				};
+			}
 		}
 		if (key === "Alexa.ModeController/SetMode") return {
 			status: 200,
@@ -82680,6 +84531,7 @@ var SUPPORTED_KINDS = [
 	DeviceType.Lock,
 	DeviceType.Presence,
 	DeviceType.Thermostat,
+	DeviceType.Climate,
 	DeviceType.Cover,
 	DeviceType.Generic
 ];
@@ -82818,6 +84670,10 @@ var ExportAlexaAddon = class extends BaseAddon {
 					ctx: this.ctx,
 					logger: this.ctx.logger
 				},
+				climateController: {
+					ctx: this.ctx,
+					logger: this.ctx.logger
+				},
 				coverController: {
 					ctx: this.ctx,
 					logger: this.ctx.logger,
@@ -83074,6 +84930,7 @@ var ExportAlexaAddon = class extends BaseAddon {
 			logger: this.ctx.logger,
 			snapshots: this.config.snapshots,
 			...this.config.detectionSensors ? { detectionClasses: async (id) => effectiveSensorClasses(await classesOf(id), parseSensorSelection(await vision.readPrefs(id))) } : {},
+			alexaName: async (id) => readAlexaName(await vision.readPrefs(id)),
 			...this.config.objectDetection ? { objectDetection: async (id) => vision.buildClasses(id, await classesOf(id)) } : {}
 		});
 	}
@@ -83641,12 +85498,28 @@ var ExportAlexaAddon = class extends BaseAddon {
 						value: enabled,
 						immediate: true
 					},
+					await this.alexaNameField(deviceId, enabledKey),
 					...kind === "camera" ? this.cameraOnlyExportFields(deviceId, settings, enabledKey) : [],
 					...kind === "camera" ? await this.cameraDetectionFields(deviceId, enabledKey) : []
 				]
 			}]
 		};
 	}
+	/** D875: the "Alexa name" field, with the validation error of the saved value. */
+	async alexaNameField(deviceId, enabledKey) {
+		const saved = readAlexaName(await this.vision.readPrefs(deviceId));
+		return {
+			type: "text",
+			key: alexaNameKey(deviceId),
+			label: "Alexa name",
+			description: `What Alexa calls this device. Leave empty to use the device name. Letters, digits and spaces only (no punctuation), up to 256 characters. Renaming updates the same Alexa device; it does not create a duplicate.`,
+			value: saved ?? "",
+			showWhen: {
+				field: enabledKey,
+				equals: true
+			}
+		};
+	}
 	/**
 	* The camera's detection fields: which classes become Alexa sensors (D778;
 	* only the classes its pipeline produces are offered) and its object
@@ -83668,6 +85541,24 @@ var ExportAlexaAddon = class extends BaseAddon {
 		})];
 	}
 	/**
+	* D875: save the Alexa name from a device-settings patch. A name Amazon would
+	* refuse throws BEFORE anything is written, so the form shows the reason and
+	* the old name stays. True when the saved name changed.
+	*/
+	async applyAlexaNamePatch(deviceId, patch) {
+		const key = alexaNameKey(deviceId);
+		if (!(key in patch)) return false;
+		const check = validateAlexaName(patch[key]);
+		if (!check.ok) throw new Error(`export-alexa: ${check.error}`);
+		if (readAlexaName(await this.vision.readPrefs(deviceId)) === check.name) return false;
+		await this.vision.writePrefs(deviceId, { [ALEXA_NAME_KEY]: check.name ?? void 0 });
+		this.ctx.logger.info("export-alexa: Alexa name saved", {
+			tags: { deviceId },
+			meta: { name: check.name }
+		});
+		return true;
+	}
+	/**
 	* Persist the camera's detection preferences from a device-settings patch
 	* into this addon's per-device store. True when anything changed — the
 	* camera's Alexa shape then needs a reconcile.
@@ -83732,6 +85623,7 @@ var ExportAlexaAddon = class extends BaseAddon {
 		const current = this.findEntry(deviceId);
 		const wasEnabled = current !== null;
 		const prefsChanged = await this.applyDetectionPrefsPatch(deviceId, patch);
+		const nameChanged = await this.applyAlexaNamePatch(deviceId, patch);
 		const enabledKey = `alexa:${deviceId}:enabled`;
 		const streamPreferenceKey = `alexa:${deviceId}:streamPreference`;
 		const allowTranscodeKey = `alexa:${deviceId}:allowTranscode`;
@@ -83757,6 +85649,12 @@ var ExportAlexaAddon = class extends BaseAddon {
 		const currentAllow = current?.settings?.allowTranscode !== false;
 		await this.patchEntrySettings(deviceId, nextSettings);
 		const sourceChanged = currentPref !== streamPreference || currentAllow !== allowTranscode;
+		if (nameChanged && !sourceChanged) this.requireSyncEngine().pushDevice(deviceId).catch((err) => {
+			this.ctx.logger.warn("export-alexa: push after an Alexa name change failed", {
+				tags: { deviceId },
+				meta: { error: errMsg(err) }
+			});
+		});
 		if (prefsChanged && !sourceChanged) this.requireSyncEngine().reconcileDevice(deviceId).catch((err) => {
 			this.ctx.logger.warn("export-alexa: re-sync after a detection preference change failed", {
 				tags: { deviceId },