Simplify table-scoped translation key; fix stale resolution; correct docstring

Simplification (feedback: this was overcomplicated): drop the validated_table gate entirely. cycle_select's table_href now just builds the translation key directly from whatever course table the device reports (washer_cycle + Table_02 -> washer_cycle_table_02) instead of comparing against a hardcoded known-good value and falling back to no key on any mismatch. A table we haven't shipped translations for yet (e.g. FlexWash's Table_00) still gets a key built for it -- Home Assistant's own missing-translation handling takes it from there, the same graceful fallback already relied on for any individual untranslated code within an existing table. Adding a newly-confirmed table later is just new strings.json entries, no code change. Independent (Opus) review of the prior version caught two real issues, fixed here regardless of the simplification above: - translation_key was resolved once at entity construction from whatever coordinator.last_resources held at that moment. Discovery can run while a sibling resource is still an empty stub (documented precedent: see _is_included), so a callable translation_key could permanently bake in a stale value for the entity's lifetime. Moved resolution into a translation_key property override (Entity.translation_key is a property upstream, not a plain attribute), re-evaluated against live coordinator data on every access, matching how options/current_option already work. - The supportedOptions fallback's "smallest passing K wins" docstring claimed every larger passing K is an exact multiple of the true one. False: the shipped dishwasher fixture has passing K=7 (true) alongside 10, 14, and 35, none of which are multiples of 7 -- position 0 always lands on the same real course code regardless of K, which alone satisfies the current-course guard for several unrelated splits. Corrected the reasoning to what's actually true (an empirically-matched heuristic across six real dumps, not a proof) and added a regression test locking in the real dishwasher case so this isn't silently lost.
Scope washer/dryer cycle translations to the device's own course table
2026-07-24 05:55:04 +00:00 · 2026-07-24 05:42:12 +00:00 · 2026-07-24 05:06:39 +00:00 · 2026-07-23 23:08:32 -05:00 · 2026-07-24 04:06:31 +00:00 · 2026-07-24 04:06:31 +00:00
56 changed files with 3738 additions and 89 deletions
@@ -17,9 +17,12 @@ Your state stays on your LAN: HA talks to the appliance over a direct DTLS sessi
 | Type | Registry |
 |---|---|
 | Air conditioner | `by_type/airconditioner.py` |
+| Air purifier | `by_type/air_purifier.py` |
 | Dryer | `by_type/dryer.py` |
 | Oven | `by_type/oven.py` |
-| Range / cooktop-oven combo | `by_type/range.py` |
+| Cooktop (read-only burner status) | `by_type/cooktop.py` |
+| Range hood | `by_type/range_hood.py` |
+| Range | `by_type/range.py` |
 | Dishwasher | `by_type/dishwasher.py` |
 | Refrigerator | `by_type/refrigerator.py` |
 | Washer | `by_type/washer.py` |
@@ -101,7 +104,7 @@ custom_components/localthings/
  diagnostics.py           Redacted diagnostics download (device state + coverage metadata)
  const.py                 Domain, config keys, probe ports
  entity.py                Base entity wiring capability registry -> HA entity
-  sensor.py / binary_sensor.py / switch.py / number.py / select.py / button.py / time.py / climate.py
+  sensor.py / binary_sensor.py / switch.py / number.py / select.py / button.py / time.py / fan.py / climate.py
                            One module per HA platform
  strings.json / translations/   Config-flow copy + entity state translations
  registry/
@@ -113,7 +116,8 @@ custom_components/localthings/
    identity.py              Reads device identity for type detection
    redact.py                 Strips account/identity data before diagnostics leave HA
    capabilities/             Shared + per-family Capability definitions (common, airconditioner,
-                               dryer, oven, dishwasher, fridge, washer, laundry, operational, ignored)
+                               cooktop, range_hood, dryer, oven, dishwasher, fridge, washer,
+                               laundry, operational, ignored)
    by_type/                  One DeviceRegistry per appliance type, composed from capabilities/
 tests/                    Registry composition, discovery, entity descriptors, coordinator/observe
                            behavior, and golden-file regression against captured device dumps
@@ -139,7 +143,7 @@ support for hardware the maintainers don't have.
 1. Get a capture of the appliance's `/device/0` response. The easiest way: add the device to HA (type detection failing is fine) and pull its Diagnostics download from Settings > Devices & Services > the device > the menu > Download diagnostics — it already contains a redacted dump of the device's resources.
 2. Reuse existing `Capability` objects from `registry/capabilities/` wherever the resource matches one already declared. Most `common.py` capabilities (power, kids lock, remote control, alarms, energy/water meters) are shared verbatim across families; add new ones only for resources unique to the new type.
 3. Create `registry/by_type/<name>.py` with a `DeviceRegistry(name=..., capabilities=_build([...]))`. Use `pattern_capabilities` instead of `capabilities` for any resource whose `href` isn't fixed (for example per-compartment fridge resources); see `refrigerator.py` for the pattern.
-4. Register it in `_REGISTRY_BY_KEY` in `registry/by_type/__init__.py`, keyed on the lowercased, space/hyphen-to-underscore-converted suffix of the device's `oneUiVersion` string (see `_type_key()` in that file for the exact transform). If the device never reports `oneUiVersion` — confirmed true for washers — add its consumer-model prefix to `_CONSUMER_PREFIX_TO_KEY` instead, so `for_device_by_model()` can route it.
+4. Register it in `_REGISTRY_BY_KEY` in `registry/by_type/__init__.py`, keyed on the lowercased, space/hyphen-to-underscore-converted suffix of the device's `oneUiVersion` string (see `_type_key()` in that file for the exact transform). If the device never reports `oneUiVersion`, add its consumer-model prefix to `_CONSUMER_PREFIX_TO_KEY` so `for_device_by_model()` can route it. If it also omits `/information/vs/0` (as the verified NA9300K cooktop does), add a distinctive, conservative resource-signature rule to `for_device_by_resources()`.
 5. Add golden-file coverage in `tests/` against a captured `/device/0` dump for the new type.

 No config-flow changes are needed. Device-type detection and entity wiring are fully driven by the registry.
@@ -13,9 +13,10 @@ snapshot via `coordinator.resource(href)` -- the same cross-resource read that

 Writes go through `coordinator.async_send_command(bound, (kind, value))`: the
 CLIMATE capability's `write_fn` maps each `(kind, value)` payload to the right
-`(path_segs, body)`, and `async_send_command` POSTs to those path_segs (the
-bound href is only used for logging), so one descriptor drives writes to power,
-mode, temperature and wind resources.
+`(path_segs, body)`, and `async_send_command` POSTs to those path_segs and
+applies the optimistic value/settle guard to that same href -- not the bound
+`/mode/vs/0` href -- so one descriptor drives writes to, and gets fresh state
+back for, power, mode, temperature and wind resources alike.
 """
 from __future__ import annotations

@@ -12,6 +12,7 @@ from typing import Any

 import voluptuous as vol
 from homeassistant import config_entries
+from homeassistant.core import callback
 from homeassistant.data_entry_flow import FlowResult
 from homeassistant.helpers.selector import (
    TextSelector,
@@ -24,6 +25,7 @@ from .const import (
    CONF_HOST, CONF_PORT,
    CONF_CA_CERT_PEM, CONF_CA_KEY_PEM,
    CONF_LEAF_CERT_PEM, CONF_LEAF_KEY_PEM,
+    CONF_BYPASS_REMOTE_CONTROL,
    PROBE_PORT_RANGE, PREFERRED_PROBE_PORTS, LIVENESS_PROBE_TIMEOUT_S,
    PROBE_GET_TIMEOUT_S,
 )
@@ -195,7 +197,9 @@ def _probe_and_validate(host: str, ca_cert_pem: str, ca_key_pem: str) -> dict:
    import cbor2
    from smartthings_local.protocol.dtls_session import DtlsCoapSession
    from .registry.batch import parse_device0_batch
-    from .registry.by_type import for_device, for_device_by_model
+    from .registry.by_type import (
+        for_device, for_device_by_model, for_device_by_resources,
+    )

    _LOGGER.debug("Fetching Samsung cloud UUID from %s", _SAMSUNG_CLOUD_HOST)
    try:
@@ -266,7 +270,7 @@ def _probe_and_validate(host: str, ca_cert_pem: str, ca_key_pem: str) -> dict:
            ) or for_device_by_model(
                info_resource.get('x.com.samsung.da.modelNum', ''),
                info_resource.get('x.com.samsung.da.description', ''),
-            )
+            ) or for_device_by_resources(resources)
            return {
                "port": port,
                "serial": serial,
@@ -298,6 +302,13 @@ class LocalThingsConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
        self._ca_key_pem: str = ""
        self._pending_info: dict | None = None

+    @staticmethod
+    @callback
+    def async_get_options_flow(
+        config_entry: config_entries.ConfigEntry,
+    ) -> LocalThingsOptionsFlow:
+        return LocalThingsOptionsFlow()
+
    def _create_entry(self, info: dict) -> FlowResult:
        return self.async_create_entry(
            title=f"Samsung Appliance ({self._host})",
@@ -382,3 +393,31 @@ class LocalThingsConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
                "one_ui_version": self._pending_info["one_ui_version"] or "(none reported)",
            },
        )
+
+
+class LocalThingsOptionsFlow(config_entries.OptionsFlow):
+    """Per-device override of the remote-control-off write block (issue
+    #54). The block exists because most devices reject writes outright
+    while remote control is off and a clear error beats a silent
+    device-side rejection -- but not every model actually enforces that,
+    so this lets a user who's confirmed their device accepts writes anyway
+    turn the block off for just that device rather than it being
+    hardcoded on for everyone."""
+
+    async def async_step_init(
+        self, user_input: dict[str, Any] | None = None
+    ) -> FlowResult:
+        if user_input is not None:
+            return self.async_create_entry(data=user_input)
+
+        return self.async_show_form(
+            step_id="init",
+            data_schema=vol.Schema({
+                vol.Required(
+                    CONF_BYPASS_REMOTE_CONTROL,
+                    default=self.config_entry.options.get(
+                        CONF_BYPASS_REMOTE_CONTROL, False
+                    ),
+                ): bool,
+            }),
+        )
@@ -1,6 +1,9 @@
 DOMAIN = "localthings"

-PLATFORMS = ["sensor", "binary_sensor", "switch", "number", "select", "button", "time", "climate"]
+PLATFORMS = [
+    "sensor", "binary_sensor", "switch", "number", "select", "button",
+    "time", "climate", "fan",
+]

 CONF_HOST         = "host"
 CONF_PORT         = "port"
@@ -9,6 +12,16 @@ CONF_CA_KEY_PEM   = "ca_key_pem"
 CONF_LEAF_CERT_PEM = "leaf_cert_pem"
 CONF_LEAF_KEY_PEM  = "leaf_key_pem"

+# Options-flow key (entry.options, not entry.data): lets a user override the
+# device-wide remote-control-off write block for a specific device (issue
+# #54). Some devices report remote control off yet still accept certain
+# writes (e.g. default detergent/softener dosing on a washer, applied even
+# to the built-in programs) -- the block exists to give a clear error
+# instead of a silent device-side rejection, but that assumption doesn't
+# hold for every model. Defaults to False (block stays on) everywhere it's
+# read, so devices this doesn't apply to see no behavior change.
+CONF_BYPASS_REMOTE_CONTROL = "bypass_remote_control_lock"
+
 # The DTLS/CoAP local API binds somewhere in this ephemeral range; which port
 # depends on firmware. Newer builds answer on 49154/49155, but older ones have
 # been seen as low as 49153, so we sweep the whole range for a live UDP port
@@ -21,7 +21,7 @@ from smartthings_local.protocol.dtls_session import DtlsCoapSession
 from smartthings_local.ocf.state_cache import StateCache

 from .registry.batch import parse_device0_batch
-from .registry.by_type import for_device, for_device_by_model
+from .registry.by_type import for_device, for_device_by_model, for_device_by_resources
 from .registry.capabilities.common import remote_control_enabled
 from .registry.discovery import discover, BoundEntity
 from .registry import CAPABILITIES
@@ -31,7 +31,7 @@ from .observe import ObserveManager, MODE_OBSERVE, MODE_POLL, GRACE_PERIOD_S

 from .const import (
    DOMAIN, CONF_HOST, CONF_PORT, CONF_LEAF_CERT_PEM, CONF_LEAF_KEY_PEM,
-    DEVICE_SUPPORT_ISSUE_URL, SUMMARY_INTERVAL_S,
+    CONF_BYPASS_REMOTE_CONTROL, DEVICE_SUPPORT_ISSUE_URL, SUMMARY_INTERVAL_S,
 )

 _LOGGER = logging.getLogger(__name__)
@@ -77,6 +77,14 @@ class LocalThingsCoordinator(DataUpdateCoordinator[dict[str, Any]]):
    # fine session shouldn't tear down a working OBSERVE subscription.
    _POLL_TIMEOUT_LIMIT: int = 3

+    # Timeouts for the two network round trips a write triggers: the PUT
+    # itself (_do_put), then the confirming full /device/0 summary poll
+    # async_send_command requests right after (_poll_once). Named here
+    # (rather than left as inline literals) so the write-settle window
+    # below can be sized to always outlast both — see async_send_command.
+    _POST_TIMEOUT_S: float = 8.0
+    _POLL_TIMEOUT_S: float = 35.0
+
    def __init__(self, hass: HomeAssistant, entry: ConfigEntry) -> None:
        # Per-device logger (module logger scoped to this device's host) so
        # every log line — including the base DataUpdateCoordinator's own
@@ -211,7 +219,7 @@ class LocalThingsCoordinator(DataUpdateCoordinator[dict[str, Any]]):
            # would have succeeded, not a dead session. 35s gives a slow
            # blockwise transfer room to actually finish instead of
            # generating a TimeoutError every cycle.
-            code, payload = sess.get(_SEED_PATH, timeout=35.0)
+            code, payload = sess.get(_SEED_PATH, timeout=self._POLL_TIMEOUT_S)
        except TimeoutError:
            raise
        except Exception as e:
@@ -295,6 +303,8 @@ class LocalThingsCoordinator(DataUpdateCoordinator[dict[str, Any]]):
                info.get('x.com.samsung.da.modelNum', ''),
                info.get('x.com.samsung.da.description', ''),
            )
+        if reg is None:
+            reg = for_device_by_resources(resources)
        unbound: list[str] = []
        if reg is not None:
            self._log.debug("device type: %s (oneUiVersion=%r)", reg.name, one_ui)
@@ -314,7 +324,7 @@ class LocalThingsCoordinator(DataUpdateCoordinator[dict[str, Any]]):
        self.device_serial = serial

        ident = self._identity
-        device_type = reg.name.title() if reg else 'Appliance'
+        device_type = reg.name.replace('_', ' ').title() if reg else 'Appliance'
        model_num = info.get('x.com.samsung.da.modelNum', '')
        model = model_num.split('|', 1)[0] if model_num else (ident.model if ident else '')
        name  = f"Samsung {device_type} ({model})" if model else f"Samsung {device_type}"
@@ -524,7 +534,11 @@ class LocalThingsCoordinator(DataUpdateCoordinator[dict[str, Any]]):
        user-facing message -- as opposed to write_fn's silent no-op below
        -- is available to every platform for free. The remote-control
        check runs first and applies to every platform unconditionally,
-        ahead of any description-specific validate_fn."""
+        ahead of any description-specific validate_fn -- unless the user has
+        opted this device out of it via CONF_BYPASS_REMOTE_CONTROL (issue
+        #54: some devices accept certain writes, e.g. a washer's default
+        dosing levels, even while reporting remote control off, so the
+        block's assumption doesn't hold for every model)."""
        desc = bound_entity.desc
        write_fn = getattr(desc, 'write_fn', None)
        if write_fn is None:
@@ -532,7 +546,8 @@ class LocalThingsCoordinator(DataUpdateCoordinator[dict[str, Any]]):
        href = bound_entity.href
        rep = self._cache.get(href or '') or {}
        resources = self._cache.snapshot()
-        if not remote_control_enabled(resources):
+        bypass_remote_control = self._entry.options.get(CONF_BYPASS_REMOTE_CONTROL, False)
+        if not bypass_remote_control and not remote_control_enabled(resources):
            raise ServiceValidationError(_REMOTE_CONTROL_DISABLED_MESSAGE)
        validate_fn = getattr(desc, 'validate_fn', None)
        if validate_fn is not None:
@@ -545,6 +560,22 @@ class LocalThingsCoordinator(DataUpdateCoordinator[dict[str, Any]]):
            return
        path_segs, body = result

+        # The write's actual target, not necessarily bound_entity.href. Most
+        # descriptors write to the same resource they're bound to, but a
+        # composite entity -- the AC's ClimateDesc, bound to /mode/vs/0 --
+        # drives writes to several sibling resources via path_segs
+        # (/power/0, /temperature/desired/0, /wind/strength/vs/0, ...) that
+        # write_fn picks per payload (see airconditioner._climate_write).
+        # Applying the optimistic value and settle guard below to
+        # bound_entity.href instead of this target protected the wrong
+        # resource: /mode/vs/0 got the (nonsensical, wrong-shaped) optimistic
+        # merge while the resource the climate entity actually displays from
+        # (e.g. /power/0) never got one, so HA kept showing the pre-write
+        # state until the next real read of that resource -- the 20-60s lag
+        # in issues #17/#53, which survived the earlier optimistic-apply fix
+        # (issue #27) because that fix applied to the wrong href too.
+        write_href = '/' + '/'.join(path_segs)
+
        # Apply the write optimistically before starting the settle guard,
        # not after -- mark_write_pending gates every source (poll, sweep,
        # observe) through the same apply(), itself included, so flipping
@@ -553,19 +584,49 @@ class LocalThingsCoordinator(DataUpdateCoordinator[dict[str, Any]]):
        # onto, the settle window was just delaying the real device
        # confirmation for a few seconds on every write, which read exactly
        # like the write being silently reverted (issue #27).
-        self._observe.apply(href, body, source='optimistic')
-        self._observe.mark_write_pending(href)
+        #
+        # settle_s must outlast the PUT and the async_request_refresh()
+        # below combined, not just DEFAULT_SETTLE_S's fixed few seconds --
+        # that refresh is a full /device/0 summary poll, which
+        # _POLL_TIMEOUT_S itself admits can legitimately take tens of
+        # seconds on these devices (see _poll_once), and some writes settle
+        # on the device itself well after that: issue #9's washer packs
+        # cycle/detergent/softener selection into the same /course/vs/0
+        # options[] array, and picking a new value there visibly needs a
+        # few seconds of internal validation/dispenser movement before the
+        # device's own state agrees -- while /washer/vs/0's temperature/
+        # spin fields (plain flags, no device-side settling) confirm
+        # instantly on the same device. A short fixed window expired while
+        # the confirm poll was still in flight (or before the device had
+        # caught up internally), so that stale read landed unprotected and
+        # reverted the optimistic value, self-correcting again only once a
+        # later poll finally saw the real change -- read by the user as the
+        # write "reverting, then re-applying itself" a few seconds later.
+        #
+        # An earlier attempt at this also released the guard early, right
+        # after the confirming refresh completed, to avoid shutting out
+        # unrelated real updates (another automation, the physical remote)
+        # for the rest of settle_s. That was reverted: releasing the guard
+        # the moment one round trip finishes doesn't mean the device has
+        # actually caught up (exactly the slow-settling case above), and it
+        # introduced its own races around overlapping writes to the same
+        # href. Simpler and safer to just hold the guard for the full,
+        # generously-sized window and let it expire on its own.
+        self._observe.apply(write_href, body, source='optimistic')
+        self._observe.mark_write_pending(
+            write_href, settle_s=self._POST_TIMEOUT_S + self._POLL_TIMEOUT_S
+        )

        def _do_put():
            sess = self._session
            if sess is None:
                raise RuntimeError("no session")
-            code, _ = sess.post(path_segs, cbor2.dumps(body), timeout=8.0)
-            self._log.info("PUT %s → code %#04x", href, code)
+            code, _ = sess.post(path_segs, cbor2.dumps(body), timeout=self._POST_TIMEOUT_S)
+            self._log.info("PUT %s → code %#04x", write_href, code)

        try:
            await self.hass.async_add_executor_job(_do_put)
        except Exception as e:
-            self._log.error("command failed for %s: %s", href, e)
+            self._log.error("command failed for %s: %s", write_href, e)
        else:
            await self.async_request_refresh()
@@ -66,12 +66,30 @@ class LocalThingsEntity(CoordinatorEntity[LocalThingsCoordinator]):
            self._attr_name = f"{bound.instance_name} {_derive_name(bound.desc.key)}".strip()
        else:
            self._attr_name = _derive_name(self._state_key)
-        self._attr_translation_key = bound.desc.translation_key
        self._attr_icon = bound.desc.icon
        raw_cat = bound.desc.entity_category
        self._attr_entity_category = EntityCategory(raw_cat) if raw_cat else None
        self._attr_entity_registry_enabled_default = bound.desc.enabled_default

+    @property
+    def translation_key(self) -> str | None:
+        """Override Entity.translation_key (a property upstream, not a
+        plain attribute) so a callable descriptor -- e.g.
+        laundry.cycle_select's table-id-gated resolver -- is re-evaluated
+        against live coordinator data on every access, not resolved once
+        at construction time.
+
+        Discovery runs on the first /device/0 poll, which the entity
+        registry already documents can hand a sibling resource an empty
+        stub rep before it's actually been fetched (see _is_included's
+        docstring) -- a static one-time resolution here would risk baking
+        in a permanent None (no translation) for the entity's whole
+        lifetime if that stub hadn't populated yet, even once the real
+        value arrives on a later poll.
+        """
+        tk = self._bound.desc.translation_key
+        return tk(self.coordinator.last_resources) if callable(tk) else tk
+
    @property
    def device_info(self) -> DeviceInfo:
        return self.coordinator.device_info
@@ -0,0 +1,122 @@
+"""Fan platform for Samsung range hoods."""
+
+from __future__ import annotations
+
+from homeassistant.components.fan import FanEntity, FanEntityFeature
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
+from homeassistant.util.percentage import (
+    ordered_list_item_to_percentage,
+    percentage_to_ordered_list_item,
+)
+
+from .const import DOMAIN
+from .coordinator import LocalThingsCoordinator
+from .entity import LocalThingsEntity, _is_included
+from .registry.entities import FanDesc
+
+
+POWER_HREF = '/power/0'
+POWER_VS_HREF = '/power/vs/0'
+_FAN_SPEED_FIELD = 'x.com.samsung.da.hood.fanSpeed'
+_SUPPORTED_FAN_SPEED_FIELD = 'x.com.samsung.da.hood.supportedFanSpeed'
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: ConfigEntry,
+    async_add_entities: AddEntitiesCallback,
+) -> None:
+    coordinator: LocalThingsCoordinator = hass.data[DOMAIN][entry.entry_id]
+    async_add_entities(
+        LocalThingsRangeHoodFan(coordinator, bound)
+        for bound in coordinator.bound
+        if isinstance(bound.desc, FanDesc) and _is_included(bound, coordinator)
+    )
+
+
+class LocalThingsRangeHoodFan(LocalThingsEntity, FanEntity):
+    """A hood fan combining sibling power and fan-speed resources."""
+
+    _enable_turn_on_off_backwards_compatibility = False
+    _attr_supported_features = (
+        FanEntityFeature.SET_SPEED
+        | FanEntityFeature.TURN_ON
+        | FanEntityFeature.TURN_OFF
+    )
+
+    def __init__(self, coordinator: LocalThingsCoordinator, bound) -> None:
+        super().__init__(coordinator, bound)
+        self._attr_name = None
+
+    def _rep(self, href: str) -> dict:
+        return self.coordinator.resource(href) or {}
+
+    def _all_speed_codes(self) -> list[str]:
+        rep = self._rep(self._bound.href)
+        return [str(value) for value in rep.get(_SUPPORTED_FAN_SPEED_FIELD, ())]
+
+    def _active_speed_codes(self) -> list[str]:
+        # Power is carried by the separate /power resource.  fanSpeed retains
+        # the selected setting while power is off (as the lamp's `current`
+        # field does), so every advertised code is an active ordered speed.
+        return self._all_speed_codes()
+
+    def _power_payload(self, enabled: bool) -> tuple[str, bool, str]:
+        """Target whichever power resource this hood actually exposes."""
+        resources = self.coordinator.last_resources
+        target = POWER_HREF if POWER_HREF in resources else POWER_VS_HREF
+        return 'power', enabled, target
+
+    @property
+    def is_on(self) -> bool:
+        rep = self._rep(POWER_HREF)
+        if 'value' in rep:
+            return bool(rep.get('value'))
+        return str(
+            self._rep(POWER_VS_HREF).get('x.com.samsung.da.power', '')
+        ).lower() == 'on'
+
+    @property
+    def speed_count(self) -> int:
+        return len(self._active_speed_codes())
+
+    @property
+    def percentage(self) -> int | None:
+        if not self.is_on:
+            return 0
+        codes = self._active_speed_codes()
+        current = str(self._rep(self._bound.href).get(_FAN_SPEED_FIELD, ''))
+        if not codes or current not in codes:
+            return None
+        return ordered_list_item_to_percentage(codes, current)
+
+    async def async_turn_on(
+        self, percentage: int | None = None, preset_mode: str | None = None,
+        **kwargs,
+    ) -> None:
+        await self.coordinator.async_send_command(
+            self._bound, self._power_payload(True),
+        )
+        if percentage is not None:
+            await self.async_set_percentage(percentage)
+
+    async def async_turn_off(self, **kwargs) -> None:
+        await self.coordinator.async_send_command(
+            self._bound, self._power_payload(False),
+        )
+
+    async def async_set_percentage(self, percentage: int) -> None:
+        if percentage <= 0:
+            await self.async_turn_off()
+            return
+        codes = self._active_speed_codes()
+        if not codes:
+            return
+        if not self.is_on:
+            await self.coordinator.async_send_command(
+                self._bound, self._power_payload(True),
+            )
+        code = percentage_to_ordered_list_item(codes, percentage)
+        await self.coordinator.async_send_command(self._bound, ('speed', code))
@@ -12,5 +12,5 @@
    "pyOpenSSL>=23.0",
    "smartthings-local>=0.1.0"
  ],
-  "version": "0.10.1"
+  "version": "0.11.1"
 }
@@ -115,8 +115,22 @@ class ObserveManager:
        could each read the same prior rep and the second writer would
        silently lose the first's fields, reintroducing the exact bug
        this merge fixes.
+
+        `source == 'optimistic'` always bypasses the settle gate below,
+        even while this href is already settling from an earlier write.
+        Several independent selects can share one href -- issue #9's washer
+        packs cycle, detergent, and softener settings onto the same
+        /course/vs/0 -- so a second, different write to the same href
+        while the first's settle window is still open (up to
+        _POST_TIMEOUT_S + _POLL_TIMEOUT_S, tens of seconds -- see
+        coordinator.async_send_command) is an expected, normal sequence,
+        not a stale echo of the first write. Gating it the same as a
+        poll/sweep/observe update would silently drop the user's own
+        second selection from the cache until the first write's guard
+        happened to expire, i.e. the exact symptom this guard exists to
+        prevent, just relocated to whichever write loses the race.
        """
-        if self._is_settling(href):
+        if source != 'optimistic' and self._is_settling(href):
            self.log.debug("dropping %s update for %s (settling)", source, href)
            return False
        with self._cache_lock:
@@ -2,18 +2,29 @@
 from typing import Optional

 from ._base import DeviceRegistry
-from . import airconditioner, dishwasher, dryer, oven, range as _range, refrigerator, washer
+from . import (
+    air_purifier, airconditioner, cooktop, dishwasher, dryer, oven,
+    range as _range, range_hood, refrigerator, washer,
+)

-__all__ = ['DeviceRegistry', '_type_key', 'for_device', 'for_device_by_model']
+__all__ = [
+    'DeviceRegistry', '_type_key', 'for_device', 'for_device_by_model',
+    'for_device_by_resources',
+]


 _REGISTRY_BY_KEY: dict[str, DeviceRegistry] = {
+    'air_purifier': air_purifier.REGISTRY,
+    'airpurifier': air_purifier.REGISTRY,
    'airconditioner': airconditioner.REGISTRY,
    'air_conditioner': airconditioner.REGISTRY,
+    'cooktop': cooktop.REGISTRY,
    'dishwasher': dishwasher.REGISTRY,
    'dryer': dryer.REGISTRY,
    'oven': oven.REGISTRY,
+    'hood': range_hood.REGISTRY,
    'range': _range.REGISTRY,
+    'range_hood': range_hood.REGISTRY,
    'refrigerator': refrigerator.REGISTRY,
    'washer': washer.REGISTRY,
 }
@@ -102,9 +113,61 @@ def for_device_by_model(model_num: str, description: str) -> Optional[DeviceRegi
    # 'P' sits between the underscore and 'RAC' in that token).
    if key is None and '_RAC_' in (model_num or ''):
        key = 'airconditioner'
+    # System air conditioners (multi-indoor-unit commercial installs, e.g.
+    # A-CAWW-TP2-20-COMMON, issue #52) report no oneUiVersion either and
+    # carry the '-CAWW-' board-family token instead of '_RAC_'/'_PRAC_'.
+    # Same TP1X/TP2X-class resource surface as the room-AC models above
+    # (confirmed by the issue #52 dump binding cleanly against the existing
+    # airconditioner registry once routed here), plus one new SAC-specific
+    # resource (see airconditioner.py's _AC_IGNORED).
+    if key is None and '-CAWW-' in (model_num or '').upper():
+        key = 'airconditioner'
+    # Air purifiers (e.g. ARTIK051_TVTL_18K, issue #56) report no
+    # oneUiVersion either, and carry the '_TVTL_' board-family token.
+    if key is None and '_TVTL_' in (model_num or ''):
+        key = 'air_purifier'
+    model_identity = f'{model_num} {description}'.upper()
+    if key is None and ('_COOKTOP' in model_identity or '_GB_CT_' in model_identity):
+        key = 'cooktop'
+    if key is None and model_identity.startswith('AHD-'):
+        key = 'range_hood'
    # Range/cooktop-oven combos (e.g. TP1X_DA-KS-RANGE-0102X, issue #44) --
    # like the RAC/PRAC air conditioners above, these report no oneUiVersion
    # and don't match the washer/dryer/dishwasher consumer-prefix map either.
    if key is None and '-RANGE-' in (model_num or '').upper():
        key = 'range'
+    # Wall ovens (e.g. TP1X_DA-KS-OVEN-0107X, issue #55) -- same board-family
+    # naming as the range combo above, minus the burners; also reports no
+    # oneUiVersion and doesn't match the washer/dryer/dishwasher prefix map.
+    if key is None and '-OVEN-' in (model_num or '').upper():
+        key = 'oven'
    return _REGISTRY_BY_KEY.get(key) if key else None
+
+
+def for_device_by_resources(resources: dict[str, dict]) -> Optional[DeviceRegistry]:
+    """Detect a device family from a distinctive local-resource signature.
+
+    Some newer cooktops omit both ``oneUiVersion`` and
+    ``/information/vs/0``.  Their mode resource still identifies them: it
+    contains a DeviceType option and multiple per-burner OperationState
+    options.  Require both shapes so an oven's unrelated ``/mode/vs/0`` is
+    not misclassified.
+    """
+    mode = resources.get('/mode/vs/0', {})
+    options = mode.get('x.com.samsung.da.options') or ()
+    has_device_type = any(
+        isinstance(option, str) and option.startswith('DeviceType_')
+        for option in options
+    )
+    operation_states = sum(
+        1 for option in options
+        if isinstance(option, str) and option.startswith('OperationState')
+    )
+    if has_device_type and operation_states >= 2:
+        return _REGISTRY_BY_KEY['cooktop']
+    if (
+        '/hood/fanspeed/vs/0' in resources
+        and '/hood/lamp/vs/0' in resources
+    ):
+        return _REGISTRY_BY_KEY['range_hood']
+    return None
@@ -0,0 +1,25 @@
+"""Air-purifier device registry (Samsung ARTIK051_TVTL-class, issue #56).
+
+Reports no oneUiVersion; resolved via for_device_by_model's '_TVTL_' modelNum
+token (see registry.py). Reuses dishwasher.DIAGNOSIS for /diagnosis/vs/0
+(identical field/write contract).
+"""
+from ..capabilities import air_purifier, common, dishwasher, ignored
+from ._base import DeviceRegistry, _build
+
+REGISTRY = DeviceRegistry(
+    name='air_purifier',
+    capabilities=_build([
+        *ignored.IGNORED,
+        *common.UNIVERSAL,
+        *common.POWER,
+        dishwasher.DIAGNOSIS,
+        air_purifier.AIR_QUALITY,
+        air_purifier.FILTER,
+        air_purifier.DEVICE_ACTIVE,
+        air_purifier.AIRFLOW_GENERIC,
+        air_purifier.AIRFLOW_VS_FALLBACK,
+        air_purifier.MODE,
+        *air_purifier.COVERAGE,
+    ]),
+)
@@ -0,0 +1,17 @@
+"""Cooktop device registry."""
+
+from ..capabilities import common, cooktop, ignored
+from ._base import DeviceRegistry, _build
+
+
+REGISTRY = DeviceRegistry(
+    name='cooktop',
+    capabilities=_build([
+        *ignored.IGNORED,
+        cooktop.COOKTOP_POWER,
+        cooktop.COOKTOP_MODE,
+        cooktop.COOKTOP_CONNECTED,
+        cooktop.PAIRED_HOOD_STATUS,
+        common.FIRMWARE_UPDATE,
+    ]),
+)
@@ -0,0 +1,22 @@
+"""Range-hood device registry."""
+
+from ..capabilities import common, ignored, range_hood
+from ._base import DeviceRegistry, _build
+
+
+REGISTRY = DeviceRegistry(
+    name='range_hood',
+    capabilities=_build([
+        *ignored.IGNORED,
+        range_hood.HOOD_ALARMS,
+        common.ENERGY_METER,
+        common.FIRMWARE_UPDATE,
+        range_hood.HOOD_FAN,
+        range_hood.HOOD_LAMP,
+        range_hood.HOOD_FILTER,
+        range_hood.AIR_QUALITY,
+        range_hood.AIR_LEVEL_CHECK,
+        range_hood.AUTO_VENTILATION,
+        *range_hood.COVERAGE,
+    ]),
+)
@@ -1,4 +1,7 @@
-from . import common, dishwasher, fridge, ignored, laundry, operational, oven
+from . import (
+    common, cooktop, dishwasher, fridge, ignored, laundry, operational, oven,
+    range_hood,
+)
 from ..capability import Capability


@@ -0,0 +1,164 @@
+"""Capabilities for the Samsung ARTIK051_TVTL-class air purifier family
+(model AX60R5080WD/SE, issue #56 -- verified against two independent
+diagnostics dumps of the same internal model).
+
+Power, kids-lock, remote-control, alarms, and the energy meter are the shared
+common.py capabilities (this family exposes the standard /power/0+/power/vs/0
+pair and /alarms/vs/0, /energy/consumption/vs/0). /diagnosis/vs/0 reuses
+dishwasher.DIAGNOSIS -- identical field/write contract
+(x.com.samsung.da.diagnosisStart, 'Ready' on both dumps).
+
+Two things are deliberately left as raw, unwritable diagnostic sensors rather
+than modeled as real controls, per the "don't guess" rule:
+
+  /airflow/0, /airflow/vs/0 -- OCF-standard + vendor pair for fan speed/
+    direction, both zeroed/'Off' on every dump seen (device was off in both).
+    No supportedSpeed/supportedModes list is present anywhere in either dump
+    to confirm the valid range, so a write-capable fan/select isn't safe to
+    build yet -- see the issue #56 request for a running-state dump.
+
+  /mode/vs/0's x.com.samsung.da.options array packs multiple independent
+    '<Prefix>_<value>' flags into one list -- the same packed-list/RMW
+    contract laundry.py's option_value/replace_in_options already model for
+    /course/vs/0's options[] (reused directly below, just against this
+    family's own href). Of the tokens seen:
+      Light_On / Light_Off       -- read as a plain on/off flag; MODE below
+                                     models it as a real switch, RMW-
+                                     replacing just that one list entry.
+      Comode_Off                 -- never seen non-'Off' on these dumps;
+                                     likely the fan operating mode the issue
+                                     describes (Auto/Sleep/1/2/3), but
+                                     unconfirmed -- exposed read-only.
+      Blooming_0 / Blooming_6     -- meaning unconfirmed; exposed read-only.
+      OptionCode_60282            -- opaque, unchanged across both dumps;
+                                     not modeled (same treatment as
+                                     range_hood's OptionCode_* token on the
+                                     same href).
+"""
+from ..capability import Capability
+from ..entities import BinarySensorDesc, SensorDesc, SwitchDesc
+from .common import int_or_none, sensor_item_value
+from .laundry import bool_option_exists, bool_option_value, option_value, replace_in_options
+
+_AIR_QUALITY_SENSORS = (
+    ('dust', 'Dust', 'mdi:blur', 'Dust'),
+    ('fine_dust', 'Fine dust', 'mdi:blur', 'FineDust'),
+    ('super_fine_dust', 'Super fine dust', 'mdi:blur', 'SuperFineDust'),
+    ('odor', 'Odor', 'mdi:scent', 'Odor'),
+    ('clean_level', 'Clean level', 'mdi:air-filter', 'CleanLevel'),
+)
+
+AIR_QUALITY = Capability(
+    href='/sensors/vs/0',
+    poll_tier='warm',
+    entities=tuple(
+        SensorDesc(key=key, field='x.com.samsung.da.items', name=name, icon=icon,
+                   value_fn=lambda items, t=sensor_type: sensor_item_value(items, t))
+        for key, name, icon, sensor_type in _AIR_QUALITY_SENSORS
+    ),
+)
+
+
+def _consumable_state(items, name):
+    """Read a `/consumable/vs/0`-style items[] entry -- {name, state} pairs,
+    unlike AIR_QUALITY's {type, value} shape above."""
+    for item in items or ():
+        if isinstance(item, dict) and item.get('x.com.samsung.da.name') == name:
+            return item.get('x.com.samsung.da.state')
+    return None
+
+
+# FilterProgress is a raw 0-100 percentage in both dumps (100 and 62); which
+# end of that scale means "replace me" isn't confirmed from the dump alone,
+# so the entity is named after the raw field rather than asserting a
+# direction (see issue #56 follow-up questions).
+FILTER = Capability(
+    href='/consumable/vs/0',
+    poll_tier='cold',
+    entities=(
+        SensorDesc(key='filter_progress', field='x.com.samsung.da.items',
+                   name='Filter progress', unit='%', state_class='measurement',
+                   icon='mdi:air-filter', entity_category='diagnostic',
+                   value_fn=lambda items: int_or_none(
+                       _consumable_state(items, 'FilterProgress'))),
+    ),
+)
+
+DEVICE_ACTIVE = Capability(
+    href='/devicespecificinfo/vs/0',
+    poll_tier='cold',
+    entities=(
+        BinarySensorDesc(key='device_active', field='x.com.samsung.da.deviceActive',
+                          name='Device active', icon='mdi:check-network-outline',
+                          entity_category='diagnostic',
+                          value_fn=lambda v: bool(v)),
+    ),
+)
+
+# OCF-native / vendor pair for fan speed+direction -- see module docstring for
+# why these are read-only for now.
+AIRFLOW_GENERIC = Capability(
+    href='/airflow/0',
+    poll_tier='warm',
+    entities=(
+        SensorDesc(key='fan_speed_level', field='speed',
+                   name='Fan speed level', icon='mdi:fan',
+                   state_class='measurement', entity_category='diagnostic'),
+        SensorDesc(key='fan_direction', field='direction',
+                   name='Fan direction', icon='mdi:rotate-3d-variant',
+                   entity_category='diagnostic'),
+    ),
+)
+
+AIRFLOW_VS_FALLBACK = Capability(
+    href='/airflow/vs/0',
+    match_fn=lambda rep, resources: '/airflow/0' not in resources,
+    poll_tier='warm',
+    entities=(
+        SensorDesc(key='fan_speed_level', field='x.com.samsung.da.speedLevel',
+                   name='Fan speed level', icon='mdi:fan',
+                   state_class='measurement', entity_category='diagnostic',
+                   value_fn=int_or_none),
+        SensorDesc(key='fan_direction', field='x.com.samsung.da.direction',
+                   name='Fan direction', icon='mdi:rotate-3d-variant',
+                   entity_category='diagnostic'),
+    ),
+)
+
+
+def _light_write(payload, rep, href=None):
+    opts = list(rep.get('x.com.samsung.da.options') or [])
+    return ['mode', 'vs', '0'], {
+        'x.com.samsung.da.options': replace_in_options(opts, 'Light', payload),
+    }
+
+
+MODE = Capability(
+    href='/mode/vs/0',
+    poll_tier='warm',
+    entities=(
+        SwitchDesc(key='display_light', name='Display light', icon='mdi:led-on',
+                   entity_category='config',
+                   rep_fn=bool_option_value('Light'),
+                   exists_fn=bool_option_exists('Light'),
+                   write_fn=_light_write),
+        # Read-only pending issue #56 follow-up -- see module docstring.
+        SensorDesc(key='operating_mode', name='Operating mode', icon='mdi:fan',
+                   entity_category='diagnostic',
+                   rep_fn=lambda rep: option_value(rep.get('x.com.samsung.da.options'), 'Comode'),
+                   exists_fn=bool_option_exists('Comode')),
+        SensorDesc(key='blooming_level', name='Blooming level', icon='mdi:flower',
+                   entity_category='diagnostic',
+                   rep_fn=lambda rep: option_value(rep.get('x.com.samsung.da.options'), 'Blooming'),
+                   exists_fn=bool_option_exists('Blooming')),
+    ),
+)
+
+# /humidity/0 and /humidity/vs/0 are empty {} on both dumps this family has
+# been verified against -- covered here (not globally, per ignored.py's
+# module docstring) since those hrefs collide with fridge/AC schemas
+# elsewhere. Same two hrefs and reasoning as airconditioner.py's _AC_IGNORED.
+COVERAGE = [
+    Capability(href='/humidity/0'),
+    Capability(href='/humidity/vs/0'),
+]
@@ -243,6 +243,11 @@ _AC_IGNORED = [
    '/remotetemperature/vs/0',     # external temp-sensor feed (unset on this unit)
    '/reserverulesets/vs/0',       # opaque hex-encoded schedule reservation blob
    '/welcome/temperature/vs/0',   # welcome-cooling plumbing
+    # System-AC-only (multi-indoor-unit commercial installs, e.g.
+    # A-CAWW-TP2-20-COMMON, issue #52): opaque hex-encoded installation
+    # topology -- indoor/outdoor unit pairing, per-unit serials, MCU info.
+    # Commissioning-time plumbing, not user-actionable appliance state.
+    '/sac/installationinfo/vs/0',
 ]

 # Built as bare no-entity caps; folded into the AC registry (not global).
@@ -23,6 +23,13 @@ def _num(v):
        return None


+def int_or_none(v):
+    try:
+        return int(v)
+    except (TypeError, ValueError):
+        return None
+
+
 def clamp_power(v):
    n = _num(v)
    return 0.0 if (n is not None and n < 0) else n
@@ -58,6 +65,26 @@ def _active_alarm_codes(items):
    return ', '.join(codes) if codes else 'none'


+def sensor_item_value(items, sensor_type, index=0):
+    """Pull one reading out of a `/sensors/vs/0`-style items[] list -- each
+    item is `{type, value: [...]}`; `index` picks which slot of a possibly
+    multi-value reading to read (index 0 is the raw measurement on every
+    family seen so far). Shared by range_hood.AIR_QUALITY and
+    air_purifier.AIR_QUALITY, which read the same resource shape."""
+    for item in items or ():
+        if not isinstance(item, dict):
+            continue
+        if item.get('x.com.samsung.da.type') != sensor_type:
+            continue
+        values = item.get('x.com.samsung.da.value') or ()
+        if index < len(values):
+            try:
+                return int(values[index])
+            except (TypeError, ValueError):
+                return None
+    return None
+
+
 # OCF-native / vendor '-vs' fallback pairs for power, kids-lock, remote control.
 #
 # These three controls exist as both a standard OCF resource (/power/0,
@@ -0,0 +1,195 @@
+"""Read-only capabilities for Samsung cooktops.
+
+The first verified device is an NA9300K-class five-burner gas cooktop.  Its
+local OCF API reports burner state as strings embedded in the
+``x.com.samsung.da.options`` array on ``/mode/vs/0``.  Heat-producing controls
+are intentionally not exposed: the local write contract is unverified and a
+cooktop must not be remotely ignited by an automation.
+"""
+
+import re
+
+from ..capability import Capability
+from ..entities import BinarySensorDesc, SensorDesc
+
+
+_INACTIVE_OPERATION_STATES = {'Off', 'Ready'}
+
+
+def _option_value(options, prefix):
+    """Return the value from the first ``<prefix>_<value>`` option."""
+    marker = prefix + '_'
+    for option in options or ():
+        if isinstance(option, str) and option.startswith(marker):
+            return option[len(marker):]
+    return None
+
+
+def _operation_slots(options) -> tuple[int, ...]:
+    """Return the numeric burner slots advertised in an options array."""
+    slots = set()
+    for option in options or ():
+        if not isinstance(option, str):
+            continue
+        match = re.match(r'^OperationState(\d+)_', option)
+        if match:
+            slots.add(int(match.group(1)))
+    return tuple(sorted(slots))
+
+
+def _any_burner_active(options):
+    """True when any advertised burner slot is not idle."""
+    states = [
+        _option_value(options, f'OperationState{slot}')
+        for slot in _operation_slots(options)
+    ]
+    states = [state for state in states if state is not None]
+    return any(state not in _INACTIVE_OPERATION_STATES for state in states)
+
+
+def _int_or_none(value):
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return None
+
+
+COOKTOP_POWER = Capability(
+    href='/power/vs/0',
+    poll_tier='hot',
+    entities=(
+        BinarySensorDesc(
+            key='power_state',
+            field='x.com.samsung.da.power',
+            name='Power state',
+            device_class='power',
+            icon='mdi:stove',
+            value_fn=lambda value: str(value).lower() == 'on',
+        ),
+    ),
+)
+
+
+# The verified NA9300K exposes physical slots 0, 1, 3, 4, and 5.  Declare a
+# generous static superset so variants with other layouts are not silently
+# omitted; exists_fn hides every slot the live options array does not report.
+# Replace this bound with data-driven entity generation when #31 lands.
+_SUPPORTED_OPERATION_SLOTS = tuple(range(8))
+
+COOKTOP_MODE = Capability(
+    href='/mode/vs/0',
+    poll_tier='hot',
+    entities=(
+        BinarySensorDesc(
+            key='any_burner_active',
+            field='x.com.samsung.da.options',
+            name='Any burner active',
+            device_class='running',
+            icon='mdi:fire',
+            value_fn=_any_burner_active,
+        ),
+        *(
+            SensorDesc(
+                key=f'burner_{slot}_state',
+                field='x.com.samsung.da.options',
+                name=f'Burner {slot} state',
+                icon='mdi:gas-burner',
+                value_fn=lambda options, slot=slot: _option_value(
+                    options, f'OperationState{slot}'
+                ),
+                exists_fn=lambda rep, resources, slot=slot: (
+                    not rep or _option_value(
+                        rep.get('x.com.samsung.da.options'),
+                        f'OperationState{slot}',
+                    ) is not None
+                ),
+            )
+            for slot in _SUPPORTED_OPERATION_SLOTS
+        ),
+        SensorDesc(
+            key='main_timer_state',
+            field='x.com.samsung.da.options',
+            name='Timer state',
+            icon='mdi:timer-outline',
+            value_fn=lambda options: _option_value(options, 'MainTimerState'),
+        ),
+        SensorDesc(
+            key='main_timer_current',
+            field='x.com.samsung.da.options',
+            name='Timer current value',
+            icon='mdi:timer-sand',
+            enabled_default=False,
+            value_fn=lambda options: _int_or_none(
+                _option_value(options, 'MainTimerCurrent')
+            ),
+        ),
+    ),
+)
+
+
+COOKTOP_CONNECTED = Capability(
+    href='/connected/vs/0',
+    poll_tier='warm',
+    entities=(
+        BinarySensorDesc(
+            key='cloud_connected',
+            field='x.com.samsung.da.connected',
+            name='Cloud connected',
+            device_class='connectivity',
+            entity_category='diagnostic',
+            value_fn=lambda value: str(value).lower() == 'on',
+        ),
+    ),
+)
+
+
+PAIRED_HOOD_STATUS = Capability(
+    href='/bluetooth/hood/status/vs/0',
+    poll_tier='hot',
+    entities=(
+        BinarySensorDesc(
+            key='paired_hood_connected',
+            field='connectionState',
+            name='Paired hood connected',
+            device_class='connectivity',
+            value_fn=lambda value: str(value).lower() == 'connected',
+        ),
+        BinarySensorDesc(
+            key='paired_hood_power',
+            field='power',
+            name='Paired hood power',
+            device_class='running',
+            value_fn=lambda value: str(value).lower() == 'on',
+        ),
+        SensorDesc(
+            key='paired_hood_fan_speed',
+            field='fanSpeed',
+            name='Paired hood fan speed',
+            icon='mdi:fan',
+            value_fn=_int_or_none,
+        ),
+        BinarySensorDesc(
+            key='paired_hood_light',
+            field='lampState',
+            name='Paired hood light',
+            device_class='light',
+            value_fn=lambda value: str(value).lower() == 'on',
+        ),
+        SensorDesc(
+            key='paired_hood_model',
+            field='micomModelId',
+            name='Paired hood model',
+            icon='mdi:information-outline',
+            entity_category='diagnostic',
+            enabled_default=False,
+        ),
+        SensorDesc(
+            key='paired_hood_firmware',
+            field='firmwareVersion',
+            name='Paired hood firmware',
+            icon='mdi:chip',
+            entity_category='diagnostic',
+            enabled_default=False,
+        ),
+    ),
+)
@@ -48,7 +48,8 @@ DRYER_SETTINGS = Capability(
 DRYER_COURSE = Capability(
    href='/course/vs/0',
    entities=(
-        cycle_select(translation_key='dryer_cycle', icon='mdi:tumble-dryer'),
+        cycle_select(translation_key='dryer_cycle', icon='mdi:tumble-dryer',
+                     table_href='/st/dryercourse/vs/0'),
    ),
 )

@@ -157,6 +157,11 @@ BUZZER_SOUND = Capability(
 # washer.py's course comment has the byte-level evidence for why the options[]
 # MostUsed_* entry is *not* a trustworthy second source.
 #
+# Some boards populate /wm/editcourse/vs/0 without ever filling in
+# editCourseList itself (issue #1) -- cycle_options() falls back to deriving
+# the same list from /course/vs/0's own supportedOptions in that case; see
+# _course_codes_from_supported_options for the byte-level evidence.
+#
 # Shared verbatim by washer, dishwasher, and dryer -- all DA_WM_-family boards
 # expose the same /course/vs/0 options contract.
 # ---------------------------------------------------------------------------
@@ -176,7 +181,10 @@ def parse_edit_course_list(raw):

 def cycle_options(resources):
    rep = resources.get('/wm/editcourse/vs/0') or {}
-    return parse_edit_course_list(rep.get('x.com.samsung.da.editCourseList'))
+    codes = parse_edit_course_list(rep.get('x.com.samsung.da.editCourseList'))
+    if codes:
+        return codes
+    return _course_codes_from_supported_options(resources.get('/course/vs/0') or {})


 def option_value(options, prefix):
@@ -187,6 +195,68 @@ def option_value(options, prefix):
    return None


+def _course_codes_from_supported_options(course_rep):
+    """Fallback for an empty/missing editCourseList: derive the selectable
+    course list from /course/vs/0's own x.com.samsung.da.supportedOptions
+    instead (issue #1: some DA_WM_TP1/TP2-class boards populate the
+    /wm/editcourse/vs/0 href but never fill in editCourseList itself).
+
+    supportedOptions is a 1-hex-nibble header followed by one fixed-width
+    record per selectable course, self-indexed rather than positional --
+    the first byte of every record is that course's own hex code, just in
+    the firmware's own internal order, not editCourseList's. Confirmed
+    against six independent real-world washer/dryer/dishwasher dumps: every
+    one divides evenly into `header + N * K bytes` with fully unique first
+    bytes across all N records, at the record's true byte width. (What the
+    rest of each record encodes is still unconfirmed -- this only uses the
+    course-code byte.)
+
+    Two guards, deliberately conservative rather than guessing further: the
+    derived codes must (a) all be distinct -- a real course table, not
+    noise -- and (b) include whatever course is currently selected
+    (x.com.samsung.da.options' Course_<code> token), which must always be a
+    member of its own device's valid list. If no split satisfies both, this
+    returns [] rather than guess.
+
+    Among splits that satisfy both, the *smallest* passing K wins, rather
+    than requiring a single unambiguous one -- more than one K reliably
+    does pass on real data (e.g. the shipped dishwasher fixture: true
+    K=7 passes, but so do 10, 14, and 35, none of which are multiples of
+    7 -- position 0 always lands on the same real course code regardless
+    of K, which is enough on its own to satisfy the current-course guard
+    for several unrelated splits). Smallest-K-wins is a heuristic, not a
+    proof: it matches the confirmed answer on every one of six independent
+    real-world dumps this was checked against, but a coincidentally
+    unique, current-course-inclusive *smaller* K is not mathematically
+    impossible on some future device, and would be picked silently. Not
+    guarded against further here, since course tables are typically large
+    enough (double digits) that colliding by chance on both checks is
+    unlikely, and no device seen so far actually needs it.
+    """
+    raw = course_rep.get('x.com.samsung.da.supportedOptions')
+    hexstr = raw[0] if isinstance(raw, list) and raw else raw
+    if not isinstance(hexstr, str) or len(hexstr) < 3:
+        return []
+    body = hexstr[1:]
+    if len(body) % 2:
+        return []
+    total_bytes = len(body) // 2
+    current = option_value(course_rep.get('x.com.samsung.da.options'), 'Course')
+    for k in range(1, total_bytes + 1):
+        if total_bytes % k:
+            continue
+        n = total_bytes // k
+        if n < 2:
+            continue
+        firsts = [body[i * k * 2:i * k * 2 + 2] for i in range(n)]
+        if len(set(firsts)) != n:
+            continue
+        if current is not None and current not in firsts:
+            continue
+        return firsts
+    return []
+
+
 def replace_in_options(options, prefix, new_value):
    return [f"{prefix}_{new_value}" if isinstance(o, str) and o.startswith(prefix + '_') else o
            for o in options]
@@ -201,15 +271,53 @@ def cycle_write(p, rep, href=None):
    }


-def cycle_select(*, translation_key, icon):
+def _table_id(resources, table_href):
+    rep = resources.get(table_href) or {}
+    return rep.get('x.com.samsung.da.st.courseTable')
+
+
+def cycle_select(*, translation_key, icon, table_href=None):
    """A 'Cycle' select over /course/vs/0, labelled from `translation_key`.

-    The caller supplies the family's translation key (washer_cycle /
-    dishwasher_cycle / dryer_cycle) and icon; the option list, current value,
-    and write path are all shared.
+    The option list, current value, and write path are all shared across
+    washer/dryer/dishwasher; only the translation is family- (and, for
+    washer/dryer, board-) specific.
+
+    table_href (washer/dryer only -- see washer.py/dryer.py's call sites)
+    suffixes translation_key with the device's own course-table id, read
+    from /st/washercourse/vs/0 or /st/dryercourse/vs/0's
+    x.com.samsung.da.st.courseTable (e.g. 'washer_cycle' + 'Table_02' ->
+    'washer_cycle_table_02'). No table id available at all -- the href
+    absent or empty -- gets no translation_key, i.e. the raw course code
+    displayed as-is.
+
+    This matters because course codes are NOT guaranteed consistent across
+    board generations sharing the same /course/vs/0 contract: every code in
+    washer_cycle_table_02 was confirmed against Table_02-reporting devices
+    (DA_WM_TP1/TP2 boards); FlexWash's older DA_WM_A51 board reports
+    Table_00 instead, so the same hex code could mean a different course
+    there for all we've verified. Building the key from whatever table the
+    device actually reports, rather than gating a single hardcoded key on
+    an exact match, means a table we haven't built translations for yet
+    (like Table_00) just falls through Home Assistant's own missing-
+    translation handling to the same raw-code display -- exactly what
+    happens today for any individual code within a table's translations
+    that isn't populated yet -- and adding one later needs new strings.json
+    entries, not a code change here.
+
+    Left at its default for dishwasher, which has no equivalent table-id
+    resource in any dump seen and no evidence its course codes vary by
+    table the way washer/dryer's do -- there's nothing to build a
+    table-specific key from.
    """
+    key = translation_key
+    if table_href is not None:
+        def key(resources):
+            table = _table_id(resources, table_href)
+            return f'{translation_key}_{table.lower()}' if table else None
+
    return SelectDesc(
-        key='cycle', name='Cycle', icon=icon, translation_key=translation_key,
+        key='cycle', name='Cycle', icon=icon, translation_key=key,
        options=cycle_options,
        exists_fn=lambda rep, resources: bool(cycle_options(resources)),
        rep_fn=lambda rep: option_value(rep.get('x.com.samsung.da.options'), 'Course'),
@@ -70,6 +70,15 @@ def _finish_time(remaining_str):
        return None


+# Shared by dryer/dishwasher/oven/washer -- oven.py imports this directly
+# rather than keeping its own copy, since both wrote the identical
+# state='Ready' RMW.
+STOP_BUTTON = ButtonDesc(key='stop', field='', name='Stop', payload='Ready',
+                         icon='mdi:stop',
+                         write_fn=lambda p, rep, href=None: (
+                             ['operational', 'state', 'vs', '0'],
+                             {'x.com.samsung.da.state': p}))
+
 OPERATIONAL_STATE = Capability(
    href='/operational/state/vs/0',
    poll_tier='hot',
@@ -83,8 +92,12 @@ OPERATIONAL_STATE = Capability(
        # Harmless for non-oven appliances — just an extra bool in state.
        # Samsung firmware keeps state='Run' after progress reaches 'Finish',
        # so we also gate on progress to avoid a stuck 'Running' indication.
+        # Named 'Running' rather than 'Cycle active' -- this href (and the
+        # start/pause/stop buttons below) is shared across the dryer/
+        # dishwasher/oven/washer families, and 'cycle' is laundry-specific
+        # vocabulary that doesn't fit an oven's bake/roast/etc.
        BinarySensorDesc(key='cycle_active', device_class='running',
-                         name='Cycle active',
+                         name='Running',
                         rep_fn=lambda rep: (
                             _SAMSUNG_STATE_TO_OCF.get(rep.get('x.com.samsung.da.state')) == 'active'
                             and rep.get('x.com.samsung.da.progress') != 'Finish'
@@ -119,20 +132,16 @@ OPERATIONAL_STATE = Capability(
                   write_fn=lambda p, rep, href=None: (
                       ['operational', 'state', 'vs', '0'],
                       {_delay_field(rep): _format_delay(p)})),
-        ButtonDesc(key='start', field='', name='Start cycle', payload='Run',
+        ButtonDesc(key='start', field='', name='Start', payload='Run',
                   icon='mdi:play',
                   write_fn=lambda p, rep, href=None: (
                       ['operational', 'state', 'vs', '0'],
                       {'x.com.samsung.da.state': p})),
-        ButtonDesc(key='pause', field='', name='Pause cycle', payload='Pause',
+        ButtonDesc(key='pause', field='', name='Pause', payload='Pause',
                   icon='mdi:pause',
                   write_fn=lambda p, rep, href=None: (
                       ['operational', 'state', 'vs', '0'],
                       {'x.com.samsung.da.state': p})),
-        ButtonDesc(key='stop', field='', name='Stop cycle', payload='Ready',
-                   icon='mdi:stop',
-                   write_fn=lambda p, rep, href=None: (
-                       ['operational', 'state', 'vs', '0'],
-                       {'x.com.samsung.da.state': p})),
+        STOP_BUTTON,
    ),
 )
@@ -26,10 +26,10 @@ from datetime import datetime, timezone, timedelta

 from ..capability import Capability
 from ..entities import (
-    BinarySensorDesc, ButtonDesc, NumberDesc, SelectDesc, SensorDesc,
-    SwitchDesc,
+    BinarySensorDesc, NumberDesc, SelectDesc, SensorDesc, SwitchDesc,
 )
 from .common import normalize_temp_unit
+from .operational import STOP_BUTTON

 # ---------------------------------------------------------------------------
 # Constants
@@ -166,12 +166,6 @@ def _cook_time_write(p, rep, href=None):
    }


-def _stop_write(p, rep, href=None):
-    return ['operational', 'state', 'vs', '0'], {
-        'x.com.samsung.da.state': 'Ready',
-    }
-
-
 def _oven_mode_write(p, rep, href=None):
    if p not in _OVEN_MODES:
        return None
@@ -237,7 +231,7 @@ OVEN_OPERATIONAL_STATE = Capability(
                   device_class='enum', options=('idle', 'active', 'pause'),
                   translation_key='machine_state', value_fn=_to_ocf),
        BinarySensorDesc(key='cycle_active', field='x.com.samsung.da.state',
-                         name='Cycle active', device_class='running',
+                         name='Running', device_class='running',
                         value_fn=lambda v: _SAMSUNG_STATE_TO_OCF.get(v) == 'active'),
        SensorDesc(key='progress_percentage',
                   field='x.com.samsung.da.progressPercentage',
@@ -254,8 +248,7 @@ OVEN_OPERATIONAL_STATE = Capability(
                   name='Cook time', unit='min', native_min=0, native_max=1439,
                   step=1.0, icon='mdi:timer', value_fn=_op_minutes,
                   write_fn=_cook_time_write),
-        ButtonDesc(key='stop', field='', name='Stop cycle', icon='mdi:stop',
-                   payload='Stop', write_fn=_stop_write),
+        STOP_BUTTON,
    ),
 )

@@ -0,0 +1,288 @@
+"""Capabilities for Samsung AHD-WW-TP1-22 range hoods.
+
+The verified device exposes its fan, two-level work lamp, washable-filter
+status, and particulate sensors as distinct local OCF resources.  Fan power
+and speed are combined into one HA fan entity by ``fan.py``; lamp power and
+brightness remain separate controls because the device advertises them as two
+independent fields.
+"""
+
+from datetime import datetime, timezone
+
+from ..capability import Capability
+from ..entities import (
+    BinarySensorDesc,
+    FanDesc,
+    SelectDesc,
+    SensorDesc,
+    SwitchDesc,
+)
+from .common import int_or_none, sensor_item_value
+
+
+def _timestamp(value):
+    try:
+        return datetime.fromtimestamp(float(value), tz=timezone.utc)
+    except (TypeError, ValueError, OSError):
+        return None
+
+
+def _active_alarm_codes(items):
+    """Discard the hood firmware's retained/deleted ``ErrorCode_OFF`` row.
+
+    Unlike ``common._alarm_codes``, the hood retains a deleted alarm row in
+    its live representation, so this family-specific helper also checks state.
+    """
+    codes = []
+    for item in items or ():
+        if not isinstance(item, dict):
+            continue
+        if str(item.get('x.com.samsung.da.state', '')).lower() == 'deleted':
+            continue
+        code = item.get('x.com.samsung.da.code')
+        if code and str(code).lower() != 'errorcode_off':
+            codes.append(code)
+    return ', '.join(codes) if codes else 'none'
+
+
+HOOD_ALARMS = Capability(
+    href='/alarms/vs/0',
+    poll_tier='hot',
+    entities=(
+        SensorDesc(
+            key='alarm_code',
+            field='x.com.samsung.da.items',
+            name='Alarm code',
+            icon='mdi:alert',
+            entity_category='diagnostic',
+            value_fn=_active_alarm_codes,
+        ),
+    ),
+)
+
+
+def _hood_fan_write(payload, rep, href=None):
+    kind, value, *args = payload
+    if kind == 'power':
+        power_href = args[0] if args else '/power/0'
+        if power_href == '/power/0':
+            return ['power', '0'], {'value': bool(value)}
+        if power_href == '/power/vs/0':
+            return ['power', 'vs', '0'], {
+                'x.com.samsung.da.power': 'On' if value else 'Off',
+            }
+        return None
+    if kind == 'speed':
+        value = str(value)
+        supported = [
+            str(code)
+            for code in rep.get('x.com.samsung.da.hood.supportedFanSpeed', ())
+        ]
+        if value not in supported:
+            return None
+        return ['hood', 'fanspeed', 'vs', '0'], {
+            'x.com.samsung.da.hood.fanSpeed': value,
+        }
+    return None
+
+
+HOOD_FAN = Capability(
+    href='/hood/fanspeed/vs/0',
+    poll_tier='hot',
+    entities=(
+        FanDesc(
+            key='fan',
+            field='x.com.samsung.da.hood.fanSpeed',
+            name=None,
+            write_fn=_hood_fan_write,
+        ),
+        BinarySensorDesc(
+            key='automatic_operation',
+            field='x.com.samsung.da.hood.autoOperation',
+            name='Automatic operation',
+            icon='mdi:fan-auto',
+            entity_category='diagnostic',
+            value_fn=lambda value: str(value).lower() == 'on',
+        ),
+    ),
+)
+
+
+def _lamp_level_write(value, rep, href=None):
+    code = str(value)
+    supported = [str(level) for level in rep.get('x.com.samsung.lamp.range', ())]
+    if code not in supported:
+        return None
+    return ['hood', 'lamp', 'vs', '0'], {
+        'x.com.samsung.lamp.current': code,
+    }
+
+
+HOOD_LAMP = Capability(
+    href='/hood/lamp/vs/0',
+    poll_tier='hot',
+    entities=(
+        SwitchDesc(
+            key='lamp',
+            field='x.com.samsung.lamp.power',
+            name='Lamp',
+            icon='mdi:range-hood',
+            value_fn=lambda value: str(value).lower() == 'on',
+            write_fn=lambda payload, rep, href=None: (
+                ['hood', 'lamp', 'vs', '0'],
+                {'x.com.samsung.lamp.power': 'On' if payload == 'On' else 'Off'},
+            ),
+        ),
+        SelectDesc(
+            key='lamp_brightness',
+            field='x.com.samsung.lamp.current',
+            name='Lamp brightness',
+            icon='mdi:brightness-6',
+            translation_key='range_hood_lamp_brightness',
+            options_field='x.com.samsung.lamp.range',
+            write_fn=_lamp_level_write,
+        ),
+    ),
+)
+
+
+HOOD_FILTER = Capability(
+    href='/filter/hoodfilter/vs/0',
+    poll_tier='cold',
+    entities=(
+        SensorDesc(
+            key='hood_filter_usage',
+            field='x.com.samsung.da.filterUsage',
+            name='Filter usage',
+            unit='%',
+            state_class='measurement',
+            icon='mdi:air-filter',
+            entity_category='diagnostic',
+            value_fn=int_or_none,
+        ),
+        SensorDesc(
+            key='hood_filter_status',
+            field='x.com.samsung.da.filterStatus',
+            name='Filter status',
+            icon='mdi:air-filter',
+            entity_category='diagnostic',
+        ),
+        SensorDesc(
+            key='hood_filter_capacity',
+            field='x.com.samsung.da.filterCapacity',
+            name='Filter capacity',
+            unit='h',
+            icon='mdi:timer-outline',
+            entity_category='diagnostic',
+            enabled_default=False,
+            value_fn=int_or_none,
+        ),
+    ),
+)
+
+
+AIR_QUALITY = Capability(
+    href='/sensors/vs/0',
+    poll_tier='warm',
+    entities=(
+        SensorDesc(
+            key='clean_level',
+            field='x.com.samsung.da.items',
+            name='Clean level',
+            icon='mdi:air-filter',
+            value_fn=lambda items: sensor_item_value(items, 'CleanLevel'),
+        ),
+        SensorDesc(
+            key='dust',
+            field='x.com.samsung.da.items',
+            name='Dust',
+            value_fn=lambda items: sensor_item_value(items, 'Dust'),
+        ),
+        SensorDesc(
+            key='fine_dust',
+            field='x.com.samsung.da.items',
+            name='Fine dust',
+            value_fn=lambda items: sensor_item_value(items, 'FineDust'),
+        ),
+        SensorDesc(
+            key='super_fine_dust',
+            field='x.com.samsung.da.items',
+            name='Super fine dust',
+            value_fn=lambda items: sensor_item_value(items, 'SuperFineDust'),
+        ),
+    ),
+)
+
+
+AIR_LEVEL_CHECK = Capability(
+    href='/airlevelcheck/vs/0',
+    poll_tier='warm',
+    entities=(
+        BinarySensorDesc(
+            key='periodic_air_sensing',
+            field='x.com.samsung.da.periodicSensingActivationState',
+            name='Periodic air sensing',
+            icon='mdi:radar',
+            entity_category='diagnostic',
+            value_fn=lambda value: str(value).lower() == 'on',
+        ),
+        SensorDesc(
+            key='air_sensing_state',
+            field='x.com.samsung.da.sensingState',
+            name='Air sensing state',
+            icon='mdi:radar',
+            entity_category='diagnostic',
+        ),
+        SensorDesc(
+            key='last_air_sensing_time',
+            field='x.com.samsung.da.lastSensingTime',
+            name='Last air sensing time',
+            device_class='timestamp',
+            entity_category='diagnostic',
+            value_fn=_timestamp,
+        ),
+        SensorDesc(
+            key='last_air_sensing_level',
+            field='x.com.samsung.da.lastSensingLevel',
+            name='Last air sensing level',
+            icon='mdi:air-filter',
+            entity_category='diagnostic',
+        ),
+        SensorDesc(
+            key='automatic_ventilation_state',
+            field='x.com.samsung.da.autoExeState',
+            name='Automatic ventilation state',
+            icon='mdi:fan-auto',
+            entity_category='diagnostic',
+        ),
+    ),
+)
+
+
+AUTO_VENTILATION = Capability(
+    href='/autoventilation/vs/0',
+    poll_tier='warm',
+    entities=(
+        SensorDesc(
+            key='auto_ventilation_action',
+            field='action',
+            name='Auto ventilation action',
+            icon='mdi:fan-auto',
+        ),
+    ),
+)
+
+
+# Resource plumbing and opaque feature-negotiation fields that are specific to
+# this family.  Bare capabilities mark them covered without creating entities.
+COVERAGE = [
+    Capability(href=href)
+    for href in (
+        '/power/0',
+        '/power/vs/0',
+        '/mode/vs/0',
+        '/personality/presence/vs/0',
+        '/availablecontrolsets/vs/0',
+        '/da/softreset/vs/0',
+    )
+]
@@ -293,7 +293,8 @@ def _bool_option_switch(key, name, icon, prefix, availability_field):
 WASHER_COURSE = Capability(
    href='/course/vs/0',
    entities=(
-        cycle_select(translation_key='washer_cycle', icon='mdi:washing-machine'),
+        cycle_select(translation_key='washer_cycle', icon='mdi:washing-machine',
+                     table_href='/st/washercourse/vs/0'),
        SensorDesc(key='drum_clean_cycles_remaining', name='Drum clean due in',
                   icon='mdi:washing-machine-alert', unit='cycles',
                   state_class='measurement',
@@ -28,7 +28,12 @@ class SamsungEntityDescription:
    key: str
    field: str = ''
    name: Optional[str] = None
-    translation_key: Optional[str] = None
+    translation_key: Any = None  # str | Callable[[dict[str, dict]], Optional[str]]
+    # callable form receives the coordinator's full href->rep resource
+    # snapshot and returns the key to use (or None for no translation this
+    # device) -- for a descriptor shared across board generations whose
+    # state-code meaning isn't guaranteed consistent between them; see
+    # laundry.cycle_select's table-id-gated resolver.
    icon: Optional[str] = None
    entity_category: Optional[str] = None      # 'diagnostic' | 'config' | None
    enabled_default: bool = True
@@ -111,6 +116,13 @@ class ClimateDesc(SamsungEntityDescription):
    write_fn: WriteFn = None


+@dataclass(frozen=True, kw_only=True)
+class FanDesc(SamsungEntityDescription):
+    # Composite fan entity: reads power from /power/0 and speed/support data
+    # from its bound href.  Payloads are (kind, value), like ClimateDesc.
+    write_fn: WriteFn = None
+
+
 PLATFORM_OF: dict[type, str] = {
    SensorDesc:       'sensor',
    BinarySensorDesc: 'binary_sensor',
@@ -120,4 +132,5 @@ PLATFORM_OF: dict[type, str] = {
    NumberDesc:       'number',
    TimeDesc:         'time',
    ClimateDesc:      'climate',
+    FanDesc:          'fan',
 }
@@ -2,6 +2,7 @@
 from __future__ import annotations

 import re
+from typing import Optional

 from homeassistant.components.select import SelectEntity
 from homeassistant.config_entries import ConfigEntry
@@ -31,9 +32,14 @@ async def async_setup_entry(
 _CAMEL_BOUNDARY_RE = re.compile(r'(?<=[a-z0-9])(?=[A-Z])')


-def _display(value, desc: SelectDesc):
+def _display(value, translation_key: Optional[str]):
    """Turn a raw device option/state value into what's shown in the UI.

+    `translation_key` is the entity's already-resolved key (SelectDesc.
+    translation_key can itself be a callable -- see entities.py -- so
+    callers pass the resolved value, e.g. self.translation_key, not
+    the raw descriptor field).
+
    An entity with a translation_key looks its state up in strings.json,
    and hassfest requires those keys to be lowercase -- so those values
    must be lowercased exactly to match, and the device still expects
@@ -50,7 +56,7 @@ def _display(value, desc: SelectDesc):
    """
    if not isinstance(value, str):
        return value
-    if desc.translation_key:
+    if translation_key:
        return value.lower()
    if value.islower():
        return value.replace('_', ' ').title()
@@ -63,7 +69,7 @@ class LocalThingsSelect(LocalThingsEntity, SelectEntity):
        super().__init__(coordinator, bound)
        desc: SelectDesc = bound.desc
        if not desc.options_field and not callable(desc.options):
-            self._attr_options = [_display(o, desc) for o in desc.options]
+            self._attr_options = [_display(o, self.translation_key) for o in desc.options]

    def _raw_options(self) -> list[str]:
        desc: SelectDesc = self._bound.desc
@@ -83,17 +89,17 @@ class LocalThingsSelect(LocalThingsEntity, SelectEntity):
    def options(self) -> list[str]:
        desc: SelectDesc = self._bound.desc
        if desc.options_field or callable(desc.options):
-            return [_display(o, desc) for o in self._raw_options()]
+            return [_display(o, self.translation_key) for o in self._raw_options()]
        return self._attr_options

    @property
    def current_option(self):
        raw = (self.coordinator.data or {}).get(self._state_key)
-        return _display(raw, self._bound.desc)
+        return _display(raw, self.translation_key)

    async def async_select_option(self, option: str) -> None:
-        desc: SelectDesc = self._bound.desc
        raw = next(
-            (o for o in self._raw_options() if _display(o, desc) == option), option
+            (o for o in self._raw_options() if _display(o, self.translation_key) == option),
+            option,
        )
        await self.coordinator.async_send_command(self._bound, raw)
@@ -16,6 +16,12 @@
          "100": "High"
        }
      },
+      "range_hood_lamp_brightness": {
+        "state": {
+          "1": "Level 1",
+          "2": "Level 2"
+        }
+      },
      "ice_type": {
        "state": {
          "off": "Off",
@@ -65,7 +71,7 @@
          "8f": "Baby Care"
        }
      },
-      "washer_cycle": {
+      "washer_cycle_table_02": {
        "state": {
          "1c": "Eco 40-60",
          "1d": "Super Speed",
@@ -97,7 +103,7 @@
          "1f": "Intense Cold"
        }
      },
-      "dryer_cycle": {
+      "dryer_cycle_table_03": {
        "state": {
          "16": "Cotton",
          "18": "Synthetics",
@@ -240,6 +246,17 @@
      "already_configured": "This device is already configured."
    }
  },
+  "options": {
+    "step": {
+      "init": {
+        "title": "Local Things Options",
+        "description": "Some devices accept certain writes (e.g. default detergent/softener dosing on a washer) even while reporting remote control off. By default, LocalThings blocks every write with a clear error whenever a device reports remote control off, rather than letting the device silently reject it. Only enable this if you've confirmed writes actually work on this device with remote control off -- otherwise you'll trade that clear error for a silent failure.",
+        "data": {
+          "bypass_remote_control_lock": "Allow writes even when remote control is reported off"
+        }
+      }
+    }
+  },
  "issues": {
    "device_gap": {
      "title": "Incomplete capability coverage for {device_name}",
@@ -16,6 +16,12 @@
          "100": "High"
        }
      },
+      "range_hood_lamp_brightness": {
+        "state": {
+          "1": "Level 1",
+          "2": "Level 2"
+        }
+      },
      "ice_type": {
        "state": {
          "off": "Off",
@@ -65,7 +71,7 @@
          "8f": "Baby Care"
        }
      },
-      "washer_cycle": {
+      "washer_cycle_table_02": {
        "state": {
          "1c": "Eco 40-60",
          "1d": "Super Speed",
@@ -97,7 +103,7 @@
          "1f": "Intense Cold"
        }
      },
-      "dryer_cycle": {
+      "dryer_cycle_table_03": {
        "state": {
          "16": "Cotton",
          "18": "Synthetics",
@@ -240,6 +246,17 @@
      "already_configured": "This device is already configured."
    }
  },
+  "options": {
+    "step": {
+      "init": {
+        "title": "Local Things Options",
+        "description": "Some devices accept certain writes (e.g. default detergent/softener dosing on a washer) even while reporting remote control off. By default, LocalThings blocks every write with a clear error whenever a device reports remote control off, rather than letting the device silently reject it. Only enable this if you've confirmed writes actually work on this device with remote control off -- otherwise you'll trade that clear error for a silent failure.",
+        "data": {
+          "bypass_remote_control_lock": "Allow writes even when remote control is reported off"
+        }
+      }
+    }
+  },
  "issues": {
    "device_gap": {
      "title": "Incomplete capability coverage for {device_name}",
@@ -0,0 +1,200 @@
+{
+  "device0": [
+    {
+      "rt": [
+        "x.com.samsung.devcol"
+      ],
+      "if": [
+        "oic.if.baseline",
+        "oic.if.ll",
+        "oic.if.b"
+      ]
+    },
+    {
+      "href": "/airflow/0",
+      "rep": {
+        "speed": 0,
+        "direction": "Off"
+      }
+    },
+    {
+      "href": "/airflow/vs/0",
+      "rep": {
+        "x.com.samsung.da.speedLevel": "0",
+        "x.com.samsung.da.direction": "Off"
+      }
+    },
+    {
+      "href": "/alarms/vs/0",
+      "rep": {
+        "x.com.samsung.da.items": [
+          {
+            "x.com.samsung.da.id": "0",
+            "x.com.samsung.da.description": "Alarm",
+            "x.com.samsung.da.alarmType": "Device",
+            "x.com.samsung.da.code": "ErrorCode_OFF",
+            "x.com.samsung.da.triggeredTime": "2026-07-23T15:56:55",
+            "x.com.samsung.da.state": "Deleted"
+          },
+          {
+            "x.com.samsung.da.id": "1",
+            "x.com.samsung.da.description": "Alarm",
+            "x.com.samsung.da.alarmType": "Device",
+            "x.com.samsung.da.code": "FilterAlarm",
+            "x.com.samsung.da.triggeredTime": "2026-07-23T15:56:55",
+            "x.com.samsung.da.state": "Created"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/configuration/vs/0",
+      "rep": {}
+    },
+    {
+      "href": "/consumable/vs/0",
+      "rep": {
+        "x.com.samsung.da.items": [
+          {
+            "x.com.samsung.da.state": "100",
+            "x.com.samsung.da.name": "FilterProgress"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/devicespecificinfo/vs/0",
+      "rep": {
+        "x.com.samsung.da.deviceActive": true
+      }
+    },
+    {
+      "href": "/diagnosis/vs/0",
+      "rep": {
+        "x.com.samsung.da.diagnosisStart": "Ready"
+      }
+    },
+    {
+      "href": "/energy/consumption/0",
+      "rep": {}
+    },
+    {
+      "href": "/energy/consumption/vs/0",
+      "rep": {}
+    },
+    {
+      "href": "/humidity/0",
+      "rep": {}
+    },
+    {
+      "href": "/humidity/vs/0",
+      "rep": {}
+    },
+    {
+      "href": "/information/vs/0",
+      "rep": {
+        "x.com.samsung.da.modelNum": "ARTIK051_TVTL_18K|10193941|7000023C001111C40100000000000000",
+        "x.com.samsung.da.description": "ARTIK051_TVTL_18K",
+        "x.com.samsung.da.serialNum": "**REDACTED**",
+        "x.com.samsung.da.otnDUID": "**REDACTED**",
+        "x.com.samsung.da.items": [
+          {
+            "x.com.samsung.da.id": "0",
+            "x.com.samsung.da.description": "Version",
+            "x.com.samsung.da.type": "Software",
+            "x.com.samsung.da.number": "02059A230513",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          },
+          {
+            "x.com.samsung.da.id": "1",
+            "x.com.samsung.da.description": "Version",
+            "x.com.samsung.da.type": "Firmware",
+            "x.com.samsung.da.number": "19071703,19071706",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/mode/vs/0",
+      "rep": {
+        "x.com.samsung.da.options": [
+          "Comode_Off",
+          "Blooming_0",
+          "Light_On",
+          "OptionCode_60282"
+        ]
+      }
+    },
+    {
+      "href": "/power/0",
+      "rep": {
+        "value": false
+      }
+    },
+    {
+      "href": "/power/vs/0",
+      "rep": {
+        "x.com.samsung.da.power": "Off"
+      }
+    },
+    {
+      "href": "/realtimenotiforclient/vs/0",
+      "rep": {
+        "x.com.samsung.da.timeforshortnoti": "0",
+        "x.com.samsung.da.longnotisubscription": "true",
+        "x.com.samsung.da.periodicnotisubscription": "false"
+      }
+    },
+    {
+      "href": "/sensors/vs/0",
+      "rep": {
+        "x.com.samsung.da.items": [
+          {
+            "x.com.samsung.da.id": "0",
+            "x.com.samsung.da.description": "Sensor for Dust",
+            "x.com.samsung.da.type": "Dust",
+            "x.com.samsung.da.value": [
+              "11",
+              "0"
+            ]
+          },
+          {
+            "x.com.samsung.da.id": "1",
+            "x.com.samsung.da.description": "Sensor for FineDust",
+            "x.com.samsung.da.type": "FineDust",
+            "x.com.samsung.da.value": [
+              "9",
+              "0"
+            ]
+          },
+          {
+            "x.com.samsung.da.id": "2",
+            "x.com.samsung.da.description": "Sensor for Odor",
+            "x.com.samsung.da.type": "Odor",
+            "x.com.samsung.da.value": [
+              "0"
+            ]
+          },
+          {
+            "x.com.samsung.da.id": "3",
+            "x.com.samsung.da.description": "Sensor for CleanLevel",
+            "x.com.samsung.da.type": "CleanLevel",
+            "x.com.samsung.da.value": [
+              "0"
+            ]
+          },
+          {
+            "x.com.samsung.da.id": "4",
+            "x.com.samsung.da.description": "Sensor for SuperFineDust",
+            "x.com.samsung.da.type": "SuperFineDust",
+            "x.com.samsung.da.value": [
+              "5",
+              "0"
+            ]
+          }
+        ]
+      }
+    }
+  ]
+}
@@ -0,0 +1,486 @@
+{
+  "device0": [
+    {
+      "rt": [
+        "x.com.samsung.devcol",
+        "oic.wk.col"
+      ],
+      "if": [
+        "oic.if.baseline",
+        "oic.if.ll",
+        "oic.if.b"
+      ]
+    },
+    {
+      "href": "/aisleep/vs/0",
+      "rep": {
+        "x.com.samsung.da.displayNightMode": "Off",
+        "x.com.samsung.da.elapsedTime": "0",
+        "x.com.samsung.da.requestFeedback": "Off",
+        "x.com.samsung.da.resultFeedback": "0",
+        "x.com.samsung.da.statusFeedback": "Idle",
+        "x.com.samsung.da.sleepTime": "14002200",
+        "x.com.samsung.da.sleepMode": "Off"
+      }
+    },
+    {
+      "href": "/alarms/vs/0",
+      "rep": {
+        "x.com.samsung.da.items": [
+          {
+            "x.com.samsung.da.id": "0",
+            "x.com.samsung.da.description": "Alarm",
+            "x.com.samsung.da.alarmType": "Device",
+            "x.com.samsung.da.code": "ErrorCode_OFF",
+            "x.com.samsung.da.triggeredTime": "2026-07-23T05:13:21",
+            "x.com.samsung.da.state": "Deleted"
+          },
+          {
+            "x.com.samsung.da.id": "1",
+            "x.com.samsung.da.description": "Alarm",
+            "x.com.samsung.da.alarmType": "Device",
+            "x.com.samsung.da.code": "FilterAlarm_OFF",
+            "x.com.samsung.da.triggeredTime": "2026-07-23T05:13:21",
+            "x.com.samsung.da.state": "Deleted"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/availablecontrolsets/vs/0",
+      "rep": {
+        "x.com.samsung.da.sets": "000100B4012C0000120000000000",
+        "x.com.samsung.da.id": "CAC",
+        "x.com.samsung.da.version": "1.0"
+      }
+    },
+    {
+      "href": "/configuration/vs/0",
+      "rep": {
+        "x.com.samsung.da.region": "4131000000",
+        "x.com.samsung.da.airconOptionList": [
+          "DR",
+          "SingleCommand_1.0",
+          "AI_2.0"
+        ]
+      }
+    },
+    {
+      "href": "/diagnosis/vs/0",
+      "rep": {}
+    },
+    {
+      "href": "/drlc/vs/0",
+      "rep": {
+        "x.com.samsung.da.drlcLevel": "0",
+        "x.com.samsung.da.durationminutes": "0",
+        "x.com.samsung.da.start": "1970-01-01T00:00:00Z",
+        "x.com.samsung.da.override": "Off",
+        "x.com.samsung.da.realSaving": "Off"
+      }
+    },
+    {
+      "href": "/energy/consumption/vs/0",
+      "rep": {
+        "x.com.samsung.da.instantaneousPower": "153.000000",
+        "x.com.samsung.da.cumulativePower": "239209",
+        "x.com.samsung.da.cumulativeSavedPower": "7201",
+        "x.com.samsung.da.cumulativeUnit": "Wh",
+        "x.com.samsung.da.instantaneousPowerUnit": "W",
+        "x.com.samsung.da.cumulativePowerType": "total",
+        "x.com.samsung.da.saveLocation": "/mnt/usage.db"
+      }
+    },
+    {
+      "href": "/file/information/vs/0",
+      "rep": {
+        "x.com.samsung.timeoffset": "+09:00",
+        "x.com.samsung.supprtedtype": 1
+      }
+    },
+    {
+      "href": "/filter/airdustfilter/vs/0",
+      "rep": {
+        "x.com.samsung.da.filterUsage": "85",
+        "x.com.samsung.da.filterUsageResolution": "1",
+        "x.com.samsung.da.filterStatus": "normal",
+        "x.com.samsung.da.filterCapacity": "1000",
+        "x.com.samsung.da.filterCapacityUnit": "Hour",
+        "x.com.samsung.da.filterResetType": [
+          "replaceable",
+          "washable"
+        ]
+      }
+    },
+    {
+      "href": "/humidity/vs/0",
+      "rep": {
+        "x.com.samsung.da.humidity": "0.000000",
+        "x.com.samsung.da.fivepercentHumidity": "83"
+      }
+    },
+    {
+      "href": "/information/vs/0",
+      "rep": {
+        "x.com.samsung.da.modelNum": "A-CAWW-TP2-20-COMMON|10241941|600301170016110B40000F2000F2AD00",
+        "x.com.samsung.da.description": "A-CAWW-TP2-20-COMMON",
+        "x.com.samsung.da.serialNum": "**REDACTED**",
+        "x.com.samsung.da.otnDUID": "**REDACTED**",
+        "x.com.samsung.da.diagProtocolType": "WIFI_HTTPS",
+        "x.com.samsung.da.diagLogType": [
+          "errCode",
+          "dump"
+        ],
+        "x.com.samsung.da.diagDumpType": "file",
+        "x.com.samsung.da.diagEndPoint": "SSM",
+        "x.com.samsung.da.diagMnid": "0AJT",
+        "x.com.samsung.da.diagSetupid": "023",
+        "x.com.samsung.da.diagMinVersion": "1.0",
+        "x.com.samsung.da.items": [
+          {
+            "x.com.samsung.da.id": "0",
+            "x.com.samsung.da.description": "Version",
+            "x.com.samsung.da.type": "Software",
+            "x.com.samsung.da.number": "02274A260512",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          },
+          {
+            "x.com.samsung.da.id": "1",
+            "x.com.samsung.da.description": "Version",
+            "x.com.samsung.da.type": "Firmware",
+            "x.com.samsung.da.number": "02419A25051901,FFFFFFFFFFFFFF",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          },
+          {
+            "x.com.samsung.da.id": "2",
+            "x.com.samsung.da.description": "Version",
+            "x.com.samsung.da.type": "Outdoor",
+            "x.com.samsung.da.number": "FFFFFFFFFFFFFF,FFFFFFFFFFFFFF"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/keepnormalstate/vs/0",
+      "rep": {
+        "x.com.samsung.da.keepnormal": 0
+      }
+    },
+    {
+      "href": "/mode/convenient/vs/0",
+      "rep": {
+        "x.com.samsung.da.modes": "Off",
+        "x.com.samsung.da.supportedModes": [
+          "Off",
+          "Nano",
+          "LongWind",
+          "Speed",
+          "Sleep",
+          "NanoSleep"
+        ]
+      }
+    },
+    {
+      "href": "/mode/vs/0",
+      "rep": {
+        "x.com.samsung.da.workingMode": "Auto",
+        "x.com.samsung.da.supportedModes": [
+          "Auto",
+          "Cool",
+          "Dry",
+          "Fan",
+          "AIComfort"
+        ],
+        "x.com.samsung.da.modes": [
+          "Auto"
+        ],
+        "x.com.samsung.da.options": [
+          "Sleep_0",
+          "ArtificialWorking_Off",
+          "ComfortAICooling_Off",
+          "AiTempChanged_Off",
+          "AiTemp_240",
+          "OutdoorTemp_82",
+          "Light_Off",
+          "Volume_100",
+          "KeyInputPermit_On",
+          "ModePermit_NoLimit",
+          "UpdateAllow_NotAllowed",
+          "DurationOn_419",
+          "WelcomeCoolingState_Off"
+        ]
+      }
+    },
+    {
+      "href": "/option/autoclean/vs/0",
+      "rep": {
+        "x.com.samsung.da.status": "Stop",
+        "x.com.samsung.da.settingStatus": "On",
+        "x.com.samsung.da.progress": "0",
+        "x.com.samsung.da.supportedStatus": [
+          "Start",
+          "Stop"
+        ],
+        "x.com.samsung.da.supportedSettingStatus": [
+          "On",
+          "Off"
+        ]
+      }
+    },
+    {
+      "href": "/option/muteonce/vs/0",
+      "rep": {
+        "muteonce": "Off"
+      }
+    },
+    {
+      "href": "/otninformation/vs/0",
+      "rep": {
+        "x.com.samsung.da.target": "",
+        "x.com.samsung.da.newVersionAvailable": "false",
+        "x.com.samsung.da.newVersionNo": "00000000",
+        "x.com.samsung.da.currentVersionInfo": "00000000",
+        "otnStatus": "None",
+        "flashingProgress": "",
+        "otnTarget": "main",
+        "otnCompleteDate": "noHistory",
+        "otnList": [
+          {
+            "type": "WIFI",
+            "modelId": "A-CAWW-TP2-20-COMMON",
+            "versions": [
+              "14260512"
+            ],
+            "visVersion": "260512"
+          },
+          {
+            "type": "Micom",
+            "modelId": "040010241941FFFFFFFF",
+            "versions": [
+              "25051901",
+              "FFFFFFFF"
+            ],
+            "visVersion": "250519"
+          },
+          {
+            "type": "Micom",
+            "modelId": "0400FFFFFFFFFFFFFFFF",
+            "versions": [
+              "FFFFFFFF",
+              "FFFFFFFF"
+            ],
+            "visVersion": ""
+          }
+        ]
+      }
+    },
+    {
+      "href": "/power/vs/0",
+      "rep": {
+        "x.com.samsung.da.power": "Off"
+      }
+    },
+    {
+      "href": "/realtimenotiforclient/vs/0",
+      "rep": {
+        "x.com.samsung.da.timeforshortnoti": "0",
+        "x.com.samsung.da.longnotisubscription": "true",
+        "x.com.samsung.da.periodicnotisubscription": "true"
+      }
+    },
+    {
+      "href": "/reserverulesets/vs/0",
+      "rep": {
+        "x.com.samsung.da.sets": "1F121E121E121E121EFFFFFFFF010001000F0001000E0000001C",
+        "x.com.samsung.da.id": "CAC",
+        "x.com.samsung.da.version": "1.0"
+      }
+    },
+    {
+      "href": "/sac/installationinfo/vs/0",
+      "rep": {
+        "installationOptions": [
+          {
+            "id": "0",
+            "option": "17444980C80171700010"
+          },
+          {
+            "id": "1",
+            "option": "28010000000000000100"
+          },
+          {
+            "id": "2",
+            "option": "50000000000000000000"
+          },
+          {
+            "id": "3",
+            "option": "30000000000000000000"
+          }
+        ],
+        "installationDeviceNum": [
+          {
+            "id": "0",
+            "number": "01"
+          },
+          {
+            "id": "1",
+            "number": "04"
+          },
+          {
+            "id": "2",
+            "number": "00"
+          }
+        ],
+        "outdoorInfo": [
+          {
+            "id": "0",
+            "info": "01900A230418",
+            "serial": "**REDACTED**"
+          },
+          {
+            "id": "1",
+            "info": "000000000000",
+            "serial": "**REDACTED**"
+          },
+          {
+            "id": "2",
+            "info": "000000000000",
+            "serial": "**REDACTED**"
+          },
+          {
+            "id": "3",
+            "info": "000000000000",
+            "serial": "**REDACTED**"
+          }
+        ],
+        "mcuInfo": [
+          {
+            "id": "0",
+            "info": ""
+          },
+          {
+            "id": "1",
+            "info": ""
+          },
+          {
+            "id": "2",
+            "info": ""
+          },
+          {
+            "id": "3",
+            "info": ""
+          },
+          {
+            "id": "4",
+            "info": ""
+          },
+          {
+            "id": "5",
+            "info": ""
+          },
+          {
+            "id": "6",
+            "info": ""
+          },
+          {
+            "id": "7",
+            "info": ""
+          },
+          {
+            "id": "8",
+            "info": ""
+          },
+          {
+            "id": "9",
+            "info": ""
+          },
+          {
+            "id": "10",
+            "info": ""
+          },
+          {
+            "id": "11",
+            "info": ""
+          },
+          {
+            "id": "12",
+            "info": ""
+          },
+          {
+            "id": "13",
+            "info": ""
+          },
+          {
+            "id": "14",
+            "info": ""
+          },
+          {
+            "id": "15",
+            "info": ""
+          }
+        ]
+      }
+    },
+    {
+      "href": "/temperature/control/vs/0",
+      "rep": {
+        "x.com.samsung.da.increment": "0.5"
+      }
+    },
+    {
+      "href": "/temperatures/vs/0",
+      "rep": {
+        "x.com.samsung.da.items": [
+          {
+            "x.com.samsung.da.id": "0",
+            "x.com.samsung.da.description": "Temperature",
+            "x.com.samsung.da.desired": "27.0",
+            "x.com.samsung.da.current": "29.0",
+            "x.com.samsung.da.maximum": "30",
+            "x.com.samsung.da.minimum": "18",
+            "x.com.samsung.da.increment": "0.5",
+            "x.com.samsung.da.unit": "Celsius"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/timezone/vs/0",
+      "rep": {
+        "timezoneid": "Asia/Seoul",
+        "offset": "+09:00",
+        "DST": "OFF"
+      }
+    },
+    {
+      "href": "/wind/direction/vs/0",
+      "rep": {
+        "x.com.samsung.da.modes": "Fix",
+        "x.com.samsung.da.supportedModes": [
+          "Up_And_Low",
+          "Fix",
+          "Left_And_Right",
+          "All"
+        ]
+      }
+    },
+    {
+      "href": "/wind/strength/vs/0",
+      "rep": {
+        "x.com.samsung.da.modes": "0",
+        "x.com.samsung.da.supportedModes": [
+          "0",
+          "1",
+          "2",
+          "3"
+        ],
+        "x.com.samsung.da.modesName": [
+          "Auto",
+          "Low",
+          "Mid",
+          "High"
+        ]
+      }
+    }
+  ]
+}
@@ -0,0 +1,73 @@
+{
+  "device0": [
+    {
+      "rt": [
+        "x.com.samsung.devcol",
+        "oic.wk.col"
+      ],
+      "if": [
+        "oic.if.baseline",
+        "oic.if.ll",
+        "oic.if.b"
+      ]
+    },
+    {
+      "href": "/otninformation/vs/0",
+      "rep": {
+        "x.com.samsung.da.target": "",
+        "x.com.samsung.da.newVersionAvailable": "false"
+      }
+    },
+    {
+      "href": "/power/vs/0",
+      "rep": {
+        "x.com.samsung.da.power": "On"
+      }
+    },
+    {
+      "href": "/mode/vs/0",
+      "rep": {
+        "rt": [
+          "x.com.samsung.da.mode"
+        ],
+        "if": [
+          "oic.if.baseline",
+          "oic.if.a"
+        ],
+        "x.com.samsung.da.options": [
+          "DeviceType_NA9300K-/AA1",
+          "MainTimerCurrent_0",
+          "MainTimerSet_0",
+          "MainTimerState_Ready",
+          "OperationState0_Ready",
+          "OperationState1_Ready",
+          "OperationState3_Ready",
+          "OperationState4_Ready",
+          "OperationState5_Ready"
+        ]
+      }
+    },
+    {
+      "href": "/connected/vs/0",
+      "rep": {
+        "x.com.samsung.da.connected": "On"
+      }
+    },
+    {
+      "href": "/configuration/vs/0",
+      "rep": {}
+    },
+    {
+      "href": "/bluetooth/hood/status/vs/0",
+      "rep": {
+        "connectionState": "disconnected",
+        "micomModelId": "",
+        "firmwareVersion": "",
+        "power": "off",
+        "fanSpeed": 0,
+        "lampState": "off",
+        "timer": {}
+      }
+    }
+  ]
+}
@@ -0,0 +1,25 @@
+{
+  "state_keys": [
+    "alarm_code",
+    "blooming_level",
+    "clean_level",
+    "device_active",
+    "diagnosis_status",
+    "display_light",
+    "dust",
+    "energy_kwh",
+    "energy_last_month_kwh",
+    "energy_saved_kwh",
+    "energy_this_month_kwh",
+    "fan_direction",
+    "fan_speed_level",
+    "filter_progress",
+    "fine_dust",
+    "odor",
+    "operating_mode",
+    "power_energy_kwh",
+    "power_switch",
+    "power_watts",
+    "super_fine_dust"
+  ]
+}
@@ -0,0 +1,15 @@
+{
+  "state_keys": [
+    "air_filter_status",
+    "air_filter_usage",
+    "alarm_code",
+    "auto_clean",
+    "climate",
+    "diagnosis_status",
+    "energy_kwh",
+    "energy_saved_kwh",
+    "firmware_update",
+    "mute_once",
+    "power_watts"
+  ]
+}
@@ -0,0 +1,21 @@
+{
+  "state_keys": [
+    "any_burner_active",
+    "burner_0_state",
+    "burner_1_state",
+    "burner_3_state",
+    "burner_4_state",
+    "burner_5_state",
+    "cloud_connected",
+    "firmware_update",
+    "main_timer_current",
+    "main_timer_state",
+    "paired_hood_connected",
+    "paired_hood_fan_speed",
+    "paired_hood_firmware",
+    "paired_hood_light",
+    "paired_hood_model",
+    "paired_hood_power",
+    "power_state"
+  ]
+}
@@ -0,0 +1,25 @@
+{
+  "state_keys": [
+    "alarm_code",
+    "child_lock",
+    "cloud_connected",
+    "cook_time",
+    "current_temp_c",
+    "cycle_active",
+    "door_open",
+    "fast_preheat",
+    "finish_time",
+    "firmware_update",
+    "lamp",
+    "machine_state",
+    "natural_steam",
+    "operation_time_minutes",
+    "oven_mode",
+    "oven_setpoint",
+    "oven_state",
+    "power_switch",
+    "progress_percentage",
+    "remote_control",
+    "sound"
+  ]
+}
@@ -0,0 +1,25 @@
+{
+  "state_keys": [
+    "air_sensing_state",
+    "alarm_code",
+    "auto_ventilation_action",
+    "automatic_operation",
+    "automatic_ventilation_state",
+    "clean_level",
+    "energy_kwh",
+    "energy_saved_kwh",
+    "fan",
+    "firmware_update",
+    "hood_filter_capacity",
+    "hood_filter_status",
+    "hood_filter_usage",
+    "lamp",
+    "lamp_brightness",
+    "last_air_sensing_level",
+    "last_air_sensing_time",
+    "periodic_air_sensing",
+    "dust",
+    "fine_dust",
+    "super_fine_dust"
+  ]
+}
@@ -2,6 +2,7 @@
  "state_keys": [
    "alarm_code",
    "child_lock",
+    "cycle",
    "cycle_active",
    "delay_start_hours",
    "detergent_low",
@@ -0,0 +1,289 @@
+{
+  "meta": {
+    "model": "TP1X_DA-KS-OVEN-0107X (NV7000BS/ET5)",
+    "device_type": "oven",
+    "source": "issue #55 diagnostics (scrubbed)",
+    "note": "Wall oven reports no oneUiVersion; resolved via the '-OVEN-' modelNum token fallback in for_device_by_model, mirroring the '-RANGE-' fallback added for issue #44."
+  },
+  "device0": [
+    {
+      "rt": [
+        "x.com.samsung.devcol",
+        "oic.wk.col"
+      ],
+      "if": [
+        "oic.if.baseline",
+        "oic.if.ll",
+        "oic.if.b"
+      ]
+    },
+    {
+      "href": "/otninformation/vs/0",
+      "rep": {
+        "x.com.samsung.da.target": "",
+        "x.com.samsung.da.newVersionAvailable": "false",
+        "flashingProgress": "",
+        "otnStatus": "None",
+        "otnList": [
+          {
+            "type": "WIFI",
+            "modelId": "AKS-WW-TP1-22-OVEN-1",
+            "versions": [
+              "40250221"
+            ],
+            "visVersion": "250221"
+          },
+          {
+            "type": "Micom",
+            "modelId": "07134046004140472641",
+            "versions": [
+              "23011700",
+              "23122000"
+            ],
+            "visVersion": "231220"
+          },
+          {
+            "type": "Micom",
+            "modelId": "071360127441FFFFFFFF",
+            "versions": [
+              "21123000",
+              "FFFFFFFF"
+            ],
+            "visVersion": "211230"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/connected/vs/0",
+      "rep": {
+        "x.com.samsung.da.connected": "On"
+      }
+    },
+    {
+      "href": "/doors/vs/0",
+      "rep": {
+        "x.com.samsung.da.items": [
+          {
+            "x.com.samsung.da.id": "0",
+            "x.com.samsung.da.description": "Door",
+            "x.com.samsung.da.openState": "Close"
+          }
+        ],
+        "rt": [
+          "x.com.samsung.da.doors"
+        ],
+        "if": [
+          "oic.if.baseline",
+          "oic.if.s"
+        ]
+      }
+    },
+    {
+      "href": "/information/vs/0",
+      "rep": {
+        "x.com.samsung.da.modelNum": "TP1X_DA-KS-OVEN-0107X|40460041|50030018001611020A00000000000000",
+        "x.com.samsung.da.description": "NV7000BS/ET5",
+        "x.com.samsung.da.serialNum": "**REDACTED**",
+        "x.com.samsung.da.otnDUID": "**REDACTED**",
+        "x.com.samsung.da.items": [
+          {
+            "x.com.samsung.da.id": "0",
+            "x.com.samsung.da.description": "Version",
+            "x.com.samsung.da.type": "Software",
+            "x.com.samsung.da.number": "25022100",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          },
+          {
+            "x.com.samsung.da.id": "1",
+            "x.com.samsung.da.description": "Version",
+            "x.com.samsung.da.type": "Firmware",
+            "x.com.samsung.da.number": "04600A23011700, 04726A23122000",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          },
+          {
+            "x.com.samsung.da.id": "2",
+            "x.com.samsung.da.description": "Version",
+            "x.com.samsung.da.type": "Firmware",
+            "x.com.samsung.da.number": "01274A21123000",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          }
+        ],
+        "x.com.samsung.da.diagProtocolType": "BLE_OCF",
+        "x.com.samsung.da.diagLogType": [
+          "errCode",
+          "dump"
+        ],
+        "x.com.samsung.da.diagDumpType": "file",
+        "x.com.samsung.da.diagEndPoint": "SSM",
+        "x.com.samsung.da.diagMnid": "0AJT",
+        "x.com.samsung.da.diagSetupid": "KV1",
+        "x.com.samsung.da.diagMinVersion": "3.0",
+        "x.com.samsung.da.diagTsId": "DA01"
+      }
+    },
+    {
+      "href": "/mode/vs/0",
+      "rep": {
+        "x.com.samsung.da.supportedModes": [
+          "Autocook",
+          "Convection",
+          "TopHeatPluseConvection",
+          "Conventional",
+          "LargeGrill",
+          "SmallGrill",
+          "BottomHeatPluseConvection",
+          "PlateWarm",
+          "KeepWarm",
+          "Bottom",
+          "EcoConvection",
+          "FanGrill",
+          "Defrost",
+          "SteamClean"
+        ],
+        "x.com.samsung.da.modes": [
+          "NoOperation"
+        ],
+        "x.com.samsung.da.options": [
+          "DeviceType_NV7000BS/ET5",
+          "UpperTimerCurrent_0",
+          "UpperTimerSet_0",
+          "UpperTimerState_Ready",
+          "UpperLamp_Off",
+          "Sound_On"
+        ],
+        "x.com.samsung.da.defaultMode": "Convection",
+        "rt": [
+          "x.com.samsung.da.mode"
+        ],
+        "if": [
+          "oic.if.baseline",
+          "oic.if.a"
+        ]
+      }
+    },
+    {
+      "href": "/operational/state/vs/0",
+      "rep": {
+        "x.com.samsung.da.state": "Ready",
+        "x.com.samsung.da.operationTime": "00:00:00",
+        "x.com.samsung.da.remainingTime": "00:00:00",
+        "x.com.samsung.da.progressPercentage": "0",
+        "rt": [
+          "x.com.samsung.da.operation"
+        ],
+        "if": [
+          "oic.if.baseline",
+          "oic.if.a"
+        ]
+      }
+    },
+    {
+      "href": "/alarms/vs/0",
+      "rep": {
+        "rt": [
+          "x.com.samsung.da.alarms"
+        ],
+        "if": [
+          "oic.if.baseline",
+          "oic.if.s"
+        ],
+        "x.com.samsung.da.items": [
+          {
+            "x.com.samsung.da.id": "0",
+            "x.com.samsung.da.description": "Alarm",
+            "x.com.samsung.da.alarmType": "Device",
+            "x.com.samsung.da.code": "OV_E_OFF",
+            "x.com.samsung.da.triggeredTime": "2026-07-23T15:26:07"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/oven/vs/0",
+      "rep": {
+        "x.com.samsung.da.state": "Ready",
+        "x.com.samsung.da.recipe": "00000000000000",
+        "rt": [
+          "x.com.samsung.da.oven"
+        ],
+        "if": [
+          "oic.if.baseline",
+          "oic.if.s"
+        ]
+      }
+    },
+    {
+      "href": "/temperatures/vs/0",
+      "rep": {
+        "x.com.samsung.da.items": [
+          {
+            "x.com.samsung.da.id": "0",
+            "x.com.samsung.da.description": "Temperature",
+            "x.com.samsung.da.desired": "0",
+            "x.com.samsung.da.current": "0",
+            "x.com.samsung.da.increment": "5",
+            "x.com.samsung.da.unit": "Celsius"
+          }
+        ],
+        "rt": [
+          "x.com.samsung.da.temperatures"
+        ],
+        "if": [
+          "oic.if.baseline",
+          "oic.if.a"
+        ]
+      }
+    },
+    {
+      "href": "/timezone/vs/0",
+      "rep": {
+        "timezoneid": "Europe/Rome",
+        "offset": "+02:00",
+        "DST": "ON"
+      }
+    },
+    {
+      "href": "/configuration/vs/0",
+      "rep": {}
+    },
+    {
+      "href": "/kidslock/vs/0",
+      "rep": {
+        "x.com.samsung.da.kidsLock": "Ready"
+      }
+    },
+    {
+      "href": "/power/vs/0",
+      "rep": {
+        "x.com.samsung.da.power": "On"
+      }
+    },
+    {
+      "href": "/remotectrl/vs/0",
+      "rep": {
+        "x.com.samsung.da.remoteControlEnabled": "true",
+        "rt": [
+          "x.com.samsung.da.configuration"
+        ],
+        "if": [
+          "oic.if.baseline",
+          "oic.if.s"
+        ]
+      }
+    },
+    {
+      "href": "/wirelessinfo/vs/0",
+      "rep": {
+        "macaddressWiFi": "**REDACTED**",
+        "macaddressBLE": "**REDACTED**"
+      }
+    },
+    {
+      "href": "/quickcontrol/info/vs/0",
+      "rep": {
+        "supportedVersion": "1.0"
+      }
+    }
+  ]
+}
@@ -0,0 +1,199 @@
+{
+  "device0": [
+    {
+      "rt": ["x.com.samsung.devcol", "oic.wk.col"],
+      "if": ["oic.if.baseline", "oic.if.ll", "oic.if.b"]
+    },
+    {
+      "href": "/personality/presence/vs/0",
+      "rep": {
+        "x.com.samsung.da.items": [
+          {
+            "x.com.samsung.da.id": "",
+            "x.com.samsung.da.deviceId": "TEST-DEVICE-ID",
+            "x.com.samsung.da.value": ""
+          }
+        ]
+      }
+    },
+    {
+      "href": "/realtimenotiforclient/vs/0",
+      "rep": {
+        "x.com.samsung.da.timeforshortnoti": "0",
+        "x.com.samsung.da.longnotisubscription": "false",
+        "x.com.samsung.da.periodicnotisubscription": "true"
+      }
+    },
+    {
+      "href": "/airlevelcheck/vs/0",
+      "rep": {
+        "x.com.samsung.da.periodicSensingActivationState": "Off",
+        "x.com.samsung.da.periodicSensingInterval": "3600",
+        "x.com.samsung.da.startSensingOnce": "Off",
+        "x.com.samsung.da.sensingState": "NonProcessing",
+        "x.com.samsung.da.lastSensingTime": "1784651378",
+        "x.com.samsung.da.lastSensingLevel": "Kr2",
+        "x.com.samsung.da.autoExeState": "Sensing",
+        "x.com.samsung.da.supportedAutoExeState": ["Airpurify", "Alarm"],
+        "x.com.samsung.da.periodicSensingSkipStatus": "Off",
+        "x.com.samsung.da.periodicSensingSkipTime": "00000000"
+      }
+    },
+    {
+      "href": "/alarms/vs/0",
+      "rep": {
+        "x.com.samsung.da.items": [
+          {
+            "x.com.samsung.da.id": "0",
+            "x.com.samsung.da.description": "Alarm",
+            "x.com.samsung.da.alarmType": "Device",
+            "x.com.samsung.da.code": "ErrorCode_OFF",
+            "x.com.samsung.da.triggeredTime": "2026-07-21T20:18:51",
+            "x.com.samsung.da.state": "Deleted"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/energy/consumption/vs/0",
+      "rep": {
+        "x.com.samsung.da.cumulativePower": "165620",
+        "x.com.samsung.da.cumulativeSavedPower": "0",
+        "x.com.samsung.da.cumulativeDate": "1784647130",
+        "x.com.samsung.da.cumulativeDateUTC": "1784665130",
+        "x.com.samsung.da.cumulativeUnit": "Wh"
+      }
+    },
+    {"href": "/energy/consumption/0", "rep": {}},
+    {
+      "href": "/mode/vs/0",
+      "rep": {
+        "x.com.samsung.da.options": ["OptionCode_19322", "UpdateAllow_NotAllowed"]
+      }
+    },
+    {
+      "href": "/power/vs/0",
+      "rep": {"x.com.samsung.da.power": "Off"}
+    },
+    {"href": "/power/0", "rep": {"value": false}},
+    {
+      "href": "/sensors/vs/0",
+      "rep": {
+        "x.com.samsung.da.items": [
+          {
+            "x.com.samsung.da.id": "0",
+            "x.com.samsung.da.description": "Sensor for CleanLevel",
+            "x.com.samsung.da.type": "CleanLevel",
+            "x.com.samsung.da.value": ["2"]
+          },
+          {
+            "x.com.samsung.da.id": "2",
+            "x.com.samsung.da.description": "Sensor for Dust",
+            "x.com.samsung.da.type": "Dust",
+            "x.com.samsung.da.value": ["18", "1"]
+          },
+          {
+            "x.com.samsung.da.id": "3",
+            "x.com.samsung.da.description": "Sensor for FineDust",
+            "x.com.samsung.da.type": "FineDust",
+            "x.com.samsung.da.value": ["14", "1"]
+          },
+          {
+            "x.com.samsung.da.id": "4",
+            "x.com.samsung.da.description": "Sensor for SuperFineDust",
+            "x.com.samsung.da.type": "SuperFineDust",
+            "x.com.samsung.da.value": ["9", "1"]
+          }
+        ]
+      }
+    },
+    {
+      "href": "/information/vs/0",
+      "rep": {
+        "x.com.samsung.da.modelNum": "AHD-WW-TP1-22-COMMON|20136141|7800006B001713C44D00090001030000",
+        "x.com.samsung.da.description": "AHD-WW-TP1-22-COMMON",
+        "x.com.samsung.da.serialNum": "TEST-HOOD-SERIAL",
+        "x.com.samsung.da.diagProtocolType": "WIFI_HTTPS",
+        "x.com.samsung.da.diagSetupid": "KH0"
+      }
+    },
+    {
+      "href": "/file/information/vs/0",
+      "rep": {"x.com.samsung.timeoffset": "-05:00"}
+    },
+    {
+      "href": "/configuration/vs/0",
+      "rep": {
+        "x.com.samsung.da.region": "0000000000",
+        "x.com.samsung.da.airconOptionList": ["DR"],
+        "x.com.samsung.da.countryCode": ""
+      }
+    },
+    {
+      "href": "/drlc/0",
+      "rep": {
+        "DRLevel": 0,
+        "start": "1970-01-01T00:00:00Z",
+        "durationminutes": 0,
+        "override": false
+      }
+    },
+    {
+      "href": "/drlc/vs/0",
+      "rep": {
+        "x.com.samsung.da.drlcLevel": "0",
+        "x.com.samsung.da.durationminutes": "0",
+        "x.com.samsung.da.start": "1970-01-01T00:00:00Z",
+        "x.com.samsung.da.override": "Off",
+        "x.com.samsung.da.realSaving": "Off"
+      }
+    },
+    {
+      "href": "/availablecontrolsets/vs/0",
+      "rep": {
+        "x.com.samsung.da.sets": "0000000000012000000000000000",
+        "x.com.samsung.da.id": "HOOD",
+        "x.com.samsung.da.version": "1.0"
+      }
+    },
+    {
+      "href": "/da/softreset/vs/0",
+      "rep": {"x.com.samsung.da.softwarereset": "false"}
+    },
+    {
+      "href": "/filter/hoodfilter/vs/0",
+      "rep": {
+        "x.com.samsung.da.filterUsage": "100",
+        "x.com.samsung.da.filterUsageResolution": "1",
+        "x.com.samsung.da.filterStatus": "wash",
+        "x.com.samsung.da.filterCapacity": "60",
+        "x.com.samsung.da.filterCapacityUnit": "Hour",
+        "x.com.samsung.da.filterResetType": ["replaceable", "washable"]
+      }
+    },
+    {
+      "href": "/hood/fanspeed/vs/0",
+      "rep": {
+        "x.com.samsung.da.hood.autoOperation": "Off",
+        "x.com.samsung.da.hood.fanSpeed": "14",
+        "x.com.samsung.da.hood.supportedFanSpeed": ["14", "15", "16", "17"]
+      }
+    },
+    {
+      "href": "/hood/lamp/vs/0",
+      "rep": {
+        "x.com.samsung.lamp.power": "Off",
+        "x.com.samsung.lamp.current": "2",
+        "x.com.samsung.lamp.range": ["1", "2"]
+      }
+    },
+    {"href": "/autoventilation/vs/0", "rep": {"action": "Start"}},
+    {
+      "href": "/otninformation/vs/0",
+      "rep": {
+        "x.com.samsung.da.target": "",
+        "x.com.samsung.da.newVersionAvailable": "false"
+      }
+    }
+  ]
+}
@@ -9,7 +9,8 @@ from homeassistant.data_entry_flow import FlowResultType
 from pytest_homeassistant_custom_component.common import MockConfigEntry

 from custom_components.localthings.const import (
-    CONF_CA_CERT_PEM, CONF_CA_KEY_PEM, CONF_HOST, CONF_PORT, DOMAIN,
+    CONF_BYPASS_REMOTE_CONTROL, CONF_CA_CERT_PEM, CONF_CA_KEY_PEM,
+    CONF_HOST, CONF_PORT, DOMAIN,
 )

 from .conftest import (
@@ -276,3 +277,45 @@ def test_probe_marks_washer_as_recognized(monkeypatch):
        ) is not None
    )
    assert recognized is True
+
+
+async def test_options_flow_default_is_off(hass: HomeAssistant) -> None:
+    """The bypass defaults to False, so devices that never touch this
+    option see no change in the remote-control write block."""
+    entry = MockConfigEntry(domain=DOMAIN, data=ENTRY_DATA, unique_id=f'localthings_{MOCK_SERIAL}')
+    entry.add_to_hass(hass)
+
+    result = await hass.config_entries.options.async_init(entry.entry_id)
+
+    assert result['type'] == FlowResultType.FORM
+    assert result['step_id'] == 'init'
+    assert result['data_schema']({})[CONF_BYPASS_REMOTE_CONTROL] is False
+
+
+async def test_options_flow_can_enable_bypass(hass: HomeAssistant) -> None:
+    """Submitting the form with the toggle on stores it in entry.options,
+    where coordinator.async_send_command reads it (issue #54)."""
+    entry = MockConfigEntry(domain=DOMAIN, data=ENTRY_DATA, unique_id=f'localthings_{MOCK_SERIAL}')
+    entry.add_to_hass(hass)
+
+    result = await hass.config_entries.options.async_init(entry.entry_id)
+    result = await hass.config_entries.options.async_configure(
+        result['flow_id'], user_input={CONF_BYPASS_REMOTE_CONTROL: True}
+    )
+
+    assert result['type'] == FlowResultType.CREATE_ENTRY
+    assert entry.options[CONF_BYPASS_REMOTE_CONTROL] is True
+
+
+async def test_options_flow_reflects_previously_saved_value(hass: HomeAssistant) -> None:
+    """Reopening the form shows the currently-saved choice as the default,
+    not always False."""
+    entry = MockConfigEntry(
+        domain=DOMAIN, data=ENTRY_DATA, unique_id=f'localthings_{MOCK_SERIAL}',
+        options={CONF_BYPASS_REMOTE_CONTROL: True},
+    )
+    entry.add_to_hass(hass)
+
+    result = await hass.config_entries.options.async_init(entry.entry_id)
+
+    assert result['data_schema']({})[CONF_BYPASS_REMOTE_CONTROL] is True
@@ -11,7 +11,7 @@ from homeassistant.exceptions import ServiceValidationError
 from homeassistant.helpers import issue_registry as ir

 from custom_components.localthings.const import (
-    CONF_HOST, DOMAIN, SUMMARY_INTERVAL_S,
+    CONF_BYPASS_REMOTE_CONTROL, CONF_HOST, DOMAIN, SUMMARY_INTERVAL_S,
 )
 from custom_components.localthings.coordinator import LocalThingsCoordinator
 from custom_components.localthings.registry.capabilities.common import (
@@ -136,6 +136,31 @@ def test_run_discovery_detects_washer_via_model_fallback(
    assert coordinator.device_type_name == 'washer'


+def test_run_discovery_detects_cooktop_via_resource_signature(
+    hass: HomeAssistant, mock_entry
+) -> None:
+    """NA9300K omits oneUiVersion and information but has burner options."""
+    from tests.conftest import _load_device
+
+    coordinator = LocalThingsCoordinator(hass, mock_entry)
+    coordinator._run_discovery(_load_device('cooktop'))
+
+    assert coordinator.device_type_name == 'cooktop'
+    assert coordinator._unbound_hrefs == []
+
+
+def test_run_discovery_detects_range_hood_via_model(
+    hass: HomeAssistant, mock_entry
+) -> None:
+    from tests.conftest import _load_device
+
+    coordinator = LocalThingsCoordinator(hass, mock_entry)
+    coordinator._run_discovery(_load_device('range_hood'))
+
+    assert coordinator.device_type_name == 'range_hood'
+    assert coordinator._unbound_hrefs == []
+
+
 def test_update_coverage_gap_issue_creates_issue_for_unknown_type(
    hass: HomeAssistant, mock_entry
 ) -> None:
@@ -618,7 +643,13 @@ async def test_write_marks_href_pending_before_post(
    hass: HomeAssistant, mock_entry, mock_coordinator_observe_session
 ) -> None:
    """async_send_command must call mark_write_pending before POSTing so a
-    slow-to-settle device can't immediately revert the optimistic write."""
+    slow-to-settle device can't immediately revert the optimistic write --
+    and it must guard the write's actual target href (write_fn's own
+    path_segs), not bound_entity.href. Those differ for a composite entity
+    like the AC's ClimateDesc (bound to /mode/vs/0, but writing power/temp/
+    fan/swing/preset to their own sibling hrefs) -- guarding the bound href
+    protected the wrong resource and left the one the entity actually
+    displays from unprotected (issues #17/#53)."""
    from custom_components.localthings.registry.discovery import BoundEntity
    from custom_components.localthings.registry.entities import NumberDesc

@@ -637,17 +668,23 @@ async def test_write_marks_href_pending_before_post(
        fake.post = lambda *a, **k: (0x44, b'')
        await coordinator.async_send_command(bound, 5)

-    assert coordinator._observe._settle_until.get('/test/vs/0') is not None
+    assert coordinator._observe._settle_until.get('/some/path') is not None
+    assert coordinator._observe._settle_until.get('/test/vs/0') is None


 async def test_send_command_applies_write_optimistically_before_settling(
-    hass: HomeAssistant, mock_entry, mock_coordinator_observe_session
+    hass: HomeAssistant, mock_entry, mock_coordinator_observe_session,
 ) -> None:
-    """The cache must reflect a write immediately, and stay put against a
-    stale echo for the rest of the settle window -- otherwise
-    mark_write_pending has nothing to protect and just delays the real
-    device confirmation instead, which reads to a user as the write being
-    silently reverted (issue #27)."""
+    """The cache must reflect a write immediately at the write's actual
+    target href (write_fn's path_segs) -- not bound_entity.href, which
+    differs for a composite entity like the AC's ClimateDesc -- and stay put
+    against a stale echo for the rest of the settle window there.
+
+    Applying the optimistic value to bound_entity.href instead is exactly
+    how issues #17/#53 survived the original optimistic-apply fix (issue
+    #27): the bound href got a harmless (if nonsensical) optimistic merge,
+    while the resource the entity actually reads from for its displayed
+    state never got one and stayed stale until the next real read of it."""
    from custom_components.localthings.registry.discovery import BoundEntity
    from custom_components.localthings.registry.entities import NumberDesc

@@ -666,18 +703,150 @@ async def test_send_command_applies_write_optimistically_before_settling(
        fake.post = lambda *a, **k: (0x44, b'')
        await coordinator.async_send_command(bound, 5)

-    # The optimistic value is visible right away, without waiting for a
-    # device response.
-    assert coordinator._cache.get('/test/vs/0') == {'value': 5}
+    # The optimistic value is visible right away at the write's real
+    # target, not the bound href.
+    assert coordinator._cache.get('/some/path') == {'value': 5}
+    assert coordinator._cache.get('/test/vs/0') != {'value': 5}

    # A stale update racing in behind the write (e.g. a poll/notify that
    # was already in flight before the PUT) must not clobber it while the
    # settle window is open.
+    applied = coordinator._observe.apply('/some/path', {'value': 0}, source='observe')
+    assert applied is False
+    assert coordinator._cache.get('/some/path') == {'value': 5}
+
+
+async def test_climate_power_write_applies_to_its_own_href_not_bound_href(
+    hass: HomeAssistant, mock_entry, mock_coordinator_observe_session
+) -> None:
+    """Regression for issues #17/#53, using the real AC capability. The
+    composite climate entity binds /mode/vs/0 (airconditioner.CLIMATE.href),
+    but a power command's write_fn (airconditioner._climate_write) targets
+    the sibling /power/0 -- the href climate.py's `_is_on()` actually reads.
+    The optimistic value and settle guard must land there, not on the bound
+    /mode/vs/0, or the entity never sees the write and shows stale state
+    until the next unrelated read of /power/0."""
+    from custom_components.localthings.registry.capabilities import airconditioner
+    from custom_components.localthings.registry.discovery import BoundEntity
+
+    fake = mock_coordinator_observe_session
+    await hass.config_entries.async_setup(mock_entry.entry_id)
+    await hass.async_block_till_done()
+    coordinator: LocalThingsCoordinator = hass.data[DOMAIN][mock_entry.entry_id]
+
+    bound = BoundEntity(
+        href=airconditioner.CLIMATE.href,
+        capability=coordinator.bound[0].capability,
+        desc=airconditioner.CLIMATE.entities[0],
+    )
+
+    with patch.object(fake, 'subscribe'):
+        fake.post = lambda *a, **k: (0x44, b'')
+        await coordinator.async_send_command(bound, ('power', True))
+
+    assert coordinator._cache.get('/power/0') == {'value': True}
+    assert coordinator._cache.get(airconditioner.CLIMATE.href) != {'value': True}
+    assert coordinator._observe._settle_until.get('/power/0') is not None
+
+
+async def test_send_command_survives_stale_confirm_poll(
+    hass: HomeAssistant, mock_entry, mock_coordinator_observe_session, fridge_resources,
+) -> None:
+    """The settle window must outlast the confirm poll async_send_command
+    triggers via async_request_refresh(), not just DEFAULT_SETTLE_S's fixed
+    few seconds (issue #9). Some devices settle a write internally slower
+    than that refresh's own round trip -- issue #9's washer packs cycle/
+    detergent/softener selection into /course/vs/0's shared options[]
+    array, which visibly takes a few seconds of validation/dispenser
+    movement to catch up, unlike /washer/vs/0's plain temperature/spin
+    fields on the same device, which confirm instantly. A confirm poll that
+    lands before the device has caught up is stale, and a settle window
+    sized only to the fixed default (rather than the PUT+poll round trip)
+    expires before that poll even returns, so the stale read lands
+    unprotected and reverts the optimistic value -- self-correcting again
+    only once a later poll finally sees the real change. That reads to a
+    user as the write reverting, then reapplying itself, a few seconds
+    later."""
+    from custom_components.localthings.registry.discovery import BoundEntity
+    from custom_components.localthings.registry.entities import NumberDesc
+
+    fake = mock_coordinator_observe_session
+    await hass.config_entries.async_setup(mock_entry.entry_id)
+    await hass.async_block_till_done()
+    coordinator: LocalThingsCoordinator = hass.data[DOMAIN][mock_entry.entry_id]
+
+    def _write_fn(payload, rep, href):
+        return (['test', 'vs', '0'], {'value': payload})
+
+    desc = NumberDesc(key='test', field='value', write_fn=_write_fn)
+    bound = BoundEntity(href='/test/vs/0', capability=coordinator.bound[0].capability, desc=desc)
+
+    def _stale_confirm_poll():
+        # Stand-in for the write's own confirming /device/0 poll racing
+        # against a stale read for the same href -- the device's internal
+        # state hasn't caught up to the write yet, even though it will a
+        # little later.
+        coordinator._observe.apply('/test/vs/0', {'value': 0}, source='poll')
+        return fridge_resources
+
+    with (
+        patch.object(fake, 'subscribe'),
+        patch.object(LocalThingsCoordinator, '_poll_once', side_effect=_stale_confirm_poll),
+    ):
+        fake.post = lambda *a, **k: (0x44, b'')
+        await coordinator.async_send_command(bound, 5)
+
+    # The optimistic value is visible right away and survived the stale
+    # confirm-poll race triggered by the refresh above.
+    assert coordinator._cache.get('/test/vs/0') == {'value': 5}
+
+    # The settle window is still open afterward -- sized to outlast the
+    # whole PUT + confirm-poll round trip, not released the moment that
+    # round trip happens to finish.
    applied = coordinator._observe.apply('/test/vs/0', {'value': 0}, source='observe')
    assert applied is False
    assert coordinator._cache.get('/test/vs/0') == {'value': 5}


+async def test_second_write_to_same_href_lands_during_first_writes_settle_window(
+    hass: HomeAssistant, mock_entry, mock_coordinator_observe_session,
+) -> None:
+    """Regression for issue #9: /course/vs/0 backs several independent
+    washer selects (cycle, detergent quantity, softener quantity, ...)
+    sharing one href. The settle window is now sized to tens of seconds
+    (see test_send_command_survives_stale_confirm_poll), which makes a
+    second, different write to that href landing while the first write's
+    window is still open a routine occurrence -- e.g. a user picking a
+    cycle and then adjusting detergent quantity within the same minute --
+    not a rare edge case. The second write's own optimistic value must
+    still show up immediately; a guard meant to protect optimistic writes
+    from stale device echoes must not itself suppress a later one."""
+    from custom_components.localthings.registry.discovery import BoundEntity
+    from custom_components.localthings.registry.entities import NumberDesc
+
+    fake = mock_coordinator_observe_session
+    await hass.config_entries.async_setup(mock_entry.entry_id)
+    await hass.async_block_till_done()
+    coordinator: LocalThingsCoordinator = hass.data[DOMAIN][mock_entry.entry_id]
+
+    desc_a = NumberDesc(key='cycle', field='cycle',
+                        write_fn=lambda p, rep, href: (['test', 'vs', '0'], {'cycle': p}))
+    desc_b = NumberDesc(key='detergent', field='detergent',
+                        write_fn=lambda p, rep, href: (['test', 'vs', '0'], {'detergent': p}))
+    bound_a = BoundEntity(href='/test/vs/0', capability=coordinator.bound[0].capability, desc=desc_a)
+    bound_b = BoundEntity(href='/test/vs/0', capability=coordinator.bound[0].capability, desc=desc_b)
+
+    with patch.object(fake, 'subscribe'):
+        fake.post = lambda *a, **k: (0x44, b'')
+        await coordinator.async_send_command(bound_a, 'Eco')
+        assert coordinator._cache.get('/test/vs/0') == {'cycle': 'Eco'}
+
+        # Still well within the first write's settle window.
+        await coordinator.async_send_command(bound_b, 'High')
+
+    assert coordinator._cache.get('/test/vs/0') == {'cycle': 'Eco', 'detergent': 'High'}
+
+
 class TestRemoteControlEnabled:
    """remote_control_enabled (registry/capabilities/common.py) is the
    single source of truth for the /remotectrl on/off signal, shared by
@@ -778,7 +947,7 @@ async def test_send_command_allowed_when_remote_control_enabled(
        fake.post = lambda *a, **k: (0x44, b'')
        await coordinator.async_send_command(bound, 5)

-    assert coordinator._observe._settle_until.get('/test/vs/0') is not None
+    assert coordinator._cache.get('/some/path') == {'value': 5}


 async def test_send_command_remote_control_check_precedes_validate_fn(
@@ -810,3 +979,44 @@ async def test_send_command_remote_control_check_precedes_validate_fn(

    with pytest.raises(ServiceValidationError, match="Remote control is turned off"):
        await coordinator.async_send_command(bound, 'On')
+
+
+async def test_send_command_bypasses_remote_control_when_option_enabled(
+    hass: HomeAssistant, mock_coordinator_observe_session
+) -> None:
+    """Issue #54: some devices accept certain writes even while reporting
+    remote control off, so a user who's confirmed that for their device can
+    opt it out of the block entirely via the options flow
+    (CONF_BYPASS_REMOTE_CONTROL, entry.options -- not entry.data)."""
+    from pytest_homeassistant_custom_component.common import MockConfigEntry
+
+    from custom_components.localthings.registry.discovery import BoundEntity
+    from custom_components.localthings.registry.entities import NumberDesc
+
+    entry = MockConfigEntry(
+        domain=DOMAIN, data=ENTRY_DATA, unique_id=f'localthings_{MOCK_SERIAL}',
+        options={CONF_BYPASS_REMOTE_CONTROL: True},
+    )
+    entry.add_to_hass(hass)
+
+    fake = mock_coordinator_observe_session
+    await hass.config_entries.async_setup(entry.entry_id)
+    await hass.async_block_till_done()
+    coordinator: LocalThingsCoordinator = hass.data[DOMAIN][entry.entry_id]
+    coordinator._cache.apply_rep(
+        '/remotectrl/vs/0',
+        {'x.com.samsung.da.remoteControlEnabled': 'false'},
+        source='test',
+    )
+
+    def _write_fn(payload, rep, href):
+        return (['some', 'path'], {'value': payload})
+
+    desc = NumberDesc(key='test', field='value', write_fn=_write_fn)
+    bound = BoundEntity(href='/test/vs/0', capability=coordinator.bound[0].capability, desc=desc)
+
+    with patch.object(fake, 'subscribe'):
+        fake.post = lambda *a, **k: (0x44, b'')
+        await coordinator.async_send_command(bound, 5)
+
+    assert coordinator._cache.get('/some/path') == {'value': 5}
@@ -67,6 +67,30 @@ def test_apply_drops_update_during_settle_window():
    assert mgr.cache.get('/oven/vs/0') == {'a': 1}


+def test_apply_optimistic_bypasses_an_in_progress_settle_window():
+    """Regression for issue #9: /course/vs/0 backs several independent
+    washer selects (cycle, detergent quantity, softener quantity, ...).
+    Picking a second one while the first's settle window is still open
+    (now sized to tens of seconds -- see coordinator._POST_TIMEOUT_S/
+    _POLL_TIMEOUT_S) is a normal sequence, not a stale echo of the first
+    write, and must land in the cache immediately -- not get silently
+    dropped by a guard that exists to protect optimistic writes, not
+    suppress them."""
+    mgr = _manager()
+    mgr.cache.apply_rep('/course/vs/0', {'Course': '1C', 'Detergent': '1'}, source='seed')
+    mgr.mark_write_pending('/course/vs/0', settle_s=30.0)
+
+    result = mgr.apply('/course/vs/0', {'Detergent': '2'}, source='optimistic')
+
+    assert result is True
+    assert mgr.cache.get('/course/vs/0') == {'Course': '1C', 'Detergent': '2'}
+
+    # A poll/sweep/observe update racing in right behind it is still
+    # gated -- the second write's own guard (re-armed by mark_write_pending,
+    # not exercised directly here) is what protects it going forward.
+    assert mgr.apply('/course/vs/0', {'Detergent': '1'}, source='poll') is False
+
+
 def test_apply_accepts_update_after_settle_window_elapses():
    mgr = _manager()
    mgr.mark_write_pending('/oven/vs/0', settle_s=0.05)
@@ -0,0 +1,108 @@
+"""Tests for the ARTIK051_TVTL_18K air-purifier profile (issue #56)."""
+from custom_components.localthings.registry.adapter import flatten
+from custom_components.localthings.registry.by_type import for_device_by_model
+from custom_components.localthings.registry.capabilities import air_purifier
+from custom_components.localthings.registry.discovery import discover
+from tests.conftest import _load_device
+
+
+def _purifier():
+    resources = _load_device('air_purifier')
+    info = resources['/information/vs/0']
+    reg = for_device_by_model(
+        info['x.com.samsung.da.modelNum'], info['x.com.samsung.da.description'],
+    )
+    return reg, resources
+
+
+def _state():
+    reg, resources = _purifier()
+    bound = discover(resources, reg.capabilities, reg.pattern_capabilities)
+    return flatten(bound, resources)
+
+
+def test_model_resolves_to_air_purifier_registry():
+    reg, _ = _purifier()
+    assert reg is not None
+    assert reg.name == 'air_purifier'
+
+
+def test_no_unbound_hrefs():
+    """Every resource in the issue #56 dump binds or is ignored -- clears the
+    coverage-gap repair."""
+    reg, resources = _purifier()
+    unbound = []
+    discover(resources, reg.capabilities, reg.pattern_capabilities, log=unbound.append)
+    assert unbound == []
+
+
+def test_expected_entities_present():
+    state = _state()
+    for key in (
+        'power_switch', 'alarm_code', 'dust', 'fine_dust', 'super_fine_dust',
+        'odor', 'clean_level', 'filter_progress', 'device_active',
+        'diagnosis_status', 'fan_speed_level', 'fan_direction',
+        'display_light', 'operating_mode', 'blooming_level',
+    ):
+        assert key in state, key
+
+
+def test_air_quality_sensor_values():
+    """Dust/FineDust/SuperFineDust/Odor/CleanLevel read index 0 of each
+    items[] entry's value list (the raw measurement, per common.sensor_item_value)."""
+    state = _state()
+    assert state['dust'] == 11
+    assert state['fine_dust'] == 9
+    assert state['super_fine_dust'] == 5
+    assert state['odor'] == 0
+    assert state['clean_level'] == 0
+
+
+def test_filter_progress_reads_named_consumable_item():
+    assert _state()['filter_progress'] == 100
+
+
+def test_diagnosis_reuses_dishwasher_capability():
+    """/diagnosis/vs/0 has the identical field/write contract as
+    dishwasher.DIAGNOSIS, so the by_type registry reuses it directly."""
+    from custom_components.localthings.registry.capabilities import dishwasher
+    reg, _ = _purifier()
+    assert dishwasher.DIAGNOSIS in reg.capabilities['/diagnosis/vs/0']
+
+
+def test_light_switch_write_contract():
+    """The display-light switch RMW-replaces only the 'Light_*' entry in the
+    packed /mode/vs/0 options list (via laundry.replace_in_options), leaving
+    the other flags and the list order untouched."""
+    desc = next(e for e in air_purifier.MODE.entities if e.key == 'display_light')
+    rep = {'x.com.samsung.da.options': [
+        'Comode_Off', 'Blooming_0', 'Light_On', 'OptionCode_60282',
+    ]}
+    assert desc.rep_fn(rep) is True
+    assert desc.write_fn('Off', rep) == (
+        ['mode', 'vs', '0'],
+        {'x.com.samsung.da.options': [
+            'Comode_Off', 'Blooming_0', 'Light_Off', 'OptionCode_60282',
+        ]},
+    )
+
+
+def test_mode_tokens_are_read_only_diagnostics():
+    """Comode_/Blooming_ tokens surface as raw diagnostic sensors rather than
+    a select/control -- their valid value ranges aren't confirmed yet (see
+    the air_purifier.py module docstring and the issue #56 follow-up)."""
+    operating_mode = next(e for e in air_purifier.MODE.entities if e.key == 'operating_mode')
+    blooming = next(e for e in air_purifier.MODE.entities if e.key == 'blooming_level')
+    rep = {'x.com.samsung.da.options': ['Comode_Off', 'Blooming_6']}
+    assert operating_mode.rep_fn(rep) == 'Off'
+    assert blooming.rep_fn(rep) == '6'
+    assert not hasattr(operating_mode, 'write_fn')
+
+
+def test_airflow_vs_fallback_only_binds_without_generic():
+    """/airflow/vs/0 is a match_fn fallback -- it must not bind when the
+    OCF-standard /airflow/0 is also present (both are on every dump seen)."""
+    assert air_purifier.AIRFLOW_VS_FALLBACK.match_fn(
+        {}, {'/airflow/0': {'speed': 0, 'direction': 'Off'}},
+    ) is False
+    assert air_purifier.AIRFLOW_VS_FALLBACK.match_fn({}, {}) is True
@@ -215,6 +215,30 @@ def test_tp1x_rac_expected_state_keys_present():
        assert key in state, key


+def test_caww_tp2_model_resolves_via_model_fallback():
+    """A-CAWW-TP2-20-COMMON (issue #52, System AC) reports no oneUiVersion
+    and no '_RAC_'/'_PRAC_' token -- resolved via the '-CAWW-' modelNum
+    fallback added for this device."""
+    reg, _ = _resolve('airconditioner_caww_tp2')
+    assert reg is not None and reg.name == 'airconditioner'
+
+
+def test_caww_tp2_no_unbound_hrefs():
+    """Every resource in the issue #52 dump binds or is ignored -- clears
+    the coverage-gap repair. Only new href beyond the existing RAC/PRAC
+    surface is /sac/installationinfo/vs/0 (opaque SAC installation topology,
+    ignored)."""
+    reg, resources = _resolve('airconditioner_caww_tp2')
+    unbound = []
+    discover(resources, reg.capabilities, reg.pattern_capabilities, log=unbound.append)
+    assert unbound == []
+
+
+def test_caww_tp2_sac_installationinfo_is_ignored():
+    ignored_hrefs = {cap.href for cap in airconditioner.COVERAGE}
+    assert '/sac/installationinfo/vs/0' in ignored_hrefs
+
+
 def test_mute_once_write_target():
    write = airconditioner.MUTE_ONCE.entities[0].write_fn
    assert write('On', {}) == (['option', 'muteonce', 'vs', '0'], {'muteonce': 'On'})
@@ -41,6 +41,16 @@ class TestForDevice:
        assert isinstance(registry, DeviceRegistry)
        assert registry.name == 'refrigerator'

+    def test_for_device_returns_cooktop_registry(self):
+        registry = for_device('7.0 Cooktop')
+        assert registry is not None
+        assert registry.name == 'cooktop'
+
+    def test_for_device_returns_range_hood_registry(self):
+        registry = for_device('7.0 Range Hood')
+        assert registry is not None
+        assert registry.name == 'range_hood'
+

 class TestDeviceRegistries:
    """Tests for device registries themselves."""
@@ -180,6 +190,25 @@ class TestForDeviceByModel:
        assert reg is not None
        assert reg.name == 'airconditioner'

+    def test_cooktop_via_legacy_model_description(self):
+        """Older cooktops identify themselves as ARTIK051_GLOBAL_COOKTOP."""
+        from custom_components.localthings.registry.by_type import for_device_by_model
+        reg = for_device_by_model(
+            'ARTIK051_GB_CT_001|40424141|50000204001211000200000000000000',
+            'ARTIK051_GLOBAL_COOKTOP',
+        )
+        assert reg is not None
+        assert reg.name == 'cooktop'
+
+    def test_range_hood_via_ahd_model(self):
+        from custom_components.localthings.registry.by_type import for_device_by_model
+        reg = for_device_by_model(
+            'AHD-WW-TP1-22-COMMON|20136141|7800006B001713C44D00090001030000',
+            'AHD-WW-TP1-22-COMMON',
+        )
+        assert reg is not None
+        assert reg.name == 'range_hood'
+
    def test_washer_wf_prefix(self):
        """US front-load washers use the WF consumer-model prefix."""
        from custom_components.localthings.registry.by_type import for_device_by_model
@@ -200,6 +229,18 @@ class TestForDeviceByModel:
        assert reg is not None
        assert reg.name == 'washer'

+    def test_oven_via_oven_token(self):
+        """Issue #55: a wall oven (NV7000BS/ET5) reports no oneUiVersion and
+        an unrecognized consumer token ('NV'); it falls back to the '-OVEN-'
+        token in modelNum, mirroring the '-RANGE-' fallback for issue #44."""
+        from custom_components.localthings.registry.by_type import for_device_by_model
+        reg = for_device_by_model(
+            'TP1X_DA-KS-OVEN-0107X|40460041|50030018001611020A00000000000000',
+            'NV7000BS/ET5',
+        )
+        assert reg is not None
+        assert reg.name == 'oven'
+
    def test_unknown_model_returns_none(self):
        from custom_components.localthings.registry.by_type import for_device_by_model
        reg = for_device_by_model('SOME-UNKNOWN-BOARD', 'SOME-UNKNOWN-BOARD')
@@ -208,3 +249,38 @@ class TestForDeviceByModel:
    def test_empty_inputs_return_none(self):
        from custom_components.localthings.registry.by_type import for_device_by_model
        assert for_device_by_model('', '') is None
+
+
+class TestForDeviceByResources:
+    def test_na9300k_without_one_ui_or_information_is_cooktop(self):
+        from custom_components.localthings.registry.by_type import for_device_by_resources
+        from tests.conftest import _load_device
+
+        reg = for_device_by_resources(_load_device('cooktop'))
+
+        assert reg is not None
+        assert reg.name == 'cooktop'
+
+    def test_unrelated_mode_options_are_not_cooktop(self):
+        from custom_components.localthings.registry.by_type import for_device_by_resources
+
+        resources = {
+            '/mode/vs/0': {
+                'x.com.samsung.da.options': [
+                    'DeviceType_SOME_OVEN',
+                    'UpperLamp_Off',
+                ],
+            },
+        }
+
+        assert for_device_by_resources(resources) is None
+
+    def test_hood_resource_signature(self):
+        from custom_components.localthings.registry.by_type import for_device_by_resources
+        resources = {
+            '/hood/fanspeed/vs/0': {},
+            '/hood/lamp/vs/0': {},
+        }
+        reg = for_device_by_resources(resources)
+        assert reg is not None
+        assert reg.name == 'range_hood'
@@ -0,0 +1,77 @@
+"""Tests for the read-only cooktop capability profile."""
+
+from custom_components.localthings.registry.adapter import flatten
+from custom_components.localthings.registry.by_type import cooktop
+from custom_components.localthings.registry.capabilities.cooktop import (
+    COOKTOP_MODE,
+)
+from custom_components.localthings.registry.discovery import discover
+from tests.conftest import _load_device
+
+
+def _state(resources):
+    bound = discover(
+        resources,
+        cooktop.REGISTRY.capabilities,
+        cooktop.REGISTRY.pattern_capabilities,
+    )
+    return flatten(bound, resources)
+
+
+def test_real_cooktop_fixture_has_expected_idle_state():
+    state = _state(_load_device('cooktop'))
+
+    assert state['power_state'] is True
+    assert state['any_burner_active'] is False
+    assert state['burner_0_state'] == 'Ready'
+    assert state['burner_5_state'] == 'Ready'
+    assert state['main_timer_state'] == 'Ready'
+    assert state['main_timer_current'] == 0
+    assert state['cloud_connected'] is True
+    assert state['paired_hood_connected'] is False
+    assert state['paired_hood_power'] is False
+    assert state['paired_hood_fan_speed'] == 0
+    assert state['paired_hood_light'] is False
+
+
+def test_run_operation_marks_any_burner_active():
+    resources = _load_device('cooktop')
+    options = resources['/mode/vs/0']['x.com.samsung.da.options']
+    options[options.index('OperationState3_Ready')] = 'OperationState3_Run'
+
+    state = _state(resources)
+
+    assert state['burner_3_state'] == 'Run'
+    assert state['any_burner_active'] is True
+
+
+def test_cooktop_profile_has_no_write_functions():
+    """A local integration must never expose unverified remote ignition."""
+    descriptions = [
+        desc
+        for capabilities in cooktop.REGISTRY.capabilities.values()
+        for capability in capabilities
+        for desc in capability.entities
+    ]
+
+    assert descriptions
+    assert all(not hasattr(desc, 'write_fn') or desc.write_fn is None
+               for desc in descriptions)
+
+
+def test_static_slot_superset_has_headroom_for_other_layouts():
+    keys = {desc.key for desc in COOKTOP_MODE.entities}
+
+    assert {f'burner_{slot}_state' for slot in range(8)} <= keys
+
+
+def test_variant_slot_outside_na9300k_layout_is_discovered():
+    resources = _load_device('cooktop')
+    resources['/mode/vs/0']['x.com.samsung.da.options'].append(
+        'OperationState7_Ready',
+    )
+
+    state = _state(resources)
+
+    assert state['burner_7_state'] == 'Ready'
+    assert 'burner_2_state' not in state
@@ -59,11 +59,17 @@ def test_power_watts_gated_for_dead_sentinel():


 def test_course_bound_to_shared_course_vs_0():
-    """Dryer course uses the shared /course/vs/0 cycle select with dryer_cycle
-    translations, consistent with washer/dishwasher."""
+    """Dryer course uses the shared /course/vs/0 cycle select, with the
+    translation key built from the device's own course table (see
+    laundry.cycle_select) -- confirmed dryers report Table_03, matching
+    the shipped dryer_cycle_table_03 translations, consistent with
+    washer/dishwasher."""
    assert dryer.DRYER_COURSE.href == '/course/vs/0'
    desc = next(e for e in dryer.DRYER_COURSE.entities if e.key == 'cycle')
-    assert desc.translation_key == 'dryer_cycle'
+    assert callable(desc.translation_key)
+    table_03 = {'/st/dryercourse/vs/0': {'x.com.samsung.da.st.courseTable': 'Table_03'}}
+    assert desc.translation_key(table_03) == 'dryer_cycle_table_03'
+    assert desc.translation_key({}) is None
    assert desc.options is laundry.cycle_options
    rep = {'x.com.samsung.da.options': ['Course_16', 'GMT_02']}
    assert desc.rep_fn(rep) == '16'
@@ -1,6 +1,6 @@
 from custom_components.localthings.registry.entities import (
    SensorDesc, BinarySensorDesc, SelectDesc, SwitchDesc, ButtonDesc,
-    NumberDesc, TimeDesc, ClimateDesc, PLATFORM_OF,
+    NumberDesc, TimeDesc, ClimateDesc, FanDesc, PLATFORM_OF,
 )


@@ -28,6 +28,7 @@ def test_platform_mapping_covers_all_subclasses():
    assert PLATFORM_OF[NumberDesc] == 'number'
    assert PLATFORM_OF[TimeDesc] == 'time'
    assert PLATFORM_OF[ClimateDesc] == 'climate'
+    assert PLATFORM_OF[FanDesc] == 'fan'


 def test_select_carries_options_and_write_fn():
@@ -7,7 +7,9 @@ GOLDEN = Path(__file__).parent / 'fixtures' / 'golden'


 def _new_state_keys(name, resources):
-    from custom_components.localthings.registry.by_type import for_device, for_device_by_model
+    from custom_components.localthings.registry.by_type import (
+        for_device, for_device_by_model, for_device_by_resources,
+    )
    from custom_components.localthings.registry.discovery import discover
    from custom_components.localthings.registry.adapter import flatten
    otn = resources.get('/otninformation/vs/0', {})
@@ -19,6 +21,8 @@ def _new_state_keys(name, resources):
            info.get('x.com.samsung.da.modelNum', ''),
            info.get('x.com.samsung.da.description', ''),
        )
+    if reg is None:
+        reg = for_device_by_resources(resources)
    if reg is None:
        from custom_components.localthings.registry.registry import CAPABILITIES
        caps, pats = CAPABILITIES, []
@@ -81,6 +85,18 @@ def test_registry_reproduces_golden_state_keys_for_airconditioner():
    )


+def test_registry_reproduces_golden_state_keys_for_cooktop():
+    from tests.conftest import _load_device
+    resources = _load_device('cooktop')
+    golden = json.loads((GOLDEN / 'cooktop.json').read_text())
+    state_keys = _new_state_keys('cooktop', resources)
+    assert set(state_keys) == set(golden['state_keys']), (
+        f"state_keys mismatch:\n"
+        f"  extra:   {sorted(set(state_keys) - set(golden['state_keys']))}\n"
+        f"  missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
+    )
+
+
 def test_registry_reproduces_golden_state_keys_for_tp1x_ref_21k_us():
    from tests.conftest import _load_device
    resources = _load_device('refrigerator_tp1x_ref_21k_us')
@@ -95,6 +111,18 @@ def test_registry_reproduces_golden_state_keys_for_tp1x_ref_21k_us():
    )


+def test_registry_reproduces_golden_state_keys_for_range_hood():
+    from tests.conftest import _load_device
+    resources = _load_device('range_hood')
+    golden = json.loads((GOLDEN / 'range_hood.json').read_text())
+    state_keys = _new_state_keys('range_hood', resources)
+    assert set(state_keys) == set(golden['state_keys']), (
+        f"state_keys mismatch:\n"
+        f"  extra:   {sorted(set(state_keys) - set(golden['state_keys']))}\n"
+        f"  missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
+    )
+
+
 def test_registry_reproduces_golden_state_keys_for_washer_flexwash():
    """FlexWash twin washers (WV-prefix consumer model, e.g. WV55M9600AW)
    report no oneUiVersion and previously fell through for_device_by_model's
@@ -185,6 +213,24 @@ def test_registry_reproduces_golden_state_keys_for_tp2x_rac_20k():
    )


+def test_registry_reproduces_golden_state_keys_for_caww_tp2():
+    """A-CAWW-TP2-20-COMMON (issue #52, System AC / multi-indoor-unit
+    commercial install) reports no oneUiVersion and no '_RAC_'/'_PRAC_'
+    token; resolved via the '-CAWW-' modelNum fallback in
+    for_device_by_model. Otherwise binds cleanly against the existing
+    airconditioner registry -- same TP1X/TP2X-class resource surface, plus
+    one SAC-only installation-topology resource (ignored)."""
+    from tests.conftest import _load_device
+    resources = _load_device('airconditioner_caww_tp2')
+    golden = json.loads((GOLDEN / 'airconditioner_caww_tp2.json').read_text())
+    state_keys = _new_state_keys('airconditioner_caww_tp2', resources)
+    assert set(state_keys) == set(golden['state_keys']), (
+        f"state_keys mismatch:\n"
+        f"  extra:   {sorted(set(state_keys) - set(golden['state_keys']))}\n"
+        f"  missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
+    )
+
+
 def test_registry_reproduces_golden_state_keys_for_tp1x_rac():
    """TP1X_DA-AC-RAC-01001_0000 (issue #38) -- fuller RAC board with display
    light, self-check, mute-once, and a current-limit setting."""
@@ -216,6 +262,38 @@ def test_registry_reproduces_golden_state_keys_for_range():
    )


+def test_registry_reproduces_golden_state_keys_for_air_purifier():
+    """ARTIK051_TVTL_18K (issue #56) -- reports no oneUiVersion; resolved via
+    the '_TVTL_' modelNum token fallback in for_device_by_model."""
+    from tests.conftest import _load_device
+    resources = _load_device('air_purifier')
+    golden = json.loads((GOLDEN / 'air_purifier.json').read_text())
+    state_keys = _new_state_keys('air_purifier', resources)
+    assert set(state_keys) == set(golden['state_keys']), (
+        f"state_keys mismatch:\n"
+        f"  extra:   {sorted(set(state_keys) - set(golden['state_keys']))}\n"
+        f"  missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
+    )
+
+
+def test_registry_reproduces_golden_state_keys_for_oven():
+    """Wall oven (model TP1X_DA-KS-OVEN-0107X, issue #55) -- reports no
+    oneUiVersion; resolved via the '-OVEN-' modelNum token fallback in
+    for_device_by_model, mirroring the '-RANGE-' fallback added for
+    issue #44. Before that fallback existed the device type came back
+    'unknown' and every href fell through to the global CAPABILITIES
+    registry instead of the oven family's own."""
+    from tests.conftest import _load_device
+    resources = _load_device('oven')
+    golden = json.loads((GOLDEN / 'oven.json').read_text())
+    state_keys = _new_state_keys('oven', resources)
+    assert set(state_keys) == set(golden['state_keys']), (
+        f"state_keys mismatch:\n"
+        f"  extra:   {sorted(set(state_keys) - set(golden['state_keys']))}\n"
+        f"  missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
+    )
+
+
 def test_resources_from_batch_preferred_over_flat():
    from tests.conftest import _resources_from_dump
    dump = {
@@ -35,6 +35,103 @@ class TestCourseHelpers:
        assert laundry.option_value(opts, 'Missing') is None


+class TestCourseCodesFromSupportedOptions:
+    """cycle_options()'s fallback for boards that populate
+    /wm/editcourse/vs/0 without ever filling in editCourseList itself
+    (issue #1) -- derives the course list from /course/vs/0's own
+    supportedOptions instead."""
+
+    # Real dump from issue #1 (DA_WM_TP1_21_COMMON, WW5000C): a 1-hex-nibble
+    # header followed by 14 self-indexed 7-byte-per-course records. '1C' (the
+    # first record) is confirmed as "Eco 40-60" both by this device's own
+    # currently-selected course matching the SmartThings app screenshot's
+    # checked item, and by six other independent devices' already-shipped
+    # translations agreeing on the same code -> name mapping.
+    _REAL_SUPPORTED_OPTIONS = (
+        '31C8410923FA67F1B847E923FA67F25843E933FA57F20857E943FA67F'
+        '088000913FA67F7485209204A5208780009000A00006841E930FA30F'
+        '7F841E920FA30F65841E943FA57F8F8102923FA57F96841E920FA37F'
+        '34841E923FA67FA0811E933FA33F'
+    )
+
+    def test_derives_codes_when_edit_course_list_is_empty(self):
+        resources = {
+            '/wm/editcourse/vs/0': {'x.com.samsung.da.editCourseList': ''},
+            '/course/vs/0': {
+                'x.com.samsung.da.options': ['Course_1C'],
+                'x.com.samsung.da.supportedOptions': [self._REAL_SUPPORTED_OPTIONS],
+            },
+        }
+        assert laundry.cycle_options(resources) == [
+            '1C', '1B', '25', '20', '08', '74', '87', '06',
+            '7F', '65', '8F', '96', '34', 'A0',
+        ]
+
+    def test_edit_course_list_still_takes_priority(self):
+        """A live editCourseList wins even with supportedOptions present --
+        no reason to prefer a derived list over the authoritative one."""
+        resources = {
+            '/wm/editcourse/vs/0': {'x.com.samsung.da.editCourseList': 'EditCourseList_651C'},
+            '/course/vs/0': {
+                'x.com.samsung.da.options': ['Course_1C'],
+                'x.com.samsung.da.supportedOptions': [self._REAL_SUPPORTED_OPTIONS],
+            },
+        }
+        assert laundry.cycle_options(resources) == ['65', '1C']
+
+    def test_rejects_a_table_missing_the_current_course(self):
+        """The device's own currently-selected course must be a member of
+        its derived list -- a mismatch means the guess is wrong, not that
+        the device selected something outside its own supported set."""
+        resources = {
+            '/course/vs/0': {
+                'x.com.samsung.da.options': ['Course_FF'],
+                'x.com.samsung.da.supportedOptions': [self._REAL_SUPPORTED_OPTIONS],
+            },
+        }
+        assert laundry.cycle_options(resources) == []
+
+    def test_smallest_passing_split_wins_over_its_own_multiples(self):
+        """K=2 and K=4 both trivially re-pass the same two checks here --
+        each is just a sparser sampling of the true, smaller K=1 table (its
+        first bytes are a subset of K=1's, so uniqueness and "contains the
+        current course" carry over for free) -- but K=1 is the real, most
+        specific table and must be the one returned."""
+        resources = {
+            '/course/vs/0': {
+                'x.com.samsung.da.options': ['Course_AA'],
+                'x.com.samsung.da.supportedOptions': ['0AABBCCDD'],
+            },
+        }
+        assert laundry.cycle_options(resources) == ['AA', 'BB', 'CC', 'DD']
+
+    def test_empty_without_supported_options_or_course_href(self):
+        assert laundry.cycle_options({}) == []
+        assert laundry.cycle_options({'/course/vs/0': {}}) == []
+
+    def test_smallest_wins_even_when_a_larger_pass_is_not_a_multiple(self):
+        """Real dishwasher dump (K=7, 10 courses): K=10, 14, and 35 also
+        pass both checks here, and none of them are multiples of 7 --
+        position 0 lands on the same real course code ('0e') regardless of
+        K, which alone satisfies the current-course guard for several
+        unrelated splits. Smallest-K-wins is a heuristic that matches every
+        real dump checked so far, not a proven guarantee -- see
+        _course_codes_from_supported_options's docstring."""
+        resources = {
+            '/course/vs/0': {
+                'x.com.samsung.da.options': ['Course_0E'],
+                'x.com.samsung.da.supportedOptions': [
+                    '30E5434B102D102835034B002D002845034B002D002805034B000D000'
+                    '865034B002D002075000B000D000905000B000D0008D5034B002D0028'
+                    'E5034B000D0008F5034B000D000'
+                ],
+            },
+        }
+        assert laundry.cycle_options(resources) == [
+            '0E', '83', '84', '80', '86', '07', '90', '8D', '8E', '8F',
+        ]
+
+
 class TestCycleSelect:
    def test_builds_labelled_cycle_select(self):
        desc = laundry.cycle_select(translation_key='dryer_cycle', icon='mdi:tumble-dryer')
@@ -70,6 +167,53 @@ class TestCycleSelect:
        assert desc.write_fn('1D', {}) is None


+class TestCycleSelectTableGating:
+    """translation_key becomes a resolver, not a plain string, once
+    table_href is given -- washer/dryer's real call sites (issue: course
+    codes aren't guaranteed consistent across board generations sharing
+    the same /course/vs/0 contract; FlexWash's older board reports a
+    different course table than every device the shipped translations
+    were confirmed against). The resolved key is built from whatever table
+    the device actually reports -- a table with no strings.json entries
+    yet just falls through Home Assistant's own missing-translation
+    handling to raw-code display, the same as any individual untranslated
+    code within an existing table."""
+
+    def _desc(self):
+        return laundry.cycle_select(
+            translation_key='washer_cycle', icon='x',
+            table_href='/st/washercourse/vs/0',
+        )
+
+    def test_static_string_when_no_table_href_given(self):
+        """dishwasher's call site -- no equivalent table-id resource in any
+        dump seen, no evidence of the same cross-board risk -- keeps the
+        plain static key unconditionally."""
+        desc = laundry.cycle_select(translation_key='dishwasher_cycle', icon='x')
+        assert desc.translation_key == 'dishwasher_cycle'
+
+    def test_resolved_key_is_built_from_the_reported_table(self):
+        desc = self._desc()
+        resources = {'/st/washercourse/vs/0': {'x.com.samsung.da.st.courseTable': 'Table_02'}}
+        assert callable(desc.translation_key)
+        assert desc.translation_key(resources) == 'washer_cycle_table_02'
+
+    def test_resolved_key_reflects_an_unbuilt_table_too(self):
+        """No gating against a hardcoded 'known good' table -- a table we
+        haven't shipped translations for yet still gets a key built for
+        it, just one strings.json has nothing under (raw-code display)."""
+        desc = self._desc()
+        resources = {'/st/washercourse/vs/0': {'x.com.samsung.da.st.courseTable': 'Table_00'}}
+        assert desc.translation_key(resources) == 'washer_cycle_table_00'
+
+    def test_resolves_to_none_when_table_id_is_unknown(self):
+        """No href, or an empty rep, gets no translation_key at all --
+        there's nothing to build a key from."""
+        desc = self._desc()
+        assert desc.translation_key({}) is None
+        assert desc.translation_key({'/st/washercourse/vs/0': {}}) is None
+
+
 class TestBuzzerSound:
    def test_href(self):
        assert laundry.BUZZER_SOUND.href == '/buzzersound/vs/0'
@@ -1,8 +1,30 @@
 """Unit tests for oven-family capabilities."""
+from custom_components.localthings.registry.by_type import for_device_by_model
 from custom_components.localthings.registry.capabilities import oven
 from custom_components.localthings.registry.discovery import discover


+# ---------------------------------------------------------------------------
+# Device-type detection + full-dump coverage (issue #55)
+# ---------------------------------------------------------------------------
+
+def test_oven_fixture_resolves_and_has_no_unbound_hrefs():
+    """The issue #55 dump previously came back device_type='unknown' with
+    /connected/vs/0 unbound -- resolving via the '-OVEN-' modelNum token
+    fallback must leave every href in the oven registry bound or ignored."""
+    from tests.conftest import _load_device
+    resources = _load_device('oven')
+    info = resources['/information/vs/0']
+    reg = for_device_by_model(
+        info['x.com.samsung.da.modelNum'], info['x.com.samsung.da.description'])
+    assert reg is not None
+    assert reg.name == 'oven'
+
+    unbound = []
+    discover(resources, reg.capabilities, reg.pattern_capabilities, log=unbound.append)
+    assert unbound == []
+
+
 # ---------------------------------------------------------------------------
 # OVEN_SETPOINT — NumberDesc with RMW write semantics
 # ---------------------------------------------------------------------------
@@ -0,0 +1,116 @@
+"""Tests for the AHD-WW-TP1-22 range-hood profile."""
+
+from custom_components.localthings.registry.adapter import flatten
+from custom_components.localthings.registry.by_type import for_device_by_model
+from custom_components.localthings.registry.capabilities import range_hood
+from custom_components.localthings.registry.discovery import discover
+from custom_components.localthings.registry.entities import FanDesc
+from tests.conftest import _load_device
+
+
+def _hood():
+    resources = _load_device('range_hood')
+    info = resources['/information/vs/0']
+    registry = for_device_by_model(
+        info['x.com.samsung.da.modelNum'],
+        info['x.com.samsung.da.description'],
+    )
+    return registry, resources
+
+
+def _state():
+    registry, resources = _hood()
+    bound = discover(
+        resources, registry.capabilities, registry.pattern_capabilities,
+    )
+    return flatten(bound, resources)
+
+
+def test_ahd_model_resolves_to_range_hood_registry():
+    registry, _ = _hood()
+    assert registry is not None
+    assert registry.name == 'range_hood'
+
+
+def test_range_hood_has_no_unbound_hrefs():
+    registry, resources = _hood()
+    unbound = []
+    discover(
+        resources,
+        registry.capabilities,
+        registry.pattern_capabilities,
+        log=unbound.append,
+    )
+    assert unbound == []
+
+
+def test_range_hood_fixture_values():
+    state = _state()
+    assert state['fan'] == '14'
+    assert state['alarm_code'] == 'none'
+    assert state['automatic_operation'] is False
+    assert state['lamp'] is False
+    assert state['lamp_brightness'] == '2'
+    assert state['hood_filter_usage'] == 100
+    assert state['hood_filter_status'] == 'wash'
+    assert state['energy_kwh'] == 165.62
+    assert state['clean_level'] == 2
+    assert state['dust'] == 18
+    assert state['fine_dust'] == 14
+    assert state['super_fine_dust'] == 9
+    assert state['periodic_air_sensing'] is False
+    assert state['air_sensing_state'] == 'NonProcessing'
+    assert state['last_air_sensing_level'] == 'Kr2'
+
+
+def test_one_composite_fan_is_bound():
+    registry, resources = _hood()
+    bound = discover(
+        resources, registry.capabilities, registry.pattern_capabilities,
+    )
+    fans = [entity for entity in bound if isinstance(entity.desc, FanDesc)]
+    assert len(fans) == 1
+    assert fans[0].href == '/hood/fanspeed/vs/0'
+
+
+def test_fan_write_contract():
+    desc = range_hood.HOOD_FAN.entities[0]
+    rep = {
+        'x.com.samsung.da.hood.supportedFanSpeed': ['14', '15', '16', '17'],
+    }
+    assert desc.write_fn(('power', True), rep) == (
+        ['power', '0'], {'value': True},
+    )
+    assert desc.write_fn(('power', False), rep) == (
+        ['power', '0'], {'value': False},
+    )
+    assert desc.write_fn(('power', True, '/power/vs/0'), rep) == (
+        ['power', 'vs', '0'], {'x.com.samsung.da.power': 'On'},
+    )
+    assert desc.write_fn(('power', False, '/power/vs/0'), rep) == (
+        ['power', 'vs', '0'], {'x.com.samsung.da.power': 'Off'},
+    )
+    assert desc.write_fn(('power', True, '/not-a-power-resource'), rep) is None
+    assert desc.write_fn(('speed', '16'), rep) == (
+        ['hood', 'fanspeed', 'vs', '0'],
+        {'x.com.samsung.da.hood.fanSpeed': '16'},
+    )
+    assert desc.write_fn(('speed', '99'), rep) is None
+
+
+def test_lamp_write_contract():
+    lamp, brightness = range_hood.HOOD_LAMP.entities
+    rep = {'x.com.samsung.lamp.range': ['1', '2']}
+    assert lamp.write_fn('On', rep) == (
+        ['hood', 'lamp', 'vs', '0'], {'x.com.samsung.lamp.power': 'On'},
+    )
+    assert lamp.write_fn('Off', rep) == (
+        ['hood', 'lamp', 'vs', '0'], {'x.com.samsung.lamp.power': 'Off'},
+    )
+    assert brightness.write_fn('1', rep) == (
+        ['hood', 'lamp', 'vs', '0'], {'x.com.samsung.lamp.current': '1'},
+    )
+    assert brightness.write_fn('2', rep) == (
+        ['hood', 'lamp', 'vs', '0'], {'x.com.samsung.lamp.current': '2'},
+    )
+    assert brightness.write_fn('Unsupported', rep) is None
@@ -0,0 +1,88 @@
+"""HA fan-entity mapping tests for the range hood."""
+
+from custom_components.localthings.fan import LocalThingsRangeHoodFan
+from custom_components.localthings.registry.by_type import range_hood
+from custom_components.localthings.registry.discovery import discover
+from custom_components.localthings.registry.entities import FanDesc
+from tests.conftest import _load_device
+
+
+class _FakeCoordinator:
+    device_serial = 'TEST-HOOD-SERIAL'
+    device_info = {}
+    data = {}
+
+    def __init__(self, resources):
+        self.last_resources = resources
+        self.commands = []
+
+    def resource(self, href):
+        return self.last_resources.get(href, {})
+
+    async def async_send_command(self, bound, payload):
+        self.commands.append((bound, payload))
+
+
+def _entity(resources, coordinator=None):
+    bound = discover(
+        resources,
+        range_hood.REGISTRY.capabilities,
+        range_hood.REGISTRY.pattern_capabilities,
+    )
+    fan_bound = next(item for item in bound if isinstance(item.desc, FanDesc))
+    return LocalThingsRangeHoodFan(
+        coordinator or _FakeCoordinator(resources), fan_bound,
+    )
+
+
+def test_power_off_maps_to_zero_percent_and_four_retained_speeds():
+    entity = _entity(_load_device('range_hood'))
+    assert entity.is_on is False
+    assert entity.speed_count == 4
+    assert entity.percentage == 0
+
+
+def test_active_codes_map_to_ordered_percentages():
+    resources = _load_device('range_hood')
+    resources['/power/0']['value'] = True
+
+    resources['/hood/fanspeed/vs/0'][
+        'x.com.samsung.da.hood.fanSpeed'
+    ] = '14'
+    assert _entity(resources).percentage == 25
+
+    resources['/hood/fanspeed/vs/0'][
+        'x.com.samsung.da.hood.fanSpeed'
+    ] = '15'
+    assert _entity(resources).percentage == 50
+
+    resources['/hood/fanspeed/vs/0'][
+        'x.com.samsung.da.hood.fanSpeed'
+    ] = '16'
+    assert _entity(resources).percentage == 75
+
+    resources['/hood/fanspeed/vs/0'][
+        'x.com.samsung.da.hood.fanSpeed'
+    ] = '17'
+    assert _entity(resources).percentage == 100
+
+
+async def test_power_write_prefers_standard_resource_when_both_exist():
+    resources = _load_device('range_hood')
+    coordinator = _FakeCoordinator(resources)
+    entity = _entity(resources, coordinator)
+
+    await entity.async_turn_on()
+
+    assert coordinator.commands[-1][1] == ('power', True, '/power/0')
+
+
+async def test_power_write_falls_back_to_vendor_resource():
+    resources = _load_device('range_hood')
+    resources.pop('/power/0')
+    coordinator = _FakeCoordinator(resources)
+    entity = _entity(resources, coordinator)
+
+    await entity.async_turn_off()
+
+    assert coordinator.commands[-1][1] == ('power', False, '/power/vs/0')
@@ -1,9 +1,8 @@
 """Tests for select-option display casing (custom_components/localthings/select.py)."""
-from custom_components.localthings.registry.entities import SelectDesc
 from custom_components.localthings.select import _display

-_UNTRANSLATED = SelectDesc(key='x', options=())
-_TRANSLATED = SelectDesc(key='y', options=(), translation_key='door_alert')
+_UNTRANSLATED = None
+_TRANSLATED = 'door_alert'


 def test_display_titlecases_a_fully_lowercase_device_native_token():
@@ -57,3 +57,20 @@ def test_callable_options_empty_result():
    desc = SelectDesc(key='cycle', options=lambda resources: [])
    entity = _make_select(desc, '/x/vs/0', {})
    assert entity.options == []
+
+
+def test_callable_translation_key_reresolves_live_not_once_at_construction():
+    """A callable translation_key (laundry.cycle_select's table-id-gated
+    resolver) must be re-evaluated against current coordinator data on
+    every access, not baked in once at __init__ -- discovery can run while
+    a sibling resource (e.g. /st/washercourse/vs/0) is still an empty stub
+    (see entity.py's _is_included docstring), and a one-time resolution
+    would permanently show untranslated codes even after a later poll
+    populates the real value."""
+    desc = SelectDesc(key='cycle', translation_key=lambda resources: resources.get('key'))
+    resources = {'key': None}
+    entity = _make_select(desc, '/x/vs/0', resources)
+    assert entity.translation_key is None
+
+    resources['key'] = 'washer_cycle_table_02'
+    assert entity.translation_key == 'washer_cycle_table_02'
@@ -61,8 +61,19 @@ class TestWasherCourse:
        assert washer.WASHER_COURSE.href == '/course/vs/0'

    def test_translation_key(self):
+        """Table-scoped (issue: course codes aren't guaranteed consistent
+        across board generations sharing /course/vs/0 -- FlexWash's older
+        board reports Table_00, not the Table_02 every washer_cycle_table_02
+        name was confirmed against) -- see laundry.cycle_select. The key is
+        built from whatever table the device reports, not gated against a
+        hardcoded 'known good' value."""
        desc = next(e for e in washer.WASHER_COURSE.entities if e.key == 'cycle')
-        assert desc.translation_key == 'washer_cycle'
+        assert callable(desc.translation_key)
+        table_02 = {'/st/washercourse/vs/0': {'x.com.samsung.da.st.courseTable': 'Table_02'}}
+        assert desc.translation_key(table_02) == 'washer_cycle_table_02'
+        table_00 = {'/st/washercourse/vs/0': {'x.com.samsung.da.st.courseTable': 'Table_00'}}
+        assert desc.translation_key(table_00) == 'washer_cycle_table_00'
+        assert desc.translation_key({}) is None

    def test_reads_raw_course_code_from_options_array(self):
        """rep_fn returns the raw device code; display names come from
Author	SHA1	Message	Date
Marc Billow	3b3dd54372	Simplify table-scoped translation key; fix stale resolution; correct docstring Simplification (feedback: this was overcomplicated): drop the validated_table gate entirely. cycle_select's table_href now just builds the translation key directly from whatever course table the device reports (washer_cycle + Table_02 -> washer_cycle_table_02) instead of comparing against a hardcoded known-good value and falling back to no key on any mismatch. A table we haven't shipped translations for yet (e.g. FlexWash's Table_00) still gets a key built for it -- Home Assistant's own missing-translation handling takes it from there, the same graceful fallback already relied on for any individual untranslated code within an existing table. Adding a newly-confirmed table later is just new strings.json entries, no code change. Independent (Opus) review of the prior version caught two real issues, fixed here regardless of the simplification above: - translation_key was resolved once at entity construction from whatever coordinator.last_resources held at that moment. Discovery can run while a sibling resource is still an empty stub (documented precedent: see _is_included), so a callable translation_key could permanently bake in a stale value for the entity's lifetime. Moved resolution into a translation_key property override (Entity.translation_key is a property upstream, not a plain attribute), re-evaluated against live coordinator data on every access, matching how options/current_option already work. - The supportedOptions fallback's "smallest passing K wins" docstring claimed every larger passing K is an exact multiple of the true one. False: the shipped dishwasher fixture has passing K=7 (true) alongside 10, 14, and 35, none of which are multiples of 7 -- position 0 always lands on the same real course code regardless of K, which alone satisfies the current-course guard for several unrelated splits. Corrected the reasoning to what's actually true (an empirically-matched heuristic across six real dumps, not a proof) and added a regression test locking in the real dishwasher case so this isn't silently lost.	2026-07-24 05:55:04 +00:00
Marc Billow	b2c32a90b6	Scope washer/dryer cycle translations to the device's own course table Course codes on the shared /course/vs/0 contract aren't guaranteed consistent across board generations: washer/combo devices report course table Table_02, dryer devices Table_03 (x.com.samsung.da.st.courseTable, previously fully ignored), and every code in washer_cycle/dryer_cycle was confirmed exclusively against those. FlexWash's older DA_WM_A51 board reports Table_00 instead -- applying the same translations there risked showing a wrong name for any code that happens to numerically collide between tables, not just an untranslated one. SelectDesc.translation_key can now be a callable (resources -> key or None), mirroring the existing pattern for `options`. laundry.cycle_select gains optional table_href/validated_table params: when given, the renamed washer_cycle_table_02/dryer_cycle_table_03 keys only apply when the device's own course table matches exactly -- a different table, or no table id at all, gets no translation_key (raw code display) rather than a guess. dishwasher's call site is unchanged (static key, unconditional): no equivalent table-id resource exists in any dump seen, and no evidence its course codes vary by table the way washer/dryer's do. entity.py and select.py resolve a callable translation_key once (via coordinator.last_resources) and reuse that resolved value everywhere _display() needs it, rather than re-checking the raw descriptor field.	2026-07-24 05:42:12 +00:00
Marc Billow	b2c0517115	feat: derive washer/dryer/dishwasher cycle list from supportedOptions when editCourseList is empty Some DA_WM_TP1/TP2-class boards populate /wm/editcourse/vs/0 without ever filling in editCourseList itself (issue #1), so the Cycle select never gets created even though the device clearly has one (confirmed via SmartThings app screenshots and a currently-selected course). /course/vs/0's own x.com.samsung.da.supportedOptions turns out to already carry the course list, just undocumented: a 1-hex-nibble header followed by one fixed-width record per course, self-indexed by a course-code first byte rather than positional like editCourseList. Confirmed against six independent real-world dumps pulled from open and closed GitHub issues. cycle_options() now falls back to deriving this when editCourseList is empty, gated on two checks: the derived codes must all be distinct, and must include whatever course is currently selected. Larger multiples of the true record width trivially re-pass both checks too (they're just a sparser sampling of the same table), so the smallest passing width wins rather than requiring one unambiguous match. Also fires on the washer_flexwash fixture, newly creating a Cycle select there -- unconfirmed against any ground truth for that device (a different, older board generation with no editCourseList and no screenshots to check against), flagged for follow-up discussion rather than silently accepted.	2026-07-24 05:06:39 +00:00
Marc Billow	ed768d7257	Merge pull request #62 from mbillow/claude/issue-52-quick-fix Recognize A-CAWW-TP2-20-COMMON system air conditioners (issue #52)	2026-07-23 23:08:32 -05:00
Marc Billow	efe87381b7	Bump version to 0.11.1	2026-07-24 04:06:31 +00:00
Marc Billow	8e25e6dc71	Recognize A-CAWW-TP2-20-COMMON system air conditioners (issue #52 ) New '-CAWW-' modelNum token for multi-indoor-unit commercial AC installs -- these report no oneUiVersion, same as the other RAC/PRAC boards. Once routed to the existing airconditioner registry, every resource in the reporter's dump already binds except one new SAC-specific installation-topology blob, now ignored.	2026-07-24 04:06:31 +00:00
Marc Billow	60f8fdf488	Merge pull request #61 from mbillow/claude/issue-9-optimistic-write-debug-k4fjdb feat: add options flow to bypass the remote-control write block per device (issue #54)	2026-07-23 22:40:51 -05:00
Marc Billow	dccd6e1209	fix: correct backwards options-flow description wording The bypass toggle is off by default and turned ON to allow writes with remote control reported off, but the description said "only turn this off if..." -- backwards from the actual control. Caught in Opus review.	2026-07-24 03:38:10 +00:00
Marc Billow	037dc9722f	feat: add options flow to bypass the remote-control write block per device (issue #54 ) The remote-control-off write block was device-wide and unconditional: whenever a device reports remote control off, every write is rejected with a user-facing error, on the assumption the device would reject it anyway. Issue #54 reports a washer where that assumption doesn't hold -- default detergent/softener dosing writes through even with remote control off, since they apply to the built-in programs too, not just a custom remote-controlled cycle. Add a per-device options flow (Settings > Devices & Services > this device > Configure) with a single toggle, stored in entry.options (not entry.data) so it doesn't affect the device's identity/unique_id. coordinator.async_send_command reads it ahead of the existing remote_control_enabled() check; defaults to False everywhere, so devices that don't touch this option see no change in behavior.	2026-07-24 03:32:49 +00:00
Marc Billow	dffe1ef455	Merge pull request #60 from mbillow/claude/issue-9-optimistic-write-debug-k4fjdb fix: settle-window fixes for slow-settling, shared-href writes (issue #9)	2026-07-23 22:24:03 -05:00
Marc Billow	49bd4ef0cb	Bump version to 0.11.0	2026-07-24 03:22:59 +00:00
Marc Billow	f7faf56689	Bump version to 0.10.2	2026-07-24 03:21:16 +00:00
Marc Billow	85cca70b6b	fix: don't let an in-progress settle window block a second write's own optimistic apply Widening the settle window to tens of seconds (previous commit) made a real gap much more likely to bite: apply() gated every source, including 'optimistic', on _is_settling. /course/vs/0 backs several independent washer selects (cycle, detergent quantity, softener quantity, ...), so picking a second one while the first write's window was still open -- routine within a ~43s window -- had its own optimistic value silently dropped from the cache instead of shown, recreating the exact "write doesn't seem to apply" symptom the guard exists to prevent, just for whichever write lost the race. Let source='optimistic' always bypass the gate; poll/sweep/observe stay gated as before. mark_write_pending still re-arms the window right after, so the newer write is protected going forward.	2026-07-24 03:14:58 +00:00
Marc Billow	020402c82f	fix: size the write-settle window to outlast a slow-settling device (issue #9 ) async_send_command's settle guard used DEFAULT_SETTLE_S's fixed few seconds, which is long enough for fields that update instantly on the device but not for ones that visibly take a few seconds of internal validation or hardware movement to catch up. Issue #9's washer packs cycle/detergent/softener selection into /course/vs/0's shared options[] array, and that settling time regularly outlasted the fixed window -- same device, same integration, but /washer/vs/0's temperature/spin fields (plain flags) confirmed instantly while these didn't. The short window expired before the confirm poll (or the device itself) caught up, so a stale read landed unprotected and reverted the optimistic value, only to self-correct again once a later poll saw the real change -- reading to the user as the write reverting and then reapplying itself a few seconds later. Size the window to always outlast the PUT and the confirming refresh's poll combined, as issues #17/#53 also needed, but without that fix's early-release mechanism (reverted previously for its own races around overlapping writes) -- just hold the guard for the full window and let it expire on its own.	2026-07-24 03:07:37 +00:00
Marc Billow	cf18cc3ecc	Merge pull request #59 from mbillow/claude/device-support-issue-56-shy2vg Add Samsung air purifier support (ARTIK051_TVTL-class, issue #56)	2026-07-23 18:50:06 -05:00
Marc Billow	61e6035a36	Merge pull request #58 from mbillow/claude/climate-state-freshness-s5v2bk fix: apply optimistic writes to their actual target href, not the bound href (issues #17, #53)	2026-07-23 18:47:48 -05:00
Marc Billow	7b155aabc2	Merge remote-tracking branch 'origin/main' into claude/device-support-issue-56-shy2vg # Conflicts: # tests/test_golden_regression.py	2026-07-23 23:47:42 +00:00
Marc Billow	788b8f98a1	Merge pull request #57 from mbillow/claude/issue-55-triage-db1omk Fix wall oven device-type detection (issue #55)	2026-07-23 18:44:57 -05:00
Marc Billow	83bd158049	fix: apply the optimistic write to its actual target href, not the bound href (issues #17 , #53 ) An independent review turned up the real bug behind the climate lag: async_send_command applied the optimistic value and settle guard to bound_entity.href, but write_fn's path_segs -- the resource actually POSTed to -- can point somewhere else entirely. The AC's composite climate entity is bound to /mode/vs/0, yet a power/temperature/fan/ swing/preset command writes to its own sibling resource (/power/0, /temperature/desired/0, ...), which is also what climate.py reads the displayed state from. The optimistic value landed on /mode/vs/0 instead, so the resource the entity actually shows stayed stale until the next unrelated read of it -- surviving the earlier optimistic-apply fix (issue #27), which applied to the same wrong href. Derive the write's target from path_segs and apply/guard/log against that instead. Reverts the previous commit's settle-window-sizing change on this branch: that was chasing a real but speculative edge case (a confirm poll slower than the settle window) that a follow-up review couldn't confirm matches the reported symptom, and its early-release mechanism had its own races (a debounced refresh that hadn't actually run yet, overlapping writes to the same href) for marginal benefit once this fix lands. Simpler to drop it than carry that risk for a case not in evidence. Added a coordinator-level regression test against the real AC CLIMATE capability (not just a synthetic mismatched-path descriptor) sending a power command and asserting the optimistic value lands on /power/0, not /mode/vs/0.	2026-07-23 22:42:04 +00:00
Marc Billow	618443db7b	Use generic names for shared start/stop/pause entities The /operational/state/vs/0 href (and its start/pause/stop buttons and "cycle active" sensor) is shared across the dryer/dishwasher/oven/washer families, but the entity names hardcoded laundry vocabulary ("Start cycle", "Cycle active") that doesn't fit an oven's bake/roast session. Rename to generic "Start"/"Pause"/"Stop"/"Running". Also fold oven.py's duplicate stop button into a single STOP_BUTTON constant in operational.py -- both wrote the identical state='Ready' RMW, so there was no reason for two copies to maintain.	2026-07-23 22:38:48 +00:00
Marc Billow	3ed277a33b	Fix wall oven device-type detection (issue #55 ) Ovens with modelNum like TP1X_DA-KS-OVEN-0107X report no oneUiVersion and don't match any consumer-prefix or other fallback token in for_device_by_model, so the device came back as "unknown" and every resource fell through to the global capability registry instead of oven.py's own -- explaining the unbound /connected/vs/0 href, the unrelated-looking entities, and the non-functional controls reported in the issue. Add a '-OVEN-' modelNum token fallback, mirroring the existing '-RANGE-' fallback from issue #44.	2026-07-23 22:38:44 +00:00
Marc Billow	42a80fffe6	Simplify air purifier support by reusing existing helpers Rewires /mode/vs/0's packed-options parsing (display_light/operating_mode/ blooming_level) onto laundry.py's existing option_value/replace_in_options/ bool_option_exists/bool_option_value instead of hand-rolled reimplementations, hoists the duplicated int-conversion helper into common.py (shared by range_hood.py too), collapses the five near-identical AIR_QUALITY sensors into a table-driven loop, extracts the /consumable/vs/0 item lookup into a named helper, and moves the humidity ignore list into capabilities/ air_purifier.py's own COVERAGE list to match the airconditioner/range_hood convention of keeping by_type files as pure composition. No behavior change; golden state keys and all existing tests are unaffected.	2026-07-23 22:36:47 +00:00
Marc Billow	b121d24966	Add Samsung air purifier support (ARTIK051_TVTL-class, issue #56 ) Adds a by_type registry for the AX60R5080WD/SE air purifier family, verified against two independent diagnostics dumps (issue #56 and its comment). Binds power, alarms, energy, diagnosis (reusing dishwasher.DIAGNOSIS), the dust/ fine-dust/super-fine-dust/odor/clean-level sensors off /sensors/vs/0, filter progress, a device-active diagnostic, and a display-light switch parsed out of /mode/vs/0's packed options list. Fan speed/direction (/airflow/0, /airflow/vs/0) and two other /mode/vs/0 tokens (Comode_, Blooming_) are exposed as read-only diagnostics rather than full controls -- neither dump has a supported-values list to confirm their write contracts, so they're left for a follow-up once that's clarified in the issue thread. Hoists range_hood's items[]-sensor-value helper into common.py (sensor_item_value) since air_purifier now reads the same /sensors/vs/0 shape.	2026-07-23 22:12:15 +00:00
Marc Billow	615c5d5aa9	fix: size the write-settle window to outlast its own confirm poll (issues #17 , #53 ) mark_write_pending's window was a fixed few seconds, started before the PUT and the confirming /device/0 refresh that follows it -- but that refresh is a full summary poll, which can legitimately take far longer than that on these AC devices. The window routinely expired while the confirm poll was still in flight, so a stale read (the device's own resource tree hadn't caught up to the instant physical change yet) landed unprotected and reverted the optimistic write, with nothing to correct it again until the next scheduled summary poll. That's the 20-60s lag both issues report even after the earlier optimistic-apply fix. Size the window to cover the PUT and confirm-poll timeouts combined, and release it as soon as that round trip actually completes (success or failure) instead of leaving it open for the rest of a now much longer window.	2026-07-23 22:11:26 +00:00
Marc Billow	30e814f242	Merge pull request #23 from themaanda/contrib/cooktop-range-hood Add cooktop and range hood support	2026-07-22 22:41:10 -05:00
Marc Billow	13f1214790	Merge branch 'main' into contrib/cooktop-range-hood	2026-07-22 22:39:19 -05:00
Marc Billow	4d21f3b8f2	Merge pull request #51 from mbillow/claude/release-notes-version-bump-1obhfb Bump version to 0.10.1	2026-07-22 22:31:42 -05:00
themaanda	f7db568a43	Merge remote-tracking branch 'upstream/main' into contrib/cooktop-range-hood # Conflicts: # custom_components/localthings/coordinator.py # custom_components/localthings/registry/by_type/__init__.py	2026-07-22 21:59:23 -05:00
themaanda	62caf769f2	Address cooktop and range hood review	2026-07-22 21:54:01 -05:00
themaanda	e7daa21931	Merge remote-tracking branch 'upstream/main' into contrib/cooktop-range-hood # Conflicts: # README.md # custom_components/localthings/registry/by_type/__init__.py # tests/test_by_type.py # tests/test_golden_regression.py	2026-07-22 21:53:45 -05:00
themaanda	c64f58aaa5	Add cooktop and range hood support	2026-07-21 16:57:45 -05:00