Merge pull request #29 from mbillow/claude/bump-version-0.7.0

chore: bump version to 0.7.0

.claude/skills/adding-device-support/SKILL.md

@@ -0,0 +1,161 @@
+---
+name: adding-device-support
+description: >-
+  Add or extend support for a Samsung OCF appliance in localthings from a
+  /device/0 diagnostics dump. Use when a device-support issue lands, a device
+  raises the "incomplete capability coverage" repair, a diagnostics JSON needs
+  triaging, or you're mapping OCF resources to HA entities. Covers reading dumps,
+  OCF-standard vs vendor hrefs, the diagnostic/config/normal entity taxonomy,
+  ensuring every href is bound or ignored, and locking it in with a fixture +
+  golden + test.
+---
+
+# Adding device support
+
+localthings maps a Samsung appliance's OCF resources (`/device/0` dump) to Home
+Assistant entities. Each resource `href` is handled by a `Capability` that
+declares the entities it produces. This skill is the workflow for turning a new
+dump into coverage.
+
+## 1. Get the dump and see the gaps
+
+A user's diagnostics download (`config_entry-localthings-*.json`) has, under
+`data`:
+- `resources`: `{href: rep}` — the parsed `/device/0` snapshot. **This is the
+  source of truth**, not code comments.
+- `unbound_hrefs`: resources that bound to no capability. The
+  "incomplete capability coverage" repair fires whenever this is **non-empty or
+  the device type is unrecognized** (`coordinator._update_coverage_gap_issue`).
+
+Goal: make `unbound_hrefs` empty by **binding** the useful resources and
+**ignoring** the noise — and surface every genuinely useful sensor/select/switch
+along the way.
+
+## 2. Compute coverage without Home Assistant
+
+The `registry/` package is HA-free, so you can drive discovery directly (HA
+isn't importable standalone because `localthings/__init__.py` pulls it in — stub
+the package to skip that):
+
+```python
+import sys, types, json, importlib
+cc = types.ModuleType('custom_components'); cc.__path__=['custom_components']; sys.modules['custom_components']=cc
+lt = types.ModuleType('custom_components.localthings'); lt.__path__=['custom_components/localthings']; sys.modules['custom_components.localthings']=lt
+by_type   = importlib.import_module('custom_components.localthings.registry.by_type')
+discovery = importlib.import_module('custom_components.localthings.registry.discovery')
+adapter   = importlib.import_module('custom_components.localthings.registry.adapter')
+
+resources = json.load(open('dump.json'))['data']['resources']
+info = resources['/information/vs/0']
+reg = by_type.for_device_by_model(info['x.com.samsung.da.modelNum'], info['x.com.samsung.da.description'])
+# or: by_type.for_device(one_ui_version)  when /otninformation has swVersionInfo.oneUiVersion
+unbound = []
+bound = discovery.discover(resources, reg.capabilities, reg.pattern_capabilities, log=unbound.append)
+state = adapter.flatten(bound, resources)   # {entity_key: value}
+print('registry:', reg.name, 'unbound:', sorted(unbound))
+print('state_keys:', sorted(state))
+```
+
+`discover()` binds caps (applies `rt_filter`/`match_fn`); `flatten()` applies
+`exists_fn` and produces the final entity values. Use the same routine to
+regenerate a golden.
+
+## 3. OCF-standard vs vendor hrefs (`/x/0` vs `/x/vs/0`)
+
+Samsung appliances run RT-OCF and often expose the **same state twice**:
+- `/x/vs/0` — **vendor** resource, `x.com.samsung.da.*` fields.
+- `/x/0` — **standard OCF** resource type (`oic.r.*`) with OCF's fixed field
+  names. Confirmable against the OCF spec: `/power/0` `{value: bool}` is
+  `oic.r.switch.binary`; `/operational/state/0` is `oic.r.operational.state`.
+
+Newer firmware advertises both as Samsung migrates onto the OCF standard. **There
+is no single "always prefer vs / always prefer non-vs" rule** — decide per
+resource from the populated dump:
+- **Both populated, same state** (power, kids-lock, remote): prefer the
+  OCF-standard `/x/0`; fall back to `/x/vs/0` when `/x/0` is absent. Encode with
+  a `match_fn` presence check — see `common.POWER_GENERIC` / `POWER_VS_FALLBACK`.
+- **Only vendor populated** (`/energy/consumption/0` is often empty `{}`): use
+  `/x/vs/0`.
+- **Vendor is a superset** (`/operational/state/vs/0` adds fields the OCF one
+  lacks): build on the vendor resource, ignore the OCF subset.
+
+Course/cycle is **not** an OCF question — there's no standard course resource, so
+`/course/vs/0` (and the `/st/*course/vs/0` re-encoding) are both vendor.
+
+## 4. Entity taxonomy — the judgement call
+
+For each field worth exposing, decide the entity kind and category
+(`entity_category` on the descriptor):
+- **Normal / primary** (no `entity_category`): the things a user acts on or
+  watches — power switch, machine state, the cycle select, energy sensors.
+- **`config`**: user-tunable settings — sound mode, door LED, wash temperature,
+  buzzer. Shown under the device's Configuration section.
+- **`diagnostic`**: read-only status/troubleshooting — alarms, diagnosis, job
+  beginning status, last-operation source.
+
+Also set `poll_tier` (`hot`/`warm`/`cold`) on the capability for how often it's
+sub-polled between summary polls. Pick descriptor types from `entities.py`
+(`SensorDesc`, `SelectDesc`, `SwitchDesc`, `NumberDesc`, `BinarySensorDesc`,
+`TimeDesc`, `ButtonDesc`) — the class selects the HA platform.
+
+**Don't guess.** If a field's meaning or write contract is unclear from the dump
+(opaque encoded blobs, no supported-values list), leave it unbound so it surfaces
+as a gap for a human, or ignore it with a documented reason — never invent an
+entity on a hunch (`ignored.py`'s rule).
+
+## 5. Enum selects need translation support
+
+Any select whose options are raw device codes (course/cycle, and code-valued
+settings) must render through translations, not Python:
+- Set `translation_key='<family>_cycle'` (or similar) on the `SelectDesc`;
+  `options`/`options_field` supply the **raw** codes.
+- Add the labels to **both** `strings.json` and `translations/en.json` under
+  `entity.select.<translation_key>.state.<code>`, with the code **lowercased**
+  (e.g. `"16": "Cotton"`). Codes with no entry render as the raw code — that's
+  the cue to identify and name them.
+
+## 6. Coverage discipline: bound or ignored
+
+Every href in the dump must resolve, or the repair fires. If a resource isn't
+worth an entity, add it to `capabilities/ignored.py` (a no-entity `Capability`)
+with a one-line reason. Add there only when it's **irrelevant plumbing**
+(network/OTA/account housekeeping) or a **duplicate of state exposed via a
+friendlier href**.
+
+- **Global vs per-registry ignore:** `ignored.IGNORED` is folded into every
+  registry. A global ignore **collides** (via `_build`) with any real capability
+  that binds the same href in some family — e.g. `/course/vs/0` can't be globally
+  ignored because washers bind it. When only one family should ignore an href
+  that another binds, scope the ignore to that family's registry.
+
+## 7. Reuse before writing new code
+
+Check `common.py` (generic OCF: power, energy, alarms, water) and `laundry.py`
+(shared washer/dryer/dishwasher: buzzer, job status, `cycle_select` + course
+machinery) before adding a capability. Cross-family reuse is normal — the dryer
+registry uses `fridge.FIRMWARE_UPDATE`; all three laundry families share
+`laundry.cycle_select`. If two families hand-roll the same helper, hoist it to a
+shared module rather than copying.
+
+## 8. Lock it in
+
+1. Add a **scrubbed** fixture `tests/fixtures/<type>_device.json`
+   (`{"device0": [ {devcol rep}, {href, rep}, ... ]}`) — replace serials, MACs,
+   and other PII with placeholders.
+2. Generate `tests/fixtures/golden/<type>.json` (`{"state_keys": [...]}`) with
+   the harness in §2.
+3. Add the type to `test_golden_regression.py` and write a
+   `test_<type>_capabilities.py` asserting **zero unbound hrefs** and that the
+   expected entities exist (and any misleading ones are gated).
+4. Run `pytest tests/ -q` — and re-run the golden tests for **other** device
+   types after any change to `common.py`/`laundry.py`, since they share those.
+
+## Key files
+- `registry/discovery.py` — `discover()`, unbound reporting, pattern caps.
+- `registry/capability.py`, `registry/entities.py` — the `Capability` and
+  descriptor shapes (`rt_filter`, `match_fn`, `exists_fn`, `rep_fn`, `write_fn`).
+- `registry/capabilities/{common,laundry,fridge,...}.py` — capability defs.
+- `registry/capabilities/ignored.py` — the ignore list + its philosophy.
+- `registry/by_type/*.py` — per-device-type registries (what to include).
+- `registry/registry.py` — the global unknown-device fallback + collision check.
+- `tests/test_golden_regression.py`, `tests/fixtures/` — regression harness.

.github/workflows/validate.yml

@@ -19,7 +19,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
 
       - name: Run hassfest validation
         uses: home-assistant/actions/hassfest@master
@@ -29,9 +29,29 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
 
       - name: Run HACS validation
         uses: hacs/action@main
         with:
           category: integration
+
+  tests:
+    name: Pytest
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout the repository
+        uses: actions/checkout@v7
+
+      - name: Set up Python
+        uses: actions/setup-python@v7
+        with:
+          python-version: "3.14"
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements-dev.txt
+
+      - name: Run tests
+        run: pytest tests/ -q

.gitignore

@@ -27,8 +27,10 @@ flows/
 # Local-only research tools (not part of the HA integration)
 local-tools/
 
-# Claude Code per-project state (permissions allowlist, etc.)
-.claude/
+# Claude Code per-project state (permissions allowlist, etc.) — but keep
+# shared, committed skills under .claude/skills/.
+.claude/*
+!.claude/skills/
 
 # HA dev instance — persisted config and secrets
 ha_config/

README.md

@@ -2,31 +2,28 @@
 
 **A native Home Assistant custom integration for local control of newer-generation Samsung connected appliances.** No cloud round-trip. Add a device through HA's normal *Settings > Devices & Services* flow and it talks CoAP-over-DTLS straight to the appliance on your LAN.
 
-> ### Where things live
->
-> This project split into two repos partway through development.
->
-> - **[`smartthings-local`](https://github.com/QuiteYellow/SmartThings-Local)** (PyPI package): the reusable protocol layer. DTLS session handling, CoAP wire encoding, Block2 reads, bounded retry/retransmit, inter-request rate limiting, cert-chain validation. No HA dependency; usable from any Python project.
-> - **This repo**: the Home Assistant integration built on top of it. Config flow, a per-device-type capability registry, the polling coordinator, and all the HA entity classes.
->
-> `custom_components/localthings/manifest.json` pulls in `smartthings-local` from PyPI like any other HA integration dependency.
+This integration uses the [`smartthings-local`](https://github.com/QuiteYellow/SmartThings-Local) library to handle the low-level DTLS/CoAP communication with devices.
 
 ### What you get
 
-Adding a device just needs a host IP and your CA credentials in the UI. The integration reads the appliance's `oneUiVersion` and picks the matching capability registry (dryer, oven, dishwasher, refrigerator) on its own, so there's no per-model descriptor to write for a new unit of a type that's already supported.
+Adding a device just needs a host IP and your CA credentials in the UI. The integration reads the appliance's identity and picks the matching capability registry on its own, so there's no per-model descriptor to write for a new unit of a type that's already supported.
 
-Credential setup is one-time. The first device you add asks for the AC14K_M CA cert and key (see Part 2); every device after that reuses the same stored CA and only asks for the host IP, minting its own per-device leaf cert automatically.
+Credential setup is one-time. The first device you add asks for a CA certificate and key (see Part 2); every device after that reuses the same stored CA and only asks for the host IP, minting its own per-device leaf cert automatically.
 
 Your state stays on your LAN: HA talks to the appliance over a direct DTLS session, and Samsung's cloud sees nothing from this integration. (The appliance itself still maintains its own connection to Samsung; that's firmware behavior on the device side, not something this integration controls.)
 
 ### Supported appliance types
 
-| Type | Registry | Notable capabilities |
-|---|---|---|
-| Dryer | `by_type/dryer.py` | Power, kids lock, remote control, alarms, energy meter, operational state, door LED, sound mode, dryer settings/course, job-beginning status, diagnosis, firmware-update sensor |
-| Oven | `by_type/oven.py` | Power, kids lock, remote control, alarms, cavity state, setpoint, mode, operational state, door, connectivity, firmware-update sensor |
-| Dishwasher | `by_type/dishwasher.py` | Power, kids lock, remote control, alarms, energy + water meters, water filter, operational state, cycle options/settings, door LED, sound mode/volume, firmware-update sensor |
-| Refrigerator | `by_type/refrigerator.py` | Power, kids lock, remote control, alarms, energy meter, water filter, status lock, door alert, icemaker (nighttime + generic per-compartment), flex zone, refrigeration mode, autofill, welcome/cabinet lighting, Sabbath mode, beverage zone, plus pattern-matched per-compartment temperature/setpoint/icemaker/door capabilities for multi-cavity fridges, firmware-update sensor |
+| Type | Registry |
+|---|---|
+| Air conditioner | `by_type/airconditioner.py` |
+| Dryer | `by_type/dryer.py` |
+| Oven | `by_type/oven.py` |
+| Dishwasher | `by_type/dishwasher.py` |
+| Refrigerator | `by_type/refrigerator.py` |
+| Washer | `by_type/washer.py` |
+
+Each registry composes shared and family-specific `Capability` objects from `registry/capabilities/`; those modules document the individual resources/entities in more depth than a README table can stay current with.
 
 Other Tizen RT / DAWIT-family appliances almost certainly speak the same protocol underneath, since the auth path and CoAP primitives are shared across the fleet. Adding a new type means writing a new `by_type/<name>.py` registry file; it doesn't require reverse-engineering the protocol again. See **Adding a new appliance type** below.
 
@@ -39,23 +36,17 @@ Other Tizen RT / DAWIT-family appliances almost certainly speak the same protoco
 nmap -Pn -sU -p 49152-49160 "$APPLIANCE_IP"
 ```
 
-- `49154/udp` or `49155/udp` open|filtered with a DTLS handshake responding: newer firmware (Tizen RT 3.x, DAWIT 3.0+). This is what the integration talks to. The config flow probes both ports automatically, so you don't need to know which one your device uses.
+- Any UDP port in `49152-49160` open|filtered with a DTLS handshake responding: newer firmware (Tizen RT 3.x, DAWIT 3.0+). This is what the integration talks to. Most devices answer on `49154`/`49155`, but some builds bind lower (e.g. `49153`). The config flow sweeps the whole range and auto-detects the live port, so you don't need to know which one your device uses.
 - Only `8888/tcp` open (token-based HTTPS): older firmware (roughly 2018-2022). **Not supported here.**
 
 ---
 
 ## Part 2: One-time setup, get the AC14K_M CA credentials
 
-The config flow (Part 3) needs a **CA certificate and CA private key** to mint each device's leaf cert itself. Specifically, it needs the `AC14K_M` intermediate CA: a cert chain that's been public for years and still ships in current Samsung firmware trust stores. It's required because every Samsung Tizen/RT-OCF appliance's factory ACL grants full CRUDN access (`perm=31` on `href=*`) to whatever identity is chained to that CA, so a cert signed by it is the one thing that lets HA talk to your appliance without Samsung's cloud in the loop. HA doesn't need the *device's* original cert or key, only something `AC14K_M` has signed, and it mints that itself once you give it the CA.
+The config flow (Part 3) needs a **CA certificate and CA private key** to mint each device's leaf cert itself. Specifically, it needs the `AC14K_M` intermediate CA — a cert chain that's been public for years and still ships in current Samsung firmware trust stores. Every Samsung Tizen/RT-OCF appliance trusts identities chained to that CA with full access by default, so a cert signed by it is what lets HA talk to your appliance without Samsung's cloud in the loop. HA doesn't need the *device's* original cert or key, only something `AC14K_M` has signed, and it mints that itself once you give it the CA.
 
 This repo doesn't include the needed CA bundle. For an example of how to obtain it, including fetching the AC14K_M cert and key and verifying they pair, see the `smartthings-local` protocol project's [`setup_cert.py`](https://github.com/QuiteYellow/SmartThings-Local/blob/main/setup_cert.py). However you obtain the CA cert and key, paste their PEM contents into the HA config flow's "CA Certificate (PEM)" and "CA Private Key (PEM)" fields in Part 3. You only need to do this once, since every appliance you add afterward reuses the same stored CA.
 
-### Why this works
-
-- Every Samsung Tizen/RT-OCF appliance has a factory-baked ACE in `/oic/sec/acl` granting the AC14K_M-chained identity `perm=31` on `href=*`.
-- TizenRT iotivity derives the peer ID via `memmem(subject_dn, "uuid:")`, which is RDN-agnostic, so a cert with the UUID in any RDN authenticates the same way.
-- You don't need the original keyholder's private key. The config flow mints its own key and has `AC14K_M` sign the leaf: different key, same identity, same access.
-
 ---
 
 ## Part 3: Add the integration in Home Assistant
@@ -64,7 +55,7 @@ This repo doesn't include the needed CA bundle. For an example of how to obtain
 2. Restart HA.
 3. **Settings > Devices & Services > Add Integration > LocalThings.**
 4. First device: paste the appliance's IP, plus the contents of the CA private and public key from Part 2.
-5. The flow fetches the current UUID from Samsung's cloud gateway, mints a leaf cert signed by your CA, probes ports `49154`/`49155`, and confirms the device answers `/device/0`. On success it creates the config entry and detects the device type automatically.
+5. The flow fetches the current UUID from Samsung's cloud gateway, mints a leaf cert signed by your CA, sweeps the `49152-49160` range to find the live DTLS port, and confirms the device answers `/device/0`. On success it creates the config entry and detects the device type automatically.
 6. Every subsequent device only asks for the host IP; the stored CA credentials are reused to mint that device's leaf cert.
 
 Entities appear under one HA device per appliance, named `Samsung Appliance (<ip>)` initially. Rename freely: the config entry is keyed on the device's serial, not the name.
@@ -80,7 +71,7 @@ docker compose up -d --build
 docker compose logs -f
 ```
 
-The `Dockerfile` builds on the official `home-assistant/home-assistant:stable` image and pre-installs `smartthings-local`, so the dependency is present at container start instead of depending on HA's own runtime pip-install step (which needs outbound network access at exactly the moment the integration loads, and repeats on every container recreate). Re-run with `--build` whenever the pinned `smartthings-local` version changes.
+The `Dockerfile` builds on the official `home-assistant/home-assistant:stable` image and pre-installs `smartthings-local`, so the dependency is present at container start instead of depending on HA's own runtime pip-install step. Re-run with `--build` whenever the pinned `smartthings-local` version changes.
 
 `docker-compose.yml` sets `network_mode: host`, which is required since DTLS is UDP and won't traverse Docker's bridge NAT to reach LAN appliances, and bind-mounts `custom_components/localthings/` read-only into `ha_config/custom_components/`. Bump `custom_components.localthings` to `debug` in `ha_config/configuration.yaml` for verbose protocol logging.
 
@@ -93,7 +84,7 @@ python3 -m venv .venv
 .venv/bin/pytest tests/ -q
 ```
 
-`requirements-dev.txt` pins `smartthings-local` the same way `manifest.json` does, so tests exercise the real published protocol layer rather than a vendored copy.
+A large suite covering registry composition, discovery, entity descriptors, and golden-file regression against captured device dumps. `requirements-dev.txt` pins `smartthings-local` the same way `manifest.json` does, so tests exercise the real published protocol layer rather than a vendored copy.
 
 ---
 
@@ -101,29 +92,32 @@ python3 -m venv .venv
 
 ```
 custom_components/localthings/
-  manifest.json                  Requirements (incl. the smartthings-local PyPI dep), version, domain
-  __init__.py                    async_setup_entry / async_unload_entry
-  config_flow.py                 UUID fetch, leaf cert minting, port probing, config entry creation
-  coordinator.py                 DataUpdateCoordinator: polling, stale-state fallback, write dispatch
-  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
-                                  One module per HA platform
+  manifest.json         Requirements (incl. the smartthings-local PyPI dep), version, domain
+  __init__.py            async_setup_entry / async_unload_entry
+  config_flow.py          UUID fetch, leaf cert minting, port probing, config entry creation
+  coordinator.py          Polling + push update coordination, stale-state fallback, write dispatch
+  observe.py              CoAP OBSERVE (push-mode) support layered on the coordinator
+  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
+                            One module per HA platform
   strings.json / translations/   Config-flow copy + entity state translations
   registry/
-    batch.py                     /device/0 batch response parsing
-    capability.py                Capability dataclass (href, entities, transforms)
-    entities.py                  Per-platform entity descriptor dataclasses
-    discovery.py                  Binds a device's live resources to registered capabilities
-    adapter.py                    Flattens bound entities into HA-ready state
-    identity.py                   Reads device identity (serial, oneUiVersion) for type detection
-    capabilities/                 Shared + per-family Capability definitions (common, dryer, oven,
-                                   dishwasher, fridge, laundry, operational)
-    by_type/                      One DeviceRegistry per appliance type, composed from capabilities/
-tests/                            80+ tests: registry composition, discovery, entity descriptors,
-                                   golden-file regression against captured device dumps
-requirements-dev.txt               Test deps, including the smartthings-local package
-docker-compose.yml / ha_config/    Local HA dev environment
+    registry.py             Builds the global capability registry, validates href collisions
+    capability.py           Capability dataclass (href, entities, transforms)
+    entities.py             Per-platform entity descriptor dataclasses
+    discovery.py            Binds a device's live resources to registered capabilities
+    adapter.py               Flattens bound entities into HA-ready state
+    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)
+    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
+requirements-dev.txt        Test deps, including the smartthings-local package
+docker-compose.yml / ha_config/   Local HA dev environment
 ```
 
 ---
@@ -141,21 +135,21 @@ support for hardware the maintainers don't have.
 
 ## Adding a new appliance type
 
-1. Capture the appliance's `/device/0` response to see what resources/fields it exposes. An authenticated `DtlsCoapSession` from `smartthings_local.protocol.dtls_session` GET is enough; `local-tools/probe_device.py` wraps this.
+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).
+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.
 5. Add golden-file coverage in `tests/` against a captured `/device/0` dump for the new type.
 
-No config-flow or coordinator changes are needed. Device-type detection and entity wiring are fully driven by the registry.
+No config-flow changes are needed. Device-type detection and entity wiring are fully driven by the registry.
 
 ---
 
-## Known DTLS behavior
+## Known device behavior
 
-Samsung's RT-OCF DTLS stack occasionally closes sessions actively, usually right after a Block2 GET or in the seconds after a POST. Retry/retransmit bounds and inter-request pacing live in the `smartthings-local` protocol layer (tuned against measured per-firmware request-rate ceilings); reconnect-with-backoff and stale-state fallback live in this repo's `coordinator.py`. From HA's perspective a brief reconnect looks like an entity holding its last value for one poll cycle rather than going `unavailable`.
+Samsung's firmware occasionally drops the DTLS session briefly — this is normal appliance-side behavior, not a bug. The integration reconnects automatically, and from HA's perspective a brief reconnect looks like an entity holding its last value for one poll cycle rather than going `unavailable`. When an appliance supports it, the integration prefers push-based updates (instant, via `observe.py`) over polling, falling back to polling otherwise.
 
-If reconnects become persistent (more than a handful per minute), something's actually wrong. Check the appliance's Wi-Fi link first, then look for a competing DTLS client on the LAN: Samsung's RT-OCF DTLS allows only one active session per peer.
+If reconnects become persistent (more than a handful per minute), something's actually wrong. Check the appliance's Wi-Fi link first, then look for a competing DTLS client on the LAN — only one active session per appliance is allowed at a time.
 
 ---
 
@@ -163,7 +157,7 @@ If reconnects become persistent (more than a handful per minute), something's ac
 
 Patches are welcome, especially:
 
-- New `by_type/` registries for appliance families not yet covered (washer, AC, microwave, etc.) on the same Tizen RT 3.x firmware family.
+- New `by_type/` registries for appliance families not yet covered (AC, microwave, etc.) on the same Tizen RT 3.x firmware family.
 - Confirmation or refutation of compatibility on additional models within an already-supported type.
 - Protocol-level fixes, which belong upstream in [`smartthings-local`](https://github.com/QuiteYellow/SmartThings-Local) rather than here. HA-side fixes (entities, config flow, coordinator, registry) belong in this repo.
 

custom_components/localthings/climate.py

@@ -0,0 +1,289 @@
+"""Climate platform for Local Things.
+
+The first composite entity in this integration: a single HA climate card that
+unifies several OCF resources of a Samsung air conditioner. Unlike every other
+platform here (one descriptor -> one resource field), a climate entity reads
+power, HVAC mode, current/target temperature, fan (wind) strength, swing (wind
+direction) and the convenient-mode preset from *different* resources.
+
+It binds one primary `BoundEntity` (the `/mode/vs/0` capability) so the registry
+still tracks it, and reads the sibling resources straight from the coordinator
+snapshot via `coordinator.resource(href)` -- the same cross-resource read that
+`number.py` (live range/unit) and `select.py` (options callable) already do.
+
+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.
+"""
+from __future__ import annotations
+
+from homeassistant.components.climate import (
+    ClimateEntity,
+    ClimateEntityFeature,
+    HVACMode,
+)
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import UnitOfTemperature
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
+
+from .registry.entities import ClimateDesc
+# The AC's canonical resource hrefs live in the capability module (the single
+# source of truth shared with its COVERAGE caps); power prefers the OCF-standard
+# href, falling back to the vendor one, mirroring common.POWER_GENERIC /
+# POWER_VS_FALLBACK.
+from .registry.capabilities.airconditioner import (
+    HREF_MODE as MODE_HREF,
+    HREF_POWER as POWER_HREF,
+    HREF_POWER_VS as POWER_VS_HREF,
+    HREF_TEMP_CURRENT as TEMP_CURRENT_HREF,
+    HREF_TEMP_DESIRED as TEMP_DESIRED_HREF,
+    HREF_TEMP_CONTROL as TEMP_CONTROL_HREF,
+    HREF_WIND_STRENGTH as WIND_STRENGTH_HREF,
+    HREF_WIND_DIRECTION as WIND_DIRECTION_HREF,
+    HREF_CONVENIENT as CONVENIENT_HREF,
+)
+from .registry.capabilities.common import normalize_temp_unit
+
+from .const import DOMAIN
+from .coordinator import LocalThingsCoordinator
+from .entity import LocalThingsEntity, _is_included
+
+_MODES_FIELD = 'x.com.samsung.da.modes'
+_SUPPORTED_FIELD = 'x.com.samsung.da.supportedModes'
+
+# --- device code <-> HA value maps -----------------------------------------
+# HVAC mode: Samsung /mode/vs/0 modes <-> HA HVACMode (excluding OFF, which is
+# driven by the power resource).
+_DEVICE_TO_HVAC: dict[str, HVACMode] = {
+    'Cool': HVACMode.COOL,
+    'Dry': HVACMode.DRY,
+    'Wind': HVACMode.FAN_ONLY,
+    'Auto': HVACMode.HEAT_COOL,
+    'Heat': HVACMode.HEAT,
+}
+_HVAC_TO_DEVICE = {v: k for k, v in _DEVICE_TO_HVAC.items()}
+
+# Fan (wind strength): device codes "0".."4" -> HA standard fan constants where
+# a clean match exists so they auto-localize; "turbo" is custom (translated).
+_DEVICE_TO_FAN: dict[str, str] = {
+    '0': 'auto',
+    '1': 'low',
+    '2': 'medium',
+    '3': 'high',
+    '4': 'turbo',
+}
+_FAN_TO_DEVICE = {v: k for k, v in _DEVICE_TO_FAN.items()}
+
+# Swing (wind direction): all map onto HA standard swing constants (auto-localize).
+_DEVICE_TO_SWING: dict[str, str] = {
+    'Fix': 'off',
+    'All': 'both',
+    'Up_And_Low': 'vertical',
+}
+_SWING_TO_DEVICE = {v: k for k, v in _DEVICE_TO_SWING.items()}
+
+# Preset (convenient mode): Off/Sleep map onto HA standard presets; Quiet/Smart/
+# Speed are custom (translated).
+_DEVICE_TO_PRESET: dict[str, str] = {
+    'Off': 'none',
+    'Sleep': 'sleep',
+    'Quiet': 'quiet',
+    'Smart': 'smart',
+    'Speed': 'speed',
+}
+_PRESET_TO_DEVICE = {v: k for k, v in _DEVICE_TO_PRESET.items()}
+
+
+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(
+        LocalThingsClimate(coordinator, b)
+        for b in coordinator.bound
+        if isinstance(b.desc, ClimateDesc) and _is_included(b, coordinator)
+    )
+
+
+def _first(value):
+    """Samsung `modes` is a single-element list on some resources, a scalar on
+    others. Return the first element of a list, else the value itself."""
+    if isinstance(value, (list, tuple)):
+        return value[0] if value else None
+    return value
+
+
+def _num(value):
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return None
+
+
+class LocalThingsClimate(LocalThingsEntity, ClimateEntity):
+    """Composite climate entity for a Samsung air conditioner."""
+
+    # translation_key comes from the ClimateDesc (base __init__ sets
+    # _attr_translation_key from bound.desc), resolving the state_attributes
+    # translations under entity.climate.airconditioner.
+    # Modern climate entities opt out of the deprecated auto-added TURN_ON/OFF.
+    _enable_turn_on_off_backwards_compatibility = False
+
+    def __init__(self, coordinator: LocalThingsCoordinator, bound) -> None:
+        super().__init__(coordinator, bound)
+        # Primary/main entity for the device: no name suffix, just the device name.
+        self._attr_name = None
+        self._attr_supported_features = (
+            ClimateEntityFeature.TARGET_TEMPERATURE
+            | ClimateEntityFeature.FAN_MODE
+            | ClimateEntityFeature.SWING_MODE
+            | ClimateEntityFeature.PRESET_MODE
+            | ClimateEntityFeature.TURN_ON
+            | ClimateEntityFeature.TURN_OFF
+        )
+
+    # -- resource helpers ---------------------------------------------------
+
+    def _rep(self, href: str) -> dict:
+        return self.coordinator.resource(href) or {}
+
+    def _is_on(self) -> bool:
+        rep = self._rep(POWER_HREF)
+        if 'value' in rep:
+            return bool(rep.get('value'))
+        vs = self._rep(POWER_VS_HREF)
+        return str(vs.get('x.com.samsung.da.power', '')).lower() == 'on'
+
+    def _supported(self, href: str) -> list[str]:
+        return list(self._rep(href).get(_SUPPORTED_FIELD) or [])
+
+    def _read_mode(self, href: str, mapping: dict):
+        """Current mode of a wind/convenient resource, mapped to its HA value."""
+        return mapping.get(_first(self._rep(href).get(_MODES_FIELD)))
+
+    def _read_modes(self, href: str, mapping: dict) -> list[str]:
+        """Supported modes of a resource, mapped to HA values (unknowns dropped)."""
+        return [mapping[c] for c in self._supported(href) if c in mapping]
+
+    # -- temperature --------------------------------------------------------
+
+    @property
+    def temperature_unit(self) -> str:
+        raw = self._rep(TEMP_DESIRED_HREF).get('units')
+        return (UnitOfTemperature.FAHRENHEIT
+                if normalize_temp_unit(raw, '°C') == '°F'
+                else UnitOfTemperature.CELSIUS)
+
+    @property
+    def current_temperature(self):
+        return _num(self._rep(TEMP_CURRENT_HREF).get('temperature'))
+
+    @property
+    def target_temperature(self):
+        return _num(self._rep(TEMP_DESIRED_HREF).get('temperature'))
+
+    def _range(self) -> list | None:
+        r = self._rep(TEMP_DESIRED_HREF).get('range')
+        return r if (isinstance(r, (list, tuple)) and len(r) == 2) else None
+
+    @property
+    def min_temp(self) -> float:
+        r = self._range()
+        return float(r[0]) if r else super().min_temp
+
+    @property
+    def max_temp(self) -> float:
+        r = self._range()
+        return float(r[1]) if r else super().max_temp
+
+    @property
+    def target_temperature_step(self) -> float:
+        return _num(self._rep(TEMP_CONTROL_HREF).get('increment')) or 1.0
+
+    # -- hvac mode ----------------------------------------------------------
+
+    @property
+    def hvac_mode(self) -> HVACMode:
+        if not self._is_on():
+            return HVACMode.OFF
+        device = _first(self._rep(MODE_HREF).get(_MODES_FIELD))
+        return _DEVICE_TO_HVAC.get(device, HVACMode.AUTO)
+
+    @property
+    def hvac_modes(self) -> list[HVACMode]:
+        modes = [HVACMode.OFF]
+        for m in self._supported(MODE_HREF):
+            mapped = _DEVICE_TO_HVAC.get(m)
+            if mapped is not None and mapped not in modes:
+                modes.append(mapped)
+        return modes
+
+    # -- fan / swing / preset ----------------------------------------------
+
+    @property
+    def fan_mode(self):
+        return self._read_mode(WIND_STRENGTH_HREF, _DEVICE_TO_FAN)
+
+    @property
+    def fan_modes(self) -> list[str]:
+        return self._read_modes(WIND_STRENGTH_HREF, _DEVICE_TO_FAN)
+
+    @property
+    def swing_mode(self):
+        return self._read_mode(WIND_DIRECTION_HREF, _DEVICE_TO_SWING)
+
+    @property
+    def swing_modes(self) -> list[str]:
+        return self._read_modes(WIND_DIRECTION_HREF, _DEVICE_TO_SWING)
+
+    @property
+    def preset_mode(self):
+        return self._read_mode(CONVENIENT_HREF, _DEVICE_TO_PRESET)
+
+    @property
+    def preset_modes(self) -> list[str]:
+        return self._read_modes(CONVENIENT_HREF, _DEVICE_TO_PRESET)
+
+    # -- writes -------------------------------------------------------------
+
+    async def async_set_temperature(self, **kwargs) -> None:
+        temp = kwargs.get('temperature')
+        if temp is not None:
+            await self.coordinator.async_send_command(self._bound, ('temperature', temp))
+
+    async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
+        if hvac_mode == HVACMode.OFF:
+            await self.coordinator.async_send_command(self._bound, ('power', False))
+            return
+        device = _HVAC_TO_DEVICE.get(hvac_mode)
+        if device is None:
+            return
+        if not self._is_on():
+            await self.coordinator.async_send_command(self._bound, ('power', True))
+        await self.coordinator.async_send_command(self._bound, ('mode', device))
+
+    async def async_turn_on(self) -> None:
+        await self.coordinator.async_send_command(self._bound, ('power', True))
+
+    async def async_turn_off(self) -> None:
+        await self.coordinator.async_send_command(self._bound, ('power', False))
+
+    async def _set_mapped(self, kind: str, mapping: dict, value: str) -> None:
+        """Map an HA fan/swing/preset value back to its device code and write it."""
+        device = mapping.get(value)
+        if device is not None:
+            await self.coordinator.async_send_command(self._bound, (kind, device))
+
+    async def async_set_fan_mode(self, fan_mode: str) -> None:
+        await self._set_mapped('fan', _FAN_TO_DEVICE, fan_mode)
+
+    async def async_set_swing_mode(self, swing_mode: str) -> None:
+        await self._set_mapped('swing', _SWING_TO_DEVICE, swing_mode)
+
+    async def async_set_preset_mode(self, preset_mode: str) -> None:
+        await self._set_mapped('preset', _PRESET_TO_DEVICE, preset_mode)

custom_components/localthings/config_flow.py

@@ -4,8 +4,10 @@ from __future__ import annotations
 import datetime
 import logging
 import re
+import selectors
 import socket
 import ssl
+import time
 from typing import Any
 
 import voluptuous as vol
@@ -22,7 +24,8 @@ from .const import (
     CONF_HOST, CONF_PORT,
     CONF_CA_CERT_PEM, CONF_CA_KEY_PEM,
     CONF_LEAF_CERT_PEM, CONF_LEAF_KEY_PEM,
-    PROBE_PORTS,
+    PROBE_PORT_RANGE, PREFERRED_PROBE_PORTS, LIVENESS_PROBE_TIMEOUT_S,
+    PROBE_GET_TIMEOUT_S,
 )
 
 _TEXT = TextSelector(TextSelectorConfig(type=TextSelectorType.TEXT))
@@ -120,6 +123,73 @@ def _mint_leaf_cert(ca_cert_pem: str, ca_key_pem: str, uuid: str) -> tuple[str,
     return fullchain_pem, leaf_key_pem
 
 
+def _order_candidates(ports: list[int]) -> list[int]:
+    """Order live ports so the historically known DTLS ports are tried first."""
+    preferred = [p for p in PREFERRED_PROBE_PORTS if p in ports]
+    rest = sorted(p for p in ports if p not in PREFERRED_PROBE_PORTS)
+    return preferred + rest
+
+
+def _find_live_ports(host: str, ports: list[int], timeout: float) -> list[int]:
+    """Fast UDP liveness sweep to narrow the range before the DTLS handshake.
+
+    UDP is connectionless, but a *connected* UDP socket surfaces the ICMP
+    port-unreachable that a closed port returns as ECONNREFUSED on its next
+    recv. So we send one probe datagram per port and watch for that error:
+
+      * ECONNREFUSED       -> port is closed (device actively rejected it)
+      * silence / any data -> port may be live (open|filtered); a candidate
+
+    This is the in-process equivalent of ``nmap -sU``: it lets us take a
+    nine-port range down to the one or two ports actually worth a full DTLS
+    handshake + /device/0 GET, and bounds the total wait to ``timeout``
+    instead of stalling on every dead port when a firewall swallows the ICMP
+    replies.
+    """
+    sockets: dict[int, socket.socket] = {}
+    sel = selectors.DefaultSelector()
+    # A single byte is enough to provoke an ICMP port-unreach from a closed
+    # port; a real DTLS ClientHello is unnecessary just to test for life.
+    probe = b"\x00"
+    try:
+        for port in ports:
+            sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            sock.setblocking(False)
+            try:
+                sock.connect((host, port))
+                sock.send(probe)
+            except OSError:
+                sock.close()
+                continue
+            sockets[port] = sock
+            sel.register(sock, selectors.EVENT_READ, port)
+
+        # Ports drop out of the selector as they refuse; whatever is still
+        # registered when the deadline passes is silent-but-live (a candidate).
+        deadline = time.monotonic() + timeout
+        while sel.get_map():
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                break
+            for key, _ in sel.select(timeout=remaining):
+                try:
+                    # Data back means live; ECONNREFUSED (or any other socket
+                    # error) means the port is closed/unusable — rule it out.
+                    key.fileobj.recv(1)
+                except OSError:
+                    sel.unregister(key.fileobj)
+        live = [key.data for key in sel.get_map().values()]
+    finally:
+        sel.close()
+        for sock in sockets.values():
+            try:
+                sock.close()
+            except OSError:
+                pass
+
+    return _order_candidates(live)
+
+
 def _probe_and_validate(host: str, ca_cert_pem: str, ca_key_pem: str) -> dict:
     """Fetch UUID, mint leaf cert, probe each port. Returns config entry data dict."""
     import cbor2
@@ -146,8 +216,21 @@ def _probe_and_validate(host: str, ca_cert_pem: str, ca_key_pem: str) -> dict:
         raise CannotConnect(f"Failed to mint leaf cert: {exc}") from exc
     _LOGGER.debug("Leaf cert minted successfully")
 
+    candidates = _find_live_ports(
+        host, PROBE_PORT_RANGE, LIVENESS_PROBE_TIMEOUT_S
+    )
+    if not candidates:
+        # Every port in the range actively refused: there is no DTLS/CoAP
+        # listener on this host, so a handshake can't succeed. Fail now with a
+        # clear message instead of retrying doomed ports.
+        raise CannotConnect(
+            f"no live DTLS port found on {host} "
+            f"in {PROBE_PORT_RANGE[0]}-{PROBE_PORT_RANGE[-1]}"
+        )
+    _LOGGER.debug("Live DTLS port candidates on %s: %s", host, candidates)
+
     last_exc = None
-    for port in PROBE_PORTS:
+    for port in candidates:
         sess = None
         try:
             sess = DtlsCoapSession(
@@ -157,7 +240,7 @@ def _probe_and_validate(host: str, ca_cert_pem: str, ca_key_pem: str) -> dict:
             )
             sess.connect()
             sess.start_reader()
-            code, payload = sess.get(['device', '0'], timeout=15.0)
+            code, payload = sess.get(['device', '0'], timeout=PROBE_GET_TIMEOUT_S)
             if code != 0x45 or not payload:
                 raise CannotConnect(f"port {port}: unexpected code {code:#04x}")
             body = cbor2.loads(payload)

custom_components/localthings/const.py

@@ -1,6 +1,6 @@
 DOMAIN = "localthings"
 
-PLATFORMS = ["sensor", "binary_sensor", "switch", "number", "select", "button", "time"]
+PLATFORMS = ["sensor", "binary_sensor", "switch", "number", "select", "button", "time", "climate"]
 
 CONF_HOST         = "host"
 CONF_PORT         = "port"
@@ -9,7 +9,25 @@ CONF_CA_KEY_PEM   = "ca_key_pem"
 CONF_LEAF_CERT_PEM = "leaf_cert_pem"
 CONF_LEAF_KEY_PEM  = "leaf_key_pem"
 
-PROBE_PORTS = [49154, 49155]
+# 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
+# before attempting the (expensive) DTLS handshake.
+PROBE_PORT_RANGE = list(range(49152, 49161))
+
+# Ports we've historically seen complete a DTLS handshake. When more than one
+# port in the range looks live, these are tried first.
+PREFERRED_PROBE_PORTS = [49154, 49155]
+
+# Per-port timeout for the cheap UDP liveness sweep. Closed ports return an
+# ICMP port-unreachable almost immediately; a live-but-silent port is only
+# detected by this timeout elapsing, so keep it short.
+LIVENESS_PROBE_TIMEOUT_S = 1.5
+
+# Deadline for the blockwise /device/0 GET during the config-flow probe. The
+# slowest device observed returns a full dump in ~8s, so 10s leaves headroom
+# without stalling setup; it matches the per-resource read timeout elsewhere.
+PROBE_GET_TIMEOUT_S = 10.0
 
 SUMMARY_INTERVAL_S = 30.0
 

custom_components/localthings/coordinator.py

@@ -115,6 +115,13 @@ class LocalThingsCoordinator(DataUpdateCoordinator[dict[str, Any]]):
     def last_resources(self) -> dict:
         return self._cache.snapshot()
 
+    def resource(self, href: str) -> dict:
+        """A single href's current rep. Cheaper than `last_resources.get(href)`
+        for callers that only need one href — `last_resources` copies every
+        tracked href's rep to build the snapshot dict, while this is a
+        direct O(1) cache lookup."""
+        return self._cache.get(href) or {}
+
     @property
     def observe_mode(self) -> str:
         return self._observe.mode

custom_components/localthings/diagnostics.py

@@ -26,13 +26,18 @@ async def async_get_config_entry_diagnostics(
     coordinator: LocalThingsCoordinator = hass.data[DOMAIN][entry.entry_id]
     integration = await async_get_integration(hass, DOMAIN)
 
+    # importlib.metadata.version() reads the installed package's metadata off
+    # disk (listdir + open + read_text), which trips HA's event-loop blocking
+    # detector when called inline here. Offload it to the executor.
+    stl_version = await hass.async_add_executor_job(pkg_version, "smartthings-local")
+
     return {
         "device_type": coordinator.device_type_name or "unknown",
         "one_ui_version": coordinator.one_ui_version,
         "unbound_hrefs": sorted(coordinator._unbound_hrefs),
         "resources": redact_resources(coordinator.last_resources),
         "integration_version": integration.version,
-        "smartthings_local_version": pkg_version("smartthings-local"),
+        "smartthings_local_version": stl_version,
         "observe_mode": coordinator.observe_mode,
         "observe_subscribed_hrefs": sorted(coordinator._observe.subscribed_hrefs),
         "observe_fallback_hrefs": sorted(coordinator._observe.fallback_hrefs),

custom_components/localthings/manifest.json

@@ -5,12 +5,12 @@
   "config_flow": true,
   "dependencies": [],
   "documentation": "https://github.com/mbillow/localthings",
-  "iot_class": "local_polling",
+  "iot_class": "local_push",
   "issue_tracker": "https://github.com/mbillow/localthings/issues",
   "requirements": [
     "cbor2>=5.4.6",
     "pyOpenSSL>=23.0",
     "smartthings-local>=0.1.0"
   ],
-  "version": "0.1.0"
+  "version": "0.7.0"
 }

custom_components/localthings/number.py

@@ -42,12 +42,18 @@ class LocalThingsNumber(LocalThingsEntity, NumberEntity):
         if desc.step is not None:
             self._attr_native_step = desc.step
 
+    @property
+    def native_unit_of_measurement(self):
+        desc: NumberDesc = self._bound.desc
+        if desc.unit_fn is not None:
+            return desc.unit_fn(self.coordinator.resource(self._bound.href))
+        return self._attr_native_unit_of_measurement
+
     def _range_from_resource(self) -> list | None:
         desc: NumberDesc = self._bound.desc
         if not desc.range_field:
             return None
-        rep = self.coordinator.last_resources.get(self._bound.href) or {}
-        r = rep.get(desc.range_field)
+        r = self.coordinator.resource(self._bound.href).get(desc.range_field)
         return r if (isinstance(r, (list, tuple)) and len(r) == 2) else None
 
     @property

custom_components/localthings/registry/by_type/__init__.py

@@ -2,12 +2,14 @@
 from typing import Optional
 
 from ._base import DeviceRegistry
-from . import dishwasher, dryer, oven, refrigerator, washer
+from . import airconditioner, dishwasher, dryer, oven, refrigerator, washer
 
 __all__ = ['DeviceRegistry', '_type_key', 'for_device', 'for_device_by_model']
 
 
 _REGISTRY_BY_KEY: dict[str, DeviceRegistry] = {
+    'airconditioner': airconditioner.REGISTRY,
+    'air_conditioner': airconditioner.REGISTRY,
     'dishwasher': dishwasher.REGISTRY,
     'dryer': dryer.REGISTRY,
     'oven': oven.REGISTRY,
@@ -88,4 +90,8 @@ def for_device_by_model(model_num: str, description: str) -> Optional[DeviceRegi
     key = _CONSUMER_PREFIX_TO_KEY.get(token[:2].upper())
     if key is None and '_REF_' in (model_num or ''):
         key = 'refrigerator'
+    # Room air conditioners (e.g. ARTIK051_PRAC_20K) report no oneUiVersion and
+    # a modelNum carrying the '_PRAC_' (Package Room Air Conditioner) token.
+    if key is None and '_PRAC_' in (model_num or ''):
+        key = 'airconditioner'
     return _REGISTRY_BY_KEY.get(key) if key else None

custom_components/localthings/registry/by_type/airconditioner.py

@@ -0,0 +1,29 @@
+"""Air-conditioner device registry (Samsung ARTIK051_PRAC-class, issue #17).
+
+The first device whose core controls surface as a single composite HA `climate`
+entity (see capabilities/airconditioner.py and climate.py). Power/mode/temp/wind
+are consumed by that entity rather than exposed as separate switches/selects, so
+this registry deliberately does NOT include the common POWER caps -- on/off is
+the climate entity's HVACMode.OFF / TURN_ON/OFF.
+
+Reuses common.ALARMS + common.ENERGY_METER, fridge.FIRMWARE_UPDATE (as every
+registry does), and dishwasher.DIAGNOSIS for /diagnosis/vs/0.
+"""
+from ..capabilities import airconditioner, common, dishwasher, fridge, ignored
+from ._base import DeviceRegistry, _build
+
+REGISTRY = DeviceRegistry(
+    name='airconditioner',
+    capabilities=_build([
+        *ignored.IGNORED,
+        common.ALARMS,
+        common.ENERGY_METER,
+        fridge.FIRMWARE_UPDATE,
+        dishwasher.DIAGNOSIS,
+        airconditioner.CLIMATE,
+        airconditioner.AIR_PURIFY,
+        airconditioner.AUTO_CLEAN,
+        airconditioner.AIR_FILTER,
+        *airconditioner.COVERAGE,
+    ]),
+)

custom_components/localthings/registry/by_type/dishwasher.py

@@ -1,14 +1,17 @@
 """Dishwasher device registry."""
-from ..capabilities import common, dishwasher, dryer, fridge, ignored, laundry, operational
+from ..capabilities import common, dishwasher, fridge, ignored, laundry, operational
 from ._base import DeviceRegistry, _build
 
 REGISTRY = DeviceRegistry(
     name='dishwasher',
     capabilities=_build([
         *ignored.IGNORED,
-        common.POWER,
-        common.KIDS_LOCK,
-        common.REMOTE_CONTROL,
+        common.POWER_GENERIC,
+        common.POWER_VS_FALLBACK,
+        common.KIDS_LOCK_GENERIC,
+        common.KIDS_LOCK_VS_FALLBACK,
+        common.REMOTE_CONTROL_GENERIC,
+        common.REMOTE_CONTROL_VS_FALLBACK,
         common.ALARMS,
         common.ENERGY_METER,
         common.WATER_METER,
@@ -18,7 +21,7 @@ REGISTRY = DeviceRegistry(
         dishwasher.DISHWASHER_SETTINGS,
         dishwasher.DIAGNOSIS,
         dishwasher.OPERATION_ORIGIN,
-        dryer.JOB_BEGINNING_STATUS,
+        laundry.JOB_BEGINNING_STATUS,
         laundry.DOOR_LED,
         laundry.SOUND_MODE,
         laundry.SOUND_VOLUME,

custom_components/localthings/registry/by_type/dryer.py

@@ -2,6 +2,12 @@
 
 Note: dryer devices use port 49155 (not 49154). The config flow handles
 this automatically via port probing.
+
+The power/kids-lock/remote-control, buzzer, energy-meter, job-status, and
+cycle-select capabilities are the shared laundry ones (laundry.py), the same
+objects the washer registry uses -- washer and dryer expose the same
+DA_WM_-family surface, so they stay consistent instead of each carrying a
+bespoke variant.
 """
 from ..capabilities import common, dryer, fridge, ignored, laundry, operational
 from ._base import DeviceRegistry, _build
@@ -10,17 +16,21 @@ REGISTRY = DeviceRegistry(
     name='dryer',
     capabilities=_build([
         *ignored.IGNORED,
-        common.POWER,
-        common.KIDS_LOCK,
-        common.REMOTE_CONTROL,
+        common.POWER_GENERIC,
+        common.POWER_VS_FALLBACK,
+        common.KIDS_LOCK_GENERIC,
+        common.KIDS_LOCK_VS_FALLBACK,
+        common.REMOTE_CONTROL_GENERIC,
+        common.REMOTE_CONTROL_VS_FALLBACK,
         common.ALARMS,
         common.ENERGY_METER,
         operational.OPERATIONAL_STATE,
         laundry.DOOR_LED,
         laundry.SOUND_MODE,
+        laundry.BUZZER_SOUND,
+        laundry.JOB_BEGINNING_STATUS,
         dryer.DRYER_SETTINGS,
         dryer.DRYER_COURSE,
-        dryer.JOB_BEGINNING_STATUS,
         dryer.DRYER_DIAGNOSIS,
         fridge.FIRMWARE_UPDATE,
     ]),

custom_components/localthings/registry/by_type/oven.py

@@ -6,9 +6,12 @@ REGISTRY = DeviceRegistry(
     name='oven',
     capabilities=_build([
         *ignored.IGNORED,
-        common.POWER,
-        common.KIDS_LOCK,
-        common.REMOTE_CONTROL,
+        common.POWER_GENERIC,
+        common.POWER_VS_FALLBACK,
+        common.KIDS_LOCK_GENERIC,
+        common.KIDS_LOCK_VS_FALLBACK,
+        common.REMOTE_CONTROL_GENERIC,
+        common.REMOTE_CONTROL_VS_FALLBACK,
         common.ALARMS,
         oven.OVEN_CAVITY,
         oven.OVEN_SETPOINT,

custom_components/localthings/registry/by_type/refrigerator.py

@@ -6,11 +6,14 @@ REGISTRY = DeviceRegistry(
     name='refrigerator',
     capabilities=_build([
         *ignored.IGNORED,
-        common.POWER,
+        common.POWER_GENERIC,
+        common.POWER_VS_FALLBACK,
         fridge.STATUS_LOCK,
         fridge.DOOR_ALERT,
-        common.KIDS_LOCK,
-        common.REMOTE_CONTROL,
+        common.KIDS_LOCK_GENERIC,
+        common.KIDS_LOCK_VS_FALLBACK,
+        common.REMOTE_CONTROL_GENERIC,
+        common.REMOTE_CONTROL_VS_FALLBACK,
         common.ALARMS,
         common.ENERGY_METER,
         common.WATER_FILTER,
@@ -30,6 +33,7 @@ REGISTRY = DeviceRegistry(
         fridge.DOORS_FALLBACK,
         fridge.TEMPERATURES_FALLBACK,
         fridge.ICEMAKER_STATUS_FALLBACK,
+        fridge.REFRIGERATION_FALLBACK,
     ]),
     pattern_capabilities=[
         fridge.TEMP_CURRENT_GENERIC,

custom_components/localthings/registry/by_type/washer.py

@@ -1,21 +1,21 @@
 """Washer device registry."""
-from ..capabilities import common, dishwasher, fridge, ignored, operational, washer
+from ..capabilities import common, dishwasher, fridge, ignored, laundry, operational, washer
 from ._base import DeviceRegistry, _build
 
 REGISTRY = DeviceRegistry(
     name='washer',
     capabilities=_build([
         *ignored.IGNORED,
-        washer.POWER_GENERIC,
-        washer.POWER_VS_FALLBACK,
-        washer.KIDS_LOCK_GENERIC,
-        washer.KIDS_LOCK_VS_FALLBACK,
-        washer.REMOTE_CONTROL_GENERIC,
-        washer.REMOTE_CONTROL_VS_FALLBACK,
+        common.POWER_GENERIC,
+        common.POWER_VS_FALLBACK,
+        common.KIDS_LOCK_GENERIC,
+        common.KIDS_LOCK_VS_FALLBACK,
+        common.REMOTE_CONTROL_GENERIC,
+        common.REMOTE_CONTROL_VS_FALLBACK,
         washer.WASHER_SETTINGS,
         washer.WASHER_COURSE,
-        washer.BUZZER_SOUND,
-        washer.WASHER_JOB_BEGINNING_STATUS,
+        laundry.BUZZER_SOUND,
+        laundry.JOB_BEGINNING_STATUS,
         common.ALARMS,
         common.ENERGY_METER,
         common.WATER_METER,

custom_components/localthings/registry/capabilities/airconditioner.py

@@ -0,0 +1,170 @@
+"""Capabilities for the Samsung air-conditioner family (ARTIK051_PRAC-class).
+
+Resources verified against the issue #17 diagnostics dump (model
+ARTIK051_PRAC_20K). This is the first family whose core controls surface as a
+single composite HA `climate` entity rather than a scatter of switches/selects:
+power (on/off), HVAC mode, current/target temperature, fan (wind) strength,
+swing (wind direction), and the convenient-mode preset all live on one climate
+card. The climate platform (climate.py) reads those sibling resources from the
+coordinator snapshot; here we bind the primary `/mode/vs/0` resource to the
+`ClimateDesc` and mark the consumed siblings as covered.
+
+None of these caps may go into the global `ALL`/`CAPABILITIES`: `/mode/vs/0`,
+`/temperatures/vs/0`, `/humidity/*` collide with fridge/oven hrefs of a
+different schema (see capabilities/__init__.py). They live only in the AC
+by_type registry.
+"""
+from ..capability import Capability
+from ..entities import ClimateDesc, SensorDesc, SwitchDesc
+
+# ---------------------------------------------------------------------------
+# Canonical AC resource hrefs. The climate entity (climate.py) binds the
+# primary HREF_MODE via CLIMATE below and reads the CLIMATE_CONSUMED_HREFS
+# siblings off the coordinator snapshot; those siblings are marked covered
+# (no-entity caps) so discover() reports no gap. Declared once here and
+# imported by climate.py, so a new sibling read can't drift out of sync with
+# its coverage entry.
+# ---------------------------------------------------------------------------
+HREF_MODE = '/mode/vs/0'                          # primary (bound by CLIMATE)
+HREF_POWER = '/power/0'                           # on/off -> HVACMode.OFF / TURN_ON/OFF
+HREF_POWER_VS = '/power/vs/0'                     # vendor fallback for on/off
+HREF_TEMP_CURRENT = '/temperature/current/0'      # current_temperature
+HREF_TEMP_DESIRED = '/temperature/desired/0'      # target_temperature (write target)
+HREF_TEMP_CONTROL = '/temperature/control/vs/0'   # target_temperature_step
+HREF_WIND_STRENGTH = '/wind/strength/vs/0'        # fan_mode
+HREF_WIND_DIRECTION = '/wind/direction/vs/0'      # swing_mode
+HREF_CONVENIENT = '/mode/convenient/vs/0'         # preset_mode
+
+CLIMATE_CONSUMED_HREFS = [
+    HREF_POWER, HREF_POWER_VS, HREF_TEMP_CURRENT, HREF_TEMP_DESIRED,
+    HREF_TEMP_CONTROL, HREF_WIND_STRENGTH, HREF_WIND_DIRECTION, HREF_CONVENIENT,
+]
+
+
+def _num(v):
+    try:
+        return float(v)
+    except (TypeError, ValueError):
+        return None
+
+
+def _filter_usage_percent(rep):
+    """Filter usage as a percentage of rated capacity. The device reports
+    `filterUsage` as a raw count in `filterCapacityUnit` (Hours here, e.g.
+    100 of a 500 capacity), so a plain value with a '%' unit would be wrong --
+    normalize to used/capacity. Returns None when capacity is missing/zero."""
+    used = _num(rep.get('x.com.samsung.da.filterUsage'))
+    cap = _num(rep.get('x.com.samsung.da.filterCapacity'))
+    if used is None or not cap:
+        return None
+    return round(used / cap * 100)
+
+
+def _first_mode(rep):
+    """Representative scalar for the climate entity in the flattened state
+    (golden/regression). The real entity computes hvac_mode from power + mode."""
+    modes = rep.get('x.com.samsung.da.modes')
+    if isinstance(modes, (list, tuple)):
+        return modes[0] if modes else None
+    return modes
+
+
+def _climate_write(payload, rep, href=None):
+    """Map a (kind, value) command from the climate platform to the
+    (path_segs, body) for that one sub-write. `value` is already the raw device
+    code (the platform maps HA<->device). async_send_command POSTs to path_segs,
+    so a single desc drives writes across power/mode/temperature/wind resources.
+    Read-modify-write safe: each write sends only its own field, leaving the
+    resource's other fields (e.g. /mode/vs/0's opaque `options` blob) untouched.
+    """
+    kind, value = payload
+    if kind == 'power':
+        return (['power', '0'], {'value': bool(value)})
+    if kind == 'mode':
+        return (['mode', 'vs', '0'], {'x.com.samsung.da.modes': [value]})
+    if kind == 'temperature':
+        return (['temperature', 'desired', '0'], {'temperature': int(round(float(value)))})
+    if kind == 'fan':
+        return (['wind', 'strength', 'vs', '0'], {'x.com.samsung.da.modes': value})
+    if kind == 'swing':
+        return (['wind', 'direction', 'vs', '0'], {'x.com.samsung.da.modes': value})
+    if kind == 'preset':
+        return (['mode', 'convenient', 'vs', '0'], {'x.com.samsung.da.modes': value})
+    return None
+
+
+CLIMATE = Capability(
+    href=HREF_MODE,
+    poll_tier='warm',
+    entities=(
+        ClimateDesc(key='climate', translation_key='airconditioner',
+                    rep_fn=_first_mode, write_fn=_climate_write),
+    ),
+)
+
+AIR_PURIFY = Capability(
+    href='/option/airpurify/vs/0',
+    poll_tier='warm',
+    entities=(
+        SwitchDesc(key='air_purify', field='x.com.samsung.da.modes',
+                   name='Air purification', icon='mdi:air-purifier',
+                   entity_category='config',
+                   value_fn=lambda v: v == 'On',
+                   write_fn=lambda p, rep, href=None: (
+                       ['option', 'airpurify', 'vs', '0'],
+                       {'x.com.samsung.da.modes': 'On' if p == 'On' else 'Off'})),
+    ),
+)
+
+AUTO_CLEAN = Capability(
+    href='/option/autoclean/vs/0',
+    poll_tier='cold',
+    entities=(
+        SwitchDesc(key='auto_clean', field='x.com.samsung.da.settingStatus',
+                   name='Auto clean', icon='mdi:spray-bottle',
+                   entity_category='config',
+                   value_fn=lambda v: v == 'On',
+                   write_fn=lambda p, rep, href=None: (
+                       ['option', 'autoclean', 'vs', '0'],
+                       {'x.com.samsung.da.settingStatus': 'On' if p == 'On' else 'Off'})),
+    ),
+)
+
+AIR_FILTER = Capability(
+    href='/filter/airdustfilter/vs/0',
+    poll_tier='cold',
+    entities=(
+        SensorDesc(key='air_filter_usage', rep_fn=_filter_usage_percent,
+                   name='Filter usage', unit='%', state_class='measurement',
+                   icon='mdi:air-filter', entity_category='diagnostic'),
+        SensorDesc(key='air_filter_status', field='x.com.samsung.da.filterStatus',
+                   name='Filter status', device_class='enum',
+                   options=('normal', 'wash', 'replace'),
+                   translation_key='air_filter_status',
+                   icon='mdi:air-filter', entity_category='diagnostic',
+                   value_fn=lambda v: v.lower() if isinstance(v, str) else v),
+    ),
+)
+
+# ---------------------------------------------------------------------------
+# AC-scoped coverage: the CLIMATE_CONSUMED_HREFS above (read by the climate
+# entity) plus vendor duplicates / all-zero-ambiguous / plumbing resources.
+# These are NOT in the global ignored.IGNORED because several of them
+# (/mode/vs/0 handled above, /temperatures/vs/0, /humidity/*) collide with
+# other families' schemas. A no-entity Capability still marks the href as
+# bound so discover() reports no coverage gap.
+# ---------------------------------------------------------------------------
+_AC_IGNORED = [
+    # Vendor superset that duplicates the OCF /temperature/current+desired pair.
+    '/temperatures/vs/0',
+    # All-zero and ambiguously encoded on this model (2-value arrays); the
+    # 'don't guess' rule -- leave unmodeled rather than invent entities.
+    '/sensors/vs/0',
+    '/humidity/0',
+    '/humidity/vs/0',
+    # Presence-personalization plumbing (empty item list here).
+    '/personality/presence/vs/0',
+]
+
+# Built as bare no-entity caps; folded into the AC registry (not global).
+COVERAGE = [Capability(href=h) for h in (CLIMATE_CONSUMED_HREFS + _AC_IGNORED)]

custom_components/localthings/registry/capabilities/common.py

@@ -21,16 +21,29 @@ def _num(v):
         return None
 
 
-def _clamp_power(v):
+def clamp_power(v):
     n = _num(v)
     return 0.0 if (n is not None and n < 0) else n
 
 
-def _wh_to_kwh(v):
+def wh_to_kwh(v):
     n = _num(v)
     return round(n / 1000.0, 2) if n is not None else None
 
 
+def normalize_temp_unit(raw, default='°F'):
+    """'C'/'Celsius' -> '°C', 'F'/'Fahrenheit' -> '°F'. Falls back to
+    `default` for any other/missing value. Shared by fridge.py and oven.py,
+    both of which read a per-device unit off a `/temperature*` resource
+    instead of assuming one (see fridge.py's module docstring, issue #7)."""
+    raw = (raw or '').strip().upper()
+    if raw.startswith('C'):
+        return '°C'
+    if raw.startswith('F'):
+        return '°F'
+    return default
+
+
 def _ml_to_l(v):
     n = _num(v)
     return round(n / 1000.0, 1) if n is not None else None
@@ -43,8 +56,57 @@ def _active_alarm_codes(items):
     return ', '.join(codes) if codes else 'none'
 
 
-KIDS_LOCK = Capability(
+# OCF-native / vendor '-vs' fallback pairs for power, kids-lock, remote control.
+#
+# These three controls exist as both a standard OCF resource (/power/0,
+# oic.r.switch.binary, plain boolean 'value') and a Samsung vendor resource
+# (/power/vs/0, x.com.samsung.da.power) -- Samsung advertises both as its
+# firmware migrates onto the OCF standard model. Prefer the OCF-standard href
+# when the device exposes it; the '-vs' href (a string-encoded duplicate for
+# these three) binds only when the generic href is absent, via match_fn. Older
+# firmware has only the '-vs' resource, so the pair is behaviour-identical to a
+# lone '-vs' cap there. See the adding-device-support skill's "OCF-standard vs
+# vendor" section for why this is preferred-non-vs-with-fallback, not a blanket
+# choice. Every device registry lists both caps of each pair.
+
+POWER_GENERIC = Capability(
+    href='/power/0',
+    entities=(
+        SwitchDesc(key='power_switch', field='value',
+                   name='Power',
+                   value_fn=lambda v: bool(v),
+                   write_fn=lambda p, rep, href=None: (
+                       ['power', '0'], {'value': p == 'On'})),
+    ),
+)
+
+POWER_VS_FALLBACK = Capability(
+    href='/power/vs/0',
+    match_fn=lambda rep, resources: '/power/0' not in resources,
+    entities=(
+        SwitchDesc(key='power_switch', field='x.com.samsung.da.power',
+                   name='Power',
+                   value_fn=lambda v: v == 'On',
+                   write_fn=lambda p, rep, href=None: (
+                       ['power', 'vs', '0'],
+                       {'x.com.samsung.da.power': 'On' if p == 'On' else 'Off'})),
+    ),
+)
+
+KIDS_LOCK_GENERIC = Capability(
+    href='/kidslock/0',
+    entities=(
+        SwitchDesc(key='child_lock', field='value',
+                   name='Child lock', device_class='lock',
+                   value_fn=lambda v: bool(v),
+                   write_fn=lambda p, rep, href=None: (
+                       ['kidslock', '0'], {'value': p == 'On'})),
+    ),
+)
+
+KIDS_LOCK_VS_FALLBACK = Capability(
     href='/kidslock/vs/0',
+    match_fn=lambda rep, resources: '/kidslock/0' not in resources,
     entities=(
         SwitchDesc(key='child_lock', field='x.com.samsung.da.kidsLock',
                    name='Child lock', device_class='lock',
@@ -55,8 +117,18 @@ KIDS_LOCK = Capability(
     ),
 )
 
-REMOTE_CONTROL = Capability(
+REMOTE_CONTROL_GENERIC = Capability(
+    href='/remotectrl/0',
+    entities=(
+        BinarySensorDesc(key='remote_control', field='value',
+                         name='Smart Control', device_class='connectivity',
+                         value_fn=lambda v: bool(v)),
+    ),
+)
+
+REMOTE_CONTROL_VS_FALLBACK = Capability(
     href='/remotectrl/vs/0',
+    match_fn=lambda rep, resources: '/remotectrl/0' not in resources,
     entities=(
         BinarySensorDesc(key='remote_control',
                          field='x.com.samsung.da.remoteControlEnabled',
@@ -65,16 +137,6 @@ REMOTE_CONTROL = Capability(
     ),
 )
 
-POWER = Capability(
-    href='/power/vs/0',
-    entities=(
-        SwitchDesc(key='power_switch', field='x.com.samsung.da.power',
-                   name='Power',
-                   value_fn=lambda v: v == 'On',
-                   write_fn=lambda p, rep, href=None: (['power', 'vs', '0'], {'x.com.samsung.da.power': 'On' if p == 'On' else 'Off'})),
-    ),
-)
-
 ALARMS = Capability(
     href='/alarms/vs/0',
     poll_tier='hot',
@@ -85,15 +147,34 @@ ALARMS = Capability(
     ),
 )
 
+# instantaneousPower is a dead field on DA_WM_-class laundry dumps (washers and
+# the issue #14 dryer) and on dishwashers too: the literal sentinel '-500',
+# unchanged across off/idle/running. clamp_power floors it to a misleading
+# "0 W" that reads as a real idle measurement. Gate power_watts out when the
+# sentinel is seen -- but only then, so a device reporting a real value (e.g. a
+# fridge's 93 W) still shows it (issue #6). cumulativePower is absent on at
+# least one washer model; the exists_fn makes that explicit rather than relying
+# on the generic field-presence gate.
+_DEAD_INSTANTANEOUS_POWER = '-500'
+
 ENERGY_METER = Capability(
     href='/energy/consumption/vs/0',
     entities=(
+        # `not rep` keeps the empty-{} stub carve-out (see entity._is_included):
+        # an explicit exists_fn otherwise bypasses it, which would drop the
+        # entity when /device/0 returns a not-yet-fetched stub. On a populated
+        # rep, hide power only for the dead sentinel or an absent field.
         SensorDesc(key='power_watts', field='x.com.samsung.da.instantaneousPower',
                    name='Power', device_class='power', state_class='measurement',
-                   unit='W', value_fn=_clamp_power),
+                   unit='W', value_fn=clamp_power,
+                   exists_fn=lambda rep, resources: not rep or (
+                       rep.get('x.com.samsung.da.instantaneousPower')
+                       not in (None, _DEAD_INSTANTANEOUS_POWER))),
         SensorDesc(key='energy_kwh', field='x.com.samsung.da.cumulativePower',
                    name='Energy', device_class='energy',
-                   state_class='total_increasing', unit='kWh', value_fn=_wh_to_kwh),
+                   state_class='total_increasing', unit='kWh', value_fn=wh_to_kwh,
+                   exists_fn=lambda rep, resources: (
+                       not rep or 'x.com.samsung.da.cumulativePower' in rep)),
     ),
 )
 

custom_components/localthings/registry/capabilities/dishwasher.py

@@ -1,9 +1,14 @@
 """Capabilities specific to dishwasher appliances (DW9000F-class).
 
 Resources verified against the live device dump at 10.0.0.129.
+
+The /course/vs/0 cycle select and its options-array machinery are shared with
+washer and dryer in laundry.py; only the dishwasher-specific options (storm
+wash, auto release dry) are read locally here.
 """
 from ..capability import Capability
 from ..entities import ButtonDesc, SelectDesc, SensorDesc, SwitchDesc
+from .laundry import cycle_select, option_value, replace_in_options
 
 # ---------------------------------------------------------------------------
 # /dishwasher/vs/0 — cycle wash/dry settings
@@ -28,63 +33,12 @@ DISHWASHER_SETTINGS = Capability(
 )
 
 # ---------------------------------------------------------------------------
-# /course/vs/0 — cycle selection and course options (RMW on options array)
+# /course/vs/0 — cycle selection (shared laundry.cycle_select) plus the
+# dishwasher-only StormWashZone / AutoDoorRelease toggles that ride in the
+# same options array. Course display names live in translations under
+# entity.select.dishwasher_cycle (see laundry.cycle_select).
 # ---------------------------------------------------------------------------
 
-# Course IDs are uppercase hex strings matching the Course_XX encoding in
-# options[]. Display names are not kept here -- they live in
-# strings.json/translations under entity.select.dishwasher_cycle.state.<id,
-# lowercased>, same as every other device-enum select in this integration
-# (see fridge.py's translation_key entities and select.py's _display()), so
-# they can be localized instead of hardcoded to English.
-#
-# No static fallback list is kept here -- a hardcoded course table would
-# show options a given dishwasher model doesn't actually have (or hide ones
-# it does). The only trustworthy per-device source is the live
-# x.com.samsung.da.editCourseList on /wm/editcourse/vs/0. When that's
-# absent (e.g. never populated until the app's course-edit screen has been
-# opened at least once), the cycle select isn't created at all -- see
-# CYCLE_OPTIONS's exists_fn below. (x.com.samsung.da.options' MostUsed_*
-# entry was considered as a second fallback source, but its bytes beyond
-# the first don't correspond to any confirmed course code on hardware we
-# have dumps for, so it isn't trustworthy either -- see washer.py's
-# _cycle_options docstring for the byte-level evidence.)
-
-
-def _parse_edit_course_list(raw):
-    """'EditCourseList_0E07908683848D808E8F' -> ['0E', '07', ...]."""
-    if not isinstance(raw, str) or '_' not in raw:
-        return []
-    codes = raw.split('_', 1)[1]
-    return [codes[i:i + 2] for i in range(0, len(codes) - 1, 2)]
-
-
-def _cycle_options(resources):
-    rep = resources.get('/wm/editcourse/vs/0') or {}
-    return _parse_edit_course_list(rep.get('x.com.samsung.da.editCourseList'))
-
-
-def _option_value(options, prefix):
-    """Find `<prefix>_<value>` in options array and return <value>."""
-    for o in (options or []):
-        if isinstance(o, str) and o.startswith(prefix + '_'):
-            return o.split('_', 1)[1]
-    return None
-
-
-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]
-
-
-def _cycle_write(p, rep, href=None):
-    opts = list(rep.get('x.com.samsung.da.options') or [])
-    if not opts:
-        return None
-    return ['course', 'vs', '0'], {
-        'x.com.samsung.da.options': _replace_in_options(opts, 'Course', p),
-    }
-
 
 def _storm_wash_write(p, rep, href=None):
     if p not in ('On', 'Off'):
@@ -93,7 +47,7 @@ def _storm_wash_write(p, rep, href=None):
     if not opts:
         return None
     return ['course', 'vs', '0'], {
-        'x.com.samsung.da.options': _replace_in_options(opts, 'StormWashZone', p),
+        'x.com.samsung.da.options': replace_in_options(opts, 'StormWashZone', p),
     }
 
 
@@ -104,22 +58,16 @@ def _auto_release_write(p, rep, href=None):
     if not opts:
         return None
     return ['course', 'vs', '0'], {
-        'x.com.samsung.da.options': _replace_in_options(opts, 'AutoDoorRelease', p),
+        'x.com.samsung.da.options': replace_in_options(opts, 'AutoDoorRelease', p),
     }
 
 
 CYCLE_OPTIONS = Capability(
     href='/course/vs/0',
     entities=(
-        SelectDesc(key='cycle', name='Cycle', icon='mdi:dishwasher',
-                   translation_key='dishwasher_cycle',
-                   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'),
-                   write_fn=_cycle_write),
+        cycle_select(translation_key='dishwasher_cycle', icon='mdi:dishwasher'),
         SwitchDesc(key='storm_wash', name='Storm Wash+', icon='mdi:weather-lightning-rainy',
-                   rep_fn=lambda rep: _option_value(
+                   rep_fn=lambda rep: option_value(
                        rep.get('x.com.samsung.da.options'), 'StormWashZone') == 'On',
                    write_fn=_storm_wash_write),
         SwitchDesc(key='auto_release_dry', name='Auto release dry', icon='mdi:door-open',
@@ -127,7 +75,7 @@ CYCLE_OPTIONS = Capability(
                        isinstance(o, str) and o.startswith('AutoDoorRelease_')
                        for o in (rep.get('x.com.samsung.da.options') or [])
                    ),
-                   rep_fn=lambda rep: _option_value(
+                   rep_fn=lambda rep: option_value(
                        rep.get('x.com.samsung.da.options'), 'AutoDoorRelease') == 'On',
                    write_fn=_auto_release_write),
     ),

custom_components/localthings/registry/capabilities/dryer.py

@@ -1,37 +1,16 @@
-"""Capabilities specific to the dryer family (Samsung DV5000T-class).
+"""Capabilities specific to the dryer family (Samsung DA_WM_TP1/TP2-class).
 
-Resources derived from the old dryer.py descriptor OBSERVE_PATHS and
-flatten() implementation:
-  /washer/vs/0              -> DRYER_SETTINGS (dryLevel, dryTime, dryerType, wrinklePrevent)
-  /st/dryercourse/vs/0      -> DRYER_COURSE (dryer_mode SelectDesc)
-  /wm/jobbeginingstatus/vs/0 -> JOB_BEGINNING_STATUS
-  /diagnosis/vs/0           -> DRYER_DIAGNOSIS
+Dryer-specific controls only. The shared laundry surface -- power/kids-lock/
+remote-control fallback pairs, buzzer, energy meter, job-beginning-status, and
+the /course/vs/0 cycle select -- lives in laundry.py.
 
-Course table captured 2026-05-29 on a DA_WM_TP2_20_COMMON_DV5000T. Other
-dryer models may use a different course table; options=() means HA renders
-whatever the device reports, and the write_fn validates against this table.
+  /washer/vs/0   -> DRYER_SETTINGS (dryLevel, dryTime, dryerType, wrinklePrevent)
+  /course/vs/0   -> DRYER_COURSE (shared cycle select; see below)
+  /diagnosis/vs/0 -> DRYER_DIAGNOSIS
 """
 from ..capability import Capability
-from ..entities import SelectDesc, SensorDesc, SwitchDesc
-
-# Course table: hex codes -> human names (Table_03, DV5000T-class).
-_COURSE_NAMES = {
-    0x16: 'Cotton',
-    0x18: 'Synthetics',
-    0x19: 'Delicates',
-    0x1A: 'Wool',
-    0x1B: 'Bedding',
-    0x1C: 'Shirts',
-    0x1D: 'Towels',
-    0x1E: 'Outdoor',
-    0x1F: 'Mixed Load',
-    0x20: 'Iron Dry',
-    0x23: 'Quick Dry 35',
-    0x24: 'Cool Air',
-    0x25: 'Warm Air',
-    0x27: 'Time Dry',
-}
-_COURSE_CODE_BY_NAME = {name: code for code, name in _COURSE_NAMES.items()}
+from ..entities import SensorDesc, SwitchDesc
+from .laundry import cycle_select
 
 
 def _wrinkle_write(p, rep, href=None):
@@ -40,20 +19,6 @@ def _wrinkle_write(p, rep, href=None):
     return ['washer', 'vs', '0'], {'x.com.samsung.da.wrinklePrevent': p}
 
 
-def _course_write(p, rep, href=None):
-    """Encode a human course name to the Samsung hex-encoded course string."""
-    code = _COURSE_CODE_BY_NAME.get(p)
-    if code is None:
-        return None
-    return ['st', 'dryercourse', 'vs', '0'], {
-        'x.com.samsung.da.st.dryerMode': f'Course_{code:02X}',
-    }
-
-
-# ---------------------------------------------------------------------------
-# Capabilities
-# ---------------------------------------------------------------------------
-
 DRYER_SETTINGS = Capability(
     href='/washer/vs/0',
     poll_tier='warm',
@@ -71,28 +36,19 @@ DRYER_SETTINGS = Capability(
     ),
 )
 
+# /course/vs/0 -- cycle selection, shared with washer/dishwasher via
+# laundry.cycle_select (options read live from /wm/editcourse/vs/0, written as
+# an RMW on the options array). Course display names live in translations
+# under entity.select.dryer_cycle (Table_03, DV5000-class, captured
+# 2026-05-29). Codes 0x21 and 0x4C appear in the issue #14 DV90BB5245AES1
+# editCourseList but aren't identified yet -- they render as the raw code
+# until named. The /st/dryercourse/vs/0 resource re-encodes the same selected
+# course and is ignored (ignored.py) -- the mirror of how /st/washercourse/vs/0
+# is ignored for washers.
 DRYER_COURSE = Capability(
-    href='/st/dryercourse/vs/0',
-    poll_tier='warm',
+    href='/course/vs/0',
     entities=(
-        SelectDesc(key='dryer_mode', field='x.com.samsung.da.st.dryerMode',
-                   name='Dryer mode', icon='mdi:tumble-dryer',
-                   options=tuple(_COURSE_CODE_BY_NAME),
-                   value_fn=lambda v: _COURSE_NAMES.get(
-                       int(v.split('_')[1], 16) if isinstance(v, str) and '_' in v else -1
-                   ),
-                   write_fn=_course_write),
-    ),
-)
-
-JOB_BEGINNING_STATUS = Capability(
-    href='/wm/jobbeginingstatus/vs/0',
-    poll_tier='warm',
-    entities=(
-        SensorDesc(key='job_beginning_status',
-                   field='x.com.samsung.da.jobBeginingStatus',
-                   name='Job beginning status',
-                   entity_category='diagnostic'),
+        cycle_select(translation_key='dryer_cycle', icon='mdi:tumble-dryer'),
     ),
 )
 

custom_components/localthings/registry/capabilities/fridge.py

@@ -2,9 +2,13 @@
 
 Resources verified against the dump at local-tools/dumps/10.0.0.254.json.
 
-Temperature fields in all /temperature/* resources are in Fahrenheit on this
-model. Setpoints are NumberDesc with direct-write write_fn — generic caps
-derive the CoAP PUT path from href at write time.
+Temperature unit is read live from each resource, not assumed: the RF9000B
+dump reports Fahrenheit ("units": "F" / "x.com.samsung.da.unit": "Fahrenheit"),
+but a TP1X_REF_21K dump (issue #7) reports the same fields in Celsius for the
+exact same resources — the device tells you which one it is, it's just never
+been read before. See `_temp_unit`/`_temp_item_unit` below. Setpoints are
+NumberDesc with direct-write write_fn — generic caps derive the CoAP PUT path
+from href at write time.
 
 Multi-instance note: the two door resources (/door/cooler/0 and
 /door/freezer/0) and the two ice-maker resources (/icemaker/one/vs/0 and
@@ -18,6 +22,7 @@ from ..entities import (
     BinarySensorDesc, ButtonDesc, NumberDesc, SelectDesc, SensorDesc,
     SwitchDesc, TimeDesc,
 )
+from .common import normalize_temp_unit
 
 # Display names for the beverage zone, flex zone, ice type, and
 # ice-making-status enums below live in strings.json / translations/en.json,
@@ -33,6 +38,12 @@ def _int(v):
         return None
 
 
+def _temp_unit(rep):
+    """'units': 'C'/'F' (or 'Celsius'/'Fahrenheit') -> '°C'/'°F'. Defaults to
+    °F (this module's original assumption) if the device omits the field."""
+    return normalize_temp_unit(rep.get('units'))
+
+
 # ---------------------------------------------------------------------------
 # Temperature (generic — covers /temperature/current/* and /temperature/desired/*)
 # ---------------------------------------------------------------------------
@@ -45,7 +56,7 @@ TEMP_CURRENT_GENERIC = Capability(
     entities=(
         SensorDesc(key='temperature', field='temperature',
                    name=None, icon='mdi:thermometer',
-                   device_class='temperature', unit='°F',
+                   device_class='temperature', unit_fn=_temp_unit,
                    state_class='measurement'),
     ),
 )
@@ -57,7 +68,7 @@ TEMP_SETPOINT_GENERIC = Capability(
     poll_tier='warm',
     entities=(
         NumberDesc(key='setpoint', field='temperature',
-                   name=None, device_class='temperature', unit='°F',
+                   name=None, device_class='temperature', unit_fn=_temp_unit,
                    native_min=-20.0, native_max=50.0,
                    range_field='range', entity_category='config',
                    write_fn=lambda p, rep, href=None: (
@@ -172,12 +183,16 @@ STATUS_LOCK = Capability(
 )
 
 # ---------------------------------------------------------------------------
-# Defrost delay
+# Defrost delay / active-defrost status
 #
-# /defrost/delay/vs/0 is the writable toggle. /defrost/block/vs/0 just
-# reports whether the defrost cycle is currently blocked as a result (a
-# derived status, not an independent control) — exposed as a read-only
-# diagnostic binary sensor.
+# /defrost/delay/vs/0 is the writable toggle to postpone a scheduled
+# defrost. /defrost/block/vs/0 is an unrelated, independently-varying
+# status: despite its "block" naming (originally assumed to mean "defrost
+# is being withheld"), live dumps confirm DEFROST_BLOCK_ON means the
+# defrost cycle is *actively running* right now, seen with defrost_delay
+# off -- i.e. "block" refers to the evaporator/coil block being defrosted,
+# not a blocking/prevention state. Exposed as a read-only diagnostic
+# binary sensor.
 # ---------------------------------------------------------------------------
 
 DEFROST_DELAY = Capability(
@@ -198,8 +213,8 @@ DEFROST_BLOCK_STATUS = Capability(
     href='/defrost/block/vs/0',
     poll_tier='warm',
     entities=(
-        BinarySensorDesc(key='defrost_blocked', field='x.com.samsung.da.modes',
-                         name='Defrost blocked', icon='mdi:snowflake-off',
+        BinarySensorDesc(key='defrost_active', field='x.com.samsung.da.modes',
+                         name='Defrost active', icon='mdi:snowflake-melt',
                          entity_category='diagnostic',
                          value_fn=lambda modes: bool(modes) and modes[0] == 'DEFROST_BLOCK_ON'),
     ),
@@ -590,6 +605,13 @@ def _temp_item_value(items, keyword):
     return None
 
 
+def _temp_item_unit(items, keyword):
+    for item in (items or []):
+        if keyword.lower() in (item.get('x.com.samsung.da.description') or '').lower():
+            return normalize_temp_unit(item.get('x.com.samsung.da.unit'))
+    return '°F'
+
+
 TEMPERATURES_FALLBACK = Capability(
     href='/temperatures/vs/0',
     match_fn=lambda rep, resources: not _any_temperature_generic(resources),
@@ -597,11 +619,15 @@ TEMPERATURES_FALLBACK = Capability(
     entities=(
         SensorDesc(key='freezer_temperature', field='x.com.samsung.da.items',
                    name='Freezer temperature', icon='mdi:thermometer',
-                   device_class='temperature', unit='°F', state_class='measurement',
+                   device_class='temperature', state_class='measurement',
+                   unit_fn=lambda rep: _temp_item_unit(
+                       rep.get('x.com.samsung.da.items'), 'Freezer'),
                    value_fn=lambda items: _temp_item_value(items, 'Freezer')),
         SensorDesc(key='fridge_temperature', field='x.com.samsung.da.items',
                    name='Fridge temperature', icon='mdi:thermometer',
-                   device_class='temperature', unit='°F', state_class='measurement',
+                   device_class='temperature', state_class='measurement',
+                   unit_fn=lambda rep: _temp_item_unit(
+                       rep.get('x.com.samsung.da.items'), 'Fridge'),
                    value_fn=lambda items: _temp_item_value(items, 'Fridge')),
     ),
 )
@@ -628,3 +654,34 @@ ICEMAKER_STATUS_FALLBACK = Capability(
                        {'x.com.samsung.da.iceMaker': 'On' if p else 'Off'})),
     ),
 )
+
+# OCF-native /refrigeration/0 (issue #7's unbound_hrefs) -- the odd one out
+# in this section: its three fields duplicate two *different* richer
+# hrefs (REFRIGERATION's rapidFridge/rapidFreezing and
+# DEFROST_BLOCK_STATUS's defrost_active), each absent independently, so a
+# single capability-level match_fn can't express it. Gated per-entity
+# (exists_fn) instead: rapid_fridge/rapid_freezing back off only when
+# REFRIGERATION's href is present; defrost_active only when
+# DEFROST_BLOCK_STATUS's is. No write path confirmed for this href, so
+# these are read-only, unlike REFRIGERATION's switches.
+REFRIGERATION_FALLBACK = Capability(
+    href='/refrigeration/0',
+    poll_tier='warm',
+    entities=(
+        BinarySensorDesc(key='defrost_active', field='defrost',
+                         name='Defrost active', icon='mdi:snowflake-melt',
+                         entity_category='diagnostic',
+                         value_fn=lambda v: bool(v),
+                         exists_fn=lambda rep, resources: '/defrost/block/vs/0' not in resources),
+        BinarySensorDesc(key='rapid_fridge', field='rapidCool',
+                         name='Rapid fridge', icon='mdi:fridge-industrial',
+                         entity_category='config',
+                         value_fn=lambda v: bool(v),
+                         exists_fn=lambda rep, resources: '/refrigeration/vs/0' not in resources),
+        BinarySensorDesc(key='rapid_freezing', field='rapidFreeze',
+                         name='Rapid freezing', icon='mdi:snowflake',
+                         entity_category='config',
+                         value_fn=lambda v: bool(v),
+                         exists_fn=lambda rep, resources: '/refrigeration/vs/0' not in resources),
+    ),
+)

custom_components/localthings/registry/capabilities/ignored.py

@@ -89,6 +89,11 @@ IGNORED: list[Capability] = [
     # supportedAiLevel on hardware seen so far, so there's no real choice
     # to expose. Revisit if a device surfaces more than one supported level.
     Capability(href='/energy/ailevel/vs/0'),
+    # OCF-native vacation-mode flag (fridge). Only one value ('RVACATION_OFF')
+    # has ever been seen in `modes` (issue #7's dump), same "no real choice
+    # to expose yet" situation as /energy/ailevel/vs/0 above. Revisit if a
+    # device surfaces it toggled on.
+    Capability(href='/mode/0'),
     # Opaque integer with no supportedModes/options list to interpret it
     # against — meaning unclear from the raw resource alone.
     Capability(href='/runningmode/vs/0'),
@@ -103,6 +108,10 @@ IGNORED: list[Capability] = [
     # washer.WASHER_COURSE at /course/vs/0 (x.com.samsung.da.st.washerMode
     # is literally "Table_02_Course_<same hex code>").
     Capability(href='/st/washercourse/vs/0'),
+    # Dryer counterpart of the above: re-encoding of the course already
+    # exposed by dryer.DRYER_COURSE at /course/vs/0
+    # (x.com.samsung.da.st.dryerMode is "Table_03_Course_<same hex code>").
+    Capability(href='/st/dryercourse/vs/0'),
     # Empty on every washer dump seen so far.
     Capability(href='/wm/welcomemsg/vs/0'),
     # User-saved custom course slots (F1-FA). No controllable/observable

custom_components/localthings/registry/capabilities/laundry.py

@@ -1,13 +1,28 @@
-"""Capabilities specific to the laundry-family appliances (dishwasher, dryer).
+"""Capabilities shared across the laundry family (washer, dryer, dishwasher).
 
-Resources verified against the DW9000F-class dump at 10.0.0.129.
-Note: door-LED keys use NO `x.com.samsung.da.` prefix — `setBrightness` and
-`setNightLight` — preserved exactly as they appear in the OCF resource rep.
+Anything here is bound by more than one laundry registry, so it lives in one
+place instead of being copied per family. Device-type-specific controls (wash
+temperature, dry level, dishwasher storm-wash, etc.) stay in washer.py /
+dryer.py / dishwasher.py; only the genuinely shared laundry surface is here.
+
+Generic OCF controls that aren't laundry-specific (power, kids-lock, remote
+control, energy meter) live in common.py, not here.
+
+Resource hrefs seen across laundry dumps:
+  /doorled/light/vs/0   -> DOOR_LED (door LED brightness / night light)
+  /settings/sound/*/vs/0-> SOUND_MODE / SOUND_VOLUME
+  /buzzersound/vs/0     -> BUZZER_SOUND (buzzer + optional finish chime)
+  /course/vs/0          -> the cycle select + per-family course options
+  /wm/editcourse/vs/0   -> live editCourseList that drives the cycle options
+  /wm/jobbeginingstatus/vs/0 -> JOB_BEGINNING_STATUS
+
+Door-LED keys use NO `x.com.samsung.da.` prefix -- `setBrightness` /
+`setNightLight` -- preserved exactly as they appear in the OCF resource rep.
 """
 from datetime import time as dt_time
 
 from ..capability import Capability
-from ..entities import NumberDesc, SelectDesc, SwitchDesc, TimeDesc
+from ..entities import NumberDesc, SelectDesc, SensorDesc, SwitchDesc, TimeDesc
 
 _LED_LEVELS = ('Low', 'High')
 _SOUND_MODES = ('voice', 'tone', 'mute')
@@ -100,3 +115,124 @@ SOUND_VOLUME = Capability(
                        {'level': str(int(p))})),
     ),
 )
+
+# ---------------------------------------------------------------------------
+# /buzzersound/vs/0 -- buzzer volume and (on some units) a separate finish
+# chime. Fields have no 'x.com.samsung.da.' prefix in this resource. Seen on
+# washers and DA_WM_TP1 dryers; the dryer dump carries only setBuzzerSound
+# (no supportedFinishSound), so finish_sound self-gates off there.
+# ---------------------------------------------------------------------------
+
+BUZZER_SOUND = Capability(
+    href='/buzzersound/vs/0',
+    entities=(
+        SelectDesc(key='buzzer_sound', field='setBuzzerSound',
+                   name='Buzzer sound', icon='mdi:volume-high',
+                   entity_category='config',
+                   options_field='supportedBuzzerSound',
+                   write_fn=lambda p, rep, href=None: (
+                       ['buzzersound', 'vs', '0'], {'setBuzzerSound': p})),
+        SelectDesc(key='finish_sound', field='setFinishSound',
+                   name='Finish sound', icon='mdi:bell-ring',
+                   entity_category='config',
+                   exists_fn=lambda rep, resources: 'supportedFinishSound' in rep,
+                   options_field='supportedFinishSound',
+                   write_fn=lambda p, rep, href=None: (
+                       ['buzzersound', 'vs', '0'], {'setFinishSound': p})),
+    ),
+)
+
+# ---------------------------------------------------------------------------
+# Cycle selection over /course/vs/0.
+#
+# The selected course and every other user-tunable option ride in the
+# x.com.samsung.da.options array on /course/vs/0 as `<Prefix>_<value>` tokens;
+# a write is a read-modify-write of that whole array (cycle_write). The set of
+# *selectable* courses is not hardcoded -- it's read live from
+# x.com.samsung.da.editCourseList on /wm/editcourse/vs/0 (cycle_options), so we
+# never show a course a given model doesn't have or hide one it does. Course
+# codes are uppercase hex; display names live in translations under
+# entity.select.<translation_key>.state.<id lowercased> so they can be
+# localized -- every device-enum select in this integration works this way.
+# washer.py's course comment has the byte-level evidence for why the options[]
+# MostUsed_* entry is *not* a trustworthy second source.
+#
+# Shared verbatim by washer, dishwasher, and dryer -- all DA_WM_-family boards
+# expose the same /course/vs/0 options contract.
+# ---------------------------------------------------------------------------
+
+
+def hex_pairs(codes):
+    """'1C1D21...' -> ['1C', '1D', '21', ...]."""
+    return [codes[i:i + 2] for i in range(0, len(codes) - 1, 2)]
+
+
+def parse_edit_course_list(raw):
+    """'EditCourseList_1C1D21...' -> ['1C', '1D', '21', ...]."""
+    if not isinstance(raw, str) or '_' not in raw:
+        return []
+    return hex_pairs(raw.split('_', 1)[1])
+
+
+def cycle_options(resources):
+    rep = resources.get('/wm/editcourse/vs/0') or {}
+    return parse_edit_course_list(rep.get('x.com.samsung.da.editCourseList'))
+
+
+def option_value(options, prefix):
+    """Find `<prefix>_<value>` in the options array and return <value>."""
+    for o in (options or []):
+        if isinstance(o, str) and o.startswith(prefix + '_'):
+            return o.split('_', 1)[1]
+    return None
+
+
+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]
+
+
+def cycle_write(p, rep, href=None):
+    opts = list(rep.get('x.com.samsung.da.options') or [])
+    if not opts:
+        return None
+    return ['course', 'vs', '0'], {
+        'x.com.samsung.da.options': replace_in_options(opts, 'Course', p),
+    }
+
+
+def cycle_select(*, translation_key, icon):
+    """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.
+    """
+    return SelectDesc(
+        key='cycle', name='Cycle', icon=icon, translation_key=translation_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'),
+        write_fn=cycle_write,
+    )
+
+
+# ---------------------------------------------------------------------------
+# /wm/jobbeginingstatus/vs/0 -- the "why did the cycle not start" reason
+# (e.g. door open, no water). The vendor field is x.com.samsung.da.currentStatus
+# on every laundry dump that populates it (washer + DA_WM_TP1 dryer). An
+# earlier dryer descriptor read x.com.samsung.da.jobBeginingStatus, but no dump
+# ever carried that field, so the dryer sensor was always blank -- fixed by
+# sharing this one reader.
+# ---------------------------------------------------------------------------
+
+JOB_BEGINNING_STATUS = Capability(
+    href='/wm/jobbeginingstatus/vs/0',
+    poll_tier='warm',
+    entities=(
+        SensorDesc(key='job_beginning_status',
+                   field='x.com.samsung.da.currentStatus',
+                   name='Job beginning status',
+                   entity_category='diagnostic'),
+    ),
+)

custom_components/localthings/registry/capabilities/operational.py

@@ -75,7 +75,9 @@ OPERATIONAL_STATE = Capability(
     poll_tier='hot',
     entities=(
         SensorDesc(key='machine_state', field='x.com.samsung.da.state',
-                   name='Machine state', value_fn=_to_ocf),
+                   name='Machine state', device_class='enum',
+                   options=('idle', 'active', 'pause'),
+                   translation_key='machine_state', value_fn=_to_ocf),
         # cycle_active is a bool derived from machine_state; used by the
         # adapter to gate oven writes (cycle_active_field='cycle_active').
         # Harmless for non-oven appliances — just an extra bool in state.
@@ -93,9 +95,11 @@ OPERATIONAL_STATE = Capability(
                        else _progress(rep.get('x.com.samsung.da.progress'))
                    )),
         SensorDesc(key='progress_percentage',
-                   field='x.com.samsung.da.progressPercentage',
                    name='Progress percent', unit='%', state_class='measurement',
-                   value_fn=_int),
+                   rep_fn=lambda rep: (
+                       0 if _SAMSUNG_STATE_TO_OCF.get(rep.get('x.com.samsung.da.state')) != 'active'
+                       else _int(rep.get('x.com.samsung.da.progressPercentage'))
+                   )),
         # Only show finish time when machine is actively running. Samsung
         # firmware leaves a stale remainingTime after a cycle ends, and
         # freezes it at '00:01:00' when progress reaches 'Finish'.

custom_components/localthings/registry/capabilities/oven.py

@@ -29,6 +29,7 @@ from ..entities import (
     BinarySensorDesc, ButtonDesc, NumberDesc, SelectDesc, SensorDesc,
     SwitchDesc,
 )
+from .common import normalize_temp_unit
 
 # ---------------------------------------------------------------------------
 # Constants
@@ -222,7 +223,9 @@ OVEN_OPERATIONAL_STATE = Capability(
     poll_tier='hot',
     entities=(
         SensorDesc(key='machine_state', field='x.com.samsung.da.state',
-                   name='Machine state', icon='mdi:stove', value_fn=_to_ocf),
+                   name='Machine state', icon='mdi:stove',
+                   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',
                          value_fn=lambda v: _SAMSUNG_STATE_TO_OCF.get(v) == 'active'),
@@ -255,13 +258,26 @@ OVEN_CAVITY = Capability(
     ),
 )
 
+def _oven_temp_unit(rep):
+    """Same shape/risk as fridge.py's TEMPERATURES_FALLBACK: this is the
+    same aggregate `/temperatures/vs/0` items[] resource type, which on
+    fridge hardware carries a per-item `x.com.samsung.da.unit` field
+    ('Celsius'/'Fahrenheit') that was previously hardcoded away (issue #7).
+    No live oven dump has surfaced a non-Celsius reading yet, so this keeps
+    the verified '°C' default when the field is absent, but reads it live
+    if a device ever reports otherwise."""
+    items = rep.get('x.com.samsung.da.items') or []
+    unit = items[0].get('x.com.samsung.da.unit') if items else None
+    return normalize_temp_unit(unit, default='°C')
+
+
 OVEN_SETPOINT = Capability(
     href='/temperatures/vs/0',
     poll_tier='hot',
     entities=(
         # NumberDesc first — test_oven_setpoint_write_is_read_modify_write uses entities[0]
         NumberDesc(key='oven_setpoint', field='x.com.samsung.da.items',
-                   name='Setpoint', device_class='temperature', unit='°C',
+                   name='Setpoint', device_class='temperature', unit_fn=_oven_temp_unit,
                    native_min=float(SETPOINT_MIN_C), native_max=float(SETPOINT_MAX_C),
                    step=float(SETPOINT_STEP_C), icon='mdi:thermometer-chevron-up',
                    value_fn=lambda items: _int(
@@ -269,7 +285,7 @@ OVEN_SETPOINT = Capability(
                    write_fn=_oven_setpoint_write),
         SensorDesc(key='current_temp_c', field='x.com.samsung.da.items',
                    name='Temperature', device_class='temperature',
-                   state_class='measurement', unit='°C',
+                   state_class='measurement', unit_fn=_oven_temp_unit,
                    value_fn=lambda items: _int(
                        (items[0].get('x.com.samsung.da.current') if items else None))),
     ),

custom_components/localthings/registry/capabilities/washer.py

@@ -5,9 +5,19 @@ Resources verified against two live WW90DG6U25LEU4 dumps (Table_02 course
 family). Washers never report `oneUiVersion` -- see
 `registry/by_type/__init__.py`'s `for_device_by_model()` for the fallback
 detection this device type requires.
+
+The shared laundry surface -- power/kids-lock/remote-control OCF+vendor
+fallback pairs, buzzer, energy meter, job-beginning-status, and the
+/course/vs/0 cycle-select machinery -- lives in laundry.py. Only washer-
+specific controls (wash settings, drum-clean tracking, dispenser dosing) are
+here; they read washer-only fields off the same shared /course/vs/0 options
+array.
 """
+from datetime import datetime, timezone
+
 from ..capability import Capability
-from ..entities import BinarySensorDesc, SelectDesc, SensorDesc, SwitchDesc
+from ..entities import BinarySensorDesc, SelectDesc, SensorDesc
+from .laundry import cycle_select, hex_pairs, option_value, replace_in_options
 
 # ---------------------------------------------------------------------------
 # Course_XX hex codes. The 23 codes named in strings.json/translations
@@ -30,11 +40,11 @@ from ..entities import BinarySensorDesc, SelectDesc, SensorDesc, SwitchDesc
 # course, '65', isn't even in the list above; models with 'AI Wash'/'Mixed
 # Load' -- both "applicable models only" per the manual -- would have yet
 # another set), so hardcoding one device's list would show/hide the wrong
-# options on a different model. _cycle_options() below reads only the live
+# options on a different model. laundry.cycle_options() reads only the live
 # x.com.samsung.da.editCourseList; if a device doesn't populate that
-# resource, the cycle select isn't created at all (see WASHER_COURSE's
-# exists_fn). x.com.samsung.da.options' MostUsed_* entry was considered as
-# a fallback source (its first byte reliably equals the currently-selected
+# resource, the cycle select isn't created at all (see cycle_select's
+# exists_fn). x.com.samsung.da.options' MostUsed_* entry was considered as a
+# fallback source (its first byte reliably equals the currently-selected
 # Course_XX on both dumps we have), but the bytes after that don't
 # correspond to any confirmed course code on either device -- e.g. dump 1's
 # MostUsed_1C8410923FA67F00000000000000 decodes to
@@ -42,19 +52,6 @@ from ..entities import BinarySensorDesc, SelectDesc, SensorDesc, SwitchDesc
 # so it isn't trustworthy as a list of selectable courses and isn't used.
 # ---------------------------------------------------------------------------
 
-
-def _parse_edit_course_list(raw):
-    """'EditCourseList_1C1D211B1E29...' -> ['1C', '1D', '21', '1B', '1E', '29', ...]."""
-    if not isinstance(raw, str) or '_' not in raw:
-        return []
-    codes = raw.split('_', 1)[1]
-    return [codes[i:i + 2] for i in range(0, len(codes) - 1, 2)]
-
-
-def _cycle_options(resources):
-    rep = resources.get('/wm/editcourse/vs/0') or {}
-    return _parse_edit_course_list(rep.get('x.com.samsung.da.editCourseList'))
-
 # ---------------------------------------------------------------------------
 # /washer/vs/0 -- wash temperature, spin speed, rinse cycle count
 #
@@ -89,162 +86,193 @@ WASHER_SETTINGS = Capability(
 )
 
 # ---------------------------------------------------------------------------
-# /course/vs/0 -- selected course, read/write (RMW on the options array,
-# same shape as dishwasher.CYCLE_OPTIONS._cycle_write).
+# /course/vs/0 -- the cycle select is the shared laundry.cycle_select; the
+# drum-clean and dispenser-dosing entities below are washer-specific reads off
+# the same options array.
 # ---------------------------------------------------------------------------
 
-def _option_value(options, prefix):
-    for o in (options or []):
-        if isinstance(o, str) and o.startswith(prefix + '_'):
-            return o.split('_', 1)[1]
-    return None
 
-
-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]
-
-
-def _cycle_write(p, rep, href=None):
-    opts = list(rep.get('x.com.samsung.da.options') or [])
-    if not opts:
+# Drum Clean+ maintenance tracking, from the same options[] array as the
+# selected course. DrumCleanProposal_<N> is the wash-cycle interval between
+# recommended cleans; WashingTimes_<N> is the count since the last one --
+# their difference is exactly the "N cycles until due" figure the Samsung
+# app shows (verified: DrumCleanProposal_40 - WashingTimes_3 == 37, matching
+# a live app screenshot's "Potreba cistenia po 37 cykloch"). DrumCleanLog_
+# is the last-clean timestamp (verified against the same screenshot's "10
+# days ago"); no explicit timezone field accompanies it on this resource,
+# so it's treated as UTC, matching this integration's convention for other
+# bare ISO datetime fields (see fridge.py's night-light schedule comment).
+def _drum_clean_cycles_remaining(rep):
+    opts = rep.get('x.com.samsung.da.options') or []
+    proposal = option_value(opts, 'DrumCleanProposal')
+    washed = option_value(opts, 'WashingTimes')
+    if proposal is None or washed is None:
         return None
-    return ['course', 'vs', '0'], {
-        'x.com.samsung.da.options': _replace_in_options(opts, 'Course', p),
-    }
+    try:
+        return max(int(proposal) - int(washed), 0)
+    except ValueError:
+        return None
+
+
+def _drum_clean_last_cleaned(rep):
+    raw = option_value(rep.get('x.com.samsung.da.options'), 'DrumCleanLog')
+    if not raw:
+        return None
+    try:
+        return datetime.fromisoformat(raw).replace(tzinfo=timezone.utc)
+    except ValueError:
+        return None
+
+
+# Detergent/softener auto-dispense dosing, from the same options[] array
+# (issue #9). '<Prefix>LevelCtrl_<code>' is the selected dose quantity;
+# '<Prefix>Level2Ctrl_<code>' is a second dial -- water hardness for
+# detergent, concentration for softener -- matching the SmartThings app's
+# two-field dispenser screens ("Distributeur de lessive": Quantité + Dureté
+# de l'eau; "Distributeur d'adoucissant": Quantité + Concentration, per
+# issue #9's screenshots). 'Supported<Prefix>Ctrl_<hexpairs>' lists the
+# valid raw codes for its field, same hex-pair shape as EditCourseList.
+# '<Prefix>Alarm_<On/Off>' is a low-reservoir warning flag.
+#
+# Label mapping (entity.select.washer_dosing_quantity/washer_detergent_
+# water_hardness/washer_softener_concentration in strings.json) is an
+# assumed, not cross-device-verified, reading of the single issue #9 dump +
+# screenshots: LevelCtrl's 4 codes as None/Low/Medium/High (00 has no
+# on-screen equivalent -- the app's Quantité picker only offers
+# Faible/Moyen/Élevé, i.e. codes 01-03; 00 is assumed to be what
+# "Activation" off collapses to) matches DetergentLevelCtrl_3/
+# SoftenerLevelCtrl_3 = "Élevé" on both dispensers. Level2Ctrl's 3 codes as
+# Soft/Medium/Hard for detergent (Dureté de l'eau: Douce/Moyenne/Dure)
+# matches DetergentLevel2Ctrl_2 = "Moyenne". The same 3-code shape as
+# 1x/2x/3x for softener concentration does *not* cleanly match
+# SoftenerLevel2Ctrl_2 against the screenshot's "3x" -- assumed to be a
+# setting the user changed in the app between the dump (issue body) and the
+# screenshots (a later comment), not a different code scheme, since it's
+# otherwise identical in shape to the detergent side. Revisit if a second
+# device's dump contradicts this.
+def _supported_level_options(resources, prefix):
+    rep = resources.get('/course/vs/0') or {}
+    raw = option_value(rep.get('x.com.samsung.da.options'), f'Supported{prefix}')
+    return hex_pairs(raw) if raw else []
+
+
+def _level_options(prefix):
+    return lambda resources: _supported_level_options(resources, prefix)
+
+
+def _dosing_level(prefix):
+    """Current dose code, normalized to the `Supported<prefix>` code format.
+
+    The device reports the selected level as `<prefix>_<code>` with the code
+    un-padded (e.g. '3'), but the valid codes -- which are also this select's
+    options and its translation keys -- come from `Supported<prefix>_<hexpairs>`
+    as zero-padded hex pairs (e.g. '03'). Left as '3', the current value sits
+    outside the select's own option list, so HA renders it 'unknown' (issue #9).
+    Resolve it to the supported code with the same integer value so
+    current_option matches an option (and its translation)."""
+    def fn(rep):
+        opts = rep.get('x.com.samsung.da.options')
+        raw = option_value(opts, prefix)
+        if raw is None:
+            return None
+        supported_raw = option_value(opts, f'Supported{prefix}')
+        try:
+            target = int(raw, 16)
+        except (TypeError, ValueError):
+            return raw
+        for code in hex_pairs(supported_raw) if supported_raw else []:
+            try:
+                if int(code, 16) == target:
+                    return code
+            except (TypeError, ValueError):
+                continue
+        return raw
+    return fn
+
+
+def _level_write(prefix):
+    def write(p, rep, href=None):
+        opts = list(rep.get('x.com.samsung.da.options') or [])
+        if not opts:
+            return None
+        # `p` is the zero-padded supported code the UI selected (e.g. '03');
+        # the device stores the level un-padded (e.g. '3'), matching how it
+        # reports it, so write it back in that native shape.
+        try:
+            native = format(int(p, 16), 'X')
+        except (TypeError, ValueError):
+            native = p
+        return ['course', 'vs', '0'], {
+            'x.com.samsung.da.options': replace_in_options(opts, prefix, native),
+        }
+    return write
+
+
+def _dosing_low(prefix):
+    return lambda rep: option_value(
+        rep.get('x.com.samsung.da.options'), prefix) not in (None, 'Off')
+
+
+def _dosing_alarm_exists(prefix):
+    return lambda rep, resources: option_value(
+        rep.get('x.com.samsung.da.options'), prefix) is not None
 
 
 WASHER_COURSE = Capability(
     href='/course/vs/0',
     entities=(
-        SelectDesc(key='cycle', name='Cycle', icon='mdi:washing-machine',
-                   translation_key='washer_cycle',
-                   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'),
-                   write_fn=_cycle_write),
-    ),
-)
-
-# ---------------------------------------------------------------------------
-# /buzzersound/vs/0 -- buzzer volume and (on some units) a separate finish
-# chime. Fields have no 'x.com.samsung.da.' prefix in this resource, unlike
-# most other washer hrefs.
-# ---------------------------------------------------------------------------
-
-BUZZER_SOUND = Capability(
-    href='/buzzersound/vs/0',
-    entities=(
-        SelectDesc(key='buzzer_sound', field='setBuzzerSound',
-                   name='Buzzer sound', icon='mdi:volume-high',
+        cycle_select(translation_key='washer_cycle', icon='mdi:washing-machine'),
+        SensorDesc(key='drum_clean_cycles_remaining', name='Drum clean due in',
+                   icon='mdi:washing-machine-alert', unit='cycles',
+                   state_class='measurement',
+                   exists_fn=lambda rep, resources: _drum_clean_cycles_remaining(rep) is not None,
+                   rep_fn=_drum_clean_cycles_remaining),
+        SensorDesc(key='drum_clean_last_cleaned', name='Drum last cleaned',
+                   icon='mdi:calendar-clock', device_class='timestamp',
+                   entity_category='diagnostic',
+                   exists_fn=lambda rep, resources: _drum_clean_last_cleaned(rep) is not None,
+                   rep_fn=_drum_clean_last_cleaned),
+        SelectDesc(key='detergent_quantity', name='Detergent quantity', icon='mdi:cup-water',
+                   translation_key='washer_dosing_quantity',
                    entity_category='config',
-                   options_field='supportedBuzzerSound',
-                   write_fn=lambda p, rep, href=None: (
-                       ['buzzersound', 'vs', '0'], {'setBuzzerSound': p})),
-        SelectDesc(key='finish_sound', field='setFinishSound',
-                   name='Finish sound', icon='mdi:bell-ring',
+                   options=_level_options('DetergentLevelCtrl'),
+                   exists_fn=lambda rep, resources: bool(
+                       _level_options('DetergentLevelCtrl')(resources)),
+                   rep_fn=_dosing_level('DetergentLevelCtrl'),
+                   write_fn=_level_write('DetergentLevelCtrl')),
+        SelectDesc(key='detergent_water_hardness', name='Detergent water hardness',
+                   icon='mdi:water-opacity',
+                   translation_key='washer_detergent_water_hardness',
                    entity_category='config',
-                   exists_fn=lambda rep, resources: 'supportedFinishSound' in rep,
-                   options_field='supportedFinishSound',
-                   write_fn=lambda p, rep, href=None: (
-                       ['buzzersound', 'vs', '0'], {'setFinishSound': p})),
-    ),
-)
-
-# ---------------------------------------------------------------------------
-# /wm/jobbeginingstatus/vs/0 -- same href as dryer.JOB_BEGINNING_STATUS, but
-# a different field name (currentStatus, not jobBeginingStatus).
-# ---------------------------------------------------------------------------
-
-WASHER_JOB_BEGINNING_STATUS = Capability(
-    href='/wm/jobbeginingstatus/vs/0',
-    poll_tier='warm',
-    entities=(
-        SensorDesc(key='job_beginning_status',
-                   field='x.com.samsung.da.currentStatus',
-                   name='Job beginning status',
-                   entity_category='diagnostic'),
-    ),
-)
-
-# ---------------------------------------------------------------------------
-# OCF-native / '-vs' fallback pairs for power, kids-lock, remote control.
-#
-# Same shape as fridge.py's "Aggregate-resource fallbacks": the generic OCF
-# href (/power/0, plain boolean 'value') is preferred when present; the
-# vendor '-vs' href (richer historically, but for these three controls just
-# a string-encoded duplicate) only binds when the generic href is absent
-# from this device's resource set, via match_fn. Scoped to washer.py, not
-# common.py -- no other device type has been confirmed to expose the
-# generic hrefs, so this must not change behavior for dishwasher/dryer/
-# oven/refrigerator.
-# ---------------------------------------------------------------------------
-
-POWER_GENERIC = Capability(
-    href='/power/0',
-    entities=(
-        SwitchDesc(key='power_switch', field='value',
-                   name='Power',
-                   value_fn=lambda v: bool(v),
-                   write_fn=lambda p, rep, href=None: (
-                       ['power', '0'], {'value': p == 'On'})),
-    ),
-)
-
-POWER_VS_FALLBACK = Capability(
-    href='/power/vs/0',
-    match_fn=lambda rep, resources: '/power/0' not in resources,
-    entities=(
-        SwitchDesc(key='power_switch', field='x.com.samsung.da.power',
-                   name='Power',
-                   value_fn=lambda v: v == 'On',
-                   write_fn=lambda p, rep, href=None: (
-                       ['power', 'vs', '0'],
-                       {'x.com.samsung.da.power': 'On' if p == 'On' else 'Off'})),
-    ),
-)
-
-KIDS_LOCK_GENERIC = Capability(
-    href='/kidslock/0',
-    entities=(
-        SwitchDesc(key='child_lock', field='value',
-                   name='Child lock', device_class='lock',
-                   value_fn=lambda v: bool(v),
-                   write_fn=lambda p, rep, href=None: (
-                       ['kidslock', '0'], {'value': p == 'On'})),
-    ),
-)
-
-KIDS_LOCK_VS_FALLBACK = Capability(
-    href='/kidslock/vs/0',
-    match_fn=lambda rep, resources: '/kidslock/0' not in resources,
-    entities=(
-        SwitchDesc(key='child_lock', field='x.com.samsung.da.kidsLock',
-                   name='Child lock', device_class='lock',
-                   value_fn=lambda v: v != 'Ready',
-                   write_fn=lambda p, rep, href=None: (
-                       ['kidslock', 'vs', '0'],
-                       {'x.com.samsung.da.kidsLock': 'Enable' if p == 'On' else 'Ready'})),
-    ),
-)
-
-REMOTE_CONTROL_GENERIC = Capability(
-    href='/remotectrl/0',
-    entities=(
-        BinarySensorDesc(key='remote_control', field='value',
-                         name='Smart Control', device_class='connectivity',
-                         value_fn=lambda v: bool(v)),
-    ),
-)
-
-REMOTE_CONTROL_VS_FALLBACK = Capability(
-    href='/remotectrl/vs/0',
-    match_fn=lambda rep, resources: '/remotectrl/0' not in resources,
-    entities=(
-        BinarySensorDesc(key='remote_control',
-                         field='x.com.samsung.da.remoteControlEnabled',
-                         name='Smart Control', device_class='connectivity',
-                         value_fn=lambda v: str(v).lower() == 'true'),
+                   options=_level_options('DetergentLevel2Ctrl'),
+                   exists_fn=lambda rep, resources: bool(
+                       _level_options('DetergentLevel2Ctrl')(resources)),
+                   rep_fn=_dosing_level('DetergentLevel2Ctrl'),
+                   write_fn=_level_write('DetergentLevel2Ctrl')),
+        SelectDesc(key='softener_quantity', name='Softener quantity', icon='mdi:flask-outline',
+                   translation_key='washer_dosing_quantity',
+                   entity_category='config',
+                   options=_level_options('SoftenerLevelCtrl'),
+                   exists_fn=lambda rep, resources: bool(
+                       _level_options('SoftenerLevelCtrl')(resources)),
+                   rep_fn=_dosing_level('SoftenerLevelCtrl'),
+                   write_fn=_level_write('SoftenerLevelCtrl')),
+        SelectDesc(key='softener_concentration', name='Softener concentration',
+                   icon='mdi:flask-plus-outline',
+                   translation_key='washer_softener_concentration',
+                   entity_category='config',
+                   options=_level_options('SoftenerLevel2Ctrl'),
+                   exists_fn=lambda rep, resources: bool(
+                       _level_options('SoftenerLevel2Ctrl')(resources)),
+                   rep_fn=_dosing_level('SoftenerLevel2Ctrl'),
+                   write_fn=_level_write('SoftenerLevel2Ctrl')),
+        BinarySensorDesc(key='detergent_low', name='Detergent low',
+                         icon='mdi:alert-circle-outline', device_class='problem',
+                         exists_fn=_dosing_alarm_exists('DetergentAlarm'),
+                         rep_fn=_dosing_low('DetergentAlarm')),
+        BinarySensorDesc(key='softener_low', name='Softener low',
+                         icon='mdi:alert-circle-outline', device_class='problem',
+                         exists_fn=_dosing_alarm_exists('SoftenerAlarm'),
+                         rep_fn=_dosing_low('SoftenerAlarm')),
     ),
 )

custom_components/localthings/registry/entities.py

@@ -29,7 +29,7 @@ class SamsungEntityDescription:
     rep_fn: Optional[Callable[[dict], Any]] = None   # replaces field+value_fn; receives full rep
     # (rep, resources): rep is this entity's own href's representation;
     # resources is the coordinator's full href->rep snapshot, for gating
-    # presence on a sibling resource (e.g. washer._cycle_options's source).
+    # presence on a sibling resource (e.g. laundry.cycle_options's source).
     exists_fn: Optional[Callable[[dict, dict], bool]] = None
 
 
@@ -38,6 +38,7 @@ class SensorDesc(SamsungEntityDescription):
     device_class: Optional[str] = None
     state_class: Optional[str] = None
     unit: Optional[str] = None
+    unit_fn: Optional[Callable[[dict], str]] = None  # overrides `unit` from the live rep, when set
     options: Optional[tuple] = None  # required by HA when device_class == 'enum'
 
 
@@ -72,6 +73,7 @@ class ButtonDesc(SamsungEntityDescription):
 class NumberDesc(SamsungEntityDescription):
     device_class: Optional[str] = None
     unit: Optional[str] = None
+    unit_fn: Optional[Callable[[dict], str]] = None  # overrides `unit` from the live rep, when set
     native_min: Optional[float] = None
     native_max: Optional[float] = None
     step: Optional[float] = None
@@ -84,6 +86,16 @@ class TimeDesc(SamsungEntityDescription):
     write_fn: WriteFn = None
 
 
+@dataclass(frozen=True, kw_only=True)
+class ClimateDesc(SamsungEntityDescription):
+    # A composite entity: it binds one *primary* resource (its href) but the
+    # climate platform reads sibling resources (power, temperature, wind) from
+    # the coordinator snapshot and writes to several of them. write_fn takes a
+    # (kind, value) payload from the platform and returns the (path_segs, body)
+    # for that one sub-write, so a single desc drives multi-resource writes.
+    write_fn: WriteFn = None
+
+
 PLATFORM_OF: dict[type, str] = {
     SensorDesc:       'sensor',
     BinarySensorDesc: 'binary_sensor',
@@ -92,4 +104,5 @@ PLATFORM_OF: dict[type, str] = {
     ButtonDesc:       'button',
     NumberDesc:       'number',
     TimeDesc:         'time',
+    ClimateDesc:      'climate',
 }

custom_components/localthings/sensor.py

@@ -43,6 +43,13 @@ class LocalThingsSensor(LocalThingsEntity, SensorEntity):
         if desc.options:
             self._attr_options = list(desc.options)
 
+    @property
+    def native_unit_of_measurement(self):
+        desc: SensorDesc = self._bound.desc
+        if desc.unit_fn is not None:
+            return desc.unit_fn(self.coordinator.resource(self._bound.href))
+        return self._attr_native_unit_of_measurement
+
     @property
     def native_value(self):
         return (self.coordinator.data or {}).get(self._state_key)

custom_components/localthings/strings.json

@@ -18,6 +18,7 @@
       },
       "ice_type": {
         "state": {
+          "off": "Off",
           "whiskey_iceball_3": "3 Balls/Day",
           "whiskey_iceball_6": "6 Balls/Day",
           "whiskey_iceball_9": "9 Balls/Day"
@@ -78,6 +79,46 @@
           "8f": "Intense Cold",
           "96": "Less Microfiber"
         }
+      },
+      "dryer_cycle": {
+        "state": {
+          "16": "Cotton",
+          "18": "Synthetics",
+          "19": "Delicates",
+          "1a": "Wool",
+          "1b": "Bedding",
+          "1c": "Shirts",
+          "1d": "Towels",
+          "1e": "Outdoor",
+          "1f": "Mixed Load",
+          "20": "Iron Dry",
+          "23": "Quick Dry 35",
+          "24": "Cool Air",
+          "25": "Warm Air",
+          "27": "Time Dry"
+        }
+      },
+      "washer_dosing_quantity": {
+        "state": {
+          "00": "None",
+          "01": "Low",
+          "02": "Medium",
+          "03": "High"
+        }
+      },
+      "washer_detergent_water_hardness": {
+        "state": {
+          "01": "Soft",
+          "02": "Medium",
+          "03": "Hard"
+        }
+      },
+      "washer_softener_concentration": {
+        "state": {
+          "01": "1x",
+          "02": "2x",
+          "03": "3x"
+        }
       }
     },
     "sensor": {
@@ -92,6 +133,51 @@
           "observe": "Push (observe)",
           "poll": "Polling"
         }
+      },
+      "machine_state": {
+        "state": {
+          "idle": "Idle",
+          "active": "Active",
+          "pause": "Paused"
+        }
+      },
+      "air_filter_status": {
+        "state": {
+          "normal": "Normal",
+          "wash": "Wash",
+          "replace": "Replace"
+        }
+      }
+    },
+    "climate": {
+      "airconditioner": {
+        "state_attributes": {
+          "fan_mode": {
+            "state": {
+              "auto": "Auto",
+              "low": "Low",
+              "medium": "Medium",
+              "high": "High",
+              "turbo": "Turbo"
+            }
+          },
+          "swing_mode": {
+            "state": {
+              "off": "Fixed",
+              "both": "All directions",
+              "vertical": "Up and down"
+            }
+          },
+          "preset_mode": {
+            "state": {
+              "none": "Off",
+              "sleep": "Sleep",
+              "quiet": "Quiet",
+              "smart": "Smart",
+              "speed": "Speed"
+            }
+          }
+        }
       }
     }
   },

custom_components/localthings/translations/en.json

@@ -18,6 +18,7 @@
       },
       "ice_type": {
         "state": {
+          "off": "Off",
           "whiskey_iceball_3": "3 Balls/Day",
           "whiskey_iceball_6": "6 Balls/Day",
           "whiskey_iceball_9": "9 Balls/Day"
@@ -78,6 +79,46 @@
           "8f": "Intense Cold",
           "96": "Less Microfiber"
         }
+      },
+      "dryer_cycle": {
+        "state": {
+          "16": "Cotton",
+          "18": "Synthetics",
+          "19": "Delicates",
+          "1a": "Wool",
+          "1b": "Bedding",
+          "1c": "Shirts",
+          "1d": "Towels",
+          "1e": "Outdoor",
+          "1f": "Mixed Load",
+          "20": "Iron Dry",
+          "23": "Quick Dry 35",
+          "24": "Cool Air",
+          "25": "Warm Air",
+          "27": "Time Dry"
+        }
+      },
+      "washer_dosing_quantity": {
+        "state": {
+          "00": "None",
+          "01": "Low",
+          "02": "Medium",
+          "03": "High"
+        }
+      },
+      "washer_detergent_water_hardness": {
+        "state": {
+          "01": "Soft",
+          "02": "Medium",
+          "03": "Hard"
+        }
+      },
+      "washer_softener_concentration": {
+        "state": {
+          "01": "1x",
+          "02": "2x",
+          "03": "3x"
+        }
       }
     },
     "sensor": {
@@ -92,6 +133,51 @@
           "observe": "Push (observe)",
           "poll": "Polling"
         }
+      },
+      "machine_state": {
+        "state": {
+          "idle": "Idle",
+          "active": "Active",
+          "pause": "Paused"
+        }
+      },
+      "air_filter_status": {
+        "state": {
+          "normal": "Normal",
+          "wash": "Wash",
+          "replace": "Replace"
+        }
+      }
+    },
+    "climate": {
+      "airconditioner": {
+        "state_attributes": {
+          "fan_mode": {
+            "state": {
+              "auto": "Auto",
+              "low": "Low",
+              "medium": "Medium",
+              "high": "High",
+              "turbo": "Turbo"
+            }
+          },
+          "swing_mode": {
+            "state": {
+              "off": "Fixed",
+              "both": "All directions",
+              "vertical": "Up and down"
+            }
+          },
+          "preset_mode": {
+            "state": {
+              "none": "Off",
+              "sleep": "Sleep",
+              "quiet": "Quiet",
+              "smart": "Smart",
+              "speed": "Speed"
+            }
+          }
+        }
       }
     }
   },

requirements-dev.txt

@@ -1,2 +1,11 @@
-pytest>=8.0
+# Test harness — pulls in home-assistant, pytest, and pytest-socket at the
+# matching versions. Current Home Assistant requires Python >= 3.14; pip will
+# resolve the newest home-assistant your interpreter supports.
+pytest-homeassistant-custom-component>=0.13.316
+
+# Integration runtime deps, needed to import the component under test
+# (also declared in custom_components/localthings/manifest.json).
 smartthings-local>=0.1.0
+cbor2>=5.4.6
+pyOpenSSL>=23.0
+cryptography>=41.0

tests/fixtures/airconditioner_device.json

@@ -0,0 +1,400 @@
+{
+  "meta": {
+    "model": "ARTIK051_PRAC_20K",
+    "device_type": "airconditioner",
+    "source": "issue #17 diagnostics (scrubbed)",
+    "note": "First air-conditioner /device/0 dump; first composite HA climate entity."
+  },
+  "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": "**REDACTED**",
+            "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": "/filter/airdustfilter/vs/0",
+      "rep": {
+        "x.com.samsung.da.filterUsage": "100",
+        "x.com.samsung.da.filterUsageResolution": "1",
+        "x.com.samsung.da.filterDesiredUsage": "500",
+        "x.com.samsung.da.filterStatus": "wash",
+        "x.com.samsung.da.filterCapacity": "500",
+        "x.com.samsung.da.filterCapacityUnit": "Hour",
+        "x.com.samsung.da.filterResetType": [
+          "replaceable",
+          "washable"
+        ]
+      }
+    },
+    {
+      "href": "/temperature/control/vs/0",
+      "rep": {
+        "x.com.samsung.da.increment": "1"
+      }
+    },
+    {
+      "href": "/mode/convenient/vs/0",
+      "rep": {
+        "x.com.samsung.da.modes": "Off",
+        "x.com.samsung.da.supportedModes": [
+          "Off",
+          "Sleep",
+          "Quiet",
+          "Smart",
+          "Speed"
+        ]
+      }
+    },
+    {
+      "href": "/option/airpurify/vs/0",
+      "rep": {
+        "x.com.samsung.da.modes": "Off",
+        "x.com.samsung.da.supportedModes": [
+          "On",
+          "Off"
+        ]
+      }
+    },
+    {
+      "href": "/option/autoclean/vs/0",
+      "rep": {
+        "x.com.samsung.da.status": "Stop",
+        "x.com.samsung.da.settingStatus": "Off",
+        "x.com.samsung.da.progress": "0",
+        "x.com.samsung.da.supportedStatus": [
+          "Start",
+          "Stop"
+        ],
+        "x.com.samsung.da.supportedSettingStatus": [
+          "On",
+          "Off"
+        ]
+      }
+    },
+    {
+      "href": "/wind/strength/vs/0",
+      "rep": {
+        "x.com.samsung.da.modes": "1",
+        "x.com.samsung.da.supportedModes": [
+          "0",
+          "1",
+          "2",
+          "3",
+          "4"
+        ],
+        "x.com.samsung.da.modesName": [
+          "Auto",
+          "Low",
+          "Mid",
+          "High",
+          "Turbo"
+        ]
+      }
+    },
+    {
+      "href": "/wind/direction/vs/0",
+      "rep": {
+        "x.com.samsung.da.modes": "Fix",
+        "x.com.samsung.da.supportedModes": [
+          "Fix",
+          "All",
+          "Up_And_Low"
+        ]
+      }
+    },
+    {
+      "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-21T07:20:30"
+          },
+          {
+            "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-21T07:20:30",
+            "x.com.samsung.da.state": "Created"
+          }
+        ]
+      }
+    },
+    {
+      "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": "24.0",
+            "x.com.samsung.da.current": "27.0",
+            "x.com.samsung.da.maximum": "30",
+            "x.com.samsung.da.minimum": "16",
+            "x.com.samsung.da.increment": "1.0",
+            "x.com.samsung.da.unit": "Celsius"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/temperature/current/0",
+      "rep": {
+        "range": [
+          16.0,
+          30.0
+        ],
+        "units": "C",
+        "temperature": 27.0
+      }
+    },
+    {
+      "href": "/temperature/desired/0",
+      "rep": {
+        "range": [
+          16.0,
+          30.0
+        ],
+        "units": "C",
+        "temperature": 24.0
+      }
+    },
+    {
+      "href": "/diagnosis/vs/0",
+      "rep": {
+        "x.com.samsung.da.diagnosisStart": "Ready"
+      }
+    },
+    {
+      "href": "/energy/consumption/vs/0",
+      "rep": {
+        "x.com.samsung.da.instantaneousPower": "0",
+        "x.com.samsung.da.cumulativePower": "1686632",
+        "x.com.samsung.da.cumulativeSavedPower": "0",
+        "x.com.samsung.da.cumulativeUnit": "Wh",
+        "x.com.samsung.da.instantaneousPowerUnit": "W"
+      }
+    },
+    {
+      "href": "/energy/consumption/0",
+      "rep": {
+        "power": 0.0
+      }
+    },
+    {
+      "href": "/mode/vs/0",
+      "rep": {
+        "x.com.samsung.da.supportedModes": [
+          "Cool",
+          "Dry",
+          "Wind",
+          "Auto",
+          "Heat"
+        ],
+        "x.com.samsung.da.modes": [
+          "Cool"
+        ],
+        "x.com.samsung.da.options": [
+          "Sleep_0",
+          "ArtificialWorking_Off",
+          "ComfortAICooling_Off",
+          "AiTempChanged_Off",
+          "AiTemp_240",
+          "OutdoorTemp_79",
+          "CoolCapa_50",
+          "WarmCapa_60",
+          "Light_Off",
+          "Volume_100",
+          "OptionCode_53304",
+          "ExtendOptionCode_197256",
+          "RacInfo_None",
+          "UpdateAllow_NotAllowed",
+          "DurationOn_0",
+          "WelcomeCoolingState_Off"
+        ]
+      }
+    },
+    {
+      "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": [
+              "0"
+            ]
+          },
+          {
+            "x.com.samsung.da.id": "1",
+            "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": "2",
+            "x.com.samsung.da.description": "Sensor for Dust",
+            "x.com.samsung.da.type": "Dust",
+            "x.com.samsung.da.value": [
+              "0",
+              "0"
+            ]
+          },
+          {
+            "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": [
+              "0",
+              "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": [
+              "0",
+              "0"
+            ]
+          }
+        ]
+      }
+    },
+    {
+      "href": "/information/vs/0",
+      "rep": {
+        "x.com.samsung.da.modelNum": "ARTIK051_PRAC_20K|10217841|60010532001411004200003000000000",
+        "x.com.samsung.da.description": "ARTIK051_PRAC_20K",
+        "x.com.samsung.da.serialNum": "**REDACTED**",
+        "x.com.samsung.da.otnDUID": "**REDACTED**",
+        "x.com.samsung.da.serialNumOption": "**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": "02181A230313",
+            "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": "22112400,FFFFFFFF",
+            "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": "0000,0000"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/file/information/vs/0",
+      "rep": {
+        "x.com.samsung.timeoffset": "+00:00",
+        "x.com.samsung.supprtedtype": 1
+      }
+    },
+    {
+      "href": "/configuration/vs/0",
+      "rep": {
+        "x.com.samsung.da.region": "0000000000",
+        "x.com.samsung.da.airconOptionList": [
+          "SingleCommand_1",
+          "DR",
+          "HOMECARE_WIZARD_V2",
+          "PRODUCT_GLOBAL",
+          "AI_RAC_GLOBAL_HEATPUMP_3.0",
+          "AI_3.0",
+          "Auto_To_AI",
+          "AI_Heat"
+        ]
+      }
+    },
+    {
+      "href": "/humidity/0",
+      "rep": {
+        "humidity": 0
+      }
+    },
+    {
+      "href": "/humidity/vs/0",
+      "rep": {
+        "x.com.samsung.da.humidity": "0"
+      }
+    },
+    {
+      "href": "/drlc/0",
+      "rep": {
+        "DRLevel": 0,
+        "start": "1970-01-01T00:00:00Z",
+        "duration": 0,
+        "override": false
+      }
+    },
+    {
+      "href": "/drlc/vs/0",
+      "rep": {
+        "x.com.samsung.da.drlcLevel": "0",
+        "x.com.samsung.da.duration": "00:00:00",
+        "x.com.samsung.da.drlcStartTime": "1970-01-01T00:00:00Z",
+        "x.com.samsung.da.override": "Off",
+        "x.com.samsung.da.realSaving": "Off"
+      }
+    },
+    {
+      "href": "/timezone/vs/0",
+      "rep": {}
+    }
+  ]
+}

tests/fixtures/dryer_device.json

@@ -0,0 +1,423 @@
+{
+  "meta": {
+    "model": "DV90BB5245AES1",
+    "device_type": "dryer",
+    "source": "issue #14 diagnostics (scrubbed)",
+    "note": "First full dryer /device/0 dump. DA_WM_TP1_21_COMMON board."
+  },
+  "device0": [
+    {
+      "rt": [
+        "x.com.samsung.devcol",
+        "oic.wk.col"
+      ],
+      "if": [
+        "oic.if.baseline",
+        "oic.if.ll",
+        "oic.if.b"
+      ]
+    },
+    {
+      "href": "/alarms/vs/0",
+      "rep": {}
+    },
+    {
+      "href": "/buzzersound/vs/0",
+      "rep": {
+        "supportedBuzzerSound": [
+          "Off",
+          "On"
+        ],
+        "setBuzzerSound": "Off"
+      }
+    },
+    {
+      "href": "/configuration/vs/0",
+      "rep": {
+        "x.com.samsung.da.region": "0000000000",
+        "x.com.samsung.da.countryCode": "GB"
+      }
+    },
+    {
+      "href": "/connectionconfig/vs/0",
+      "rep": {
+        "autoReconnectionMinVersion": "1.0",
+        "autoReconnection": "true",
+        "autoReconnectionProtocolType": [
+          "helper_hotspot",
+          "ble_ocf"
+        ],
+        "supportedWiFiAuthType": [
+          "OPEN",
+          "WEP",
+          "WPA-PSK",
+          "WPA2-PSK",
+          "SAE"
+        ],
+        "supportedWiFiCryptoType": [
+          "TKIP",
+          "AES",
+          "WEP-64",
+          "WEP-128"
+        ],
+        "supportedWiFiFreq": [
+          "2.4G"
+        ],
+        "calmConnectionCare": {
+          "version": "1.0",
+          "role": [
+            "things"
+          ]
+        }
+      }
+    },
+    {
+      "href": "/course/vs/0",
+      "rep": {
+        "x.com.samsung.da.supportedModes": [
+          "HOMECARE_WIZARD_V2"
+        ],
+        "x.com.samsung.da.options": [
+          "DeviceType_0165",
+          "UpdateAllow_NotAllowed",
+          "Course_16",
+          "AiOption_On",
+          "MixedLoadBell_Disable",
+          "MixedLoadBellNoti_Nothing",
+          "LaundryOutTime_0",
+          "SeamlessControl_Disable",
+          "KidsLockBypass_On",
+          "DetergentOnce_1",
+          "DetergentLeft_0",
+          "DetergentBase_5",
+          "DetergentAlarm_Off",
+          "DetergentType_3",
+          "DetergentTotal_0",
+          "SpecialFunction_20",
+          "AvailableDelayTime_182",
+          "LaundryPlannerUserSetTime_0",
+          "ProgressTimeSet_B2198CB4003C",
+          "WrinklePreventRunning_Off",
+          "SendToDevice_Off",
+          "GMT_02",
+          "DrumLight_Off",
+          "DryTimeSet_FF000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000070007FE020007FE020007FE00000000",
+          "EnergyLevelSet_0505030503020404030502030304020102",
+          "MostUsed_27D000",
+          "WrinklePreventSet_0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F",
+          "MixedLoadBellSet_02FF0202FFFFFFFFFFFFFFFFFFFFFFFF",
+          "EmptyingTheBucket_Nothing",
+          "GeoFenceAlarm",
+          "UsagesDB_ok",
+          "EnergyKW_396",
+          "DrumCleanLog_Empty",
+          "TimeSync_NotSupported"
+        ],
+        "x.com.samsung.da.supportedOptions": [
+          "116D20E23D0001FD20E18D20E19D2041DD2041BD2041CD20E21D3081AD1021ED20420D10227D00025D00024D0004CD10E"
+        ]
+      }
+    },
+    {
+      "href": "/cycleinterface/vs/0",
+      "rep": {
+        "x.com.samsung.da.cycleInterfaceEnabled": "Off"
+      }
+    },
+    {
+      "href": "/diagnosis/vs/0",
+      "rep": {
+        "x.com.samsung.da.diagnosisStart": "Ready"
+      }
+    },
+    {
+      "href": "/energy/consumption/0",
+      "rep": {}
+    },
+    {
+      "href": "/energy/consumption/vs/0",
+      "rep": {
+        "x.com.samsung.da.instantaneousPower": "-500",
+        "x.com.samsung.da.instantaneousPowerUnit": "W",
+        "x.com.samsung.da.cumulativePower": "677300",
+        "x.com.samsung.da.cumulativeUnit": "Wh",
+        "x.com.samsung.da.cumulativeDate": "1784469600",
+        "x.com.samsung.da.cumulativeDateUTC": "1784466000"
+      }
+    },
+    {
+      "href": "/file/information/vs/0",
+      "rep": {
+        "x.com.samsung.timeoffset": "+01:00"
+      }
+    },
+    {
+      "href": "/information/vs/0",
+      "rep": {
+        "x.com.samsung.da.modelNum": "DA_WM_TP1_21_COMMON|20314441|30010102001611000AA3031700000000",
+        "x.com.samsung.da.description": "DA_WM_TP1_21_COMMON_DV5000B/DC92-03266A_0004",
+        "x.com.samsung.da.serialNum": "0AJ8XREDACTED000",
+        "x.com.samsung.da.otnDUID": "REDACTEDDUID0000000000000000000000000000",
+        "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": "DR1",
+        "x.com.samsung.da.diagMinVersion": "3.0",
+        "x.com.samsung.da.diagTsId": "DA01",
+        "x.com.samsung.da.items": [
+          {
+            "x.com.samsung.da.id": "0",
+            "x.com.samsung.da.description": "DA_WM_TP1_21_COMMON|20314441|30010102001611000AA3031700000000",
+            "x.com.samsung.da.type": "Software",
+            "x.com.samsung.da.number": "02986A260118(A182)",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          },
+          {
+            "x.com.samsung.da.id": "1",
+            "x.com.samsung.da.description": "Firmware_1_DB_20314441220516500FFFFF203266412207065004FFFF(01652031444120326641_30000000)(FileDown:0)(Type:0)",
+            "x.com.samsung.da.type": "Firmware",
+            "x.com.samsung.da.number": "03144A22051650,03266A22070650",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          },
+          {
+            "x.com.samsung.da.id": "2",
+            "x.com.samsung.da.description": "Firmware_2_DB_2032244122050903042FFFFFFFFFFFFFFFFFFFFFFFFE(016520322441FFFFFFFF_30000000)(FileDown:0)(Type:0)",
+            "x.com.samsung.da.type": "Firmware",
+            "x.com.samsung.da.number": "03224A22050903,FFFFFFFFFFFFFF"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/kidslock/0",
+      "rep": {
+        "value": false
+      }
+    },
+    {
+      "href": "/kidslock/vs/0",
+      "rep": {
+        "x.com.samsung.da.kidsLock": "Ready"
+      }
+    },
+    {
+      "href": "/operational/state/0",
+      "rep": {
+        "currentMachineState": "Ready",
+        "machineStates": [
+          "None",
+          "Ready",
+          "Running",
+          "Paused",
+          "Finish"
+        ],
+        "jobStates": [
+          "None",
+          "Drying",
+          "Cooling",
+          "Finish"
+        ],
+        "currentJobState": "None",
+        "remainingTime": "03:02:00",
+        "progressPercentage": "1"
+      }
+    },
+    {
+      "href": "/operational/state/vs/0",
+      "rep": {
+        "x.com.samsung.da.state": "Ready",
+        "x.com.samsung.da.remainingTime": "03:02:00",
+        "x.com.samsung.da.progressPercentage": "1",
+        "x.com.samsung.da.progress": "None",
+        "x.com.samsung.da.delayEndTime": "00:00:00",
+        "x.com.samsung.da.supportedProgress": [
+          "None",
+          "Drying",
+          "Cooling",
+          "Finish"
+        ]
+      }
+    },
+    {
+      "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": "2026-03-04",
+        "otnList": [
+          {
+            "type": "WIFI",
+            "modelId": "DA_WM_TP1_21_COMMON",
+            "versions": [
+              "30260118"
+            ],
+            "visVersion": "260118"
+          },
+          {
+            "type": "Micom",
+            "modelId": "01652031444120326641",
+            "versions": [
+              "22051650",
+              "22070650"
+            ],
+            "visVersion": "220706"
+          },
+          {
+            "type": "Micom",
+            "modelId": "016520322441FFFFFFFF",
+            "versions": [
+              "22050903",
+              "FFFFFFFF"
+            ],
+            "visVersion": "220509"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/power/0",
+      "rep": {
+        "value": false
+      }
+    },
+    {
+      "href": "/power/vs/0",
+      "rep": {
+        "x.com.samsung.da.power": "Off"
+      }
+    },
+    {
+      "href": "/quickcontrol/info/vs/0",
+      "rep": {
+        "supportedVersion": "1.0"
+      }
+    },
+    {
+      "href": "/realtimenotiforclient/vs/0",
+      "rep": {
+        "x.com.samsung.da.timeforshortnoti": "0",
+        "x.com.samsung.da.periodicnotisubscription": "true"
+      }
+    },
+    {
+      "href": "/remotectrl/0",
+      "rep": {
+        "value": false
+      }
+    },
+    {
+      "href": "/remotectrl/vs/0",
+      "rep": {
+        "x.com.samsung.da.remoteControlEnabled": "false"
+      }
+    },
+    {
+      "href": "/setting/vs/0",
+      "rep": {}
+    },
+    {
+      "href": "/st/dryercourse/vs/0",
+      "rep": {
+        "x.com.samsung.da.st.dryerMode": "Table_03_Course_16",
+        "x.com.samsung.da.st.courseTable": "Table_03"
+      }
+    },
+    {
+      "href": "/timezone/vs/0",
+      "rep": {
+        "timezoneid": "Europe/London",
+        "offset": "+01:00",
+        "DST": "ON"
+      }
+    },
+    {
+      "href": "/washer/vs/0",
+      "rep": {
+        "x.com.samsung.da.wrinklePrevent": "Off",
+        "x.com.samsung.da.dryLevel": "Normal",
+        "x.com.samsung.da.supportedDryLevel": [
+          "None",
+          "Less",
+          "Normal",
+          "More"
+        ],
+        "x.com.samsung.da.dryTime": "00:00:00",
+        "x.com.samsung.da.supportedDryTime": [
+          "00:00:00",
+          "00:20:00",
+          "00:30:00",
+          "00:40:00",
+          "00:50:00",
+          "01:00:00",
+          "01:30:00",
+          "02:00:00",
+          "02:30:00",
+          "03:00:00",
+          "04:00:00"
+        ],
+        "x.com.samsung.da.dryerType": "Electricity"
+      }
+    },
+    {
+      "href": "/wirelessinfo/vs/0",
+      "rep": {
+        "macaddressWiFi": "00:00:00:00:00:00",
+        "macaddressBLE": "00:00:00:00:00:00"
+      }
+    },
+    {
+      "href": "/wm/editcourse/vs/0",
+      "rep": {
+        "x.com.samsung.da.editCourseList": "EditCourseList_16271D231F18191B1C211A1E2025244C",
+        "x.com.samsung.da.fixedCourseList": "FixedCourseList_161820"
+      }
+    },
+    {
+      "href": "/wm/jobbeginingstatus/vs/0",
+      "rep": {
+        "x.com.samsung.da.currentStatus": "None"
+      }
+    },
+    {
+      "href": "/wm/personalcourse/vs/0",
+      "rep": {
+        "x.com.samsung.da.courses": [
+          "F1_00",
+          "F2_00",
+          "F3_00",
+          "F4_00",
+          "F5_00",
+          "F6_00",
+          "F7_00",
+          "F8_00",
+          "F9_00",
+          "FA_00"
+        ],
+        "x.com.samsung.da.maxCourseNum": "10"
+      }
+    },
+    {
+      "href": "/wm/setinfo/vs/0",
+      "rep": {
+        "x.com.samsung.da.isModelSettingWithoutSC": "true",
+        "x.com.samsung.da.aiCourse": "false",
+        "x.com.samsung.da.isModelSettingPowerOnOff": "false",
+        "x.com.samsung.da.modelCode": "M(None),W(DV90BB5245AES1)"
+      }
+    },
+    {
+      "href": "/wm/welcomemsg/vs/0",
+      "rep": {}
+    }
+  ]
+}

tests/fixtures/golden/airconditioner.json

@@ -0,0 +1,13 @@
+{
+  "state_keys": [
+    "air_filter_status",
+    "air_filter_usage",
+    "air_purify",
+    "alarm_code",
+    "auto_clean",
+    "climate",
+    "diagnosis_status",
+    "energy_kwh",
+    "power_watts"
+  ]
+}

tests/fixtures/golden/dishwasher.json

@@ -20,7 +20,6 @@
     "machine_state",
     "operation_origin",
     "power_switch",
-    "power_watts",
     "progress",
     "progress_percentage",
     "remote_control",
@@ -53,7 +52,6 @@
     "samsung_dishwasher_operation_origin",
     "samsung_dishwasher_pause",
     "samsung_dishwasher_power_switch",
-    "samsung_dishwasher_power_watts",
     "samsung_dishwasher_progress",
     "samsung_dishwasher_progress_percentage",
     "samsung_dishwasher_remote_control",

tests/fixtures/golden/dryer.json

@@ -0,0 +1,24 @@
+{
+  "state_keys": [
+    "alarm_code",
+    "buzzer_sound",
+    "child_lock",
+    "cycle",
+    "cycle_active",
+    "delay_start_hours",
+    "diagnosis",
+    "dry_level",
+    "dry_time",
+    "dryer_type",
+    "energy_kwh",
+    "finish_time",
+    "firmware_update",
+    "job_beginning_status",
+    "machine_state",
+    "power_switch",
+    "progress",
+    "progress_percentage",
+    "remote_control",
+    "wrinkle_prevent"
+  ]
+}

tests/fixtures/golden/refrigerator.json

@@ -10,7 +10,7 @@
     "cooler_setpoint",
     "cooler_temperature",
     "day_brightness",
-    "defrost_blocked",
+    "defrost_active",
     "defrost_delay",
     "door_alert",
     "door_cooler_open",
@@ -50,7 +50,7 @@
     "samsung_refrigerator_cooler_setpoint",
     "samsung_refrigerator_cooler_temperature",
     "samsung_refrigerator_day_brightness",
-    "samsung_refrigerator_defrost_blocked",
+    "samsung_refrigerator_defrost_active",
     "samsung_refrigerator_defrost_delay",
     "samsung_refrigerator_door_alert",
     "samsung_refrigerator_door_cooler_open",

tests/fixtures/golden/washer.json

@@ -6,18 +6,21 @@
     "cycle",
     "cycle_active",
     "delay_start_hours",
+    "detergent_low",
     "diagnosis_status",
+    "drum_clean_cycles_remaining",
+    "drum_clean_last_cleaned",
     "energy_kwh",
     "finish_time",
     "firmware_update",
     "job_beginning_status",
     "machine_state",
     "power_switch",
-    "power_watts",
     "progress",
     "progress_percentage",
     "remote_control",
     "rinse_cycles",
+    "softener_low",
     "spin_speed",
     "wash_temperature",
     "water_liters"

tests/localthings/test_config_flow.py

@@ -56,6 +56,113 @@ async def test_successful_setup(hass: HomeAssistant, mock_probe) -> None:
     assert result['data'][CONF_CA_CERT_PEM] == MOCK_CA_CERT_PEM
 
 
+def test_order_candidates_prefers_known_ports() -> None:
+    """Live ports are ordered with the historically known DTLS ports first,
+    then the rest ascending."""
+    from custom_components.localthings.config_flow import _order_candidates
+
+    assert _order_candidates([49160, 49153, 49155, 49154]) == [
+        49154, 49155, 49153, 49160,
+    ]
+    assert _order_candidates([49153]) == [49153]
+
+
+def test_find_live_ports_detects_silent_port(socket_enabled) -> None:
+    """The UDP liveness sweep flags a bound-but-silent port as live and drops
+    ports that refuse with ICMP port-unreachable.
+
+    A bound, never-recv'd UDP socket stands in for a device that listens but
+    stays silent (open|filtered), like the dishwasher in issue #13 on 49153.
+    Two sibling ports are reserved then closed so loopback refuses datagrams
+    to them, standing in for the closed ports the scan should discard.
+
+    `socket_enabled` lifts pytest-socket's default block (the HA test harness
+    disables real sockets); this test genuinely needs loopback UDP to exercise
+    the ICMP-unreachable path.
+    """
+    import socket
+
+    from custom_components.localthings.config_flow import _find_live_ports
+
+    reserve = [socket.socket(socket.AF_INET, socket.SOCK_DGRAM) for _ in range(3)]
+    for s in reserve:
+        s.bind(('127.0.0.1', 0))
+    ports = [s.getsockname()[1] for s in reserve]
+    live_sock, live_port = reserve[0], ports[0]
+    reserve[1].close()
+    reserve[2].close()
+    closed_ports = ports[1:]
+
+    try:
+        result = _find_live_ports(
+            '127.0.0.1', [closed_ports[0], live_port, closed_ports[1]], 0.8,
+        )
+    finally:
+        live_sock.close()
+
+    assert result == [live_port]
+
+
+async def test_probe_uses_discovered_low_port(hass: HomeAssistant, monkeypatch) -> None:
+    """A device that only answers on 49153 — outside the historical
+    49154/49155 pair — is found by the liveness sweep and its port is stored
+    on the config entry (issue #13)."""
+    import cbor2
+
+    from custom_components.localthings import config_flow
+
+    device0 = [
+        {'rt': ['x.com.samsung.devcol']},
+        {'href': '/information/vs/0', 'rep': {
+            'x.com.samsung.da.modelNum':
+                'DA_WM_TP1_21_COMMON|20375141|20010002001811424AA30217008A0000',
+            'x.com.samsung.da.description':
+                'DA_WM_TP1_21_COMMON_WW5000C/DC92-03495A_B048',
+            'x.com.samsung.da.serialNum': 'DISHWASHER-49153',
+        }},
+        {'href': '/otninformation/vs/0', 'rep': {'otnStatus': 'None'}},
+    ]
+
+    class _FakeSession:
+        def __init__(self, host, port, cert_pem=None, key_pem=None):
+            self.host, self.port = host, port
+
+        def connect(self):
+            pass
+
+        def start_reader(self):
+            pass
+
+        def get(self, path, timeout=15.0):
+            return 0x45, cbor2.dumps(device0)
+
+        def close(self):
+            pass
+
+    monkeypatch.setattr(config_flow, '_fetch_samsung_uuid', lambda: 'test-uuid')
+    monkeypatch.setattr(
+        config_flow, '_mint_leaf_cert',
+        lambda ca_cert, ca_key, uuid: ('FULLCHAIN', 'LEAFKEY'),
+    )
+    monkeypatch.setattr(
+        config_flow, '_find_live_ports',
+        lambda host, ports, timeout: [49153],
+    )
+    monkeypatch.setattr(
+        'smartthings_local.protocol.dtls_session.DtlsCoapSession', _FakeSession,
+    )
+
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN, context={'source': 'user'}
+    )
+    result = await hass.config_entries.flow.async_configure(
+        result['flow_id'],
+        {CONF_HOST: MOCK_HOST, CONF_CA_CERT_PEM: MOCK_CA_CERT_PEM, CONF_CA_KEY_PEM: MOCK_CA_KEY_PEM},
+    )
+    assert result['type'] == FlowResultType.CREATE_ENTRY
+    assert result['data'][CONF_PORT] == 49153
+
+
 async def test_cannot_connect(hass: HomeAssistant) -> None:
     """Failed probe: form re-shown with cannot_connect error."""
     from custom_components.localthings.config_flow import CannotConnect

tests/localthings/test_diagnostics.py

@@ -1,12 +1,21 @@
 """Tests for the diagnostics platform."""
 from __future__ import annotations
 
+import json
+import threading
+from pathlib import Path
+
 from homeassistant.core import HomeAssistant
 
+from custom_components.localthings import diagnostics as diagnostics_mod
 from custom_components.localthings.const import DOMAIN
 from custom_components.localthings.diagnostics import async_get_config_entry_diagnostics
 from custom_components.localthings.registry.redact import REDACTED
 
+_MANIFEST_VERSION = json.loads(
+    (Path(__file__).parents[2] / 'custom_components' / 'localthings' / 'manifest.json').read_text()
+)['version']
+
 
 async def test_diagnostics_shape_and_redaction(
     hass: HomeAssistant, mock_entry, mock_coordinator_session
@@ -19,7 +28,7 @@ async def test_diagnostics_shape_and_redaction(
     assert diagnostics["device_type"] == 'refrigerator'
     assert diagnostics["one_ui_version"] == '7.0 Refrigerator'
     assert diagnostics["unbound_hrefs"] == []
-    assert diagnostics["integration_version"] == '0.1.0'
+    assert diagnostics["integration_version"] == _MANIFEST_VERSION
     assert diagnostics["smartthings_local_version"]
 
     resources = diagnostics["resources"]
@@ -42,3 +51,27 @@ async def test_diagnostics_include_observe_mode_fields(
     assert diag['observe_fallback_hrefs'] == []
     assert 'observe_last_mode_change' in diag
     assert diag['observe_href_freshness_s'] == {}
+
+
+async def test_dependency_version_read_off_the_event_loop(
+    hass: HomeAssistant, mock_entry, mock_coordinator_session, monkeypatch
+) -> None:
+    """importlib.metadata.version() does blocking disk I/O, so it must run in
+    the executor, not on the event loop (issue #9's logs flagged it)."""
+    await hass.config_entries.async_setup(mock_entry.entry_id)
+    await hass.async_block_till_done()
+
+    loop_thread_id = threading.get_ident()  # this coroutine runs on the loop
+    seen: dict[str, int] = {}
+    real_pkg_version = diagnostics_mod.pkg_version
+
+    def _spy(name: str) -> str:
+        seen['thread_id'] = threading.get_ident()
+        return real_pkg_version(name)
+
+    monkeypatch.setattr(diagnostics_mod, 'pkg_version', _spy)
+
+    diag = await async_get_config_entry_diagnostics(hass, mock_entry)
+
+    assert diag['smartthings_local_version']
+    assert seen['thread_id'] != loop_thread_id

tests/test_airconditioner_capabilities.py

@@ -0,0 +1,108 @@
+"""Tests for Samsung air-conditioner support (issue #17).
+
+These stay HA-free like the rest of the suite: they exercise the registry,
+discovery/flatten, and the CLIMATE capability's write contract. The composite
+climate entity itself lives in climate.py (imports homeassistant) and is not
+importable here -- consistent with how the other HA platform files are untested.
+"""
+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 airconditioner
+from custom_components.localthings.registry.discovery import discover
+from custom_components.localthings.registry.entities import ClimateDesc
+
+from tests.conftest import _load_device
+
+
+def _ac():
+    resources = _load_device('airconditioner')
+    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 _bound():
+    reg, resources = _ac()
+    return discover(resources, reg.capabilities, reg.pattern_capabilities), resources
+
+
+def _state():
+    bound, resources = _bound()
+    return flatten(bound, resources)
+
+
+def test_ac_model_resolves_to_airconditioner_registry():
+    reg, _ = _ac()
+    assert reg is not None and reg.name == 'airconditioner'
+
+
+def test_no_unbound_hrefs():
+    """Every resource in the issue #17 dump binds or is covered -- clears the
+    coverage-gap repair."""
+    reg, resources = _ac()
+    unbound = []
+    discover(resources, reg.capabilities, reg.pattern_capabilities, log=unbound.append)
+    assert unbound == []
+
+
+def test_climate_entity_is_bound():
+    """The composite climate entity binds the primary /mode/vs/0 resource."""
+    bound, _ = _bound()
+    climate = [b for b in bound if isinstance(b.desc, ClimateDesc)]
+    assert len(climate) == 1
+    assert climate[0].href == '/mode/vs/0'
+
+
+def test_expected_state_keys_present():
+    state = _state()
+    for key in ('climate', 'air_purify', 'auto_clean', 'air_filter_status',
+                'air_filter_usage', 'diagnosis_status', 'alarm_code', 'energy_kwh'):
+        assert key in state, key
+
+
+def test_power_and_convenient_folded_into_climate():
+    """On/off is the climate entity's HVACMode.OFF and convenient mode is its
+    preset_mode -- neither surfaces as a standalone switch/select."""
+    state = _state()
+    assert 'power_switch' not in state
+    assert 'convenient_mode' not in state
+
+
+def test_air_filter_usage_is_percentage_of_capacity():
+    """filterUsage is a raw count in the capacity unit (100 of 500), surfaced as
+    a percentage rather than the misleading raw value."""
+    assert _state()['air_filter_usage'] == 20
+
+
+def test_climate_write_targets():
+    """The CLIMATE write_fn maps each (kind, value) command to the right OCF
+    POST target and body. `value` is already the raw device code."""
+    write = airconditioner.CLIMATE.entities[0].write_fn
+    assert write(('power', True), {}) == (['power', '0'], {'value': True})
+    assert write(('power', False), {}) == (['power', '0'], {'value': False})
+    assert write(('mode', 'Heat'), {}) == (
+        ['mode', 'vs', '0'], {'x.com.samsung.da.modes': ['Heat']})
+    assert write(('temperature', 23.6), {}) == (
+        ['temperature', 'desired', '0'], {'temperature': 24})
+    assert write(('fan', '2'), {}) == (
+        ['wind', 'strength', 'vs', '0'], {'x.com.samsung.da.modes': '2'})
+    assert write(('swing', 'All'), {}) == (
+        ['wind', 'direction', 'vs', '0'], {'x.com.samsung.da.modes': 'All'})
+    assert write(('preset', 'Sleep'), {}) == (
+        ['mode', 'convenient', 'vs', '0'], {'x.com.samsung.da.modes': 'Sleep'})
+    assert write(('bogus', 1), {}) is None
+
+
+def test_climate_consumed_hrefs_declared_as_coverage():
+    """The climate-consumed and ambiguous hrefs are declared in the AC registry
+    (as no-entity coverage caps) so they don't leak as gaps -- but produce no
+    standalone entities."""
+    reg, _ = _ac()
+    for href in ('/power/0', '/power/vs/0', '/temperature/desired/0',
+                 '/wind/strength/vs/0', '/mode/convenient/vs/0',
+                 '/temperatures/vs/0', '/sensors/vs/0', '/humidity/0'):
+        caps = reg.capabilities.get(href)
+        assert caps, href
+        assert all(c.entities == () for c in caps), href

tests/test_by_type.py

@@ -154,6 +154,32 @@ class TestForDeviceByModel:
         assert reg is not None
         assert reg.name == 'refrigerator'
 
+    def test_refrigerator_rl_series_via_ref_token(self):
+        """Issue #7: RL38C6B0CWW/EG (a bottom-freezer RL-series fridge, not
+        the RF9000-style french-door this module was originally verified
+        against) reports description/modelNum 'TP1X_REF_21K' -- same
+        internal platform code as any other TP1X-based fridge, so the
+        existing '_REF_' fallback already resolves it correctly."""
+        from custom_components.localthings.registry.by_type import for_device_by_model
+        reg = for_device_by_model(
+            'TP1X_REF_21K|00156941|00050126001611304100000031010000',
+            'TP1X_REF_21K',
+        )
+        assert reg is not None
+        assert reg.name == 'refrigerator'
+
+    def test_airconditioner_via_prac_token(self):
+        """Issue #17: a room AC (ARTIK051_PRAC_20K) reports no oneUiVersion and
+        an unrecognized consumer token ('20K'); it falls back to the '_PRAC_'
+        (Package Room Air Conditioner) token in modelNum."""
+        from custom_components.localthings.registry.by_type import for_device_by_model
+        reg = for_device_by_model(
+            'ARTIK051_PRAC_20K|10217841|60010532001411004200003000000000',
+            'ARTIK051_PRAC_20K',
+        )
+        assert reg is not None
+        assert reg.name == 'airconditioner'
+
     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')

tests/test_common_capabilities.py

@@ -4,28 +4,129 @@ from custom_components.localthings.registry.discovery import discover
 
 def _reg():
     return {c.href: [c] for c in (
-        common.KIDS_LOCK, common.REMOTE_CONTROL, common.POWER,
+        common.KIDS_LOCK_GENERIC, common.KIDS_LOCK_VS_FALLBACK,
+        common.REMOTE_CONTROL_GENERIC, common.REMOTE_CONTROL_VS_FALLBACK,
+        common.POWER_GENERIC, common.POWER_VS_FALLBACK,
         common.ALARMS, common.ENERGY_METER, common.WATER_METER,
         common.WATER_FILTER,
     )}
 
 
-def test_kids_lock_binary_value_fn():
-    desc = common.KIDS_LOCK.entities[0]
+def test_kids_lock_vs_value_fn():
+    desc = common.KIDS_LOCK_VS_FALLBACK.entities[0]
     assert desc.value_fn('Lock') is True
     assert desc.value_fn('Ready') is False
 
 
-def test_energy_clamps_negative_power(fridge_resources):
-    # instantaneousPower can read negative at idle; must clamp to 0.
-    pw = next(e for e in common.ENERGY_METER.entities if e.key == 'power_watts')
-    assert pw.value_fn(-500.0) == 0.0
-    assert pw.value_fn(93.0) == 93.0
-
-
 def test_common_caps_discover_on_dishwasher(dishwasher_resources):
     bound = discover(dishwasher_resources, _reg())
     keys = {b.desc.key for b in bound}
     assert 'child_lock' in keys
     assert 'remote_control' in keys
-    assert 'power_watts' in keys
+    assert 'power_switch' in keys
+
+
+# ---------------------------------------------------------------------------
+# OCF-native / vendor '-vs' fallback pairs (power, kids-lock, remote control).
+# ---------------------------------------------------------------------------
+
+
+class TestPowerFallback:
+    def test_generic_href_read_write(self):
+        assert common.POWER_GENERIC.href == '/power/0'
+        desc = common.POWER_GENERIC.entities[0]
+        assert desc.value_fn(True) is True
+        assert desc.value_fn(False) is False
+        path, body = desc.write_fn('On', {})
+        assert path == ['power', '0']
+        assert body == {'value': True}
+        assert desc.write_fn('Off', {})[1] == {'value': False}
+
+    def test_vs_fallback_binds_only_when_generic_absent(self):
+        assert common.POWER_VS_FALLBACK.href == '/power/vs/0'
+        assert common.POWER_VS_FALLBACK.match_fn({}, {'/power/vs/0': {}}) is True
+        assert common.POWER_VS_FALLBACK.match_fn(
+            {}, {'/power/0': {}, '/power/vs/0': {}}) is False
+
+    def test_vs_fallback_read_write(self):
+        desc = common.POWER_VS_FALLBACK.entities[0]
+        assert desc.value_fn('On') is True
+        assert desc.value_fn('Off') is False
+        path, body = desc.write_fn('On', {})
+        assert path == ['power', 'vs', '0']
+        assert body == {'x.com.samsung.da.power': 'On'}
+
+
+class TestKidsLockFallback:
+    def test_generic_read_write(self):
+        assert common.KIDS_LOCK_GENERIC.href == '/kidslock/0'
+        desc = common.KIDS_LOCK_GENERIC.entities[0]
+        assert desc.value_fn(True) is True
+        path, body = desc.write_fn('On', {})
+        assert path == ['kidslock', '0']
+        assert body == {'value': True}
+
+    def test_vs_fallback_gated(self):
+        assert common.KIDS_LOCK_VS_FALLBACK.match_fn({}, {'/kidslock/vs/0': {}}) is True
+        assert common.KIDS_LOCK_VS_FALLBACK.match_fn(
+            {}, {'/kidslock/0': {}, '/kidslock/vs/0': {}}) is False
+
+
+class TestRemoteControlFallback:
+    def test_generic_read(self):
+        assert common.REMOTE_CONTROL_GENERIC.href == '/remotectrl/0'
+        desc = common.REMOTE_CONTROL_GENERIC.entities[0]
+        assert desc.value_fn(True) is True
+        assert desc.value_fn(False) is False
+
+    def test_vs_fallback_gated(self):
+        assert common.REMOTE_CONTROL_VS_FALLBACK.match_fn({}, {'/remotectrl/vs/0': {}}) is True
+        assert common.REMOTE_CONTROL_VS_FALLBACK.match_fn(
+            {}, {'/remotectrl/0': {}, '/remotectrl/vs/0': {}}) is False
+
+
+# ---------------------------------------------------------------------------
+# Energy meter. instantaneousPower clamps negatives to 0, but the constant
+# '-500' sentinel (a dead field on DA_WM_ laundry + dishwasher dumps, issue #6)
+# gates power_watts out entirely so it doesn't read as a real idle "0 W".
+# ---------------------------------------------------------------------------
+
+
+class TestEnergyMeter:
+    def test_href(self):
+        assert common.ENERGY_METER.href == '/energy/consumption/vs/0'
+
+    def test_power_clamps_negative(self):
+        pw = next(e for e in common.ENERGY_METER.entities if e.key == 'power_watts')
+        assert pw.value_fn(-500.0) == 0.0
+        assert pw.value_fn(93.0) == 93.0
+
+    def test_power_watts_hidden_for_dead_sentinel(self):
+        pw = next(e for e in common.ENERGY_METER.entities if e.key == 'power_watts')
+        assert pw.exists_fn({'x.com.samsung.da.instantaneousPower': '-500'}, {}) is False
+
+    def test_power_watts_shown_for_real_value(self):
+        pw = next(e for e in common.ENERGY_METER.entities if e.key == 'power_watts')
+        assert pw.exists_fn({'x.com.samsung.da.instantaneousPower': '150'}, {}) is True
+
+    def test_energy_kwh_hidden_when_cumulative_power_absent(self):
+        kwh = next(e for e in common.ENERGY_METER.entities if e.key == 'energy_kwh')
+        assert kwh.exists_fn({'x.com.samsung.da.instantaneousPower': '-500'}, {}) is False
+
+    def test_energy_kwh_shown_when_present(self):
+        kwh = next(e for e in common.ENERGY_METER.entities if e.key == 'energy_kwh')
+        assert kwh.exists_fn({'x.com.samsung.da.cumulativePower': '58900'}, {}) is True
+
+    def test_both_entities_included_on_empty_stub(self):
+        """An empty {} rep means the resource exists but data isn't fetched yet
+        (see entity._is_included) -- include both so sub-polls populate them."""
+        pw = next(e for e in common.ENERGY_METER.entities if e.key == 'power_watts')
+        kwh = next(e for e in common.ENERGY_METER.entities if e.key == 'energy_kwh')
+        assert pw.exists_fn({}, {}) is True
+        assert kwh.exists_fn({}, {}) is True
+
+    def test_power_watts_hidden_when_field_absent_in_populated_rep(self):
+        """A populated rep that lacks instantaneousPower must not spawn a
+        phantom power sensor (the exists_fn replaces the field-presence gate)."""
+        pw = next(e for e in common.ENERGY_METER.entities if e.key == 'power_watts')
+        assert pw.exists_fn({'x.com.samsung.da.cumulativePower': '5'}, {}) is False

tests/test_dishwasher_capabilities.py

@@ -1,51 +1,49 @@
-"""Tests for dishwasher-specific capabilities."""
-from custom_components.localthings.registry.capabilities import dishwasher
+"""Tests for dishwasher-specific capabilities.
+
+The shared /course/vs/0 cycle-select machinery (parse_edit_course_list,
+cycle_options, cycle_write) is tested in test_laundry_capabilities.py; here we
+check the dishwasher wiring and its device-specific options.
+"""
+from custom_components.localthings.registry.capabilities import dishwasher, laundry
 
 
 class TestCycleOptions:
-    def test_parses_edit_course_list(self):
-        raw = 'EditCourseList_0E07908683848D808E8F'
-        assert dishwasher._parse_edit_course_list(raw) == [
-            '0E', '07', '90', '86', '83', '84', '8D', '80', '8E', '8F',
-        ]
+    def _cycle(self):
+        return next(e for e in dishwasher.CYCLE_OPTIONS.entities if e.key == 'cycle')
 
-    def test_parse_edit_course_list_handles_missing_or_malformed(self):
-        assert dishwasher._parse_edit_course_list(None) == []
-        assert dishwasher._parse_edit_course_list('') == []
-        assert dishwasher._parse_edit_course_list('no underscore') == []
-
-    def test_cycle_options_reads_live_edit_course_list(self):
-        resources = {
-            '/wm/editcourse/vs/0': {
-                'x.com.samsung.da.editCourseList': 'EditCourseList_0E9086',
-            },
-        }
-        assert dishwasher._cycle_options(resources) == ['0E', '90', '86']
-
-    def test_cycle_options_empty_when_resource_absent(self):
-        assert dishwasher._cycle_options({}) == []
-
-    def test_cycle_options_empty_when_resource_empty(self):
-        resources = {'/wm/editcourse/vs/0': {}}
-        assert dishwasher._cycle_options(resources) == []
-
-    def test_cycle_desc_uses_cycle_options_callable(self):
-        desc = next(e for e in dishwasher.CYCLE_OPTIONS.entities if e.key == 'cycle')
-        assert desc.options is dishwasher._cycle_options
+    def test_cycle_desc_uses_shared_cycle_options(self):
+        desc = self._cycle()
+        assert desc.options is laundry.cycle_options
         assert desc.translation_key == 'dishwasher_cycle'
 
     def test_exists_only_when_edit_course_list_is_live(self):
-        desc = next(e for e in dishwasher.CYCLE_OPTIONS.entities if e.key == 'cycle')
+        desc = self._cycle()
         assert desc.exists_fn({}, {}) is False
         assert desc.exists_fn({}, {'/wm/editcourse/vs/0': {}}) is False
         live = {'/wm/editcourse/vs/0': {'x.com.samsung.da.editCourseList': 'EditCourseList_0E'}}
         assert desc.exists_fn({}, live) is True
 
     def test_cycle_write_uses_raw_code_directly(self):
-        desc = next(e for e in dishwasher.CYCLE_OPTIONS.entities if e.key == 'cycle')
+        desc = self._cycle()
         rep = {'x.com.samsung.da.options': ['DeviceType_0001', 'Course_0E', 'GMT_04']}
         path, body = desc.write_fn('90', rep)
         assert path == ['course', 'vs', '0']
         assert body == {
             'x.com.samsung.da.options': ['DeviceType_0001', 'Course_90', 'GMT_04'],
         }
+
+
+class TestDishwasherOptions:
+    def test_storm_wash_read_and_write(self):
+        desc = next(e for e in dishwasher.CYCLE_OPTIONS.entities if e.key == 'storm_wash')
+        assert desc.rep_fn({'x.com.samsung.da.options': ['StormWashZone_On']}) is True
+        assert desc.rep_fn({'x.com.samsung.da.options': ['StormWashZone_Off']}) is False
+        path, body = desc.write_fn('Off', {'x.com.samsung.da.options': ['StormWashZone_On']})
+        assert path == ['course', 'vs', '0']
+        assert 'StormWashZone_Off' in body['x.com.samsung.da.options']
+
+    def test_auto_release_exists_only_when_field_present(self):
+        desc = next(e for e in dishwasher.CYCLE_OPTIONS.entities if e.key == 'auto_release_dry')
+        assert desc.exists_fn({'x.com.samsung.da.options': []}, {}) is False
+        assert desc.exists_fn(
+            {'x.com.samsung.da.options': ['AutoDoorRelease_On']}, {}) is True

tests/test_dryer_capabilities.py

@@ -0,0 +1,77 @@
+"""Tests for dryer support and washer/dryer consistency (issue #14)."""
+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 dryer, ignored, laundry
+from custom_components.localthings.registry.discovery import discover
+
+from tests.conftest import _load_device
+
+
+def _dryer():
+    resources = _load_device('dryer')
+    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 = _dryer()
+    bound = discover(resources, reg.capabilities, reg.pattern_capabilities)
+    return flatten(bound, resources)
+
+
+def test_dryer_model_resolves_to_dryer_registry():
+    reg, _ = _dryer()
+    assert reg is not None and reg.name == 'dryer'
+
+
+def test_no_unbound_hrefs():
+    """Every resource in the issue #14 dump binds or is ignored -- clears the
+    coverage-gap repair."""
+    reg, resources = _dryer()
+    unbound = []
+    discover(resources, reg.capabilities, reg.pattern_capabilities, log=unbound.append)
+    assert unbound == []
+
+
+def test_expected_entities_present():
+    state = _state()
+    for key in ('buzzer_sound', 'cycle', 'power_switch', 'child_lock',
+                'remote_control', 'dry_level', 'wrinkle_prevent', 'energy_kwh'):
+        assert key in state, key
+
+
+def test_job_beginning_status_reads_current_status():
+    """The dump carries x.com.samsung.da.currentStatus (not the old
+    jobBeginingStatus field the dryer descriptor used to read), so the sensor
+    is populated instead of blank."""
+    assert _state()['job_beginning_status'] == 'None'  # the dump's currentStatus value
+
+
+def test_power_watts_gated_for_dead_sentinel():
+    """instantaneousPower is the dead '-500' sentinel on this dryer, so the
+    misleading 0 W power sensor is suppressed; cumulative energy still shows."""
+    state = _state()
+    assert 'power_watts' not in state
+    assert 'energy_kwh' in state
+
+
+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."""
+    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 desc.options is laundry.cycle_options
+    rep = {'x.com.samsung.da.options': ['Course_16', 'GMT_02']}
+    assert desc.rep_fn(rep) == '16'
+
+
+def test_st_dryercourse_is_ignored():
+    """/st/dryercourse/vs/0 re-encodes the course exposed via /course/vs/0 and
+    is globally ignored -- the mirror of /st/washercourse/vs/0."""
+    ignored_hrefs = {c.href for c in ignored.IGNORED}
+    assert '/st/dryercourse/vs/0' in ignored_hrefs
+    assert '/st/washercourse/vs/0' in ignored_hrefs

tests/test_entities.py

@@ -1,6 +1,6 @@
 from custom_components.localthings.registry.entities import (
     SensorDesc, BinarySensorDesc, SelectDesc, SwitchDesc, ButtonDesc,
-    NumberDesc, PLATFORM_OF,
+    NumberDesc, TimeDesc, ClimateDesc, PLATFORM_OF,
 )
 
 
@@ -26,6 +26,8 @@ def test_platform_mapping_covers_all_subclasses():
     assert PLATFORM_OF[SwitchDesc] == 'switch'
     assert PLATFORM_OF[ButtonDesc] == 'button'
     assert PLATFORM_OF[NumberDesc] == 'number'
+    assert PLATFORM_OF[TimeDesc] == 'time'
+    assert PLATFORM_OF[ClimateDesc] == 'climate'
 
 
 def test_select_carries_options_and_write_fn():

tests/test_fridge_capabilities.py

@@ -0,0 +1,104 @@
+"""Tests for fridge-specific capabilities."""
+from custom_components.localthings.registry.capabilities import fridge
+
+
+class TestTempCurrentGeneric:
+    """Issue #7: unit must be read live from the device, not assumed to be
+    Fahrenheit -- a TP1X_REF_21K fridge (RL38C6B0CWW/EG) reports the same
+    resource in Celsius."""
+
+    def test_unit_reads_celsius(self):
+        desc = fridge.TEMP_CURRENT_GENERIC.entities[0]
+        assert desc.unit_fn({'temperature': 3.0, 'units': 'C'}) == '°C'
+
+    def test_unit_reads_fahrenheit(self):
+        desc = fridge.TEMP_CURRENT_GENERIC.entities[0]
+        assert desc.unit_fn({'temperature': 5.0, 'units': 'F'}) == '°F'
+
+    def test_unit_defaults_to_fahrenheit_when_missing(self):
+        desc = fridge.TEMP_CURRENT_GENERIC.entities[0]
+        assert desc.unit_fn({'temperature': 5.0}) == '°F'
+
+
+class TestTempSetpointGeneric:
+    def test_unit_reads_celsius(self):
+        desc = fridge.TEMP_SETPOINT_GENERIC.entities[0]
+        assert desc.unit_fn({'temperature': -19.0, 'units': 'C'}) == '°C'
+
+
+class TestTemperaturesFallback:
+    """Aggregate /temperatures/vs/0 -- per-item unit from
+    x.com.samsung.da.unit ('Celsius'/'Fahrenheit')."""
+
+    def test_freezer_unit_celsius(self):
+        desc = next(e for e in fridge.TEMPERATURES_FALLBACK.entities
+                    if e.key == 'freezer_temperature')
+        rep = {'x.com.samsung.da.items': [
+            {'x.com.samsung.da.description': 'Freezer', 'x.com.samsung.da.current': '-19',
+             'x.com.samsung.da.unit': 'Celsius'},
+            {'x.com.samsung.da.description': 'Fridge', 'x.com.samsung.da.current': '3',
+             'x.com.samsung.da.unit': 'Celsius'},
+        ]}
+        assert desc.unit_fn(rep) == '°C'
+        assert desc.value_fn(rep['x.com.samsung.da.items']) == -19
+
+    def test_fridge_unit_fahrenheit(self):
+        desc = next(e for e in fridge.TEMPERATURES_FALLBACK.entities
+                    if e.key == 'fridge_temperature')
+        rep = {'x.com.samsung.da.items': [
+            {'x.com.samsung.da.description': 'Fridge', 'x.com.samsung.da.current': '37',
+             'x.com.samsung.da.unit': 'Fahrenheit'},
+        ]}
+        assert desc.unit_fn(rep) == '°F'
+
+    def test_unit_defaults_to_fahrenheit_when_item_missing(self):
+        desc = next(e for e in fridge.TEMPERATURES_FALLBACK.entities
+                    if e.key == 'freezer_temperature')
+        assert desc.unit_fn({'x.com.samsung.da.items': []}) == '°F'
+
+
+class TestDefrostBlockStatus:
+    """DEFROST_BLOCK_ON means the defrost cycle is actively running, not
+    that defrost is being withheld -- confirmed against live dumps showing
+    it ON while defrost_delay is off."""
+
+    def test_key_and_name_reflect_active_defrosting(self):
+        desc = fridge.DEFROST_BLOCK_STATUS.entities[0]
+        assert desc.key == 'defrost_active'
+
+    def test_value_fn(self):
+        desc = fridge.DEFROST_BLOCK_STATUS.entities[0]
+        assert desc.value_fn(['DEFROST_BLOCK_ON']) is True
+        assert desc.value_fn(['DEFROST_BLOCK_OFF']) is False
+
+
+class TestRefrigerationFallback:
+    """/refrigeration/0 duplicates two of REFRIGERATION's (/refrigeration/vs/0)
+    fields under different names (rapidFreeze/rapidCool vs
+    rapidFreezing/rapidFridge) but also carries one genuinely new field
+    (defrost) that has no vs-href equivalent."""
+
+    def test_href(self):
+        assert fridge.REFRIGERATION_FALLBACK.href == '/refrigeration/0'
+
+    def test_defrost_active_is_fallback_of_defrost_block_status(self):
+        # Duplicates DEFROST_BLOCK_STATUS's defrost_active
+        # (/defrost/block/vs/0) -- only a true fallback when that richer
+        # href is absent (issue #7's device: /refrigeration/0 only).
+        desc = next(e for e in fridge.REFRIGERATION_FALLBACK.entities
+                    if e.key == 'defrost_active')
+        assert desc.value_fn(True) is True
+        assert desc.value_fn(False) is False
+        assert desc.exists_fn({}, {'/refrigeration/0': {}}) is True
+        assert desc.exists_fn(
+            {}, {'/refrigeration/0': {}, '/defrost/block/vs/0': {}}) is False
+
+    def test_rapid_switches_hidden_when_vs_href_present(self):
+        for key in ('rapid_fridge', 'rapid_freezing'):
+            desc = next(e for e in fridge.REFRIGERATION_FALLBACK.entities if e.key == key)
+            assert desc.exists_fn({}, {'/refrigeration/vs/0': {}, '/refrigeration/0': {}}) is False
+
+    def test_rapid_switches_shown_when_vs_href_absent(self):
+        for key in ('rapid_fridge', 'rapid_freezing'):
+            desc = next(e for e in fridge.REFRIGERATION_FALLBACK.entities if e.key == key)
+            assert desc.exists_fn({}, {'/refrigeration/0': {}}) is True

tests/test_golden_regression.py

@@ -57,6 +57,30 @@ def test_registry_reproduces_golden_state_keys_for_washer():
     )
 
 
+def test_registry_reproduces_golden_state_keys_for_dryer():
+    from tests.conftest import _load_device
+    resources = _load_device('dryer')
+    golden = json.loads((GOLDEN / 'dryer.json').read_text())
+    state_keys = _new_state_keys('dryer', 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_airconditioner():
+    from tests.conftest import _load_device
+    resources = _load_device('airconditioner')
+    golden = json.loads((GOLDEN / 'airconditioner.json').read_text())
+    state_keys = _new_state_keys('airconditioner', 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 = {

tests/test_laundry_capabilities.py

@@ -0,0 +1,95 @@
+"""Tests for the shared laundry capabilities (washer/dryer/dishwasher)."""
+from custom_components.localthings.registry.capabilities import laundry
+
+
+class TestCourseHelpers:
+    def test_parses_edit_course_list(self):
+        raw = 'EditCourseList_1C1D211B1E29243328262722202325322F2E30662D8F96'
+        assert laundry.parse_edit_course_list(raw) == [
+            '1C', '1D', '21', '1B', '1E', '29', '24', '33', '28', '26', '27',
+            '22', '20', '23', '25', '32', '2F', '2E', '30', '66', '2D', '8F', '96',
+        ]
+
+    def test_parse_edit_course_list_handles_missing_or_malformed(self):
+        assert laundry.parse_edit_course_list(None) == []
+        assert laundry.parse_edit_course_list('') == []
+        assert laundry.parse_edit_course_list('no underscore') == []
+
+    def test_cycle_options_reads_live_edit_course_list(self):
+        """The device's own course list -- including a code ('65') never seen
+        on the primary dump -- is used as-is; there is no hardcoded table."""
+        resources = {
+            '/wm/editcourse/vs/0': {
+                'x.com.samsung.da.editCourseList': 'EditCourseList_651C',
+            },
+        }
+        assert laundry.cycle_options(resources) == ['65', '1C']
+
+    def test_cycle_options_empty_when_resource_absent_or_empty(self):
+        assert laundry.cycle_options({}) == []
+        assert laundry.cycle_options({'/wm/editcourse/vs/0': {}}) == []
+
+    def test_option_value(self):
+        opts = ['DeviceType_0167', 'Course_1C', 'GMT_04']
+        assert laundry.option_value(opts, 'Course') == '1C'
+        assert laundry.option_value(opts, 'Missing') is None
+
+
+class TestCycleSelect:
+    def test_builds_labelled_cycle_select(self):
+        desc = laundry.cycle_select(translation_key='dryer_cycle', icon='mdi:tumble-dryer')
+        assert desc.key == 'cycle'
+        assert desc.translation_key == 'dryer_cycle'
+        assert desc.icon == 'mdi:tumble-dryer'
+        assert desc.options is laundry.cycle_options
+
+    def test_reads_raw_course_code_from_options(self):
+        desc = laundry.cycle_select(translation_key='dryer_cycle', icon='x')
+        rep = {'x.com.samsung.da.options': ['DeviceType_0167', 'Course_16', 'GMT_04']}
+        assert desc.rep_fn(rep) == '16'
+        assert desc.rep_fn({'x.com.samsung.da.options': ['GMT_04']}) is None
+
+    def test_exists_only_when_edit_course_list_is_live(self):
+        desc = laundry.cycle_select(translation_key='dryer_cycle', icon='x')
+        assert desc.exists_fn({}, {}) is False
+        assert desc.exists_fn({}, {'/wm/editcourse/vs/0': {}}) is False
+        live = {'/wm/editcourse/vs/0': {'x.com.samsung.da.editCourseList': 'EditCourseList_16'}}
+        assert desc.exists_fn({}, live) is True
+
+    def test_cycle_write_rmw_on_options(self):
+        desc = laundry.cycle_select(translation_key='dryer_cycle', icon='x')
+        rep = {'x.com.samsung.da.options': ['DeviceType_0167', 'Course_16', 'GMT_04']}
+        path, body = desc.write_fn('1D', rep)
+        assert path == ['course', 'vs', '0']
+        assert body == {
+            'x.com.samsung.da.options': ['DeviceType_0167', 'Course_1D', 'GMT_04'],
+        }
+
+    def test_cycle_write_noop_without_options(self):
+        desc = laundry.cycle_select(translation_key='dryer_cycle', icon='x')
+        assert desc.write_fn('1D', {}) is None
+
+
+class TestBuzzerSound:
+    def test_href(self):
+        assert laundry.BUZZER_SOUND.href == '/buzzersound/vs/0'
+
+    def test_buzzer_sound_write(self):
+        desc = next(e for e in laundry.BUZZER_SOUND.entities if e.key == 'buzzer_sound')
+        assert desc.options_field == 'supportedBuzzerSound'
+        path, body = desc.write_fn('On', {})
+        assert path == ['buzzersound', 'vs', '0']
+        assert body == {'setBuzzerSound': 'On'}
+
+    def test_finish_sound_exists_only_when_supported(self):
+        desc = next(e for e in laundry.BUZZER_SOUND.entities if e.key == 'finish_sound')
+        assert desc.exists_fn({'setBuzzerSound': 'On'}, {}) is False
+        assert desc.exists_fn({'supportedFinishSound': ['FinishSound_1']}, {}) is True
+
+
+class TestJobBeginningStatus:
+    def test_href_and_field(self):
+        assert laundry.JOB_BEGINNING_STATUS.href == '/wm/jobbeginingstatus/vs/0'
+        desc = laundry.JOB_BEGINNING_STATUS.entities[0]
+        assert desc.field == 'x.com.samsung.da.currentStatus'
+        assert desc.entity_category == 'diagnostic'

tests/test_operational_capability.py

@@ -8,6 +8,22 @@ def test_machine_state_maps_samsung_to_ocf():
     assert ms.value_fn('Ready') == 'idle'
 
 
+class TestProgressPercentage:
+    """issue #9: device firmware leaves progressPercentage stale (e.g. '1')
+    after a cycle ends instead of resetting it, so it must be gated on
+    active state the same way `progress`/`cycle_active`/`finish_time` are."""
+
+    def test_zeroed_when_not_active(self):
+        desc = next(e for e in OPERATIONAL_STATE.entities if e.key == 'progress_percentage')
+        rep = {'x.com.samsung.da.state': 'Ready', 'x.com.samsung.da.progressPercentage': '1'}
+        assert desc.rep_fn(rep) == 0
+
+    def test_passes_through_when_active(self):
+        desc = next(e for e in OPERATIONAL_STATE.entities if e.key == 'progress_percentage')
+        rep = {'x.com.samsung.da.state': 'Run', 'x.com.samsung.da.progressPercentage': '42'}
+        assert desc.rep_fn(rep) == 42
+
+
 class TestDelayFieldFallback:
     def test_reads_delay_end_time_when_delay_start_time_absent(self):
         from custom_components.localthings.registry.capabilities.operational import OPERATIONAL_STATE

tests/test_select_options.py

@@ -36,7 +36,7 @@ def test_options_field_unaffected():
 def test_callable_options_receives_full_resource_snapshot():
     """A callable options is handed the coordinator's full href->rep
     snapshot, not just this entity's own href's rep -- needed for course
-    lists decoded from a sibling resource (see washer._cycle_options)."""
+    lists decoded from a sibling resource (see laundry.cycle_options)."""
     calls = []
 
     def _options_fn(resources):

tests/test_washer_capabilities.py

@@ -1,5 +1,10 @@
-"""Tests for washer-specific capabilities."""
-from custom_components.localthings.registry.capabilities import washer
+"""Tests for washer-specific capabilities.
+
+Shared laundry capabilities (cycle-select machinery, buzzer, job status) are
+tested in test_laundry_capabilities.py; the OCF power/kids-lock/remote-control
+fallback pairs and the energy meter in test_common_capabilities.py.
+"""
+from custom_components.localthings.registry.capabilities import laundry, washer
 
 
 def _rep_by_href(cap, href):
@@ -57,7 +62,7 @@ class TestWasherCourse:
 
     def test_cycle_desc_uses_cycle_options_callable(self):
         desc = next(e for e in washer.WASHER_COURSE.entities if e.key == 'cycle')
-        assert desc.options is washer._cycle_options
+        assert desc.options is laundry.cycle_options
 
     def test_exists_only_when_edit_course_list_is_live(self):
         """No hardcoded course table is kept -- the selector only appears
@@ -79,119 +84,152 @@ class TestWasherCourse:
         }
 
 
-class TestCycleOptions:
-    def test_parses_edit_course_list(self):
-        raw = 'EditCourseList_1C1D211B1E29243328262722202325322F2E30662D8F96'
-        assert washer._parse_edit_course_list(raw) == [
-            '1C', '1D', '21', '1B', '1E', '29', '24', '33', '28', '26', '27',
-            '22', '20', '23', '25', '32', '2F', '2E', '30', '66', '2D', '8F', '96',
-        ]
+class TestDrumClean:
+    def test_cycles_remaining(self):
+        """DrumCleanProposal_40 - WashingTimes_3 == 37, matching a live
+        app screenshot's 'Potreba cistenia po 37 cykloch'."""
+        desc = next(e for e in washer.WASHER_COURSE.entities
+                    if e.key == 'drum_clean_cycles_remaining')
+        rep = {'x.com.samsung.da.options': ['WashingTimes_3', 'DrumCleanProposal_40']}
+        assert desc.rep_fn(rep) == 37
 
-    def test_parse_edit_course_list_handles_missing_or_malformed(self):
-        assert washer._parse_edit_course_list(None) == []
-        assert washer._parse_edit_course_list('') == []
-        assert washer._parse_edit_course_list('no underscore') == []
+    def test_cycles_remaining_never_negative(self):
+        desc = next(e for e in washer.WASHER_COURSE.entities
+                    if e.key == 'drum_clean_cycles_remaining')
+        rep = {'x.com.samsung.da.options': ['WashingTimes_50', 'DrumCleanProposal_40']}
+        assert desc.rep_fn(rep) == 0
 
-    def test_cycle_options_reads_live_edit_course_list(self):
-        """A different washer model's own course list -- including a code
-        ('65') never seen on the primary dump -- is used as-is; there is
-        no hardcoded table to fall back to or reconcile against."""
-        resources = {
-            '/wm/editcourse/vs/0': {
-                'x.com.samsung.da.editCourseList': 'EditCourseList_651C',
-            },
-        }
-        assert washer._cycle_options(resources) == ['65', '1C']
+    def test_cycles_remaining_missing_fields(self):
+        desc = next(e for e in washer.WASHER_COURSE.entities
+                    if e.key == 'drum_clean_cycles_remaining')
+        assert desc.rep_fn({'x.com.samsung.da.options': []}) is None
 
-    def test_cycle_options_empty_when_resource_absent(self):
-        assert washer._cycle_options({}) == []
+    def test_cycles_remaining_exists_only_when_computable(self):
+        desc = next(e for e in washer.WASHER_COURSE.entities
+                    if e.key == 'drum_clean_cycles_remaining')
+        assert desc.exists_fn({'x.com.samsung.da.options': []}, {}) is False
+        rep = {'x.com.samsung.da.options': ['WashingTimes_3', 'DrumCleanProposal_40']}
+        assert desc.exists_fn(rep, {}) is True
 
-    def test_cycle_options_empty_when_resource_empty(self):
-        """The second known washer dump has /wm/editcourse/vs/0 == {}."""
-        resources = {'/wm/editcourse/vs/0': {}}
-        assert washer._cycle_options(resources) == []
+    def test_last_cleaned(self):
+        """DrumCleanLog_2026-07-01T20:18:07 -> a UTC-aware datetime,
+        matching the same screenshot's '10 days ago' (as of 2026-07-11)."""
+        desc = next(e for e in washer.WASHER_COURSE.entities
+                    if e.key == 'drum_clean_last_cleaned')
+        rep = {'x.com.samsung.da.options': ['DrumCleanLog_2026-07-01T20:18:07']}
+        from datetime import datetime, timezone
+        assert desc.rep_fn(rep) == datetime(2026, 7, 1, 20, 18, 7, tzinfo=timezone.utc)
+
+    def test_last_cleaned_missing(self):
+        desc = next(e for e in washer.WASHER_COURSE.entities
+                    if e.key == 'drum_clean_last_cleaned')
+        assert desc.rep_fn({'x.com.samsung.da.options': []}) is None
+        assert desc.exists_fn({'x.com.samsung.da.options': []}, {}) is False
 
 
-class TestBuzzerSound:
-    def test_href(self):
-        assert washer.BUZZER_SOUND.href == '/buzzersound/vs/0'
-
-    def test_buzzer_sound_write(self):
-        desc = next(e for e in washer.BUZZER_SOUND.entities if e.key == 'buzzer_sound')
-        path, body = desc.write_fn('Volume_High', {})
-        assert path == ['buzzersound', 'vs', '0']
-        assert body == {'setBuzzerSound': 'Volume_High'}
-
-    def test_finish_sound_exists_only_when_supported(self):
-        desc = next(e for e in washer.BUZZER_SOUND.entities if e.key == 'finish_sound')
-        assert desc.exists_fn({'setBuzzerSound': 'On'}, {}) is False
-        assert desc.exists_fn({'supportedFinishSound': ['FinishSound_1']}, {}) is True
-
-    def test_finish_sound_write(self):
-        desc = next(e for e in washer.BUZZER_SOUND.entities if e.key == 'finish_sound')
-        path, body = desc.write_fn('FinishSound_2', {})
-        assert path == ['buzzersound', 'vs', '0']
-        assert body == {'setFinishSound': 'FinishSound_2'}
+# Raw options array from issue #9's diagnostic dump (trimmed to the fields
+# relevant to detergent/softener dosing).
+_DOSING_OPTIONS = [
+    'Course_1C',
+    'DetergentAlarm_Off',
+    'SoftenerAlarm_Off',
+    'DetergentLevelCtrl_3',
+    'SoftenerLevelCtrl_3',
+    'SupportedDetergentLevelCtrl_00010203',
+    'SupportedSoftenerLevelCtrl_00010203',
+    'DetergentLevel2Ctrl_2',
+    'SoftenerLevel2Ctrl_2',
+    'SupportedDetergentLevel2Ctrl_010203',
+    'SupportedSoftenerLevel2Ctrl_010203',
+]
+_DOSING_RESOURCES = {'/course/vs/0': {'x.com.samsung.da.options': _DOSING_OPTIONS}}
 
 
-class TestJobBeginningStatus:
-    def test_href_and_field(self):
-        assert washer.WASHER_JOB_BEGINNING_STATUS.href == '/wm/jobbeginingstatus/vs/0'
-        desc = washer.WASHER_JOB_BEGINNING_STATUS.entities[0]
-        assert desc.field == 'x.com.samsung.da.currentStatus'
+class TestDetergentSoftenerDosing:
+    @staticmethod
+    def _desc(key):
+        return next(e for e in washer.WASHER_COURSE.entities if e.key == key)
 
+    def test_quantity_and_hardness_read(self):
+        """The device reports the level un-padded ('3'), but the options and
+        translation keys are zero-padded supported codes ('03'); rep_fn
+        normalizes to the supported code so the value is a valid option
+        (issue #9 -- otherwise HA renders the select 'unknown')."""
+        rep = {'x.com.samsung.da.options': _DOSING_OPTIONS}
+        assert self._desc('detergent_quantity').rep_fn(rep) == '03'
+        assert self._desc('detergent_water_hardness').rep_fn(rep) == '02'
+        assert self._desc('softener_quantity').rep_fn(rep) == '03'
+        assert self._desc('softener_concentration').rep_fn(rep) == '02'
 
-class TestPowerFallback:
-    def test_generic_href(self):
-        assert washer.POWER_GENERIC.href == '/power/0'
+    def test_current_value_is_a_valid_option_for_every_dosing_select(self):
+        """The core regression: HA shows a select 'unknown' when current_option
+        is not in options. Each dosing select's value must be one of its own
+        options."""
+        rep = {'x.com.samsung.da.options': _DOSING_OPTIONS}
+        for key in ('detergent_quantity', 'detergent_water_hardness',
+                    'softener_quantity', 'softener_concentration'):
+            desc = self._desc(key)
+            assert desc.rep_fn(rep) in desc.options(_DOSING_RESOURCES), key
 
-    def test_generic_read_write(self):
-        desc = washer.POWER_GENERIC.entities[0]
-        assert desc.value_fn(True) is True
-        assert desc.value_fn(False) is False
-        path, body = desc.write_fn('On', {})
-        assert path == ['power', '0']
-        assert body == {'value': True}
-        path, body = desc.write_fn('Off', {})
-        assert body == {'value': False}
+    def test_read_passes_through_when_no_supported_match(self):
+        """A value with no matching supported code is returned as-is rather than
+        dropped, so an unexpected device stays visible instead of blank."""
+        rep = {'x.com.samsung.da.options': ['DetergentLevelCtrl_7',
+                                            'SupportedDetergentLevelCtrl_00010203']}
+        assert self._desc('detergent_quantity').rep_fn(rep) == '7'
 
-    def test_vs_fallback_binds_only_when_generic_absent(self):
-        assert washer.POWER_VS_FALLBACK.href == '/power/vs/0'
-        assert washer.POWER_VS_FALLBACK.match_fn({}, {'/power/vs/0': {}}) is True
-        assert washer.POWER_VS_FALLBACK.match_fn({}, {'/power/0': {}, '/power/vs/0': {}}) is False
+    def test_translation_keys(self):
+        """detergent_quantity and softener_quantity share one translation_key
+        (same 00-03 -> None/Low/Medium/High vocabulary on both dispensers,
+        same shape as fridge.py's shared 'brightness_level' key); hardness
+        and concentration each have their own since their labels differ."""
+        assert self._desc('detergent_quantity').translation_key == 'washer_dosing_quantity'
+        assert self._desc('softener_quantity').translation_key == 'washer_dosing_quantity'
+        assert self._desc('detergent_water_hardness').translation_key == 'washer_detergent_water_hardness'
+        assert self._desc('softener_concentration').translation_key == 'washer_softener_concentration'
 
-    def test_vs_fallback_read_write(self):
-        desc = washer.POWER_VS_FALLBACK.entities[0]
-        assert desc.value_fn('On') is True
-        assert desc.value_fn('Off') is False
-        path, body = desc.write_fn('On', {})
-        assert path == ['power', 'vs', '0']
-        assert body == {'x.com.samsung.da.power': 'On'}
+    def test_quantity_and_hardness_options_decode_supported_list(self):
+        assert self._desc('detergent_quantity').options(_DOSING_RESOURCES) == ['00', '01', '02', '03']
+        assert self._desc('softener_quantity').options(_DOSING_RESOURCES) == ['00', '01', '02', '03']
+        assert self._desc('detergent_water_hardness').options(_DOSING_RESOURCES) == ['01', '02', '03']
+        assert self._desc('softener_concentration').options(_DOSING_RESOURCES) == ['01', '02', '03']
 
+    def test_exists_only_when_supported_list_present(self):
+        for key in ('detergent_quantity', 'detergent_water_hardness',
+                    'softener_quantity', 'softener_concentration'):
+            desc = self._desc(key)
+            assert desc.exists_fn({}, {}) is False
+            assert desc.exists_fn({}, _DOSING_RESOURCES) is True
 
-class TestKidsLockFallback:
-    def test_generic_read_write(self):
-        assert washer.KIDS_LOCK_GENERIC.href == '/kidslock/0'
-        desc = washer.KIDS_LOCK_GENERIC.entities[0]
-        assert desc.value_fn(True) is True
-        path, body = desc.write_fn('On', {})
-        assert path == ['kidslock', '0']
-        assert body == {'value': True}
+    def test_quantity_write(self):
+        """The UI selects a padded supported code ('01'); the write posts the
+        un-padded device code ('1'), mirroring how the device reports it."""
+        rep = {'x.com.samsung.da.options': list(_DOSING_OPTIONS)}
+        path, body = self._desc('detergent_quantity').write_fn('01', rep)
+        assert path == ['course', 'vs', '0']
+        assert 'DetergentLevelCtrl_1' in body['x.com.samsung.da.options']
+        assert 'DetergentLevelCtrl_3' not in body['x.com.samsung.da.options']
+        # untouched siblings survive the read-modify-write
+        assert 'SoftenerLevelCtrl_3' in body['x.com.samsung.da.options']
 
-    def test_vs_fallback_gated(self):
-        assert washer.KIDS_LOCK_VS_FALLBACK.match_fn({}, {'/kidslock/vs/0': {}}) is True
-        assert washer.KIDS_LOCK_VS_FALLBACK.match_fn(
-            {}, {'/kidslock/0': {}, '/kidslock/vs/0': {}}) is False
+    def test_hardness_write(self):
+        rep = {'x.com.samsung.da.options': list(_DOSING_OPTIONS)}
+        path, body = self._desc('softener_concentration').write_fn('03', rep)
+        assert path == ['course', 'vs', '0']
+        assert 'SoftenerLevel2Ctrl_3' in body['x.com.samsung.da.options']
 
+    def test_low_reservoir_off_when_alarm_off(self):
+        rep = {'x.com.samsung.da.options': _DOSING_OPTIONS}
+        assert self._desc('detergent_low').rep_fn(rep) is False
+        assert self._desc('softener_low').rep_fn(rep) is False
 
-class TestRemoteControlFallback:
-    def test_generic_read(self):
-        assert washer.REMOTE_CONTROL_GENERIC.href == '/remotectrl/0'
-        desc = washer.REMOTE_CONTROL_GENERIC.entities[0]
-        assert desc.value_fn(True) is True
-        assert desc.value_fn(False) is False
+    def test_low_reservoir_on_when_alarm_active(self):
+        opts = ['DetergentAlarm_On', 'SoftenerAlarm_On']
+        rep = {'x.com.samsung.da.options': opts}
+        assert self._desc('detergent_low').rep_fn(rep) is True
+        assert self._desc('softener_low').rep_fn(rep) is True
 
-    def test_vs_fallback_gated(self):
-        assert washer.REMOTE_CONTROL_VS_FALLBACK.match_fn({}, {'/remotectrl/vs/0': {}}) is True
-        assert washer.REMOTE_CONTROL_VS_FALLBACK.match_fn(
-            {}, {'/remotectrl/0': {}, '/remotectrl/vs/0': {}}) is False
+    def test_low_reservoir_exists_only_when_alarm_field_present(self):
+        assert self._desc('detergent_low').exists_fn({'x.com.samsung.da.options': []}, {}) is False
+        rep = {'x.com.samsung.da.options': _DOSING_OPTIONS}
+        assert self._desc('detergent_low').exists_fn(rep, {}) is True