@camstack/addon-export-alexa 1.2.144 → 1.2.145

package/dist/export-alexa.addon.mjs

@@ -5393,7 +5393,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-DRqxtc0C.mjs
+//#region ../types/dist/sleep-bwsTj221.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -6644,7 +6644,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 +6667,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);
 		},
@@ -7500,7 +7499,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 +7575,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
@@ -8188,7 +8280,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 +8549,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 +8629,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 +12090,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
@@ -16140,6 +16234,28 @@ id: union([string(), number()]) }), {
 	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()
+});
+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"
+});
 /**
 * `keychain` — the hub's encrypted store of secret values (D787).
 *
@@ -16681,6 +16797,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({
@@ -53138,7 +53264,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 +53305,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 +55151,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 +55219,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
@@ -64114,6 +64261,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",
@@ -64510,6 +64663,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",
@@ -67894,6 +68053,18 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"storageAdmin.dropCollection": {
+		capName: "storage-admin",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"storageAdmin.listTables": {
+		capName: "storage-admin",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"storageEvictable.evict": {
 		capName: "storage-evictable",
 		capScope: "system",
@@ -73998,6 +74169,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 +74991,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 +75737,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 +75746,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 +76044,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 +76056,7 @@ var GENERIC_ADAPTERS = [
 	contactAdapter,
 	motionAdapter,
 	presenceAdapter,
+	climateAdapter,
 	temperatureAdapter,
 	humidityAdapter,
 	{
@@ -75070,7 +76068,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 +76114,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 +76168,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 +76179,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 +76196,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 +76212,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 +76953,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 +77012,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 +77031,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 +77525,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 +77578,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 +77618,8 @@ var DISPLAY_CATEGORIES = new Set([
 	"SMARTLOCK",
 	"INTERIOR_BLIND",
 	"EXTERIOR_BLIND",
+	"THERMOSTAT",
+	"AIR_CONDITIONER",
 	"DOOR",
 	"GATE",
 	"GARAGE_DOOR",
@@ -76594,6 +77698,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 +79629,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 +83792,7 @@ var SUPPORTED_KINDS = [
 	DeviceType.Lock,
 	DeviceType.Presence,
 	DeviceType.Thermostat,
+	DeviceType.Climate,
 	DeviceType.Cover,
 	DeviceType.Generic
 ];
@@ -82818,6 +83931,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 +84191,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 +84759,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 +84802,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 +84884,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 +84910,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 },