@camstack/addon-import-alexa 0.2.188 → 0.2.189

package/dist/addon.js

@@ -6044,7 +6044,7 @@ function number(params) {
 	return /* @__PURE__ */ _coercedNumber(ZodNumber, params);
 }
 //#endregion
-//#region ../types/dist/sleep-9TIHFj1w.mjs
+//#region ../types/dist/sleep-DEZaLbiu.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -6853,6 +6853,12 @@ function projectStore(store, perNodeKeys, nodeId) {
 	}
 	return out;
 }
+/** Every scope, in the order the guard and the docs list them. */
+var SCOPED_SETTINGS_SCOPES = [
+	"cluster",
+	"device-defaults",
+	"node"
+];
 /**
 * The address of one keychain value: `secret://<owner>/<scope>/<fieldPath>`.
 *
@@ -7744,6 +7750,13 @@ var BaseAddon = class {
 	*/
 	secretStatePaths = [];
 	_addonSecretTree = null;
+	/**
+	* D986 M4: the scoped schemas this addon declared, resolved once per capability
+	* (`loadScopedSchemas`) so the sync readers (`perNodeKeys`, the secret tree, the restart check)
+	* see them. Empty until loaded: the readers then fall back to {@link globalSettingsSchema}.
+	*/
+	_scopedByCap = /* @__PURE__ */ new Map();
+	_nodeKeysByCap = /* @__PURE__ */ new Map();
 	_deviceSecretTree = null;
 	/** Refs the last resolved config pointed at — a change to one re-resolves. */
 	_configSecretRefs = /* @__PURE__ */ new Set();
@@ -7813,6 +7826,7 @@ var BaseAddon = class {
 			this._ctx = context;
 			this._secretSettings = null;
 		}
+		await this.loadScopedSchemas();
 		await this.resolveConfig();
 		if (secrets !== void 0) this._secretChangeUnsub = secrets.onChange((ref) => {
 			if (this._configSecretRefs.has(ref)) this.scheduleSecretReresolve(SECRET_CHANGE_DEBOUNCE_MS);
@@ -7822,6 +7836,7 @@ var BaseAddon = class {
 		const normalized = normalizeAddonInitResult(result);
 		const providers = normalized && "providers" in normalized && normalized.providers ? normalized.providers : [];
 		this._registeredCapNames = providers.map((p) => p.capability.name);
+		await this.loadScopedSchemas();
 		return normalized;
 	}
 	/**
@@ -7910,6 +7925,16 @@ var BaseAddon = class {
 	schema(schema) {
 		return schema;
 	}
+	/**
+	* The capability names whose scoped settings schemas ({@link clusterSettingsSchema},
+	* {@link nodeSettingsSchema}, {@link deviceDefaultsSchema}) this addon declares. Read BEFORE
+	* `onInitialize`, when the providers it registers are not known yet: the first config resolve
+	* must already know which keys are per node. Names the providers register at init are added
+	* once known.
+	*/
+	scopedSettingsCapabilities() {
+		return [];
+	}
 	/** Override to provide global-level settings UI schema. */
 	globalSettingsSchema(_cap) {
 		return null;
@@ -7953,7 +7978,8 @@ var BaseAddon = class {
 		return [];
 	}
 	async getGlobalSettings(overlay, cap, nodeId) {
-		const schema = this.globalSettingsSchema(cap);
+		await this.loadScopedSchemas(cap);
+		const schema = this.globalSettingsSchema(cap) ?? this.scopedFormSchema(cap);
 		if (!schema) return { sections: [] };
 		const projected = await this.readRawProjectedStore(nodeId, cap);
 		return hydrateSchema(schema, overlay ? await this.overlayKeepingMarkers(projected, overlay) : projected, { inlineSecretsAsViews: true });
@@ -8084,6 +8110,7 @@ var BaseAddon = class {
 	* resolved blob back is a no-op for every unchanged secret.
 	*/
 	async resolveGlobalStore(nodeId, cap) {
+		await this.loadScopedSchemas(cap);
 		const raw = await this._ctx?.settings?.readAddonStore() ?? {};
 		return this.projectForNode(raw, nodeId, cap);
 	}
@@ -8094,6 +8121,7 @@ var BaseAddon = class {
 	}
 	/** The PROJECTED store with its markers — the form hydrate only (D798). */
 	async readRawProjectedStore(nodeId, cap) {
+		await this.loadScopedSchemas(cap);
 		const raw = await this.rawSettings()?.readAddonStore() ?? {};
 		return this.projectForNode(raw, nodeId, cap);
 	}
@@ -8196,6 +8224,7 @@ var BaseAddon = class {
 		await this.applyGlobalPatch(patch, nodeId);
 	}
 	async applyGlobalPatch(barePatch, nodeId) {
+		await this.loadScopedSchemas();
 		const keys = this.perNodeKeys();
 		const localNode = normalizeNodeId(this._ctx?.kernel?.localNodeId);
 		const target = normalizeNodeId(nodeId ?? this._ctx?.kernel?.localNodeId);
@@ -8209,7 +8238,8 @@ var BaseAddon = class {
 		await this.resolveConfig();
 		await this.onConfigChanged();
 		this.emitLifecycle(EventCategory.AddonUpdated, { level: "global" });
-		this.maybeAutoRestart(Object.keys(barePatch), this.globalSettingsSchema());
+		const legacy = this.globalSettingsSchema();
+		this.maybeAutoRestart(Object.keys(barePatch), [...legacy === null ? [] : [legacy], ...this.loadedScopedSchemas().map((entry) => entry.schema)]);
 	}
 	/**
 	* The set of field keys the global settings schema declares `perNode: true`
@@ -8217,14 +8247,67 @@ var BaseAddon = class {
 	* declarations). Empty set ⇒ every per-node code path is bypassed and the
 	* settings API behaves exactly like the legacy node-agnostic one.
 	*/
-	_perNodeKeysCache = /* @__PURE__ */ new Map();
+	/**
+	* Load the scoped schemas of every capability this addon declares (the override and the
+	* providers registered at init, plus `extraCap`) that is not loaded yet, then drop what was
+	* derived from the previous set. Idempotent.
+	*/
+	async loadScopedSchemas(extraCap) {
+		const caps = new Set([
+			...this.scopedSettingsCapabilities(),
+			...this._registeredCapNames,
+			...extraCap === void 0 ? [] : [extraCap]
+		]);
+		let added = false;
+		for (const cap of caps) {
+			if (this._scopedByCap.has(cap)) continue;
+			const loaded = [];
+			for (const scope of SCOPED_SETTINGS_SCOPES) {
+				const schema = await this.getScopedSettingsSchema(scope, cap);
+				if (schema !== null) loaded.push({
+					scope,
+					schema
+				});
+			}
+			this._scopedByCap.set(cap, loaded);
+			added = true;
+		}
+		if (!added) return;
+		this._nodeKeysByCap = /* @__PURE__ */ new Map();
+		this._addonSecretTree = null;
+	}
+	/**
+	* The form the settings API serves while an addon declares no {@link globalSettingsSchema}: the
+	* sections of its scoped schemas, so dropping the old hook does not blank the form.
+	*/
+	scopedFormSchema(cap) {
+		const byId = /* @__PURE__ */ new Map();
+		for (const entry of this.loadedScopedSchemas(cap)) for (const section of entry.schema.sections) if (!byId.has(section.id)) byId.set(section.id, section);
+		return byId.size === 0 ? null : { sections: [...byId.values()] };
+	}
+	/** Every loaded scoped schema of `cap`, or of every loaded capability. */
+	loadedScopedSchemas(cap) {
+		if (cap !== void 0) return this._scopedByCap.get(cap) ?? [];
+		return [...this._scopedByCap.values()].flat();
+	}
+	/**
+	* The field keys that are stored per node: every field of a {@link nodeSettingsSchema}, plus
+	* the fields the legacy {@link globalSettingsSchema} still marks `perNode: true`. Derived once
+	* per `cap` argument and memoized (schemas are static declarations). Empty set ⇒ every
+	* per-node code path is bypassed and the settings API behaves like the node-agnostic one.
+	* Call {@link loadScopedSchemas} first (the async seams do).
+	*/
 	perNodeKeys(cap) {
 		const cacheKey = cap ?? "";
-		const cached = this._perNodeKeysCache.get(cacheKey);
+		const cached = this._nodeKeysByCap.get(cacheKey);
 		if (cached) return cached;
-		const schema = this.globalSettingsSchema(cap);
-		const keys = new Set(schema ? schema.sections.flatMap((section) => collectPerNodeFieldKeys(section.fields)) : []);
-		this._perNodeKeysCache.set(cacheKey, keys);
+		const legacy = this.globalSettingsSchema(cap);
+		const keys = new Set(legacy ? legacy.sections.flatMap((section) => collectPerNodeFieldKeys(section.fields)) : []);
+		for (const { scope, schema } of this.loadedScopedSchemas(cap)) {
+			if (scope !== "node") continue;
+			for (const section of schema.sections) for (const key of collectValueFieldKeys(section.fields)) keys.add(key);
+		}
+		this._nodeKeysByCap.set(cacheKey, keys);
 		return keys;
 	}
 	/**
@@ -8234,10 +8317,9 @@ var BaseAddon = class {
 	* time to return its response before the addon is torn down and
 	* re-initialised by `AddonRegistryService.restartAddon`.
 	*/
-	maybeAutoRestart(patchKeys, schema) {
-		if (!schema) return;
+	maybeAutoRestart(patchKeys, schemas) {
 		const restartKeys = /* @__PURE__ */ new Set();
-		for (const section of schema.sections) for (const field of section.fields) {
+		for (const schema of schemas) for (const section of schema.sections) for (const field of section.fields) {
 			if (field.type === "separator" || field.type === "info") continue;
 			if (field.requiresRestart) restartKeys.add(field.key);
 		}
@@ -8433,12 +8515,14 @@ var BaseAddon = class {
 	* here, in the addon's own process, so the hub keeps no copy of it.
 	*/
 	async getDeclaredSettingsKeys() {
+		await this.loadScopedSchemas();
 		return { keys: [...this.declaredKeySet()].toSorted() };
 	}
 	declaredKeySet() {
 		const keys = new Set(Object.keys(this.defaults));
 		const schema = this.globalSettingsSchema();
 		if (schema) for (const section of schema.sections) for (const key of collectFieldKeys(section.fields)) keys.add(key);
+		for (const { schema: scoped } of this.loadedScopedSchemas()) for (const section of scoped.sections) for (const key of collectFieldKeys(section.fields)) keys.add(key);
 		for (const key of this._declaredStateKeys) keys.add(key);
 		for (const path of this.secretStatePaths) {
 			const root = path.split(/[.[]/, 1)[0];
@@ -8534,7 +8618,11 @@ var BaseAddon = class {
 	}
 	/** The addon store's secret tree: schema fields by TYPE, plus `secretStatePaths`. */
 	addonSecretTree() {
-		this._addonSecretTree ??= mergeSecretStatePaths(secretTreeFromSchema(this.globalSettingsSchema()), this.secretStatePaths);
+		if (this._addonSecretTree === null) {
+			const tree = new Map(secretTreeFromSchema(this.globalSettingsSchema()));
+			for (const { schema } of this.loadedScopedSchemas()) for (const [key, node] of secretTreeFromSchema(schema)) tree.set(key, node);
+			this._addonSecretTree = mergeSecretStatePaths(tree, this.secretStatePaths);
+		}
 		return this._addonSecretTree;
 	}
 	deviceSecretTree() {
@@ -8784,6 +8872,23 @@ function dropPerNodeFields(fields) {
 	}
 	return kept;
 }
+/** The keys of the value-holding fields, recursing into layout containers. */
+function collectValueFieldKeys(fields) {
+	const collected = [];
+	for (const field of fields) {
+		if (field.type === "group") {
+			collected.push(...collectValueFieldKeys(field.fields));
+			continue;
+		}
+		if (field.type === "sub-tabs") {
+			for (const tab of field.tabs) collected.push(...collectValueFieldKeys(tab.fields));
+			continue;
+		}
+		if (field.type === "separator" || field.type === "info") continue;
+		if ("key" in field && typeof field.key === "string") collected.push(field.key);
+	}
+	return collected;
+}
 function collectFieldKeys(fields) {
 	const collected = [];
 	for (const field of fields) {
@@ -13576,12 +13681,22 @@ var RecordIntegrationInstances = class {
 		...this.hooks.description,
 		mintsId: true
 	};
-	instanceFormSchema = async ({ id }) => this.hooks.formSchema(id);
+	/**
+	* The record an id names. A caller holding the `integrations` registry id (the Integrations
+	* page) reaches a kind whose body links to it through `integrationId`; an id that is itself a
+	* record id answers as it is. An id that names nothing comes back unchanged.
+	*/
+	async resolveRecordId(id) {
+		if (await this.handle.get(id) !== null) return id;
+		const linked = (await this.handle.query({ limit: INSTANCES_LIST_MAX })).records.find((record) => record.data["integrationId"] === id);
+		return linked === void 0 ? id : linked.id;
+	}
+	instanceFormSchema = async ({ id }) => this.hooks.formSchema(id === null ? null : await this.resolveRecordId(id));
 	listInstances = async () => {
 		return (await this.handle.query({ limit: INSTANCES_LIST_MAX })).records.map((record) => this.viewOf(record));
 	};
 	getInstance = async ({ id }) => {
-		const record = await this.handle.get(id);
+		const record = await this.handle.get(await this.resolveRecordId(id));
 		return record === null ? null : this.viewOf(record);
 	};
 	/** Insert ONE row (`ifRev: 0`: an existing id is refused, never overwritten). */
@@ -13598,7 +13713,8 @@ var RecordIntegrationInstances = class {
 		await this.hooks.onChanged?.(minted, "created");
 		return { id: minted };
 	};
-	updateInstance = async ({ id, name, values }) => {
+	updateInstance = async ({ id: askedId, name, values }) => {
+		const id = await this.resolveRecordId(askedId);
 		const patch = {};
 		for (const [key, value] of Object.entries(values)) {
 			if (value === void 0) continue;
@@ -13633,7 +13749,10 @@ var RecordIntegrationInstances = class {
 			status: "unsupported",
 			error: "This integration declares no connection test"
 		};
-		return this.hooks.test(input);
+		return this.hooks.test(input.id === null ? input : {
+			...input,
+			id: await this.resolveRecordId(input.id)
+		});
 	};
 	/** The flat provider object to hand to `registerProvider`. */
 	toProvider() {
@@ -98407,7 +98526,12 @@ var AMAZON_DOMAIN_BY_COUNTRY = {
 	BR: "amazon.com.br",
 	MX: "amazon.com.mx"
 };
-/** Hand-written connection form for the broker/integration creation UI. */
+/**
+* The connection form: what the operator chooses (region, poll cadence). The cookie blob and the
+* refresh token are login STATE minted by the in-house sign-in; they live on the record as
+* keychain secrets, are written by that flow and are never part of this form, so a form save
+* cannot overwrite or clear them.
+*/
 function buildConnectionFormSchema() {
 	return { sections: [{
 		id: "alexa-account",
@@ -98416,45 +98540,26 @@ function buildConnectionFormSchema() {
 		description: "Sign in with your Amazon account to link it. This is an unofficial integration: Amazon can change or break it without notice, and it may violate Amazon ToS. State is polled, not pushed.",
 		descriptionKey: "import-alexa:connection.s_alexa-account.description",
 		columns: 1,
-		fields: [
-			{
-				type: "select",
-				key: "amazonDomain",
-				label: "Amazon domain (region)",
-				labelKey: "import-alexa:connection.s_alexa-account.amazonDomain.label",
-				options: AMAZON_DOMAINS.map((value) => ({
-					value,
-					label: value
-				})),
-				default: "amazon.com",
-				defaultByCountry: AMAZON_DOMAIN_BY_COUNTRY
-			},
-			{
-				type: "password",
-				key: "cookie",
-				label: "Cookie blob (filled by the sign-in)",
-				labelKey: "import-alexa:connection.s_alexa-account.cookie.label",
-				showToggle: true,
-				filledBySignIn: true
-			},
-			{
-				type: "password",
-				key: "refreshToken",
-				label: "Refresh token (alternative to the sign-in)",
-				labelKey: "import-alexa:connection.s_alexa-account.refreshToken.label",
-				showToggle: true,
-				filledBySignIn: true
-			},
-			{
-				type: "number",
-				key: "pollIntervalMs",
-				label: "State poll interval (ms)",
-				labelKey: "import-alexa:connection.s_alexa-account.pollIntervalMs.label",
-				min: 15e3,
-				max: 36e5,
-				default: 6e4
-			}
-		]
+		fields: [{
+			type: "select",
+			key: "amazonDomain",
+			label: "Amazon domain (region)",
+			labelKey: "import-alexa:connection.s_alexa-account.amazonDomain.label",
+			options: AMAZON_DOMAINS.map((value) => ({
+				value,
+				label: value
+			})),
+			default: "amazon.com",
+			defaultByCountry: AMAZON_DOMAIN_BY_COUNTRY
+		}, {
+			type: "number",
+			key: "pollIntervalMs",
+			label: "State poll interval (ms)",
+			labelKey: "import-alexa:connection.s_alexa-account.pollIntervalMs.label",
+			min: 15e3,
+			max: 36e5,
+			default: 6e4
+		}]
 	}] };
 }
 //#endregion
@@ -142819,6 +142924,13 @@ var ECHO_REREAD_MS = 1500;
 /** After a 429 the account is left alone for this long, doubling up to the cap. */
 var ECHO_RATE_BACKOFF_BASE_MS = 3e4;
 var ECHO_RATE_BACKOFF_MAX_MS = 5 * 6e4;
+/**
+* A command (volume, play, Do Not Disturb) that has not started within this, or not
+* finished, is answered with an error instead of running minutes late.
+*/
+var ECHO_COMMAND_DEADLINE_MS = 12e3;
+/** A poll read is stale after this; it is dropped from the queue rather than sent late. */
+var ECHO_READ_DEADLINE_MS = 25e3;
 //#endregion
 //#region src/alexa-broker-provider.ts
 /**
@@ -144019,6 +144131,10 @@ var AlexaEchoDevice = class extends BaseDevice {
 	failureLogged = false;
 	volumeFailureLogged = false;
 	health = "ok";
+	/** The last level this device asked Amazon for, and when; a step starts from it until a read is newer. */
+	lastSet = null;
+	/** When the read that produced the current media-player slice began. */
+	polledFrom = 0;
 	constructor(ctx) {
 		const persisted = alexaEchoDeviceSchema.parse(ctx.persistedConfig ?? {});
 		super(ctx, alexaEchoDeviceSchema, { type: DeviceType.MediaPlayer });
@@ -144090,7 +144206,10 @@ var AlexaEchoDevice = class extends BaseDevice {
 		}
 		const deviceType = this.amazonDeviceType !== "" ? this.amazonDeviceType : listed?.deviceType ?? "";
 		try {
-			const fromPlayer = mapPlayerInfoToStatus(await session.playerState(this.serial, deviceType), {
+			const readStartedAt = Date.now();
+			const info = await session.playerState(this.serial, deviceType, this.id);
+			this.polledFrom = readStartedAt;
+			const fromPlayer = mapPlayerInfoToStatus(info, {
 				online: true,
 				now: Date.now()
 			});
@@ -144158,16 +144277,28 @@ var AlexaEchoDevice = class extends BaseDevice {
 		});
 	}
 	async command(command) {
-		await this.session().npCommand(this.serial, command);
+		await this.session().npCommand(this.serial, command, this.id);
+		this.rereadSoon();
+	}
+	async sendVolume(level) {
+		this.lastSet = {
+			level,
+			at: Date.now()
+		};
+		await this.session().setVolume(this.serial, level, this.id);
 		this.rereadSoon();
 	}
-	/** Amazon has no step command: move from the last known level, refuse when there is none. */
+	/**
+	* Amazon has no step command: move from the level we last SET when no read since
+	* is newer (a polled level lags the command), else the polled one; refuse when
+	* there is none.
+	*/
 	async stepVolume(delta) {
-		const level = this.runtimeState.getCapState("media-player")?.volumeLevel;
+		const polled = this.runtimeState.getCapState("media-player")?.volumeLevel;
+		const set = this.lastSet;
+		const level = set !== null && set.at >= this.polledFrom ? set.level : polled;
 		if (level === null || level === void 0) throw new Error("the Echo volume is not known yet");
-		const next = Math.max(0, Math.min(100, level + delta));
-		await this.session().setVolume(this.serial, next);
-		this.rereadSoon();
+		await this.sendVolume(Math.max(0, Math.min(100, level + delta)));
 	}
 	registerMediaPlayer() {
 		this.ctx.registerNativeCap(mediaPlayerCapability, {
@@ -144176,10 +144307,7 @@ var AlexaEchoDevice = class extends BaseDevice {
 			pause: () => this.command("pause"),
 			next: () => this.command("next"),
 			previous: () => this.command("previous"),
-			setVolume: async ({ volumeLevel }) => {
-				await this.session().setVolume(this.serial, Math.round(volumeLevel));
-				this.rereadSoon();
-			},
+			setVolume: async ({ volumeLevel }) => this.sendVolume(Math.round(volumeLevel)),
 			stop: async () => unsupported("stop"),
 			turnOn: async () => unsupported("power"),
 			turnOff: async () => unsupported("power"),
@@ -144199,7 +144327,7 @@ var AlexaEchoDevice = class extends BaseDevice {
 		this.ctx.registerNativeCap(doNotDisturbCapability, {
 			getStatus: async () => this.runtimeState.getCapState("do-not-disturb") ?? COLD_DND,
 			setEnabled: async ({ enabled }) => {
-				await this.session().setDnd(this.serial, enabled);
+				await this.session().setDnd(this.serial, enabled, this.id);
 				this.runtimeState.setCapState("do-not-disturb", {
 					enabled,
 					lastChangedAt: Date.now()
@@ -144301,15 +144429,7 @@ function buildAlexaInstances(records, deps) {
 		},
 		configured: isAlexaBodyConfigured,
 		onChanged: deps.onChanged,
-		test: async ({ id, values }) => {
-			if (["cookie", "refreshToken"].some((key) => {
-				const v = values[key];
-				return typeof v === "string" && v.length > 0 && v !== "__camstack_redacted__";
-			})) return {
-				success: true,
-				status: "inconclusive",
-				error: "Save the account to check the sign-in"
-			};
+		test: async ({ id }) => {
 			const info = id === null ? null : deps.infoOf(id);
 			if (info === null) return {
 				success: false,
@@ -144609,6 +144729,9 @@ function scrubSecrets(text, secrets) {
 }
 //#endregion
 //#region src/speak/broker-echo.ts
+function withDevice(deviceId) {
+	return deviceId === void 0 ? {} : { deviceId };
+}
 var BrokerEcho = class {
 	deps;
 	currentState = "starting";
@@ -144754,29 +144877,29 @@ var BrokerEcho = class {
 		}
 	}
 	/** The raw player state of one Echo. Throws on any failure, a 429 included: never an empty answer. */
-	async playerState(serial, deviceType) {
+	async playerState(serial, deviceType, deviceId) {
 		await this.requireReady();
 		return this.limited(async () => parsePlayerState(await this.deps.worker.request({
 			op: "player_state",
 			serial,
 			deviceType
-		})));
+		}, withDevice(deviceId))));
 	}
-	async npCommand(serial, command) {
+	async npCommand(serial, command, deviceId) {
 		await this.requireReady();
 		await this.limited(() => this.deps.worker.request({
 			op: "np_command",
 			serial,
 			command
-		}));
+		}, withDevice(deviceId)));
 	}
-	async setVolume(serial, level) {
+	async setVolume(serial, level, deviceId) {
 		await this.requireReady();
 		await this.limited(() => this.deps.worker.request({
 			op: "set_volume",
 			serial,
 			level
-		}));
+		}, withDevice(deviceId)));
 	}
 	/** Do Not Disturb of every device of the account, by serial, in one call. */
 	async dndState() {
@@ -144788,13 +144911,13 @@ var BrokerEcho = class {
 		await this.requireReady();
 		return this.limited(async () => parseDeviceVolumes(await this.deps.worker.request({ op: "device_volumes" })));
 	}
-	async setDnd(serial, enabled) {
+	async setDnd(serial, enabled, deviceId) {
 		await this.requireReady();
 		await this.limited(() => this.deps.worker.request({
 			op: "set_dnd",
 			serial,
 			enabled
-		}));
+		}, withDevice(deviceId)));
 	}
 	async requireReady() {
 		if (!await this.ensureReady()) throw new Error(this.notReadyReason());
@@ -145380,6 +145503,28 @@ function resolveAlexaWorkerScript(fromModuleUrl = require("url").pathToFileURL(_
 * A crash restarts the process until the same bound CrashSupervisor uses,
 * then requests fail instead of looping.
 */
+var READ_OPS = new Set([
+	"player_state",
+	"device_volumes",
+	"dnd_state",
+	"devices",
+	"session_status"
+]);
+function coalesceKey(request) {
+	switch (request.op) {
+		case "set_volume":
+		case "player_state": return `${request.op}:${request.serial}`;
+		case "device_volumes":
+		case "dnd_state":
+		case "devices":
+		case "session_status": return request.op;
+		default: return null;
+	}
+}
+function defaultDeadlineMs(request) {
+	if (request.op === "set_volume" || request.op === "np_command" || request.op === "set_dnd") return ECHO_COMMAND_DEADLINE_MS;
+	if (READ_OPS.has(request.op) && request.op !== "devices" && request.op !== "session_status") return ECHO_READ_DEADLINE_MS;
+}
 /** Pure: a new timestamp list, never a mutated one. */
 function recordWorkerCrash(times, now, windowMs, maxCrashes) {
 	const cutoff = now - windowMs;
@@ -145464,10 +145609,40 @@ function startAlexaWorker(deps) {
 	function scrub(text) {
 		return scrubSecrets(text, secrets);
 	}
+	function clearTimer(entry) {
+		if (entry.timer !== null) clearTimeout(entry.timer);
+		entry.timer = null;
+	}
+	function timing(entry, outcome) {
+		const end = now();
+		const queuedMs = (entry.sentAt ?? end) - entry.enqueuedAt;
+		const workerMs = entry.sentAt === null ? 0 : end - entry.sentAt;
+		const totalMs = end - entry.enqueuedAt;
+		const extras = {
+			...entry.deviceId === void 0 ? {} : { tags: { deviceId: entry.deviceId } },
+			meta: {
+				op: entry.request.op,
+				outcome,
+				queuedMs,
+				workerMs,
+				totalMs
+			}
+		};
+		if (totalMs > 5e3) logger.warn("alexa worker request was slow", extras);
+		else logger.debug("alexa worker request", extras);
+	}
+	function settle(entry, outcome, error, result) {
+		clearTimer(entry);
+		timing(entry, outcome);
+		const waiters = entry.waiters;
+		entry.waiters = [];
+		for (const waiter of waiters) if (error === null) waiter.resolve(result);
+		else waiter.reject(error);
+	}
 	function failPending(err) {
 		const current = pending;
 		pending = null;
-		current?.reject(err);
+		if (current !== null && !current.abandoned) settle(current, "worker-gone", err);
 	}
 	function attach(spawned) {
 		child = spawned;
@@ -145520,9 +145695,16 @@ function startAlexaWorker(deps) {
 		}
 		const current = pending;
 		pending = null;
-		if (message.ok) current.resolve(message.result);
-		else if (message.code === "rate-limited") current.reject(new RateLimitedError(scrub(message.error)));
-		else current.reject(new Error(scrub(message.error)));
+		if (current.abandoned) logger.debug("alexa worker late reply dropped", {
+			...current.deviceId === void 0 ? {} : { tags: { deviceId: current.deviceId } },
+			meta: {
+				op: current.request.op,
+				lateMs: now() - current.enqueuedAt
+			}
+		});
+		else if (message.ok) settle(current, "ok", null, message.result);
+		else if (message.code === "rate-limited") settle(current, "rate-limited", new RateLimitedError(scrub(message.error)));
+		else settle(current, "error", new Error(scrub(message.error)));
 		pump();
 	}
 	function onExit(code) {
@@ -145538,7 +145720,7 @@ function startAlexaWorker(deps) {
 			failed = true;
 			logger.error("alexa worker restart bound reached", { meta: { crashes: crashTimes.length } });
 			const waiting = queue.splice(0, queue.length);
-			for (const item of waiting) item.pending.reject(/* @__PURE__ */ new Error("alexa worker restart bound reached"));
+			for (const item of waiting) settle(item, "worker-gone", /* @__PURE__ */ new Error("alexa worker restart bound reached"));
 			return;
 		}
 		logger.warn("alexa worker exited; restarting", { meta: {
@@ -145559,23 +145741,74 @@ function startAlexaWorker(deps) {
 		if (pending !== null || child === null || failed || stopped) return;
 		const next = queue.shift();
 		if (next === void 0) return;
-		pending = next.pending;
-		child.stdin.write(requestLine(next.pending.id, next.request));
+		pending = next;
+		next.sentAt = now();
+		child.stdin.write(requestLine(next.id, next.request));
+	}
+	function expire(entry, deadlineMs) {
+		if (pending === entry) {
+			entry.abandoned = true;
+			settle(entry, "timeout-in-flight", /* @__PURE__ */ new Error(`alexa worker call timed out after ${deadlineMs} ms`));
+			return;
+		}
+		const at = queue.indexOf(entry);
+		if (at < 0) return;
+		queue.splice(at, 1);
+		settle(entry, "expired-queued", /* @__PURE__ */ new Error(`alexa worker call not started within ${deadlineMs} ms`));
 	}
-	function request(body) {
+	function enqueue(entry) {
+		if (entry.isRead) {
+			queue.push(entry);
+			return;
+		}
+		const firstRead = queue.findIndex((queued) => queued.isRead);
+		if (firstRead < 0) queue.push(entry);
+		else queue.splice(firstRead, 0, entry);
+	}
+	function request(body, options) {
 		if (failed) return Promise.reject(/* @__PURE__ */ new Error("alexa worker restart bound reached"));
 		if (stopped) return Promise.reject(/* @__PURE__ */ new Error("alexa worker stopped"));
-		const id = String(nextId);
-		nextId += 1;
+		const key = coalesceKey(body);
+		const isRead = READ_OPS.has(body.op);
 		return new Promise((resolve, reject) => {
-			queue.push({
+			const waiter = {
+				resolve,
+				reject
+			};
+			const twin = key === null ? void 0 : queue.find((queued) => queued.key === key);
+			if (twin !== void 0 && isRead) {
+				twin.waiters.push(waiter);
+				return;
+			}
+			const id = String(nextId);
+			nextId += 1;
+			const entry = {
+				id,
 				request: body,
-				pending: {
-					id,
-					resolve,
-					reject
-				}
-			});
+				key,
+				isRead,
+				deviceId: options?.deviceId,
+				enqueuedAt: now(),
+				sentAt: null,
+				waiters: [waiter],
+				abandoned: false,
+				timer: null
+			};
+			if (twin !== void 0) {
+				queue.splice(queue.indexOf(twin), 1);
+				clearTimer(twin);
+				entry.waiters = [...twin.waiters, waiter];
+				logger.debug("alexa worker queued call replaced by a newer one", {
+					...twin.deviceId === void 0 ? {} : { tags: { deviceId: twin.deviceId } },
+					meta: { op: body.op }
+				});
+			}
+			const deadlineMs = options?.deadlineMs ?? defaultDeadlineMs(body);
+			if (deadlineMs !== void 0) {
+				entry.timer = setTimeout(() => expire(entry, deadlineMs), deadlineMs);
+				entry.timer.unref();
+			}
+			enqueue(entry);
 			if (child === null) launch();
 			pump();
 		});
@@ -145592,7 +145825,7 @@ function startAlexaWorker(deps) {
 			current?.kill("SIGTERM");
 			failPending(/* @__PURE__ */ new Error("alexa worker stopped"));
 			const waiting = queue.splice(0, queue.length);
-			for (const item of waiting) item.pending.reject(/* @__PURE__ */ new Error("alexa worker stopped"));
+			for (const item of waiting) settle(item, "worker-gone", /* @__PURE__ */ new Error("alexa worker stopped"));
 		},
 		get failed() {
 			return failed;
@@ -146571,22 +146804,9 @@ var AlexaImportAddon = class extends BaseDeviceProvider {
 			}
 		});
 	}
-	globalSettingsSchema() {
-		return this.schema({ sections: [{
-			id: "alexa-account",
-			title: "Amazon Alexa account",
-			titleKey: "import-alexa:globalSettings.s_alexa-account.title",
-			description: "Alexa accounts are managed in the External systems → Brokers tab.",
-			descriptionKey: "import-alexa:globalSettings.s_alexa-account.description",
-			columns: 1,
-			fields: [{
-				type: "info",
-				key: "accountHelp",
-				label: "Accounts are managed separately",
-				labelKey: "import-alexa:globalSettings.s_alexa-account.accountHelp.label",
-				content: "This integration links to an Amazon Alexa account broker. Add, edit, or remove accounts from External systems → Brokers, then adopt the imported devices. The integration only stores a reference to its broker. NOTE: this is an unofficial integration that Amazon can change or break without notice."
-			}]
-		}] });
+	/** The connection form a record carries; the values live on the record, never in `addon-settings`. */
+	async integrationFormSchema(_instance) {
+		return buildConnectionFormSchema();
 	}
 	async supportsManualCreation() {
 		return false;