@yunlefun-home/air-conditioner-core 0.2.0 → 0.3.0

package/dist/index.js

@@ -21,17 +21,74 @@ const acAudioFileNames = {
 };
 const minTemperature = 16;
 const maxTemperature = 31;
+const defaultAcLimits = {
+	min: 16,
+	max: 31,
+	step: 1
+};
 const recommendedColdTemperature = 26;
 const recommendedHotTemperature = 20;
 const defaultAcState = {
 	mode: "cold",
 	status: false,
-	temperature: 26
+	temperature: 26,
+	sound: "normal"
+};
+/**
+* 遥控器「声音」键依次切换的顺序。
+*/
+const acSoundModes = [
+	"normal",
+	"sleep",
+	"mute"
+];
+const acSoundModeLabels = {
+	normal: "标准",
+	sleep: "睡眠",
+	mute: "静音"
+};
+/**
+* 各声音模式的总音量（0–1）。
+*/
+const acSoundVolumes = {
+	normal: 1,
+	sleep: .3,
+	mute: 0
 };
+function isAcSoundMode(value) {
+	return acSoundModes.includes(value);
+}
+/**
+* 声音键的下一个模式：标准 → 睡眠 → 静音 → 标准。
+*/
+function nextAcSoundMode(mode) {
+	const index = Math.max(acSoundModes.indexOf(mode), 0);
+	return acSoundModes[(index + 1) % acSoundModes.length];
+}
+/**
+* 音效时序。时长单位为毫秒，`*Level` 是风声相对音量（0–1）。
+*/
 const soundTimings = {
+	/** 开机后多久接上持续的风声（启动声约 9 秒） */
 	startDelayMs: 8e3,
-	noiseStartTime: 2,
-	noiseDuration: 56
+	/** 风声循环首尾的交叉淡化时长 */
+	loopCrossfadeMs: 1500,
+	/** 关机时声音淡出时长 */
+	stopFadeMs: 600,
+	/** 开机运行多久后室温达标、风声降下来 */
+	settleAfterMs: 9e4,
+	/** 风声降下来的渐变时长 */
+	settleRampMs: 2e4,
+	/** 达标后的安静风声 */
+	settleLevel: .5,
+	/** 室温回升、压缩机重新发力时的风声 */
+	surgeLevel: .85,
+	/** 两次发力之间安静运行的时长范围 */
+	quietDurationMs: [18e4, 36e4],
+	/** 每次发力持续的时长范围 */
+	surgeDurationMs: [6e4, 12e4],
+	/** 发力 / 回落的渐变时长 */
+	surgeRampMs: 1e4
 };
 /**
 * 根据基础路径解析出三个音频文件的完整 URL。
@@ -51,78 +108,535 @@ function resolveAcAudioAssets(baseUrl = "/assets/audio", ext = "m4a") {
 }
 //#endregion
 //#region src/audio.ts
-function createAcAudioController(elements) {
-	let playStartSoundTimeoutId;
-	let playWorkSoundTimeoutId;
-	let playWorkSoundIntervalId;
-	function clearWorkTimers() {
-		if (playStartSoundTimeoutId) clearTimeout(playStartSoundTimeoutId);
-		if (playWorkSoundTimeoutId) clearTimeout(playWorkSoundTimeoutId);
-		if (playWorkSoundIntervalId) clearInterval(playWorkSoundIntervalId);
-		playStartSoundTimeoutId = void 0;
-		playWorkSoundTimeoutId = void 0;
-		playWorkSoundIntervalId = void 0;
-	}
-	function play(audio) {
-		if (!audio) return;
-		audio.load();
-		audio.play();
-	}
-	function playWorkSound() {
-		if (!elements.work) return;
-		play(elements.work);
-		playWorkSoundTimeoutId = setTimeout(() => {
-			playWorkSoundIntervalId = setInterval(() => {
-				if (elements.work) elements.work.currentTime = soundTimings.noiseStartTime;
-			}, soundTimings.noiseDuration * 1e3);
-		}, soundTimings.noiseStartTime * 1e3);
-	}
-	function playStartSound() {
-		play(elements.start);
-		playStartSoundTimeoutId = setTimeout(() => {
-			playWorkSound();
+/** Web Audio 资源迟迟没加载好时，本次开机先用 `<audio>` 播放 */
+const readyTimeoutMs = 1500;
+const fallbackTweenStepMs = 100;
+const curveLength = 64;
+function sourceUrl(element) {
+	return element?.currentSrc || element?.src || "";
+}
+async function fetchAudioData(url) {
+	const response = await fetch(url);
+	if (!response.ok) throw new Error(`Failed to load ${url}: ${response.status}`);
+	return response.arrayBuffer();
+}
+function createDefaultAudioContext() {
+	const scope = globalThis;
+	const AudioContextConstructor = scope.AudioContext ?? scope.webkitAudioContext;
+	return AudioContextConstructor ? new AudioContextConstructor() : null;
+}
+/**
+* 等功率淡入 / 淡出曲线，噪声类声音交叉淡化时中段不会变小。
+*/
+function fadeCurve(direction) {
+	const curve = new Float32Array(curveLength);
+	for (let i = 0; i < curveLength; i++) {
+		const phase = i / 63 * Math.PI / 2;
+		curve[i] = direction === "in" ? Math.sin(phase) : Math.cos(phase);
+	}
+	return curve;
+}
+function randomBetween(range, random) {
+	return range[0] + (range[1] - range[0]) * random();
+}
+function playElement(element) {
+	if (!element) return;
+	element.load();
+	Promise.resolve(element.play()).catch(() => {});
+}
+function stopElement(element) {
+	if (!element) return;
+	if (element.pause) element.pause();
+	else element.load();
+}
+/**
+* 空调音效：按键「嘀」声、开机启动声与持续的风声。
+*
+* 默认通过 Web Audio API 播放：风声无缝循环，开关机淡入淡出，运行一段时间后
+* 风声变小、并不定时随压缩机发力起伏。环境不支持或音频无法获取时退回
+* `<audio>` 元素。
+*
+* 需在用户交互（点击遥控器）里首次调用，浏览器才允许发声。
+*
+* @param elements 三个音频元素；Web Audio 会从它们的 `src` 获取音频
+* @param options 声音模式与可替换的环境依赖
+*/
+function createAcAudioController(elements, options = {}) {
+	const random = options.random ?? Math.random;
+	let soundMode = options.soundMode ?? "normal";
+	/** undefined：尚未尝试；null：不可用 */
+	let engine;
+	let run;
+	/** 每次开关机自增，丢弃过期的异步回调 */
+	let session = 0;
+	const timers = /* @__PURE__ */ new Set();
+	/** `<audio>` 播放时的风声相对音量 */
+	let fallbackFanLevel = 1;
+	let fallbackTween;
+	function later(callback, delayMs) {
+		const timer = setTimeout(() => {
+			timers.delete(timer);
+			callback();
+		}, delayMs);
+		timers.add(timer);
+	}
+	function clearTimers() {
+		timers.forEach((timer) => clearTimeout(timer));
+		timers.clear();
+	}
+	function volume() {
+		return acSoundVolumes[soundMode];
+	}
+	function applyElementVolume(element, level = 1) {
+		if (!element) return;
+		if (element.volume !== void 0) element.volume = Math.min(1, Math.max(0, volume() * level));
+		if (element.muted !== void 0) element.muted = soundMode === "mute";
+	}
+	function cancelFallbackTween() {
+		if (fallbackTween) clearInterval(fallbackTween);
+		fallbackTween = void 0;
+	}
+	function tweenFallbackFan(target, durationMs, onDone) {
+		cancelFallbackTween();
+		const from = fallbackFanLevel;
+		const steps = Math.max(1, Math.round(durationMs / fallbackTweenStepMs));
+		let step = 0;
+		fallbackTween = setInterval(() => {
+			step++;
+			fallbackFanLevel = from + (target - from) * (step / steps);
+			applyElementVolume(elements.work, fallbackFanLevel);
+			if (step >= steps) {
+				cancelFallbackTween();
+				onDone?.();
+			}
+		}, fallbackTweenStepMs);
+	}
+	function ensureEngine() {
+		if (engine !== void 0) return engine;
+		engine = createEngine();
+		return engine;
+	}
+	function createEngine() {
+		if (options.webAudio === false) return null;
+		let context;
+		try {
+			context = (options.createAudioContext ?? createDefaultAudioContext)();
+		} catch {
+			return null;
+		}
+		if (!context) return null;
+		const master = context.createGain();
+		master.gain.value = volume();
+		master.connect(context.destination);
+		const buffers = {};
+		const load = options.loadAudioData ?? fetchAudioData;
+		const decode = async (name) => {
+			const url = sourceUrl(elements[name]);
+			if (!url) return;
+			try {
+				buffers[name] = await context.decodeAudioData(await load(url));
+			} catch {}
+		};
+		const ready = Promise.all([
+			"beep",
+			"start",
+			"work"
+		].map(decode)).then(() => Boolean(buffers.start && buffers.work));
+		return {
+			context,
+			master,
+			buffers,
+			ready
+		};
+	}
+	function resume(web) {
+		if (web.context.state === "suspended") Promise.resolve(web.context.resume()).catch(() => {});
+	}
+	function waitReady(web) {
+		return Promise.race([web.ready, new Promise((resolve) => setTimeout(resolve, readyTimeoutMs, false))]);
+	}
+	function playBuffer(web, buffer, destination, when) {
+		const source = web.context.createBufferSource();
+		source.buffer = buffer;
+		source.connect(destination);
+		source.start(when);
+		return source;
+	}
+	function track(target, source, cleanup) {
+		target.sources.add(source);
+		source.onended = () => {
+			target.sources.delete(source);
+			source.disconnect();
+			cleanup?.();
+		};
+	}
+	/**
+	* 排一段风声，并在它结束前交叉淡化接上下一段。
+	*/
+	function loopFan(web, target, when) {
+		const buffer = web.buffers.work;
+		const crossfade = Math.min(soundTimings.loopCrossfadeMs / 1e3, buffer.duration / 2);
+		const gain = web.context.createGain();
+		gain.gain.value = 0;
+		gain.gain.setValueCurveAtTime(fadeCurve("in"), when, crossfade);
+		gain.gain.setValueCurveAtTime(fadeCurve("out"), when + buffer.duration - crossfade, crossfade);
+		gain.connect(target.fan);
+		const source = playBuffer(web, buffer, gain, when);
+		source.stop(when + buffer.duration);
+		track(target, source, () => gain.disconnect());
+		const next = when + buffer.duration - crossfade;
+		later(() => {
+			if (run === target) loopFan(web, target, next);
+		}, Math.max(0, (next - web.context.currentTime - 1) * 1e3));
+	}
+	function setFanLevel(level, rampMs) {
+		if (run && engine) {
+			const gain = run.fan.gain;
+			const now = engine.context.currentTime;
+			gain.cancelScheduledValues(now);
+			gain.setValueAtTime(gain.value, now);
+			gain.linearRampToValueAtTime(level, now + rampMs / 1e3);
+		} else tweenFallbackFan(level, rampMs);
+	}
+	/**
+	* 室温达标后风声变小；之后不定时随压缩机发力变大，再回落。
+	*/
+	function startFanCycle() {
+		const quiet = () => {
+			later(() => {
+				setFanLevel(soundTimings.surgeLevel, soundTimings.surgeRampMs);
+				later(() => {
+					setFanLevel(soundTimings.settleLevel, soundTimings.surgeRampMs);
+					quiet();
+				}, randomBetween(soundTimings.surgeDurationMs, random));
+			}, randomBetween(soundTimings.quietDurationMs, random));
+		};
+		later(() => {
+			setFanLevel(soundTimings.settleLevel, soundTimings.settleRampMs);
+			quiet();
+		}, soundTimings.settleAfterMs);
+	}
+	function startWeb(web) {
+		const output = web.context.createGain();
+		output.connect(web.master);
+		const fan = web.context.createGain();
+		fan.connect(output);
+		const target = {
+			output,
+			fan,
+			sources: /* @__PURE__ */ new Set()
+		};
+		run = target;
+		const now = web.context.currentTime;
+		track(target, playBuffer(web, web.buffers.start, output, now));
+		loopFan(web, target, now + soundTimings.startDelayMs / 1e3);
+		later(startFanCycle, soundTimings.startDelayMs);
+	}
+	function stopWeb(fadeMs) {
+		const target = run;
+		run = void 0;
+		if (!target || !engine) return;
+		const now = engine.context.currentTime;
+		const end = now + fadeMs / 1e3;
+		const gain = target.output.gain;
+		gain.cancelScheduledValues(now);
+		gain.setValueAtTime(gain.value, now);
+		gain.linearRampToValueAtTime(0, end);
+		target.sources.forEach((source) => {
+			try {
+				source.stop(end);
+			} catch {}
+		});
+		setTimeout(() => target.output.disconnect(), fadeMs + 100);
+	}
+	function startFallback() {
+		const { start, work } = elements;
+		stopElement(work);
+		applyElementVolume(start);
+		playElement(start);
+		later(() => {
+			if (!work) return;
+			fallbackFanLevel = 0;
+			applyElementVolume(work, 0);
+			if (work.loop !== void 0) work.loop = true;
+			playElement(work);
+			tweenFallbackFan(1, soundTimings.loopCrossfadeMs);
+			startFanCycle();
 		}, soundTimings.startDelayMs);
 	}
+	function stopFallback(fadeMs) {
+		stopElement(elements.start);
+		if (fadeMs > 0) tweenFallbackFan(0, fadeMs, () => stopElement(elements.work));
+		else stopElement(elements.work);
+	}
+	function powerOn() {
+		const id = ++session;
+		clearTimers();
+		cancelFallbackTween();
+		stopWeb(0);
+		stopFallback(0);
+		const web = ensureEngine();
+		if (!web) {
+			startFallback();
+			return;
+		}
+		resume(web);
+		waitReady(web).then((ok) => {
+			if (id !== session) return;
+			if (ok) startWeb(web);
+			else startFallback();
+		});
+	}
+	function powerOff() {
+		session++;
+		clearTimers();
+		stopWeb(soundTimings.stopFadeMs);
+		stopFallback(soundTimings.stopFadeMs);
+	}
 	return {
 		beep() {
-			play(elements.beep);
+			if (soundMode === "mute") return;
+			const web = ensureEngine();
+			if (web) {
+				resume(web);
+				if (web.buffers.beep) {
+					playBuffer(web, web.buffers.beep, web.master, web.context.currentTime);
+					return;
+				}
+			}
+			applyElementVolume(elements.beep);
+			playElement(elements.beep);
 		},
 		toggleStatusAudio(previousStatus) {
-			if (previousStatus) {
-				clearWorkTimers();
-				if (elements.start) elements.start.load();
-				if (elements.work) elements.work.currentTime = soundTimings.noiseStartTime + soundTimings.noiseDuration;
-			} else {
-				clearWorkTimers();
-				playStartSound();
-			}
+			if (previousStatus) powerOff();
+			else powerOn();
+		},
+		setSoundMode(mode) {
+			soundMode = mode;
+			if (engine) engine.master.gain.setTargetAtTime(volume(), engine.context.currentTime, .08);
+			applyElementVolume(elements.beep);
+			applyElementVolume(elements.start);
+			applyElementVolume(elements.work, fallbackFanLevel);
 		},
 		dispose() {
-			clearWorkTimers();
+			session++;
+			clearTimers();
+			cancelFallbackTween();
+			stopWeb(0);
+			stopFallback(0);
+			if (engine && !options.createAudioContext) Promise.resolve(engine.context.close()).catch(() => {});
+			engine = null;
+		}
+	};
+}
+//#endregion
+//#region src/motion.ts
+/**
+* 动效 token：各框架视图层共用的时长与缓动曲线。
+*
+* 样式里统一通过 CSS 变量（`--acw-motion-*`）引用，
+* 需要在 JS 里计时的地方（如 React 过渡组件）直接读取 `acMotion`。
+*/
+const acMotion = {
+	duration: {
+		/** 按下反馈 */
+		instant: 90,
+		/** 悬停、指示灯、图标 */
+		fast: 160,
+		/** 显示屏、数字切换、提示 */
+		base: 240,
+		/** 导风板、出风淡入淡出 */
+		slow: 420,
+		/** 出风气流单次循环 */
+		flow: 1800
+	},
+	easing: {
+		/** 常规状态切换 */
+		standard: "cubic-bezier(0.2, 0, 0, 1)",
+		/** 进入：快起慢停 */
+		enter: "cubic-bezier(0, 0, 0, 1)",
+		/** 退出：慢起快走 */
+		exit: "cubic-bezier(0.3, 0, 1, 1)",
+		/** 轻微回弹（按钮松开、图标弹出） */
+		spring: "cubic-bezier(0.34, 1.56, 0.64, 1)"
+	}
+};
+/**
+* `prefers-reduced-motion: reduce` 时使用的时长：
+* 保留短促的淡入淡出（不涉及位移），去掉较长的过渡；循环动画由各样式表自行关闭。
+*/
+const acReducedMotionDuration = {
+	instant: 0,
+	fast: 80,
+	base: 120,
+	slow: 120,
+	flow: 0
+};
+const acReducedMotionQuery = "(prefers-reduced-motion: reduce)";
+/**
+* 当前环境是否要求减少动效（SSR / 无 matchMedia 时返回 `false`）。
+*/
+function prefersReducedMotion() {
+	return typeof globalThis.matchMedia === "function" && globalThis.matchMedia("(prefers-reduced-motion: reduce)").matches;
+}
+function declarations(durations, withEasing, indent) {
+	const lines = Object.keys(durations).map((key) => `${indent}--acw-motion-duration-${key}: ${durations[key]}ms;`);
+	if (withEasing) for (const key of Object.keys(acMotion.easing)) lines.push(`${indent}--acw-motion-ease-${key}: ${acMotion.easing[key]};`);
+	return lines.join("\n");
+}
+/**
+* 生成动效 CSS 变量声明（含 reduced-motion 覆盖），供 Shadow DOM 注入或样式表同步使用。
+*
+* @param selector 变量挂载的选择器，如 `:root`、`:host`
+*/
+function renderAcMotionCssVars(selector = ":root") {
+	return [
+		`${selector} {`,
+		declarations(acMotion.duration, true, "  "),
+		"}",
+		"",
+		`@media ${acReducedMotionQuery} {`,
+		`  ${selector} {`,
+		declarations(acReducedMotionDuration, false, "    "),
+		"  }",
+		"}"
+	].join("\n");
+}
+//#endregion
+//#region src/layout.ts
+/**
+* 机身的设计尺寸（px），约 3:1，接近真实壁挂机（如 800–900mm × 280–300mm）的比例。
+* 窄容器下按比例整体缩放，保持「长款」外观不被压扁。
+*
+* - `compact`：Vue / React 组件库 / Web Component 使用的 360 × 128 机身
+* - `wide`：React 主站使用的 600 × 200 机身
+*/
+const acShellSize = {
+	compact: {
+		width: 360,
+		height: 128
+	},
+	wide: {
+		width: 600,
+		height: 200
+	}
+};
+/**
+* 根据可用宽度计算机身缩放比例：只缩小、不放大。
+*/
+function getAcScale(availableWidth, designWidth) {
+	if (!(availableWidth > 0) || !(designWidth > 0)) return 1;
+	return Math.min(1, availableWidth / designWidth);
+}
+/**
+* 监听容器宽度变化并回调缩放比例。
+*
+* 不支持 `ResizeObserver` 的环境（如 SSR）直接返回空的清理函数，保持 1 倍显示。
+*
+* @param target 被测量宽度的容器（不要传被缩放的元素本身）
+* @param designWidth 机身的设计宽度
+* @param onScale 比例变化时的回调
+* @returns 停止监听的清理函数
+*/
+function observeAcScale(target, designWidth, onScale) {
+	if (typeof ResizeObserver === "undefined") return () => {};
+	let current;
+	const update = (width) => {
+		const scale = getAcScale(width, designWidth);
+		if (scale !== current) {
+			current = scale;
+			onScale(scale);
 		}
 	};
+	update(target.getBoundingClientRect().width);
+	const observer = new ResizeObserver((entries) => {
+		for (const entry of entries) update(entry.contentRect.width);
+	});
+	observer.observe(target);
+	return () => observer.disconnect();
+}
+/** 指针跟随倾斜的最大角度（deg） */
+const acMaxTilt = 4;
+const finePointerQuery = "(hover: hover) and (pointer: fine)";
+/**
+* 指针在元素上移动时回调轻微的 3D 倾斜角度（`rotateX` / `rotateY`，单位 deg），离开时回到 0。
+*
+* 仅在有悬停能力的精细指针（鼠标 / 触控板）上启用；`prefers-reduced-motion: reduce`、
+* 触屏或 SSR 下直接返回空的清理函数。
+*
+* @returns 停止监听的清理函数
+*/
+function observeAcTilt(target, onTilt, maxTilt = 4) {
+	const matchMedia = globalThis.matchMedia;
+	if (typeof matchMedia !== "function" || !matchMedia(finePointerQuery).matches || matchMedia("(prefers-reduced-motion: reduce)").matches) return () => {};
+	let frame = 0;
+	const schedule = (rotateX, rotateY) => {
+		cancelAnimationFrame(frame);
+		frame = requestAnimationFrame(() => onTilt(rotateX, rotateY));
+	};
+	const onMove = (event) => {
+		const rect = target.getBoundingClientRect();
+		if (!rect.width || !rect.height) return;
+		const x = (event.clientX - rect.left) / rect.width - .5;
+		const y = (event.clientY - rect.top) / rect.height - .5;
+		const round = (value) => Math.round(value * 100) / 100;
+		schedule(round(-y * 2 * maxTilt), round(x * 2 * maxTilt));
+	};
+	const onLeave = () => schedule(0, 0);
+	target.addEventListener("pointermove", onMove);
+	target.addEventListener("pointerleave", onLeave);
+	return () => {
+		cancelAnimationFrame(frame);
+		target.removeEventListener("pointermove", onMove);
+		target.removeEventListener("pointerleave", onLeave);
+	};
 }
 //#endregion
 //#region src/reducer.ts
-function normalizeAcState(state) {
+/**
+* Merge a partial state over the defaults and clamp its temperature.
+*
+* @param state - Partial or stored state
+* @param limits - Device limits; omit to keep the default 16–31 °C range
+*/
+function normalizeAcState(state, limits) {
 	return {
 		...defaultAcState,
 		...state,
-		temperature: clampTemperature(state?.temperature ?? defaultAcState.temperature)
+		temperature: clampTemperature(state?.temperature ?? defaultAcState.temperature, limits),
+		sound: isAcSoundMode(state?.sound) ? state.sound : defaultAcState.sound
 	};
 }
-function clampTemperature(temperature) {
-	return Math.min(31, Math.max(16, temperature));
+/**
+* Clamp a temperature into range. When `limits` are given the value also
+* snaps to the device step, measured from `limits.min`.
+*
+* @param temperature - Requested temperature in Celsius
+* @param limits - Device limits; omit to clamp to 16–31 °C without snapping
+*/
+function clampTemperature(temperature, limits) {
+	if (!limits) return Math.min(31, Math.max(16, temperature));
+	const { min, max, step } = limits;
+	const snapped = step > 0 ? Math.round((temperature - min) / step) * step + min : temperature;
+	return Number(Math.min(max, Math.max(min, snapped)).toFixed(4));
 }
-function acReducer(state, action) {
+/**
+* Apply an action to the state.
+*
+* @param state - Current state
+* @param action - Action to apply
+* @param limits - Device limits; increments use `limits.step`
+*/
+function acReducer(state, action, limits) {
+	const step = limits?.step ?? defaultAcLimits.step;
 	switch (action.type) {
 		case "increment": return {
 			...state,
-			temperature: clampTemperature(state.temperature + 1)
+			temperature: clampTemperature(state.temperature + step, limits)
 		};
 		case "decrement": return {
 			...state,
-			temperature: clampTemperature(state.temperature - 1)
+			temperature: clampTemperature(state.temperature - step, limits)
 		};
 		case "toggleStatus": return {
 			...state,
@@ -136,25 +650,53 @@ function acReducer(state, action) {
 			...state,
 			mode: action.mode
 		};
+		case "sound": return {
+			...state,
+			sound: isAcSoundMode(action.sound) ? action.sound : state.sound
+		};
+		case "cycleSound": return {
+			...state,
+			sound: nextAcSoundMode(state.sound)
+		};
 		case "update": return normalizeAcState({
 			...state,
 			...action.payload
-		});
+		}, limits);
 		default: throw new Error("Unexpected Ac Action");
 	}
 }
 function getRecommendedTemperatureMessage(mode, temperature) {
 	return `建议将空调的制${mode === "cold" ? "冷" : "热"}温度调至 ${temperature} 度以${mode === "cold" ? "上" : "下"}，为节能减排贡献一份力量！`;
 }
-function getAcActionNotification(previousState, nextState, action) {
-	if (action.type === "increment" && previousState.temperature >= 31) return {
+function getSoundModeMessage(sound) {
+	return `${acSoundModeLabels[sound]}模式：${{
+		normal: "风声和按键音恢复正常",
+		sleep: "风声和按键音都调小了，晚安",
+		mute: "空调不再发出任何声音"
+	}[sound]}`;
+}
+/**
+* Visual tone for a state: `idle` when off, otherwise `cool` or `heat`.
+*
+* @param state - Current state
+*/
+function acTone(state) {
+	if (!state.status) return "idle";
+	return state.mode === "hot" ? "heat" : "cool";
+}
+function getAcActionNotification(previousState, nextState, action, limits = defaultAcLimits) {
+	if (action.type === "increment" && previousState.temperature >= limits.max) return {
 		message: "已经是最大温度啦！",
 		severity: "error"
 	};
-	if (action.type === "decrement" && previousState.temperature <= 16) return {
+	if (action.type === "decrement" && previousState.temperature <= limits.min) return {
 		message: "已经是最小温度啦！",
 		severity: "error"
 	};
+	if ((action.type === "sound" || action.type === "cycleSound") && nextState.sound !== previousState.sound) return {
+		message: getSoundModeMessage(nextState.sound),
+		severity: "info"
+	};
 	if (action.type === "mode" && nextState.mode === "cold" && previousState.temperature < 26) return {
 		message: getRecommendedTemperatureMessage("cold", 26),
 		severity: "success"
@@ -210,11 +752,12 @@ function createAirConditionerStore(options = {}) {
 	const storageKey = options.storageKey ?? "ac:state";
 	const storage = options.storage === void 0 ? getBrowserStorage() : options.storage;
 	const persistedState = readAcState(storage, storageKey);
+	const limits = options.limits;
 	let state = normalizeAcState({
 		...defaultAcState,
 		...persistedState,
 		...options.initialState
-	});
+	}, limits);
 	const listeners = /* @__PURE__ */ new Set();
 	return {
 		getState() {
@@ -222,8 +765,8 @@ function createAirConditionerStore(options = {}) {
 		},
 		dispatch(action) {
 			const previousState = state;
-			const nextState = acReducer(state, action);
-			const notification = getAcActionNotification(previousState, nextState, action);
+			const nextState = acReducer(state, action, limits);
+			const notification = getAcActionNotification(previousState, nextState, action, limits);
 			const event = {
 				action,
 				previousState,
@@ -245,4 +788,231 @@ function createAirConditionerStore(options = {}) {
 	};
 }
 //#endregion
-export { acAudioFileNames, acModeIcons, acReducer, acStorageKey, clampTemperature, createAcAudioController, createAirConditionerStore, createMemoryStorage, defaultAcState, getAcActionNotification, getBrowserStorage, getRecommendedTemperatureMessage, maxTemperature, minTemperature, normalizeAcState, readAcState, recommendedColdTemperature, recommendedHotTemperature, resolveAcAudioAssets, soundTimings, writeAcState };
+//#region src/thermal/levels.ts
+const heatLevels = [
+	"nominal",
+	"fair",
+	"serious",
+	"critical"
+];
+/** Default Celsius thresholds for fair, serious and critical. */
+const defaultHeatThresholds = [
+	60,
+	75,
+	90
+];
+/**
+* @param level - A heat level
+* @returns Its rank from 0 (nominal) to 3 (critical)
+*/
+function heatLevelRank(level) {
+	return heatLevels.indexOf(level);
+}
+function isHeatLevel(value) {
+	return heatLevels.includes(value);
+}
+/**
+* Convert a temperature to a heat level. With a previous level, the value
+* must fall `hysteresis` degrees below a threshold before dropping a level,
+* which keeps readings near a threshold from flickering.
+*
+* @param celsius - Measured temperature
+* @param thresholds - Lower bounds for fair, serious and critical
+* @param previous - Level from the previous reading
+* @param hysteresis - Degrees required below a threshold to step down
+*/
+function celsiusToHeatLevel(celsius, thresholds = defaultHeatThresholds, previous, hysteresis = 5) {
+	const raw = thresholds.filter((threshold) => celsius >= threshold).length;
+	if (previous === void 0) return heatLevels[raw];
+	const held = thresholds.filter((threshold) => celsius >= threshold - hysteresis).length;
+	return heatLevels[Math.max(raw, Math.min(heatLevelRank(previous), held))];
+}
+/**
+* Create a filter that raises the level immediately but only lowers it after
+* lower readings persist for `dwellMs`, measured with `reading.at`.
+*
+* @param options - Governor options
+* @param options.dwellMs - Time a lower level must persist; defaults to 30 seconds
+* @returns A function that maps each reading to the settled level
+*/
+function createHeatGovernor(options = {}) {
+	const dwellMs = options.dwellMs ?? 3e4;
+	let current;
+	let lowerSince;
+	return (reading) => {
+		if (current === void 0 || heatLevelRank(reading.level) >= heatLevelRank(current)) {
+			current = reading.level;
+			lowerSince = void 0;
+			return current;
+		}
+		lowerSince ??= reading.at;
+		if (reading.at - lowerSince >= dwellMs) {
+			current = reading.level;
+			lowerSince = void 0;
+		}
+		return current;
+	};
+}
+//#endregion
+//#region src/thermal/plan.ts
+const coolingByLevel = {
+	fair: {
+		temperature: 26,
+		airflow: .4
+	},
+	serious: {
+		temperature: 24,
+		airflow: .7
+	},
+	critical: {
+		temperature: 22,
+		airflow: 1
+	}
+};
+/**
+* Decide how the virtual air conditioner should respond to a heat level.
+*
+* @param level - Settled heat level
+* @param limits - Device limits used to clamp the target temperature
+* @returns A cooling plan, or `null` at `nominal` so the user keeps control
+*/
+function planCooling(level, limits) {
+	if (level === "nominal") return null;
+	const { temperature, airflow } = coolingByLevel[level];
+	return {
+		status: true,
+		mode: "cold",
+		temperature: clampTemperature(temperature, limits),
+		airflow
+	};
+}
+//#endregion
+//#region src/thermal/pressure.ts
+function getPressureObserver() {
+	return globalThis.PressureObserver;
+}
+/**
+* Heat source backed by the browser Compute Pressure API. It reports CPU
+* load levels, not temperatures; browsers expose no CPU temperature.
+*
+* Supported in Chromium-based browsers on secure origins. The API is only
+* touched when the source is started.
+*
+* @param options - Sampling and error handling options
+*/
+function createComputePressureSource(options = {}) {
+	return {
+		id: "compute-pressure",
+		isSupported: () => typeof getPressureObserver() === "function",
+		start(listener) {
+			const Observer = getPressureObserver();
+			if (!Observer) return () => {};
+			let stopped = false;
+			const observer = new Observer((records) => {
+				const record = records.at(-1);
+				if (stopped || !record || !isHeatLevel(record.state)) return;
+				listener({
+					level: record.state,
+					source: "compute-pressure",
+					at: Date.now()
+				});
+			});
+			observer.observe("cpu", { sampleInterval: options.sampleIntervalMs ?? 2e3 }).catch((error) => {
+				if (!stopped) options.onError?.(error);
+			});
+			return () => {
+				stopped = true;
+				observer.disconnect();
+			};
+		}
+	};
+}
+//#endregion
+//#region src/ui.ts
+/**
+* 各框架视图层共用的界面数据：遥控器图标与能效标签的点阵布局。
+* 保证 Vue / React / Web Component 渲染出完全一致的空调外观。
+*/
+/**
+* 遥控器按钮图标（24 × 24 viewBox 的 SVG path）。
+*/
+const acIconPaths = {
+	cold: "m22 11h-4.17l3.24-3.24l-1.41-1.42L15 11h-2V9l4.66-4.66l-1.42-1.41L13 6.17V2h-2v4.17L7.76 2.93L6.34 4.34L11 9v2H9L4.34 6.34L2.93 7.76L6.17 11H2v2h4.17l-3.24 3.24l1.41 1.42L9 13h2v2l-4.66 4.66l1.42 1.41L11 17.83V22h2v-4.17l3.24 3.24l1.42-1.41L13 15v-2h2l4.66 4.66l1.41-1.42L17.83 13H22z",
+	power: "M13 3h-2v10h2zm4.83 2.17l-1.42 1.42A6.92 6.92 0 0 1 19 12a7 7 0 0 1-14 0a6.92 6.92 0 0 1 2.58-5.42L6.17 5.17A9 9 0 1 0 21 12a8.94 8.94 0 0 0-3.17-6.83",
+	hot: "M12 7a5 5 0 1 0 5 5a5 5 0 0 0-5-5m0-5a1 1 0 0 0-1 1v2a1 1 0 0 0 2 0V3a1 1 0 0 0-1-1m0 17a1 1 0 0 0-1 1v2a1 1 0 0 0 2 0v-2a1 1 0 0 0-1-1M5.64 6.05L4.22 4.64a1 1 0 0 0-1.41 1.41l1.41 1.42a1 1 0 0 0 1.42 0a1 1 0 0 0 0-1.42M21 11h-2a1 1 0 0 0 0 2h2a1 1 0 0 0 0-2M5 12a1 1 0 0 0-1-1H2a1 1 0 0 0 0 2h2a1 1 0 0 0 1-1m13.36-5.95a1 1 0 0 0 .7-.29l1.42-1.42a1 1 0 1 0-1.41-1.41l-1.42 1.41a1 1 0 0 0 0 1.42a1 1 0 0 0 .71.29m0 11.9a1 1 0 0 0-1.42 1.41l1.42 1.42a1 1 0 0 0 1.41 0a1 1 0 0 0 0-1.41ZM5.64 17.95l-1.42 1.42a1 1 0 0 0 0 1.41a1 1 0 0 0 1.41 0l1.42-1.42a1 1 0 0 0-1.41-1.41",
+	increase: "m12 8l6 8H6z",
+	decrease: "m12 16l-6-8h12z",
+	soundNormal: "M3 10v4c0 .55.45 1 1 1h3l3.29 3.29c.63.63 1.71.18 1.71-.71V6.41c0-.89-1.08-1.34-1.71-.71L7 9H4c-.55 0-1 .45-1 1m13.5 2A4.5 4.5 0 0 0 14 7.97v8.05c1.48-.73 2.5-2.25 2.5-4.02M14 4.45v.2c0 .38.25.71.6.85C17.18 6.53 19 9.06 19 12s-1.82 5.47-4.4 6.5c-.36.14-.6.47-.6.85v.2c0 .63.63 1.07 1.21.85C18.6 19.11 21 15.84 21 12s-2.4-7.11-5.79-8.4c-.58-.23-1.21.22-1.21.85",
+	soundSleep: "M11.65 3.46c.27-.71-.36-1.45-1.12-1.34c-5.52.8-9.47 6.07-8.34 11.88c.78 4.02 4.09 7.21 8.14 7.87c3.74.61 7.16-.87 9.32-3.44c.48-.57.19-1.48-.55-1.62c-6.02-1.15-9.68-7.54-7.45-13.35",
+	soundMute: "M3.63 3.63a.996.996 0 0 0 0 1.41L7.29 8.7L7 9H4c-.55 0-1 .45-1 1v4c0 .55.45 1 1 1h3l3.29 3.29c.63.63 1.71.18 1.71-.71v-4.17l4.18 4.18c-.49.37-1.02.68-1.6.91c-.36.15-.58.53-.58.92c0 .72.73 1.18 1.39.91c.8-.33 1.55-.77 2.22-1.31l1.34 1.34a.996.996 0 1 0 1.41-1.41L5.05 3.63c-.39-.39-1.02-.39-1.42 0M19 12c0 .82-.15 1.61-.41 2.34l1.53 1.53c.56-1.17.88-2.48.88-3.87c0-3.83-2.4-7.11-5.78-8.4c-.59-.23-1.22.23-1.22.86v.19c0 .38.25.71.61.85C17.18 6.54 19 9.06 19 12m-8.71-6.29l-.17.17L12 7.76V6.41c0-.89-1.08-1.33-1.71-.7M16.5 12A4.5 4.5 0 0 0 14 7.97v1.79l2.48 2.48c.01-.08.02-.16.02-.24"
+};
+/**
+* 声音键在各声音模式下显示的图标。
+*/
+const acSoundIcons = {
+	normal: "soundNormal",
+	sleep: "soundSleep",
+	mute: "soundMute"
+};
+/**
+* 能效标签的点阵与等级条布局。
+*/
+const acEnergyLabel = {
+	top: [{
+		num: 6,
+		size: 4,
+		mx: 2,
+		my: 0,
+		color: "white"
+	}],
+	detail: [
+		{
+			num: 11,
+			size: 2,
+			mx: .8,
+			my: 2,
+			color: "black"
+		},
+		{
+			num: 9,
+			size: 1.5,
+			mx: .8,
+			my: 2,
+			color: "black"
+		},
+		{
+			num: 10,
+			size: 1.2,
+			mx: .8,
+			my: 0,
+			color: "black"
+		}
+	],
+	footer: {
+		num: 8,
+		size: 2,
+		mx: .8,
+		my: 0,
+		color: "white"
+	},
+	levels: [
+		{
+			background: "lightgreen",
+			width: "50%"
+		},
+		{
+			background: "#ffc107",
+			width: "60%"
+		},
+		{
+			background: "orange",
+			width: "70%"
+		},
+		{
+			background: "red",
+			width: "80%"
+		}
+	]
+};
+//#endregion
+export { acAudioFileNames, acEnergyLabel, acIconPaths, acMaxTilt, acModeIcons, acMotion, acReducedMotionDuration, acReducedMotionQuery, acReducer, acShellSize, acSoundIcons, acSoundModeLabels, acSoundModes, acSoundVolumes, acStorageKey, acTone, celsiusToHeatLevel, clampTemperature, createAcAudioController, createAirConditionerStore, createComputePressureSource, createHeatGovernor, createMemoryStorage, defaultAcLimits, defaultAcState, defaultHeatThresholds, getAcActionNotification, getAcScale, getBrowserStorage, getRecommendedTemperatureMessage, getSoundModeMessage, heatLevelRank, heatLevels, isAcSoundMode, isHeatLevel, maxTemperature, minTemperature, nextAcSoundMode, normalizeAcState, observeAcScale, observeAcTilt, planCooling, prefersReducedMotion, readAcState, recommendedColdTemperature, recommendedHotTemperature, renderAcMotionCssVars, resolveAcAudioAssets, soundTimings, writeAcState };