Merge pull request #215 from mbillow/claude/issue-214-device-registration-d2smcv

fix(subdevices): don't materialize a slot whose only live state is a meter

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

@@ -5,9 +5,14 @@ description: >-
   /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,
+  routing an unrecognized board family to a registry (modelNum board tokens,
+  resource signatures),
   OCF-standard vs vendor hrefs, the diagnostic/config/normal entity taxonomy,
+  preferring dynamic (device-reported) select options over hardcoded lists,
   ensuring every href is bound or ignored, and locking it in with a fixture +
-  golden + test.
+  golden + test. Also covers multi-subdevice ("composite") appliances that
+  expose several logical indoor subdevices over one IP — triaging a missing
+  second subdevice, and why registry hrefs stay canonical rather than indexed.
 ---
 
 # Adding device support
@@ -22,11 +27,25 @@ dump into coverage.
 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.
+  source of truth**, not code comments. On a multi-subdevice appliance this is
+  the subdevice the config entry connects to and *only* that subdevice;
+  siblings report their own (see below).
 - `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`).
 
+Multi-subdevice appliances (one IP, one DTLS session, several logical indoor
+subdevices — issue #177) add four more, all absent/empty on an ordinary device:
+- `subdevices`: one entry per materialized sibling — `kind`/`key`/`seed_path`,
+  its own `model`, its bound hrefs, and its own `resources`.
+- `subdevices_skipped`: candidates whose seed answered but that produced no
+  live primary state, with the reps the gate actually judged. An unused
+  SmartThings slot lands here, not in `subdevices`.
+- `subdevice_probes`: `{seed_href: found}` for every seed attempted — tells
+  "checked, nothing there" apart from "never checked".
+- `multidevice`: `/multidevice/vs/0`'s rep if the board answers it. Its
+  `numofsubdevice` is a corroborating count, not a gate.
+
 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.
@@ -46,9 +65,7 @@ discovery = importlib.import_module('custom_components.localthings.registry.disc
 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
+reg = by_type.resolve(resources)      # the same entry point the coordinator uses
 unbound = []
 bound = discovery.discover(resources, reg.capabilities, reg.pattern_capabilities, log=unbound.append)
 state = adapter.flatten(bound, resources)   # {entity_key: value}
@@ -60,7 +77,101 @@ print('state_keys:', sorted(state))
 `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`)
+**A sibling subdevice's block runs through this unchanged.** `subdevices[i].resources`
+(and `subdevices_skipped[i].resources`) are keyed by *canonical* hrefs —
+`/mode/vs/0`, never the `/mode/vs/1` or `/<uuid>/mode/vs/0` that subdevice
+actually answers on — precisely so you can paste one into `resources` above and
+read the result exactly like the master's. No de-indexing by hand.
+
+## 3. Route the device to a registry — add a row, never a branch
+
+If detection returns `None`, the device falls back to common capabilities and
+loses roughly **half** its entities (measured across the fixture corpus: 843 of
+1510 bound entities survive). So routing is the first thing to fix, and
+`registry/by_type/__init__.py` is deliberately kept boring.
+
+`resolve(resources)` is the only entry point — the coordinator, the config
+flow's probe and the golden-regression harness all call it, so the order can't
+drift between what ships and what the tests assert. Two stages:
+
+1. **`for_device_by_model(model_num, description)`** — the primary path. Both
+   fields come from `/information/vs/0`. Board-family tokens are matched
+   against `modelNum` first, then `description`, then the fuzzy two-letter
+   consumer-model prefix.
+2. **`for_device_by_resources(resources)`** — for boards that report no
+   `/information/vs/0` at all. Needs a *distinctive* signature.
+
+**`oneUiVersion` is not consulted.** It looks like the obvious signal — the
+device naming its own type, `'7.0 Dishwasher'` — and it used to be stage one.
+But only a minority of hardware reports it, every device that does is already
+typed by its modelNum board token (`TestOneUiVersionIsNotConsulted` checks that
+against the whole corpus), and no device-support issue was ever fixed by adding
+a mapping for it. Don't reintroduce it as a detection stage; it stays in
+diagnostics as a firmware-generation marker (`'7.0 Air conditioner'` means
+Tizen Lite), which is useful when triaging.
+
+### Adding a board family
+
+Almost always a one-line addition to `_BOARD_TOKEN_TO_KEY`:
+
+```python
+'VSKR': 'vacuum_station',   # issue #131 -- stick-vacuum clean station
+```
+
+Matching is on **whole tokens** of the model string, split on any run of
+non-alphanumerics and upper-cased. That is what keeps this a table, and it
+carries rules:
+
+- **Never add a delimiter spelling.** `'_RAC_'` and `'-RAC-'` are the same
+  entry, `RAC`. If you find yourself adding a second row for punctuation, the
+  tokenizer already handled it.
+- **Name the specific type, never the board family.** `DA-AC-` prefixes
+  RAC/WAC/DHM/AIR alike — a bare `'AC'` row would swallow the dehumidifier
+  and the air purifier. Same for `DA`, `KS`, `WM`, `TP1X`, `ARTIK051`.
+  `TestBoardTokenTable` asserts these stay out.
+- **Never add a token that can co-occur with another.** `_board_family_key`
+  returns the first hit, which is only safe while no real model string
+  contains two tokens naming different types.
+  `TestBoardTokenAmbiguity` checks that invariant against every fixture, so a
+  new dump exercises it automatically — if it fails, the answer is a narrower
+  token, not a reordering.
+- **Two-letter tokens are a last resort.** `'CT'` (legacy gas cooktop) is the
+  only one, and it is loose enough to collide by accident.
+
+Reach past the table only when the evidence isn't a board token:
+
+- **Consumer-model prefix** (`_CONSUMER_PREFIX_TO_KEY`) — for washers, dryers
+  and dishwashers, whose `modelNum` is the shared `DA_WM_` laundry board and
+  whose real type is only in `description`'s trailing model code
+  (`..._WA8000T`). Deliberately split on `_` only: widening it to `-` would
+  read the dishwasher's `ADW-WW-RTL-24-AILITE` board segment as a `WW`
+  washer. Consulted last because a two-letter prefix is the weakest evidence
+  here — `WAC` (window AC) starts with `WA` (top-load washer).
+- **Resource signature** (`for_device_by_resources`) — only when
+  `/information/vs/0` is absent entirely. Require **two** independent shapes
+  (e.g. `/oven/vs/0` present *and* a `MicroWave*` entry in `supportedModes`),
+  never one, or an unrelated family's `/mode/vs/0` will match.
+
+### If the model string identifies nothing
+
+Check the diagnostics `identity` block before inventing a rule: it carries
+`/oic/p` and `/oic/d`, which sit outside the `/device/0` dump.
+`identity.device_types` is `/oic/d`'s `rt` — OCF's own device-type
+declaration (`oic.d.airconditioner`). Nothing routes on it yet because no
+captured dump has ever included it; if real hardware turns out to populate it,
+it beats parsing board part numbers and this whole section shrinks. Note in
+the issue when a dump has it.
+
+### Sharing a registry vs adding one
+
+Route a new family to an **existing** registry when its resource surface
+matches (most AC board families do — verify by checking the dump binds with
+zero unbound hrefs). Add a **new** registry only when the resources genuinely
+differ: `vacuum_station` earned one because it shares no hrefs with anything
+modelled; `microwave` split from `oven` over a distinct mode vocabulary,
+setpoint bounds, and a `powerLevel` field.
+
+## 4. 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.
@@ -82,7 +193,7 @@ resource from the populated dump:
 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
+## 5. Entity taxonomy — the judgement call
 
 For each field worth exposing, decide the entity kind and category
 (`entity_category` on the descriptor):
@@ -103,18 +214,89 @@ sub-polled between summary polls. Pick descriptor types from `entities.py`
 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
+This is a rule about **writes and entities**, not about reading. A speculative
+`GET` of an href a dump doesn't contain is fine and the codebase already relies
+on it: `read_identity` reads `/oic/p`, `/oic/d` and `/oic/res`, and
+`subdevices.enumerate_subdevices` probes `/device/<n>`, `/<uuid>/device/0` and
+`/multidevice/vs/0` on every device — and, when a prefixed candidate's own
+`/<uuid>/device/0` doesn't answer (issue #205: not guaranteed even on the
+board this pattern was built against), every href the master itself
+answered this cycle, individually under that UUID's prefix (see §11). A
+RETRIEVE is non-mutating and a 4.04 is tolerated everywhere in that path, so
+the cost of a wrong guess is one wasted round trip. Guessing a *write*
+against live hardware is the thing this rule forbids — as is materializing
+an entity from a field you can't explain.
 
-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. Select options: read them from the device, don't hardcode
 
-## 6. Coverage discipline: bound or ignored
+A `SelectDesc`'s `options` should come from the device's own advertised list
+whenever the resource carries one, not from a Python tuple typed in from a
+single dump. Two dynamic forms already exist in the repo and should be
+reached for first:
+- `options_field='x.com.samsung.da.supportedModes'` (or whatever the
+  resource's own supported-values field is called) — reads the live rep on
+  the capability's own href. See `laundry.py`'s `buzzer_sound`/
+  `finish_sound` (`options_field='supportedBuzzerSound'`/
+  `'supportedFinishSound'`).
+- `options=<callable>` — for option lists that live on a **different**
+  resource than the select's own href (e.g. a course table keyed off a
+  sibling href). See `laundry.cycle_select`'s `options=cycle_options`.
+
+A static `options=(...)` tuple is a coverage gap waiting to happen: the next
+dump from a different board generation will report modes/values the tuple
+doesn't have, and both the HA options list *and* `write_fn`'s validation (if
+it checks the same tuple) will silently reject values the device itself
+advertises as supported. That's exactly what happened with `oven._OVEN_MODES`
+in issue #138 — a hardcoded list rejected `AirFryer`/`Dehydrate`/
+`SelfClean`/etc. even though the device's own `supportedModes` field listed
+them. Reach for a static tuple only when the dump genuinely has no
+supported-values field to read (e.g. the NV7000BS-class oven dump
+`_OVEN_MODES` was inferred before any live oven dump existed — see that
+module's docstring), and treat it as an interim best-guess rather than a
+permanent design choice: migrate it to `options_field`/a callable the moment
+a dump with a real supported-values list surfaces, instead of just adding
+the new values to the static tuple.
+
+## 7. Names and enum labels live in translations, never in Python
+
+Descriptors have **no `name` field**. Every entity is named from the shipped
+catalog, keyed by `translation_key` — which defaults to the descriptor's own
+`key`. So adding `SensorDesc(key='filter_status', ...)` obliges you to add:
+
+```json
+"entity": { "sensor": { "filter_status": { "name": "Filter status" } } }
+```
+
+to `translations/en.json`. Skip it and the entity ships nameless;
+`tests/test_translations.py` fails the build instead.
+
+- **Sentence case** ("Filter status", not "Filter Status"), per HA's style
+  guide — capitalize only proper nouns and Samsung feature names ("AI Energy
+  Mode", "Storm Wash+").
+- Set `translation_key` explicitly only to **share** one catalog entry across
+  descriptors, or to point at a differently-named one. Two descriptors on the
+  same platform with the same `key` already share an entry — intended for
+  `common.py`'s OCF/vendor fallback pairs, a silent mislabel otherwise.
+- Prefer HA's own vocabulary where it fits: a `device_class` gives you
+  translated states for free (`binary_sensor` door/running, `sensor`
+  timestamp/enum), so don't restate them.
+
+Selects whose options are raw device codes (course/cycle, code-valued
+settings) additionally need those codes labelled:
+- `options`/`options_field` supply the **raw** codes; the catalog maps them.
+- Add labels under `entity.select.<translation_key>.state.<code>`, code
+  **lowercased** (e.g. `"16": "Cotton"`). `select.py` derives which values it
+  normalizes from the catalog itself, so there is no Python list to keep in
+  sync — a code with no entry simply renders as the raw code, which is the cue
+  to identify and name it.
+
+`translations/en.json` is the only place any of this lives: there is no
+`strings.json` (Home Assistant doesn't read one from a custom integration) and
+no `[%key:...%]` resolution (that's Core build tooling). Every other language
+must mirror `en.json` key for key — also enforced by
+`tests/test_translations.py`.
+
+## 8. 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`)
@@ -128,7 +310,18 @@ friendlier href**.
   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
+- **Registry hrefs are always canonical — never index or prefix one.** On a
+  multi-subdevice appliance, `unbound_hrefs` reports the *real* href a gap was
+  seen on, so a sibling's gap shows up as `/foo/vs/1` or
+  `/<uuid>/foo/vs/0`. Do **not** write `Capability(href='/foo/vs/1')` for it.
+  Binding runs against each subdevice's canonical view, so an indexed or
+  prefixed href in a registry matches nothing on any device and fails
+  silently — no error, no entity, and the gap stays open. Fix it on the
+  `/foo/vs/0` form and every subdevice gets it at once.
+  (`registry/subdevices.py` owns the canonical ⇄ actual translation; nothing
+  under `capabilities/` or `by_type/` should ever mention a subdevice index.)
+
+## 9. 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
@@ -137,20 +330,136 @@ 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
+## 10. 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.
+
+   A multi-subdevice dump (issue #177) may carry three more top-level keys, all
+   optional and defaulted for every other fixture — load them with
+   `conftest._load_device_full` rather than `_load_device`:
+   - `oic_res`: the raw `/oic/res` link array, which is what enumeration reads
+     to find `/device/<n>` siblings.
+   - `seeds`: `{seed_href: raw_batch_list}` — each sibling's own collection
+     response, in the same `[devcol rep, {href, rep}, ...]` shape as `device0`.
+   - `probes`: `{href: rep}` for plain Property-map resources belonging to no
+     batch (e.g. a hand-read `/multidevice/vs/0`).
+
+   Add a `seeds_note` saying which parts are verbatim captures and which were
+   constructed. A fixture that quietly mixes the two is worse than no fixture:
+   the whole point of the corpus is that it records what hardware actually did.
 2. Generate `tests/fixtures/golden/<type>.json` (`{"state_keys": [...]}`) with
-   the harness in §2.
+   the harness in §2. A multi-subdevice fixture's golden carries a sibling's
+   keys under a prefix (`subdevice1_climate`, `subdevice_<uuid>_climate`)
+   alongside the unprefixed master keys — that's the entity-ID namespacing,
+   not a bug.
+   The master's keys are unprefixed *by design* and must never gain one:
+   that's what keeps every pre-#177 device's `unique_id` stable.
 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.
 
+The new fixture is picked up automatically by the corpus-wide checks (the
+`all_device_fixtures` conftest fixture), including
+`TestBoardTokenAmbiguity` — so a model string that collides with an existing
+board token fails the build rather than silently mistyping someone's
+appliance.
+
+**Don't put a reporter's name or GitHub username in code.** Fixture data
+gets serials/MACs/other device PII scrubbed per point 1 above — the same
+rule applies to the *prose* you write while fixing the issue: comments,
+docstrings, `seeds_note`, and test/function names should say "the
+reporter," "issue #NNN's reporter," or (when a module already distinguishes
+multiple reporters, like `subdevices.py`'s Pattern A/Pattern B) "the
+Pattern A reporter," never a real name or handle. That prose ships in the
+package and lives in git history indefinitely — unlike an issue thread or a
+release-notes thank-you (both fine places to credit someone by name), it's
+not somewhere a person would expect to stay named forever. If you're fixing
+an issue and about to write `<username>'s board`/`<username>'s dump` in a
+comment, stop and swap in a generic reference instead.
+
+## 11. Triage: "one of my subdevices is missing"
+
+For an appliance that exposes several logical indoor subdevices over one IP —
+a 2-in-1 air conditioner, plausibly a multi-drum washer (#19). Work down
+the dump in this order; each step rules out a different cause.
+
+1. **`subdevice_probes`** — did we even look? Every seed attempted appears
+   here with what it returned. An absent seed means enumeration never tried
+   that path; a `false` means it tried and got nothing. On a UUID-prefixed
+   board whose `/<uuid>/device/0` reads `false` (issue #205 — this isn't
+   rare, not even on the board the pattern was built against), the report
+   also carries one probe per href the master itself answered that cycle,
+   individually under that prefix (`subdevices.enumerate_subdevices`'s flat
+   fallback) — a `true` there is real, confirmed-live evidence for that one
+   href, not a guess.
+2. **`subdevices`**/**`flat_hrefs`** — for a *materialized* subdevice found
+   this way, `flat_hrefs` lists exactly which hrefs it's actually being
+   polled on (individually, no Collection endpoint to batch through) —
+   compare against the master's own hrefs to see what's still unconfirmed
+   for that sibling.
+3. **`subdevices_skipped`** — did we find it and reject it? A candidate lands
+   here when its seed(s) answered but it produced no *primary*
+   (non-diagnostic), non-meter entity with a populated value. Its
+   `resources` block holds the exact reps the gate judged, so you can check
+   the call yourself. If every power/mode/temperature rep is `{}`, the
+   subdevice is an unused slot and the skip is correct — a populated
+   `/energy/consumption/vs/<n>` alongside them doesn't change that (issue
+   #214: an appliance's lifetime kWh counter shows up under an unused
+   slot's index too, and materializing on it produced a phantom duplicate
+   air conditioner, so cumulative meters are excluded from the gate). If
+   the *operational* reps are populated, the gate is wrong — that's a bug
+   worth a fixture. A flat-fallback candidate whose
+   only confirmed href is `/information/vs/0` (never bound to any entity —
+   only ever read for device-type resolution) will *always* land here until
+   more of its hrefs are confirmed live; that's the gate working as
+   intended, not a bug to chase.
+4. **`multidevice.numofsubdevice`** — the board's own count, where it
+   reports one. `coordinator._run_discovery` compares it against
+   `len(materialized) + 1` (materialized subdevices plus the master) and
+   only warns on disagreement — `subdevices_skipped` entries don't count
+   toward either side, since they never materialized. A strong hint, not
+   proof; only one board family is known to expose it.
+5. **Which pattern is this board?** `identity.resources['/oic/res']` listing
+   `/device/1`, `/device/2` means indexed siblings. `resources['/subdevices/
+   vs/0']` carrying a `subdeviceIdList` means a UUID-prefixed tree, and that
+   same UUID usually shows up as an href prefix in `/oic/res` too — enumerate
+   whether or not `/<uuid>/device/0` itself answers, per §5's fallback.
+   Neither present, on a device the owner insists has two subdevices, is the
+   interesting case — that's a third mechanism and needs a new dump, not a
+   code guess.
+
+Two things that are *not* the fix: adding a capability for an indexed href
+(see §8), and loosening the liveness gate to "any populated entity" — a
+rejected slot routinely reports a non-`None` *diagnostic* value off an empty
+resource (and, on some boards, a populated appliance-level meter), which is
+exactly what the primary-entity and meter filters exist to ignore.
+
+### The mirror image: "I have one subdevice too many"
+
+Same dump, read the other way (issue #214). A duplicate device in HA is
+either a candidate that shouldn't have materialized — check `subdevices`
+for one whose `resources` are all `{}` except a meter/`/information`, which
+is the unused-slot shape from step 3 — or a **leftover registry entry** from
+a release that did materialize it. Those two look identical in the HA UI and
+are told apart by the dump: a leftover shows `subdevices: []` (or no entry
+for that key) while the device is still listed in HA.
+
+Nothing prunes a leftover automatically — subdevice enumeration is one-shot
+and a real sibling can miss a poll, so auto-removal would throw away a live
+subdevice's name/area/automations on a transient miss. The integration
+implements `async_remove_config_entry_device`
+(`custom_components/localthings/__init__.py`) instead, which is what puts a
+working "Delete device" button on anything this entry no longer provides;
+devices it *does* provide refuse removal, since HA would just recreate them.
+Tell the reporter to delete the stale device, don't add a pruning pass.
+
 ## Key files
+- `registry/subdevices.py` — `Subdevice`, enumeration, canonical ⇄ actual href
+  translation, and the materialization gate for multi-subdevice appliances.
 - `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`).

README.md

@@ -1,3 +1,21 @@
+<!-- dark mode -->
+<img src="custom_components/localthings/brand/dark_logo@2x.png#gh-dark-mode-only" alt="LocalThings Logo"/>
+<!-- light mode -->
+<img src="custom_components/localthings/brand/logo@2x.png#gh-light-mode-only" alt="LocalThings Logo"/>
+
+<p align="center">
+  <img alt="GitHub Repo stars" src="https://img.shields.io/github/stars/mbillow/localthings" />
+  <img alt="GitHub watchers" src="https://img.shields.io/github/watchers/mbillow/localthings" />
+</p>
+
+<p align="center">
+  <img alt="GitHub Release" src="https://img.shields.io/github/v/release/mbillow/localthings" />
+  <img alt="hacs validation" src="https://img.shields.io/github/check-runs/mbillow/localthings/main?nameFilter=HACS%20validation&label=hacs%20validation" />
+  <img alt="hassfest" src="https://img.shields.io/github/check-runs/mbillow/localthings/main?nameFilter=Hassfest%20validation&label=hassfest" />
+  <img alt="tests" src="https://img.shields.io/github/check-runs/mbillow/localthings/main?nameFilter=Pytest&label=tests" />
+
+</p>
+
 # LocalThings
 
 **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.
@@ -18,14 +36,19 @@ Your state stays on your LAN: HA talks to the appliance over a direct DTLS sessi
 |---|---|
 | Air conditioner | `by_type/airconditioner.py` |
 | Air purifier | `by_type/air_purifier.py` |
+| Dehumidifier | `by_type/dehumidifier.py` |
 | Dryer | `by_type/dryer.py` |
 | Oven | `by_type/oven.py` |
-| Cooktop (read-only burner status) | `by_type/cooktop.py` |
+| Microwave | `by_type/microwave.py` |
+| Gas cooktop (read-only burner status) | `by_type/cooktop.py` |
 | Range hood | `by_type/range_hood.py` |
 | Range | `by_type/range.py` |
 | Dishwasher | `by_type/dishwasher.py` |
 | Refrigerator | `by_type/refrigerator.py` |
 | Washer | `by_type/washer.py` |
+| Water purifier | `by_type/water_purifier.py` |
+| Vacuum clean/auto-empty station | `by_type/vacuum_station.py` |
+| Air dresser | `by_type/air_dresser.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.
 
@@ -82,12 +105,13 @@ The `Dockerfile` builds on the official `home-assistant/home-assistant:stable` i
 ### Tests
 
 ```sh
-python3 -m venv .venv
+python3.13 -m venv .venv          # 3.13 or newer; see below
 .venv/bin/pip install -r requirements-dev.txt
-.venv/bin/pip install pytest-homeassistant-custom-component homeassistant
 .venv/bin/pytest tests/ -q
 ```
 
+`requirements-dev.txt` already pulls in Home Assistant and pytest at matching versions, so there's nothing to install alongside it. Use Python 3.13 or newer: pip resolves the newest `pytest-homeassistant-custom-component` your interpreter supports, and on 3.12 or older nothing resolves and the install fails outright. CI runs 3.14.
+
 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.
 
 ---
@@ -106,14 +130,17 @@ custom_components/localthings/
   entity.py                Base entity wiring capability registry -> HA entity
   sensor.py / binary_sensor.py / switch.py / number.py / select.py / button.py / time.py / fan.py / climate.py
                             One module per HA platform
-  strings.json / translations/   Config-flow copy + entity state translations
+  catalog.py               Reads the shipped translation catalog (which keys/states exist)
+  translations/            Config-flow copy + entity name/state translations, one file per
+                            language; en.json is the source of truth (no strings.json —
+                            Home Assistant never reads one from a custom integration)
   registry/
     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
+    identity.py              Reads /oic/p + /oic/d (manufacturer, model, OCF device type)
     redact.py                 Strips account/identity data before diagnostics leave HA
     capabilities/             Shared + per-family Capability definitions (common, airconditioner,
                                cooktop, range_hood, dryer, oven, dishwasher, fridge, washer,
@@ -143,7 +170,9 @@ support for hardware the maintainers don't have.
 1. Get a capture of the appliance's `/device/0` response. The easiest way: add the device to HA (type detection failing is fine) and pull its Diagnostics download from Settings > Devices & Services > the device > the menu > Download diagnostics — it already contains a redacted dump of the device's resources.
 2. Reuse existing `Capability` objects from `registry/capabilities/` wherever the resource matches one already declared. Most `common.py` capabilities (power, kids lock, remote control, alarms, energy/water meters) are shared verbatim across families; add new ones only for resources unique to the new type.
 3. Create `registry/by_type/<name>.py` with a `DeviceRegistry(name=..., capabilities=_build([...]))`. Use `pattern_capabilities` instead of `capabilities` for any resource whose `href` isn't fixed (for example per-compartment fridge resources); see `refrigerator.py` for the pattern.
-4. Register it in `_REGISTRY_BY_KEY` in `registry/by_type/__init__.py`, keyed on the lowercased, space/hyphen-to-underscore-converted suffix of the device's `oneUiVersion` string (see `_type_key()` in that file for the exact transform). If the device never reports `oneUiVersion`, add its consumer-model prefix to `_CONSUMER_PREFIX_TO_KEY` so `for_device_by_model()` can route it. If it also omits `/information/vs/0` (as the verified NA9300K cooktop does), add a distinctive, conservative resource-signature rule to `for_device_by_resources()`.
+4. Register it in `_REGISTRY_BY_KEY` in `registry/by_type/__init__.py`, then route devices to it by adding the board-family token from their `modelNum` to `_BOARD_TOKEN_TO_KEY` — a single row, e.g. `'VSKR': 'vacuum_station'`. Tokens are matched whole (the model string is upper-cased and split on any run of non-alphanumerics), so one entry covers every delimiter spelling Samsung uses: `TP1X_DA-AC-RAC-01001` and `TP2X_RAC_20K` both resolve on `RAC`. Name the specific type, never the board family that contains it — `DA-AC-` prefixes RAC/WAC/DHM/AIR alike, so a bare `AC` row would swallow the dehumidifier and the air purifier. If the board is shared across types (washers and dryers both report `DA_WM_`), add the consumer-model prefix from `description` to `_CONSUMER_PREFIX_TO_KEY` instead. If the device omits `/information/vs/0` entirely (as the verified NA9300K cooktop does), add a distinctive, conservative resource-signature rule to `for_device_by_resources()`.
+
+   `oneUiVersion` is deliberately not consulted — see `resolve()` in that file for why.
 5. Add golden-file coverage in `tests/` against a captured `/device/0` dump for the new type.
 
 No config-flow changes are needed. Device-type detection and entity wiring are fully driven by the registry.
@@ -156,6 +185,17 @@ Samsung's firmware occasionally drops the DTLS session briefly — this is norma
 
 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.
 
+### Multi-subdevice ("2-in-1") air conditioner systems
+
+Some Samsung installs run more than one indoor subdevice off a single outdoor unit, all reachable over the *one* IP/DTLS session your config entry connects to (a floor-standing + wall-mounted 2-in-1 is a common shape). The integration discovers any sibling subdevices automatically, once, right after the first successful poll — there's nothing to configure. Each discovered subdevice gets its own HA device (linked to the main one via "via device") and its own `climate` card, so it lands in its own room in the dashboard instead of being invisible or mixed into the master's state.
+
+Two on-the-wire shapes are supported, both keyed off what the appliance itself reports:
+
+- **Indexed siblings** — the device answers a `/device/1`, `/device/2`, ... collection alongside its own `/device/0`, mirroring every resource at that index.
+- **UUID-prefixed tree** — the device reports a sibling's id in `x.com.samsung.da.subdeviceIdList`, and that id doubles as a literal href prefix for the sibling's own resource tree.
+
+A candidate that answers but never produces any real, user-facing state (an unused slot some installs report alongside a genuine second subdevice) is silently skipped rather than turned into a phantom entity — check diagnostics' `subdevices`/`subdevices_skipped` blocks if a subdevice you expect to see isn't showing up, and file an issue with that diagnostics download attached.
+
 ---
 
 ## Contributing

custom_components/localthings/__init__.py

@@ -6,6 +6,7 @@ import logging
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
+from homeassistant.helpers import device_registry as dr
 
 from .const import DOMAIN, PLATFORMS
 from .coordinator import LocalThingsCoordinator
@@ -25,6 +26,44 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     return True
 
 
+async def async_remove_config_entry_device(
+    hass: HomeAssistant, entry: ConfigEntry, device: dr.DeviceEntry,
+) -> bool:
+    """Allow deleting a device this entry no longer provides (issue #214).
+
+    Defining this at all is what makes Home Assistant offer the "Delete
+    device" action for our devices; without it a device registry entry
+    belonging to a loaded config entry can never be removed from the UI. That
+    matters because a subdevice's HA device outlives the discovery that
+    created it: a candidate that materialized under an older release (issue
+    #214's phantom second air conditioner, born from an unused /device/1 slot
+    reporting the appliance's energy counter -- see
+    registry/subdevices.py's liveness gate) leaves a device entry behind that
+    nothing recreates and nothing cleans up once the gate stops materializing
+    it. Same for a sibling that a firmware update stops exposing.
+
+    Removal is refused for devices this entry *does* currently provide --
+    HA would recreate them on the next entity add, so allowing it would look
+    like the delete silently failed. Deliberately no automatic pruning at
+    discovery time: subdevice enumeration is one-shot and a sibling can fail
+    to answer for a poll (issue #205 is exactly that on the reference
+    hardware), so auto-removal would throw away a real subdevice's name,
+    area and automation references on a transient miss. The user gets the
+    button; the integration doesn't guess.
+    """
+    coordinator: LocalThingsCoordinator | None = hass.data.get(DOMAIN, {}).get(
+        entry.entry_id
+    )
+    if coordinator is None:
+        # Entry not loaded (or already unloaded) -- nothing is claiming this
+        # device, so there's nothing to protect it from being removed.
+        return True
+    live = set(coordinator.device_info.get('identifiers') or set())
+    for subdevice in coordinator.subdevices:
+        live |= set(coordinator.device_info_for(subdevice).get('identifiers') or set())
+    return not (device.identifiers & live)
+
+
 async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     unloaded = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
     if unloaded:

custom_components/localthings/catalog.py

@@ -0,0 +1,49 @@
+"""The integration's own shipped translation catalog, as data.
+
+Home Assistant loads exactly one file per language for a custom integration:
+``translations/<lang>.json``. It does not read ``strings.json`` and it does
+not resolve ``[%key:...%]`` references -- both of those belong to Core's
+build tooling (``script/translations``), which custom integrations never run
+through. So ``translations/en.json`` is not a generated artifact here, it is
+the source of truth, and English is the one catalog required to be complete
+(hassfest validates it for custom integrations).
+
+That makes the English catalog the authority on *which* translation keys and
+states exist, which is something the Python side genuinely needs to know:
+
+  * ``select`` has to decide whether to normalize a raw Samsung option into
+    a lowercase state key (so Home Assistant can look it up) or leave the
+    vendor's own casing alone as a readable fallback.
+  * ``laundry.cycle_select`` has to decide whether a device-reported course
+    table has translations at all before keying off it.
+
+Reading it from the catalog instead of restating it in Python means adding a
+state or a course table is a one-file change, and the two can't drift.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+# Read at import, not lazily: custom integrations are imported in an executor
+# thread, so this stays off the event loop no matter who asks first.
+_ENTITY_CATALOG: dict[str, dict[str, dict]] = json.loads(
+    (Path(__file__).parent / 'translations' / 'en.json').read_text(encoding='utf-8')
+).get('entity', {})
+
+
+def has_entity_translation(platform: str, translation_key: str) -> bool:
+    """Whether `platform`.`translation_key` has an entry in the catalog."""
+    return translation_key in _ENTITY_CATALOG.get(platform, {})
+
+
+def translated_states(platform: str, translation_key: str) -> frozenset[str]:
+    """The state keys translated for `platform`.`translation_key`.
+
+    Empty when the entity has no translation at all, and also when it has a
+    translated *name* but deliberately no state table (a course list whose
+    codes we can't map, for instance) -- callers treat both the same way:
+    leave the device's value untouched.
+    """
+    entry = _ENTITY_CATALOG.get(platform, {}).get(translation_key)
+    return frozenset(entry.get('state', ())) if entry else frozenset()

custom_components/localthings/climate.py

@@ -20,10 +20,13 @@ back for, power, mode, temperature and wind resources alike.
 """
 from __future__ import annotations
 
+import logging
+
 from homeassistant.components.climate import (
     ClimateEntity,
     ClimateEntityFeature,
     HVACMode,
+    PRESET_NONE,
 )
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import UnitOfTemperature
@@ -45,7 +48,10 @@ from .registry.capabilities.airconditioner import (
     HREF_TEMPS_VS as TEMPS_VS_HREF,
     HREF_WIND_STRENGTH as WIND_STRENGTH_HREF,
     HREF_WIND_DIRECTION as WIND_DIRECTION_HREF,
+    HREF_WIND_OSCILLATION as WIND_OSCILLATION_HREF,
     HREF_CONVENIENT as CONVENIENT_HREF,
+    HREF_AIRFLOW as AIRFLOW_HREF,
+    is_legacy_board,
 )
 from .registry.capabilities.common import normalize_temp_unit
 
@@ -53,6 +59,8 @@ from .const import DOMAIN
 from .coordinator import LocalThingsCoordinator
 from .entity import LocalThingsEntity, _is_included
 
+_LOGGER = logging.getLogger(__name__)
+
 _MODES_FIELD = 'x.com.samsung.da.modes'
 _SUPPORTED_FIELD = 'x.com.samsung.da.supportedModes'
 
@@ -62,12 +70,39 @@ _SUPPORTED_FIELD = 'x.com.samsung.da.supportedModes'
 _DEVICE_TO_HVAC: dict[str, HVACMode] = {
     'Cool': HVACMode.COOL,
     'Dry': HVACMode.DRY,
+    # Fan-only is spelled 'Wind' on some boards (e.g. TP1X_DA-AC-RAC-01001) and
+    # 'Fan' on others (e.g. TP1X_DA-AC-RAC-01011); both map to FAN_ONLY. The
+    # reverse write can't rely on this map alone (two codes, one HA value) --
+    # _device_code_for_hvac() resolves the code from the unit's own
+    # supportedModes, so this is only a fallback for a unit reporting no
+    # supportedModes at all. 'Fan' is listed first so the {v: k} reverse
+    # comprehension below has 'Wind' win that fallback (last-key-wins),
+    # preserving the original single-spelling behavior rather than silently
+    # flipping it when 'Fan' was added.
+    'Fan': HVACMode.FAN_ONLY,
     'Wind': HVACMode.FAN_ONLY,
-    'Auto': HVACMode.HEAT_COOL,
+    # The device's 'Auto' is a single-setpoint "device decides" mode -> HA
+    # HVACMode.AUTO (renders "Auto"). Not HEAT_COOL: that renders "Heat/cool"
+    # and implies a two-setpoint heat+cool range these single-setpoint units
+    # (including cool-only models) don't have.
+    'Auto': HVACMode.AUTO,
     'Heat': HVACMode.HEAT,
 }
 _HVAC_TO_DEVICE = {v: k for k, v in _DEVICE_TO_HVAC.items()}
 
+# AI-driven auto-comfort mode (issue #93, A-CAWW-TP2-20-COMMON). Not a flat
+# _DEVICE_TO_HVAC entry: 'AIComfort' isn't a distinct thermodynamic operation
+# like Cool/Dry/Heat, it's an AI overlay on top of the device's own 'Auto'
+# behavior -- confirmed by this unit reporting both 'Auto' and 'AIComfort' as
+# separate, mutually-exclusive entries in /mode/vs/0's supportedModes. Modeled
+# the idiomatic HA way instead: hvac_mode reports AUTO (same as the plain
+# 'Auto' code maps to) and a dedicated 'ai_comfort' preset carries the
+# distinction a bare hvac_mode can't. Not reachable via async_set_hvac_mode --
+# entered/left only through the preset, since there's no dedicated HVACMode
+# value for it to write back to.
+_AI_COMFORT_MODE = 'AIComfort'
+PRESET_AI_COMFORT = 'ai_comfort'
+
 # 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] = {
@@ -84,19 +119,58 @@ _DEVICE_TO_SWING: dict[str, str] = {
     'Fix': 'off',
     'All': 'both',
     'Up_And_Low': 'vertical',
+    'Left_And_Right': 'horizontal',  # issue #75
 }
 _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()}
+# Swing fallback via /wind/oscillation/vs/0 (issue #126) -- boards without
+# WIND_DIRECTION_HREF at all report two independent Swing|Fix toggles
+# instead of one combined code. Same HA vocabulary as _DEVICE_TO_SWING
+# above (off/vertical/horizontal/both), just read from/written to a pair
+# of fields rather than a single one.
+def _oscillation_swing(rep: dict) -> str | None:
+    vertical = rep.get('vertical')
+    horizontal = rep.get('horizontal')
+    if vertical is None and horizontal is None:
+        return None
+    v = vertical == 'Swing'
+    h = horizontal == 'Swing'
+    if v and h:
+        return 'both'
+    if v:
+        return 'vertical'
+    if h:
+        return 'horizontal'
+    return 'off'
+
+def _wind_strength_label(code, rep: dict) -> str:
+    """Human label for a /wind/strength/vs/0 code from the device's own
+    modesName array (parallel-indexed with supportedModes), lowercased for
+    HA -- used only for codes _DEVICE_TO_FAN doesn't already cover (issue
+    #155, TP1X_DA-AC-RAC-01001_0000: codes "0"/"31"-"35" instead of the
+    "0"-"4" scale _DEVICE_TO_FAN was built from, with modesName giving
+    "Auto"/"1"/"2"/"3"/"4"/"MAX"). No per-model numeric map -- mirrors
+    preset_mode's dynamic code->str resolution. Falls back to the raw code
+    lowercased when modesName is absent or misaligned."""
+    supported = rep.get('x.com.samsung.da.supportedModes') or []
+    names = rep.get('x.com.samsung.da.modesName') or []
+    if code in supported and len(names) == len(supported):
+        return str(names[supported.index(code)]).lower()
+    return str(code).lower()
+
+
+# Preset (convenient mode): resolved dynamically from the device's own
+# /mode/convenient/vs/0 supportedModes -- no per-model table. The device 'Off'
+# code maps to HA's PRESET_NONE ("no preset active"); every other code is
+# exposed as its lowercased self and labelled in translations
+# (entity.climate.airconditioner.state_attributes.preset_mode.state.<code>),
+# so any board's convenient modes surface without code changes, and an
+# unlabelled code just renders as its raw value until a label is added.
+# (Samsung's WindFree still-air cooling shows up here as the 'Nano'/
+# 'NanoSleep' codes on cool-only global RAC boards -- that's just a
+# translation label, not a hard-coded mode.)
+def _preset_to_ha(code) -> str:
+    return PRESET_NONE if code == 'Off' else str(code).lower()
 
 
 async def async_setup_entry(
@@ -164,32 +238,140 @@ class LocalThingsClimate(LocalThingsEntity, ClimateEntity):
             | ClimateEntityFeature.TURN_ON
             | ClimateEntityFeature.TURN_OFF
         )
+        # (href, raw device code) pairs already logged by _warn_unmapped --
+        # these properties are read on every coordinator refresh, so an
+        # un-deduped warning would spam the log for any device with a
+        # genuinely unrecognized code.
+        self._warned_unmapped: set[tuple[str, str]] = set()
 
     # -- resource helpers ---------------------------------------------------
 
+    # Preset codes on legacy ARTIK051 boards, learned by driving the same unit
+    # through its cloud integration and reading the local token back each time:
+    # Nano=windFree, Quiet, Comfort, 2Step, Speed=Fast Turbo, Off=none.
+    _LEGACY_PRESET_CODES = ('Off', 'Nano', 'Quiet', 'Comfort', '2Step', 'Speed')
+
+    def _legacy_convenient(self) -> dict:
+        """A /mode/convenient/vs/0-shaped rep built from the Comode_* token in
+        /mode/vs/0's options, for boards that have no convenient resource."""
+        options = self._rep(MODE_HREF).get('x.com.samsung.da.options') or []
+        for option in options:
+            if isinstance(option, str) and option.startswith('Comode_'):
+                return {_MODES_FIELD: [option.split('_', 1)[1]],
+                        _SUPPORTED_FIELD: list(self._LEGACY_PRESET_CODES)}
+        return {}
+
+    def _legacy_airflow(self) -> dict:
+        """The /airflow/vs/0 rep, but only when it is the fan/swing channel to
+        use -- i.e. this board has no /wind/strength/vs/0.
+
+        Delegates the board-generation test to is_legacy_board (the same
+        test capabilities/airconditioner.py's token entities are gated on)
+        instead of re-implementing it. Uses self._resources (this unit's own
+        canonical view, issue #177 -- see LocalThingsEntity._resources)
+        rather than a two-key presence dict built from coordinator.resource()'s
+        truthiness -- resource() collapses "href absent" and "href present
+        with an empty {} rep" to the same falsy value, while is_legacy_board
+        (and discover()'s own binding) test key membership, not truthiness. A
+        presence dict built from truthiness alone would disagree with the
+        token entities on a board reporting a genuinely empty /airflow/vs/0,
+        silently reintroducing the drift this delegation exists to prevent.
+
+        Reads the actual href through self._rep rather than
+        coordinator.resource() directly -- on a subdevice (a legacy-board
+        sibling has its own /airflow/vs/1, or /<id>/airflow/vs/0), the
+        canonical AIRFLOW_HREF must be translated through this bound
+        entity's own subdevice first, exactly like every other sibling read
+        below.
+        """
+        if not is_legacy_board(self._resources):
+            return {}
+        return self._rep(AIRFLOW_HREF)
+
+    def _legacy_preset(self) -> bool:
+        """Whether presets come from the Comode_* token rather than a resource.
+
+        Gated on the same board test as _legacy_airflow, not on the convenient
+        rep being empty alone: newer boards carry Comode tokens too, so a
+        momentarily empty /mode/convenient/vs/0 there must not silently switch
+        the preset read (and write) over to the token path.
+
+        Deliberately reads the *raw* href (translated through this bound
+        entity's own subdevice, not through self._rep) rather than going
+        through _rep's own CONVENIENT_HREF fallback branch -- that fallback
+        is exactly the legacy_convenient() rep this method is deciding
+        whether to use, so routing through it here would make the resource
+        never look empty and this always resolve to the wrong side.
+        """
+        convenient_href = self._bound.subdevice.to_actual(CONVENIENT_HREF)
+        return (not self.coordinator.resource(convenient_href)
+                and bool(self._legacy_airflow()))
+
     def _rep(self, href: str) -> dict:
-        return self.coordinator.resource(href) or {}
+        """`href` is one of this module's canonical HREF_* constants --
+        translated through this bound entity's own subdevice (issue #177) to
+        the real, on-the-wire href before the single-href cache lookup
+        (identity for MAIN, so a device with no subdevices reads exactly the
+        href it always did)."""
+        rep = self.coordinator.resource(self._bound.subdevice.to_actual(href)) or {}
+        if not rep and href == CONVENIENT_HREF and self._legacy_airflow():
+            return self._legacy_convenient()
+        return rep
 
     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'
+        # Prefer the vendor /power/vs/0 (present on every observed board and
+        # the resource writes target -- see airconditioner._climate_write).
+        # The OCF /power/0 is absent on many boards and a stale mirror on
+        # some, so reading it first showed pre-write state after a power
+        # toggle (issue #53: "can turn on but not off").
+        power = self._rep(POWER_VS_HREF).get('x.com.samsung.da.power')
+        if power is not None:
+            return str(power).lower() == 'on'
+        return bool(self._rep(POWER_HREF).get('value'))
 
     def _supported(self, href: str) -> list[str]:
         return list(self._rep(href).get(_SUPPORTED_FIELD) or [])
 
+    def _warn_unmapped(self, href: str, code: str) -> None:
+        """Log once per (href, code) when a device-reported mode has no
+        entry in the relevant device<->HA map, so a real device gap surfaces
+        in the log instead of silently vanishing (issue #93)."""
+        key = (href, code)
+        if key in self._warned_unmapped:
+            return
+        self._warned_unmapped.add(key)
+        _LOGGER.warning(
+            "%s: device mode %r on %s has no HA mapping and was dropped; "
+            "please file an issue with your diagnostics dump",
+            self.entity_id, code, href,
+        )
+
     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)))
+        raw = _first(self._rep(href).get(_MODES_FIELD))
+        if raw is not None and raw not in mapping:
+            self._warn_unmapped(href, raw)
+        return mapping.get(raw)
 
     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]
+        supported = self._supported(href)
+        for c in supported:
+            if c not in mapping:
+                self._warn_unmapped(href, c)
+        return [mapping[c] for c in supported if c in mapping]
 
     # -- temperature --------------------------------------------------------
 
+    def _ocf_temp_authoritative(self) -> bool:
+        """True when the OCF /temperature/{current,desired}/0 pair is the
+        authoritative temperature channel -- signalled by
+        /temperature/current/0 being present. Those boards honour reads/
+        writes on /temperature/desired/0 and ignore the vendor
+        /temperatures/vs/0; boards without the pair (only a desired stub, or
+        nothing) are the reverse. Confirmed on live units of both kinds."""
+        return bool(self._rep(TEMP_CURRENT_HREF))
+
     def _temps_vs(self) -> dict:
         """Vendor `/temperatures/vs/0` items[0] (empty {} when absent)."""
         return _temps_vs_item(self._rep(TEMPS_VS_HREF))
@@ -212,10 +394,14 @@ class LocalThingsClimate(LocalThingsEntity, ClimateEntity):
 
     @property
     def target_temperature(self):
-        v = _num(self._rep(TEMP_DESIRED_HREF).get('temperature'))
-        if v is None:
-            v = _num(self._temps_vs().get('x.com.samsung.da.desired'))
-        return v
+        # Read from the same channel writes go to (see async_set_temperature):
+        # OCF /temperature/desired/0 on boards with the full OCF pair, vendor
+        # /temperatures/vs/0 otherwise -- with the other as fallback.
+        ocf = _num(self._rep(TEMP_DESIRED_HREF).get('temperature'))
+        vs = _num(self._temps_vs().get('x.com.samsung.da.desired'))
+        if self._ocf_temp_authoritative():
+            return ocf if ocf is not None else vs
+        return vs if vs is not None else ocf
 
     def _range(self) -> list | None:
         r = self._rep(TEMP_DESIRED_HREF).get('range')
@@ -250,14 +436,23 @@ class LocalThingsClimate(LocalThingsEntity, ClimateEntity):
         if not self._is_on():
             return HVACMode.OFF
         device = _first(self._rep(MODE_HREF).get(_MODES_FIELD))
+        if device == _AI_COMFORT_MODE:
+            return HVACMode.AUTO
+        if device is not None and device not in _DEVICE_TO_HVAC:
+            self._warn_unmapped(MODE_HREF, device)
         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):
+            if m == _AI_COMFORT_MODE:
+                continue
             mapped = _DEVICE_TO_HVAC.get(m)
-            if mapped is not None and mapped not in modes:
+            if mapped is None:
+                self._warn_unmapped(MODE_HREF, m)
+                continue
+            if mapped not in modes:
                 modes.append(mapped)
         return modes
 
@@ -265,40 +460,103 @@ class LocalThingsClimate(LocalThingsEntity, ClimateEntity):
 
     @property
     def fan_mode(self):
-        return self._read_mode(WIND_STRENGTH_HREF, _DEVICE_TO_FAN)
+        airflow = self._legacy_airflow()
+        if airflow:
+            return _DEVICE_TO_FAN.get(str(airflow.get('x.com.samsung.da.speedLevel')))
+        rep = self._rep(WIND_STRENGTH_HREF)
+        code = _first(rep.get(_MODES_FIELD))
+        if code is None:
+            return None
+        return _DEVICE_TO_FAN.get(code) or _wind_strength_label(code, rep)
 
     @property
     def fan_modes(self) -> list[str]:
-        return self._read_modes(WIND_STRENGTH_HREF, _DEVICE_TO_FAN)
+        if self._legacy_airflow():
+            # This resource carries no supportedModes, so the full scale is offered.
+            return list(_DEVICE_TO_FAN.values())
+        rep = self._rep(WIND_STRENGTH_HREF)
+        modes = []
+        for code in self._supported(WIND_STRENGTH_HREF):
+            mode = _DEVICE_TO_FAN.get(code) or _wind_strength_label(code, rep)
+            if mode not in modes:
+                modes.append(mode)
+        return modes
+
+    def _swing_via_direction(self) -> bool:
+        """True when WIND_DIRECTION_HREF is the swing channel to use --
+        signalled by its presence. Boards without it (issue #126) report
+        the 2-axis oscillation resource instead; see _oscillation_swing."""
+        return bool(self._rep(WIND_DIRECTION_HREF))
 
     @property
     def swing_mode(self):
-        return self._read_mode(WIND_DIRECTION_HREF, _DEVICE_TO_SWING)
+        airflow = self._legacy_airflow()
+        if airflow:
+            return _DEVICE_TO_SWING.get(airflow.get('x.com.samsung.da.direction'))
+        if self._swing_via_direction():
+            return self._read_mode(WIND_DIRECTION_HREF, _DEVICE_TO_SWING)
+        return _oscillation_swing(self._rep(WIND_OSCILLATION_HREF))
 
     @property
     def swing_modes(self) -> list[str]:
-        return self._read_modes(WIND_DIRECTION_HREF, _DEVICE_TO_SWING)
+        if self._legacy_airflow():
+            return list(_SWING_TO_DEVICE.keys())
+        if self._swing_via_direction():
+            return self._read_modes(WIND_DIRECTION_HREF, _DEVICE_TO_SWING)
+        if self._rep(WIND_OSCILLATION_HREF):
+            return list(_SWING_TO_DEVICE.keys())
+        return []
 
     @property
     def preset_mode(self):
-        return self._read_mode(CONVENIENT_HREF, _DEVICE_TO_PRESET)
+        if _first(self._rep(MODE_HREF).get(_MODES_FIELD)) == _AI_COMFORT_MODE:
+            return PRESET_AI_COMFORT
+        code = _first(self._rep(CONVENIENT_HREF).get(_MODES_FIELD))
+        return _preset_to_ha(code) if code is not None else None
 
     @property
     def preset_modes(self) -> list[str]:
-        return self._read_modes(CONVENIENT_HREF, _DEVICE_TO_PRESET)
+        modes = [_preset_to_ha(c) for c in self._supported(CONVENIENT_HREF)]
+        if _AI_COMFORT_MODE in self._supported(MODE_HREF):
+            modes.append(PRESET_AI_COMFORT)
+        return modes
 
     # -- writes -------------------------------------------------------------
 
+    def _device_code_for_hvac(self, hvac_mode: HVACMode):
+        """Device mode code for an HA hvac_mode, chosen from this unit's own
+        supportedModes -- fan-only is 'Wind' on some boards and 'Fan' on
+        others, so the reverse map alone can't pick the code this unit
+        accepts."""
+        for code in self._supported(MODE_HREF):
+            if _DEVICE_TO_HVAC.get(code) == hvac_mode:
+                return code
+        return _HVAC_TO_DEVICE.get(hvac_mode)
+
     async def async_set_temperature(self, **kwargs) -> None:
+        # HA's set_temperature service forwards an optional hvac_mode here; honour
+        # it (set the mode first -- that also powers the unit on when it was off),
+        # matching the climate contract other integrations follow. Without this a
+        # set_temperature call carrying hvac_mode (e.g. a dashboard "turn on to
+        # Auto 24" button) set the setpoint but never changed mode or powered on.
+        hvac_mode = kwargs.get('hvac_mode')
+        if hvac_mode is not None:
+            await self.async_set_hvac_mode(hvac_mode)
+            if hvac_mode == HVACMode.OFF:
+                return
         temp = kwargs.get('temperature')
-        if temp is not None:
-            await self.coordinator.async_send_command(self._bound, ('temperature', temp))
+        if temp is None:
+            return
+        # OCF-pair boards write /temperature/desired/0; vendor boards write
+        # /temperatures/vs/0 (see airconditioner._climate_write).
+        kind = 'temperature_ocf' if self._ocf_temp_authoritative() else 'temperature'
+        await self.coordinator.async_send_command(self._bound, (kind, 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)
+        device = self._device_code_for_hvac(hvac_mode)
         if device is None:
             return
         if not self._is_on():
@@ -318,10 +576,55 @@ class LocalThingsClimate(LocalThingsEntity, ClimateEntity):
             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)
+        if self._legacy_airflow():
+            level = _FAN_TO_DEVICE.get(fan_mode)
+            if level is not None:
+                await self.coordinator.async_send_command(
+                    self._bound, ('fan_legacy', level))
+            return
+        supported = self._supported(WIND_STRENGTH_HREF)
+        device = _FAN_TO_DEVICE.get(fan_mode)
+        # A static hit is only trustworthy if this unit's own supportedModes
+        # actually includes that code -- a board can use non-standard codes
+        # (issue #155's "31"-"35") while still spelling a standard label
+        # ("Low"/"High") in modesName, in which case _FAN_TO_DEVICE.get would
+        # return a plausible-looking code ('1'/'3') the device never
+        # advertised at all. Fall through to the live scan whenever the
+        # static guess isn't actually one of this unit's own codes.
+        if device is None or (supported and device not in supported):
+            rep = self._rep(WIND_STRENGTH_HREF)
+            for code in supported:
+                if _wind_strength_label(code, rep) == fan_mode:
+                    device = code
+                    break
+        if device is not None:
+            await self.coordinator.async_send_command(self._bound, ('fan', device))
 
     async def async_set_swing_mode(self, swing_mode: str) -> None:
-        await self._set_mapped('swing', _SWING_TO_DEVICE, swing_mode)
+        if self._legacy_airflow():
+            code = _SWING_TO_DEVICE.get(swing_mode)
+            if code is not None:
+                await self.coordinator.async_send_command(
+                    self._bound, ('swing_legacy', code))
+            return
+        if self._swing_via_direction():
+            await self._set_mapped('swing', _SWING_TO_DEVICE, swing_mode)
+            return
+        if self._rep(WIND_OSCILLATION_HREF):
+            await self.coordinator.async_send_command(
+                self._bound, ('oscillation', swing_mode))
 
     async def async_set_preset_mode(self, preset_mode: str) -> None:
-        await self._set_mapped('preset', _PRESET_TO_DEVICE, preset_mode)
+        if preset_mode == PRESET_AI_COMFORT:
+            # Writes the primary mode resource, not the convenient one --
+            # 'AIComfort' lives in /mode/vs/0 alongside Cool/Dry/Auto, not in
+            # /mode/convenient/vs/0 with Quiet/Smart/Speed/Sleep.
+            await self.coordinator.async_send_command(self._bound, ('mode', _AI_COMFORT_MODE))
+            return
+        # Reverse-resolve against the unit's own supportedModes (codes aren't
+        # a fixed transform of the HA value -- e.g. 'NanoSleep' -> 'nanosleep').
+        for code in self._supported(CONVENIENT_HREF):
+            if _preset_to_ha(code) == preset_mode:
+                kind = 'preset_legacy' if self._legacy_preset() else 'preset'
+                await self.coordinator.async_send_command(self._bound, (kind, code))
+                return

custom_components/localthings/config_flow.py

@@ -194,7 +194,29 @@ def _find_live_ports(host: str, ports: list[int], timeout: float) -> list[int]:
             except OSError:
                 pass
 
-    return _order_candidates(live)
+    # The sweep's ICMP-based verdict isn't reliable on every network path --
+    # issue #192 captured a segregated-VLAN device where it called three
+    # ports live that a concurrent nmap scan showed as closed, while the
+    # port nmap found genuinely open|filtered (49154, one of our historically
+    # confirmed ports) never showed up as live at all. Rather than trust a
+    # wrong "not live" verdict on a port we already have strong prior
+    # evidence for, always give the historically-confirmed ports a real
+    # handshake attempt too. Bounded cost: at most len(PREFERRED_PROBE_PORTS)
+    # extra handshakes, only when the sweep disagrees with the prior.
+    rescued = [p for p in PREFERRED_PROBE_PORTS if p in ports and p not in live]
+    return _order_candidates(live + rescued)
+
+
+def _is_placeholder_serial(serial: str) -> bool:
+    """True for a non-empty serialNum that isn't actually a real identity.
+
+    The ARTIK051_DONGLE_REF firmware family reports the literal string
+    'Nothing(SVC)' for every unit -- non-empty, so the plain `if not
+    serial` check here (and the equivalent one in coordinator.py's
+    `_run_discovery`) doesn't catch it, and two such units get the same
+    config-entry unique_id / entity unique_ids and collide (issue #83).
+    """
+    return serial.strip().lower().startswith('nothing')
 
 
 def _probe_and_validate(host: str, ca_cert_pem: str, ca_key_pem: str) -> dict:
@@ -202,9 +224,7 @@ def _probe_and_validate(host: str, ca_cert_pem: str, ca_key_pem: str) -> dict:
     import cbor2
     from smartthings_local.protocol.dtls_session import DtlsCoapSession
     from .registry.batch import parse_device0_batch
-    from .registry.by_type import (
-        for_device, for_device_by_model, for_device_by_resources,
-    )
+    from .registry.by_type import resolve as resolve_registry
 
     _LOGGER.debug("Fetching Samsung cloud UUID from %s", _SAMSUNG_CLOUD_HOST)
     try:
@@ -228,14 +248,13 @@ def _probe_and_validate(host: str, ca_cert_pem: str, ca_key_pem: str) -> dict:
     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]}"
-        )
+    # No early "every port refused" fast-fail here: _find_live_ports always
+    # rescues PREFERRED_PROBE_PORTS (issue #192), so candidates is never
+    # empty as long as that table is non-empty and within PROBE_PORT_RANGE --
+    # both true today, which made this branch permanently unreachable. A
+    # genuinely dead host now fails via the handshake loop's own error below,
+    # which carries the actual per-port timeout/refusal reason instead of a
+    # generic "no live port found" message.
     _LOGGER.debug("Live DTLS port candidates on %s: %s", host, candidates)
 
     last_exc = None
@@ -261,27 +280,14 @@ def _probe_and_validate(host: str, ca_cert_pem: str, ca_key_pem: str) -> dict:
                 .get('/information/vs/0', {})
                 .get('x.com.samsung.da.serialNum', '')
             )
-            if not serial:
+            if not serial or _is_placeholder_serial(serial):
                 serial = f"{host}:{port}"
-            one_ui_version = (
-                resources
-                .get('/otninformation/vs/0', {})
-                .get('swVersionInfo', {})
-                .get('oneUiVersion', '')
-            )
-            info_resource = resources.get('/information/vs/0', {})
-            recognized_registry = (
-                for_device(one_ui_version) if one_ui_version else None
-            ) or for_device_by_model(
-                info_resource.get('x.com.samsung.da.modelNum', ''),
-                info_resource.get('x.com.samsung.da.description', ''),
-            ) or for_device_by_resources(resources)
+            recognized_registry = resolve_registry(resources)
             return {
                 "port": port,
                 "serial": serial,
                 "leaf_cert_pem": fullchain_pem,
                 "leaf_key_pem": leaf_key_pem,
-                "one_ui_version": one_ui_version,
                 "device_type_recognized": recognized_registry is not None,
             }
         except CannotConnect:
@@ -368,35 +374,36 @@ class LocalThingsConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
 
         if has_creds:
             schema = vol.Schema({vol.Required(CONF_HOST): _TEXT})
-            reuse_note = "CA credentials will be reused from the existing device."
+            step_id = "user_reuse"
         else:
             schema = vol.Schema({
                 vol.Required(CONF_HOST):        _TEXT,
                 vol.Required(CONF_CA_CERT_PEM): _MULTILINE,
                 vol.Required(CONF_CA_KEY_PEM):  _MULTILINE,
             })
-            reuse_note = ""
+            step_id = "user"
 
         return self.async_show_form(
-            step_id="user",
+            step_id=step_id,
             data_schema=schema,
             errors=errors,
-            description_placeholders={"reuse_note": reuse_note},
         )
 
+    async def async_step_user_reuse(
+        self, user_input: dict[str, Any] | None = None
+    ) -> FlowResult:
+        """Handle the localized host-only form for additional appliances."""
+        return await self.async_step_user(user_input)
+
     async def async_step_confirm_unknown_type(
         self, user_input: dict[str, Any] | None = None
     ) -> FlowResult:
         """Shown only when the probe already knows the device type is unrecognized."""
         if user_input is not None:
             return self._create_entry(self._pending_info)
-
         return self.async_show_form(
             step_id="confirm_unknown_type",
             data_schema=vol.Schema({}),
-            description_placeholders={
-                "one_ui_version": self._pending_info["one_ui_version"] or "(none reported)",
-            },
         )
 
 
@@ -487,7 +494,7 @@ class LocalThingsOptionsFlow(config_entries.OptionsFlow):
                 "href": href,
                 "current_value": (
                     json.dumps(current, indent=2, ensure_ascii=False)
-                    if current else "(no cached value)"
+                    if current else "{}"
                 ),
             },
         )
@@ -531,7 +538,7 @@ class LocalThingsOptionsFlow(config_entries.OptionsFlow):
                 "code": f"{code >> 5}.{code & 0x1f:02d} ({code:#04x})",
                 "new_value": (
                     json.dumps(new_rep, indent=2, ensure_ascii=False)
-                    if new_rep else "(no value returned)"
+                    if new_rep else "{}"
                 ),
             },
         )

custom_components/localthings/const.py

@@ -42,6 +42,13 @@ LIVENESS_PROBE_TIMEOUT_S = 1.5
 # without stalling setup; it matches the per-resource read timeout elsewhere.
 PROBE_GET_TIMEOUT_S = 10.0
 
+# Base for the local (client-side) DTLS source port, distinct from the
+# destination probe ports above. See coordinator._local_source_port for why a
+# fixed per-device source port matters and how the per-device offset is
+# derived. Base mirrors the upstream smartthings-local reference bridge.
+# Requires smartthings-local >= 0.1.1.
+DTLS_LOCAL_PORT_BASE = 49700
+
 SUMMARY_INTERVAL_S = 30.0
 
 DEVICE_SUPPORT_ISSUE_URL = (

custom_components/localthings/coordinator.py

@@ -2,9 +2,11 @@
 from __future__ import annotations
 
 import asyncio
+import ipaddress
 import logging
 import threading
 import time
+import zlib
 from datetime import timedelta
 from typing import Any
 
@@ -21,30 +23,33 @@ from smartthings_local.protocol.dtls_session import DtlsCoapSession
 from smartthings_local.ocf.state_cache import StateCache
 
 from .registry.batch import parse_device0_batch
-from .registry.by_type import for_device, for_device_by_model, for_device_by_resources
-from .registry.capabilities.common import merge_options_field, remote_control_enabled
-from .registry.discovery import discover, BoundEntity
+from .registry.by_type import resolve as resolve_registry
+from .registry.capabilities.common import (
+    merge_items_field,
+    merge_options_field,
+    remote_control_enabled,
+    remote_control_required_for_write,
+)
+from .registry.discovery import BoundEntity
 from .registry import CAPABILITIES
 from .registry.adapter import flatten
 from .registry.identity import read_identity, DeviceIdentity
+from .registry.subdevices import (
+    MAIN, Subdevice, canonical_view, discover_partitioned, enumerate_subdevices,
+    normalize_seed_batch,
+)
 from .observe import ObserveManager, MODE_OBSERVE, MODE_POLL, GRACE_PERIOD_S
 
 from .const import (
     DOMAIN, CONF_HOST, CONF_PORT, CONF_LEAF_CERT_PEM, CONF_LEAF_KEY_PEM,
     CONF_BYPASS_REMOTE_CONTROL, DEVICE_SUPPORT_ISSUE_URL, SUMMARY_INTERVAL_S,
+    DTLS_LOCAL_PORT_BASE,
 )
 
 _LOGGER = logging.getLogger(__name__)
 
 _SEED_PATH = ['device', '0']
 
-_REMOTE_CONTROL_DISABLED_MESSAGE = (
-    "Remote control is turned off on this device. Check your appliance's "
-    "manual for how to enable remote control before Home Assistant can "
-    "control it."
-)
-
-
 class _NoOpDescriptor:
     """StateCache requires a descriptor with an on_observation hook. This
     integration doesn't use per-capability observation hooks, so this is a
@@ -56,6 +61,45 @@ class _NoOpDescriptor:
 _RECOVERY_RETRY_S = 600.0  # re-attempt observe mode this often while polling
 
 
+def _local_source_port(host: str) -> int:
+    """Deterministic UDP source port for this device's DTLS socket.
+
+    Binding the same source port on every (re)connect keeps the client on one
+    5-tuple, so the appliance evicts an orphaned session left by a previous run
+    (unclean shutdown -> no DTLS close_notify) at handshake time per RFC 6347
+    §4.2.8, instead of holding it for 5-15 min while the new session's reads
+    hang. See DTLS_LOCAL_PORT_BASE in const.py. Requires smartthings-local
+    >= 0.1.1 (the version that added DtlsCoapSession(local_port=...)).
+
+    The port must be stable across restarts and unique per device on this HA
+    host: the library's socket is unconnected (recvfrom), so two devices
+    sharing a source port would mis-demux each other's datagrams. For the usual
+    dotted-IPv4 host we use the last octet as the offset (unique on a /24);
+    anything else folds a stable CRC32 into the same 256-wide window.
+    """
+    try:
+        offset = int(ipaddress.IPv4Address(host)) & 0xFF
+    except (ipaddress.AddressValueError, ValueError):
+        offset = zlib.crc32(host.encode()) & 0xFF
+    return DTLS_LOCAL_PORT_BASE + offset
+
+
+def _is_placeholder_serial(serial: str) -> bool:
+    """True for a non-empty serialNum that isn't actually a real identity.
+
+    The ARTIK051_DONGLE_REF firmware family reports the literal string
+    'Nothing(SVC)' for every unit -- non-empty, so the plain `if not
+    serial` check below doesn't catch it, and `device_serial` feeds both
+    the HA device-registry identifier and every entity's unique_id
+    (entity.py), so two such units on the same install silently collide
+    and the second one's entities get dropped (issue #83). Mirrors the
+    identical helper in config_flow.py's `_probe_and_validate` -- kept
+    separate rather than imported to avoid pulling the config-flow module
+    into the runtime coordinator's import graph for a two-line check.
+    """
+    return serial.strip().lower().startswith('nothing')
+
+
 class LocalThingsCoordinator(DataUpdateCoordinator[dict[str, Any]]):
     """Manages one Samsung appliance: session, discovery, polling."""
 
@@ -71,6 +115,24 @@ class LocalThingsCoordinator(DataUpdateCoordinator[dict[str, Any]]):
     _OBSERVE_GRACE_PERIOD_S: float = GRACE_PERIOD_S
     _RECONNECT_PAUSE_S: float = 5.0
 
+    # A single reconnect is normal appliance-side behavior (see the
+    # README's "Known device behavior" section) -- Samsung's firmware
+    # drops the DTLS session briefly every now and then, and the
+    # coordinator recovering from that on its own isn't something a user
+    # needs to see at WARNING. Only escalate once reconnects pile up
+    # within a trailing window (issue #119).
+    #
+    # The window can't be a literal 60s: consecutive reconnect attempts are
+    # never closer together than one summary poll interval (SUMMARY_INTERVAL_S,
+    # 30s) plus _RECONNECT_PAUSE_S, so at most ~2 can ever land inside a 60s
+    # window regardless of how unhealthy the connection is -- a threshold of
+    # 5 there could never fire, silently downgrading every reconnect
+    # (including a persistently broken one) to INFO forever. 300s/3 instead:
+    # reachable under normal polling, and 3 reconnects inside 5 minutes is
+    # still a reasonable proxy for the README's "actually broken" case.
+    _RECONNECT_WARN_WINDOW_S: float = 300.0
+    _RECONNECT_WARN_THRESHOLD: int = 3
+
     # A block-level ACK timeout on the summary GET doesn't prove the
     # session is dead (see _poll_once) — require this many in a row
     # before treating it as one. A single slow transfer on an otherwise
@@ -103,6 +165,40 @@ class LocalThingsCoordinator(DataUpdateCoordinator[dict[str, Any]]):
         self._identity: DeviceIdentity | None = None
         self._discovered = False
         self.bound = []
+        # Sibling indoor subdevices discovered on this connection (issue
+        # #177) -- candidates set once, at first discovery, by
+        # _enumerate_subdevices_blocking; narrowed by _run_discovery to the
+        # ones that actually produced live primary state (see
+        # subdevices.discover_partitioned). MAIN itself is never in this list
+        # (see subdevices.canonical_view's docstring for why that's safe):
+        # it's the *other* subdevices sharing this DTLS session, if any.
+        self.subdevices: list[Subdevice] = []
+        # Candidates _run_discovery's gate rejected (an unused SmartThings
+        # slot that still answers its seed, e.g. the issue #177 reporter's
+        # /device/2) -- surfaced in diagnostics alongside the materialized
+        # ones so a report shows what was found and why it didn't become an
+        # entity.
+        self._skipped_subdevices: list = []
+        # Those rejected candidates' raw reps, kept aside for diagnostics
+        # only (see _live_subdevice_resources). They are deliberately not in the
+        # state cache: nothing polls them again, so anything applied there
+        # would sit frozen at its first-discovery value while looking as
+        # live as every other href in `last_resources`.
+        self._skipped_subdevice_resources: dict[str, dict] = {}
+        # /multidevice/vs/0's rep, if this board answers it -- a plain
+        # subdevice count that corroborates the liveness gate without deciding it.
+        # Deliberately outside `resources`; see _enumerate_subdevices_blocking.
+        self._multidevice: dict = {}
+        # What each subdevice probe found, keyed by the seed href attempted --
+        # surfaced in diagnostics so a report can tell "checked, nothing
+        # there" apart from "never checked" (the same posture the
+        # speculative-probe code this replaced documented in identity.py).
+        self._subdevice_probes: dict[str, bool] = {}
+        # canonical_resources() memo, keyed by (subdevice.kind, subdevice.key).
+        # Invalidated in _on_cache_changed -- climate.py reads this on every
+        # property access (is_legacy_board and friends), so it must not
+        # rebuild an O(hrefs) view from scratch on every single property.
+        self._canonical_cache: dict[tuple[str, str], dict] = {}
         self._cache = StateCache(_NoOpDescriptor())
         self._cache.set_on_change(self._on_cache_changed)
         self._observe = ObserveManager(self._cache, logger=self._log)
@@ -122,6 +218,7 @@ class LocalThingsCoordinator(DataUpdateCoordinator[dict[str, Any]]):
         self.one_ui_version: str = ''
         self._consecutive_poll_timeouts = 0
         self._unbound_hrefs: list[str] = []
+        self._reconnect_times: list[float] = []
 
     # ------------------------------------------------------------------
     # Session management (all blocking — must run in executor)
@@ -138,6 +235,72 @@ class LocalThingsCoordinator(DataUpdateCoordinator[dict[str, Any]]):
         direct O(1) cache lookup."""
         return self._cache.get(href) or {}
 
+    def canonical_resources(self, subdevice: Subdevice) -> dict[str, dict]:
+        """`subdevice`'s own view of the live snapshot, rewritten into the
+        canonical hrefs (issue #177) the registry/platforms are written
+        against -- see subdevices.canonical_view. A platform property that
+        needs the *whole* resources dict (as opposed to one href via
+        `resource()`/`last_resources.get(href)`) must use this instead of
+        `last_resources`, or a sibling subdevice's own `/mode/vs/1` would leak
+        into MAIN's canonical `/mode/vs/0` view (or vice versa) under
+        exists_fn/is_legacy_board-style checks that scan the whole dict.
+
+        Memoized per cache generation: climate.py calls this on every
+        property read (is_legacy_board and friends), and building it is
+        O(hrefs) -- _on_cache_changed clears the memo whenever the
+        snapshot actually changes, not on every property access.
+        """
+        view_key = (subdevice.kind, subdevice.key)
+        cached = self._canonical_cache.get(view_key)
+        if cached is not None:
+            return cached
+        view = canonical_view(subdevice, self._cache.snapshot(), self.subdevices)
+        self._canonical_cache[view_key] = view
+        return view
+
+    def device_info_for(self, subdevice: Subdevice) -> DeviceInfo:
+        """DeviceInfo for one logical subdevice sharing this connection
+        (issue #177) -- the master's own (unchanged) device_info for MAIN, or
+        a linked child device for a discovered subdevice.
+
+        Identifiers derive from the *master's* serial (device_serial) plus
+        this subdevice's stable key, never from whatever serial the
+        subdevice itself reports (or fails to) -- deterministic across
+        reconnects whether or not this subdevice's own identity resource
+        (/information/vs/<n>, or /<id>/information/vs/0) answered on the
+        poll that first created the HA device. `serial_number` is set from
+        that resource when present anyway -- it's informational, not an
+        identifier.
+        """
+        if subdevice.kind == 'main':
+            return self.device_info
+        info = self.canonical_resources(subdevice).get('/information/vs/0', {})
+        model_num = info.get('x.com.samsung.da.modelNum', '')
+        model = model_num.split('|', 1)[0] if model_num else ''
+        serial = info.get('x.com.samsung.da.serialNum') or None
+        base_name = self.device_info.get('name') or 'Samsung Appliance'
+        if model:
+            label = model.replace('_', ' ').title()
+        else:
+            # This poll never got (or never will get) the subdevice's own
+            # identity resource -- fall back to a generic per-subdevice label
+            # rather than leaving the device unnamed. 'Subdevice <n>' only
+            # makes sense for an indexed subdevice (the key is a small
+            # ordinal); UUID-prefixed subdevices are never more than one per
+            # connection today, so there's no ordinal to show.
+            label = (
+                f'Subdevice {subdevice.key}' if subdevice.kind == 'indexed'
+                else 'Secondary Subdevice'
+            )
+        return DeviceInfo(
+            identifiers={(DOMAIN, f"{self.device_serial}_{subdevice.key}")},
+            via_device=(DOMAIN, self.device_serial),
+            name=f"{base_name} {label}",
+            manufacturer=self.device_info.get('manufacturer') or 'Samsung',
+            model=model or None,
+            serial_number=serial,
+        )
+
     @property
     def observe_mode(self) -> str:
         return self._observe.mode
@@ -149,7 +312,8 @@ class LocalThingsCoordinator(DataUpdateCoordinator[dict[str, Any]]):
         key_pem  = self._entry.data[CONF_LEAF_KEY_PEM]
 
         sess = DtlsCoapSession(host, port, cert_pem=cert_pem, key_pem=key_pem,
-                               on_notification=self._observe.on_notification)
+                               on_notification=self._observe.on_notification,
+                               local_port=_local_source_port(host))
         sess.connect()
         sess.start_reader()
         self._session = sess
@@ -185,6 +349,7 @@ class LocalThingsCoordinator(DataUpdateCoordinator[dict[str, Any]]):
         into a single push instead of one hass.add_job per href."""
         if not changed:
             return
+        self._canonical_cache.clear()
         with self._push_pending_lock:
             if self._push_pending:
                 return
@@ -232,7 +397,83 @@ class LocalThingsCoordinator(DataUpdateCoordinator[dict[str, Any]]):
             body = cbor2.loads(payload)
         except Exception as e:
             raise RuntimeError(f"poll cbor decode: {e}") from e
-        return parse_device0_batch(body) if isinstance(body, list) else {}
+        result = parse_device0_batch(body) if isinstance(body, list) else {}
+        # Refresh every already-enumerated sibling subdevice's seed collection
+        # on this same summary poll (issue #177) -- without this, a subdevice's
+        # climate card would show only its enumeration-time snapshot forever.
+        for subdevice in self.subdevices:
+            result.update(self._poll_subdevice_seed(subdevice))
+        return result
+
+    def _poll_subdevice_seed(self, subdevice: Subdevice) -> dict[str, dict]:
+        """GET one subdevice's seed Collection and return its batch,
+        normalized to real hrefs. A sibling failing to answer is a debug
+        log, never a failed poll -- the master must not go unavailable
+        because a sibling timed out or dropped off (e.g. the issue #177
+        reporter's /device/2, a SmartThings-unused component that may not
+        always respond). Blocking -- called from _poll_once, already in
+        executor."""
+        sess = self._session
+        if sess is None:
+            return {}
+        if subdevice.flat_hrefs:
+            return self._poll_subdevice_flat_hrefs(subdevice, sess)
+        try:
+            code, payload = sess.get(list(subdevice.seed_path), timeout=10.0)
+            if code == 0x45 and payload:
+                body = cbor2.loads(payload)
+                if isinstance(body, list):
+                    return normalize_seed_batch(subdevice, parse_device0_batch(body))
+        except Exception as e:
+            self._log.debug("subdevice %s seed poll failed: %s", subdevice.key, e)
+        return {}
+
+    def _poll_subdevice_flat_hrefs(self, subdevice: Subdevice, sess) -> dict[str, dict]:
+        """Re-poll a flat-mode prefixed subdevice's hrefs individually
+        (issue #205) -- it has no Collection endpoint to batch-refresh
+        through (see enumerate_subdevices' fallback), so each canonical
+        href confirmed at enumeration time gets its own GET under the
+        subdevice's prefix. A href failing to answer this cycle just drops
+        out of the result, same "never let a sibling's flakiness fail the
+        master's poll" posture as the Collection path above.
+
+        Takes `sess` from the caller (already None-checked there) rather
+        than re-reading self._session -- async_close() can null that
+        without holding _session_lock, and pace()/get() both need a live
+        session on every iteration, not just the first.
+
+        Skips any href already covered by the hot/warm sub-poll tiers
+        (self._hot_hrefs/_warm_hrefs, in the same actual/on-the-wire form
+        this method builds) -- those are already refreshed every 3s/6s by
+        _run_subpolls, strictly more current than this once-per-summary-poll
+        pass could offer, so re-fetching them here would only add GETs
+        without adding freshness. A subdevice with many confirmed hrefs
+        (unlike a Collection batch, which is always one GET regardless of
+        count) is otherwise a summary-poll cost that scales with its href
+        count."""
+        skip = set(self._hot_hrefs) | set(self._warm_hrefs)
+        result: dict[str, dict] = {}
+        first = True
+        for href in subdevice.flat_hrefs:
+            actual = subdevice.to_actual(href)
+            if actual in skip:
+                continue
+            try:
+                if not first:
+                    sess.pace()
+                first = False
+                path = [s for s in actual.strip('/').split('/')]
+                code, payload = sess.get(path, timeout=10.0)
+                if code == 0x45 and payload:
+                    rep = cbor2.loads(payload)
+                    if isinstance(rep, dict):
+                        result[actual] = rep
+            except Exception as e:
+                self._log.debug(
+                    "subdevice %s flat href %s poll failed: %s",
+                    subdevice.key, href, e,
+                )
+        return result
 
     def _poll_hrefs_blocking(self, hrefs: list[str]) -> dict[str, dict]:
         """GET individual hrefs sequentially. Does not reconnect on failure. Blocking."""
@@ -291,41 +532,159 @@ class LocalThingsCoordinator(DataUpdateCoordinator[dict[str, Any]]):
     # Discovery (runs once on first successful poll)
     # ------------------------------------------------------------------
 
+    def _enumerate_subdevices_blocking(self, resources: dict[str, dict]) -> dict[str, dict]:
+        """One-time (first discovery only) probe for sibling indoor subdevices
+        sharing this connection (issue #177) -- see
+        registry.subdevices.enumerate_subdevices for the two detection
+        patterns. Blocking -- runs in executor, under the session lock
+        (shares the same DTLS session _poll_once just used this cycle).
+
+        Sets self.subdevices to every *candidate* the probes turned up
+        (self._subdevice_probes as a side effect too) and returns `resources`
+        merged with whatever each candidate's seed returned, so this cycle's
+        _run_discovery sees every candidate's state without a second poll
+        round trip. `_run_discovery` is what narrows self.subdevices down to
+        the ones that are actually live (see discover_partitioned) -- this
+        method doesn't know how to tell an unused SmartThings slot (the
+        issue #177 reporter's /device/2) from a real sibling, only that
+        something answered.
+        """
+        if self._session is None:
+            self._connect_session()
+        sess = self._session
+        if sess is None:
+            return resources
+        oic_res = self._identity.raw.get('/oic/res', []) if self._identity else []
+        probes: dict[str, bool] = {}
+        subdevices, extra = enumerate_subdevices(
+            sess, resources, oic_res,
+            probe_log=lambda href, found: probes.__setitem__(href, found),
+        )
+        self.subdevices = subdevices
+        self._subdevice_probes = probes
+        # /multidevice/vs/0 is corroborating metadata, not appliance state,
+        # and it is probed on *every* device -- so it must not join the
+        # returned resources dict. Two things go wrong if it does. It would
+        # reach discovery on families whose registry doesn't ignore that
+        # href (only the AC one does), binding to nothing and raising a
+        # spurious "incomplete capability coverage" repair for every washer
+        # or fridge whose firmware happens to answer it. And it is fetched
+        # once here and never polled again, so applying it to the state
+        # cache would freeze it there exactly like a rejected candidate's
+        # reps (see _live_subdevice_resources). Kept aside for diagnostics and
+        # for the numofsubdevice cross-check in _run_discovery instead.
+        self._multidevice = extra.pop('/multidevice/vs/0', {})
+        return {**resources, **extra}
+
+    def _live_subdevice_resources(self, resources: dict[str, dict]) -> dict[str, dict]:
+        """`resources` minus every href belonging to a candidate subdevice the
+        liveness gate rejected (issue #177).
+
+        Called once, between _run_discovery and the first cache apply, so a
+        rejected slot's reps are seen by the gate and then dropped rather
+        than frozen into the cache forever -- see the call site. The reps
+        themselves are kept in _skipped_subdevice_resources for diagnostics,
+        which is the only thing that still wants them.
+        """
+        if not self._skipped_subdevices:
+            return resources
+        kept: dict[str, dict] = {}
+        skipped: dict[str, dict] = {}
+        for href, rep in resources.items():
+            bucket = skipped if any(
+                skip.subdevice.owns(href) for skip in self._skipped_subdevices
+            ) else kept
+            bucket[href] = rep
+        self._skipped_subdevice_resources = skipped
+        return kept
+
     def _run_discovery(self, resources: dict[str, dict]) -> None:
-        one_ui = (resources.get('/otninformation/vs/0', {})
-                  .get('swVersionInfo', {})
-                  .get('oneUiVersion', ''))
-        self.one_ui_version = one_ui
+        # Reported for diagnostics only -- it names the firmware generation
+        # ('7.0 Air conditioner' is Tizen Lite), which is useful when triaging
+        # an issue. It does not route: only a minority of hardware reports it
+        # at all, and every device that does is already typed by its modelNum.
+        self.one_ui_version = (resources.get('/otninformation/vs/0', {})
+                               .get('swVersionInfo', {})
+                               .get('oneUiVersion', ''))
         info = resources.get('/information/vs/0', {})
-        reg = for_device(one_ui) if one_ui else None
-        if reg is None:
-            reg = for_device_by_model(
-                info.get('x.com.samsung.da.modelNum', ''),
-                info.get('x.com.samsung.da.description', ''),
-            )
-        if reg is None:
-            reg = for_device_by_resources(resources)
         unbound: list[str] = []
-        if reg is not None:
-            self._log.debug("device type: %s (oneUiVersion=%r)", reg.name, one_ui)
-            bound = discover(resources, reg.capabilities, reg.pattern_capabilities,
-                              log=unbound.append)
-            self.device_type_name = reg.name
+        hot, warm = set(), set()
+
+        def _tier_log(href: str, tier: str) -> None:
+            if tier == 'hot':
+                hot.add(href)
+            elif tier == 'warm':
+                warm.add(href)
+
+        model_num = info.get('x.com.samsung.da.modelNum', '')
+        description = info.get('x.com.samsung.da.description', '')
+
+        # Partitioned discovery (issue #177): the main pass binds every href
+        # owned by no subdevice; one further pass per *candidate* subdevice
+        # binds its own canonical view, resolving its own device type from
+        # its own /information/vs/0 when it reports one and falling back to
+        # the master's registry otherwise. See subdevices.discover_partitioned
+        # -- it also gates each candidate down to whether it actually
+        # produced live primary state (the issue #177 reporter's /device/2,
+        # an unused SmartThings slot, answers its seed but never does), so
+        # self.subdevices below is narrowed to the ones that passed, not
+        # every candidate _enumerate_subdevices_blocking found. For a device
+        # with no candidates (self.subdevices == []) this is exactly the
+        # single discover() call this method used to make.
+        bound, device_type_name, materialized, skipped = discover_partitioned(
+            resources, self.subdevices, resolve_registry, CAPABILITIES,
+            log=unbound.append, tier_log=_tier_log,
+        )
+        self.subdevices = materialized
+        self._skipped_subdevices = skipped
+        for skip in skipped:
+            self._log.info(
+                "subdevice %s (%s) answered its seed but produced no live "
+                "primary state; not materialized (hrefs=%s)",
+                skip.subdevice.key, skip.subdevice.kind, list(skip.hrefs),
+            )
+        # Corroborating signal, not a gate (DESIGN-177.md section 4):
+        # /multidevice/vs/0's numofsubdevice is a plain count the issue
+        # #177 reporter's board reports independently of the liveness gate
+        # above. Log, don't raise, on a disagreement -- only this one board
+        # family is known to expose the resource at all, so a mismatch is a
+        # "look into this" signal for triage, not proof either side is
+        # wrong.
+        numofsubdevice = self._multidevice.get(
+            'x.com.samsung.da.numofsubdevice')
+        if numofsubdevice is not None:
+            try:
+                reported = int(numofsubdevice)
+            except (TypeError, ValueError):
+                reported = None
+            subdevice_count = len(materialized) + 1  # +1 for the master itself
+            if reported is not None and reported != subdevice_count:
+                self._log.debug(
+                    "/multidevice/vs/0 reports numofsubdevice=%r but %d "
+                    "subdevice(s) materialized (including the master)",
+                    numofsubdevice, subdevice_count,
+                )
+        if device_type_name is not None:
+            self._log.debug("device type: %s (modelNum=%r)", device_type_name, model_num)
         else:
-            self._log.warning("unknown device type oneUiVersion=%r; using common caps", one_ui)
-            bound = discover(resources, CAPABILITIES, log=unbound.append)
-            self.device_type_name = None
+            # Both fields: detection reads each of them (board token, then
+            # consumer-model code), and this line is what a user pastes into
+            # an issue -- modelNum alone doesn't identify a washer or dryer.
+            self._log.warning(
+                "unknown device type modelNum=%r description=%r; using common caps",
+                model_num, description,
+            )
+        self.device_type_name = device_type_name
         self.bound = bound
         self._unbound_hrefs = unbound
 
         serial = info.get('x.com.samsung.da.serialNum', '')
-        if not serial:
+        if not serial or _is_placeholder_serial(serial):
             serial = self._entry.data[CONF_HOST]
         self.device_serial = serial
 
         ident = self._identity
-        device_type = reg.name.replace('_', ' ').title() if reg else 'Appliance'
-        model_num = info.get('x.com.samsung.da.modelNum', '')
+        device_type = device_type_name.replace('_', ' ').title() if device_type_name else 'Appliance'
         model = model_num.split('|', 1)[0] if model_num else (ident.model if ident else '')
         name  = f"Samsung {device_type} ({model})" if model else f"Samsung {device_type}"
         mfr   = (ident.manufacturer if ident else '') or 'Samsung'
@@ -336,22 +695,16 @@ class LocalThingsCoordinator(DataUpdateCoordinator[dict[str, Any]]):
             manufacturer=mfr,
             model=model,
         )
-        self._update_coverage_gap_issue(reg is None, unbound, name)
+        self._update_coverage_gap_issue(device_type_name is None, unbound, name)
 
-        hot, warm = set(), set()
-        for be in bound:
-            tier = be.capability.poll_tier
-            if tier == 'hot':
-                hot.add(be.href)
-            elif tier == 'warm':
-                warm.add(be.href)
         self._hot_hrefs = sorted(hot)
         self._warm_hrefs = sorted(warm)
 
         self._discovered = True
         self._log.info(
-            "discovered %d entities (serial=%s) hot=%s warm=%s",
+            "discovered %d entities (serial=%s) hot=%s warm=%s subdevices=%s",
             len(bound), serial, self._hot_hrefs, self._warm_hrefs,
+            [su.key for su in self.subdevices],
         )
 
     def _update_coverage_gap_issue(
@@ -430,6 +783,17 @@ class LocalThingsCoordinator(DataUpdateCoordinator[dict[str, Any]]):
         self._consecutive_poll_timeouts += 1
         return self._consecutive_poll_timeouts < self._POLL_TIMEOUT_LIMIT
 
+    def _reconnect_is_frequent(self) -> bool:
+        """True once this cycle's reconnect is the Nth within the trailing
+        warn window -- see _RECONNECT_WARN_WINDOW_S/_RECONNECT_WARN_THRESHOLD."""
+        now = time.monotonic()
+        self._reconnect_times = [
+            t for t in self._reconnect_times
+            if now - t < self._RECONNECT_WARN_WINDOW_S
+        ]
+        self._reconnect_times.append(now)
+        return len(self._reconnect_times) >= self._RECONNECT_WARN_THRESHOLD
+
     # ------------------------------------------------------------------
     # DataUpdateCoordinator hook
     # ------------------------------------------------------------------
@@ -456,7 +820,13 @@ class LocalThingsCoordinator(DataUpdateCoordinator[dict[str, Any]]):
                 self._consecutive_poll_timeouts = 0
                 # One reconnect attempt — pause briefly so the device can
                 # clean up its DTLS session state before we knock again.
-                self._log.warning("poll failed, reconnecting: %s", e)
+                # A lone reconnect is routine (see the README's "Known
+                # device behavior" section); only warn once they're piling
+                # up within the trailing window.
+                if self._reconnect_is_frequent():
+                    self._log.warning("poll failed, reconnecting: %s", e)
+                else:
+                    self._log.info("poll failed, reconnecting: %s", e)
                 await self.hass.async_add_executor_job(self._close_session)
                 await asyncio.sleep(self._RECONNECT_PAUSE_S)
                 try:
@@ -487,7 +857,37 @@ class LocalThingsCoordinator(DataUpdateCoordinator[dict[str, Any]]):
                         self._observe.downgrade_to_poll()
                         just_downgraded_from_observe = True
 
+        if not self._discovered:
+            # One-time (issue #177): find out whether this connection has
+            # sibling indoor subdevices before the first discovery pass, and
+            # fold their seed resources into this cycle's snapshot so
+            # discovery sees every subdevice's state on the very first poll
+            # rather than waiting a cycle. Runs under its own session-lock
+            # scope (the poll above already released the lock) since it
+            # shares the same DTLS session.
+            async with self._session_lock:
+                resources = await self.hass.async_add_executor_job(
+                    self._enumerate_subdevices_blocking, resources
+                )
+
         source = 'sweep' if self._discovered else 'poll'
+        first_cycle = not self._discovered
+        if first_cycle:
+            # Discovery runs *before* the apply loop below, not after it, so
+            # a rejected candidate's resources never reach the state cache
+            # at all (issue #177). Enumeration has to fetch every candidate's
+            # seed to evaluate the liveness gate, but only the subdevices that
+            # pass it are ever polled again -- applying the rest would freeze
+            # ~14 hrefs per rejected slot into the cache on this one cycle
+            # and leave them there forever, indistinguishable from live
+            # state in `last_resources` and in the diagnostics dump built
+            # from it. StateCache has no eviction, so the only way to keep
+            # them out is to not put them in. Safe to reorder: _run_discovery
+            # reads the dict passed to it and never the cache, and
+            # log_sweep_discrepancies below can't fire on a first cycle
+            # (observe mode is only ever attempted after discovery).
+            self._run_discovery(resources)
+            resources = self._live_subdevice_resources(resources)
         sweep_mismatch = False
         if self._observe.mode == MODE_OBSERVE:
             # A sweep/cache mismatch never tears down a still-live OBSERVE
@@ -503,8 +903,7 @@ class LocalThingsCoordinator(DataUpdateCoordinator[dict[str, Any]]):
         for href, rep in resources.items():
             self._observe.apply(href, rep, source=source)
 
-        if not self._discovered:
-            self._run_discovery(resources)
+        if first_cycle:
             await self._attempt_observe_mode()
         elif just_downgraded_from_observe:
             await self._attempt_observe_mode()
@@ -538,7 +937,10 @@ class LocalThingsCoordinator(DataUpdateCoordinator[dict[str, Any]]):
         opted this device out of it via CONF_BYPASS_REMOTE_CONTROL (issue
         #54: some devices accept certain writes, e.g. a washer's default
         dosing levels, even while reporting remote control off, so the
-        block's assumption doesn't hold for every model)."""
+        block's assumption doesn't hold for every model), or the laundry
+        firmware flag isModelSettingWithoutSC declares settings writable
+        without Smart Control (cycle start/pause/stop on /operational/state
+        still require it)."""
         desc = bound_entity.desc
         write_fn = getattr(desc, 'write_fn', None)
         if write_fn is None:
@@ -547,14 +949,27 @@ class LocalThingsCoordinator(DataUpdateCoordinator[dict[str, Any]]):
         rep = self._cache.get(href or '') or {}
         resources = self._cache.snapshot()
         bypass_remote_control = self._entry.options.get(CONF_BYPASS_REMOTE_CONTROL, False)
-        if not bypass_remote_control and not remote_control_enabled(resources):
-            raise ServiceValidationError(_REMOTE_CONTROL_DISABLED_MESSAGE)
+        if (
+            not bypass_remote_control
+            and remote_control_required_for_write(resources, href or '')
+            and not remote_control_enabled(resources)
+        ):
+            raise ServiceValidationError(
+                translation_domain=DOMAIN,
+                translation_key="remote_control_disabled",
+            )
         validate_fn = getattr(desc, 'validate_fn', None)
         if validate_fn is not None:
             error = validate_fn(payload, rep, resources)
             if error:
-                raise ServiceValidationError(error)
-        result = write_fn(payload, rep, href)
+                raise ServiceValidationError(
+                    translation_domain=DOMAIN,
+                    translation_key=error,
+                )
+        try:
+            result = write_fn(payload, rep, href, resources)
+        except TypeError:
+            result = write_fn(payload, rep, href)
         if result is None:
             self._log.warning("write_fn rejected payload %r for %s", payload, href)
             return
@@ -574,7 +989,17 @@ class LocalThingsCoordinator(DataUpdateCoordinator[dict[str, Any]]):
         # state until the next real read of that resource -- the 20-60s lag
         # in issues #17/#53, which survived the earlier optimistic-apply fix
         # (issue #27) because that fix applied to the wrong href too.
-        write_href = '/' + '/'.join(path_segs)
+        #
+        # write_fn's path_segs are canonical (issue #177) -- a subdevice's
+        # ClimateDesc is bound to its own *actual* /mode/vs/1 (or
+        # /<id>/mode/vs/0) href, but _climate_write only knows the canonical
+        # sibling hrefs (e.g. ['power', 'vs', '0']). Translate through this
+        # bound entity's own subdevice so the optimistic apply, the settle
+        # guard and the POST below all target that subdevice's real resource --
+        # to_actual is the identity transform for MAIN, so a device with no
+        # subdevices writes exactly where it always did.
+        write_href = bound_entity.subdevice.to_actual('/' + '/'.join(path_segs))
+        path_segs = [s for s in write_href.strip('/').split('/') if s]
 
         # Apply the write optimistically before starting the settle guard,
         # not after -- mark_write_pending gates every source (poll, sweep,
@@ -612,23 +1037,35 @@ class LocalThingsCoordinator(DataUpdateCoordinator[dict[str, Any]]):
         # introduced its own races around overlapping writes to the same
         # href. Simpler and safer to just hold the guard for the full,
         # generously-sized window and let it expire on its own.
-        # write_fn bodies that touch x.com.samsung.da.options carry only the
-        # changed token(s) now (issue #54: confirmed sufficient on the wire --
-        # the device merges by prefix itself), not the whole packed array.
-        # observe.apply()'s field-level {**cached, **rep} merge doesn't know
-        # that -- handed the bare token list, it would replace the cached
-        # field outright and wipe every sibling option for the rest of the
-        # settle window. Pre-merge it here the same way the device does, so
-        # the optimistic cache entry stays complete; the minimal `body` below
-        # is still exactly what goes out over the wire.
+        # write_fn bodies that touch x.com.samsung.da.options or
+        # x.com.samsung.da.items carry only the changed token(s)/item now
+        # (issue #54 for options; the AC vendor temperature write for items --
+        # confirmed sufficient on the wire, the device merges the rest itself),
+        # not the whole packed array. observe.apply()'s field-level
+        # {**cached, **rep} merge doesn't know that -- handed the bare
+        # partial value, it would replace the cached field outright and wipe
+        # every sibling option/item for the rest of the settle window.
+        # Pre-merge it here the same way the device does, so the optimistic
+        # cache entry stays complete; the minimal `body` below is still
+        # exactly what goes out over the wire.
         optimistic_body = body
         new_options = body.get('x.com.samsung.da.options')
         if isinstance(new_options, list):
             cached_options = (self._cache.get(write_href) or {}).get('x.com.samsung.da.options')
             optimistic_body = {
-                **body,
+                **optimistic_body,
                 'x.com.samsung.da.options': merge_options_field(cached_options, new_options),
             }
+        # Same fact, items[] shape (e.g. airconditioner._climate_write's vendor
+        # temperature write, which now carries only {id, desired} -- see that
+        # module for the write-side half of this).
+        new_items = body.get('x.com.samsung.da.items')
+        if isinstance(new_items, list):
+            cached_items = (self._cache.get(write_href) or {}).get('x.com.samsung.da.items')
+            optimistic_body = {
+                **optimistic_body,
+                'x.com.samsung.da.items': merge_items_field(cached_items, new_items),
+            }
         self._observe.apply(write_href, optimistic_body, source='optimistic')
         self._observe.mark_write_pending(
             write_href, settle_s=self._POST_TIMEOUT_S + self._POLL_TIMEOUT_S
@@ -689,10 +1126,16 @@ class LocalThingsCoordinator(DataUpdateCoordinator[dict[str, Any]]):
         help users pin down device-specific write behavior without a new
         release."""
         if not isinstance(body, dict) or not body:
-            raise ServiceValidationError("Debug write payload must be a non-empty object.")
+            raise ServiceValidationError(
+                translation_domain=DOMAIN,
+                translation_key="debug_payload_empty",
+            )
         path_segs = [s for s in href.strip('/').split('/') if s]
         if not path_segs:
-            raise ServiceValidationError("A resource href is required.")
+            raise ServiceValidationError(
+                translation_domain=DOMAIN,
+                translation_key="resource_href_required",
+            )
         norm_href = '/' + '/'.join(path_segs)
         async with self._session_lock:
             code, new_rep = await self.hass.async_add_executor_job(

custom_components/localthings/diagnostics.py

@@ -18,6 +18,7 @@ from homeassistant.loader import async_get_integration
 from .const import DOMAIN
 from .coordinator import LocalThingsCoordinator
 from .registry.redact import redact_resources
+from .registry.subdevices import MAIN
 
 
 async def async_get_config_entry_diagnostics(
@@ -31,11 +32,127 @@ async def async_get_config_entry_diagnostics(
     # detector when called inline here. Offload it to the executor.
     stl_version = await hass.async_add_executor_job(pkg_version, "smartthings-local")
 
+    # /oic/p, /oic/d, and /oic/res sit outside the /device/0 batch captured
+    # below, so they'd otherwise never reach an issue report. /oic/d's `rt`
+    # is OCF's standard device-type declaration; /oic/res is OCF's
+    # discovery endpoint, listing every href/Collection the connection
+    # hosts -- relevant to the "Composite Device" model (issue #177) where
+    # a single physical device exposes more than one logical subdevice. See
+    # registry/identity.py.
+    identity = coordinator._identity
+
+    def _seed_diag(su) -> dict:
+        # A flat-mode subdevice (issue #205 -- no working /<uuid>/device/0
+        # Collection, so its state comes from individually-polled hrefs
+        # instead) has no meaningful seed_path; report the flat_hrefs list
+        # in its place rather than the misleading bare "/" a joined empty
+        # tuple would otherwise produce.
+        return {
+            "seed_path": ("/" + "/".join(su.seed_path)) if su.seed_path else None,
+            "flat_hrefs": list(su.flat_hrefs),
+        }
+
+    def _subdevice_diag(su) -> dict:
+        # One pass over coordinator.bound for both fields below (count and
+        # the distinct hrefs), and one redaction of this subdevice's canonical
+        # view -- `model` reads modelNum off the already-redacted `resources`
+        # rather than redacting /information/vs/0 a second time. modelNum
+        # itself never matches redact.py's substring rules, so which side of
+        # redact_resources it's read from doesn't change the value.
+        matching = [b for b in coordinator.bound if b.subdevice == su]
+        res = redact_resources(coordinator.canonical_resources(su))
+        return {
+            "kind": su.kind,
+            "key": su.key,
+            **_seed_diag(su),
+            "bound_entity_count": len(matching),
+            "hrefs": sorted({b.href for b in matching}),
+            "model": res.get('/information/vs/0', {}).get('x.com.samsung.da.modelNum', ''),
+            # Keyed by this subdevice's *canonical* hrefs, not the real ones
+            # it answers on -- '/mode/vs/0' rather than '/mode/vs/1' or
+            # '/<uuid>/mode/vs/0'. That's the form the registry and every
+            # capability are written against, so a sibling's block can be
+            # read (or pasted into the skill's standalone-discovery
+            # recipe) exactly like the master's `resources` above,
+            # instead of having to be de-indexed by hand first.
+            "resources": res,
+        }
+
     return {
         "device_type": coordinator.device_type_name or "unknown",
         "one_ui_version": coordinator.one_ui_version,
+        "identity": {
+            "manufacturer": identity.manufacturer,
+            "model": identity.model,
+            "device_types": list(identity.device_types),
+            "resources": redact_resources(identity.raw),
+        } if identity is not None else None,
         "unbound_hrefs": sorted(coordinator._unbound_hrefs),
-        "resources": redact_resources(coordinator.last_resources),
+        # This subdevice's own resources, and only this subdevice's -- what
+        # the module docstring and the adding-device-support skill have
+        # always described it as ("the parsed /device/0 snapshot"). On a
+        # composite device (issue #177) `last_resources` is the union across
+        # every live subdevice keyed by real hrefs, so reporting it raw here
+        # would mix a sibling's /mode/vs/1 in with the master's /mode/vs/0
+        # under no attribution at all. Each sibling reports its own
+        # resources in its own `subdevices` entry below instead. For a
+        # device with no subdevices -- almost every device -- this is
+        # byte-identical to `last_resources`.
+        "resources": redact_resources(coordinator.canonical_resources(MAIN)),
+        # Sibling indoor subdevices discovered on this connection (issue
+        # #177) -- per-subdevice kind/key/seed path plus what actually bound
+        # to it, so a report shows whether a composite device's subdevice
+        # was found at all and what it resolved to. subdeviceIdList (the
+        # UUID a prefixed subdevice's key comes from) is deliberately NOT
+        # redacted here even
+        # though the field matches redact.py's 'deviceid' substring rule
+        # elsewhere in `resources` above -- it's an appliance-internal
+        # pairing id, not account data, and reporting the key is what makes
+        # this block actionable.
+        "subdevices": [_subdevice_diag(su) for su in coordinator.subdevices],
+        # Candidates that answered their seed but that discover_partitioned's
+        # entity-level liveness gate rejected -- an unused SmartThings slot
+        # (the issue #177 reporter's /device/2) that still answers a
+        # same-shaped batch, not a real second subdevice. Reported alongside
+        # subdevices above so a report shows what was found *and* why it
+        # didn't become an entity, not just silence where a third climate
+        # card might otherwise be expected.
+        "subdevices_skipped": [
+            {
+                "kind": skip.subdevice.kind,
+                "key": skip.subdevice.key,
+                **_seed_diag(skip.subdevice),
+                "hrefs": list(skip.hrefs),
+                # The reps the liveness gate actually judged, canonicalized
+                # like the materialized subdevices above. These are the one
+                # thing a reader needs to second-guess a skip ("is my second
+                # subdevice really absent, or did the gate get it wrong?"),
+                # and they exist nowhere else in this dump: a rejected
+                # candidate is never polled again and never enters the state
+                # cache, so `resources` above cannot contain them by
+                # construction.
+                "resources": redact_resources({
+                    canon: rep
+                    for href, rep in coordinator._skipped_subdevice_resources.items()
+                    if (canon := skip.subdevice.to_canonical(href)) is not None
+                }),
+            }
+            for skip in coordinator._skipped_subdevices
+        ],
+        # What each enumeration probe returned ({} vs a batch), keyed by the
+        # seed href attempted -- lets a report distinguish "checked, nothing
+        # there" from "never checked", the same posture the speculative
+        # /device/1 //device/2 probe this replaced used to document directly
+        # in identity.py before it moved to registry/subdevices.py.
+        "subdevice_probes": dict(sorted(coordinator._subdevice_probes.items())),
+        # /multidevice/vs/0's rep ({} when the board doesn't answer it).
+        # Reported on its own rather than inside `resources` because it is
+        # metadata about the connection rather than state of any one
+        # subdevice -- and because nothing polls it after discovery, so it
+        # would go stale in there. Its numofsubdevice count is what
+        # independently corroborates the subdevices/subdevices_skipped split
+        # above.
+        "multidevice": redact_resources(coordinator._multidevice),
         "integration_version": integration.version,
         "smartthings_local_version": stl_version,
         "observe_mode": coordinator.observe_mode,

custom_components/localthings/entity.py

@@ -8,6 +8,7 @@ from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.const import EntityCategory
 
 from .registry.adapter import _key
+from .registry.batch import is_stub_rep
 from .registry.discovery import BoundEntity, _snake_to_title
 
 from .const import DOMAIN
@@ -21,32 +22,64 @@ def _is_included(bound: BoundEntity, coordinator: 'LocalThingsCoordinator') -> b
     require that field to be present in the resource rep so that optional
     fields on shared resources don't create phantom entities.
 
-    An empty rep ({}) means /device/0 returned a stub for this resource —
-    the resource exists on the device but data hasn't been fetched yet.
-    In that case we include the entity so it can be populated by sub-polls.
+    A stub rep (is_stub_rep — /device/0's "resource exists, no data fetched
+    yet" marker) is included anyway so it can be populated by sub-polls. A
+    genuinely empty {} rep is included too by this default gate -- whether
+    empty means "not populated yet" or "permanently unsupported" needs
+    per-field domain knowledge this generic gate doesn't have: /alarms/vs/0's
+    {} is fridge.py's documented *normal* no-alarm state (see
+    _active_alarm_codes), not an absence signal, and it's far from the only
+    resource like that. Only a capability whose author has actually verified
+    a field is genuinely never populated on unsupported hardware opts into
+    stricter gating with its own is_stub_rep-based exists_fn (see
+    common.ENERGY_METER, issue #127) -- this default stays permissive.
+
+    `bound.href` is already the *actual* href (issue #177 -- see
+    BoundEntity/Subdevice), so the direct cache lookup below is correct as-is;
+    `exists_fn` gets `bound`'s own subdevice's *canonical* view instead of the
+    raw snapshot, same rule as everywhere else a whole-resources-dict scan
+    happens (coordinator.canonical_resources) -- this is a free function, not
+    an LocalThingsEntity method, so it can't use self._resources.
     """
     rep = coordinator.last_resources.get(bound.href)
     if rep is None:
         return False
     if bound.desc.exists_fn is not None:
-        return bound.desc.exists_fn(rep, coordinator.last_resources)
+        return bound.desc.exists_fn(rep, coordinator.canonical_resources(bound.subdevice))
     if bound.desc.field:
-        if not rep:  # stub — resource known to exist, data not yet fetched
+        if not rep or is_stub_rep(rep):
             return True
         return bound.desc.field in rep
     return True  # rep_fn or no-field entities (ButtonDesc) are always included
 
 
 def _derive_name(state_key: str) -> str:
-    """Turn a snake_case state key into a title-cased display name.
+    """Turn a snake_case state key into a title-cased label.
 
     Strips a trailing instance number of 0 (singleton), promotes any other
     instance number with a space: "door_cooler_open1" → "Door Cooler Open 1".
+
+    Entity names themselves come from the translation catalog; this only
+    builds the {instance_name} placeholder those translations interpolate,
+    for a device that named its own compartments/ice makers.
     """
     name = re.sub(r'(\d+)$', lambda m: f' {m.group()}' if int(m.group()) > 0 else '', state_key)
     return _snake_to_title(name).strip()
 
 
+def _instance_display_name(bound: BoundEntity, state_key: str) -> str:
+    """Return the stable vendor/href instance label used in a name placeholder."""
+    if bound.instance_name:
+        return bound.instance_name
+    source = bound.key_override or state_key
+    suffix = f"_{bound.desc.key}"
+    if source.endswith(suffix):
+        source = source[:-len(suffix)]
+    elif bound.instance and source.endswith(bound.instance):
+        source = source[:-len(bound.instance)] + bound.instance.replace("_", " ")
+    return _derive_name(source)
+
+
 class LocalThingsEntity(CoordinatorEntity[LocalThingsCoordinator]):
     """Base class for all Local Things entities."""
 
@@ -57,15 +90,21 @@ class LocalThingsEntity(CoordinatorEntity[LocalThingsCoordinator]):
         self._bound = bound
         self._state_key = _key(bound)
         self._attr_unique_id = f"{DOMAIN}_{coordinator.device_serial}_{self._state_key}"
-        if bound.desc.name is not None:
-            self._attr_name = bound.desc.name
-        elif bound.instance_name:
-            # A device-given instance name (e.g. an ice maker's "Cubed
-            # Ice") takes the place of the href-derived instance label,
-            # keeping the same entity-specific suffix (issue #27).
-            self._attr_name = f"{bound.instance_name} {_derive_name(bound.desc.key)}".strip()
-        else:
-            self._attr_name = _derive_name(self._state_key)
+        if bound.desc.translation_placeholders is not None:
+            self._attr_translation_placeholders = dict(
+                bound.desc.translation_placeholders
+            )
+        elif bound.desc.use_instance_name:
+            self._attr_translation_placeholders = {
+                "instance_name": _instance_display_name(bound, self._state_key)
+            }
+
+        # _attr_name is deliberately left unset: Home Assistant gives an
+        # explicitly-set name precedence over the translation catalog, so
+        # setting it here would make every entity untranslatable. Every
+        # descriptor resolves to a catalog entry (see translation_key below);
+        # a platform that wants the bare device name instead sets
+        # _attr_name = None itself, as fan.py does for the hood's main entity.
         self._attr_icon = bound.desc.icon
         raw_cat = bound.desc.entity_category
         self._attr_entity_category = EntityCategory(raw_cat) if raw_cat else None
@@ -73,11 +112,12 @@ class LocalThingsEntity(CoordinatorEntity[LocalThingsCoordinator]):
 
     @property
     def translation_key(self) -> str | None:
-        """Override Entity.translation_key (a property upstream, not a
-        plain attribute) so a callable descriptor -- e.g.
-        laundry.cycle_select's table-id-gated resolver -- is re-evaluated
-        against live coordinator data on every access, not resolved once
-        at construction time.
+        """The descriptor's catalog key, defaulting to its own `key`.
+
+        Overrides Entity.translation_key (a property upstream, not a plain
+        attribute) so a callable descriptor -- e.g. laundry.cycle_select's
+        table-id-gated resolver -- is re-evaluated against live coordinator
+        data on every access, not resolved once at construction time.
 
         Discovery runs on the first /device/0 poll, which the entity
         registry already documents can hand a sibling resource an empty
@@ -88,8 +128,22 @@ class LocalThingsEntity(CoordinatorEntity[LocalThingsCoordinator]):
         value arrives on a later poll.
         """
         tk = self._bound.desc.translation_key
-        return tk(self.coordinator.last_resources) if callable(tk) else tk
+        if callable(tk):
+            return tk(self._resources)
+        return tk if tk is not None else self._bound.desc.key
+
+    @property
+    def _resources(self) -> dict:
+        """This entity's own subdevice's canonical resources view (issue
+        #177) -- see coordinator.canonical_resources. Every platform
+        property that needs the *whole* resources dict, as opposed to one
+        href via `coordinator.resource(href)`, must read through this
+        instead of `coordinator.last_resources`, or a sibling subdevice's own
+        actual hrefs would leak into (or be missing from) this entity's
+        view. For MAIN (every device with no subdevices) this is exactly
+        `coordinator.last_resources`."""
+        return self.coordinator.canonical_resources(self._bound.subdevice)
 
     @property
     def device_info(self) -> DeviceInfo:
-        return self.coordinator.device_info
+        return self.coordinator.device_info_for(self._bound.subdevice)

custom_components/localthings/fan.py

@@ -1,7 +1,23 @@
-"""Fan platform for Samsung range hoods."""
+"""Fan platform for Samsung range hoods and air purifiers.
+
+Four FanDesc-bound hrefs exist, dispatched by href in async_setup_entry
+below since each needs different HA fan semantics: the range hood's fan
+speed and the older ARTIK051_TVTL air-purifier family's Auto/Sleep/Low/
+Medium/High (issue #56) are both an ordered set of numeric levels
+(SET_SPEED) -- the latter confirmed monotonic in capabilities/
+air_purifier.py's module docstring, with no named-mode list to preserve
+since this board never self-reports one. The TP1X air-purifier family's
+modes (Smart/Max/Mid/WindFree/Sleep, issue #130) and the A-VTWW-TP2-21
+family's /wind/strength/vs/0 modes (issue #151) are both named behaviors
+with no linear order (PRESET_MODE) -- LocalThingsAirPurifierFan handles
+both hrefs, the only difference being whether the label comes straight
+from supportedModes or from a parallel modesName array (see
+_label_for_code)."""
 
 from __future__ import annotations
 
+import logging
+
 from homeassistant.components.fan import FanEntity, FanEntityFeature
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
@@ -14,13 +30,24 @@ from homeassistant.util.percentage import (
 from .const import DOMAIN
 from .coordinator import LocalThingsCoordinator
 from .entity import LocalThingsEntity, _is_included
+from .registry.capabilities.air_purifier import HREF_AIRFLOW
+from .registry.capabilities.air_purifier import HREF_MODE as AIR_PURIFIER_FAN_HREF
+from .registry.capabilities.air_purifier import HREF_WIND_STRENGTH as AIR_PURIFIER_WIND_STRENGTH_HREF
 from .registry.entities import FanDesc
 
+_LOGGER = logging.getLogger(__name__)
 
 POWER_HREF = '/power/0'
 POWER_VS_HREF = '/power/vs/0'
 _FAN_SPEED_FIELD = 'x.com.samsung.da.hood.fanSpeed'
 _SUPPORTED_FAN_SPEED_FIELD = 'x.com.samsung.da.hood.supportedFanSpeed'
+_MIN_FAN_SPEED_FIELD = 'x.com.samsung.da.hood.settableMinFanSpeed'
+_MAX_FAN_SPEED_FIELD = 'x.com.samsung.da.hood.settableMaxFanSpeed'
+_OFF_SPEED_CODE = '0'
+
+_MODES_FIELD = 'x.com.samsung.da.modes'
+_SUPPORTED_MODES_FIELD = 'x.com.samsung.da.supportedModes'
+_MODES_NAME_FIELD = 'x.com.samsung.da.modesName'
 
 
 async def async_setup_entry(
@@ -29,22 +56,47 @@ async def async_setup_entry(
     async_add_entities: AddEntitiesCallback,
 ) -> None:
     coordinator: LocalThingsCoordinator = hass.data[DOMAIN][entry.entry_id]
-    async_add_entities(
-        LocalThingsRangeHoodFan(coordinator, bound)
-        for bound in coordinator.bound
-        if isinstance(bound.desc, FanDesc) and _is_included(bound, coordinator)
-    )
+    entities = []
+    for bound in coordinator.bound:
+        if not (isinstance(bound.desc, FanDesc) and _is_included(bound, coordinator)):
+            continue
+        if bound.href in (AIR_PURIFIER_FAN_HREF, AIR_PURIFIER_WIND_STRENGTH_HREF):
+            entities.append(LocalThingsAirPurifierFan(coordinator, bound))
+        elif bound.href == HREF_AIRFLOW:
+            entities.append(LocalThingsAirflowFan(coordinator, bound))
+        else:
+            entities.append(LocalThingsRangeHoodFan(coordinator, bound))
+    async_add_entities(entities)
 
 
 class LocalThingsRangeHoodFan(LocalThingsEntity, FanEntity):
-    """A hood fan combining sibling power and fan-speed resources."""
+    """A hood fan combining sibling power and fan-speed resources.
+
+    Some boards that reuse this capability (built-in microwave vent fans,
+    issues #137/#142) report no sibling `/power/0` or `/power/vs/0`
+    resource at all -- fan speed 0 is itself the off state there, with no
+    separate power toggle to write. `_speed_zero_is_off` detects that
+    shape from the hood resource's own settableMinFanSpeed/
+    supportedFanSpeed fields and switches every method below to drive
+    off/on purely through the fanSpeed field, including '0' in the
+    ordered speed codes as the off step instead of assuming every
+    advertised code is an active speed.
+
+    This is deliberately not the same question as `_has_separate_power`,
+    which only proves *some* power resource exists on the device --  on a
+    combi appliance (e.g. an over-the-range microwave) that resource can
+    belong to the cavity, not the vent fan, and toggling it from here
+    would turn off the whole appliance instead of just the fan.
+    """
 
     _enable_turn_on_off_backwards_compatibility = False
-    _attr_supported_features = (
-        FanEntityFeature.SET_SPEED
-        | FanEntityFeature.TURN_ON
-        | FanEntityFeature.TURN_OFF
-    )
+
+    @property
+    def supported_features(self) -> FanEntityFeature:
+        features = FanEntityFeature.TURN_ON | FanEntityFeature.TURN_OFF
+        if self.speed_count > 0:
+            features |= FanEntityFeature.SET_SPEED
+        return features
 
     def __init__(self, coordinator: LocalThingsCoordinator, bound) -> None:
         super().__init__(coordinator, bound)
@@ -53,24 +105,58 @@ class LocalThingsRangeHoodFan(LocalThingsEntity, FanEntity):
     def _rep(self, href: str) -> dict:
         return self.coordinator.resource(href) or {}
 
+    def _has_separate_power(self) -> bool:
+        return bool(self._rep(POWER_HREF)) or bool(self._rep(POWER_VS_HREF))
+
+    def _speed_zero_is_off(self) -> bool:
+        """Whether fan speed '0' is itself this hood's off step, with no
+        separate power resource to toggle. The board says so directly:
+        settableMinFanSpeed '0', or '0' inside supportedFanSpeed. The
+        standalone hood's codes start at 14 and it carries a real /power
+        resource instead, so this is False there."""
+        rep = self._rep(self._bound.href)
+        return (
+            str(rep.get(_MIN_FAN_SPEED_FIELD, '')) == _OFF_SPEED_CODE
+            or _OFF_SPEED_CODE in self._all_speed_codes()
+        )
+
     def _all_speed_codes(self) -> list[str]:
         rep = self._rep(self._bound.href)
-        return [str(value) for value in rep.get(_SUPPORTED_FAN_SPEED_FIELD, ())]
+        supported = rep.get(_SUPPORTED_FAN_SPEED_FIELD)
+        if supported:
+            return [str(value) for value in supported]
+        min_s = rep.get(_MIN_FAN_SPEED_FIELD)
+        max_s = rep.get(_MAX_FAN_SPEED_FIELD)
+        if min_s is not None and max_s is not None:
+            try:
+                mn, mx = int(min_s), int(max_s)
+                return [str(i) for i in range(mn, mx + 1)]
+            except (ValueError, TypeError):
+                pass
+        return []
 
     def _active_speed_codes(self) -> list[str]:
-        # Power is carried by the separate /power resource.  fanSpeed retains
-        # the selected setting while power is off (as the lamp's `current`
-        # field does), so every advertised code is an active ordered speed.
-        return self._all_speed_codes()
+        codes = self._all_speed_codes()
+        if self._speed_zero_is_off():
+            # No separate power resource: '0' is the off step, not a speed.
+            return [code for code in codes if code != _OFF_SPEED_CODE]
+        # Power is carried by the separate /power resource.  fanSpeed
+        # retains the selected setting while power is off (as the
+        # lamp's `current` field does), so every advertised code is an
+        # active ordered speed.
+        return codes
 
     def _power_payload(self, enabled: bool) -> tuple[str, bool, str]:
         """Target whichever power resource this hood actually exposes."""
-        resources = self.coordinator.last_resources
+        resources = self._resources
         target = POWER_HREF if POWER_HREF in resources else POWER_VS_HREF
         return 'power', enabled, target
 
     @property
     def is_on(self) -> bool:
+        if self._speed_zero_is_off():
+            current = str(self._rep(self._bound.href).get(_FAN_SPEED_FIELD, '0'))
+            return current not in ('', _OFF_SPEED_CODE)
         rep = self._rep(POWER_HREF)
         if 'value' in rep:
             return bool(rep.get('value'))
@@ -96,6 +182,18 @@ class LocalThingsRangeHoodFan(LocalThingsEntity, FanEntity):
         self, percentage: int | None = None, preset_mode: str | None = None,
         **kwargs,
     ) -> None:
+        if self._speed_zero_is_off():
+            if percentage is not None:
+                await self.async_set_percentage(percentage)
+                return
+            if self.is_on:
+                # Already running: no percentage given means "just turn on",
+                # not "reset to the lowest speed".
+                return
+            codes = self._active_speed_codes()
+            if codes:
+                await self.coordinator.async_send_command(self._bound, ('speed', codes[0]))
+            return
         await self.coordinator.async_send_command(
             self._bound, self._power_payload(True),
         )
@@ -103,6 +201,9 @@ class LocalThingsRangeHoodFan(LocalThingsEntity, FanEntity):
             await self.async_set_percentage(percentage)
 
     async def async_turn_off(self, **kwargs) -> None:
+        if self._speed_zero_is_off():
+            await self.coordinator.async_send_command(self._bound, ('speed', _OFF_SPEED_CODE))
+            return
         await self.coordinator.async_send_command(
             self._bound, self._power_payload(False),
         )
@@ -114,9 +215,189 @@ class LocalThingsRangeHoodFan(LocalThingsEntity, FanEntity):
         codes = self._active_speed_codes()
         if not codes:
             return
-        if not self.is_on:
+        if not self._speed_zero_is_off() and not self.is_on:
             await self.coordinator.async_send_command(
                 self._bound, self._power_payload(True),
             )
         code = percentage_to_ordered_list_item(codes, percentage)
         await self.coordinator.async_send_command(self._bound, ('speed', code))
+
+
+class LocalThingsAirPurifierFan(LocalThingsEntity, FanEntity):
+    """Air-purifier fan: named preset modes, not an ordered percentage --
+    see air_purifier.FAN's comment for why (Smart/WindFree/Sleep aren't
+    "faster/slower" than Max/Mid)."""
+
+    _enable_turn_on_off_backwards_compatibility = False
+    _attr_supported_features = (
+        FanEntityFeature.PRESET_MODE
+        | FanEntityFeature.TURN_ON
+        | FanEntityFeature.TURN_OFF
+    )
+
+    def __init__(self, coordinator: LocalThingsCoordinator, bound) -> None:
+        super().__init__(coordinator, bound)
+        self._attr_name = None
+
+    def _rep(self, href: str) -> dict:
+        return self.coordinator.resource(href) or {}
+
+    def _mode_rep(self) -> dict:
+        return self._rep(self._bound.href)
+
+    def _power_payload(self, enabled: bool) -> tuple[str, bool, str]:
+        """Target whichever power resource this unit actually exposes --
+        same pattern as LocalThingsRangeHoodFan._power_payload above.
+        Writing a hardcoded href here would silently no-op on a board that
+        only reports the other one, even though is_on already falls back
+        correctly."""
+        resources = self._resources
+        target = POWER_VS_HREF if POWER_VS_HREF in resources else POWER_HREF
+        return 'power', enabled, target
+
+    @property
+    def is_on(self) -> bool:
+        power = self._rep(POWER_VS_HREF).get('x.com.samsung.da.power')
+        if power is not None:
+            return str(power).lower() == 'on'
+        return bool(self._rep(POWER_HREF).get('value'))
+
+    def _label_for_code(self, code) -> str:
+        """Lowercased HA preset label for a device mode code.
+
+        The TP1X_DA-AC-AIR board (issue #130) reports its named modes
+        directly as supportedModes ('Smart'/'Max'/...), so the code IS the
+        label. The A-VTWW-TP2-21 board (issue #151) instead reports numeric
+        wind-strength codes ('87'/'89'/...) with a separate modesName array
+        (parallel-indexed with supportedModes) giving the actual names --
+        same shape as climate.py's _wind_strength_label, and coincidentally
+        the same word set (Smart/Max/WindFree/Sleep), so both board
+        generations land on identical HA preset values without needing
+        their own translation catalog entry."""
+        rep = self._mode_rep()
+        supported = list(rep.get(_SUPPORTED_MODES_FIELD, ()))
+        names = rep.get(_MODES_NAME_FIELD)
+        if names and code in supported and len(names) == len(supported):
+            return str(names[supported.index(code)]).lower()
+        return str(code).lower()
+
+    @property
+    def preset_modes(self) -> list[str]:
+        return [
+            self._label_for_code(code)
+            for code in self._mode_rep().get(_SUPPORTED_MODES_FIELD, ())
+        ]
+
+    @property
+    def preset_mode(self) -> str | None:
+        modes = self._mode_rep().get(_MODES_FIELD)
+        code = modes[0] if isinstance(modes, (list, tuple)) and modes else modes
+        return self._label_for_code(code) if code is not None else None
+
+    async def async_turn_on(
+        self, percentage: int | None = None, preset_mode: str | None = None,
+        **kwargs,
+    ) -> None:
+        await self.coordinator.async_send_command(self._bound, self._power_payload(True))
+        if preset_mode is not None:
+            await self.async_set_preset_mode(preset_mode)
+
+    async def async_turn_off(self, **kwargs) -> None:
+        await self.coordinator.async_send_command(self._bound, self._power_payload(False))
+
+    async def async_set_preset_mode(self, preset_mode: str) -> None:
+        # Reverse-resolve against the unit's own supportedModes -- the
+        # write needs the raw device code (e.g. 'WindFree', or '90' on the
+        # modesName-labelled board), not the lowercased HA value.
+        for code in self._mode_rep().get(_SUPPORTED_MODES_FIELD, ()):
+            if self._label_for_code(code) == preset_mode:
+                await self.coordinator.async_send_command(self._bound, ('mode', code))
+                return
+        _LOGGER.warning(
+            "%s: %r is not a valid preset mode (supported: %s)",
+            self.entity_id, preset_mode, self.preset_modes,
+        )
+
+
+_AIRFLOW_SPEED_FIELD = 'speed'
+# Raw `speed` codes, low-to-high -- confirmed monotonic (Auto=0, Sleep=1,
+# Low=2, Medium=3, High=4) via air_purifier.py's module docstring. Ordered
+# as plain strings, same as _all_speed_codes above, so
+# ordered_list_item_to_percentage/percentage_to_ordered_list_item can treat
+# it exactly like the range hood's numeric levels -- no named-preset table
+# needed since this board never reports mode names to hang one off of.
+_AIRFLOW_SPEED_CODES = ('0', '1', '2', '3', '4')
+
+
+class LocalThingsAirflowFan(LocalThingsEntity, FanEntity):
+    """ARTIK051_TVTL-class air purifier fan (issue #56): an ordered numeric
+    speed range, same SET_SPEED shape as LocalThingsRangeHoodFan above."""
+
+    _enable_turn_on_off_backwards_compatibility = False
+    _attr_supported_features = (
+        FanEntityFeature.SET_SPEED
+        | FanEntityFeature.TURN_ON
+        | FanEntityFeature.TURN_OFF
+    )
+
+    def __init__(self, coordinator: LocalThingsCoordinator, bound) -> None:
+        super().__init__(coordinator, bound)
+        self._attr_name = None
+
+    def _rep(self, href: str) -> dict:
+        return self.coordinator.resource(href) or {}
+
+    def _power_payload(self, enabled: bool) -> tuple[str, bool, str]:
+        """Prefer /power/0 like LocalThingsRangeHoodFan above, NOT
+        LocalThingsAirPurifierFan's vs/0-first order -- that order is only
+        harmless for the TP1X board because it never reports /power/0 at
+        all. This family's dumps carry both hrefs, and common.POWER_GENERIC
+        (the power_switch entity) is unconditionally bound to /power/0
+        whenever it's present, so writing here to /power/vs/0 first would
+        leave power_switch and this fan reading/writing two different
+        resources -- disagreeing until the next poll refreshes the other
+        one (the same optimistic-apply lag coordinator.py's own comments
+        warn about)."""
+        resources = self._resources
+        target = POWER_HREF if POWER_HREF in resources else POWER_VS_HREF
+        return 'power', enabled, target
+
+    @property
+    def is_on(self) -> bool:
+        power = self._rep(POWER_HREF)
+        if 'value' in power:
+            return bool(power.get('value'))
+        return str(self._rep(POWER_VS_HREF).get('x.com.samsung.da.power', '')).lower() == 'on'
+
+    @property
+    def speed_count(self) -> int:
+        return len(_AIRFLOW_SPEED_CODES)
+
+    @property
+    def percentage(self) -> int | None:
+        if not self.is_on:
+            return 0
+        current = str(self._rep(self._bound.href).get(_AIRFLOW_SPEED_FIELD, ''))
+        if current not in _AIRFLOW_SPEED_CODES:
+            return None
+        return ordered_list_item_to_percentage(_AIRFLOW_SPEED_CODES, current)
+
+    async def async_turn_on(
+        self, percentage: int | None = None, preset_mode: str | None = None,
+        **kwargs,
+    ) -> None:
+        await self.coordinator.async_send_command(self._bound, self._power_payload(True))
+        if percentage is not None:
+            await self.async_set_percentage(percentage)
+
+    async def async_turn_off(self, **kwargs) -> None:
+        await self.coordinator.async_send_command(self._bound, self._power_payload(False))
+
+    async def async_set_percentage(self, percentage: int) -> None:
+        if percentage <= 0:
+            await self.async_turn_off()
+            return
+        if not self.is_on:
+            await self.coordinator.async_send_command(self._bound, self._power_payload(True))
+        code = percentage_to_ordered_list_item(_AIRFLOW_SPEED_CODES, percentage)
+        await self.coordinator.async_send_command(self._bound, ('speed', int(code)))

custom_components/localthings/icons.json

@@ -0,0 +1,66 @@
+{
+  "entity": {
+    "climate": {
+      "airconditioner": {
+        "state_attributes": {
+          "fan_mode": {
+            "state": {
+              "1": "mdi:fan-speed-1",
+              "2": "mdi:fan-speed-1",
+              "3": "mdi:fan-speed-2",
+              "4": "mdi:fan-speed-3",
+              "5": "mdi:fan-speed-3",
+              "turbo": "mdi:fan-speed-3",
+              "max": "mdi:fan-speed-3"
+            }
+          },
+          "preset_mode": {
+            "state": {
+              "ai_comfort": "mdi:creation",
+              "quiet": "mdi:volume-off",
+              "smart": "mdi:brain",
+              "speed": "mdi:speedometer",
+              "nano": "mdi:weather-dust",
+              "nanosleep": "mdi:sleep",
+              "longwind": "mdi:weather-windy",
+              "motiondirect": "mdi:account-arrow-left",
+              "motionindirect": "mdi:account-arrow-right",
+              "drycomfort": "mdi:water-percent",
+              "2step": "mdi:stairs"
+            }
+          }
+        }
+      }
+    },
+    "fan": {
+      "air_purifier_fan": {
+        "state_attributes": {
+          "preset_mode": {
+            "state": {
+              "smart": "mdi:brain",
+              "max": "mdi:fan-speed-3",
+              "mid": "mdi:fan-speed-2",
+              "windfree": "mdi:weather-dust",
+              "sleep": "mdi:sleep"
+            }
+          }
+        }
+      }
+    },
+    "sensor": {
+      "machine_state": {
+        "state": {
+          "idle": "mdi:power-standby",
+          "active": "mdi:play",
+          "pause": "mdi:pause"
+        }
+      },
+      "connection_mode": {
+        "state": {
+          "observe": "mdi:broadcast",
+          "poll": "mdi:sync"
+        }
+      }
+    }
+  }
+}

custom_components/localthings/manifest.json

@@ -10,7 +10,7 @@
   "requirements": [
     "cbor2>=5.4.6",
     "pyOpenSSL>=23.0",
-    "smartthings-local>=0.1.0"
+    "smartthings-local>=0.1.1"
   ],
-  "version": "0.11.1"
+  "version": "0.17.0"
 }

custom_components/localthings/registry/adapter.py

@@ -4,19 +4,44 @@ from __future__ import annotations
 from typing import Any
 
 from .discovery import BoundEntity
+from .subdevices import Subdevice, canonical_view
 
 
 def _key(b: BoundEntity) -> str:
-    return f"{b.key_override or b.desc.key}{b.instance}"
+    # b.subdevice.key_prefix is '' for MAIN, so a device with no subdevices
+    # (every device this integration shipped before issue #177) gets a
+    # byte-identical key to before -- a hard regression guard, not a nicety
+    # (see test_unique_ids.py and every golden file under tests/fixtures/golden/).
+    return f"{b.subdevice.key_prefix}{b.key_override or b.desc.key}{b.instance}"
 
 
 def flatten(bound: list[BoundEntity], resources: dict) -> dict[str, Any]:
-    """Map bound entities to their current scalar values."""
+    """Map bound entities to their current scalar values.
+
+    `exists_fn(rep, resources)` receives that entity's own subdevice's
+    *canonical* resources view (see subdevices.canonical_view), not the raw
+    actual-href snapshot -- an exists_fn that scans the whole resources dict
+    for a sibling href (e.g. is_legacy_board) must judge each subdevice on its
+    own resources, not see another subdevice's hrefs bleed in under the same
+    canonical key. Views are built once per distinct subdevice per call, not
+    once per entity -- O(subdevices), not O(bound entities).
+    """
     out: dict[str, Any] = {}
+    # Subdevice is a frozen dataclass (hashable, equal by value), so it can key
+    # `views` directly -- no need to re-derive an identity for it out of
+    # (kind, key) first.
+    all_subdevices = list(dict.fromkeys(b.subdevice for b in bound))
+    views: dict[Subdevice, dict] = {}
+
     for b in bound:
         rep = resources.get(b.href) or {}
-        if b.desc.exists_fn is not None and not b.desc.exists_fn(rep, resources):
-            continue
+        if b.desc.exists_fn is not None:
+            view = views.get(b.subdevice)
+            if view is None:
+                view = canonical_view(b.subdevice, resources, all_subdevices)
+                views[b.subdevice] = view
+            if not b.desc.exists_fn(rep, view):
+                continue
         if b.desc.rep_fn is not None:
             out[_key(b)] = b.desc.rep_fn(rep)
         elif b.desc.field:

custom_components/localthings/registry/batch.py

@@ -2,8 +2,25 @@
 from __future__ import annotations
 
 
+def is_stub_rep(rep: dict) -> bool:
+    """True for the device's "resource exists, no data fetched yet" marker --
+    an echoed {"href": "..."} with no other fields.
+
+    Distinct from a genuinely empty {} rep, which is the device's confirmed
+    (if empty) answer -- e.g. an unsupported resource on this model that will
+    never populate. Conflating the two used to make every field-gated entity
+    on a permanently-empty resource look like a not-yet-fetched stub forever,
+    creating phantom always-"unknown" entities (issue #127)."""
+    return isinstance(rep, dict) and set(rep.keys()) == {'href'}
+
+
 def parse_device0_batch(device0: list) -> dict[str, dict]:
-    """Extract {href: rep} from a /device/0 CBOR list response."""
+    """Extract {href: rep} from a /device/0 CBOR list response.
+
+    A stub rep is passed through unchanged rather than collapsed to {} --
+    downstream code (entity._is_included, capability exists_fns) uses
+    is_stub_rep to tell "not fetched yet" apart from a confirmed-empty {}.
+    """
     out = {}
     for entry in device0[1:]:   # skip [0] (device-level rep)
         if not isinstance(entry, dict):
@@ -12,8 +29,6 @@ def parse_device0_batch(device0: list) -> dict[str, dict]:
         rep  = entry.get('rep')
         if not href:
             continue
-        # rep == {"href": "..."} is a stub (resource present, no current data).
-        # Include it as {} so capabilities still bind and the entity exists.
         if isinstance(rep, dict):
-            out[href] = {} if set(rep.keys()) == {'href'} else rep
+            out[href] = rep
     return out

custom_components/localthings/registry/by_type/__init__.py

@@ -1,77 +1,42 @@
 """Per-device-type registries."""
+import re
 from typing import Optional
 
 from ._base import DeviceRegistry
 from . import (
-    air_purifier, airconditioner, cooktop, dishwasher, dryer, oven,
-    range as _range, range_hood, refrigerator, washer,
+    air_dresser, air_purifier, airconditioner, cooktop, dehumidifier,
+    dishwasher, dryer, induction_cooktop, microwave, oven, range as _range,
+    range_hood, refrigerator, vacuum_station, washer, water_purifier,
 )
 
 __all__ = [
-    'DeviceRegistry', '_type_key', 'for_device', 'for_device_by_model',
-    'for_device_by_resources',
+    'DeviceRegistry', 'resolve', 'for_device_by_model',
+    'for_device_by_resources', '_board_tokens',
 ]
 
 
+# One entry per registry, no aliases: every key here is reachable from
+# `_BOARD_TOKEN_TO_KEY`, `_CONSUMER_PREFIX_TO_KEY`, or `for_device_by_resources`.
 _REGISTRY_BY_KEY: dict[str, DeviceRegistry] = {
+    'air_dresser': air_dresser.REGISTRY,
     'air_purifier': air_purifier.REGISTRY,
-    'airpurifier': air_purifier.REGISTRY,
     'airconditioner': airconditioner.REGISTRY,
-    'air_conditioner': airconditioner.REGISTRY,
     'cooktop': cooktop.REGISTRY,
+    'dehumidifier': dehumidifier.REGISTRY,
     'dishwasher': dishwasher.REGISTRY,
     'dryer': dryer.REGISTRY,
+    'induction_cooktop': induction_cooktop.REGISTRY,
+    'microwave': microwave.REGISTRY,
     'oven': oven.REGISTRY,
-    'hood': range_hood.REGISTRY,
     'range': _range.REGISTRY,
     'range_hood': range_hood.REGISTRY,
     'refrigerator': refrigerator.REGISTRY,
+    'vacuum_station': vacuum_station.REGISTRY,
     'washer': washer.REGISTRY,
+    'water_purifier': water_purifier.REGISTRY,
 }
 
 
-def _type_key(one_ui_version: str) -> str:
-    """Convert oneUiVersion string to registry key.
-
-    Args:
-        one_ui_version: String like '7.0 Dishwasher' or 'Oven'.
-
-    Returns:
-        Lowercase key with version prefix stripped and spaces/hyphens converted to underscores.
-
-    Examples:
-        '7.0 Dishwasher' -> 'dishwasher'
-        '7.0 French Door Refrigerator' -> 'french_door_refrigerator'
-        'Oven' -> 'oven'
-    """
-    if ' ' in one_ui_version:
-        # Strip version prefix: everything before and including the first space
-        suffix = one_ui_version.split(' ', 1)[-1]
-    else:
-        suffix = one_ui_version
-
-    return suffix.lower().replace(' ', '_').replace('-', '_')
-
-
-def for_device(one_ui_version: str) -> Optional[DeviceRegistry]:
-    """Return the DeviceRegistry for the given oneUiVersion string, or None if unknown.
-
-    Args:
-        one_ui_version: Device's oneUiVersion string (e.g., '7.0 Dishwasher').
-
-    Returns:
-        DeviceRegistry if a matching registry exists, None otherwise.
-    """
-    key = _type_key(one_ui_version)
-    if key in _REGISTRY_BY_KEY:
-        return _REGISTRY_BY_KEY[key]
-    # Suffix fallback: e.g. "french_door_refrigerator" ends with "_refrigerator"
-    for rkey, reg in _REGISTRY_BY_KEY.items():
-        if key.endswith(f'_{rkey}'):
-            return reg
-    return None
-
-
 # Consumer-model prefix (first two letters of the '_'-delimited token in
 # `description` right before any '/board-info' suffix) -> registry key.
 # NOT derived from `modelNum` -- washer and dryer share the same 'DA_WM_'
@@ -82,76 +47,195 @@ _CONSUMER_PREFIX_TO_KEY: dict[str, str] = {
     'WD': 'washer',
     'WF': 'washer',
     'WV': 'washer',  # FlexWash twin units (e.g. WV55M9600AW) -- issue #19
+    'WA': 'washer',  # Top-load washers (e.g. WA8000T) -- issue #106
     'DV': 'dryer',
     'DW': 'dishwasher',
 }
 
+# Board-family token -> registry key, matched against whole tokens of
+# `modelNum`/`description` (see `_board_tokens`).
+#
+# Tokenizing instead of substring-matching is what keeps this a table rather
+# than a ladder of hand-written rules. Samsung spells the same board family
+# with either delimiter -- 'TP1X_DA-AC-RAC-01001' and 'TP2X_RAC_20K' are the
+# same RAC family -- so a substring rule has to be written once per spelling
+# ('_RAC_' *and* '-RAC-'), and a token that lands at the end of the
+# pipe-prefix with no trailing delimiter ('ARTIK051_DONGLE_REF', issues #77
+# and #83) matches no '_TOKEN_' spelling at all. Whole-token matching sees
+# every one of those as a single entry.
+#
+# Entries must name the *specific* device type, never the board family that
+# contains it: 'DA-AC-' prefixes RAC/WAC/DHM/AIR alike, so a bare 'AC' entry
+# would swallow the dehumidifier and the air purifier. Where two families
+# genuinely share a resource surface they share a registry (all the
+# air-conditioner spellings below), which is a statement about the hardware,
+# not a shortcut.
+_BOARD_TOKEN_TO_KEY: dict[str, str] = {
+    'REF': 'refrigerator',
+    # Air conditioners. Every one of these is a distinct board family with
+    # the same resource surface: room (issues #37, #91), package, Korean
+    # (#136), window (#87), 2-in-1 floor+wall (#150, #153), system/commercial
+    # (#52), cassette (#191), and ARA-WW wall-mount (#115, #116, #117, #120).
+    'RAC': 'airconditioner',
+    'PRAC': 'airconditioner',
+    'KRAC': 'airconditioner',
+    'WAC': 'airconditioner',
+    'FAC': 'airconditioner',
+    'CAWW': 'airconditioner',
+    'CAC': 'airconditioner',        # issue #191 -- TP1X_DA-AC-CAC-01001_0000
+    'ARA': 'airconditioner',
+    'DHM': 'dehumidifier',          # issue #88 -- target humidity, no climate
+    'TVTL': 'air_purifier',         # issue #56 (ARTIK051)
+    'VTWW': 'air_purifier',         # issue #151 (BESPOKE Cube Air)
+    'AVT': 'air_purifier',          # issue #190 -- AVT-WW-TP1-23-AXX500, a
+                                     # next-gen BESPOKE Cube Air board; same
+                                     # lineage as VTWW above but the '-WW-'
+                                     # delimiter now falls one letter to the
+                                     # left ('A-VTWW-' -> 'AVT-WW-'), splitting
+                                     # into a token the existing entry can't see
+    'AIR': 'air_purifier',          # issue #130 (TP1X_DA-AC-AIR)
+    'WATERPURIFIER': 'water_purifier',   # issue #90
+    'ADW': 'dishwasher',
+    'AHD': 'range_hood',
+    'RANGE': 'range',               # issue #44 -- cooktop+oven combo
+    'OVEN': 'oven',                 # issue #55 -- wall oven, no burners
+    'MICROWAVE': 'microwave',       # issues #66, #121
+    'COOKTOP': 'induction_cooktop',  # issue #86 -- standalone, no oven
+    # Legacy ARTIK051 gas cooktops ('ARTIK051_GB_CT_001'), whose burner state
+    # lives in /mode/vs/0's options array. Deliberately a bare two-letter
+    # token, and so the loosest entry in this table -- it is only ever
+    # reached by a device that matched nothing more specific, and its
+    # `description` ('ARTIK051_GLOBAL_COOKTOP') would otherwise read as an
+    # induction cooktop via the COOKTOP entry above. See `for_device_by_model`
+    # for the field ordering that makes that resolve correctly.
+    'CT': 'cooktop',
+    'VSKR': 'vacuum_station',       # issue #131 -- stick-vacuum clean station
+    'DF': 'air_dresser',            # issue #162
+}
+
+_TOKEN_SPLIT_RE = re.compile(r'[^A-Z0-9]+')
+
+
+def _board_tokens(value: str, cut_at: str) -> list[str]:
+    """Whole, upper-cased tokens of `value` up to the first `cut_at`.
+
+    `cut_at` drops the trailing junk each field carries -- everything after
+    modelNum's first '|' (a board revision and a capability bitmap, which can
+    contain anything) and after description's first '/' (a '/DC92-...' board
+    part number).
+    """
+    head = (value or '').split(cut_at, 1)[0].upper()
+    return [t for t in _TOKEN_SPLIT_RE.split(head) if t]
+
+
+def _board_family_key(value: str, cut_at: str) -> Optional[str]:
+    """First `_BOARD_TOKEN_TO_KEY` hit among `value`'s tokens, or None.
+
+    No known modelNum or description yields two *conflicting* board keys, so
+    which token is found first doesn't matter within one field -- the table is
+    a flat lookup, not a priority list. Adding an entry that could co-occur
+    with another (a family token, or one short enough to collide by accident)
+    would break that property; see this table's comment.
+
+    One documented exception (issue #196): AILITE water-purifier boards
+    spell their modelNum '...-REF-WATERPURIFIER-...', where 'REF' names the
+    shared cooling-subsystem board, not the refrigerator device type --
+    'WATERPURIFIER' is the actual, more specific type here. Rather than drop
+    or rename either entry (both are correct on their own for the model
+    strings that exist today), this one known co-occurrence resolves to
+    'water_purifier'; TestBoardTokenAmbiguity's blanket check carries a
+    matching carve-out for this exact pair.
+    """
+    tokens = _board_tokens(value, cut_at)
+    if 'REF' in tokens and 'WATERPURIFIER' in tokens:
+        return 'water_purifier'
+    for token in tokens:
+        key = _BOARD_TOKEN_TO_KEY.get(token)
+        if key is not None:
+            return key
+    return None
+
+
+def _consumer_model_key(description: str) -> Optional[str]:
+    """Registry key from the consumer-model token in `description`, or None.
+
+    Usually that token is the last '_'-delimited segment before any
+    '/board-info' suffix (e.g. '..._WW90DG6U25LEU4' -> 'WW90DG6U25LEU4').
+    But issue #79's dryer pairs two model numbers in one description --
+    '..._DVE50A8800_8600/DC92-...' -- so the true consumer token
+    ('DVE50A8800') sits one segment *before* the actual last segment
+    ('8600', a bare second model number with no recognizable prefix). Scan
+    segments from the end and take the first one that resolves, rather
+    than assuming the last segment is always it.
+
+    Splits on '_' only, unlike `_board_tokens` above: these are two-letter
+    prefixes matched against the *start* of a segment, so widening the split
+    to '-' as well would start reading board-family segments as consumer
+    models -- the dishwasher's 'ADW-WW-RTL-24-AILITE' would offer up a bare
+    'WW' segment and route to washer.
+
+    Only a 2-letter *prefix* match -- e.g. 'WAC' (the Window Air Conditioner
+    board-family token, issue #87) also starts with 'WA' (the top-load-washer
+    prefix, issue #106) at this granularity. for_device_by_model() consults
+    the board-family table first and this function only as a fallback, so
+    that ambiguity resolves correctly without this function needing to know
+    about unrelated device families.
+    """
+    segments = (description or '').split('/', 1)[0].split('_')
+    for segment in reversed(segments):
+        key = _CONSUMER_PREFIX_TO_KEY.get(segment[:2].upper())
+        if key is not None:
+            return key
+    return None
+
 
 def for_device_by_model(model_num: str, description: str) -> Optional[DeviceRegistry]:
-    """Fallback device-type detection for hardware that never reports
-    oneUiVersion (confirmed for washers -- their /otninformation/vs/0 has
-    no swVersionInfo key at all).
+    """Device-type detection from /information/vs/0's model strings.
+
+    The primary path: the board named in `modelNum` determines the resource
+    surface, which is what a registry describes.
+
+    Three passes, narrowest evidence first:
+
+    1. Board-family tokens in `modelNum`. The most reliable signal -- it names
+       the board, which determines the resource surface.
+    2. The same tokens in `description`. Some units carry the board token only
+       there (a scrubbed or placeholder modelNum, e.g. description
+       'TP1X_REF_21K'). This runs second so that a device whose two fields
+       disagree is typed by its modelNum: the legacy gas cooktop reports
+       'ARTIK051_GB_CT_001' (CT -> gas cooktop) alongside
+       'ARTIK051_GLOBAL_COOKTOP' (COOKTOP -> induction cooktop), and the
+       board is right.
+    3. The consumer-model prefix in `description` (washer/dryer/dishwasher).
+       Last, because a bare two-letter prefix is the fuzziest evidence here
+       and would otherwise shadow the specific board tokens above.
 
     Args:
         model_num: x.com.samsung.da.modelNum from /information/vs/0.
         description: x.com.samsung.da.description from /information/vs/0.
 
     Returns:
-        DeviceRegistry if the consumer-model code or modelNum resolves to a
+        DeviceRegistry if the modelNum or consumer-model code resolves to a
         known type, None otherwise.
     """
-    token = (description or '').split('/', 1)[0].rsplit('_', 1)[-1]
-    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'
-    # Older/simpler RAC boards (e.g. TP2X_RAC_20K, issue #37) use the plain
-    # '_RAC_' token instead -- distinct from '_PRAC_' above (no overlap: the
-    # 'P' sits between the underscore and 'RAC' in that token).
-    if key is None and '_RAC_' in (model_num or ''):
-        key = 'airconditioner'
-    # System air conditioners (multi-indoor-unit commercial installs, e.g.
-    # A-CAWW-TP2-20-COMMON, issue #52) report no oneUiVersion either and
-    # carry the '-CAWW-' board-family token instead of '_RAC_'/'_PRAC_'.
-    # Same TP1X/TP2X-class resource surface as the room-AC models above
-    # (confirmed by the issue #52 dump binding cleanly against the existing
-    # airconditioner registry once routed here), plus one new SAC-specific
-    # resource (see airconditioner.py's _AC_IGNORED).
-    if key is None and '-CAWW-' in (model_num or '').upper():
-        key = 'airconditioner'
-    # Air purifiers (e.g. ARTIK051_TVTL_18K, issue #56) report no
-    # oneUiVersion either, and carry the '_TVTL_' board-family token.
-    if key is None and '_TVTL_' in (model_num or ''):
-        key = 'air_purifier'
-    model_identity = f'{model_num} {description}'.upper()
-    if key is None and ('_COOKTOP' in model_identity or '_GB_CT_' in model_identity):
-        key = 'cooktop'
-    if key is None and model_identity.startswith('AHD-'):
-        key = 'range_hood'
-    # Range/cooktop-oven combos (e.g. TP1X_DA-KS-RANGE-0102X, issue #44) --
-    # like the RAC/PRAC air conditioners above, these report no oneUiVersion
-    # and don't match the washer/dryer/dishwasher consumer-prefix map either.
-    if key is None and '-RANGE-' in (model_num or '').upper():
-        key = 'range'
-    # Wall ovens (e.g. TP1X_DA-KS-OVEN-0107X, issue #55) -- same board-family
-    # naming as the range combo above, minus the burners; also reports no
-    # oneUiVersion and doesn't match the washer/dryer/dishwasher prefix map.
-    if key is None and '-OVEN-' in (model_num or '').upper():
-        key = 'oven'
+    key = (
+        _board_family_key(model_num, '|')
+        or _board_family_key(description, '/')
+        or _consumer_model_key(description)
+    )
     return _REGISTRY_BY_KEY.get(key) if key else None
 
 
 def for_device_by_resources(resources: dict[str, dict]) -> Optional[DeviceRegistry]:
     """Detect a device family from a distinctive local-resource signature.
 
-    Some newer cooktops omit both ``oneUiVersion`` and
-    ``/information/vs/0``.  Their mode resource still identifies them: it
-    contains a DeviceType option and multiple per-burner OperationState
-    options.  Require both shapes so an oven's unrelated ``/mode/vs/0`` is
-    not misclassified.
+    For boards that ship no ``/information/vs/0`` at all, leaving
+    `for_device_by_model` nothing to read. Some newer cooktops are the
+    original case: their mode resource still identifies them, carrying a
+    DeviceType option and multiple per-burner OperationState options.
+
+    Require two independent shapes for every signature here, never one, so
+    an unrelated family's ``/mode/vs/0`` isn't misclassified.
     """
     mode = resources.get('/mode/vs/0', {})
     options = mode.get('x.com.samsung.da.options') or ()
@@ -170,4 +254,45 @@ def for_device_by_resources(resources: dict[str, dict]) -> Optional[DeviceRegist
         and '/hood/lamp/vs/0' in resources
     ):
         return _REGISTRY_BY_KEY['range_hood']
+    # Oven/range/microwave boards that report no /information/vs/0 at all
+    # (issue #74's NE63B8411SS, issue #172's ME8000T -- the resource is simply
+    # absent from the dump, not just empty) can't be matched via
+    # for_device_by_model's modelNum tokens either. Mode vocabulary alongside
+    # the oven cavity resource (/oven/vs/0) is a safe signature.
+    supported_modes = mode.get('x.com.samsung.da.supportedModes') or ()
+    if '/oven/vs/0' in resources:
+        if any(
+            m in supported_modes
+            for m in ('MicroWave', 'MicroWaveGrill', 'MicroWaveConvection')
+        ):
+            return _REGISTRY_BY_KEY['microwave']
+        if 'Bake' in supported_modes:
+            if '/cooktopmonitoring/vs/0' in resources or '/cooktop/status/vs/0' in resources:
+                return _REGISTRY_BY_KEY['range']
+            return _REGISTRY_BY_KEY['oven']
     return None
+
+
+def resolve(resources: dict[str, dict]) -> Optional[DeviceRegistry]:
+    """Device type for a parsed /device/0 dump, or None if unrecognized.
+
+    The single entry point for detection -- the coordinator, the config
+    flow's probe and the golden-regression harness all call this, so the
+    order can't drift between what ships and what the tests assert.
+
+    Model strings first (`for_device_by_model`), then a distinctive resource
+    signature (`for_device_by_resources`) for boards that report no
+    /information/vs/0 at all.
+
+    `/otninformation/vs/0`'s oneUiVersion is deliberately not consulted. It
+    reads like the obvious signal -- the device naming its own type, e.g.
+    '7.0 Dishwasher' -- but only a minority of hardware populates it, every
+    device that does is already typed by its modelNum board token, and no
+    device-support issue has ever been fixed by adding a mapping for it. It
+    is still reported in diagnostics as a firmware-generation marker.
+    """
+    info = resources.get('/information/vs/0', {})
+    return for_device_by_model(
+        info.get('x.com.samsung.da.modelNum', ''),
+        info.get('x.com.samsung.da.description', ''),
+    ) or for_device_by_resources(resources)

custom_components/localthings/registry/by_type/air_dresser.py

@@ -0,0 +1,24 @@
+"""AirDresser device registry (issue #162).
+
+Reuses washer/dryer/dishwasher's shared laundry surface -- job-beginning
+status, operational state, and diagnosis. air_dresser.py holds the two
+pieces specific to this device type: a minimal wrinkle-prevent-only
+/washer/vs/0 capability, and the course select's own translation key.
+"""
+from ..capabilities import air_dresser, common, dishwasher, ignored, laundry, operational
+from ._base import DeviceRegistry, _build
+
+REGISTRY = DeviceRegistry(
+    name='air_dresser',
+    capabilities=_build([
+        *ignored.IGNORED,
+        *common.UNIVERSAL,
+        *common.POWER,
+        air_dresser.AIR_DRESSER_SETTINGS,
+        air_dresser.AIR_DRESSER_COURSE,
+        air_dresser.AIR_DRESSER_SANITIZE,
+        laundry.JOB_BEGINNING_STATUS,
+        operational.OPERATIONAL_STATE,
+        dishwasher.DIAGNOSIS,
+    ]),
+)

custom_components/localthings/registry/by_type/air_purifier.py

@@ -1,10 +1,31 @@
-"""Air-purifier device registry (Samsung ARTIK051_TVTL-class, issue #56).
+"""Air-purifier device registry.
 
-Reports no oneUiVersion; resolved via for_device_by_model's '_TVTL_' modelNum
-token (see registry.py). Reuses dishwasher.DIAGNOSIS for /diagnosis/vs/0
-(identical field/write contract).
+Spans three board generations sharing this one registry (see
+capabilities/air_purifier.py's module docstring for the per-href
+match_fn discriminators that keep them from colliding):
+
+- ARTIK051_TVTL-class (issue #56). Resolved via the 'TVTL' modelNum board
+  token (see by_type/__init__.py).
+- TP1X_DA-AC-AIR-class (issue #130). Resolved via the 'AIR' board token.
+  Adds real fan-mode control plus
+  display/HEPA-filter/pet-filter/sound resources the older family never
+  reported; reuses airconditioner.DISPLAY_LIGHT and airconditioner.MUTE_ONCE
+  for /light/vs/0 and /option/muteonce/vs/0, which are identical shapes on
+  the shared DA-AC- board family.
+- A-VTWW-TP2-21-COMMON-class (issue #151). Resolved via the 'VTWW' board
+  token, added for it. Its fan
+  is WIND_STRENGTH_FAN on /wind/strength/vs/0 rather than FAN on
+  /mode/vs/0 -- see that capability's comment.
+- AVT-WW-TP1-23-class (issue #190). A next-gen board in the same VTWW
+  lineage, resolved via its own 'AVT' board token since the '-WW-' delimiter
+  falls one letter to the left of 'VTWW's whole-token spelling. Same
+  resource surface as A-VTWW-TP2-21-COMMON above; no new capabilities
+  needed.
+
+Reuses dishwasher.DIAGNOSIS for /diagnosis/vs/0 (identical field/write
+contract).
 """
-from ..capabilities import air_purifier, common, dishwasher, ignored
+from ..capabilities import air_purifier, airconditioner, common, dishwasher, ignored
 from ._base import DeviceRegistry, _build
 
 REGISTRY = DeviceRegistry(
@@ -20,6 +41,17 @@ REGISTRY = DeviceRegistry(
         air_purifier.AIRFLOW_GENERIC,
         air_purifier.AIRFLOW_VS_FALLBACK,
         air_purifier.MODE,
+        air_purifier.FAN,
+        air_purifier.WIND_STRENGTH_FAN,
+        air_purifier.DISPLAY,
+        air_purifier.HEPA_FILTER,
+        air_purifier.PANEL_STATUS,
+        air_purifier.PET_FILTER_ACTIVATION,
+        air_purifier.SOUND_MODE,
+        air_purifier.SOUND_OUTPUT,
+        air_purifier.SOUND_VOLUME,
+        airconditioner.DISPLAY_LIGHT,
+        airconditioner.MUTE_ONCE,
         *air_purifier.COVERAGE,
     ]),
 )

custom_components/localthings/registry/by_type/airconditioner.py

@@ -7,6 +7,13 @@ this registry includes *common.UNIVERSAL but deliberately NOT common.POWER --
 on/off is the climate entity's HVACMode.OFF / TURN_ON/OFF. See common.POWER's
 own comment in capabilities/common.py for why it's excluded.
 
+common.ENERGY_METER itself is also excluded from UNIVERSAL here, replaced by
+the ENERGY_METER_GENERIC/ENERGY_METER_LEGACY pair -- the legacy ARTIK051 board
+generation (issue #193) reports cumulativePower in a different unit than
+every other AC family, so this registry needs two mutually-exclusive variants
+of that one capability instead of the single shared one every other registry
+uses unconditionally.
+
 Reuses dishwasher.DIAGNOSIS for /diagnosis/vs/0.
 """
 from ..capabilities import airconditioner, common, dishwasher, ignored
@@ -16,15 +23,24 @@ REGISTRY = DeviceRegistry(
     name='airconditioner',
     capabilities=_build([
         *ignored.IGNORED,
-        *common.UNIVERSAL,
+        *[c for c in common.UNIVERSAL if c is not common.ENERGY_METER],
+        airconditioner.ENERGY_METER_GENERIC,
+        airconditioner.ENERGY_METER_LEGACY,
         dishwasher.DIAGNOSIS,
         airconditioner.CLIMATE,
         airconditioner.AIR_PURIFY,
         airconditioner.AUTO_CLEAN,
         airconditioner.AIR_FILTER,
+        airconditioner.AIR_QUALITY,
         airconditioner.DISPLAY_LIGHT,
         airconditioner.MUTE_ONCE,
         airconditioner.CURRENT_LIMIT,
+        airconditioner.ANOMALY_LOAD,
+        airconditioner.ABSENCE_POWER_SAVING,
+        airconditioner.MOTION_DETECT_WIND,
+        airconditioner.CURRENT_TEMPERATURE,
+        airconditioner.CURRENT_TEMPERATURE_VS,
+        airconditioner.HUMIDITY,
         *airconditioner.COVERAGE,
     ]),
 )

custom_components/localthings/registry/by_type/cooktop.py

@@ -1,11 +1,20 @@
-"""Cooktop device registry."""
+"""Gas cooktop device registry (NA9300K-class, PR #23).
+
+Named 'gas_cooktop' (not 'cooktop') so its diagnostics/device-info label
+doesn't collide with the unrelated induction_cooktop family (issue #86,
+by_type/induction_cooktop.py) -- two different OCF surfaces that happen to
+share the English word "cooktop". The `_REGISTRY_BY_KEY['cooktop']` lookup
+key is unchanged: it's relied on by the legacy ARTIK051 'CT' modelNum token
+(for_device_by_model) and the resource-signature fallback
+(for_device_by_resources) alike.
+"""
 
 from ..capabilities import common, cooktop, ignored
 from ._base import DeviceRegistry, _build
 
 
 REGISTRY = DeviceRegistry(
-    name='cooktop',
+    name='gas_cooktop',
     capabilities=_build([
         *ignored.IGNORED,
         cooktop.COOKTOP_POWER,

custom_components/localthings/registry/by_type/dehumidifier.py

@@ -0,0 +1,23 @@
+"""Dehumidifier device registry (Samsung TP1X_DA_AC_DHM-class, issue #88).
+
+Shares the DA_AC_ board family with airconditioner.py (power, air filter,
+auto-clean, mute-once all use the identical resource shapes), so those three
+Capability objects are reused directly rather than duplicated.
+"""
+from ..capabilities import airconditioner, common, dehumidifier, ignored
+from ._base import DeviceRegistry, _build
+
+REGISTRY = DeviceRegistry(
+    name='dehumidifier',
+    capabilities=_build([
+        *ignored.IGNORED,
+        *common.UNIVERSAL,
+        *common.POWER,
+        dehumidifier.MODE,
+        dehumidifier.HUMIDITY,
+        airconditioner.AUTO_CLEAN,
+        airconditioner.AIR_FILTER,
+        airconditioner.MUTE_ONCE,
+        *dehumidifier.COVERAGE,
+    ]),
+)

custom_components/localthings/registry/by_type/induction_cooktop.py

@@ -0,0 +1,30 @@
+"""Standalone induction-cooktop device registry (Samsung
+TP1X_DA-KS-COOKTOP-class, issue #86) -- the cooktop half of the
+range/oven board family (see capabilities/range.py), but with no oven
+attached at all.
+
+Reuses range.py's COOKTOP_STATUS/COOKTOP_SPEC/COOKTOP_SAFETY/PROBE_STATUS
+wholesale (identical resource shapes to the range combo's cooktop half)
+and cooktop.PAIRED_HOOD_STATUS for the Bluetooth-paired range hood some
+units pair with. Distinct registry key from cooktop.REGISTRY ('cooktop')
+-- that family is the unrelated NA9300K-class gas cooktop (burner state
+embedded in /mode/vs/0's options array, a completely different OCF
+surface that happens to share the English word "cooktop").
+"""
+from ..capabilities import common, cooktop as cooktop_caps, ignored
+from ..capabilities import range as range_caps
+from ._base import DeviceRegistry, _build
+
+REGISTRY = DeviceRegistry(
+    name='induction_cooktop',
+    capabilities=_build([
+        *ignored.IGNORED,
+        *common.UNIVERSAL,
+        *common.POWER,
+        range_caps.COOKTOP_STATUS,
+        range_caps.COOKTOP_SPEC,
+        range_caps.COOKTOP_SAFETY,
+        range_caps.PROBE_STATUS,
+        cooktop_caps.PAIRED_HOOD_STATUS,
+    ]),
+)

custom_components/localthings/registry/by_type/microwave.py

@@ -0,0 +1,37 @@
+"""Microwave device registry (combi and plain microwaves, issues #66/#121).
+
+Shares the oven board family's cavity/cook-cycle resource shape, so the
+operational-state, door, cloud-connected, and quick-recipe-display
+Capability objects are reused directly from oven.py rather than duplicated.
+Cooking mode, setpoint, cavity power level, and lamp are genuinely
+different for this family (different mode vocabulary, different setpoint
+bounds, an extra powerLevel field, a differently-named lamp option) and are
+defined fresh in capabilities/microwave.py -- see that module's docstring.
+
+Some combi units (built-in over-the-range microwaves, issues #137/#142)
+also carry the vent fan's `/hood/fanspeed/vs/0` resource, in the exact same
+shape a standalone range hood reports it in -- reused directly from
+range_hood.py rather than duplicated. Unlike a standalone hood, this dump
+has no sibling `/power/0` or `/power/vs/0` resource; fan.py's
+LocalThingsRangeHoodFan falls back to treating fan speed 0 as off in that
+case (see its `_speed_zero_is_off` check).
+"""
+from ..capabilities import common, ignored, microwave, oven, range_hood
+from ._base import DeviceRegistry, _build
+
+REGISTRY = DeviceRegistry(
+    name='microwave',
+    capabilities=_build([
+        *ignored.IGNORED,
+        *common.UNIVERSAL,
+        *common.POWER,
+        microwave.MICROWAVE_CAVITY,
+        microwave.MICROWAVE_SETPOINT,
+        microwave.MICROWAVE_MODE,
+        oven.OVEN_OPERATIONAL_STATE,
+        oven.OVEN_DOOR,
+        oven.OVEN_CONNECTED,
+        oven.OVEN_RECIPE_COOK,
+        range_hood.HOOD_FAN,
+    ]),
+)

custom_components/localthings/registry/by_type/oven.py

@@ -15,5 +15,6 @@ REGISTRY = DeviceRegistry(
         oven.OVEN_DOOR,
         oven.OVEN_CONNECTED,
         oven.OVEN_SPEC,
+        oven.OVEN_RECIPE_COOK,
     ]),
 )

custom_components/localthings/registry/by_type/range.py

@@ -25,5 +25,6 @@ REGISTRY = DeviceRegistry(
         range_caps.COOKTOP_STATUS,
         range_caps.COOKTOP_SPEC,
         range_caps.COOKTOP_SAFETY,
+        range_caps.COOKTOP_MONITORING,
     ]),
 )

custom_components/localthings/registry/by_type/range_hood.py

@@ -11,6 +11,7 @@ REGISTRY = DeviceRegistry(
         range_hood.HOOD_ALARMS,
         common.ENERGY_METER,
         common.FIRMWARE_UPDATE,
+        range_hood.AFTER_RUN,
         range_hood.HOOD_FAN,
         range_hood.HOOD_LAMP,
         range_hood.HOOD_FILTER,

custom_components/localthings/registry/by_type/refrigerator.py

@@ -25,6 +25,7 @@ REGISTRY = DeviceRegistry(
         fridge.DEFROST_DELAY,
         fridge.DEFROST_DELAY_NATIVE_DUPLICATE,
         fridge.DEFROST_BLOCK_STATUS,
+        fridge.DEFINITE_TEMPERATURE_COOLER,
         fridge.DOORS_FALLBACK,
         fridge.TEMPERATURES_FALLBACK,
         fridge.ICEMAKER_STATUS_FALLBACK,
@@ -33,8 +34,10 @@ REGISTRY = DeviceRegistry(
     ]),
     pattern_capabilities=[
         fridge.TEMP_CURRENT_GENERIC,
-        fridge.TEMP_SETPOINT_GENERIC,
+        fridge.TEMP_SETPOINT,
         fridge.ICEMAKER_GENERIC,
         fridge.DOOR_GENERIC,
+        fridge.KIMCHI_ZONE,
+        fridge.KIMCHI_DOOR_GENERIC,
     ],
 )

custom_components/localthings/registry/by_type/vacuum_station.py

@@ -0,0 +1,22 @@
+"""Stick-vacuum clean/auto-empty station device registry (issue #131).
+
+See capabilities/vacuum_station.py's module docstring for why this only
+covers the station's own dustbag/dustbin/UV-sanitize state and not any
+vacuum-body control (suction, battery, cleaning mode) -- the diagnostics
+dump this was built from reports none of that.
+"""
+from ..capabilities import common, ignored, vacuum_station
+from ._base import DeviceRegistry, _build
+
+REGISTRY = DeviceRegistry(
+    name='vacuum_station',
+    capabilities=_build([
+        *ignored.IGNORED,
+        *common.UNIVERSAL,
+        *common.POWER,
+        vacuum_station.DUSTBAG,
+        vacuum_station.DUSTBAG_USAGE,
+        vacuum_station.DUSTBIN_SETTING,
+        vacuum_station.CLEANSTATION_STATUS,
+    ]),
+)

custom_components/localthings/registry/by_type/water_purifier.py

@@ -0,0 +1,25 @@
+"""Water-purifier device registry (Samsung TP2X_WATERPURIFIER-class, issue #90).
+"""
+from ..capabilities import common, ignored, water_purifier
+from ._base import DeviceRegistry, _build
+
+REGISTRY = DeviceRegistry(
+    name='water_purifier',
+    capabilities=_build([
+        *ignored.IGNORED,
+        *common.UNIVERSAL,
+        common.WATER_FILTER,
+        water_purifier.DISPENSE,
+        water_purifier.STATUS,
+        water_purifier.FAVORITE_CAPACITY,
+        water_purifier.FAVORITE_HOTWATER,
+        water_purifier.COFFEE,
+        water_purifier.LOCK,
+        water_purifier.CUP_STATE,
+        water_purifier.SOUND_MODE,
+        water_purifier.SOUND_OUTPUT,
+        water_purifier.SOUND_VOLUME,
+        water_purifier.STATISTIC_POUR,
+        *water_purifier.COVERAGE,
+    ]),
+)

custom_components/localthings/registry/capabilities/air_dresser.py

@@ -0,0 +1,80 @@
+"""Capabilities specific to the AirDresser family (Samsung DA_DF-class,
+issues #162/#157).
+
+This board family carried no /information/vs/0 token any existing family
+routed on, so it gets its own device type (the 'DF' board token) -- but most
+of the resources it exposes are already handled by the shared laundry
+machinery:
+
+  /washer/vs/0    -> AIR_DRESSER_SETTINGS (wrinkle_prevent only -- a
+                      dedicated capability rather than reusing
+                      dryer.DRYER_SETTINGS wholesale: this board never
+                      populates dryLevel/dryTime/dryerType at all, and
+                      those are permanently-empty-not-just-absent
+                      dryer-only fields on an AirDresser, not merely unset
+                      ones, so binding them here would ship three sensors
+                      that can never read anything on this device type)
+  /course/vs/0    -> AIR_DRESSER_COURSE (cycle select), table id from
+                      /st/airdressercourse/vs/0 (issue #157's
+                      DA_DF_TP2_20_COMMON reports "Table_00"; issue #162's
+                      DA_DF_A51_20_COMMON has no table resource at all and
+                      falls back to the name-only 'cycle' key, same as an
+                      unrecognized table on washer/dryer). Options come
+                      from laundry.cycle_options -- #157's board populates
+                      /wm/editcourse/vs/0's editCourseList directly; #162's
+                      has no editcourse resource at all and falls through
+                      to cycle_options' supportedOptions decode instead.
+                      Course names aren't identified yet for either table
+                      (no code->name mapping was reported), so they render
+                      as their raw codes until named in translations, same
+                      as dryer.py's unidentified codes.
+  /diagnosis/vs/0 -> reuses dishwasher.DIAGNOSIS
+  /airdresseroption/sanitize/vs/0 -> AIR_DRESSER_SANITIZE (issue #157 only;
+                      #162's board doesn't report this resource at all)
+"""
+from ..capability import Capability
+from ..entities import SwitchDesc
+from .laundry import cycle_select
+
+
+def _wrinkle_write(p, rep, href=None):
+    if p not in ('On', 'Off'):
+        return None
+    return ['washer', 'vs', '0'], {'x.com.samsung.da.wrinklePrevent': p}
+
+
+def _sanitize_write(p, rep, href=None):
+    if p not in ('On', 'Off'):
+        return None
+    return ['airdresseroption', 'sanitize', 'vs', '0'], {'x.com.samsung.da.sanitize': p}
+
+
+AIR_DRESSER_SETTINGS = Capability(
+    href='/washer/vs/0',
+    poll_tier='warm',
+    entities=(
+        SwitchDesc(key='wrinkle_prevent', field='x.com.samsung.da.wrinklePrevent',
+                   icon='mdi:iron',
+                   value_fn=lambda v: v == 'On',
+                   write_fn=_wrinkle_write),
+    ),
+)
+
+AIR_DRESSER_COURSE = Capability(
+    href='/course/vs/0',
+    entities=(
+        cycle_select(translation_key='air_dresser_cycle', icon='mdi:tshirt-crew',
+                     table_href='/st/airdressercourse/vs/0'),
+    ),
+)
+
+AIR_DRESSER_SANITIZE = Capability(
+    href='/airdresseroption/sanitize/vs/0',
+    poll_tier='warm',
+    entities=(
+        SwitchDesc(key='sanitize', field='x.com.samsung.da.sanitize',
+                   icon='mdi:weather-sunny',
+                   value_fn=lambda v: v == 'On',
+                   write_fn=_sanitize_write),
+    ),
+)

custom_components/localthings/registry/capabilities/air_purifier.py

@@ -15,6 +15,13 @@ issue #56's follow-up (five diagnostics dumps captured with the physical unit
 set to Auto/Sleep/Low/Medium/High):
   Light_On / Light_Off  -- a plain on/off flag; MODE below models it as a
                             real switch, RMW-replacing just that one entry.
+                            NOT the same polarity as the AC family's own
+                            Light_On/Light_Off token on its own /mode/vs/0
+                            (airconditioner._display_light_on) -- that one is
+                            confirmed inverted (Light_Off means the panel is
+                            lit) on live hardware. Same token name, same
+                            resource name, different device type and
+                            opposite meaning -- don't unify them.
   Comode_Off            -- read 'Off' on *every* one of the five dumps,
                             including High/Low/Medium/Auto -- confirms this
                             is NOT the fan-speed selector (ruling out the
@@ -32,35 +39,62 @@ set to Auto/Sleep/Low/Medium/High):
                             automatic side effect of sleep mode, e.g. a
                             display-dimming level, but that's still a guess).
 
-/airflow/0 and /airflow/vs/0's `speed` still isn't modeled as a real
-fan-speed control: across the same five dumps it read 0 for both Auto *and*
-High, and 3 for Low/Medium *and* Sleep -- not a monotonic mapping to any
-selectable level, and the dumps were all captured within about three minutes
-of each other (only one poll cycle apart at this integration's 30s summary
-interval), so the values may not have settled after each change before the
-diagnostics snapshot was taken. Exposed read-only pending a confirmed,
-stable capture -- see the issue #56 discussion for what's needed.
+/airflow/0's `speed` is now a real fan-speed control (issue #56 follow-up).
+The first round of five dumps above wasn't conclusive -- it read 0 for both
+Auto *and* High, and 3 for Low/Medium *and* Sleep, likely because all five
+were captured within about a minute of each other, faster than this
+integration's own ~30s poll cycle could settle each change. A second round,
+captured 60-90s apart per setting on two independent units, confirmed a
+clean monotonic mapping instead: Auto=0, Sleep=1, Low=2, Medium=3, High=4.
+AIRFLOW_GENERIC below builds an ordered-speed fan off that confirmed 0-4
+range -- same SET_SPEED shape as range_hood.py's fan, mapping HA's
+percentage steps straight onto the raw code, no named-preset table needed
+(unlike the TP1X family's FAN, which exposes real named modes because its
+board actually reports a supportedModes list to hang names off of).
+
+/airflow/vs/0's vendor `speedLevel` is NOT used for the same purpose -- it
+was unreliable on both units in that second round (Low/Medium collided on
+one unit, stuck at 0 throughout on the other), so AIRFLOW_VS_FALLBACK below
+stays a plain read-only diagnostic even after this change.
 """
 from ..capability import Capability
-from ..entities import BinarySensorDesc, SensorDesc, SwitchDesc
-from .common import int_or_none, sensor_item_value
+from ..entities import (
+    BinarySensorDesc, FanDesc, NumberDesc, SelectDesc, SensorDesc, SwitchDesc,
+)
+from .common import filter_usage_percent, int_or_none, sensor_item_value
 from .laundry import bool_option_exists, bool_option_value, option_value, option_write
 
+# Newer TP1X_DA-AC-AIR-class boards (e.g. TP1X_DA-AC-AIR-01031_0000, issue
+# #130) report fan modes directly on /mode/vs/0's top-level `modes`/
+# `supportedModes` fields (Smart/Max/Mid/WindFree/Sleep) instead of packing
+# everything into the options[] array the way the older ARTIK051_TVTL
+# family above does -- that older family's /mode/vs/0 has no top-level
+# supportedModes at all (see the module docstring's Comode_Off finding).
+# Both board generations share the /mode/vs/0 href, so FAN and MODE below
+# are mutually exclusive via this presence check rather than colliding.
+HREF_MODE = '/mode/vs/0'
+HREF_AIRFLOW = '/airflow/0'
+HREF_WIND_STRENGTH = '/wind/strength/vs/0'
+
+
+def _has_top_level_modes(rep, resources):
+    return isinstance(rep.get('x.com.samsung.da.supportedModes'), (list, tuple))
+
 _AIR_QUALITY_SENSORS = (
-    ('dust', 'Dust', 'mdi:blur', 'Dust'),
-    ('fine_dust', 'Fine dust', 'mdi:blur', 'FineDust'),
-    ('super_fine_dust', 'Super fine dust', 'mdi:blur', 'SuperFineDust'),
-    ('odor', 'Odor', 'mdi:scent', 'Odor'),
-    ('clean_level', 'Clean level', 'mdi:air-filter', 'CleanLevel'),
+    ('dust', 'mdi:blur', 'Dust'),
+    ('fine_dust', 'mdi:blur', 'FineDust'),
+    ('super_fine_dust', 'mdi:blur', 'SuperFineDust'),
+    ('odor', 'mdi:scent', 'Odor'),
+    ('clean_level', 'mdi:air-filter', 'CleanLevel'),
 )
 
 AIR_QUALITY = Capability(
     href='/sensors/vs/0',
     poll_tier='warm',
     entities=tuple(
-        SensorDesc(key=key, field='x.com.samsung.da.items', name=name, icon=icon,
+        SensorDesc(key=key, field='x.com.samsung.da.items', icon=icon,
                    value_fn=lambda items, t=sensor_type: sensor_item_value(items, t))
-        for key, name, icon, sensor_type in _AIR_QUALITY_SENSORS
+        for key, icon, sensor_type in _AIR_QUALITY_SENSORS
     ),
 )
 
@@ -85,7 +119,7 @@ FILTER = Capability(
     poll_tier='cold',
     entities=(
         SensorDesc(key='filter_progress', field='x.com.samsung.da.items',
-                   name='Filter progress', unit='%', state_class='measurement',
+                   unit='%', state_class='measurement',
                    icon='mdi:air-filter', entity_category='diagnostic',
                    value_fn=lambda items: int_or_none(
                        _consumable_state(items, 'FilterProgress'))),
@@ -97,38 +131,77 @@ DEVICE_ACTIVE = Capability(
     poll_tier='cold',
     entities=(
         BinarySensorDesc(key='device_active', field='x.com.samsung.da.deviceActive',
-                          name='Device active', icon='mdi:check-network-outline',
+                          icon='mdi:check-network-outline',
                           entity_category='diagnostic',
                           value_fn=lambda v: bool(v)),
     ),
 )
 
-# OCF-native / vendor pair for fan speed+direction -- see module docstring for
-# why these are read-only for now.
+def _power_write(power_href, value):
+    """Shared 'power' payload handling for this family's three FanDesc write
+    functions -- targets whichever power href fan.py's _power_payload picked
+    (the board may only report /power/0); a hardcoded vendor href here would
+    silently no-op on such a board even though the entity's own is_on
+    already falls back to reading it correctly."""
+    if power_href == '/power/0':
+        return ['power', '0'], {'value': bool(value)}
+    return (['power', 'vs', '0'],
+            {'x.com.samsung.da.power': 'On' if value else 'Off'})
+
+
+def _airflow_fan_write(payload, rep, href=None):
+    kind, value, *args = payload
+    if kind == 'power':
+        return _power_write(args[0] if args else '/power/vs/0', value)
+    if kind == 'speed':
+        return ['airflow', '0'], {'speed': int(value)}
+    return None
+
+
+# Confirmed via issue #56's second, properly-spaced round of diagnostics
+# (two independent units, 60-90s apart per setting): /airflow/0's `speed` is
+# a clean, monotonic 0-4 code across Auto/Sleep/Low/Medium/High, so it now
+# backs a real ordered-speed fan (fan.py's LocalThingsAirflowFan, same
+# SET_SPEED shape as the range hood's) instead of a read-only sensor --
+# no named-preset table needed, since HA's percentage steps map onto the
+# raw 0-4 code directly, the same way the range hood's numeric levels do.
+# `direction` stays a plain diagnostic: every dump seen (both rounds, both
+# units) reads 'Off' for it regardless of fan setting, so there's nothing
+# confirmed to control there yet.
+#
+# Keyed 'airflow_fan', not 'fan' -- FAN below (bound to the shared
+# /mode/vs/0 href) also uses 'fan', and BoundEntity's unique_id is built
+# from key alone (entity.py's _key), not href. FAN and AIRFLOW_GENERIC are
+# only *empirically* mutually exclusive (every dump seen has one board
+# generation's shape or the other, never both), not architecturally
+# enforced the way same-href caps are by _build()'s match_fn check -- a
+# same key would collide if a future board ever reported both.
 AIRFLOW_GENERIC = Capability(
-    href='/airflow/0',
+    href=HREF_AIRFLOW,
     poll_tier='warm',
     entities=(
-        SensorDesc(key='fan_speed_level', field='speed',
-                   name='Fan speed level', icon='mdi:fan',
-                   state_class='measurement', entity_category='diagnostic'),
+        FanDesc(key='airflow_fan', field='speed', write_fn=_airflow_fan_write),
         SensorDesc(key='fan_direction', field='direction',
-                   name='Fan direction', icon='mdi:rotate-3d-variant',
+                   icon='mdi:rotate-3d-variant',
                    entity_category='diagnostic'),
     ),
 )
 
+# Left exactly as a read-only fallback -- speedLevel is NOT the same
+# confirmed-reliable field as /airflow/0's speed above (see module
+# docstring): it collided Low/Medium on one unit and stuck at 0 throughout
+# on the other in the same properly-spaced round.
 AIRFLOW_VS_FALLBACK = Capability(
     href='/airflow/vs/0',
     match_fn=lambda rep, resources: '/airflow/0' not in resources,
     poll_tier='warm',
     entities=(
         SensorDesc(key='fan_speed_level', field='x.com.samsung.da.speedLevel',
-                   name='Fan speed level', icon='mdi:fan',
+                   icon='mdi:fan',
                    state_class='measurement', entity_category='diagnostic',
                    value_fn=int_or_none),
         SensorDesc(key='fan_direction', field='x.com.samsung.da.direction',
-                   name='Fan direction', icon='mdi:rotate-3d-variant',
+                   icon='mdi:rotate-3d-variant',
                    entity_category='diagnostic'),
     ),
 )
@@ -149,26 +222,244 @@ def _light_write(payload, rep, href=None):
 MODE = Capability(
     href='/mode/vs/0',
     poll_tier='warm',
+    match_fn=lambda rep, resources: not _has_top_level_modes(rep, resources),
     entities=(
-        SwitchDesc(key='display_light', name='Display light', icon='mdi:led-on',
+        SwitchDesc(key='display_light', icon='mdi:led-on',
                    entity_category='config',
                    rep_fn=bool_option_value('Light'),
                    exists_fn=bool_option_exists('Light'),
                    write_fn=_light_write),
         # Read-only -- confirmed NOT the fan-speed selector (see module
         # docstring), actual purpose still unconfirmed.
-        SensorDesc(key='operating_mode', name='Operating mode', icon='mdi:fan',
+        SensorDesc(key='operating_mode', icon='mdi:fan',
                    entity_category='diagnostic',
                    rep_fn=lambda rep: option_value(rep.get('x.com.samsung.da.options'), 'Comode'),
                    exists_fn=bool_option_exists('Comode')),
     ),
 )
 
+
+def _fan_write(payload, rep, href=None):
+    kind, value, *args = payload
+    if kind == 'power':
+        return _power_write(args[0] if args else '/power/vs/0', value)
+    if kind == 'mode':
+        return ['mode', 'vs', '0'], {'x.com.samsung.da.modes': [value]}
+    return None
+
+
+def _first_fan_mode(rep):
+    """Representative scalar for the fan entity in the flattened state
+    (golden/regression), mirroring airconditioner.py's own _first_mode --
+    the real entity computes its state from live coordinator reads."""
+    modes = rep.get('x.com.samsung.da.modes')
+    if isinstance(modes, (list, tuple)):
+        return modes[0] if modes else None
+    return modes
+
+
+# Named preset modes (Smart/Max/Mid/WindFree/Sleep), not an ordered
+# percentage -- WindFree/Smart/Sleep are named behaviors, not
+# "faster/slower" positions relative to Max/Mid, so fan.py's entity for
+# this only exposes PRESET_MODE, matching how the AC family's own named
+# convenient modes are modeled as a preset rather than a speed number.
+FAN = Capability(
+    href=HREF_MODE,
+    poll_tier='warm',
+    match_fn=_has_top_level_modes,
+    entities=(
+        FanDesc(key='fan', translation_key='air_purifier_fan',
+                rep_fn=_first_fan_mode, write_fn=_fan_write),
+    ),
+)
+
+
+def _wind_strength_fan_write(payload, rep, href=None):
+    kind, value, *args = payload
+    if kind == 'power':
+        return _power_write(args[0] if args else '/power/vs/0', value)
+    if kind == 'mode':
+        return ['wind', 'strength', 'vs', '0'], {'x.com.samsung.da.modes': value}
+    return None
+
+
+# A-VTWW-TP2-21-COMMON (issue #151): named preset modes like FAN above, but
+# on a distinct href with numeric codes ("87"/"89"/"90"/"91") instead of
+# self-describing supportedModes -- x.com.samsung.da.modesName gives the
+# actual names (SMART/MAX/WINDFREE/Sleep), read live by fan.py's
+# LocalThingsAirPurifierFan._label_for_code rather than a hardcoded
+# per-model map. modes here is a bare string ('87'), not a single-element
+# list like HREF_MODE's -- _wind_strength_fan_write writes it back as-is.
+#
+# key is 'wind_strength_fan', NOT 'fan' -- FAN above shares this registry
+# and also uses a FanDesc; BoundEntity's unique_id is built from key alone
+# (entity.py's _key), not href, so two same-key FanDescs in one registry
+# would collide if a board ever bound both (see AIRFLOW_GENERIC's own
+# comment on this exact hazard -- missed here in the initial cut).
+WIND_STRENGTH_FAN = Capability(
+    href=HREF_WIND_STRENGTH,
+    poll_tier='warm',
+    entities=(
+        FanDesc(key='wind_strength_fan', translation_key='air_purifier_fan',
+                field='x.com.samsung.da.modes', write_fn=_wind_strength_fan_write),
+    ),
+)
+
+# ---------------------------------------------------------------------------
+# TP1X_DA-AC-AIR-class additions (issue #130). This board reports several
+# resources the older ARTIK051_TVTL family never did.
+# ---------------------------------------------------------------------------
+
+# Screen/indicator-panel on/off -- distinct from LIGHT below (ambient mood
+# light): both report the same {mode, supportedModes: [On, Off]} shape on
+# separate hrefs on this dump, so they're two independent physical controls,
+# not a duplicate encoding of one.
+DISPLAY = Capability(
+    href='/display/vs/0',
+    poll_tier='cold',
+    entities=(
+        SwitchDesc(key='display', field='mode',
+                   icon='mdi:monitor',
+                   entity_category='config',
+                   value_fn=lambda v: v == 'On',
+                   write_fn=lambda p, rep, href=None: (
+                       ['display', 'vs', '0'],
+                       {'mode': 'On' if p == 'On' else 'Off'})),
+    ),
+)
+
+# Same filterUsage/filterCapacity/filterStatus shape as the AC family's own
+# AIR_FILTER (airconditioner.py) -- confirmed normal/wash/replace values not
+# seen on this one dump, so the option list there is reused as-is rather
+# than re-deriving it from a single sample.
+HEPA_FILTER = Capability(
+    href='/filter/hepafilter/vs/0',
+    poll_tier='cold',
+    entities=(
+        SensorDesc(key='hepa_filter_usage', rep_fn=filter_usage_percent,
+                   unit='%', state_class='measurement',
+                   icon='mdi:air-filter', entity_category='diagnostic'),
+        SensorDesc(key='hepa_filter_status', field='x.com.samsung.da.filterStatus',
+                   device_class='enum',
+                   options=('normal', 'wash', 'replace'),
+                   translation_key='filter_status',
+                   icon='mdi:air-filter', entity_category='diagnostic',
+                   value_fn=lambda v: v.lower() if isinstance(v, str) else v),
+    ),
+)
+
+# Physical panel/cover status -- meaning of the one value seen ('Close') is
+# plausible (the HEPA-filter access cover) but unconfirmed, and no
+# supportedStatus list is present to check against -- exposed as a plain
+# diagnostic sensor rather than an asserted binary_sensor polarity.
+PANEL_STATUS = Capability(
+    href='/panel/vs/0',
+    poll_tier='cold',
+    entities=(
+        SensorDesc(key='panel_status', field='status',
+                   icon='mdi:archive-outline', entity_category='diagnostic'),
+    ),
+)
+
+# Pet-care filter mode -- a plain On/Off field with no vendor prefix, same
+# convention as airconditioner.MUTE_ONCE.
+PET_FILTER_ACTIVATION = Capability(
+    href='/petfilteractivation/vs/0',
+    poll_tier='cold',
+    entities=(
+        SwitchDesc(key='pet_filter_activation', field='status',
+                   icon='mdi:paw',
+                   entity_category='config',
+                   value_fn=lambda v: v == 'On',
+                   write_fn=lambda p, rep, href=None: (
+                       ['petfilteractivation', 'vs', '0'],
+                       {'status': 'On' if p == 'On' else 'Off'})),
+    ),
+)
+
+# Sound mode/volume shapes look like laundry.py's SOUND_MODE/SOUND_VOLUME at
+# a glance, but this board's actual values differ (supportedModes here is
+# ['mute', 'buzzer'], not laundry's hardcoded voice/tone/mute; volume range
+# is 0-3, not laundry's fixed 0-15) -- reusing those would either reject a
+# valid write ('buzzer') or expose the wrong number range, so these are
+# separate descriptors reading the live supported values instead of a
+# hardcoded table.
+SOUND_MODE = Capability(
+    href='/settings/sound/mode/vs/0',
+    poll_tier='cold',
+    entities=(
+        # Distinct translation_key from laundry.SOUND_MODE's shared
+        # 'sound_mode' catalog entry -- that one's state table is
+        # {voice, tone, mute}, but this board's supportedModes is
+        # {mute, buzzer}. Sharing the key would leave 'buzzer' unlabelled
+        # (falls through to the raw code) since the catalogs don't overlap.
+        SelectDesc(key='sound_mode', translation_key='air_purifier_sound_mode',
+                   field='mode',
+                   icon='mdi:volume-high',
+                   entity_category='config',
+                   options_field='supportedModes',
+                   write_fn=lambda p, rep, href=None: (
+                       ['settings', 'sound', 'mode', 'vs', '0'], {'mode': p})),
+    ),
+)
+
+# Read-only descriptor of which sound output the unit has -- only one value
+# seen, no alternatives to select between.
+SOUND_OUTPUT = Capability(
+    href='/settings/sound/output/vs/0',
+    poll_tier='cold',
+    entities=(
+        SensorDesc(key='sound_output', field='deviceType',
+                   icon='mdi:volume-high', entity_category='diagnostic'),
+    ),
+)
+
+SOUND_VOLUME = Capability(
+    href='/settings/sound/volume/vs/0',
+    poll_tier='cold',
+    entities=(
+        NumberDesc(key='sound_volume', field='level',
+                   icon='mdi:volume-medium',
+                   entity_category='config',
+                   native_min_fn=lambda rep: int_or_none(rep.get('minLevel')) or 0,
+                   native_max_fn=lambda rep: int_or_none(rep.get('maxLevel')) or 0,
+                   step_fn=lambda rep: int_or_none(rep.get('resolution')) or 1,
+                   value_fn=int_or_none,
+                   write_fn=lambda p, rep, href=None: (
+                       ['settings', 'sound', 'volume', 'vs', '0'],
+                       {'level': str(int(p))})),
+    ),
+)
+
 # /humidity/0 and /humidity/vs/0 are empty {} on both dumps this family has
 # been verified against -- covered here (not globally, per ignored.py's
 # module docstring) since those hrefs collide with fridge/AC schemas
 # elsewhere. Same two hrefs and reasoning as airconditioner.py's _AC_IGNORED.
+#
+# The next six hrefs (issue #130, TP1X_DA-AC-AIR board) are the exact same
+# resources, same shapes, same reasoning as airconditioner.py's
+# _AC_IGNORED on the shared DA-AC- board family -- duplicated here rather
+# than promoted to the global ignored.py list, since that would require
+# also removing them from _AC_IGNORED in the same change (a global entry
+# colliding with a family-local bare Capability on the same href raises in
+# _build()); left as a possible follow-up DRY cleanup.
 COVERAGE = [
     Capability(href='/humidity/0'),
     Capability(href='/humidity/vs/0'),
+    Capability(href='/airlevelcheck/vs/0'),        # periodic air-quality sensing scheduler plumbing
+    Capability(href='/availablecontrolsets/vs/0'), # opaque hex-encoded control-set bitmap
+    Capability(href='/da/softreset/vs/0'),         # soft-reset trigger plumbing
+    Capability(href='/keepnormalstate/vs/0'),      # internal keep-normal flag
+    Capability(href='/personality/presence/vs/0'), # presence-personalization plumbing (empty here)
+    Capability(href='/reserverulesets/vs/0'),      # opaque hex-encoded schedule reservation blob
+    # Do-not-disturb/auto-sleep schedule (visible/startTime/endTime/
+    # useTimeSetting/functionState) -- every field reads its inert default
+    # on the only dump seen (times both '00:00:00', useTimeSetting/
+    # functionState both 'false'). Same "needs a multi-field schedule
+    # editor" treatment as fridge.py's /defrost/reservation/vs/0.
+    Capability(href='/dnd/autosleep/vs/0'),
+    # Empty ({}) on the A-VTWW-TP2-21 dump (issue #151) -- this board's
+    # convenient-mode-equivalent behavior lives entirely in WIND_STRENGTH_FAN
+    # above instead.
+    Capability(href='/mode/convenient/vs/0'),
 ]

custom_components/localthings/registry/capabilities/airconditioner.py

@@ -14,8 +14,145 @@ None of these caps may go into the global `ALL`/`CAPABILITIES`: `/mode/vs/0`,
 different schema (see capabilities/__init__.py). They live only in the AC
 by_type registry.
 """
+from dataclasses import replace
+
 from ..capability import Capability
-from ..entities import BinarySensorDesc, ClimateDesc, SensorDesc, SwitchDesc
+from ..entities import (
+    BinarySensorDesc, ClimateDesc, NumberDesc, SelectDesc, SensorDesc, SwitchDesc,
+)
+from . import common
+from .common import filter_usage_percent, normalize_temp_unit
+from .laundry import option_write
+
+
+def _int(v):
+    try:
+        return int(v)
+    except (TypeError, ValueError):
+        return None
+
+
+def _beep_on(rep):
+    """Beep on/off from the `Volume_*` option token: Volume_Mute = off,
+    Volume_100 (and any non-Mute) = on. None when no Volume_ slot.
+
+    _option_token (defined further below, alongside the legacy-board token
+    helpers) returns the token's *value* half (e.g. 'Mute', '100'), not the
+    full 'Volume_100' token -- shared with _option_token_num/_option_token_on,
+    which this module's other options[] readers already rely on.
+    """
+    tok = _option_token(rep, 'Volume')
+    if tok is None:
+        return None
+    return tok != 'Mute'
+
+
+def _beep_write(payload, rep, href=None):
+    """Toggle beep via a single-token /mode/vs/0 options write (option_write's
+    one-token merge -- a full options RMW reverts on ARTIK051_PRAC). 'On'
+    restores the last non-Mute level rather than forcing Volume_100, so a
+    user's intermediate setting (e.g. Volume_50 set via the cloud) survives an
+    off/on cycle; falls back to 100 when no prior level is known."""
+    if payload not in ('On', 'Off'):
+        return None
+    if payload == 'Off':
+        token = 'Mute'
+    else:
+        prev = _option_token(rep, 'Volume')
+        token = prev if (prev and prev != 'Mute') else '100'
+    return ['mode', 'vs', '0'], {
+        'x.com.samsung.da.options': option_write('Volume', token),
+    }
+
+
+def _tropical_night_value(rep):
+    """Tropical night mode level (0-16) from the `Sleep_<N>` option token.
+
+    _option_token returns the token's value half already (e.g. '16' for
+    'Sleep_16'), same convention as _beep_on above.
+    """
+    tok = _option_token(rep, 'Sleep')
+    if tok is None:
+        return None
+    return _int(tok)
+
+
+def _tropical_night_write(value, rep, href=None):
+    """Set tropical night level via a single-token `Sleep_<N>` options write.
+    Samsung cloud counterpart: custom.airConditionerTropicalNightMode (0-16)."""
+    try:
+        level = int(round(float(value)))
+    except (TypeError, ValueError):
+        return None
+    if not 0 <= level <= 16:
+        return None
+    return ['mode', 'vs', '0'], {
+        'x.com.samsung.da.options': option_write('Sleep', str(level)),
+    }
+
+
+def _filter_unit(rep):
+    """Unit of the filter-usage fields, normalised from filterCapacityUnit
+    ('Hour' -> 'h'). Wired through unit_fn so a board advertising a different
+    unit doesn't silently mislabel a duration statistic."""
+    u = rep.get('x.com.samsung.da.filterCapacityUnit')
+    return {'Hour': 'h', 'Minute': 'min', 'Second': 's'}.get(u, u or 'h')
+
+
+def _threshold_write(payload, rep, href=None):
+    """filterDesiredUsage is locally writable: a plain scalar POST of the
+    field to /filter/airdustfilter/vs/0 is 2.04-accepted and persists
+    (confirmed live on ARTIK051_PRAC: POST 700 -> 2.04, read-back 700). The
+    Select only surfaces where the device advertises
+    supportedFilterDesiredUsage, so the valid options are known rather than
+    guessed; boards without that enum leave this writable field unexposed."""
+    return ['filter', 'airdustfilter', 'vs', '0'], {
+        'x.com.samsung.da.filterDesiredUsage': payload,
+    }
+
+
+def _sensor_item_value(items, type_):
+    """First value of the /sensors/vs/0 item with the given
+    x.com.samsung.da.type. The resource exposes no unit, so no device_class is
+    set until a populated reading + unit is observed (the 'don't guess' rule).
+
+    Dust/FineDust/SuperFineDust report a 2-element array (['0','0']) while
+    CleanLevel/Odor report a single element -- the second element's meaning is
+    unconfirmed, so v[0] is taken as the reading and v[1] is dropped; left as
+    a string rather than coerced numeric because only CleanLevel has
+    corroborating evidence (a top-level x.com.samsung.da.cleanLevel scalar)."""
+    for it in (items or []):
+        if isinstance(it, dict) and it.get('x.com.samsung.da.type') == type_:
+            v = it.get('x.com.samsung.da.value')
+            if isinstance(v, list) and v:
+                return str(v[0])
+            return None
+    return None
+
+
+def _has_sensor_type(type_):
+    """True when the /sensors/vs/0 items[] array lists an item of this type.
+
+    This proves the type is *listed*, not that the reading is real: issue
+    #166 (ARxxTXFCAWKNEU, board ARTIK051_PRAC_20K) lists all five item types
+    with permanent zero values on both its units, and the reporter confirmed
+    none of these sensors are physically present. A top-level
+    x.com.samsung.da.cleanLevel scalar (separate from the CleanLevel item)
+    looked like a corroborating "this reading is real" signal at first --
+    present alongside genuinely populated readings on tp1x_da_ac_rac_01011
+    and the tp1x_da_ac_air air purifier fixture, absent on every all-zero
+    ARTIK051_PRAC_20K dump including both #166 units -- but it doesn't hold
+    up as a general rule: air_purifier_device.json (ARTIK051_TVTL_18K),
+    air_purifier_vtww_device.json, and range_hood_device.json all carry
+    genuinely populated, non-AC-family Dust/FineDust/SuperFineDust readings
+    with no such scalar. So this stays item-type presence only -- the
+    entities are disabled by default instead (see AIR_QUALITY below) rather
+    than existence-gated on a signal that would silently drop real readings
+    on hardware this repo hasn't seen yet."""
+    def fn(rep, resources):
+        return any(isinstance(i, dict) and i.get('x.com.samsung.da.type') == type_
+                   for i in (rep.get('x.com.samsung.da.items') or []))
+    return fn
 
 # ---------------------------------------------------------------------------
 # Canonical AC resource hrefs. The climate entity (climate.py) binds the
@@ -33,13 +170,26 @@ HREF_TEMP_DESIRED = '/temperature/desired/0'      # target_temperature (write ta
 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
+# Newer boards (issue #126, TP1X_DA-AC-RAC-01011 WindFree variant) report no
+# HREF_WIND_DIRECTION at all and instead carry a 2-axis oscillation resource
+# (separate vertical/horizontal Swing|Fix toggles, each with its own angle).
+# climate.py falls back to this when HREF_WIND_DIRECTION is absent, the same
+# duality pattern as the OCF/vendor temperature channel below.
+HREF_WIND_OSCILLATION = '/wind/oscillation/vs/0'  # swing_mode fallback
 HREF_CONVENIENT = '/mode/convenient/vs/0'         # preset_mode
 HREF_TEMPS_VS = '/temperatures/vs/0'              # vendor temp fallback (items[] array)
+# Legacy ARTIK051 boards (ARTIK051_KRAC_18K, issue #136) carry no /wind/* resources
+# at all: fan speed and vane direction sit together in this one resource, as
+# x.com.samsung.da.speedLevel (the same 0-4 scale as _DEVICE_TO_FAN) and
+# x.com.samsung.da.direction (the same codes as _DEVICE_TO_SWING). Their
+# convenient-mode preset is a Comode_* token in /mode/vs/0's options instead of a
+# resource of its own -- see climate.py's _legacy_airflow/_legacy_convenient.
+HREF_AIRFLOW = '/airflow/vs/0'                    # legacy fan_mode + swing_mode
 
 CLIMATE_CONSUMED_HREFS = [
     HREF_POWER, HREF_POWER_VS, HREF_TEMP_CURRENT, HREF_TEMP_DESIRED,
     HREF_TEMP_CONTROL, HREF_TEMPS_VS, HREF_WIND_STRENGTH, HREF_WIND_DIRECTION,
-    HREF_CONVENIENT,
+    HREF_WIND_OSCILLATION, HREF_CONVENIENT, HREF_AIRFLOW,
 ]
 
 
@@ -50,16 +200,23 @@ def _num(v):
         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 _temps_vs_item(rep):
+    """First item of the vendor `/temperatures/vs/0` items[] array -- the
+    Tizen Lite board's only current-temperature source (see climate.py's
+    identical helper; duplicated rather than imported to avoid a
+    capabilities<->platform import cycle)."""
+    items = rep.get('x.com.samsung.da.items')
+    if isinstance(items, (list, tuple)) and items and isinstance(items[0], dict):
+        return items[0]
+    return {}
+
+
+def _temps_vs_current(rep):
+    return _num(_temps_vs_item(rep).get('x.com.samsung.da.current'))
+
+
+def _temps_vs_unit(rep):
+    return normalize_temp_unit(_temps_vs_item(rep).get('x.com.samsung.da.unit'), '°C')
 
 
 def _first_mode(rep):
@@ -71,25 +228,247 @@ def _first_mode(rep):
     return modes
 
 
+def _mode_options(rep):
+    opts = rep.get('x.com.samsung.da.options')
+    return opts if isinstance(opts, (list, tuple)) else ()
+
+
+def _has_display_light_option(rep, resources):
+    """True when the panel light state is carried inside /mode/vs/0's options
+    blob (a `Light_On`/`Light_Off` token) rather than a dedicated /light/vs/0
+    switch. The two encodings are mutually exclusive across observed boards:
+    models exposing the /light/vs/0 switch (bound by DISPLAY_LIGHT below)
+    carry no Light_* option, so this entity only materialises on the boards
+    that would otherwise have no display-light entity at all."""
+    return any(isinstance(o, str) and o.startswith('Light_')
+               for o in _mode_options(rep))
+
+
+def _display_light_on(rep):
+    """Panel display light state from /mode/vs/0's options blob. The token is
+    INVERTED relative to its name -- confirmed by a live toggle test: with the
+    panel lit the option reads `Light_Off`, and with it dark it reads
+    `Light_On` (the flag really encodes "night/display-off mode active"). So
+    `Light_Off` -> light on, `Light_On` -> light off. Read-only from here; the
+    write below uses the device's own single-token merge (see option_write)."""
+    for o in _mode_options(rep):
+        if isinstance(o, str) and o.startswith('Light_'):
+            return o == 'Light_Off'
+    return None
+
+
+def _display_light_write(payload, rep, href=None):
+    """Toggle the panel light via a single-token /mode/vs/0 options write
+    ('SingleCommand_1' is advertised in this family's /configuration/vs/0
+    airconOptionList; option_write's one-token merge is the same mechanism
+    air_purifier.py uses for its own Light switch). Polarity is inverted (see
+    _display_light_on): switching the lamp ON writes 'Light_Off', OFF writes
+    'Light_On'."""
+    token = 'Off' if payload == 'On' else 'On'
+    return (['mode', 'vs', '0'],
+            {'x.com.samsung.da.options': option_write('Light', token)})
+
+
+# ---------------------------------------------------------------------------
+# Legacy ARTIK051 boards keep several settings that newer boards expose as their
+# own resources (/option/*, /electriccurrent/vs/0, ...) as `<Prefix>_<value>`
+# tokens inside /mode/vs/0's options blob instead. Reads pull the token apart;
+# writes reuse option_write's single-token merge, exactly like the display light.
+# ---------------------------------------------------------------------------
+
+
+def _option_token(rep, prefix):
+    """Value part of a `<prefix>_<value>` token in /mode/vs/0's options."""
+    for option in _mode_options(rep):
+        if isinstance(option, str) and option.startswith(prefix + '_'):
+            return option.split('_', 1)[1]
+    return None
+
+
+def is_legacy_board(resources):
+    """True for the board generation whose airflow lives in /airflow/vs/0.
+
+    Newer families carry several of the same option tokens (Sleep, OutdoorTemp,
+    Autoclean) *alongside* dedicated resources for those settings, so an
+    ungated token entity would either duplicate an existing one or apply a
+    scale calibrated elsewhere. (Volume used to be in this list too, back when
+    it had its own gated buzzer_volume Number for this board generation --
+    issue #136 replaced that with the unified 'beep' switch, which applies
+    across every generation and isn't gated here at all.) Every AC dump on
+    record has one shape or the other: /airflow/vs/0 with no /wind/* at all,
+    or /wind/strength/vs/0 with no /airflow/vs/0. Same test as climate.py's
+    _legacy_airflow(), so the entities below and the climate entity can never
+    disagree about the generation.
+    """
+    return HREF_AIRFLOW in resources and HREF_WIND_STRENGTH not in resources
+
+
+# This legacy ARTIK051 board generation (issue #193, model AR12NXWXCWKNEU /
+# ARTIK051_KRAC_18K) reports /energy/consumption/vs/0's cumulativePower in
+# centiwatt-hours -- raw value 100x the plain Wh every other AC board family
+# (and common.wh_to_kwh's assumed unit) reports. Confirmed against the
+# reporter's own SmartThings-app reading: raw '117430000' vs the app's
+# authoritative 1,174.30 kWh is exactly a /100000 factor (i.e. /100 on top of
+# wh_to_kwh's own /1000), not wh_to_kwh's plain /1000 alone. No other field in
+# ENERGY_METER's entities is present on this board's dump, so only
+# 'energy_kwh' needs a replacement value_fn here; the rest pass through
+# unchanged in case a future legacy dump ever reports them.
+def _legacy_cumulative_power_kwh(v):
+    # float, not _int -- matches common.wh_to_kwh's own numeric parsing
+    # (float via _num) rather than this module's integer-only _int, so a
+    # decimal-formatted reading doesn't raise and silently go 'unknown'.
+    try:
+        n = float(v)
+    except (TypeError, ValueError):
+        return None
+    return round(n / 100000.0, 2)
+
+
+ENERGY_METER_LEGACY = replace(
+    common.ENERGY_METER,
+    match_fn=lambda rep, resources: is_legacy_board(resources),
+    entities=tuple(
+        replace(e, value_fn=_legacy_cumulative_power_kwh)
+        if e.key == 'energy_kwh' else e
+        for e in common.ENERGY_METER.entities
+    ),
+)
+
+# The non-legacy counterpart to ENERGY_METER_LEGACY above -- identical to
+# common.ENERGY_METER, just excluding the legacy board generation so the two
+# capabilities can share /energy/consumption/vs/0 in this registry without
+# the 'multiple caps need a discriminator' build check tripping (common.
+# ENERGY_METER itself has no match_fn, since every *other* registry includes
+# it unconditionally and alone).
+ENERGY_METER_GENERIC = replace(
+    common.ENERGY_METER,
+    match_fn=lambda rep, resources: not is_legacy_board(resources),
+)
+
+
+def _has_option_token(prefix):
+    return lambda rep, resources: (
+        is_legacy_board(resources) and _option_token(rep, prefix) is not None)
+
+
+def _option_token_on(prefix):
+    return lambda rep: _option_token(rep, prefix) == 'On'
+
+
+def _option_token_num(prefix, offset=0, divisor=1):
+    def read(rep):
+        raw = _option_token(rep, prefix)
+        try:
+            return (float(raw) - offset) / divisor
+        except (TypeError, ValueError):
+            return None
+    return read
+
+
+def _option_switch_write(prefix):
+    def write(payload, rep, href=None):
+        return (['mode', 'vs', '0'],
+                {'x.com.samsung.da.options': option_write(prefix, payload)})
+    return write
+
+
+def _option_number_write(prefix):
+    def write(payload, rep, href=None):
+        return (['mode', 'vs', '0'],
+                {'x.com.samsung.da.options':
+                 option_write(prefix, str(int(round(float(payload)))))})
+    return write
+
+
+def _humidity(rep):
+    """Relative humidity, preferring the 5%-rounded field where it exists.
+
+    ARTIK051 boards have no fivepercentHumidity field at all and report the
+    plain x.com.samsung.da.humidity instead -- and only populate it while the
+    Air monitoring option is on: the unit measures for roughly half a minute
+    (51% observed, matching what the same unit's cloud integration reported at
+    that moment), then zeroes the field and switches Air monitoring back off by
+    itself. So 0 reads as "not measuring" and is reported as unknown rather than
+    as 0% humidity, which would poison long-term history.
+
+    That zero-as-"not measuring" carve-out is specific to the ARTIK051
+    fallback field's hardware quirk -- every other board's fivepercentHumidity
+    has never been documented getting stuck at zero, and collapsing a
+    genuine 0% reading there to unknown is a regression, not a safeguard
+    (issue #160). So fivepercentHumidity passes 0 through unchanged; only the
+    humidity fallback applies the zero-collapse.
+    """
+    if 'x.com.samsung.da.fivepercentHumidity' in rep:
+        return _num(rep['x.com.samsung.da.fivepercentHumidity'])
+    if 'x.com.samsung.da.humidity' in rep:
+        value = _num(rep['x.com.samsung.da.humidity'])
+        return value if value else None
+    return None
+
+
 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.
+    so a single desc drives writes across the power/mode/temperature/wind
+    resources.
+
+    Power goes to the vendor `/power/vs/0` (the OCF `/power/0` is absent on
+    most boards and a non-authoritative mirror where present -- vendor works
+    on every board). Temperature is board-dependent, so the platform picks the
+    channel and sends `temperature_ocf` (-> OCF `/temperature/desired/0`,
+    boards with the full OCF current+desired pair) or `temperature` (-> vendor
+    `/temperatures/vs/0`, boards without it). Mode/fan/swing/preset are always
+    the vendor `/x/vs/0` resources.
+
+    Each write sends only its own field(s), leaving the resource's other
+    fields (e.g. /mode/vs/0's opaque `options` blob, or the vendor temperature
+    item's current/minimum/maximum/unit) untouched -- the device merges the
+    rest itself, same contract as the options[] array (see
+    common.merge_items_field / merge_options_field, which keep the
+    coordinator's optimistic cache complete for the settle window instead of
+    this write echoing those fields back).
     """
     kind, value = payload
     if kind == 'power':
-        return (['power', '0'], {'value': bool(value)})
+        return (['power', 'vs', '0'],
+                {'x.com.samsung.da.power': 'On' if value else 'Off'})
     if kind == 'mode':
         return (['mode', 'vs', '0'], {'x.com.samsung.da.modes': [value]})
+    if kind == 'temperature_ocf':
+        return (['temperature', 'desired', '0'],
+                {'temperature': int(round(float(value)))})
     if kind == 'temperature':
-        return (['temperature', 'desired', '0'], {'temperature': int(round(float(value)))})
+        # Vendor items[] array; only one item observed on every AC dump, id
+        # '0'. See the docstring above for why this doesn't echo current/
+        # minimum/maximum/unit back at the unit.
+        return (['temperatures', 'vs', '0'],
+                {'x.com.samsung.da.items': [
+                    {'x.com.samsung.da.id': '0',
+                     'x.com.samsung.da.desired': str(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 == 'oscillation':
+        # value is the HA swing_mode string ('off'/'vertical'/'horizontal'/
+        # 'both'); both axes are independent Swing|Fix toggles on this
+        # resource, so one HA value maps to a pair of fields written
+        # together (see climate.py's oscillation fallback).
+        return (['wind', 'oscillation', 'vs', '0'], {
+            'vertical': 'Swing' if value in ('vertical', 'both') else 'Fix',
+            'horizontal': 'Swing' if value in ('horizontal', 'both') else 'Fix',
+        })
+    if kind == 'fan_legacy':
+        return (['airflow', 'vs', '0'],
+                {'x.com.samsung.da.speedLevel': str(value)})
+    if kind == 'swing_legacy':
+        return (['airflow', 'vs', '0'],
+                {'x.com.samsung.da.direction': value})
+    if kind == 'preset_legacy':
+        # Single-token options merge, same mechanism as _display_light_write.
+        return (['mode', 'vs', '0'],
+                {'x.com.samsung.da.options': option_write('Comode', value)})
     if kind == 'preset':
         return (['mode', 'convenient', 'vs', '0'], {'x.com.samsung.da.modes': value})
     return None
@@ -101,6 +480,108 @@ CLIMATE = Capability(
     entities=(
         ClimateDesc(key='climate', translation_key='airconditioner',
                     rep_fn=_first_mode, write_fn=_climate_write),
+        # Display (panel) light switch, only on boards that encode it in
+        # /mode/vs/0's options instead of a /light/vs/0 switch (see
+        # _has_display_light_option). Shares the /mode/vs/0 href with the
+        # climate entity above -- same Capability, so no multi-cap
+        # discriminator is needed. /mode/vs/0 is OBSERVE-subscribed, so state
+        # updates on push; writes go through the single-token merge in
+        # _display_light_write. Shares the switch.display_light translation
+        # with DISPLAY_LIGHT (the /light/vs/0 switch on other boards) --
+        # mutually exclusive per href, so only one ever binds for a given unit.
+        SwitchDesc(key='display_light', rep_fn=_display_light_on,
+                   exists_fn=_has_display_light_option,
+                   write_fn=_display_light_write,
+                   icon='mdi:led-on', entity_category='config'),
+        # Beep on/off from the `Volume_*` option token (Volume_Mute/Volume_100).
+        # Single-token option_write; a full options RMW reverts on ARTIK051_PRAC.
+        #
+        # Applies uniformly across board generations, including legacy
+        # ARTIK051 boards -- issue #136: this token was originally modeled as
+        # a 0-100 buzzer_volume Number for legacy boards on the assumption it
+        # was a real graduated volume level, but every unit confirmed on
+        # hardware (three units across two reporters) only ever carries
+        # Volume_100 or Volume_Mute, never an intermediate value, and the
+        # Number's write path (a plain integer string) could never produce
+        # the literal 'Mute' token needed to actually turn it off -- writing
+        # '0' is simply not a token this firmware recognizes. A switch is
+        # both the correct model and the actual fix.
+        SwitchDesc(key='beep', rep_fn=_beep_on,
+                   exists_fn=lambda rep, resources: _option_token(rep, 'Volume') is not None,
+                   write_fn=_beep_write,
+                   icon='mdi:volume-high', entity_category='config'),
+        # Tropical night mode level (0-16) from the `Sleep_<N>` option token.
+        # Single-token option_write. Cloud: custom.airConditionerTropicalNightMode.
+        # Gated off the legacy board for the same reason as beep above -- its
+        # Sleep_ token is already the good_sleep Number below.
+        #
+        # exists_fn only proves the Sleep_ token slot is present, not that
+        # tropical night mode is a real feature of the unit: issue #166
+        # (ARxxTXFCAWKNEU) reports Sleep_0 in every dump -- the exact same
+        # always-there-at-zero shape as the issue #17 dump #164 was verified
+        # against -- yet the reporter confirmed their remote/app has no
+        # tropical night mode control at all. Samsung's OCF options[] blob
+        # carries this scaffolding token regardless of physical capability,
+        # so there's no reliable signal here to gate on (same 'don't guess'
+        # rule as elsewhere in this file, just with no signal to guess from).
+        # Registered but disabled by default, same precedent as
+        # fridge.rack_count / cooktop.paired_hood_* -- units that do have the
+        # feature can enable it themselves.
+        NumberDesc(key='tropical_night_mode', rep_fn=_tropical_night_value,
+                   exists_fn=lambda rep, resources: (
+                       not is_legacy_board(resources)
+                       and _option_token(rep, 'Sleep') is not None),
+                   write_fn=_tropical_night_write,
+                   native_min=0, native_max=16, step=1,
+                   enabled_default=False,
+                   icon='mdi:weather-night', entity_category='config'),
+        # Settings that this board generation keeps as options[] tokens.
+        SwitchDesc(key='spi', rep_fn=_option_token_on('Spi'),
+                   exists_fn=_has_option_token('Spi'),
+                   write_fn=_option_switch_write('Spi'),
+                   icon='mdi:air-purifier', entity_category='config'),
+        # Shares AUTO_CLEAN's catalog entry rather than duplicating it: same
+        # feature, different board generation (that one is a /option/autoclean/
+        # vs/0 field, absent here). Distinct key, so nothing collides if some
+        # future board ever reported both.
+        SwitchDesc(key='auto_clean_legacy', translation_key='auto_clean',
+                   rep_fn=_option_token_on('Autoclean'),
+                   exists_fn=_has_option_token('Autoclean'),
+                   write_fn=_option_switch_write('Autoclean'),
+                   icon='mdi:fan-auto', entity_category='config'),
+        SwitchDesc(key='air_monitoring', rep_fn=_option_token_on('AirMonitoring'),
+                   exists_fn=_has_option_token('AirMonitoring'),
+                   write_fn=_option_switch_write('AirMonitoring'),
+                   icon='mdi:air-filter', entity_category='config'),
+        # "Good Sleep" timer. 0 = off; the upper bound is a guess (the token
+        # carries no range hint and only 0 has been observed on hardware), so a
+        # write above 0 is unverified.
+        NumberDesc(key='good_sleep', rep_fn=_option_token_num('Sleep'),
+                   exists_fn=_has_option_token('Sleep'),
+                   write_fn=_option_number_write('Sleep'),
+                   native_min=0, native_max=12, step=1, unit='h',
+                   icon='mdi:sleep', entity_category='config'),
+        # Outdoor temperature, offset by 55. Two calibration points on one unit:
+        # token 75 while an independent outdoor thermometer in the same install
+        # read 20.3 C, and token 74 against a 19.4 C forecast. Fahrenheit fits far
+        # worse (74 F = 23.3 C); the issue #136 unit's 81 gives 26 C in a warmer
+        # climate, which is also plausible.
+        SensorDesc(key='outdoor_temperature',
+                   rep_fn=_option_token_num('OutdoorTemp', offset=55),
+                   exists_fn=_has_option_token('OutdoorTemp'),
+                   device_class='temperature', state_class='measurement',
+                   unit='°C', icon='mdi:home-thermometer-outline'),
+        # Filter time in tenths of an hour: the token read 1710 while the official
+        # Samsung app displayed "171 hours 0 minutes" for the filter on the same
+        # unit, and the .0 matching the app's "0 minutes" pins the scale. Whether
+        # it counts up or down is NOT established -- it was seen rising (171.0 ->
+        # 171.5) while the unit ran, which contradicts the app's "remaining"
+        # wording, so the entity is deliberately named neutrally.
+        SensorDesc(key='filter_time',
+                   rep_fn=_option_token_num('FilterTime', divisor=10),
+                   exists_fn=_has_option_token('FilterTime'),
+                   device_class='duration', unit='h',
+                   state_class='measurement', icon='mdi:air-filter'),
     ),
 )
 
@@ -109,7 +590,7 @@ AIR_PURIFY = Capability(
     poll_tier='warm',
     entities=(
         SwitchDesc(key='air_purify', field='x.com.samsung.da.modes',
-                   name='Air purification', icon='mdi:air-purifier',
+                   icon='mdi:air-purifier',
                    entity_category='config',
                    value_fn=lambda v: v == 'On',
                    write_fn=lambda p, rep, href=None: (
@@ -123,7 +604,7 @@ AUTO_CLEAN = Capability(
     poll_tier='cold',
     entities=(
         SwitchDesc(key='auto_clean', field='x.com.samsung.da.settingStatus',
-                   name='Auto clean', icon='mdi:spray-bottle',
+                   icon='mdi:spray-bottle',
                    entity_category='config',
                    value_fn=lambda v: v == 'On',
                    write_fn=lambda p, rep, href=None: (
@@ -136,13 +617,35 @@ 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',
+        SensorDesc(key='air_filter_usage', rep_fn=filter_usage_percent,
+                   unit='%', state_class='measurement',
                    icon='mdi:air-filter', entity_category='diagnostic'),
+        # filterUsage is a lifetime hour counter that only resets on filter
+        # replacement -- total_increasing so HA's long-term statistics handle
+        # the reset rather than treating it as a bounded measurement.
+        SensorDesc(key='air_filter_usage_hours',
+                   field='x.com.samsung.da.filterUsage',
+                   device_class='duration',
+                   state_class='total_increasing',
+                   unit_fn=_filter_unit,
+                   icon='mdi:air-filter', entity_category='diagnostic',
+                   value_fn=_int),
+        # The alarm threshold (filterDesiredUsage) is a locally writable option:
+        # see _threshold_write. Surfaces as a Select only where the device
+        # advertises supportedFilterDesiredUsage; boards without that enum
+        # leave it unexposed rather than guess the valid set.
+        SelectDesc(key='air_filter_threshold',
+                   field='x.com.samsung.da.filterDesiredUsage',
+                   options_field='x.com.samsung.da.supportedFilterDesiredUsage',
+                   exists_fn=lambda rep, res: bool(
+                       rep.get('x.com.samsung.da.supportedFilterDesiredUsage')),
+                   icon='mdi:alarm', entity_category='config',
+                   write_fn=_threshold_write,
+                   value_fn=lambda v: str(v) if v is not None else None),
         SensorDesc(key='air_filter_status', field='x.com.samsung.da.filterStatus',
-                   name='Filter status', device_class='enum',
+                   device_class='enum',
                    options=('normal', 'wash', 'replace'),
-                   translation_key='air_filter_status',
+                   translation_key='filter_status',
                    icon='mdi:air-filter', entity_category='diagnostic',
                    value_fn=lambda v: v.lower() if isinstance(v, str) else v),
     ),
@@ -153,7 +656,7 @@ DISPLAY_LIGHT = Capability(
     poll_tier='cold',
     entities=(
         SwitchDesc(key='display_light', field='mode',
-                   name='Display light', icon='mdi:led-on',
+                   icon='mdi:led-on',
                    entity_category='config',
                    value_fn=lambda v: v == 'On',
                    write_fn=lambda p, rep, href=None: (
@@ -170,7 +673,7 @@ MUTE_ONCE = Capability(
     poll_tier='warm',
     entities=(
         SwitchDesc(key='mute_once', field='muteonce',
-                   name='Mute once', icon='mdi:volume-mute',
+                   icon='mdi:volume-mute',
                    entity_category='config',
                    value_fn=lambda v: v == 'On',
                    write_fn=lambda p, rep, href=None: (
@@ -190,15 +693,196 @@ CURRENT_LIMIT = Capability(
     poll_tier='cold',
     entities=(
         BinarySensorDesc(key='current_limit_enabled', field='operation',
-                          name='Current limit enabled', icon='mdi:current-ac',
+                          icon='mdi:current-ac',
                           entity_category='diagnostic',
                           value_fn=lambda v: v == 'On'),
         SensorDesc(key='current_limit_level', field='modes',
-                   name='Current limit level', icon='mdi:current-ac',
+                   icon='mdi:current-ac',
                    entity_category='diagnostic'),
     ),
 )
 
+# Overload-response setting (issue #126, TP1X_DA-AC-RAC-01011 WindFree
+# variant): `operation` toggles the feature and `mode` picks 'Alarm' vs
+# 'PowerSaving' out of `supportedModes`, with a `savingTime` duration
+# ('20'/'40'/'60' minutes) alongside. Plausible shape (compressor-overload
+# alarm vs. automatic power throttling), but nothing in the dump confirms
+# the exact behavioral difference between the two modes or whether writing
+# 'operation' is safe on live HVAC hardware -- exposed read-only per the
+# 'don't guess' rule, same precedent as CURRENT_LIMIT above.
+ANOMALY_LOAD = Capability(
+    href='/anomalyload/vs/0',
+    poll_tier='cold',
+    entities=(
+        BinarySensorDesc(key='overload_protection_active', field='operation',
+                          icon='mdi:flash-alert',
+                          entity_category='diagnostic',
+                          value_fn=lambda v: v == 'On'),
+        SensorDesc(key='overload_protection_mode', field='mode',
+                   device_class='enum',
+                   options=('alarm', 'powersaving'),
+                   translation_key='overload_protection_mode',
+                   icon='mdi:flash-alert', entity_category='diagnostic',
+                   value_fn=lambda v: v.lower() if isinstance(v, str) else v),
+    ),
+)
+
+# Absence-detection power-saving (issue #173, TP1X_LNX-AC-RAC-01001 --
+# Lennox-branded heat pump on the RAC board family): `status` is a bare
+# On/Off boolean with no vendor prefix, the same shape already shipped
+# writable elsewhere in this file (MUTE_ONCE, AUTO_CLEAN, AIR_PURIFY,
+# DISPLAY_LIGHT) despite none of those having a live-confirmed write either
+# -- worst case a wrong token no-ops, same risk profile as that family, so
+# it's a switch rather than a sensor. `switchPowerSaveMode` picks the save
+# intensity out of its own supportedSwitchPowerSaveMode list, but *what*
+# writing it actually does to a running compressor isn't knowable from the
+# dump -- same 'don't guess' read-only treatment as CURRENT_LIMIT/
+# ANOMALY_LOAD's mode fields. A third field, `motionState`, also carries a
+# supportedMotionState list but its role (a live sensor readout vs. a
+# sensitivity setting) isn't distinguishable from the dump, so it's left
+# unmodeled entirely.
+ABSENCE_POWER_SAVING = Capability(
+    href='/mds/absencepowersaving/vs/0',
+    poll_tier='cold',
+    entities=(
+        SwitchDesc(key='absence_power_saving_active', field='status',
+                   icon='mdi:human-greeting-proximity',
+                   entity_category='config',
+                   value_fn=lambda v: v == 'On',
+                   write_fn=lambda p, rep, href=None: (
+                       ['mds', 'absencepowersaving', 'vs', '0'],
+                       {'status': 'On' if p == 'On' else 'Off'})),
+        SensorDesc(key='absence_power_saving_mode', field='switchPowerSaveMode',
+                   device_class='enum',
+                   options=('eco', 'normal', 'comfort'),
+                   translation_key='absence_power_saving_mode',
+                   icon='mdi:leaf', entity_category='diagnostic',
+                   value_fn=lambda v: v.lower() if isinstance(v, str) else v),
+    ),
+)
+
+# Avoid-direct-wind-on-motion, a sibling AI feature to ABSENCE_POWER_SAVING
+# above on the same dump: `status` is the same bare On/Off shape, promoted to
+# a switch for the same reason. `modes` (Direct/Indirect airflow out of
+# `supportedModes`) stays read-only -- same reasoning as
+# absence_power_saving_mode above.
+MOTION_DETECT_WIND = Capability(
+    href='/option/motiondetectwind/stateful/vs/0',
+    poll_tier='cold',
+    entities=(
+        SwitchDesc(key='motion_detect_wind_active', field='status',
+                   icon='mdi:motion-sensor',
+                   entity_category='config',
+                   value_fn=lambda v: v == 'On',
+                   write_fn=lambda p, rep, href=None: (
+                       ['option', 'motiondetectwind', 'stateful', 'vs', '0'],
+                       {'status': 'On' if p == 'On' else 'Off'})),
+        SensorDesc(key='motion_detect_wind_mode', field='modes',
+                   device_class='enum',
+                   options=('direct', 'indirect'),
+                   translation_key='motion_detect_wind_mode',
+                   icon='mdi:weather-windy', entity_category='diagnostic',
+                   value_fn=lambda v: v.lower() if isinstance(v, str) else v),
+    ),
+)
+
+# The climate entity already surfaces current_temperature as a card
+# attribute, but that's not enough for history graphs/automations/
+# statistics -- issue #75 asked for a standalone sensor. Same OCF-standard-
+# with-vendor-fallback shape as common.py's POWER_GENERIC/POWER_VS_FALLBACK
+# pair: both share key='current_temperature_c' so only one ever binds
+# (match_fn gates the vendor one off when the OCF resource is present).
+CURRENT_TEMPERATURE = Capability(
+    href=HREF_TEMP_CURRENT,
+    poll_tier='warm',
+    entities=(
+        SensorDesc(key='current_temperature_c', field='temperature',
+                   device_class='temperature', state_class='measurement',
+                   unit_fn=lambda rep: normalize_temp_unit(rep.get('units'), '°C')),
+    ),
+)
+
+CURRENT_TEMPERATURE_VS = Capability(
+    href=HREF_TEMPS_VS,
+    poll_tier='warm',
+    match_fn=lambda rep, resources: HREF_TEMP_CURRENT not in resources,
+    entities=(
+        SensorDesc(key='current_temperature_c', rep_fn=_temps_vs_current,
+                   device_class='temperature', state_class='measurement',
+                   unit_fn=_temps_vs_unit),
+    ),
+)
+
+# Only the vendor resource's `fivepercentHumidity` (current reading, rounded
+# to the nearest 5%) has live data on the issue #75 dump -- its `humidity`
+# field, and the OCF-standard /humidity/0 resource entirely, both read a
+# stuck "0" there, so /humidity/0 stays ignored per the 'don't guess' rule
+# (see _AC_IGNORED below).
+#
+# ARTIK051 boards (issue #136) have no fivepercentHumidity field at all, and
+# there the plain `humidity` field is not stuck: it carries a real reading
+# (51%, matching the same unit's cloud integration at that moment) for as long
+# as the Air monitoring option is on, which the unit itself switches back off
+# after roughly a minute -- so most dumps catch it at 0. Hence _humidity's
+# fallback, and hence 0 reading as "not measuring" rather than 0%: on both
+# board generations a zero here means no measurement, never dry air.
+# /humidity/0 stayed 0 throughout that same observation too.
+HUMIDITY = Capability(
+    href='/humidity/vs/0',
+    poll_tier='warm',
+    entities=(
+        SensorDesc(key='humidity', rep_fn=_humidity,
+                   device_class='humidity', state_class='measurement', unit='%'),
+    ),
+)
+
+# /sensors/vs/0 items[] carry live air-quality readings. Removed from
+# _AC_IGNORED below so AIR_QUALITY is the sole cap on the href. CleanLevel is
+# corroborated as numeric by a top-level x.com.samsung.da.cleanLevel scalar
+# (tp1x_da_ac_rac_01011 reports both as '1'), so it's a measurement; the others
+# are 1- or 2-element arrays with no corroborating scalar, so they stay string
+# diagnostics (see _sensor_item_value for the 2-element ambiguity and why only
+# v[0] is taken). No unit is advertised on the resource, so no device_class.
+#
+# exists_fn (_has_sensor_type) only proves the item *type* is listed, not
+# that the unit actually carries that sensor: issue #166 (ARxxTXFCAWKNEU,
+# board ARTIK051_PRAC_20K) reports all five item types on both its units,
+# values permanently '0'/['0','0'] -- yet the reporter confirmed none apply
+# to their model. A tighter existence gate was tried (requiring the
+# corroborating cleanLevel scalar above) but doesn't hold up as a general
+# rule -- see _has_sensor_type's docstring -- and risks silently dropping
+# real readings on hardware that reports them without that scalar. So these
+# stay bound whenever the type is listed, same as before #166, and disabled
+# by default instead (same precedent as fridge.rack_count /
+# cooktop.paired_hood_model / this file's own tropical_night_mode): units
+# that do have the sensor can enable it themselves.
+AIR_QUALITY = Capability(
+    href='/sensors/vs/0',
+    poll_tier='cold',
+    entities=(
+        SensorDesc(key='clean_level', field='x.com.samsung.da.items',
+                   icon='mdi:broom', entity_category='diagnostic',
+                   state_class='measurement',
+                   exists_fn=_has_sensor_type('CleanLevel'),
+                   enabled_default=False,
+                   value_fn=lambda items: _int(_sensor_item_value(items, 'CleanLevel'))),
+        *tuple(
+            SensorDesc(key=key, field='x.com.samsung.da.items',
+                       icon=icon, entity_category='diagnostic',
+                       exists_fn=_has_sensor_type(type_),
+                       enabled_default=False,
+                       value_fn=lambda items, t=type_: _sensor_item_value(items, t))
+            for key, icon, type_ in (
+                ('odor', 'mdi:weather-windy', 'Odor'),
+                ('dust', 'mdi:cloud', 'Dust'),
+                ('fine_dust', 'mdi:cloud-outline', 'FineDust'),
+                ('super_fine_dust', 'mdi:weather-fog', 'SuperFineDust'),
+            )
+        ),
+    ),
+)
+
+
 # ---------------------------------------------------------------------------
 # AC-scoped coverage: the CLIMATE_CONSUMED_HREFS above (read by the climate
 # entity) plus vendor duplicates / all-zero-ambiguous / plumbing resources.
@@ -218,13 +902,18 @@ CURRENT_LIMIT = Capability(
 # of waiting on the summary sweep.
 # ---------------------------------------------------------------------------
 _AC_IGNORED = [
-    # 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',
+    # Stuck at "0" on every dump seen -- HUMIDITY above reads the vendor
+    # resource's usable fivepercentHumidity field instead; this OCF-standard
+    # one has no corresponding live value confirmed yet.
     '/humidity/0',
-    '/humidity/vs/0',
     # Presence-personalization plumbing (empty item list here).
     '/personality/presence/vs/0',
+    # OCF-standard mirror of /airflow/vs/0 ({speed, direction} vs
+    # {speedLevel, direction}, identical values). The climate entity reads and
+    # writes the vendor form, which is the one confirmed on hardware here --
+    # note that air_purifier.py found the opposite ordering on its family, so
+    # neither form is reliable sight-unseen and this one stays unmodeled.
+    '/airflow/0',
     # --- TP1X/TP2X-class housekeeping / opaque blobs. These carry no
     # user-actionable state or no documented write contract, so per the
     # 'don't guess' rule they are ignored rather than modeled.
@@ -240,19 +929,52 @@ _AC_IGNORED = [
     '/mds/absencemonitoring/vs/0', # motion-detection sensor plumbing (empty here)
     '/mds/absencestate/vs/0',      # motion-detection state (empty here)
     '/remotedatacontrol/vs/0',     # remote data-control session status
+    '/remotedeviceinfo/vs/0',      # remote paired-device id list (empty didList here)
     '/remotetemperature/vs/0',     # external temp-sensor feed (unset on this unit)
+    # Manual airflow-step position (supportedModes Off/80/60/40/Power).
+    # Overlaps the /wind/direction swing control already on the climate card,
+    # and the meaning of the numeric steps vs. 'Power' isn't documented in the
+    # dump -- ignored per the 'don't guess' rule rather than modeled as a
+    # select whose write could confuse live HVAC hardware.
+    '/stepcontrol/vs/0',
     '/reserverulesets/vs/0',       # opaque hex-encoded schedule reservation blob
     '/welcome/temperature/vs/0',   # welcome-cooling plumbing
-    # System-AC-only (multi-indoor-unit commercial installs, e.g.
+    # System-AC-only (multi-indoor-subdevice commercial installs, e.g.
     # A-CAWW-TP2-20-COMMON, issue #52): opaque hex-encoded installation
-    # topology -- indoor/outdoor unit pairing, per-unit serials, MCU info.
-    # Commissioning-time plumbing, not user-actionable appliance state.
+    # topology -- indoor/outdoor unit pairing, per-subdevice serials, MCU
+    # info. Commissioning-time plumbing, not user-actionable appliance state.
     '/sac/installationinfo/vs/0',
+    # Wind-Free 2-in-1 systems (one outdoor unit driving a floor-standing
+    # *and* a wall-mounted indoor subdevice over one shared local IP, e.g.
+    # TP2X_FAC_BORA_21K, issues #150/#153): an opaque paired-subdevice id
+    # list, same "remote device ids, not user-actionable locally" role as
+    # /remotedeviceinfo/vs/0 above -- true whenever this field is redacted
+    # (the shipped airconditioner_fac_bora fixture) or absent. When it does
+    # carry a real id (issue #177's airconditioner_fac_bora_2in1 fixture),
+    # registry/subdevices.py's enumerate_subdevices reads this same
+    # subdeviceIdList to reach the second indoor subdevice over this same
+    # connection instead -- see that module's Pattern B.
+    '/subdevices/vs/0',
+    # Undocumented single int (runningMode: 0 on every dump seen), no
+    # supported-values list to interpret it against -- 'don't guess'.
+    '/runn/vs/0',
+    # 2-in-1/multi-indoor-subdevice systems (issue #177, the reporter's
+    # ARTIK051_DONGLE_FAC_18K): x.com.samsung.da.numofsubdevice, a plain
+    # corroborating count of indoor subdevices on this connection. Confirmed
+    # read-only (a write attempt returned CoAP 4.00). Absent from
+    # /device/0's batch entirely -- registry.subdevices.enumerate_subdevices
+    # fetches it with its own RETRIEVE and folds it into the resources dict
+    # for diagnostics, which is why it needs an entry here rather than
+    # surfacing as an unbound-href gap on every board that has it.
+    '/multidevice/vs/0',
 ]
 
 # Built as bare no-entity caps; folded into the AC registry (not global).
+# HREF_TEMP_CURRENT and HREF_TEMPS_VS are excluded here -- CURRENT_TEMPERATURE
+# / CURRENT_TEMPERATURE_VS above already cover those two with real entities.
 COVERAGE = [
     Capability(href=h, poll_tier='warm') for h in CLIMATE_CONSUMED_HREFS
+    if h not in (HREF_TEMP_CURRENT, HREF_TEMPS_VS)
 ] + [
     Capability(href=h) for h in _AC_IGNORED
 ]

custom_components/localthings/registry/capabilities/common.py

@@ -10,6 +10,9 @@ against live device dumps:
   /water/consumption/vs/0   -> x.com.samsung.da.cumulativeWater
   /filter/waterfilter/vs/0  -> x.com.samsung.da.filterUsage / filterStatus
 """
+from datetime import datetime, timezone
+
+from ..batch import is_stub_rep
 from ..capability import Capability
 from ..entities import (
     BinarySensorDesc, ButtonDesc, SelectDesc, SensorDesc, SwitchDesc,
@@ -40,6 +43,35 @@ def wh_to_kwh(v):
     return round(n / 1000.0, 2) if n is not None else None
 
 
+def parse_iso_utc(raw):
+    """ISO datetime defaulting to UTC when the string carries no timezone
+    of its own (this integration's convention for other bare ISO datetime
+    fields -- see washer.py's drum-clean-log comment). A few boards do
+    ship a 'Z'/offset suffix (fromisoformat parses that natively since
+    Python 3.11) -- only fill in UTC when parsing left the result naive,
+    rather than unconditionally overwriting whatever offset was parsed."""
+    if not raw:
+        return None
+    try:
+        dt = datetime.fromisoformat(raw)
+    except ValueError:
+        return None
+    return dt if dt.tzinfo is not None else dt.replace(tzinfo=timezone.utc)
+
+
+def filter_usage_percent(rep):
+    """Filter usage as a percentage of rated capacity. Several families
+    (AC, air purifier) report `filterUsage` as a raw count in
+    `filterCapacityUnit` (Hours, 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 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,
@@ -59,9 +91,35 @@ def _ml_to_l(v):
 
 
 def _active_alarm_codes(items):
+    """Join active alarm codes; skip retained rows Samsung leaves as Deleted,
+    and any code ending in '_OFF'.
+
+    Laundry boards keep a Deleted ErrorCode row in /alarms/vs/0 after the
+    condition clears (see WD7000B diagnostics). Surface only live alarms so
+    HA doesn't stick on a stale ErrorCode.
+
+    Samsung pre-populates this array with one row per alarm *type* the board
+    supports, each carrying its own '<Name>_OFF' placeholder code when that
+    alarm isn't firing -- confirmed across independent device families
+    (ErrorCode_OFF, FilterAlarm_OFF, OV_E_OFF, CT_E_OFF, WaterTankFull_OFF,
+    AC_V_0002_OFF all appear in fixtures with no corresponding active
+    condition). An alarm that's actually firing instead reports a plain,
+    unsuffixed code (FilterAlarm, DoorA_Opened, SNSF_Reached) -- issue #166's
+    AC dump has both a FilterAlarm_OFF placeholder and shows what a live
+    filter alert looks like: code 'FilterAlarm' (no suffix), state
+    'Created'. Range-hood previously special-cased only the literal
+    'ErrorCode_OFF' string in its own stricter helper; this generalizes
+    the same rule to the whole '_OFF' suffix convention.
+    """
     if not items or not isinstance(items, list):
         return 'none'
-    codes = [i.get('x.com.samsung.da.code') for i in items if i.get('x.com.samsung.da.code')]
+    codes = [
+        i.get('x.com.samsung.da.code')
+        for i in items
+        if i.get('x.com.samsung.da.code')
+        and str(i.get('x.com.samsung.da.state', '')).lower() != 'deleted'
+        and not str(i.get('x.com.samsung.da.code', '')).lower().endswith('_off')
+    ]
     return ', '.join(codes) if codes else 'none'
 
 
@@ -92,6 +150,80 @@ def merge_options_field(cached, new_tokens):
     return merged
 
 
+def merge_items_field(cached, new_items):
+    """Merge a partial x.com.samsung.da.items[]-style write (matched by
+    x.com.samsung.da.id) into a cached items array -- the read-side
+    counterpart of merge_options_field above, for the items[] shape instead
+    of the packed options[] shape.
+
+    Confirmed on hardware that a write only needs to carry the array item
+    with the changed id plus the field(s) being changed; the device merges
+    the rest itself (same fact as the options[] case, different array --
+    see airconditioner._climate_write's vendor temperature write). Fields
+    within the matched item are merged, not replaced outright, so a
+    setpoint-only write doesn't wipe current/minimum/maximum/unit from the
+    optimistic cache entry for the settle window. An id with no match in
+    `cached` is appended."""
+    merged = [dict(i) if isinstance(i, dict) else i for i in (cached or [])]
+    for new_item in new_items or ():
+        if not isinstance(new_item, dict):
+            continue
+        item_id = new_item.get('x.com.samsung.da.id')
+        for i, existing in enumerate(merged):
+            if isinstance(existing, dict) and existing.get('x.com.samsung.da.id') == item_id:
+                merged[i] = {**existing, **new_item}
+                break
+        else:
+            merged.append(new_item)
+    return merged
+
+
+# /wm/setinfo/vs/0 -- laundry-family firmware capability flags. Present on
+# washers, dryers, and dishwashers; absent on fridge/oven/AC. Static for the
+# life of a given board, so reading them from the /device/0 seed (no dedicated
+# poll_tier) is enough.
+_SETINFO_HREF = '/wm/setinfo/vs/0'
+_POWER_ON_OFF_FIELD = 'x.com.samsung.da.isModelSettingPowerOnOff'
+_WITHOUT_SC_FIELD = 'x.com.samsung.da.isModelSettingWithoutSC'
+
+
+def model_allows_power_on_off(resources: dict) -> bool:
+    """True unless firmware explicitly declares remote power on/off unsupported.
+
+    `/wm/setinfo/vs/0`.`isModelSettingPowerOnOff` is `"false"` on many laundry
+    boards (washers/dryers): `/power/0` and `/power/vs/0` still report state,
+    but CoAP writes are ignored. Absent setinfo (non-laundry families) keeps
+    the writable switch -- current behavior.
+    """
+    setinfo = resources.get(_SETINFO_HREF)
+    if setinfo is None:
+        return True
+    flag = setinfo.get(_POWER_ON_OFF_FIELD)
+    if flag is None:
+        return True
+    return str(flag).lower() != 'false'
+
+
+def model_setting_without_sc(resources: dict) -> bool:
+    """True when firmware declares settings writable without Smart Control.
+
+    `/wm/setinfo/vs/0`.`isModelSettingWithoutSC` is `"true"` on washers/dryers
+    that accept temperature/spin/cycle-option writes while remote control is
+    off. Cycle start/pause/stop still need Smart Control on those boards --
+    the flag name is settings-specific, not a blanket remote-control bypass.
+    """
+    setinfo = resources.get(_SETINFO_HREF) or {}
+    return str(setinfo.get(_WITHOUT_SC_FIELD, '')).lower() == 'true'
+
+
+def _power_switch_exists(rep, resources):
+    return model_allows_power_on_off(resources)
+
+
+def _power_sensor_exists(rep, resources):
+    return not model_allows_power_on_off(resources)
+
+
 def sensor_item_value(items, sensor_type, index=0):
     """Pull one reading out of a `/sensors/vs/0`-style items[] list -- each
     item is `{type, value: [...]}`; `index` picks which slot of a possibly
@@ -127,25 +259,42 @@ def sensor_item_value(items, sensor_type, index=0):
 
 POWER_GENERIC = Capability(
     href='/power/0',
+    # Neither href of this pair carried a poll_tier before (issue #56's
+    # follow-up), so power state only ever refreshed on the once-per-30s
+    # summary poll instead of the subscribe/subpoll cadence 'warm' and 'hot'
+    # hrefs get -- the same "signal drives real-time state, but sat in the
+    # slow default tier" gap as REMOTE_CONTROL_GENERIC/VS_FALLBACK above.
+    poll_tier='warm',
     entities=(
+        # Writable when firmware allows remote power; otherwise a read-only
+        # binary_sensor with the same key keeps HA state without a dead switch.
         SwitchDesc(key='power_switch', field='value',
-                   name='Power',
                    value_fn=lambda v: bool(v),
+                   exists_fn=_power_switch_exists,
                    write_fn=lambda p, rep, href=None: (
                        ['power', '0'], {'value': p == 'On'})),
+        BinarySensorDesc(key='power_switch', field='value',
+                         device_class='power',
+                         value_fn=lambda v: bool(v),
+                         exists_fn=_power_sensor_exists),
     ),
 )
 
 POWER_VS_FALLBACK = Capability(
     href='/power/vs/0',
     match_fn=lambda rep, resources: '/power/0' not in resources,
+    poll_tier='warm',
     entities=(
         SwitchDesc(key='power_switch', field='x.com.samsung.da.power',
-                   name='Power',
                    value_fn=lambda v: v == 'On',
+                   exists_fn=_power_switch_exists,
                    write_fn=lambda p, rep, href=None: (
                        ['power', 'vs', '0'],
                        {'x.com.samsung.da.power': 'On' if p == 'On' else 'Off'})),
+        BinarySensorDesc(key='power_switch', field='x.com.samsung.da.power',
+                         device_class='power',
+                         value_fn=lambda v: v == 'On',
+                         exists_fn=_power_sensor_exists),
     ),
 )
 
@@ -153,7 +302,7 @@ KIDS_LOCK_GENERIC = Capability(
     href='/kidslock/0',
     entities=(
         SwitchDesc(key='child_lock', field='value',
-                   name='Child lock', device_class='lock',
+                   device_class='lock',
                    value_fn=lambda v: bool(v),
                    write_fn=lambda p, rep, href=None: (
                        ['kidslock', '0'], {'value': p == 'On'})),
@@ -165,7 +314,7 @@ KIDS_LOCK_VS_FALLBACK = Capability(
     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',
+                   device_class='lock',
                    value_fn=lambda v: v != 'Ready',
                    write_fn=lambda p, rep, href=None: (
                        ['kidslock', 'vs', '0'],
@@ -194,12 +343,26 @@ def remote_control_enabled(resources: dict) -> bool:
     return True
 
 
+def remote_control_required_for_write(resources: dict, bound_href: str) -> bool:
+    """Whether a write to bound_href should be gated on Smart Control.
+
+    When isModelSettingWithoutSC is true, laundry firmware accepts settings
+    writes (wash temp, spin, course options, buzzer, ...) with remote
+    control off, but cycle start/pause/stop on /operational/state still
+    need Smart Control. Absent that flag, keep the historical blanket gate.
+    """
+    if not model_setting_without_sc(resources):
+        return True
+    href = bound_href or ''
+    return href.startswith('/operational/state')
+
+
 REMOTE_CONTROL_GENERIC = Capability(
     href='/remotectrl/0',
     poll_tier='warm',
     entities=(
         BinarySensorDesc(key='remote_control', field='value',
-                         name='Smart Control', device_class='connectivity',
+                         device_class='connectivity',
                          value_fn=lambda v: bool(v)),
     ),
 )
@@ -211,7 +374,7 @@ REMOTE_CONTROL_VS_FALLBACK = Capability(
     entities=(
         BinarySensorDesc(key='remote_control',
                          field='x.com.samsung.da.remoteControlEnabled',
-                         name='Smart Control', device_class='connectivity',
+                         device_class='connectivity',
                          value_fn=lambda v: str(v).lower() == 'true'),
     ),
 )
@@ -221,7 +384,7 @@ ALARMS = Capability(
     poll_tier='hot',
     entities=(
         SensorDesc(key='alarm_code', field='x.com.samsung.da.items',
-                   name='Alarm code', icon='mdi:alert',
+                   icon='mdi:alert',
                    entity_category='diagnostic', value_fn=_active_alarm_codes),
     ),
 )
@@ -239,53 +402,56 @@ _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):
+        # `is_stub_rep(rep)` keeps the 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.
+        # entity when /device/0 returns a not-yet-fetched stub. A genuinely
+        # empty {} rep is NOT a stub -- it's the device's confirmed (if empty)
+        # answer, so it falls through to the normal field/sentinel checks like
+        # any populated rep. 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',
+                   device_class='power', state_class='measurement',
                    unit='W', value_fn=clamp_power,
-                   exists_fn=lambda rep, resources: not rep or (
+                   exists_fn=lambda rep, resources: is_stub_rep(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',
+                   device_class='energy',
                    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)),
+                       is_stub_rep(rep) or 'x.com.samsung.da.cumulativePower' in rep)),
         # cumulativeConsumption is a second, independently-varying running
         # total alongside cumulativePower -- some fridges (issue #26) report
-        # both. Self-gates off where only cumulativePower is present. `not
-        # rep or` keeps the same empty-{} stub carve-out as power_watts/
+        # both. Self-gates off where only cumulativePower is present. The
+        # `is_stub_rep(rep) or` keeps the same stub carve-out as power_watts/
         # energy_kwh above -- without it, an exists_fn permanently drops the
         # entity if setup happens to land on a not-yet-fetched stub.
         SensorDesc(key='power_energy_kwh', field='x.com.samsung.da.cumulativeConsumption',
-                   name='Power energy', device_class='energy',
+                   device_class='energy',
                    state_class='total_increasing', unit='kWh', value_fn=wh_to_kwh,
                    exists_fn=lambda rep, resources: (
-                       not rep or 'x.com.samsung.da.cumulativeConsumption' in rep)),
+                       is_stub_rep(rep) or 'x.com.samsung.da.cumulativeConsumption' in rep)),
         # AI Energy Mode's lifetime savings estimate vs. an unoptimized
         # baseline -- present on some models (e.g. TP1X_REF_21K, issue #21/
         # #27) and absent on others (issue #20/#26), unlike cumulativePower.
         SensorDesc(key='energy_saved_kwh', field='x.com.samsung.da.cumulativeSavedPower',
-                   name='Energy saved', device_class='energy',
+                   device_class='energy',
                    state_class='total_increasing', unit='kWh', value_fn=wh_to_kwh,
                    exists_fn=lambda rep, resources: (
-                       not rep or 'x.com.samsung.da.cumulativeSavedPower' in rep)),
+                       is_stub_rep(rep) or 'x.com.samsung.da.cumulativeSavedPower' in rep)),
         # Monthly billing-cycle totals -- the completed prior month and the
         # in-progress current month. Not ever-increasing (each resets at
         # month boundary), so no state_class.
         SensorDesc(key='energy_last_month_kwh', field='x.com.samsung.da.monthlyConsumption',
-                   name='Energy (last month)', device_class='energy',
+                   device_class='energy',
                    unit='kWh', value_fn=wh_to_kwh,
                    exists_fn=lambda rep, resources: (
-                       not rep or 'x.com.samsung.da.monthlyConsumption' in rep)),
+                       is_stub_rep(rep) or 'x.com.samsung.da.monthlyConsumption' in rep)),
         SensorDesc(key='energy_this_month_kwh', field='x.com.samsung.da.thismonthlyConsumption',
-                   name='Energy (this month)', device_class='energy',
+                   device_class='energy',
                    unit='kWh', value_fn=wh_to_kwh,
                    exists_fn=lambda rep, resources: (
-                       not rep or 'x.com.samsung.da.thismonthlyConsumption' in rep)),
+                       is_stub_rep(rep) or 'x.com.samsung.da.thismonthlyConsumption' in rep)),
     ),
 )
 
@@ -293,7 +459,7 @@ WATER_METER = Capability(
     href='/water/consumption/vs/0',
     entities=(
         SensorDesc(key='water_liters', field='x.com.samsung.da.cumulativeWater',
-                   name='Water consumption', device_class='water',
+                   device_class='water',
                    state_class='total_increasing', unit='L', icon='mdi:water',
                    value_fn=_ml_to_l),
     ),
@@ -304,10 +470,14 @@ WATER_FILTER = Capability(
     match_fn=lambda rep, _: rep.get('x.com.samsung.da.filterStatus', '').lower() != 'notused',
     entities=(
         SensorDesc(key='filter_usage', field='x.com.samsung.da.filterUsage',
-                   name='Filter usage', unit='%', state_class='measurement',
+                   unit='%', state_class='measurement',
                    icon='mdi:filter'),
         SensorDesc(key='filter_status', field='x.com.samsung.da.filterStatus',
-                   name='Filter status', icon='mdi:filter-check'),
+                   icon='mdi:filter-check',
+                   device_class='enum', options=('normal', 'wash', 'replace'),
+                   value_fn=lambda value: (
+                       value.lower() if isinstance(value, str) else value
+                   )),
     ),
 )
 
@@ -324,7 +494,7 @@ WATER_FILTER = Capability(
 #
 # No translation_key: aiLevel's values are plain digit strings, and
 # select.py's _display() already renders an untranslated numeric string
-# as-is -- there's nothing a strings.json entry adds that's worth maintaining
+# as-is -- there's nothing a catalog entry adds that's worth maintaining
 # against an unknown, growing number of future levels.
 
 
@@ -354,7 +524,7 @@ AI_ENERGY_LEVEL = Capability(
     href='/energy/ailevel/vs/0',
     poll_tier='cold',
     entities=(
-        # No `not rep` stub carve-out on either side, unlike most exists_fn
+        # No is_stub_rep carve-out on either side, unlike most exists_fn
         # gates in this file -- entity creation only ever runs once, against
         # whichever snapshot happens to be current the moment platforms are
         # set up (see entity._is_included / __init__.py's
@@ -371,14 +541,14 @@ AI_ENERGY_LEVEL = Capability(
         # cold-tier href, the same reload already required to fix which
         # platform got picked in that case.
         SwitchDesc(key='ai_energy_level', field='aiLevel',
-                   name='AI energy level', icon='mdi:leaf',
+                   icon='mdi:leaf',
                    entity_category='config',
                    value_fn=lambda v: v != '0',
                    exists_fn=lambda rep, resources: (
                        len(_ai_energy_supported_levels(rep)) == 1),
                    write_fn=_ai_energy_level_switch_write),
         SelectDesc(key='ai_energy_level', field='aiLevel',
-                   name='AI energy level', icon='mdi:leaf',
+                   icon='mdi:leaf',
                    entity_category='config',
                    options=_ai_energy_level_options,
                    exists_fn=lambda rep, resources: (
@@ -394,7 +564,6 @@ FIRMWARE_UPDATE = Capability(
         BinarySensorDesc(
             key='firmware_update',
             field='x.com.samsung.da.newVersionAvailable',
-            name='Firmware update available',
             device_class='update',
             entity_category='diagnostic',
             value_fn=lambda v: str(v).lower() == 'true' if v is not None else None,
@@ -407,21 +576,21 @@ SELF_CHECK = Capability(
     poll_tier='cold',
     entities=(
         SensorDesc(key='selfcheck_status', field='x.com.samsung.da.status',
-                   name='Self-check status', icon='mdi:stethoscope',
+                   icon='mdi:stethoscope',
                    entity_category='diagnostic'),
         SensorDesc(key='selfcheck_result', field='x.com.samsung.da.result',
-                   name='Self-check result', icon='mdi:clipboard-check-outline',
+                   icon='mdi:clipboard-check-outline',
                    entity_category='diagnostic'),
         # List of error codes from the last self-check; joined for display.
         # Not every fridge reports the field, hence the exists_fn.
         SensorDesc(key='selfcheck_error', field='x.com.samsung.da.error',
-                   name='Self-check error', icon='mdi:alert-circle-outline',
+                   icon='mdi:alert-circle-outline',
                    entity_category='diagnostic',
                    exists_fn=lambda rep, resources: (
-                       not rep or 'x.com.samsung.da.error' in rep),
+                       is_stub_rep(rep) or 'x.com.samsung.da.error' in rep),
                    value_fn=lambda v: (', '.join(v) if v else None) if isinstance(v, list) else v),
-        ButtonDesc(key='selfcheck_start', field='', name='Start self-check',
-                   payload='Start', icon='mdi:play-circle-outline',
+        ButtonDesc(key='selfcheck_start', field='', payload='Start',
+                   icon='mdi:play-circle-outline',
                    entity_category='diagnostic',
                    write_fn=lambda p, rep, href=None: (
                        ['selfcheck', 'vs', '0'], {'x.com.samsung.da.status': p})),
@@ -442,15 +611,22 @@ SELF_CHECK = Capability(
 # level: 2 of 6 families confirmed, blanket-added everywhere else).
 #
 # POWER is kept separate -- airconditioner is the one family that opts out
-# of it. Canonical reason (see by_type/airconditioner.py and its test for
-# pointers back here, not restatements): AC's climate entity already owns
-# /power/0 and /power/vs/0 via bare, no-entity Capability objects
-# (airconditioner.COVERAGE), and a second, real POWER_GENERIC/
+# of it entirely. Canonical reason (see by_type/airconditioner.py and its
+# test for pointers back here, not restatements): AC's climate entity
+# already owns /power/0 and /power/vs/0 via bare, no-entity Capability
+# objects (airconditioner.COVERAGE), and a second, real POWER_GENERIC/
 # POWER_VS_FALLBACK cap on the same href would make _build() raise (a href
 # with >1 cap must have every cap discriminated by rt_filter/match_fn, and
 # the bare COVERAGE cap has neither). Kids-lock/remote-control don't have
 # this conflict -- no AC dump has ever reported those hrefs -- so they stay
 # in UNIVERSAL.
+#
+# Airconditioner also partially opts out of UNIVERSAL itself, not just
+# POWER: issue #193 needs ENERGY_METER's cumulativePower scale to differ by
+# board generation, so by_type/airconditioner.py excludes just that one
+# member (`*[c for c in common.UNIVERSAL if c is not common.ENERGY_METER]`)
+# and substitutes airconditioner.ENERGY_METER_GENERIC/ENERGY_METER_LEGACY in
+# its place -- every other registry still unpacks UNIVERSAL wholesale.
 # ---------------------------------------------------------------------------
 
 UNIVERSAL = (

custom_components/localthings/registry/capabilities/cooktop.py

@@ -9,6 +9,7 @@ cooktop must not be remotely ignited by an automation.
 
 import re
 
+from ..batch import is_stub_rep
 from ..capability import Capability
 from ..entities import BinarySensorDesc, SensorDesc
 
@@ -61,7 +62,6 @@ COOKTOP_POWER = Capability(
         BinarySensorDesc(
             key='power_state',
             field='x.com.samsung.da.power',
-            name='Power state',
             device_class='power',
             icon='mdi:stove',
             value_fn=lambda value: str(value).lower() == 'on',
@@ -83,7 +83,6 @@ COOKTOP_MODE = Capability(
         BinarySensorDesc(
             key='any_burner_active',
             field='x.com.samsung.da.options',
-            name='Any burner active',
             device_class='running',
             icon='mdi:fire',
             value_fn=_any_burner_active,
@@ -92,13 +91,14 @@ COOKTOP_MODE = Capability(
             SensorDesc(
                 key=f'burner_{slot}_state',
                 field='x.com.samsung.da.options',
-                name=f'Burner {slot} state',
+                translation_key='burner_state',
+                translation_placeholders={'number': str(slot)},
                 icon='mdi:gas-burner',
                 value_fn=lambda options, slot=slot: _option_value(
                     options, f'OperationState{slot}'
                 ),
                 exists_fn=lambda rep, resources, slot=slot: (
-                    not rep or _option_value(
+                    is_stub_rep(rep) or _option_value(
                         rep.get('x.com.samsung.da.options'),
                         f'OperationState{slot}',
                     ) is not None
@@ -109,14 +109,12 @@ COOKTOP_MODE = Capability(
         SensorDesc(
             key='main_timer_state',
             field='x.com.samsung.da.options',
-            name='Timer state',
             icon='mdi:timer-outline',
             value_fn=lambda options: _option_value(options, 'MainTimerState'),
         ),
         SensorDesc(
             key='main_timer_current',
             field='x.com.samsung.da.options',
-            name='Timer current value',
             icon='mdi:timer-sand',
             enabled_default=False,
             value_fn=lambda options: _int_or_none(
@@ -134,7 +132,6 @@ COOKTOP_CONNECTED = Capability(
         BinarySensorDesc(
             key='cloud_connected',
             field='x.com.samsung.da.connected',
-            name='Cloud connected',
             device_class='connectivity',
             entity_category='diagnostic',
             value_fn=lambda value: str(value).lower() == 'on',
@@ -150,35 +147,30 @@ PAIRED_HOOD_STATUS = Capability(
         BinarySensorDesc(
             key='paired_hood_connected',
             field='connectionState',
-            name='Paired hood connected',
             device_class='connectivity',
             value_fn=lambda value: str(value).lower() == 'connected',
         ),
         BinarySensorDesc(
             key='paired_hood_power',
             field='power',
-            name='Paired hood power',
             device_class='running',
             value_fn=lambda value: str(value).lower() == 'on',
         ),
         SensorDesc(
             key='paired_hood_fan_speed',
             field='fanSpeed',
-            name='Paired hood fan speed',
             icon='mdi:fan',
             value_fn=_int_or_none,
         ),
         BinarySensorDesc(
             key='paired_hood_light',
             field='lampState',
-            name='Paired hood light',
             device_class='light',
             value_fn=lambda value: str(value).lower() == 'on',
         ),
         SensorDesc(
             key='paired_hood_model',
             field='micomModelId',
-            name='Paired hood model',
             icon='mdi:information-outline',
             entity_category='diagnostic',
             enabled_default=False,
@@ -186,7 +178,6 @@ PAIRED_HOOD_STATUS = Capability(
         SensorDesc(
             key='paired_hood_firmware',
             field='firmwareVersion',
-            name='Paired hood firmware',
             icon='mdi:chip',
             entity_category='diagnostic',
             enabled_default=False,

custom_components/localthings/registry/capabilities/dehumidifier.py

@@ -0,0 +1,85 @@
+"""Capabilities for the Samsung dehumidifier family (TP1X_DA_AC_DHM-class,
+issue #88, model AY18CG7500GED).
+
+Same DA_AC_ board family as the room-AC models in airconditioner.py (shared
+power/energy/filter/auto-clean/mute-once resource shapes), but target
+humidity -- not temperature -- is this device's primary control, and there
+is no climate composite: power, mode, and humidity are exposed as separate
+entities rather than folded into one card.
+"""
+from ..capability import Capability
+from ..entities import NumberDesc, SelectDesc, SensorDesc
+from .common import int_or_none
+
+
+def _first_mode(rep):
+    """Representative scalar for the operating-mode select. `modes` is a
+    single-element list on every dump seen so far, mirroring
+    airconditioner._first_mode's handling of the same field shape."""
+    modes = rep.get('x.com.samsung.da.modes')
+    if isinstance(modes, (list, tuple)):
+        return modes[0] if modes else None
+    return modes
+
+
+MODE = Capability(
+    href='/mode/vs/0',
+    poll_tier='warm',
+    entities=(
+        SelectDesc(key='operating_mode', rep_fn=_first_mode,
+                   icon='mdi:tune-variant',
+                   options_field='x.com.samsung.da.supportedModes',
+                   write_fn=lambda p, rep, href=None: (
+                       ['mode', 'vs', '0'], {'x.com.samsung.da.modes': [p]})),
+    ),
+)
+
+# Target humidity is this device's primary control (the issue-#88 dump's
+# equivalent of a thermostat setpoint). No min/max range field is present in
+# any dump seen so far -- native_min/native_max are deliberately left unset
+# so the number entity falls back to HA's own 0-100 default, the natural
+# bound for a percentage field, rather than a bound guessed from one unit's
+# spec sheet (see the adding-device-support skill's "never hard-code the one
+# dump's values" section). Step comes live from the device's own `increment`
+# field.
+HUMIDITY = Capability(
+    href='/humidity/vs/0',
+    poll_tier='warm',
+    entities=(
+        SensorDesc(key='humidity', field='x.com.samsung.da.humidity',
+                   device_class='humidity', unit='%', state_class='measurement',
+                   value_fn=int_or_none),
+        NumberDesc(key='target_humidity', field='x.com.samsung.da.desiredHumidity',
+                   device_class='humidity', unit='%',
+                   icon='mdi:water-percent',
+                   entity_category='config',
+                   value_fn=int_or_none,
+                   step_fn=lambda rep: int_or_none(rep.get('increment')) or 1,
+                   write_fn=lambda p, rep, href=None: (
+                       ['humidity', 'vs', '0'],
+                       {'x.com.samsung.da.desiredHumidity': str(int(round(float(p))))})),
+    ),
+)
+
+# ---------------------------------------------------------------------------
+# Dehumidifier-scoped coverage: vendor plumbing with no user-actionable state
+# or no documented write contract, following the same 'don't guess' rule as
+# airconditioner._AC_IGNORED (this is the same DA_AC_ board family). Not in
+# the global ignored.IGNORED since some of these hrefs collide with other
+# families' schemas.
+# ---------------------------------------------------------------------------
+_DHM_IGNORED = [
+    '/availablecontrolsets/vs/0',  # opaque hex-encoded control-set bitmap (id: DHM)
+    '/da/softreset/vs/0',          # soft-reset trigger plumbing
+    '/keepnormalstate/vs/0',       # internal keep-normal flag
+    '/personality/presence/vs/0',  # presence-personalization plumbing (empty item value)
+    '/reserverulesets/vs/0',       # opaque hex-encoded schedule reservation blob
+    '/sensors/vs/0',               # empty {} on this dump
+    '/welcome/humidity/vs/0',      # welcome-mode plumbing (requestId/operatingStatus, inert)
+    # Only supportedModes ([Off, Sleep]) is present -- no live "current
+    # value" field on this dump to confirm the read/write contract, so per
+    # the 'don't guess' rule this is left unmodeled rather than assumed.
+    '/mode/convenient/vs/0',
+]
+
+COVERAGE = [Capability(href=h) for h in _DHM_IGNORED]

custom_components/localthings/registry/capabilities/dishwasher.py

@@ -18,13 +18,13 @@ DISHWASHER_SETTINGS = Capability(
     href='/dishwasher/vs/0',
     entities=(
         SwitchDesc(key='sanitize', field='x.com.samsung.da.sanitize',
-                   name='Sanitize', icon='mdi:bacteria',
+                   icon='mdi:bacteria',
                    value_fn=lambda v: v == 'On',
                    write_fn=lambda p, rep, href=None: (
                        ['dishwasher', 'vs', '0'],
                        {'x.com.samsung.da.sanitize': 'On' if p == 'On' else 'Off'})),
         SelectDesc(key='heated_dry', field='x.com.samsung.da.heatedDry',
-                   name='Smart Dry', icon='mdi:heat-wave',
+                   icon='mdi:heat-wave',
                    options_field='x.com.samsung.da.supportedHeatedDry',
                    write_fn=lambda p, rep, href=None: (
                        ['dishwasher', 'vs', '0'],
@@ -45,9 +45,9 @@ CYCLE_OPTIONS = Capability(
     href='/course/vs/0',
     entities=(
         cycle_select(translation_key='dishwasher_cycle', icon='mdi:dishwasher'),
-        bool_option_switch('storm_wash', 'Storm Wash+', 'mdi:weather-lightning-rainy',
+        bool_option_switch('storm_wash', 'mdi:weather-lightning-rainy',
                             'StormWashZone'),
-        bool_option_switch('auto_release_dry', 'Auto release dry', 'mdi:door-open',
+        bool_option_switch('auto_release_dry', 'mdi:door-open',
                             'AutoDoorRelease', gate_on_presence=True),
     ),
 )
@@ -61,10 +61,10 @@ DIAGNOSIS = Capability(
     poll_tier='cold',
     entities=(
         SensorDesc(key='diagnosis_status', field='x.com.samsung.da.diagnosisStart',
-                   name='Diagnosis status', icon='mdi:stethoscope',
+                   icon='mdi:stethoscope',
                    entity_category='diagnostic'),
-        ButtonDesc(key='diagnosis_start', field='', name='Start diagnosis',
-                   payload='Start', icon='mdi:play-circle-outline',
+        ButtonDesc(key='diagnosis_start', field='', payload='Start',
+                   icon='mdi:play-circle-outline',
                    entity_category='diagnostic',
                    write_fn=lambda p, rep, href=None: (
                        ['diagnosis', 'vs', '0'], {'x.com.samsung.da.diagnosisStart': p})),
@@ -76,7 +76,7 @@ OPERATION_ORIGIN = Capability(
     poll_tier='cold',
     entities=(
         SensorDesc(key='operation_origin', field='origin',
-                   name='Last operation source', icon='mdi:remote',
+                   icon='mdi:remote',
                    entity_category='diagnostic'),
     ),
 )

custom_components/localthings/registry/capabilities/dryer.py

@@ -24,13 +24,13 @@ DRYER_SETTINGS = Capability(
     poll_tier='warm',
     entities=(
         SensorDesc(key='dry_level', field='x.com.samsung.da.dryLevel',
-                   name='Dry level', icon='mdi:water-percent'),
+                   icon='mdi:water-percent'),
         SensorDesc(key='dry_time', field='x.com.samsung.da.dryTime',
-                   name='Dry time', icon='mdi:timer'),
+                   icon='mdi:timer'),
         SensorDesc(key='dryer_type', field='x.com.samsung.da.dryerType',
-                   name='Dryer type', icon='mdi:tumble-dryer'),
+                   icon='mdi:tumble-dryer'),
         SwitchDesc(key='wrinkle_prevent', field='x.com.samsung.da.wrinklePrevent',
-                   name='Wrinkle prevent', icon='mdi:iron',
+                   icon='mdi:iron',
                    value_fn=lambda v: v == 'On',
                    write_fn=_wrinkle_write),
     ),
@@ -42,7 +42,10 @@ DRYER_SETTINGS = Capability(
 # 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
+# until named. Codes '01' Normal and '06' Time dry were confirmed on a
+# DVE50A8600V/A3 (also Table_03) by selecting each cycle on the physical
+# appliance and reading back the raw code from the entity's state (issue
+# #80). 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(
@@ -58,6 +61,6 @@ DRYER_DIAGNOSIS = Capability(
     poll_tier='warm',
     entities=(
         SensorDesc(key='diagnosis', field='x.com.samsung.da.diagnosisStart',
-                   name='Diagnosis', entity_category='diagnostic'),
+                   entity_category='diagnostic'),
     ),
 )

custom_components/localthings/registry/capabilities/fridge.py

@@ -25,7 +25,7 @@ from ..entities import (
 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,
+# ice-making-status enums below live in translations/en.json,
 # keyed by the lowercased raw device value — select.py and SensorDesc.options
 # normalize to lowercase for HA's translation lookup and map back to this
 # original casing before writing to the device.
@@ -55,26 +55,87 @@ TEMP_CURRENT_GENERIC = Capability(
     poll_tier='warm',
     entities=(
         SensorDesc(key='temperature', field='temperature',
-                   name=None, icon='mdi:thermometer',
+                   translation_key='instance_temperature',
+                   use_instance_name=True, icon='mdi:thermometer',
                    device_class='temperature', unit_fn=_temp_unit,
                    state_class='measurement'),
     ),
 )
 
-TEMP_SETPOINT_GENERIC = Capability(
+def _temp_setpoint_write(p, rep, href=None, resources=None):
+    """Write temperature — prefer vendor /temperatures/vs/0 when available,
+    fall back to direct OCF /temperature/desired/ write otherwise.
+
+    Samsung fridges expose both OCF-standard /temperature/desired/* and vendor
+    /temperatures/vs/0. On some models only the vendor path commits the change;
+    on others both work. Using the vendor path when present is always correct.
+    Item IDs follow the Samsung convention: "0" = Freezer, "1" = Fridge/Cooler.
+    """
+    if not href:
+        return None
+    if resources and '/temperatures/vs/0' in resources:
+        if '/cooler/' in href:
+            item_id = '1'
+        elif '/freezer/' in href:
+            item_id = '0'
+        else:
+            return None
+        return (
+            ['temperatures', 'vs', '0'],
+            {'x.com.samsung.da.items': [
+                {'x.com.samsung.da.id': item_id,
+                 'x.com.samsung.da.desired': str(int(round(float(p))))}
+            ]}
+        )
+    return (
+        [s for s in href.strip('/').split('/') if s],
+        {'temperature': int(round(float(p)))}
+    )
+
+
+TEMP_SETPOINT = Capability(
     href=None,
     href_prefix='/temperature/desired/',
     strip_prefix_in_key=True,
     poll_tier='warm',
     entities=(
         NumberDesc(key='setpoint', field='temperature',
-                   name=None, device_class='temperature', unit_fn=_temp_unit,
+                   translation_key='instance_setpoint',
+                   use_instance_name=True, 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: (
-                       [s for s in href.strip('/').split('/') if s],
-                       {'temperature': int(round(float(p)))}
-                   ) if href else None),
+                   write_fn=_temp_setpoint_write),
+    ),
+)
+
+# ---------------------------------------------------------------------------
+# Discrete cooler setpoint (issue #186) -- some single-door ("cooler only")
+# fridges report no /temperature/current|desired/* pair at all (this href
+# doesn't match TEMP_CURRENT_GENERIC/TEMP_SETPOINT's '/temperature/current/'
+# or '/temperature/desired/' prefixes), only this one vendor resource that
+# bundles the live desired value together with the *specific* values the
+# unit accepts. That supportedList (e.g. ['1','2','3','4','7'] on the issue
+# #186 dump) is not a contiguous range -- 5 and 6 genuinely aren't valid
+# setpoints on this model -- so a NumberDesc with a min/max/step would let a
+# user pick an unsupported value; modeled as a select reading its own live
+# options list instead, same shape as BEVERAGE_ZONE/PANTRY_ZONE above.
+# ---------------------------------------------------------------------------
+
+def _definite_cooler_write(p, rep, href=None):
+    return (['temperature', 'definite', 'cooler', 'vs', '0'],
+            {'x.com.samsung.da.definite.desired': p})
+
+
+DEFINITE_TEMPERATURE_COOLER = Capability(
+    href='/temperature/definite/cooler/vs/0',
+    poll_tier='warm',
+    entities=(
+        SelectDesc(key='cooler_temperature_setpoint',
+                   field='x.com.samsung.da.definite.desired',
+                   icon='mdi:thermometer',
+                   entity_category='config',
+                   options_field='x.com.samsung.da.definite.supportedList',
+                   write_fn=_definite_cooler_write),
     ),
 )
 
@@ -87,7 +148,7 @@ ICEMAKER_NIGHTTIME = Capability(
     poll_tier='warm',
     entities=(
         SwitchDesc(key='ice_night_mode', field='ice.night.status',
-                   name='Nighttime ice quiet mode', icon='mdi:weather-night',
+                   icon='mdi:weather-night',
                    entity_category='config',
                    value_fn=lambda v: v == 'On',
                    write_fn=lambda p, rep, href=None: (
@@ -101,8 +162,9 @@ ICEMAKER_NIGHTTIME = Capability(
 # /icemaker/status/vs/0 is kept as exact-href cap and binds first.
 # /icemaker/nighttime/vs/0 is excluded by match_fn (lacks iceMaker.state).
 #
-# Entity names are derived from x.com.samsung.da.iceMaker.name ("CUBED_ICE",
-# "ICE_BITES") via name_field, not the href's "one"/"two" segment -- these two
+# Entity names interpolate x.com.samsung.da.iceMaker.name ("CUBED_ICE",
+# "ICE_BITES") -- read via name_field, reaching the translated name as the
+# {instance_name} placeholder -- not the href's "one"/"two" segment. These two
 # ice makers are independent on/off toggles that can both be enabled at once
 # (issue #27), so they stay separate entities rather than a single ice-type
 # select, but users still want them labeled with the device's own names.
@@ -123,17 +185,18 @@ ICEMAKER_GENERIC = Capability(
     entities=(
         SensorDesc(key='making_status',
                    field='x.com.samsung.da.iceMaker.iceMakingStatus',
-                   name=None, icon='mdi:cube-outline',
+                   use_instance_name=True, icon='mdi:cube-outline',
                    device_class='enum',
                    options=('icestatus_stop', 'icestatus_run'),
                    translation_key='ice_making_status',
                    value_fn=lambda v: v.lower() if isinstance(v, str) else v),
         SwitchDesc(key='enabled', field='x.com.samsung.da.iceMaker.state',
-                   name=None, icon='mdi:cube-outline',
+                   translation_key='instance_enabled',
+                   use_instance_name=True, icon='mdi:cube-outline',
                    value_fn=lambda v: v == 'On',
                    write_fn=_icemaker_write('x.com.samsung.da.iceMaker.state')),
         SelectDesc(key='type', field='x.com.samsung.da.iceType.desired',
-                   name=None, icon='mdi:cube-outline',
+                   use_instance_name=True, icon='mdi:cube-outline',
                    translation_key='ice_type',
                    entity_category='config',
                    options_field='x.com.samsung.da.iceType.supported',
@@ -151,7 +214,7 @@ DOOR_ALERT = Capability(
     poll_tier='warm',
     entities=(
         SelectDesc(key='door_alert', field='alert.door',
-                   name='Door alarm', icon='mdi:bell-alert',
+                   icon='mdi:bell-alert',
                    translation_key='door_alert',
                    entity_category='config',
                    options_field='supportedAlert.door',
@@ -177,12 +240,12 @@ STATUS_LOCK = Capability(
     poll_tier='warm',
     entities=(
         SwitchDesc(key='auto_door_opener', field='x.com.samsung.da.ado.devicecontrol',
-                   name='Auto door opener', icon='mdi:door-open',
+                   icon='mdi:door-open',
                    entity_category='config',
                    value_fn=lambda v: v == 'On',
                    write_fn=_status_lock_write('x.com.samsung.da.ado.devicecontrol')),
         SwitchDesc(key='fridge_sound', field='x.com.samsung.da.device.sound',
-                   name='Sound', icon='mdi:volume-high',
+                   icon='mdi:volume-high',
                    entity_category='config',
                    value_fn=lambda v: v == 'On',
                    write_fn=_status_lock_write('x.com.samsung.da.device.sound')),
@@ -207,7 +270,7 @@ DEFROST_DELAY = Capability(
     poll_tier='warm',
     entities=(
         SwitchDesc(key='defrost_delay', field='x.com.samsung.da.delayDefrost',
-                   name='Defrost delay', icon='mdi:snowflake-off',
+                   icon='mdi:snowflake-off',
                    entity_category='config',
                    value_fn=lambda v: v == 'On',
                    write_fn=lambda p, rep, href=None: (
@@ -229,7 +292,7 @@ DEFROST_BLOCK_STATUS = Capability(
     poll_tier='warm',
     entities=(
         BinarySensorDesc(key='defrost_active', field='x.com.samsung.da.modes',
-                         name='Defrost active', icon='mdi:snowflake-melt',
+                         icon='mdi:snowflake-melt',
                          entity_category='diagnostic',
                          value_fn=lambda modes: bool(modes) and modes[0] == 'DEFROST_BLOCK_ON'),
     ),
@@ -252,12 +315,12 @@ REFRIGERATION = Capability(
     poll_tier='warm',
     entities=(
         SwitchDesc(key='rapid_fridge', field='x.com.samsung.da.rapidFridge',
-                   name='Rapid fridge', icon='mdi:fridge-industrial',
+                   icon='mdi:fridge-industrial',
                    entity_category='config',
                    value_fn=lambda v: v == 'On',
                    write_fn=_refrigeration_write('x.com.samsung.da.rapidFridge')),
         SwitchDesc(key='rapid_freezing', field='x.com.samsung.da.rapidFreezing',
-                   name='Rapid freezing', icon='mdi:snowflake',
+                   icon='mdi:snowflake',
                    entity_category='config',
                    value_fn=lambda v: v == 'On',
                    write_fn=_refrigeration_write('x.com.samsung.da.rapidFreezing')),
@@ -279,7 +342,7 @@ AUTOFILL = Capability(
     poll_tier='warm',
     entities=(
         SwitchDesc(key='autofill', field='x.com.samsung.da.autofill',
-                   name='Autofill pitcher', icon='mdi:cup-water',
+                   icon='mdi:cup-water',
                    entity_category='config',
                    value_fn=lambda v: v == 'On',
                    write_fn=_autofill_write),
@@ -295,7 +358,7 @@ WELCOME_LIGHTING = Capability(
     poll_tier='warm',
     entities=(
         SwitchDesc(key='welcome_lighting', field='status',
-                   name='Welcome lighting', icon='mdi:motion-sensor',
+                   icon='mdi:motion-sensor',
                    entity_category='config',
                    value_fn=lambda v: v == 'On',
                    write_fn=lambda p, rep, href=None: (
@@ -386,15 +449,15 @@ CABINET_LIGHT_ENHANCED = Capability(
     poll_tier='warm',
     entities=(
         SelectDesc(key='day_brightness', field='level.brightness.daytime',
-                   name='Cabinet brightness', icon='mdi:brightness-5',
-                   translation_key='brightness_level',
+                   icon='mdi:brightness-5',
+                   translation_key='day_brightness',
                    entity_category='config',
                    options=_NIGHT_BRIGHTNESS_OPTIONS,
                    write_fn=lambda p, rep, href=None: (
                        ['cabinet', 'light', 'enhanced', 'vs', '0'],
                        {'level.brightness.daytime': p})),
         SelectDesc(key='brightness_level', field='level.brightness.nighttime',
-                   name='Night brightness', icon='mdi:brightness-4',
+                   icon='mdi:brightness-4',
                    translation_key='brightness_level',
                    entity_category='config',
                    options=_NIGHT_BRIGHTNESS_OPTIONS,
@@ -402,12 +465,12 @@ CABINET_LIGHT_ENHANCED = Capability(
                        ['cabinet', 'light', 'enhanced', 'vs', '0'],
                        {'level.brightness.nighttime': p})),
         TimeDesc(key='night_start', field='',
-                 name='Night light start', icon='mdi:clock-start',
+                 icon='mdi:clock-start',
                  entity_category='config',
                  rep_fn=_night_start_value,
                  write_fn=_night_start_write),
         TimeDesc(key='night_end', field='',
-                 name='Night light end', icon='mdi:clock-end',
+                 icon='mdi:clock-end',
                  entity_category='config',
                  rep_fn=_night_end_value,
                  write_fn=_night_end_write),
@@ -431,11 +494,11 @@ CABINET_LIGHT = Capability(
     poll_tier='warm',
     entities=(
         SwitchDesc(key='cabinet_light_switch', field='x.com.samsung.da.lightControl',
-                   name='Cabinet light', icon='mdi:fridge-outline',
+                   icon='mdi:fridge-outline',
                    value_fn=lambda v: v == 'On',
                    write_fn=_cabinet_light_write),
         SwitchDesc(key='cabinet_light_dim', field='light.dimming.status',
-                   name='Brighten gradually', icon='mdi:brightness-auto',
+                   icon='mdi:brightness-auto',
                    entity_category='config',
                    value_fn=lambda v: v == 'On',
                    write_fn=lambda p, rep, href=None: (
@@ -459,7 +522,7 @@ SABBATH = Capability(
     poll_tier='warm',
     entities=(
         SwitchDesc(key='sabbath_mode', field='x.com.samsung.da.sabbathMode',
-                   name='Sabbath mode', icon='mdi:hands-pray',
+                   icon='mdi:hands-pray',
                    entity_category='config',
                    value_fn=lambda v: v == 'On',
                    write_fn=_sabbath_write),
@@ -479,7 +542,7 @@ BEVERAGE_ZONE = Capability(
     poll_tier='warm',
     entities=(
         SelectDesc(key='beverage_zone_mode', field='roomDesiredMode',
-                   name='Beverage zone mode', icon='mdi:glass-wine',
+                   icon='mdi:glass-wine',
                    translation_key='beverage_zone_mode',
                    entity_category='config',
                    options_field='roomSupportedModes',
@@ -507,7 +570,7 @@ PANTRY_ZONE = Capability(
     poll_tier='warm',
     entities=(
         SelectDesc(key='pantry_zone_mode', field='x.com.samsung.da.mode',
-                   name='Pantry zone mode', icon='mdi:glass-wine',
+                   icon='mdi:glass-wine',
                    translation_key='pantry_zone_mode',
                    entity_category='config',
                    options_field='x.com.samsung.da.supportedOptions',
@@ -554,12 +617,21 @@ FLEX_ZONE = Capability(
     poll_tier='warm',
     entities=(
         SelectDesc(key='flex_zone_mode',
-                   name='Flex zone mode', icon='mdi:thermostat',
+                   icon='mdi:thermostat',
                    translation_key='flex_zone_mode',
                    entity_category='config',
                    options_field='x.com.samsung.da.supportedOptions',
-                   exists_fn=lambda rep, resources: bool(
-                       rep.get('x.com.samsung.da.supportedOptions')),
+                   # A nonempty supportedOptions alone isn't sufficient: the
+                   # kimchi-refrigerator family (issue #26) also populates
+                   # /mode/vs/0's modes/supportedOptions with real data, but
+                   # its tokens carry a "_[n]:[n]" parameter suffix on
+                   # supportedOptions that modes never repeats, so no item
+                   # ever overlaps -- the RF9000/Bespoke-class overlap this
+                   # capability was built for never happens there. Require an
+                   # actual resolvable value instead of just a populated
+                   # list, so this stays absent on that family rather than
+                   # showing a select permanently stuck on "unknown".
+                   exists_fn=lambda rep, resources: _flex_zone_current(rep) is not None,
                    rep_fn=_flex_zone_current,
                    write_fn=_flex_zone_write),
     ),
@@ -569,14 +641,126 @@ FLEX_ZONE = Capability(
 # Generic door pattern capability (href=None — use as pattern_cap only)
 # ---------------------------------------------------------------------------
 
+def _door_open_state(rep):
+    """Most /door/* resources report bare `openState`, but the
+    ARTIK051_DONGLE_REF family's /door/onedoorfreezer/vs/0 (issues #77, #83)
+    reports the vendor-prefixed `x.com.samsung.da.openState` instead. This
+    capability still binds either way (href_prefix match doesn't care about
+    field names), but a plain `field=` lookup against the wrong key means
+    the entity exists and is permanently unavailable -- check both."""
+    v = rep.get('openState')
+    if v is None:
+        v = rep.get('x.com.samsung.da.openState')
+    return v == 'Open'
+
+
 DOOR_GENERIC = Capability(
     href=None,
     href_prefix='/door/',
     poll_tier='hot',
     entities=(
-        BinarySensorDesc(key='open', field='openState',
-                         name=None, device_class='door',
-                         value_fn=lambda v: v == 'Open'),
+        BinarySensorDesc(key='open', rep_fn=_door_open_state,
+                         translation_key='instance_open',
+                         use_instance_name=True, device_class='door'),
+    ),
+)
+
+# ---------------------------------------------------------------------------
+# Kimchi refrigerator compartments (TP2X_REF_20K-class 3-compartment kimchi
+# units, issue #26) -- top/middle/bottom each report their own storage mode
+# plus a ripening status/timer on /status/kimchi/<slot>/vs/0, all three in
+# an identical shape; modeled as a pattern capability the same way
+# DOOR_GENERIC/TEMP_CURRENT_GENERIC above are, deriving the per-compartment
+# key and {instance_name} from the href's top/middle/bottom segment. Only
+# the top compartment's door has been seen reported separately (kimchidoors);
+# middle/bottom apparently have no contact switch of their own, so that's
+# its own narrower pattern cap rather than assumed universal.
+#
+# The same state is also mirrored -- packed into single tokens like
+# "KIMCHIT_KIMCHI_STORAGE_NORMAL" (T/M/B prefix per compartment) with
+# bracketed parameters -- on /mode/vs/0, the same resource FLEX_ZONE reads
+# for RF9000-class fridges. /status/kimchi/<slot>/vs/0's plain currentMode/
+# supportMode fields are unpacked and self-describing, so that's what this
+# binds to instead.
+#
+# Write path is unconfirmed (no live write against a real unit) -- same
+# "write the same field back to the entity's own href" convention as
+# PANTRY_ZONE/BEVERAGE_ZONE above, first real-world write is also the test.
+#
+# translations/en.json's kimchi_zone_mode state labels were translated
+# directly from the reporter's own (Korean-language) SmartThings app
+# screenshots, not guessed from the codes or from their English paraphrase.
+# Cross-checking the screenshots against supportMode confirms the on-screen
+# option order matches the array order everywhere it's verifiable: the top
+# compartment's freezer triplet (표준/강냉/약냉 = Standard/Strong/Weak, at
+# -19/-21/-17°C) lines up 1:1 with STORAGE_FREEZER_NORMAL/COLD/WARM, and the
+# middle/bottom compartments' full 8-entry kimchi-storage list, 2-entry
+# ripening list, and 4-entry custom-storage list each line up 1:1 with their
+# supportMode order too -- so COLD/WARM consistently means Strong/Weak (a
+# colder or warmer preset around the NORMAL setpoint) everywhere that suffix
+# appears, including on STORAGE_FRIDGE_* and the low-salt kimchi variants,
+# which weren't directly screenshotted but share the same NORMAL/COLD/WARM
+# vocabulary as the two confirmed triplets. CRUNFCH (아삭, "crisp/crunchy")
+# and BUY (구입, "purchased") are also confirmed exact matches, not
+# abbreviation guesses.
+# ---------------------------------------------------------------------------
+
+def _kimchi_mode_write(p, rep, href=None):
+    if not href or p not in (rep.get('x.com.samsung.da.supportMode') or ()):
+        return None
+    return [s for s in href.strip('/').split('/') if s], {
+        'x.com.samsung.da.currentMode': p,
+    }
+
+
+KIMCHI_ZONE = Capability(
+    href=None,
+    href_prefix='/status/kimchi/',
+    strip_prefix_in_key=True,
+    poll_tier='warm',
+    entities=(
+        SelectDesc(key='mode', field='x.com.samsung.da.currentMode',
+                   use_instance_name=True, icon='mdi:fridge-outline',
+                   translation_key='kimchi_zone_mode',
+                   entity_category='config',
+                   options_field='x.com.samsung.da.supportMode',
+                   write_fn=_kimchi_mode_write),
+        SensorDesc(key='ripening_status', field='x.com.samsung.da.ripeStatus',
+                   use_instance_name=True, icon='mdi:progress-clock',
+                   translation_key='kimchi_ripening_status',
+                   entity_category='diagnostic'),
+        SensorDesc(key='ripening_remaining', field='x.com.samsung.da.ripeRemaintime',
+                   use_instance_name=True, icon='mdi:timer-sand',
+                   translation_key='kimchi_ripening_remaining',
+                   entity_category='diagnostic',
+                   # No dump has this nonzero (ripeStatus is always "Off" so
+                   # far) -- device-reported unit unconfirmed, so this stays
+                   # a bare number rather than asserting minutes or hours.
+                   value_fn=_int),
+        SensorDesc(key='rack_count', field='x.com.samsung.da.rackCount',
+                   use_instance_name=True, icon='mdi:tray-full',
+                   translation_key='kimchi_rack_count',
+                   entity_category='diagnostic', enabled_default=False,
+                   value_fn=_int),
+    ),
+)
+
+KIMCHI_DOOR_GENERIC = Capability(
+    href=None,
+    href_prefix='/kimchidoors/',
+    strip_prefix_in_key=True,
+    poll_tier='hot',
+    entities=(
+        # Not deduped against DOORS_FALLBACK below: on the one reporter
+        # (refrigerator_tp2x_ref_20k_kimchi) this binds alongside, the
+        # /doors/vs/0 aggregate carries a single generic item (id "4", no
+        # /door/<instance> siblings for DOORS_FALLBACK's match_fn to see)
+        # that doesn't share this compartment's "top" instance numbering --
+        # a distinct main-cabinet door, not this kimchi drawer's own contact
+        # switch reported twice.
+        BinarySensorDesc(key='open', rep_fn=_door_open_state,
+                         translation_key='instance_open',
+                         use_instance_name=True, device_class='door'),
     ),
 )
 
@@ -604,7 +788,7 @@ DOORS_FALLBACK = Capability(
     poll_tier='hot',
     entities=(
         BinarySensorDesc(key='door_open', field='x.com.samsung.da.items',
-                         name='Door', device_class='door',
+                         device_class='door',
                          value_fn=lambda items: any(
                              i.get('x.com.samsung.da.openState') == 'Open'
                              for i in (items or []))),
@@ -636,13 +820,13 @@ TEMPERATURES_FALLBACK = Capability(
     poll_tier='warm',
     entities=(
         SensorDesc(key='freezer_temperature', field='x.com.samsung.da.items',
-                   name='Freezer temperature', icon='mdi:thermometer',
+                   icon='mdi:thermometer',
                    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',
+                   icon='mdi:thermometer',
                    device_class='temperature', state_class='measurement',
                    unit_fn=lambda rep: _temp_item_unit(
                        rep.get('x.com.samsung.da.items'), 'Fridge'),
@@ -665,7 +849,7 @@ ICEMAKER_STATUS_FALLBACK = Capability(
     poll_tier='warm',
     entities=(
         SwitchDesc(key='ice_maker_enabled', field='x.com.samsung.da.iceMaker',
-                   name='Ice maker', icon='mdi:cube-outline',
+                   icon='mdi:cube-outline',
                    value_fn=lambda v: v == 'On',
                    write_fn=lambda p, rep, href=None: (
                        ['icemaker', 'status', 'vs', '0'],
@@ -695,17 +879,17 @@ REFRIGERATION_FALLBACK = Capability(
     poll_tier='warm',
     entities=(
         BinarySensorDesc(key='defrost_active', field='defrost',
-                         name='Defrost active', icon='mdi:snowflake-melt',
+                         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',
+                         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',
+                         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

@@ -53,6 +53,10 @@ IGNORED: list[Capability] = [
     Capability(href='/setting/vs/0'),          # supported/selected UI language
     Capability(href='/timezone/vs/0'),         # redundant with HA's own timezone
     Capability(href='/wm/setinfo/vs/0'),       # model/manufacturing metadata
+    # Resource-monitoring poll-interval config (a bare minPeriod in
+    # milliseconds, issue #165's TP1X_REF_21K fridge) -- internal transport
+    # plumbing, not appliance state.
+    Capability(href='/rm/control/vs/0'),
 
     # Demand Response Load Control — utility-company grid signals; requires
     # cloud registration with a utility program we don't support locally.
@@ -107,6 +111,11 @@ IGNORED: list[Capability] = [
     # 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'),
+    # AirDresser counterpart of the above (issue #157): read only for its
+    # courseTable id (air_dresser.AIR_DRESSER_COURSE's table_href), no
+    # entity of its own -- same "no entity, just the table id" role as
+    # /st/washercourse/vs/0 and /st/dryercourse/vs/0.
+    Capability(href='/st/airdressercourse/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
@@ -131,4 +140,12 @@ IGNORED: list[Capability] = [
     # parallel write-capable capability around an unverified generic OCF
     # write contract.
     Capability(href='/operational/state/0'),
+
+    # Cooktop guided-cooking/recipe status (issue #86, TP1X_DA-KS-COOKTOP
+    # family): sequenceNumber, operationBurnerNumber, a stageInfo block, and
+    # a textData.menu string -- every field empty/zero on the only dump
+    # seen so far (device idle, no guided-cooking program active). Same
+    # "don't guess" treatment as the microwave family's /recipe/cook/vs/0.
+    # Revisit if a dump with an active recipe surfaces.
+    Capability(href='/cooktop/recipe/status/vs/0'),
 ]

custom_components/localthings/registry/capabilities/laundry.py

@@ -21,6 +21,7 @@ Door-LED keys use NO `x.com.samsung.da.` prefix -- `setBrightness` /
 """
 from datetime import time as dt_time
 
+from ...catalog import has_entity_translation
 from ..capability import Capability
 from ..entities import NumberDesc, SelectDesc, SensorDesc, SwitchDesc, TimeDesc
 
@@ -60,30 +61,30 @@ DOOR_LED = Capability(
     href='/doorled/light/vs/0',
     entities=(
         SelectDesc(key='led_brightness', field='setBrightness',
-                   name='Door LED brightness', icon='mdi:brightness-6',
+                   icon='mdi:brightness-6',
                    entity_category='config',
                    options=_LED_LEVELS, write_fn=_led_brightness_write),
         SwitchDesc(key='led_night_light', field='setNightLight',
-                   name='Door LED night light', icon='mdi:weather-night',
+                   icon='mdi:weather-night',
                    entity_category='config',
                    value_fn=lambda v: v == 'On',
                    write_fn=_led_night_write),
         SelectDesc(key='led_night_brightness', field='setNightLightBrightness',
-                   name='Door LED night brightness', icon='mdi:brightness-4',
+                   icon='mdi:brightness-4',
                    entity_category='config',
                    options=_LED_LEVELS,
                    write_fn=lambda p, rep, href=None: (
                        ['doorled', 'light', 'vs', '0'],
                        {'setNightLightBrightness': p})),
         TimeDesc(key='led_night_start', field='setNightLightTimeStart',
-                 name='Door LED night start', icon='mdi:clock-start',
+                 icon='mdi:clock-start',
                  entity_category='config',
                  value_fn=_parse_hm,
                  write_fn=lambda p, rep, href=None: (
                      ['doorled', 'light', 'vs', '0'],
                      {'setNightLightTimeStart': f'{p.hour:02d}:{p.minute:02d}'})),
         TimeDesc(key='led_night_end', field='setNightLightTimeEnd',
-                 name='Door LED night end', icon='mdi:clock-end',
+                 icon='mdi:clock-end',
                  entity_category='config',
                  value_fn=_parse_hm,
                  write_fn=lambda p, rep, href=None: (
@@ -96,7 +97,7 @@ SOUND_MODE = Capability(
     href='/settings/sound/mode/vs/0',
     entities=(
         SelectDesc(key='sound_mode', field='mode',
-                   name='Sound mode', icon='mdi:volume-high',
+                   icon='mdi:volume-high',
                    entity_category='config',
                    options=_SOUND_MODES, write_fn=_sound_mode_write),
     ),
@@ -106,7 +107,7 @@ SOUND_VOLUME = Capability(
     href='/settings/sound/volume/vs/0',
     entities=(
         NumberDesc(key='sound_volume', field='level',
-                   name='Sound volume', icon='mdi:volume-medium',
+                   icon='mdi:volume-medium',
                    entity_category='config',
                    native_min=0, native_max=15, step=5,
                    value_fn=lambda v: int(v) if v is not None else None,
@@ -127,13 +128,13 @@ BUZZER_SOUND = Capability(
     href='/buzzersound/vs/0',
     entities=(
         SelectDesc(key='buzzer_sound', field='setBuzzerSound',
-                   name='Buzzer sound', icon='mdi:volume-high',
+                   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',
+                   icon='mdi:bell-ring',
                    entity_category='config',
                    exists_fn=lambda rep, resources: 'supportedFinishSound' in rep,
                    options_field='supportedFinishSound',
@@ -291,23 +292,22 @@ def cycle_select(*, translation_key, icon, table_href=None):
     suffixes translation_key with the device's own course-table id, read
     from /st/washercourse/vs/0 or /st/dryercourse/vs/0's
     x.com.samsung.da.st.courseTable (e.g. 'washer_cycle' + 'Table_02' ->
-    'washer_cycle_table_02'). No table id available at all -- the href
-    absent or empty -- gets no translation_key, i.e. the raw course code
-    displayed as-is.
+    'washer_cycle_table_02'). An absent or unrecognized table id gets the
+    name-only ``cycle`` translation key while the raw course code remains
+    visible and writable.
 
     This matters because course codes are NOT guaranteed consistent across
     board generations sharing the same /course/vs/0 contract: every code in
     washer_cycle_table_02 was confirmed against Table_02-reporting devices
     (DA_WM_TP1/TP2 boards); FlexWash's older DA_WM_A51 board reports
     Table_00 instead, so the same hex code could mean a different course
-    there for all we've verified. Building the key from whatever table the
-    device actually reports, rather than gating a single hardcoded key on
-    an exact match, means a table we haven't built translations for yet
-    (like Table_00) just falls through Home Assistant's own missing-
-    translation handling to the same raw-code display -- exactly what
-    happens today for any individual code within a table's translations
-    that isn't populated yet -- and adding one later needs new strings.json
-    entries, not a code change here.
+    there for all we've verified. So a table-specific key is used only when
+    the shipped catalog actually has one; any other table (Table_00 today,
+    whatever ships next) falls back to the name-only ``cycle`` key, which
+    shows the raw course code rather than a label borrowed from another
+    board generation. Translating a new table is therefore a
+    translations-only change -- add the ``<family>_cycle_<table>`` entry and
+    this resolver picks it up.
 
     Left at its default for dishwasher, which has no equivalent table-id
     resource in any dump seen and no evidence its course codes vary by
@@ -318,10 +318,13 @@ def cycle_select(*, translation_key, icon, table_href=None):
     if table_href is not None:
         def key(resources):
             table = _table_id(resources, table_href)
-            return f'{translation_key}_{table.lower()}' if table else None
+            if not isinstance(table, str) or not table:
+                return 'cycle'
+            candidate = f'{translation_key}_{table.lower()}'
+            return candidate if has_entity_translation('select', candidate) else 'cycle'
 
     return SelectDesc(
-        key='cycle', name='Cycle', icon=icon, translation_key=key,
+        key='cycle', icon=icon, translation_key=key,
         options=cycle_options,
         exists_fn=lambda rep, resources: bool(cycle_options(resources)),
         rep_fn=lambda rep: option_value(rep.get('x.com.samsung.da.options'), 'Course'),
@@ -360,8 +363,8 @@ def bool_option_exists(prefix):
         rep.get('x.com.samsung.da.options'), prefix) is not None
 
 
-def bool_option_switch(key, name, icon, prefix, *, entity_category=None,
-                        gate_on_presence=False, validate_fn=None):
+def bool_option_switch(key, icon, prefix, *, entity_category=None,
+                       gate_on_presence=False, validate_fn=None):
     """A SwitchDesc over a '<prefix>_On'/'<prefix>_Off' options[] token.
 
     gate_on_presence self-gates the entity off on models that never report
@@ -373,7 +376,7 @@ def bool_option_switch(key, name, icon, prefix, *, entity_category=None,
     building one, if needed, is the caller's job.
     """
     return SwitchDesc(
-        key=key, name=name, icon=icon, entity_category=entity_category,
+        key=key, icon=icon, entity_category=entity_category,
         exists_fn=bool_option_exists(prefix) if gate_on_presence else None,
         rep_fn=bool_option_value(prefix),
         write_fn=bool_option_write(prefix),
@@ -396,7 +399,6 @@ JOB_BEGINNING_STATUS = Capability(
     entities=(
         SensorDesc(key='job_beginning_status',
                    field='x.com.samsung.da.currentStatus',
-                   name='Job beginning status',
                    entity_category='diagnostic'),
     ),
 )

custom_components/localthings/registry/capabilities/microwave.py

@@ -0,0 +1,266 @@
+"""Capabilities for the Samsung microwave family (TP1X_DA-KS-MICROWAVE-*
+class boards, both combi units and plain microwaves).
+
+Shares the oven board family's cavity/cook-cycle resource shape
+(`/operational/state/vs/0`, `/doors/vs/0`, `/connected/vs/0`,
+`/recipe/cook/vs/0`) -- those Capability objects are reused directly from
+oven.py in by_type/microwave.py rather than duplicated. What's genuinely
+different from an oven, and defined fresh here:
+
+  * Cooking-mode vocabulary: MicroWave/MicroWaveGrill/MicroWaveConvection/
+    KeepWarm never appear on an oven's /mode/vs/0, and this family spells
+    some shared-sounding modes differently than oven.py's own constants
+    (e.g. 'AirFryer', not oven.py's 'AirFry') -- a distinct SelectDesc and
+    mode list, not oven.OVEN_MODE.
+  * Setpoint bounds: this family's Convection/MicroWaveConvection modeSpec
+    (issue #121's MW7300B dump) reports 40-200 C / step 5, not oven.py's
+    30-270 C range (verified against a different, bake-oven-class board).
+  * Cavity: /oven/vs/0 here also carries a `powerLevel` field (100W-900W
+    on the MicroWave mode's powerListData) that plain ovens don't report --
+    exposed as its own sensor.
+  * Lamp: this family's option-array token is bare 'Lamp' (issue #137's
+    'Lamp_Off'), not oven.py's 'UpperLamp' -- and it's genuinely absent on
+    the combi dump (issue #121), so it's gated with exists_fn rather than
+    assumed universal like oven.py's lamp switch. Issue #137's dump only
+    ever showed 'Off', so 'On' was a guess at the paired value; issue #152's
+    ME7500D dump is the first to show a real non-Off value, and it's 'High'
+    (a brightness level, not literally 'On') -- the switch now treats any
+    non-Off/non-None value as "on" for reads, and writes back 'High'/'Off'
+    (the two confirmed tokens) rather than the never-confirmed 'On'.
+  * Filter reminder / end signal reminder: bare 'FilterRemind'/'RemindBeep'
+    option-array tokens (issue #181), both with On and Off observed live
+    (issue #152's ME7500D fixtures) -- gated with exists_fn like Lamp since
+    the MW7300B combi dump has neither.
+
+Note: cooking-mode writes are unproven here, same caveat as oven.py's
+OVEN_MODE -- exposed as a SelectDesc for fidelity, first real-world write
+is also the test.
+"""
+from ..capability import Capability
+from ..entities import NumberDesc, SelectDesc, SensorDesc, SwitchDesc
+from .common import int_or_none, normalize_temp_unit
+from .laundry import option_value, option_write
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+
+# Union of every mode seen across the two known dumps: issue #121's combi
+# MW7300B (NoOperation/Autocook/AutocookCustom/Convection/AirFryer/Grill/
+# MicroWave/MicroWaveGrill/MicroWaveConvection/Deodorization) and issue #137's
+# plain ME7500D (NoOperation/MicroWave/Autocook/KeepWarm). No dump has shown
+# every mode below on one device -- the select surfaces whatever a given
+# board's own /mode/vs/0 supportedModes reports; an entry here that a device
+# never sends just never gets picked.
+_MICROWAVE_MODES = (
+    'NoOperation',
+    'MicroWave',
+    'MicroWaveGrill',
+    'MicroWaveConvection',
+    'Convection',
+    'AirFryer',
+    'Grill',
+    'Autocook',
+    'AutocookCustom',
+    'Deodorization',
+    'KeepWarm',
+)
+
+# Convection/MicroWaveConvection modeSpec on issue #121's dump: tempMinC 40,
+# tempMaxC 200, tempIntervalC 5. No Fahrenheit dump exists for this family;
+# unlike oven.py's own SETPOINT_MIN_F/MAX_F/STEP_F (independently verified
+# against issue #44's range dump), there's nothing to verify a microwave's
+# Fahrenheit bounds against, so this module only exposes the setpoint
+# control when the live unit is Celsius (see _microwave_temp_unit below).
+SETPOINT_MIN_C = 40
+SETPOINT_MAX_C = 200
+SETPOINT_STEP_C = 5
+
+
+def _microwave_temp_unit(rep):
+    """Same shape as oven.py's _oven_temp_unit: /temperatures/vs/0 items[]
+    carries a per-item x.com.samsung.da.unit field. Both known dumps for
+    this family report 'Celsius'; kept live rather than hardcoded per the
+    fridge/oven convention (issue #7)."""
+    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')
+
+
+def _setpoint_write(p, rep, href=None):
+    """RMW write to /temperatures/vs/0 items array -- unproven for this
+    family (no live write confirmed against a real unit), same "exposed for
+    fidelity" caveat as the mode select."""
+    try:
+        temp = float(p)
+    except (TypeError, ValueError):
+        return None
+    temp_i = int(round(temp / SETPOINT_STEP_C) * SETPOINT_STEP_C)
+    if not (SETPOINT_MIN_C <= temp_i <= SETPOINT_MAX_C):
+        return None
+    items = rep.get('x.com.samsung.da.items')
+    if not items:
+        return None
+    items = [dict(it) for it in items]
+    items[0]['x.com.samsung.da.desired'] = str(temp_i)
+    return ['temperatures', 'vs', '0'], {'x.com.samsung.da.items': items}
+
+
+def _power_level_watts(v):
+    """'100W'..'900W' (issue #121) or a bare '0' (issue #137) -> int watts."""
+    if v is None:
+        return None
+    s = str(v).strip()
+    if s.upper().endswith('W'):
+        s = s[:-1]
+    return int_or_none(s)
+
+
+def _cooking_mode_options(resources):
+    """Live mode list from the device's own /mode/vs/0 supportedModes when
+    it reports one (both known dumps do); the union-of-all-dumps
+    _MICROWAVE_MODES guess otherwise. Same live-first, static-fallback
+    pattern as oven._oven_mode_options -- a fixed list here would offer
+    users modes their own unit doesn't have (issue #152's ME7500D reports
+    only 4 of _MICROWAVE_MODES' 11)."""
+    rep = resources.get('/mode/vs/0') or {}
+    live = rep.get('x.com.samsung.da.supportedModes')
+    return list(live) if live else list(_MICROWAVE_MODES)
+
+
+def _mode_write(p, rep, href=None):
+    valid = rep.get('x.com.samsung.da.supportedModes') or _MICROWAVE_MODES
+    if p not in valid:
+        return None
+    return ['mode', 'vs', '0'], {'x.com.samsung.da.modes': [p]}
+
+
+def _sound_write(p, rep, href=None):
+    if p not in ('On', 'Off'):
+        return None
+    if not rep.get('x.com.samsung.da.options'):
+        return None
+    return ['mode', 'vs', '0'], {
+        'x.com.samsung.da.options': option_write('Sound', p),
+    }
+
+
+def _lamp_exists(rep, resources):
+    return option_value(rep.get('x.com.samsung.da.options'), 'Lamp') is not None
+
+
+def _filter_remind_exists(rep, resources):
+    return option_value(rep.get('x.com.samsung.da.options'), 'FilterRemind') is not None
+
+
+def _remind_beep_exists(rep, resources):
+    return option_value(rep.get('x.com.samsung.da.options'), 'RemindBeep') is not None
+
+
+def _lamp_write(p, rep, href=None):
+    if p not in ('On', 'Off'):
+        return None
+    if not rep.get('x.com.samsung.da.options'):
+        return None
+    # 'High' and 'Off' are the two tokens actually confirmed on live dumps
+    # (issues #137/#152) -- 'On' has never been observed and the device
+    # likely doesn't recognize it (see module docstring).
+    token = 'High' if p == 'On' else 'Off'
+    return ['mode', 'vs', '0'], {
+        'x.com.samsung.da.options': option_write('Lamp', token),
+    }
+
+
+def _filter_remind_write(p, rep, href=None):
+    if p not in ('On', 'Off'):
+        return None
+    if not rep.get('x.com.samsung.da.options'):
+        return None
+    return ['mode', 'vs', '0'], {
+        'x.com.samsung.da.options': option_write('FilterRemind', p),
+    }
+
+
+def _remind_beep_write(p, rep, href=None):
+    if p not in ('On', 'Off'):
+        return None
+    if not rep.get('x.com.samsung.da.options'):
+        return None
+    return ['mode', 'vs', '0'], {
+        'x.com.samsung.da.options': option_write('RemindBeep', p),
+    }
+
+
+# ---------------------------------------------------------------------------
+# Capabilities
+# ---------------------------------------------------------------------------
+
+MICROWAVE_CAVITY = Capability(
+    href='/oven/vs/0',
+    poll_tier='hot',
+    entities=(
+        SensorDesc(key='cavity_state', field='x.com.samsung.da.state'),
+        SensorDesc(key='power_level', field='x.com.samsung.da.powerLevel',
+                   unit='W', value_fn=_power_level_watts),
+    ),
+)
+
+MICROWAVE_SETPOINT = Capability(
+    href='/temperatures/vs/0',
+    poll_tier='hot',
+    entities=(
+        NumberDesc(key='setpoint', field='x.com.samsung.da.items',
+                   device_class='temperature', unit_fn=_microwave_temp_unit,
+                   native_min=float(SETPOINT_MIN_C), native_max=float(SETPOINT_MAX_C),
+                   step=float(SETPOINT_STEP_C), icon='mdi:thermometer-chevron-up',
+                   exists_fn=lambda rep, resources: _microwave_temp_unit(rep) == '°C',
+                   value_fn=lambda items: int_or_none(
+                       (items[0].get('x.com.samsung.da.desired') if items else None)),
+                   write_fn=_setpoint_write),
+        SensorDesc(key='current_temp_c', field='x.com.samsung.da.items',
+                   device_class='temperature',
+                   state_class='measurement', unit_fn=_microwave_temp_unit,
+                   value_fn=lambda items: int_or_none(
+                       (items[0].get('x.com.samsung.da.current') if items else None))),
+    ),
+)
+
+MICROWAVE_MODE = Capability(
+    href='/mode/vs/0',
+    poll_tier='warm',
+    entities=(
+        # SelectDesc first — test_microwave_mode_options_nonempty uses entities[0]
+        SelectDesc(key='cooking_mode', field='x.com.samsung.da.modes',
+                   icon='mdi:tune',
+                   options=_cooking_mode_options,
+                   value_fn=lambda v: v[0] if v else None,
+                   write_fn=_mode_write),
+        SwitchDesc(key='sound', field='x.com.samsung.da.options',
+                   icon='mdi:volume-high',
+                   entity_category='config',
+                   value_fn=lambda opts: option_value(opts, 'Sound') == 'On',
+                   write_fn=_sound_write),
+        SwitchDesc(key='lamp', field='x.com.samsung.da.options',
+                   icon='mdi:track-light',
+                   exists_fn=_lamp_exists,
+                   value_fn=lambda opts: option_value(opts, 'Lamp') not in (None, 'Off'),
+                   write_fn=_lamp_write),
+        # issue #181: Filter Reminder / End Signal Reminder toggles,
+        # confirmed present (both On and Off observed across dumps -- see
+        # issue #152's ME7500D fixtures) but only on boards that carry the
+        # FilterRemind_*/RemindBeep_* tokens; gated off elsewhere (e.g. the
+        # MW7300B combi dump has neither) rather than assumed universal.
+        SwitchDesc(key='filter_remind', field='x.com.samsung.da.options',
+                   icon='mdi:air-filter',
+                   entity_category='config',
+                   exists_fn=_filter_remind_exists,
+                   value_fn=lambda opts: option_value(opts, 'FilterRemind') == 'On',
+                   write_fn=_filter_remind_write),
+        SwitchDesc(key='remind_beep', field='x.com.samsung.da.options',
+                   icon='mdi:bell-ring',
+                   entity_category='config',
+                   exists_fn=_remind_beep_exists,
+                   value_fn=lambda opts: option_value(opts, 'RemindBeep') == 'On',
+                   write_fn=_remind_beep_write),
+    ),
+)

custom_components/localthings/registry/capabilities/operational.py

@@ -2,7 +2,8 @@
 
 Shared by dryer/dishwasher/oven/washer families.
 """
-from datetime import datetime, timezone, timedelta
+import math
+from datetime import datetime, timedelta, timezone
 
 from ..capability import Capability
 from ..entities import BinarySensorDesc, ButtonDesc, NumberDesc, SensorDesc
@@ -28,17 +29,41 @@ def _int(v):
         return None
 
 
+def _is_active(rep):
+    """Check if appliance is actively running and cycle is not finished."""
+    return (
+        _SAMSUNG_STATE_TO_OCF.get(rep.get('x.com.samsung.da.state')) == 'active'
+        and rep.get('x.com.samsung.da.progress') != 'Finish'
+    )
+
+
+def _remaining_seconds(raw):
+    """'HH:MM:SS' (or 'MM:SS') -> total seconds, or None."""
+    if not isinstance(raw, str):
+        return None
+    try:
+        parts = [int(p) for p in raw.split(':')]
+    except (ValueError, TypeError):
+        return None
+
+    if len(parts) == 3:
+        h, m, s = parts
+    elif len(parts) == 2:
+        h, m, s = 0, *parts
+    else:
+        return None
+
+    return h * 3600 + m * 60 + s
+
+
 def _delay_hours(v):
     """delayStartTime is a duration until the cycle starts, not a
     wall-clock time -- "01:00" means "1 hour from when you press start",
     not "1 AM"."""
-    if not v:
-        return 0.0
-    try:
-        h, m, s = v.split(':')
-        return int(h) + int(m) / 60 + int(s) / 3600
-    except Exception:
-        return None
+    total_seconds = _remaining_seconds(v)
+    if total_seconds is None:
+        return 0.0 if not v else None
+    return total_seconds / 3600.0
 
 
 def _format_delay(hours):
@@ -53,27 +78,39 @@ def _delay_field(rep):
     wall-clock time -- see _delay_hours). Write back whichever key the
     device itself is using; default to delayStartTime for hardware that
     reports neither yet (matches prior behavior)."""
-    return ('x.com.samsung.da.delayEndTime' if 'x.com.samsung.da.delayEndTime' in rep
-            else 'x.com.samsung.da.delayStartTime')
+    return (
+        'x.com.samsung.da.delayEndTime' if 'x.com.samsung.da.delayEndTime' in rep
+        else 'x.com.samsung.da.delayStartTime'
+    )
 
 
-def _finish_time(remaining_str):
-    if not remaining_str:
+def _finish_time(rep):
+    if not _is_active(rep):
         return None
-    try:
-        h, m, s = remaining_str.split(':')
-        total_s = int(h) * 3600 + int(m) * 60 + int(s)
-        if total_s == 0:
-            return None
-        return datetime.now(timezone.utc) + timedelta(seconds=total_s)
-    except Exception:
+    total_s = _remaining_seconds(rep.get('x.com.samsung.da.remainingTime'))
+    if not total_s:
         return None
+    return datetime.now(timezone.utc) + timedelta(seconds=total_s)
+
+
+def _completion_minutes(rep):
+    """Parse remaining time into minutes directly from device payload."""
+    raw = rep.get('x.com.samsung.da.remainingTime') or rep.get('remainingTime')
+    total_s = _remaining_seconds(raw)
+    if total_s is None:
+        return None
+    
+    # Avoid the firmware bug where it freezes at 1 minute post-cycle
+    if rep.get('x.com.samsung.da.progress') == 'Finish':
+        return 0
+        
+    return math.ceil(total_s / 60)
 
 
 # Shared by dryer/dishwasher/oven/washer -- oven.py imports this directly
 # rather than keeping its own copy, since both wrote the identical
 # state='Ready' RMW.
-STOP_BUTTON = ButtonDesc(key='stop', field='', name='Stop', payload='Ready',
+STOP_BUTTON = ButtonDesc(key='stop', field='', payload='Ready',
                          icon='mdi:stop',
                          write_fn=lambda p, rep, href=None: (
                              ['operational', 'state', 'vs', '0'],
@@ -84,46 +121,50 @@ OPERATIONAL_STATE = Capability(
     poll_tier='hot',
     entities=(
         SensorDesc(key='machine_state', field='x.com.samsung.da.state',
-                   name='Machine state', device_class='enum',
+                   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.
         # Samsung firmware keeps state='Run' after progress reaches 'Finish',
         # so we also gate on progress to avoid a stuck 'Running' indication.
-        # Named 'Running' rather than 'Cycle active' -- this href (and the
+        # Named 'Running' in the catalog rather than 'Cycle active' -- this href (and the
         # start/pause/stop buttons below) is shared across the dryer/
         # dishwasher/oven/washer families, and 'cycle' is laundry-specific
         # vocabulary that doesn't fit an oven's bake/roast/etc.
         BinarySensorDesc(key='cycle_active', device_class='running',
-                         name='Running',
                          rep_fn=lambda rep: (
                              _SAMSUNG_STATE_TO_OCF.get(rep.get('x.com.samsung.da.state')) == 'active'
                              and rep.get('x.com.samsung.da.progress') != 'Finish'
                          )),
-        SensorDesc(key='progress', name='Progress', icon='mdi:progress-wrench',
+        SensorDesc(key='progress', icon='mdi:progress-wrench',
                    rep_fn=lambda rep: (
                        'Idle' if _SAMSUNG_STATE_TO_OCF.get(rep.get('x.com.samsung.da.state')) != 'active'
                        else _progress(rep.get('x.com.samsung.da.progress'))
                    )),
+                   
         SensorDesc(key='progress_percentage',
-                   name='Progress percent', unit='%', state_class='measurement',
+                   unit='%', state_class='measurement',
                    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'.
         SensorDesc(key='finish_time', device_class='timestamp',
-                   name='Estimated finish',
-                   rep_fn=lambda rep: (
-                       None if _SAMSUNG_STATE_TO_OCF.get(rep.get('x.com.samsung.da.state')) != 'active'
-                            or rep.get('x.com.samsung.da.progress') == 'Finish'
-                       else _finish_time(rep.get('x.com.samsung.da.remainingTime'))
-                   )),
-        NumberDesc(key='delay_start_hours', name='Delay start', icon='mdi:timer-plus-outline',
+                   rep_fn=_finish_time),
+                   
+        SensorDesc(key='completion_minutes',
+                   icon='mdi:clock-outline', unit='min',
+                   device_class='duration', state_class='measurement',
+                   exists_fn=lambda rep, resources: _completion_minutes(rep) is not None,
+                   rep_fn=_completion_minutes),
+                   
+        NumberDesc(key='delay_start_hours', icon='mdi:timer-plus-outline',
                    device_class='duration', unit='h',
                    native_min=0, native_max=24, step=1,
                    rep_fn=lambda rep: _delay_hours(
@@ -132,16 +173,17 @@ OPERATIONAL_STATE = Capability(
                    write_fn=lambda p, rep, href=None: (
                        ['operational', 'state', 'vs', '0'],
                        {_delay_field(rep): _format_delay(p)})),
-        ButtonDesc(key='start', field='', name='Start', payload='Run',
+        ButtonDesc(key='start', field='', payload='Run',
                    icon='mdi:play',
                    write_fn=lambda p, rep, href=None: (
                        ['operational', 'state', 'vs', '0'],
                        {'x.com.samsung.da.state': p})),
-        ButtonDesc(key='pause', field='', name='Pause', payload='Pause',
+        ButtonDesc(key='pause', field='', payload='Pause',
                    icon='mdi:pause',
                    write_fn=lambda p, rep, href=None: (
                        ['operational', 'state', 'vs', '0'],
                        {'x.com.samsung.da.state': p})),
+                       
         STOP_BUTTON,
     ),
 )

custom_components/localthings/registry/capabilities/oven.py

@@ -24,6 +24,7 @@ but is effectively read-only in practice.
 """
 from datetime import datetime, timezone, timedelta
 
+from ..batch import is_stub_rep
 from ..capability import Capability
 from ..entities import (
     BinarySensorDesc, NumberDesc, SelectDesc, SensorDesc, SwitchDesc,
@@ -51,6 +52,14 @@ SETPOINT_STEP_F = 5
 # Mode options seen on NV7000BS-class. No dump exists so this list is inferred
 # from Samsung documentation and firmware observations. The firmware will
 # reject unknown modes; missing entries here are a coverage gap, not a bug.
+#
+# This is a fallback only, used when a device's own /mode/vs/0 doesn't report
+# x.com.samsung.da.supportedModes at all -- see _oven_mode_options/
+# _oven_mode_write below. issue #138's range dump (NE63A6511SS/AA) reports
+# ConvectionRoast/KeepWarm/BreadProof/AirFryer/Dehydrate/SelfClean/SteamClean
+# in its own supportedModes; those are read live rather than added here, per
+# the adding-device-support skill's preference for device-reported option
+# lists over hardcoded ones.
 _OVEN_MODES = (
     'NoOperation',
     'Bake',
@@ -122,6 +131,28 @@ def _option_value(options, prefix):
     return None
 
 
+def _has_option(prefix):
+    """exists_fn for an options-array switch: bind only when the device's own
+    options[] actually carries a `<prefix>_<value>` token.
+
+    fast_preheat/natural_steam were shipped unconditionally (no exists_fn) as
+    an unverified guess (see module docstring) -- issue #183's dump (model
+    NE6516A) reports neither `fastpreheat_*` nor `NaturalSteam_*` in its
+    options[] at all, so both switches were phantom controls: always read as
+    off, and toggling them wrote a token the firmware never recognized in
+    the first place, hence "does not appear to do anything."
+
+    `is_stub_rep(rep) or` keeps the same stub carve-out as cooktop.py's
+    identical per-token exists_fn on its own options[]-array href: a stub
+    /device/0 seed rep (not yet sub-polled) has no options[] at all, and
+    without this an entity whose token is genuinely present would never get
+    a first chance to bind, since exists_fn runs before that first real
+    fetch lands.
+    """
+    return lambda rep, resources: is_stub_rep(rep) or _option_value(
+        rep.get('x.com.samsung.da.options'), prefix) is not None
+
+
 def _option_write(prefix, new_value):
     """A one-token x.com.samsung.da.options write, mirroring
     laundry.option_write. NOT independently confirmed on an oven -- issue
@@ -173,50 +204,37 @@ def _cook_time_write(p, rep, href=None):
     }
 
 
+def _oven_mode_options(resources):
+    """Live mode list from the device's own /mode/vs/0 supportedModes when
+    it reports one; the NV7000BS-era _OVEN_MODES guess otherwise. Mirrors
+    laundry.py's options_field pattern (buzzer_sound/finish_sound), but
+    needs the callable form rather than options_field because a static
+    fallback has to kick in when the device's own field is absent."""
+    rep = resources.get('/mode/vs/0') or {}
+    live = rep.get('x.com.samsung.da.supportedModes')
+    return list(live) if live else list(_OVEN_MODES)
+
+
 def _oven_mode_write(p, rep, href=None):
-    if p not in _OVEN_MODES:
+    valid = rep.get('x.com.samsung.da.supportedModes') or _OVEN_MODES
+    if p not in valid:
         return None
     return ['mode', 'vs', '0'], {'x.com.samsung.da.modes': [p]}
 
 
-def _lamp_write(p, rep, href=None):
-    if p not in ('On', 'Off'):
-        return None
-    if not rep.get('x.com.samsung.da.options'):
-        return None
-    return ['mode', 'vs', '0'], {
-        'x.com.samsung.da.options': _option_write('UpperLamp', p),
-    }
-
-
-def _sound_write(p, rep, href=None):
-    if p not in ('On', 'Off'):
-        return None
-    if not rep.get('x.com.samsung.da.options'):
-        return None
-    return ['mode', 'vs', '0'], {
-        'x.com.samsung.da.options': _option_write('Sound', p),
-    }
-
-
-def _fastpreheat_write(p, rep, href=None):
-    if p not in ('On', 'Off'):
-        return None
-    if not rep.get('x.com.samsung.da.options'):
-        return None
-    return ['mode', 'vs', '0'], {
-        'x.com.samsung.da.options': _option_write('fastpreheat', p),
-    }
-
-
-def _naturalsteam_write(p, rep, href=None):
-    if p not in ('On', 'Off'):
-        return None
-    if not rep.get('x.com.samsung.da.options'):
-        return None
-    return ['mode', 'vs', '0'], {
-        'x.com.samsung.da.options': _option_write('NaturalSteam', p),
-    }
+def _option_switch_write(prefix):
+    """Factory for a single-token on/off options-array write -- lamp, sound,
+    fast_preheat, natural_steam, energy_saving, and cooktop_on_alert were all
+    a byte-for-byte copy of this same shape, one per prefix."""
+    def write(p, rep, href=None):
+        if p not in ('On', 'Off'):
+            return None
+        if not rep.get('x.com.samsung.da.options'):
+            return None
+        return ['mode', 'vs', '0'], {
+            'x.com.samsung.da.options': _option_write(prefix, p),
+        }
+    return write
 
 
 # ---------------------------------------------------------------------------
@@ -228,25 +246,25 @@ OVEN_OPERATIONAL_STATE = Capability(
     poll_tier='hot',
     entities=(
         SensorDesc(key='machine_state', field='x.com.samsung.da.state',
-                   name='Machine state', icon='mdi:stove',
+                   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='Running', device_class='running',
+                         device_class='running',
                          value_fn=lambda v: _SAMSUNG_STATE_TO_OCF.get(v) == 'active'),
         SensorDesc(key='progress_percentage',
                    field='x.com.samsung.da.progressPercentage',
-                   name='Progress percent', unit='%', state_class='measurement',
+                   unit='%', state_class='measurement',
                    value_fn=_int),
         SensorDesc(key='operation_time_minutes',
                    field='x.com.samsung.da.operationTime',
-                   name='Operation time (minutes)', unit='min',
+                   unit='min',
                    state_class='measurement', value_fn=_op_minutes),
         SensorDesc(key='finish_time', field='x.com.samsung.da.remainingTime',
-                   name='Estimated finish', device_class='timestamp',
+                   device_class='timestamp',
                    value_fn=_finish_time),
         NumberDesc(key='cook_time', field='x.com.samsung.da.operationTime',
-                   name='Cook time', unit='min', native_min=0, native_max=1439,
+                   unit='min', native_min=0, native_max=1439,
                    step=1.0, icon='mdi:timer', value_fn=_op_minutes,
                    write_fn=_cook_time_write),
         STOP_BUTTON,
@@ -258,7 +276,7 @@ OVEN_CAVITY = Capability(
     poll_tier='hot',
     entities=(
         SensorDesc(key='oven_state', field='x.com.samsung.da.state',
-                   name='Cavity state'),
+                   ),
     ),
 )
 
@@ -291,7 +309,7 @@ OVEN_SETPOINT = Capability(
     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_fn=_oven_temp_unit,
+                   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',
                    native_min_fn=lambda rep: float(_setpoint_bounds(rep)[0]),
@@ -301,7 +319,7 @@ OVEN_SETPOINT = Capability(
                        (items[0].get('x.com.samsung.da.desired') if items else None)),
                    write_fn=_oven_setpoint_write),
         SensorDesc(key='current_temp_c', field='x.com.samsung.da.items',
-                   name='Temperature', device_class='temperature',
+                   device_class='temperature',
                    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))),
@@ -313,7 +331,7 @@ OVEN_DOOR = Capability(
     poll_tier='hot',
     entities=(
         BinarySensorDesc(key='door_open', field='x.com.samsung.da.items',
-                         name='Door', device_class='door',
+                         device_class='door',
                          value_fn=lambda items: (
                              items[0].get('x.com.samsung.da.openState') == 'Open'
                              if items else None)),
@@ -325,7 +343,7 @@ OVEN_CONNECTED = Capability(
     poll_tier='warm',
     entities=(
         BinarySensorDesc(key='cloud_connected', field='x.com.samsung.da.connected',
-                         name='Cloud connected', device_class='connectivity',
+                         device_class='connectivity',
                          entity_category='diagnostic',
                          value_fn=lambda v: v == 'On'),
     ),
@@ -338,32 +356,57 @@ OVEN_CONNECTED = Capability(
 # fields worth exposing.
 OVEN_SPEC = Capability(href='/oven/spec/vs/0')
 
+# Quick-recipe display blob (combi microwave, issue #121) -- a JSON-encoded
+# string (language/menu/servingSize/option) with every field blank on the
+# only dump seen, and no documented write contract. No entity to bind per
+# the 'don't guess' rule; a bare Capability still marks the href covered.
+OVEN_RECIPE_COOK = Capability(href='/recipe/cook/vs/0')
+
 OVEN_MODE = Capability(
     href='/mode/vs/0',
     poll_tier='warm',
     entities=(
         # SelectDesc first — test_oven_mode_options_nonempty uses entities[0]
         SelectDesc(key='oven_mode', field='x.com.samsung.da.modes',
-                   name='Cooking mode', icon='mdi:tune',
-                   options=_OVEN_MODES,
+                   icon='mdi:tune',
+                   options=_oven_mode_options,
                    value_fn=lambda v: v[0] if v else None,
                    write_fn=_oven_mode_write),
         SwitchDesc(key='lamp', field='x.com.samsung.da.options',
-                   name='Lamp', icon='mdi:track-light',
+                   icon='mdi:track-light',
                    value_fn=lambda opts: _option_value(opts, 'UpperLamp') == 'On',
-                   write_fn=_lamp_write),
+                   write_fn=_option_switch_write('UpperLamp')),
         SwitchDesc(key='sound', field='x.com.samsung.da.options',
-                   name='Sound', icon='mdi:volume-high',
+                   icon='mdi:volume-high',
                    entity_category='config',
                    value_fn=lambda opts: _option_value(opts, 'Sound') == 'On',
-                   write_fn=_sound_write),
+                   write_fn=_option_switch_write('Sound')),
         SwitchDesc(key='fast_preheat', field='x.com.samsung.da.options',
-                   name='Fast preheat', icon='mdi:fire',
+                   icon='mdi:fire',
+                   exists_fn=_has_option('fastpreheat'),
                    value_fn=lambda opts: _option_value(opts, 'fastpreheat') == 'On',
-                   write_fn=_fastpreheat_write),
+                   write_fn=_option_switch_write('fastpreheat')),
         SwitchDesc(key='natural_steam', field='x.com.samsung.da.options',
-                   name='Natural steam', icon='mdi:kettle-steam',
+                   icon='mdi:kettle-steam',
+                   exists_fn=_has_option('NaturalSteam'),
                    value_fn=lambda opts: _option_value(opts, 'NaturalSteam') == 'On',
-                   write_fn=_naturalsteam_write),
+                   write_fn=_option_switch_write('NaturalSteam')),
+        # 120-hour energy-saving standby (issue #183): confirmed present in
+        # this unit's options[] (EnergySaving_On) and directly requested --
+        # unlike fast_preheat/natural_steam above, this token is real on this
+        # hardware, just previously unbound entirely.
+        SwitchDesc(key='energy_saving', field='x.com.samsung.da.options',
+                   icon='mdi:leaf', entity_category='config',
+                   exists_fn=_has_option('EnergySaving'),
+                   value_fn=lambda opts: _option_value(opts, 'EnergySaving') == 'On',
+                   write_fn=_option_switch_write('EnergySaving')),
+        # Cooktop-on alert (issue #183): also confirmed present
+        # (BurnerOnAlert_Off) though the reporter noted it mainly matters for
+        # the SmartThings app's own alerting, not local automation.
+        SwitchDesc(key='cooktop_on_alert', field='x.com.samsung.da.options',
+                   icon='mdi:alert-circle-outline', entity_category='config',
+                   exists_fn=_has_option('BurnerOnAlert'),
+                   value_fn=lambda opts: _option_value(opts, 'BurnerOnAlert') == 'On',
+                   write_fn=_option_switch_write('BurnerOnAlert')),
     ),
 )

custom_components/localthings/registry/capabilities/range.py

@@ -24,7 +24,8 @@ write pattern already proven safe elsewhere in this codebase (oven setpoint,
 icemaker toggles).
 """
 from ..capability import Capability
-from ..entities import BinarySensorDesc, SelectDesc, SensorDesc
+from ..entities import BinarySensorDesc, SelectDesc, SensorDesc, SwitchDesc
+from .common import normalize_temp_unit
 
 # Observed as high as 4 (this issue's dump); user-reported hardware with 5
 # burners exists. Kept a little above both since exists_fn gates unused
@@ -52,6 +53,10 @@ def _burner_hot_surface_fn(i):
     return lambda burner_list: get_state(burner_list) not in (None, 'normal')
 
 
+def _burner_pan_detection_fn(i):
+    return lambda burner_list: bool(_burner_field_fn(i, 'panDetection')(burner_list))
+
+
 def _power_level_options(resources):
     spec = resources.get('/cooktop/spec/vs/0') or {}
     return list(spec.get('supportedPowerLevelList') or [])
@@ -81,28 +86,63 @@ def _burner_entities(i):
     n = i + 1
     return (
         SelectDesc(key=f'burner_{i}_power_level', field='burnerList',
-                   name=f'Burner {n} power level', icon='mdi:knob',
+                   icon='mdi:knob',
+                   translation_key='range_burner_power_level',
+                   translation_placeholders={'number': str(n)},
                    options=_power_level_options,
                    exists_fn=exists,
                    value_fn=_burner_field_fn(i, 'powerLevel'),
                    write_fn=_burner_power_level_write(i)),
         SensorDesc(key=f'burner_{i}_state', field='burnerList',
-                   name=f'Burner {n} state', icon='mdi:stove',
+                   icon='mdi:stove',
+                   translation_key='burner_state',
+                   translation_placeholders={'number': str(n)},
                    exists_fn=exists,
                    value_fn=_burner_field_fn(i, 'operationState')),
         BinarySensorDesc(key=f'burner_{i}_hot_surface', field='burnerList',
-                         name=f'Burner {n} hot surface', device_class='heat',
+                         device_class='heat',
+                         translation_key='burner_hot_surface',
+                         translation_placeholders={'number': str(n)},
                          exists_fn=exists,
                          value_fn=_burner_hot_surface_fn(i)),
+        BinarySensorDesc(key=f'burner_{i}_pan_detected', field='burnerList',
+                         icon='mdi:pot',
+                         translation_key='burner_pan_detected',
+                         translation_placeholders={'number': str(n)},
+                         entity_category='diagnostic',
+                         exists_fn=exists,
+                         value_fn=_burner_pan_detection_fn(i)),
     )
 
 
+def _child_lock_write(p, rep, href=None):
+    if p not in ('On', 'Off'):
+        return None
+    return ['cooktop', 'status', 'vs', '0'], {'childLock': p.lower()}
+
+
 COOKTOP_STATUS = Capability(
     href='/cooktop/status/vs/0',
     poll_tier='hot',
     entities=(
         SensorDesc(key='cooktop_state', field='operationState',
-                   name='Cooktop state', icon='mdi:pot-steam'),
+                   icon='mdi:pot-steam'),
+        # The cooktop section's own on/off (issue #86) -- distinct from
+        # common.POWER's /power/0 or /power/vs/0, which some boards in this
+        # family (the range combo) additionally carry for the whole
+        # appliance. Read-only: no live device to confirm remotely turning
+        # a cooktop on wouldn't leave a burner active unattended.
+        BinarySensorDesc(key='cooktop_power', field='power',
+                         device_class='power', icon='mdi:pot-steam',
+                         value_fn=lambda v: str(v).lower() == 'on'),
+        # Safe to write -- a lock toggle, not a heat control -- via a
+        # direct single-field PUT (no RMW needed; unlike burnerList this
+        # is a lone scalar, not an array of siblings to preserve).
+        SwitchDesc(key='cooktop_child_lock', field='childLock',
+                   device_class='lock', entity_category='config',
+                   icon='mdi:lock',
+                   value_fn=lambda v: str(v).lower() == 'on',
+                   write_fn=_child_lock_write),
         *[e for i in range(MAX_BURNERS) for e in _burner_entities(i)],
     ),
 )
@@ -123,8 +163,50 @@ COOKTOP_SAFETY = Capability(
     poll_tier='warm',
     entities=(
         BinarySensorDesc(key='cooktop_safety_shutoff_enabled', field='safetyAlert',
-                         name='Hot surface auto-shutoff enabled',
                          entity_category='config',
                          value_fn=lambda v: (v or {}).get('state') == 'on'),
     ),
 )
+
+# Bluetooth meat probe (issue #86). All-idle sentinel values when
+# disconnected (operationBurnerNumber -1, temperatures 0) -- no special
+# gating on those, matching cooktop.PAIRED_HOOD_STATUS's own precedent of
+# showing a disconnected accessory's fields plainly rather than hiding the
+# whole capability.
+PROBE_STATUS = Capability(
+    href='/bluetooth/probe/status/vs/0',
+    poll_tier='warm',
+    entities=(
+        BinarySensorDesc(key='probe_connected', field='connectionState',
+                         device_class='connectivity',
+                         value_fn=lambda v: str(v).lower() == 'connected'),
+        SensorDesc(key='probe_battery', field='batteryPercentage',
+                   device_class='battery', state_class='measurement',
+                   unit='%', entity_category='diagnostic'),
+        SensorDesc(key='probe_temperature', field='currentTemperature',
+                   device_class='temperature', state_class='measurement',
+                   unit_fn=lambda rep: normalize_temp_unit(rep.get('temperatureUnit'), '°C')),
+        SensorDesc(key='probe_target_temperature', field='targetTemperature',
+                   device_class='temperature', entity_category='diagnostic',
+                   unit_fn=lambda rep: normalize_temp_unit(rep.get('temperatureUnit'), '°C')),
+    ),
+)
+
+# Some range boards (issue #74's NE63B8411SS) report no /cooktop/status/vs/0
+# burner array at all -- their local API only exposes this coarse
+# monitoring resource for the cooktop half, with no per-burner detail.
+# Meaning of `cooktopMonitoring` (a bare "0" on the only dump seen) and
+# `warmingCenterState`'s full value set aren't confirmed, so both are
+# exposed as plain sensors rather than guessed at as a switch/select --
+# `supportedHoodLampStateList` has no corresponding live-state field on
+# this resource, so nothing to bind it to yet.
+COOKTOP_MONITORING = Capability(
+    href='/cooktopmonitoring/vs/0',
+    poll_tier='warm',
+    entities=(
+        SensorDesc(key='cooktop_running_state', field='x.com.samsung.da.cooktopRunningState',
+                   icon='mdi:pot-steam-outline'),
+        SensorDesc(key='warming_center_state', field='x.com.samsung.da.warmingCenterState',
+                   icon='mdi:heat-wave', entity_category='diagnostic'),
+    ),
+)

custom_components/localthings/registry/capabilities/range_hood.py

@@ -9,9 +9,11 @@ independent fields.
 
 from datetime import datetime, timezone
 
+from ..batch import is_stub_rep
 from ..capability import Capability
 from ..entities import (
     BinarySensorDesc,
+    ButtonDesc,
     FanDesc,
     SelectDesc,
     SensorDesc,
@@ -52,7 +54,6 @@ HOOD_ALARMS = Capability(
         SensorDesc(
             key='alarm_code',
             field='x.com.samsung.da.items',
-            name='Alarm code',
             icon='mdi:alert',
             entity_category='diagnostic',
             value_fn=_active_alarm_codes,
@@ -93,15 +94,18 @@ HOOD_FAN = Capability(
         FanDesc(
             key='fan',
             field='x.com.samsung.da.hood.fanSpeed',
-            name=None,
             write_fn=_hood_fan_write,
         ),
         BinarySensorDesc(
             key='automatic_operation',
             field='x.com.samsung.da.hood.autoOperation',
-            name='Automatic operation',
             icon='mdi:fan-auto',
             entity_category='diagnostic',
+            # Absent on the microwave family's built-in vent fan (issue
+            # #137) -- this board has no auto-ventilation mode, unlike the
+            # standalone range hood this capability was written for.
+            exists_fn=lambda rep, resources: (
+                is_stub_rep(rep) or 'x.com.samsung.da.hood.autoOperation' in rep),
             value_fn=lambda value: str(value).lower() == 'on',
         ),
     ),
@@ -125,7 +129,6 @@ HOOD_LAMP = Capability(
         SwitchDesc(
             key='lamp',
             field='x.com.samsung.lamp.power',
-            name='Lamp',
             icon='mdi:range-hood',
             value_fn=lambda value: str(value).lower() == 'on',
             write_fn=lambda payload, rep, href=None: (
@@ -136,7 +139,6 @@ HOOD_LAMP = Capability(
         SelectDesc(
             key='lamp_brightness',
             field='x.com.samsung.lamp.current',
-            name='Lamp brightness',
             icon='mdi:brightness-6',
             translation_key='range_hood_lamp_brightness',
             options_field='x.com.samsung.lamp.range',
@@ -153,7 +155,6 @@ HOOD_FILTER = Capability(
         SensorDesc(
             key='hood_filter_usage',
             field='x.com.samsung.da.filterUsage',
-            name='Filter usage',
             unit='%',
             state_class='measurement',
             icon='mdi:air-filter',
@@ -163,14 +164,18 @@ HOOD_FILTER = Capability(
         SensorDesc(
             key='hood_filter_status',
             field='x.com.samsung.da.filterStatus',
-            name='Filter status',
             icon='mdi:air-filter',
             entity_category='diagnostic',
+            device_class='enum',
+            options=('normal', 'wash', 'replace'),
+            translation_key='filter_status',
+            value_fn=lambda value: (
+                value.lower() if isinstance(value, str) else value
+            ),
         ),
         SensorDesc(
             key='hood_filter_capacity',
             field='x.com.samsung.da.filterCapacity',
-            name='Filter capacity',
             unit='h',
             icon='mdi:timer-outline',
             entity_category='diagnostic',
@@ -181,6 +186,50 @@ HOOD_FILTER = Capability(
 )
 
 
+# After Run (issue #147): the hood keeps the fan running at low speed for a
+# while after it's switched off, to clear residual cooking smoke -- a
+# feature a user actively watches and cancels, not passive diagnostics, so
+# none of the three entities below carry entity_category. No
+# supported-values list is advertised for activationState, so it's modeled
+# read-only (monitoring, not an invented "enable" write) per the 'don't
+# guess' rule; runningCancel's only observed value is the command name
+# itself ('Cancel'), the same self-describing command-field shape as
+# operational.STOP_BUTTON. runningProgress's own name states its domain
+# (a percentage of the cycle completed), so it's modeled as one rather than
+# left an opaque passthrough -- unlike activationState/runningCancel, there's
+# no ambiguous field name or missing-write-contract question here to hedge on.
+AFTER_RUN = Capability(
+    href='/afterrun/vs/0',
+    poll_tier='warm',
+    entities=(
+        BinarySensorDesc(
+            key='after_run_active',
+            field='x.com.samsung.da.activationState',
+            icon='mdi:fan-clock',
+            value_fn=lambda value: str(value).lower() == 'on',
+        ),
+        SensorDesc(
+            key='after_run_progress',
+            field='x.com.samsung.da.runningProgress',
+            unit='%',
+            state_class='measurement',
+            icon='mdi:fan-clock',
+            value_fn=int_or_none,
+        ),
+        ButtonDesc(
+            key='after_run_cancel',
+            field='',
+            payload='Cancel',
+            icon='mdi:fan-off',
+            write_fn=lambda p, rep, href=None: (
+                ['afterrun', 'vs', '0'],
+                {'x.com.samsung.da.runningCancel': p},
+            ),
+        ),
+    ),
+)
+
+
 AIR_QUALITY = Capability(
     href='/sensors/vs/0',
     poll_tier='warm',
@@ -188,26 +237,22 @@ AIR_QUALITY = Capability(
         SensorDesc(
             key='clean_level',
             field='x.com.samsung.da.items',
-            name='Clean level',
             icon='mdi:air-filter',
             value_fn=lambda items: sensor_item_value(items, 'CleanLevel'),
         ),
         SensorDesc(
             key='dust',
             field='x.com.samsung.da.items',
-            name='Dust',
             value_fn=lambda items: sensor_item_value(items, 'Dust'),
         ),
         SensorDesc(
             key='fine_dust',
             field='x.com.samsung.da.items',
-            name='Fine dust',
             value_fn=lambda items: sensor_item_value(items, 'FineDust'),
         ),
         SensorDesc(
             key='super_fine_dust',
             field='x.com.samsung.da.items',
-            name='Super fine dust',
             value_fn=lambda items: sensor_item_value(items, 'SuperFineDust'),
         ),
     ),
@@ -221,7 +266,6 @@ AIR_LEVEL_CHECK = Capability(
         BinarySensorDesc(
             key='periodic_air_sensing',
             field='x.com.samsung.da.periodicSensingActivationState',
-            name='Periodic air sensing',
             icon='mdi:radar',
             entity_category='diagnostic',
             value_fn=lambda value: str(value).lower() == 'on',
@@ -229,14 +273,12 @@ AIR_LEVEL_CHECK = Capability(
         SensorDesc(
             key='air_sensing_state',
             field='x.com.samsung.da.sensingState',
-            name='Air sensing state',
             icon='mdi:radar',
             entity_category='diagnostic',
         ),
         SensorDesc(
             key='last_air_sensing_time',
             field='x.com.samsung.da.lastSensingTime',
-            name='Last air sensing time',
             device_class='timestamp',
             entity_category='diagnostic',
             value_fn=_timestamp,
@@ -244,14 +286,12 @@ AIR_LEVEL_CHECK = Capability(
         SensorDesc(
             key='last_air_sensing_level',
             field='x.com.samsung.da.lastSensingLevel',
-            name='Last air sensing level',
             icon='mdi:air-filter',
             entity_category='diagnostic',
         ),
         SensorDesc(
             key='automatic_ventilation_state',
             field='x.com.samsung.da.autoExeState',
-            name='Automatic ventilation state',
             icon='mdi:fan-auto',
             entity_category='diagnostic',
         ),
@@ -266,7 +306,6 @@ AUTO_VENTILATION = Capability(
         SensorDesc(
             key='auto_ventilation_action',
             field='action',
-            name='Auto ventilation action',
             icon='mdi:fan-auto',
         ),
     ),

custom_components/localthings/registry/capabilities/vacuum_station.py

@@ -0,0 +1,109 @@
+"""Capabilities for the Samsung stick-vacuum clean/auto-empty station
+(model A-VSKR-TP1-22-VS9500AL, "Bespoke Jet" clean station, issue #131).
+
+The reporter's diagnostics dump shows no vacuum-body state at all (no
+suction level, no battery, no cleaning-mode/room-mapping control, no
+docked/undocked status even) -- only the clean station's own dustbag,
+dustbin auto-empty settings, and UV-C sanitizing-cycle status. This
+strongly suggests the WiFi/DTLS module lives in the station, not the
+handheld stick: the station is the only "device" this integration's local
+API can see, and the wand's own controls are unrelated hardware not
+reachable this way. Modeled as its own device type -- these hrefs don't
+overlap with any existing family, so there's no shared-href ambiguity to
+resolve against another type (see registry/by_type/__init__.py's
+docstring for that rule).
+
+Resources verified against the issue #131 diagnostics dump.
+"""
+from ..capability import Capability
+from ..entities import BinarySensorDesc, SelectDesc, SensorDesc, SwitchDesc
+from .common import int_or_none, parse_iso_utc as _parse_iso_utc
+
+
+DUSTBAG = Capability(
+    href='/component/station/dustbag/vs/0',
+    poll_tier='warm',
+    entities=(
+        BinarySensorDesc(key='dustbag_full', field='x.com.samsung.da.status',
+                          device_class='problem',
+                          icon='mdi:bag-personal',
+                          value_fn=lambda v: v == 'full'),
+    ),
+)
+
+# dustbagUsage/dustbagPrevUsage are raw counters with no capacity/resolution
+# field alongside them to normalize into a percentage (unlike the AC/range
+# families' filterUsage, which always ships filterCapacity) -- exposed as a
+# plain diagnostic count rather than guessing a unit.
+DUSTBAG_USAGE = Capability(
+    href='/component/station/dustbagusage/vs/0',
+    poll_tier='cold',
+    entities=(
+        SensorDesc(key='dustbag_usage', field='x.com.samsung.da.dustbagUsage',
+                   icon='mdi:counter', entity_category='diagnostic',
+                   state_class='total_increasing', value_fn=int_or_none),
+    ),
+)
+
+DUSTBIN_SETTING = Capability(
+    href='/setting/dustbin/vs/0',
+    poll_tier='warm',
+    entities=(
+        SwitchDesc(key='auto_empty', field='x.com.samsung.da.autoEmpty',
+                   icon='mdi:delete-empty',
+                   entity_category='config',
+                   value_fn=lambda v: v == 'On',
+                   write_fn=lambda p, rep, href=None: (
+                       ['setting', 'dustbin', 'vs', '0'],
+                       {'x.com.samsung.da.autoEmpty': 'On' if p == 'On' else 'Off'})),
+        SwitchDesc(key='dustbin_auto_close', field='x.com.samsung.da.autoClose',
+                   icon='mdi:door-sliding',
+                   entity_category='config',
+                   value_fn=lambda v: v == 'On',
+                   write_fn=lambda p, rep, href=None: (
+                       ['setting', 'dustbin', 'vs', '0'],
+                       {'x.com.samsung.da.autoClose': 'On' if p == 'On' else 'Off'})),
+        SelectDesc(key='discharging_time', field='x.com.samsung.da.desiredDischargingTime',
+                   icon='mdi:timer-outline',
+                   entity_category='config',
+                   options_field='x.com.samsung.da.supportedDischargingTime',
+                   write_fn=lambda p, rep, href=None: (
+                       ['setting', 'dustbin', 'vs', '0'],
+                       {'x.com.samsung.da.desiredDischargingTime': p})),
+    ),
+)
+
+# stickStatus's exact meaning (docked? powered? charging?) isn't confirmed
+# from this single On/Off dump -- exposed as a plain diagnostic sensor
+# rather than a binary_sensor, so no polarity/semantic is asserted that
+# might be wrong.
+CLEANSTATION_STATUS = Capability(
+    href='/status/cleanstation/vs/0',
+    poll_tier='warm',
+    entities=(
+        SensorDesc(key='cleanstation_status', field='x.com.samsung.da.status',
+                   icon='mdi:home-lightning-bolt', entity_category='diagnostic'),
+        SensorDesc(key='stick_status', field='x.com.samsung.da.stickStatus',
+                   icon='mdi:broom', entity_category='diagnostic'),
+        SwitchDesc(key='uvc_intensive_mode', field='x.com.samsung.da.uvcIntensive',
+                   icon='mdi:lightbulb-on-outline',
+                   entity_category='config',
+                   value_fn=lambda v: v == 'On',
+                   write_fn=lambda p, rep, href=None: (
+                       ['status', 'cleanstation', 'vs', '0'],
+                       {'x.com.samsung.da.uvcIntensive': 'On' if p == 'On' else 'Off'})),
+        SensorDesc(key='uvc_operation_time', field='x.com.samsung.da.uvcOperationTime',
+                   icon='mdi:timer-sand', entity_category='diagnostic',
+                   value_fn=int_or_none),
+        SensorDesc(key='uvc_total_operation_time',
+                   field='x.com.samsung.da.uvcTotalOperationTime',
+                   icon='mdi:timer-sand', entity_category='diagnostic',
+                   state_class='total_increasing', value_fn=int_or_none),
+        SensorDesc(key='uvc_finished_time', field='x.com.samsung.da.uvcFinishedTime',
+                   device_class='timestamp', entity_category='diagnostic',
+                   value_fn=_parse_iso_utc),
+        SensorDesc(key='uvc_emitted_time', field='x.com.samsung.da.emittedTime',
+                   device_class='timestamp', entity_category='diagnostic',
+                   value_fn=_parse_iso_utc),
+    ),
+)

custom_components/localthings/registry/capabilities/washer.py

@@ -2,9 +2,10 @@
 front-load washers).
 
 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.
+family). Washers share the `DA_WM_` laundry board with dryers, so their
+`modelNum` can't tell the two apart -- see `registry/by_type/__init__.py`'s
+`_CONSUMER_PREFIX_TO_KEY` for the `description`-based 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
@@ -23,8 +24,8 @@ from .laundry import (
 )
 
 # ---------------------------------------------------------------------------
-# Course_XX hex codes. 23 of the codes named in strings.json/translations
-# under entity.select.washer_cycle.state.<id, lowercased> were captured
+# Course_XX hex codes. 23 of the codes named in translations/en.json
+# under entity.select.washer_cycle_table_02.state.<id, lowercased> were captured
 # from a live WW90DG6U25LEU4's x.com.samsung.da.editCourseList
 # (EditCourseList_1C1D211B1E29243328262722202325322F2E30662D8F96), matched
 # positionally against a Slovak-UI user's screenshots of their app's course
@@ -45,6 +46,14 @@ from .laundry import (
 # (issue #22). Combo units carry their own course set, so these codes
 # don't imply anything about '1F' on a plain washer.
 #
+# Three more -- '52' Eco Cold, '54' Towels, '60' Self Clean+ -- came from a
+# WF50A8600AV/US, verified directly rather than by inference: the reporter
+# selected each cycle on the physical appliance and read back the resulting
+# raw code from the cycle_select entity's state (issue #80). '54' shares a
+# display name with the existing '24' Towels -- a different code on a
+# different course table legitimately landing on the same label, not a typo
+# (same pattern as '21'/'65' Colors and '27'/'5E' Rinse+Spin above).
+#
 # No static fallback list of those codes is kept here, deliberately: other
 # washer models have a different actual course set (a second dump's active
 # course, '65', isn't even in the list above; models with 'AI Wash'/'Mixed
@@ -75,19 +84,19 @@ WASHER_SETTINGS = Capability(
     href='/washer/vs/0',
     entities=(
         SelectDesc(key='wash_temperature', field='x.com.samsung.da.waterTemperature',
-                   name='Wash temperature', icon='mdi:thermometer-water',
+                   icon='mdi:thermometer-water',
                    entity_category='config',
                    options_field='x.com.samsung.da.supportedWaterTemperature',
                    write_fn=lambda p, rep, href=None: (
                        ['washer', 'vs', '0'], {'x.com.samsung.da.waterTemperature': p})),
         SelectDesc(key='spin_speed', field='x.com.samsung.da.spinLevel',
-                   name='Spin speed', icon='mdi:sync',
+                   icon='mdi:sync',
                    entity_category='config',
                    options_field='x.com.samsung.da.supportedSpinLevel',
                    write_fn=lambda p, rep, href=None: (
                        ['washer', 'vs', '0'], {'x.com.samsung.da.spinLevel': p})),
         SelectDesc(key='rinse_cycles', field='x.com.samsung.da.rinseCycles',
-                   name='Rinse cycles', icon='mdi:water-sync',
+                   icon='mdi:water-sync',
                    entity_category='config',
                    options_field='x.com.samsung.da.supportedRinseCycles',
                    write_fn=lambda p, rep, href=None: (
@@ -97,7 +106,7 @@ WASHER_SETTINGS = Capability(
         # #22. Self-gates off on plain washers, which never report
         # supportedDryLevel.
         SelectDesc(key='dry_level', field='x.com.samsung.da.dryLevel',
-                   name='Dry level', icon='mdi:tumble-dryer',
+                   icon='mdi:tumble-dryer',
                    entity_category='config',
                    translation_key='washer_dry_level',
                    options_field='x.com.samsung.da.supportedDryLevel',
@@ -157,8 +166,8 @@ def _drum_clean_last_cleaned(rep):
 # 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
+# Label mapping (entity.select.{detergent,softener}_quantity /
+# detergent_water_hardness / softener_concentration in translations/en.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
@@ -259,7 +268,7 @@ def _dosing_low(prefix):
 # auto-release-dry toggles -- only this per-course gating is washer-only, so
 # it stays here rather than in laundry.py (see laundry.bool_option_switch's
 # docstring: it takes a prebuilt validate_fn and has no opinion on it).
-def _bool_option_switch(key, name, icon, prefix, availability_field):
+def _bool_option_switch(key, icon, prefix, availability_field):
     def validate(p, rep, resources):
         """Reject turning on when the selected course's byte in
         `availability_field` isn't 'F0'. Turning off is never blocked. Falls
@@ -281,11 +290,11 @@ def _bool_option_switch(key, name, icon, prefix, availability_field):
         if len(pairs) != len(courses):
             return None
         if pairs[courses.index(current)] != 'F0':
-            return f"{name} isn't available on the selected cycle."
+            return f"{key}_unavailable_for_cycle"
         return None
 
     return bool_option_switch(
-        key, name, icon, prefix,
+        key, icon, prefix,
         entity_category='config', gate_on_presence=True, validate_fn=validate)
 
 
@@ -294,63 +303,61 @@ WASHER_COURSE = Capability(
     entities=(
         cycle_select(translation_key='washer_cycle', icon='mdi:washing-machine',
                      table_href='/st/washercourse/vs/0'),
-        SensorDesc(key='drum_clean_cycles_remaining', name='Drum clean due in',
-                   icon='mdi:washing-machine-alert', unit='cycles',
+        SensorDesc(key='drum_clean_cycles_remaining', unit='cycles',
+                   icon='mdi:washing-machine-alert',
                    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',
+        SensorDesc(key='drum_clean_last_cleaned', device_class='timestamp',
+                   icon='mdi:calendar-clock',
                    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',
+        SelectDesc(key='detergent_quantity', icon='mdi:cup-water',
+                   translation_key='detergent_quantity',
                    entity_category='config',
                    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',
+        SelectDesc(key='detergent_water_hardness', icon='mdi:water-opacity',
+                   translation_key='detergent_water_hardness',
                    entity_category='config',
                    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',
+        SelectDesc(key='softener_quantity', icon='mdi:flask-outline',
+                   translation_key='softener_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',
+        SelectDesc(key='softener_concentration', icon='mdi:flask-plus-outline',
+                   translation_key='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',
+        BinarySensorDesc(key='detergent_low', device_class='problem',
+                         icon='mdi:alert-circle-outline',
                          exists_fn=bool_option_exists('DetergentAlarm'),
                          rep_fn=_dosing_low('DetergentAlarm')),
-        BinarySensorDesc(key='softener_low', name='Softener low',
-                         icon='mdi:alert-circle-outline', device_class='problem',
+        BinarySensorDesc(key='softener_low', device_class='problem',
+                         icon='mdi:alert-circle-outline',
                          exists_fn=bool_option_exists('SoftenerAlarm'),
                          rep_fn=_dosing_low('SoftenerAlarm')),
-        _bool_option_switch('bubble_soak', 'Bubble soak', 'mdi:chart-bubble',
+        _bool_option_switch('bubble_soak', 'mdi:chart-bubble',
                              'BubbleSoak', 'BubbleSoakSet'),
-        _bool_option_switch('pre_wash', 'Pre wash', 'mdi:washing-machine',
+        _bool_option_switch('pre_wash', 'mdi:washing-machine',
                              'PreWashSetting', 'PreWashAvailableSet'),
-        _bool_option_switch('intensive', 'Intensive', 'mdi:washing-machine',
+        _bool_option_switch('intensive', 'mdi:washing-machine',
                              'IntensiveSetting', 'IntensiveAvailableSet'),
     ),
 )

custom_components/localthings/registry/capabilities/water_purifier.py

@@ -0,0 +1,351 @@
+"""Capabilities for the Samsung water-purifier family (TP2X_WATERPURIFIER-class,
+issue #90, model TP2X_WATERPURIFIER_20K; also AILITE_DA-REF-WATERPURIFIER-class,
+issue #196, model RWP70F15ANW/AILITE_WATERPURIFIER_25K).
+
+Resources verified against the issue #90 and #196 diagnostics dumps.
+"""
+from ..batch import is_stub_rep
+from ..capability import Capability
+from ..entities import BinarySensorDesc, NumberDesc, SelectDesc, SensorDesc, SwitchDesc
+from .common import int_or_none, parse_iso_utc as _parse_iso_utc
+
+
+DISPENSE = Capability(
+    href='/setting/waterpurifier/vs/0',
+    poll_tier='warm',
+    entities=(
+        SelectDesc(key='dispense_type', field='x.com.samsung.da.desiredType',
+                   icon='mdi:cup-water',
+                   options_field='x.com.samsung.da.supportedTypes',
+                   write_fn=lambda p, rep, href=None: (
+                       ['setting', 'waterpurifier', 'vs', '0'],
+                       {'x.com.samsung.da.desiredType': p})),
+        # Only a handful of discrete temperatures are selectable (not a
+        # continuous range) -- a select over the live-reported set, not a
+        # number with invented bounds.
+        #
+        # Newer boards (issue #196, RWP70F15ANW) don't populate
+        # supportedHotTemperatures at all -- they report a hotwaterRange
+        # (min/max) and a hotwaterLevel (step count?) instead, with no
+        # confirmed write contract for values off the old preset list. With
+        # an empty options_field result, HA's current_option still returns
+        # the live tempDesiredHotWater, which isn't in the (empty) options
+        # list and renders as "unknown" -- the exact symptom reported. Gate
+        # the entity off entirely when the board doesn't report a supported
+        # list, rather than guess at hotwaterRange/hotwaterLevel's meaning.
+        SelectDesc(key='hot_water_temperature', field='x.com.samsung.da.tempDesiredHotWater',
+                   icon='mdi:thermometer',
+                   entity_category='config',
+                   options_field='x.com.samsung.da.supportedHotTemperatures',
+                   exists_fn=lambda rep, resources: (
+                       is_stub_rep(rep)
+                       or 'x.com.samsung.da.supportedHotTemperatures' in rep),
+                   write_fn=lambda p, rep, href=None: (
+                       ['setting', 'waterpurifier', 'vs', '0'],
+                       {'x.com.samsung.da.tempDesiredHotWater': p})),
+        # Bounds and step come live from the device's own
+        # desiredCapacityRange/capacityResolution fields, not a hardcoded
+        # constant -- see the adding-device-support skill's "never hard-code
+        # the one dump's values" section. No unit is set: capacityUnit reads
+        # "C" on this dump, which can't be right for a volume field, so per
+        # the 'don't guess' rule the unit is left unset rather than assumed
+        # to be mL.
+        NumberDesc(key='dispense_capacity', field='x.com.samsung.da.desiredCapacity',
+                   icon='mdi:cup-water',
+                   value_fn=int_or_none,
+                   range_field='x.com.samsung.da.desiredCapacityRange',
+                   step_fn=lambda rep: int_or_none(
+                       rep.get('x.com.samsung.da.capacityResolution')) or 1,
+                   write_fn=lambda p, rep, href=None: (
+                       ['setting', 'waterpurifier', 'vs', '0'],
+                       {'x.com.samsung.da.desiredCapacity': str(int(round(float(p))))})),
+        BinarySensorDesc(key='pouring', field='x.com.samsung.da.pourStatus',
+                          icon='mdi:cup-water',
+                          value_fn=lambda v: v == 'On'),
+    ),
+)
+
+STATUS = Capability(
+    href='/status/waterpurifier/vs/0',
+    poll_tier='warm',
+    entities=(
+        SensorDesc(key='waterpurifier_status', field='x.com.samsung.da.status',
+                   icon='mdi:water-pump',
+                   entity_category='diagnostic'),
+        BinarySensorDesc(key='filter_door_status', field='x.com.samsung.da.filterDoorStatus',
+                          device_class='door',
+                          entity_category='diagnostic',
+                          value_fn=lambda v: v == 'Open'),
+        SensorDesc(key='sterilize_period', field='x.com.samsung.da.sterilizePeriod',
+                   icon='mdi:calendar-sync',
+                   entity_category='diagnostic'),
+        SensorDesc(key='sterilize_run_time', field='x.com.samsung.da.sterilizeRunTime',
+                   icon='mdi:timer-outline',
+                   entity_category='diagnostic'),
+        SensorDesc(key='sterilize_last_time', device_class='timestamp',
+                   entity_category='diagnostic',
+                   rep_fn=lambda rep: _parse_iso_utc(
+                       rep.get('x.com.samsung.da.sterilizeLastTime'))),
+        SensorDesc(key='sterilize_plan_time', device_class='timestamp',
+                   entity_category='diagnostic',
+                   rep_fn=lambda rep: _parse_iso_utc(
+                       rep.get('x.com.samsung.da.sterilizePlanTime'))),
+        SensorDesc(key='filter_clean_remain_time', field='x.com.samsung.da.filterCleanRemainTime',
+                   icon='mdi:timer-sand',
+                   entity_category='diagnostic'),
+    ),
+)
+
+FAVORITE_CAPACITY = Capability(
+    href='/favorite/capacity/vs/0',
+    poll_tier='cold',
+    entities=(
+        SwitchDesc(key='favorite_capacity_enabled', field='x.com.samsung.da.switchCapacity',
+                   icon='mdi:star-outline',
+                   entity_category='config',
+                   value_fn=lambda v: v == 'On',
+                   write_fn=lambda p, rep, href=None: (
+                       ['favorite', 'capacity', 'vs', '0'],
+                       {'x.com.samsung.da.switchCapacity': 'On' if p == 'On' else 'Off'})),
+        SelectDesc(key='favorite_capacity', field='x.com.samsung.da.defaultCapacity',
+                   icon='mdi:cup-water',
+                   entity_category='config',
+                   options_field='x.com.samsung.da.capacityList',
+                   write_fn=lambda p, rep, href=None: (
+                       ['favorite', 'capacity', 'vs', '0'],
+                       {'x.com.samsung.da.defaultCapacity': p})),
+    ),
+)
+
+# Coffee-capable variant (issue #107) -- a "favorite" supported-list select
+# for the hot water dispensed alongside brewing, same shape as
+# FAVORITE_CAPACITY above.
+
+
+def _status_lock_definitely_lacks_hotwater_field(resources: dict) -> bool:
+    """Three-way read of /status/lock/vs/0's hotwaterLock field, favouring
+    LOCK.hotwater_lock (the primary descriptor) whenever the outcome is
+    still ambiguous:
+
+    - href entirely absent from this device -> definitely no clash, the
+      switchHotwater fallback below may claim the entity.
+    - href present but an unfetched stub ({}) -> outcome pending, *not* a
+      confirmed absence. LOCK's own exists_fn optimistically includes itself
+      through a stub (matching entity.py's default), so returning True here
+      too would register both descriptors -- as SwitchDescs sharing one key,
+      with identical unique_ids -- until the next poll resolves it.
+    - href present and fetched -> the real answer."""
+    rep = resources.get('/status/lock/vs/0')
+    if rep is None:
+        return True
+    if not rep:
+        return False
+    return 'x.com.samsung.da.hotwaterLock' not in rep
+
+
+FAVORITE_HOTWATER = Capability(
+    href='/favorite/hotwater/vs/0',
+    poll_tier='cold',
+    entities=(
+        # Despite the resource/field naming, switchHotwater's value domain is
+        # Locked/Unlocked, not an enable flag (issue #144) -- it's the same
+        # hot-water lock as LOCK.hotwater_lock below, just surfaced through
+        # this href on boards that don't populate /status/lock/vs/0's
+        # hotwaterLock field. Shares that descriptor's key so only one "Hot
+        # water lock" entity ever appears.
+        #
+        # Both halves of this fallback pair need an exists_fn, not just this
+        # one: adapter.flatten() (the coordinator.data source every entity's
+        # is_on reads) only ever honours exists_fn, never entity.py's
+        # implicit "require own field present" default that gates plain
+        # registration. Two same-keyed descriptors with only one of them
+        # gated still both land in flatten()'s output dict -- whichever is
+        # processed last silently wins, decided by device-reported href
+        # order, not by which one is actually correct. So this exists_fn
+        # also re-asserts its own field's presence (switchHotwater), the
+        # gate a bare `field=` used to get for free before it had to share a
+        # key with LOCK's descriptor.
+        SwitchDesc(key='hotwater_lock', field='x.com.samsung.da.switchHotwater',
+                   device_class='lock',
+                   entity_category='config',
+                   value_fn=lambda v: v != 'Unlocked',
+                   exists_fn=lambda rep, resources: (
+                       'x.com.samsung.da.switchHotwater' in rep
+                       and _status_lock_definitely_lacks_hotwater_field(resources)),
+                   write_fn=lambda p, rep, href=None: (
+                       ['favorite', 'hotwater', 'vs', '0'],
+                       {'x.com.samsung.da.switchHotwater': 'Locked' if p == 'On' else 'Unlocked'})),
+        SelectDesc(key='favorite_hotwater_temperature',
+                   field='x.com.samsung.da.favorite.defaultTemperature',
+                   icon='mdi:thermometer',
+                   entity_category='config',
+                   options_field='x.com.samsung.da.favorite.supportedList',
+                   write_fn=lambda p, rep, href=None: (
+                       ['favorite', 'hotwater', 'vs', '0'],
+                       {'x.com.samsung.da.favorite.defaultTemperature': p})),
+    ),
+)
+
+# Coffee-capable variant (issue #107). No 'x.com.samsung.da.' field prefix
+# on this resource, unlike the rest of the water-purifier surface.
+COFFEE = Capability(
+    href='/favorite/coffee/vs/0',
+    poll_tier='warm',
+    entities=(
+        SwitchDesc(key='favorite_coffee_enabled', field='favorite.activate',
+                   icon='mdi:coffee-outline',
+                   entity_category='config',
+                   value_fn=lambda v: v == 'On',
+                   write_fn=lambda p, rep, href=None: (
+                       ['favorite', 'coffee', 'vs', '0'],
+                       {'favorite.activate': 'On' if p == 'On' else 'Off'})),
+        SensorDesc(key='coffee_brew_status', field='brew.status',
+                   icon='mdi:coffee-outline',
+                   entity_category='diagnostic'),
+    ),
+)
+
+# Cup-detection status (issue #196, RWP70F15ANW). Only "UnReady" observed;
+# the full state domain isn't confirmed, so this stays a plain diagnostic
+# sensor rather than an enum with an invented state table.
+CUP_STATE = Capability(
+    href='/cup/state/vs/0',
+    poll_tier='warm',
+    entities=(
+        SensorDesc(key='cup_state', field='water.cup.state',
+                   icon='mdi:cup-outline', entity_category='diagnostic'),
+    ),
+)
+
+# Sound mode/output/volume (issue #196). Shapes echo laundry.py/
+# air_purifier.py's same-named hrefs, but this board's own values differ
+# from both (supportedModes here is voice/fixedTone/mute, not laundry's
+# voice/tone/mute nor air_purifier's mute/buzzer) -- reusing either would
+# reject a live-supported value, so these read the device's own supported
+# list/range like air_purifier's versions do.
+SOUND_MODE = Capability(
+    href='/settings/sound/mode/vs/0',
+    poll_tier='cold',
+    entities=(
+        SelectDesc(key='sound_mode', translation_key='water_purifier_sound_mode',
+                   field='mode',
+                   icon='mdi:volume-high',
+                   entity_category='config',
+                   options_field='supportedModes',
+                   write_fn=lambda p, rep, href=None: (
+                       ['settings', 'sound', 'mode', 'vs', '0'], {'mode': p})),
+    ),
+)
+
+SOUND_OUTPUT = Capability(
+    href='/settings/sound/output/vs/0',
+    poll_tier='cold',
+    entities=(
+        SensorDesc(key='sound_output', field='deviceType',
+                   icon='mdi:volume-high', entity_category='diagnostic'),
+        # No confirmed write contract (no sibling field advertising this as
+        # user-settable) -- surfaced read-only per the 'don't guess' rule.
+        BinarySensorDesc(key='alarm_in_mute', field='alarmInMute',
+                          icon='mdi:volume-mute',
+                          entity_category='diagnostic',
+                          value_fn=lambda v: str(v).lower() == 'true'),
+    ),
+)
+
+SOUND_VOLUME = Capability(
+    href='/settings/sound/volume/vs/0',
+    poll_tier='cold',
+    entities=(
+        NumberDesc(key='sound_volume', field='level',
+                   icon='mdi:volume-medium',
+                   entity_category='config',
+                   native_min_fn=lambda rep: int_or_none(rep.get('minLevel')) or 0,
+                   native_max_fn=lambda rep: int_or_none(rep.get('maxLevel')) or 0,
+                   step_fn=lambda rep: int_or_none(rep.get('resolution')) or 1,
+                   value_fn=int_or_none,
+                   write_fn=lambda p, rep, href=None: (
+                       ['settings', 'sound', 'volume', 'vs', '0'],
+                       {'level': str(int(p))})),
+    ),
+)
+
+# Last-pour statistics (issue #196). last.capacity's unit isn't confirmed
+# (no sibling unit field on this resource, unlike DISPENSE.dispense_capacity
+# which at least has an -- albeit suspect -- capacityUnit) so it's left
+# unitless rather than assumed to be mL.
+STATISTIC_POUR = Capability(
+    href='/statistic/pour/vs/0',
+    poll_tier='cold',
+    entities=(
+        SensorDesc(key='last_pour_type', field='last.type',
+                   icon='mdi:cup-water', entity_category='diagnostic'),
+        SensorDesc(key='last_pour_capacity', field='last.capacity',
+                   icon='mdi:cup-water', entity_category='diagnostic',
+                   value_fn=int_or_none),
+    ),
+)
+
+LOCK = Capability(
+    href='/status/lock/vs/0',
+    poll_tier='warm',
+    entities=(
+        # Shares its key with FAVORITE_HOTWATER's switchHotwater fallback
+        # above (issue #144); see the comment there for why this half also
+        # needs an explicit exists_fn now that the two share a key in
+        # adapter.flatten()'s output. A stub rep ({}) still counts as
+        # "present" here (matches entity.py's own default for a field-less
+        # gate) since the alternative -- treating an unfetched resource as
+        # confirmed-absent -- is what let both descriptors register at once.
+        SwitchDesc(key='hotwater_lock', field='x.com.samsung.da.hotwaterLock',
+                   device_class='lock',
+                   entity_category='config',
+                   value_fn=lambda v: v != 'Unlocked',
+                   exists_fn=lambda rep, resources: (
+                       not rep or 'x.com.samsung.da.hotwaterLock' in rep),
+                   write_fn=lambda p, rep, href=None: (
+                       ['status', 'lock', 'vs', '0'],
+                       {'x.com.samsung.da.hotwaterLock': 'Locked' if p == 'On' else 'Unlocked'})),
+        SwitchDesc(key='coldwater_lock', field='x.com.samsung.da.coldwaterLock',
+                   device_class='lock',
+                   entity_category='config',
+                   value_fn=lambda v: v != 'Unlocked',
+                   write_fn=lambda p, rep, href=None: (
+                       ['status', 'lock', 'vs', '0'],
+                       {'x.com.samsung.da.coldwaterLock': 'Locked' if p == 'On' else 'Unlocked'})),
+        SwitchDesc(key='buzz_lock', field='x.com.samsung.da.buzzLock',
+                   device_class='lock',
+                   entity_category='config',
+                   value_fn=lambda v: v != 'Unlocked',
+                   write_fn=lambda p, rep, href=None: (
+                       ['status', 'lock', 'vs', '0'],
+                       {'x.com.samsung.da.buzzLock': 'Locked' if p == 'On' else 'Unlocked'})),
+    ),
+)
+
+# ---------------------------------------------------------------------------
+# Water-purifier-scoped coverage: hrefs with no user-actionable state or no
+# confirmed contract, following the 'don't guess' rule.
+# ---------------------------------------------------------------------------
+_WP_IGNORED = [
+    # supportedModes carries a single opaque wizard-workflow token
+    # ('HOMECARE_WIZARD_V2') and modes reports a completely different,
+    # unrelated value ('WATERFILTER_DISABLE') not even present in
+    # supportedModes -- internal plumbing, not a real user-facing mode
+    # select. OCF-standard /mode/0 mirrors the same vendor resource but is
+    # already covered by the global ignored.IGNORED (fridge's OCF-native
+    # vacation-mode flag shares that href).
+    '/mode/vs/0',
+    # Static support-flags blob (automation.supported.modes/options) -- no
+    # live "current automation setting" field to expose.
+    '/automation/waterpurifier/vs/0',
+    # Coffee-capable variant (issue #107). All four are static
+    # capability-advertisement blobs or empty -- no live "current recipe" /
+    # "current custom slot" field to expose, unlike /favorite/coffee/vs/0
+    # (COFFEE above), which does carry live brew status.
+    '/brand/recipe/info/vs/0',        # revision + max-brand-count metadata
+    '/coffee/custom/recipe/vs/0',     # publisher.support: allowed custom-recipe slot IDs
+    '/recipe/coffee/vs/0',            # same publisher.support shape, no per-recipe content
+    '/recipe/coffee/deletion/vs/0',   # empty {} on this dump
+]
+
+COVERAGE = [Capability(href=h) for h in _WP_IGNORED]

custom_components/localthings/registry/discovery.py

@@ -18,6 +18,7 @@ from typing import Callable, Iterable, Optional
 
 from .capability import Capability
 from .entities import SamsungEntityDescription
+from .subdevices import MAIN, Subdevice
 
 
 @dataclass
@@ -28,11 +29,17 @@ class BoundEntity:
     instance: str = ''
     key_override: Optional[str] = None
     instance_name: Optional[str] = None
+    # Which logical indoor subdevice (issue #177) this entity belongs to.
+    # `href` above is always the *actual*, on-the-wire href for that
+    # subdevice -- MAIN's
+    # to_actual is the identity transform, so every device with no subdevices
+    # behaves exactly as before this field existed.
+    subdevice: Subdevice = MAIN
 
 
 def _snake_to_title(s: str) -> str:
     """'CUBED_ICE'/'cubed_ice' -> 'Cubed Ice'. Shared with entity.py's
-    _derive_name, which applies the same transform to a state key."""
+    _derive_name, which applies the same transform to an href-derived key."""
     return s.replace('_', ' ').title()
 
 
@@ -57,13 +64,20 @@ def instance_suffix(href: str) -> str:
 
 
 def _bind(cap: Capability, href: str, inst: str, inst_name: Optional[str],
-          key_prefix: Optional[str] = None) -> list[BoundEntity]:
+          key_prefix: Optional[str] = None,
+          subdevice: Subdevice = MAIN) -> list[BoundEntity]:
     """Build one BoundEntity per entity on `cap`, sharing the instance/
-    key-prefix/instance-name computed once by the caller."""
+    key-prefix/instance-name computed once by the caller.
+
+    `href` here is the *canonical* href discover() is iterating over;
+    `subdevice.to_actual` maps it to the real, on-the-wire href the entity
+    actually reads/writes (identity for MAIN, so single-subdevice devices are
+    unaffected -- see subdevices.py)."""
     return [
-        BoundEntity(href=href, capability=cap, desc=desc, instance=inst,
+        BoundEntity(href=subdevice.to_actual(href), capability=cap, desc=desc,
+                    instance=inst,
                     key_override=f'{key_prefix}_{desc.key}' if key_prefix else None,
-                    instance_name=inst_name)
+                    instance_name=inst_name, subdevice=subdevice)
         for desc in cap.entities
     ]
 
@@ -73,7 +87,28 @@ def discover(
     registry: dict[str, list[Capability]],
     pattern_caps: Iterable[Capability] = (),
     log: Optional[Callable[[str], None]] = None,
+    tier_log: Optional[Callable[[str, str], None]] = None,
+    subdevice: Subdevice = MAIN,
 ) -> list[BoundEntity]:
+    """`tier_log(href, poll_tier)` fires for every href a capability actually
+    matches, even a no-entity "coverage-only" capability (see COVERAGE lists
+    in capabilities/*.py) that `_bind()` turns into zero `BoundEntity` rows.
+    Callers that need a href's poll cadence (the coordinator's hot/warm
+    sub-poll and OBSERVE-attempt lists) must use this, not `bound` -- a
+    coverage-only capability's `poll_tier` would otherwise be silently
+    dropped since it never appears in `bound`.
+
+    `resources` is always keyed by *canonical* hrefs -- for a subdevice
+    (issue #177) that means its own canonical view (see
+    subdevices.canonical_view), the same shape as a plain single-subdevice
+    device's resources dict, so registry lookups/rt_filter/match_fn/
+    instance_suffix all behave identically regardless of which subdevice is
+    being discovered.
+    `subdevice` only affects the *href* stamped onto each BoundEntity (via
+    `_bind`, see above) and the href `log`/`tier_log` report -- both the
+    real, subscribable/pollable path, not the canonical one the registry is
+    keyed on.
+    """
     out: list[BoundEntity] = []
 
     for href, rep in resources.items():
@@ -89,8 +124,10 @@ def discover(
             if cap.match_fn is not None and not cap.match_fn(rep, resources):
                 continue
             inst = instance_suffix(href)
-            out.extend(_bind(cap, href, inst, _instance_name(cap, rep)))
+            out.extend(_bind(cap, href, inst, _instance_name(cap, rep), subdevice=subdevice))
             matched = True
+            if tier_log is not None:
+                tier_log(subdevice.to_actual(href), cap.poll_tier)
 
         if matched:
             continue
@@ -107,11 +144,14 @@ def discover(
             # Auto-derive key prefix from href segments (skip digits and 'vs')
             src = href[len(cap.href_prefix):] if (cap.strip_prefix_in_key and cap.href_prefix) else href
             segs = [s for s in src.strip('/').split('/') if s and not s.isdigit() and s != 'vs']
-            out.extend(_bind(cap, href, inst, _instance_name(cap, rep), '_'.join(segs)))
+            out.extend(_bind(cap, href, inst, _instance_name(cap, rep), '_'.join(segs),
+                              subdevice=subdevice))
             matched = True
+            if tier_log is not None:
+                tier_log(subdevice.to_actual(href), cap.poll_tier)
             break
 
         if not matched and not caps and log is not None:
-            log(href)
+            log(subdevice.to_actual(href))
 
     return out

custom_components/localthings/registry/entities.py

@@ -8,14 +8,14 @@ where a description declares one.
 """
 from __future__ import annotations
 
-from dataclasses import dataclass, field
-from typing import Any, Callable, Optional
+from dataclasses import dataclass
+from typing import Any, Callable, Mapping, Optional
 
 WriteFn = Optional[Callable[[Any, dict], "tuple[list[str], dict] | None"]]
-# (payload, rep, resources) -> a human-readable rejection message, or None to
-# allow the write. resources is the coordinator's full href->rep snapshot, for
-# the same cross-resource lookups exists_fn needs (e.g. reading a sibling
-# href's live option list).
+# (payload, rep, resources) -> a translation key, or None to allow the
+# write. resources is the coordinator's full href->rep snapshot, for the same
+# cross-resource lookups exists_fn needs (e.g. reading a sibling href's live
+# option list).
 ValidateFn = Optional[Callable[[Any, dict, dict], "str | None"]]
 
 
@@ -27,13 +27,18 @@ def _identity(v: Any) -> Any:
 class SamsungEntityDescription:
     key: str
     field: str = ''
-    name: Optional[str] = None
+    # Defaults to `key`: entity names and states live in translations/, never
+    # here, so a descriptor only sets this to share one catalog entry across
+    # several descriptors, or to point at a differently-named one.
     translation_key: Any = None  # str | Callable[[dict[str, dict]], Optional[str]]
     # callable form receives the coordinator's full href->rep resource
-    # snapshot and returns the key to use (or None for no translation this
-    # device) -- for a descriptor shared across board generations whose
-    # state-code meaning isn't guaranteed consistent between them; see
-    # laundry.cycle_select's table-id-gated resolver.
+    # snapshot and returns the key to use -- for a descriptor shared across
+    # board generations whose state-code meaning isn't guaranteed consistent
+    # between them; see laundry.cycle_select's table-id-gated resolver.
+    translation_placeholders: Optional[Mapping[str, str]] = None
+    # Dynamic resources such as fridge compartments and ice makers use a
+    # device-provided or href-derived instance label inside a translated name.
+    use_instance_name: bool = False
     icon: Optional[str] = None
     entity_category: Optional[str] = None      # 'diagnostic' | 'config' | None
     enabled_default: bool = True

custom_components/localthings/registry/identity.py

@@ -1,7 +1,7 @@
-"""Read device identity from standard OCF resources (/oic/p, /oic/d)."""
+"""Read device identity from standard OCF resources (/oic/p, /oic/d, /oic/res)."""
 from __future__ import annotations
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Optional
 
 import cbor2
@@ -13,6 +13,8 @@ class DeviceIdentity:
     model: str
     name: str
     serial: Optional[str]
+    device_types: tuple[str, ...] = ()
+    raw: dict[str, dict] = field(default_factory=dict)
 
 
 def _get(sess, path) -> dict:
@@ -26,12 +28,65 @@ def _get(sess, path) -> dict:
     return {}
 
 
+def _get_links(sess, path) -> list:
+    """Like _get, but for /oic/res: a baseline-Interface RETRIEVE on it
+    returns a CBOR array of Link objects (href/rt/if/di/...), not a single
+    Property map."""
+    try:
+        code, pl = sess.get(path, timeout=10.0)
+        if code == 0x45 and pl:
+            body = cbor2.loads(pl)
+            return body if isinstance(body, list) else []
+    except Exception:
+        pass
+    return []
+
+
+def _device_types(d: dict) -> tuple[str, ...]:
+    """/oic/d's `rt` -- the device's own OCF device-type declaration.
+
+    In OCF this is the one standardized "what am I" field: alongside the
+    generic 'oic.wk.d' it carries a concrete type such as 'oic.d.airconditioner'
+    or a Samsung 'x.com.samsung.da.*' equivalent. Nothing routes on it yet --
+    device-type detection currently parses board part numbers out of
+    /information/vs/0's modelNum instead (see registry/by_type/__init__.py) --
+    because no captured dump has ever included it: /device/0 batch responses
+    don't carry /oic/d, and diagnostics didn't report it. It's surfaced in
+    diagnostics so incoming issue reports can tell us whether real hardware
+    populates it usefully enough to route on.
+    """
+    rt = d.get('rt')
+    if isinstance(rt, str):
+        rt = [rt]
+    if not isinstance(rt, (list, tuple)):
+        return ()
+    return tuple(t for t in rt if isinstance(t, str))
+
+
 def read_identity(sess, serial: Optional[str]) -> DeviceIdentity:
     p = _get(sess, ['oic', 'p'])
     d = _get(sess, ['oic', 'd'])
+    # /oic/res is OCF's baseline resource-discovery endpoint: a unicast
+    # RETRIEVE on it returns every Resource/Collection href this endpoint
+    # hosts, not just the one /device/0 seed path the coordinator polls.
+    # Relevant for the OCF "Composite Device" model (issue #177: a single
+    # physical device -- one IP, one /oic/p -- exposing more than one logical
+    # subdevice, each as its own Collection resource, same rt shape as our own
+    # /device/0). This is what registry.subdevices.enumerate_subdevices reads
+    # to find a board's `/device/<n>` siblings (Pattern A -- the reporter's
+    # ARTIK051_DONGLE_FAC_18K) -- that probing, plus the /device/1 and
+    # /device/2 speculative fallback it used to run right here on every
+    # _connect_session (including every reconnect), moved to that module so
+    # it only runs once, at first discovery, instead of on every reconnect.
+    res = _get_links(sess, ['oic', 'res'])
     return DeviceIdentity(
         manufacturer=p.get('mnmn') or 'Samsung',
         model=p.get('mnmo') or '',
         name=d.get('n') or '',
         serial=serial,
+        device_types=_device_types(d),
+        # Kept whole rather than field-by-field: these resources are outside
+        # the /device/0 dump diagnostics already captures, and we don't yet
+        # know which of their fields will turn out to identify a device type.
+        raw={'/oic/p': p, '/oic/d': d, '/oic/res': res},
     )

custom_components/localthings/registry/redact.py

@@ -19,9 +19,26 @@ _SENSITIVE_SUBSTRINGS = (
     'userid', 'deviceid', 'uuid', 'duid', 'password', 'secret',
 )
 
+# Matched whole, not as substrings. OCF's /oic/d and /oic/p identify the unit
+# with bare one- and two-letter keys that the rules above cannot see, being
+# far too short to match on -- 'di' alone is a substring of 'condition',
+# 'display', 'dispenser' and plenty of other ordinary appliance fields:
+#
+#   'di' -- device UUID, 'pi' -- platform UUID. As identifying as the serial
+#           number above.
+#   'n'  -- /oic/d's device name. Free text the owner can set from the
+#           SmartThings app, so it may well carry a person's name. Nothing
+#           in the /device/0 dump has ever exposed it; it only became
+#           reachable when diagnostics started reporting /oic/d, and the
+#           device-type signal we actually want from that resource is `rt`,
+#           which is not redacted.
+_SENSITIVE_EXACT = frozenset({'di', 'pi', 'n'})
+
 
 def _is_sensitive_key(key: str) -> bool:
     lowered = key.lower()
+    if lowered in _SENSITIVE_EXACT:
+        return True
     return any(s in lowered for s in _SENSITIVE_SUBSTRINGS)
 
 

custom_components/localthings/registry/subdevices.py

@@ -0,0 +1,611 @@
+"""Subdevice ("composite device") support for one physical connection exposing
+more than one logical indoor subdevice -- issue #177.
+
+Two reporters, two different board families, two genuinely different
+mechanisms for exposing a second indoor subdevice over one IP / one DTLS
+session (see DESIGN-177.md section 1 for the full evidence trail; the two
+diagnostics dumps this was built against come from the Pattern A and
+Pattern B reporters, respectively -- they each filed one of the two
+reports this module unifies):
+
+Pattern A -- indexed siblings (`ARTIK051_DONGLE_FAC_18K`, that reporter's
+board). `/oic/res` lists three complete parallel resource sets whose
+trailing path segment is the index (`/mode/vs/0`, `/mode/vs/1`,
+`/mode/vs/2`, ... on both OCF-standard and vendor hrefs), and `/device/0`'s
+batch carries only the index-0 hrefs -- the sibling subdevices are
+reachable only via their own `/device/<n>` collection.
+
+Pattern B -- UUID-prefixed tree (`TP2X_FAC_BORA_21K`, that reporter's board).
+`/oic/res` hides the whole appliance tree; `/device/0`'s batch instead
+carries `x.com.samsung.da.subdeviceIdList` on `/subdevices/vs/0`, and that
+same UUID appears as a literal href prefix in `/oic/res`
+(`/<uuid>/file/list/vs/0`, ...). What's actually been confirmed live on
+that reporter's unit is narrower than early issue #177 writeups suggested: a
+single individual `GET /<uuid>/information/vs/0` was read by hand through
+the debug panel and came back carrying a different model/serial than the
+master (`TP2X_FAC_BORA_RAC_21K`, the wall-mounted subdevice, vs. the
+master's `TP2X_FAC_BORA_21K`, the floor subdevice) -- real evidence a
+second subdevice exists at that prefix, but not evidence that `GET
+/<uuid>/device/0` (the Collection batch PR #199 built this pattern's seed
+around) itself returns anything. Issue #205, the same unit on a later
+version, is that assumption failing: `/<uuid>/device/0` comes back empty.
+So `enumerate_subdevices` tries it first (a future board might genuinely
+expose it) and falls back, when it's empty, to probing every href the
+master itself answered this cycle individually under the UUID prefix --
+the only thing ever actually confirmed to work for this pattern -- on the
+assumption that a composite device's siblings share the master's resource
+surface. See `Subdevice.flat_hrefs`.
+
+Both are "the same thing wearing different clothes": a logical subdevice is a
+seed collection path to poll, plus an href transform between the canonical
+href the registry knows (`/mode/vs/0`) and the actual on-the-wire href. The
+detection signals don't overlap on either captured board (the Pattern A
+reporter's has no `/subdevices/vs/0` at all; the Pattern B reporter's has
+no `/device/1`), so no disambiguation logic is needed --
+`enumerate_subdevices` checks both and materializes any candidate whose
+seed answers with a non-empty batch.
+
+A non-empty seed batch is necessary but not sufficient for the *candidate*
+to actually be a live second subdevice, though: the Pattern A reporter's
+own board also has a `/device/2` -- a third, unused SmartThings slot --
+that answers with the exact same 14-href shape as the real `/device/1`
+sibling, populated with three constant/echoed/shape-only reps (a region
+code identical to every other subdevice's, an /information rep echoing the
+*same* model string as subdevice 1, and a /temperatures items[] entry with
+an id/description but no current/desired/minimum/maximum reading) and
+nothing resembling live climate state. Gating on *resource* shape/hrefs
+turned out to be the wrong layer -- it would need per-family domain
+knowledge (which hrefs mean "in use" for a washer's second drum, a
+fridge's second compartment, ...) baked into a registry field before any
+of those families could use this module at all. `discover_partitioned`
+instead gates at the *entity* layer, after discovery+flattening: a
+candidate is only kept if it produced at least one *primary* (no
+`entity_category`), non-meter bound entity whose flattened value isn't
+`None` -- e.g. the Pattern A reporter's /device/2 does flatten to an
+`alarm_code` value, but that entity is diagnostic-category and derived from
+an empty /alarms/vs/2, so it doesn't count. This reuses the same
+primary/config/diagnostic taxonomy every registry already declares (see the
+adding-device-support skill's entity-taxonomy section) instead of adding a
+second, parallel domain-knowledge mechanism.
+
+The meter carve-out is issue #214, and it's the same "an unused slot still
+answers *something*" problem one layer further in: that reporter's
+single-split ARTIK051_KRAC_18K has a /device/1 whose operational reps are
+all empty {} -- the /device/2 shape above -- but which also reports a
+populated /energy/consumption/vs/1, a whole-appliance lifetime kWh counter
+that materialized the slot as a phantom second air conditioner. See
+`_has_live_primary_entity`.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Callable, Optional
+
+import cbor2
+
+from .batch import parse_device0_batch
+
+_INDEXED_HREF_RE = re.compile(r'^/device/(\d+)$')
+
+# Speculative /device/<n> siblings probed when /oic/res doesn't reveal a
+# second logical subdevice's Collection on this board (moved here from
+# identity.py, issue #177 -- see enumerate_subdevices' docstring for why: the
+# old read_identity fired these two extra RETRIEVEs on *every* _connect_session,
+# including every reconnect, for information enumeration only needs once).
+# Same bound as before: a plain, tolerated-404 RETRIEVE, not the kind of
+# guess the write-contract 'don't guess' rule is about. Widen only if a real
+# board ever turns out to need more than two siblings.
+_SPECULATIVE_DEVICE_INDICES = (1, 2)
+
+
+@dataclass(frozen=True)
+class Subdevice:
+    """One logical indoor subdevice reachable over a single physical
+    connection.
+
+    `kind='main'` is the subdevice this config entry actually connects to and
+    always exists (see MAIN below) -- its `to_actual`/`to_canonical` are the
+    identity transform, so every existing single-subdevice device keeps
+    behaving exactly as it did before this module existed. `'indexed'`/
+    `'prefixed'` are Pattern A/B above; `key` is the trailing index string
+    ('1', '2', ...) or the full subdevice UUID, and `seed_path` is the
+    Collection href (as path segments) whose batch response
+    enumerates/refreshes that subdevice.
+
+    `flat_hrefs` is non-empty only for a 'prefixed' subdevice that doesn't
+    expose its own Collection at `seed_path` (issue #205 -- not even
+    TP2X_FAC_BORA_21K, the board this pattern was built against, always
+    does). When set, `seed_path` is meaningless (left as `()`) and this
+    subdevice's state comes from GETting each of these canonical hrefs
+    individually under its prefix instead of one Collection batch -- see
+    enumerate_subdevices' fallback and coordinator._poll_subdevice_seed.
+    """
+    kind: str            # 'main' | 'indexed' | 'prefixed'
+    key: str             # ''    | '1'       | '6c2dff6d-ee5c-dad1-6a5e-000000000001'
+    seed_path: tuple[str, ...]
+    flat_hrefs: tuple[str, ...] = ()
+
+    def to_actual(self, canonical: str) -> str:
+        """Canonical registry href (e.g. '/mode/vs/0') -> the real,
+        on-the-wire href for this subdevice."""
+        if self.kind == 'indexed':
+            head, sep, tail = canonical.rpartition('/')
+            # Only the index-0 trailing segment is ours to rewrite --
+            # deliberately not a "replace any trailing digit" rule, which
+            # would misread a genuine multi-instance resource (the fridge's
+            # pattern-cap hrefs, e.g. '/door/vs/1') as a subdevice's. No
+            # registry declares a non-zero trailing index today and no
+            # fixture in the corpus contains one (verified across the whole
+            # corpus), so the strict rule costs nothing.
+            if tail == '0':
+                return f'{head}{sep}{self.key}'
+            return canonical
+        if self.kind == 'prefixed':
+            return f'/{self.key}{canonical}'
+        return canonical
+
+    def to_canonical(self, actual: str) -> Optional[str]:
+        """Inverse of to_actual, or None when `actual` isn't this subdevice's."""
+        if self.kind == 'indexed':
+            head, sep, tail = actual.rpartition('/')
+            if tail == self.key:
+                return f'{head}{sep}0'
+            return None
+        if self.kind == 'prefixed':
+            prefix = f'/{self.key}'
+            if actual.startswith(prefix + '/'):
+                return actual[len(prefix):]
+            return None
+        return actual
+
+    def owns(self, actual: str) -> bool:
+        """True if `actual` belongs to this subdevice's namespace. MAIN never
+        "owns" anything by this definition -- it gets whatever's left after
+        every other subdevice's hrefs are excluded (see canonical_view)."""
+        if self.kind == 'main':
+            return False
+        return self.to_canonical(actual) is not None
+
+    @property
+    def key_prefix(self) -> str:
+        """Prefix that guarantees a unique entity key/unique_id (see
+        adapter._key). '' for MAIN -- the master's flattened state
+        keys must stay byte-identical to every device this integration
+        shipped before issue #177, so no golden file changes. The full
+        subdevice UUID is used verbatim (non-alphanumerics stripped, not
+        truncated or replaced with an ordinal) because it's device-reported
+        and stable across reconnects/restarts, unlike an ordinal assigned by
+        enumeration order -- and it never appears in a user-visible string
+        (see DESIGN-177.md section 6): HA derives the visible entity_id from
+        the device name + entity name, not from unique_id.
+        """
+        if self.kind == 'indexed':
+            return f'subdevice{self.key}_'
+        if self.kind == 'prefixed':
+            slug = re.sub(r'[^a-zA-Z0-9]', '', self.key)
+            return f'subdevice_{slug}_'
+        return ''
+
+
+MAIN = Subdevice(kind='main', key='', seed_path=('device', '0'))
+
+
+def canonical_view(
+    subdevice: Subdevice, resources: dict[str, dict], subdevices: list['Subdevice'],
+) -> dict[str, dict]:
+    """Rewrite `resources` (real, on-the-wire hrefs) into `subdevice`'s own
+    canonical namespace -- what discover()/exists_fn/rep_fn/is_legacy_board
+    and friends are written against.
+
+    For MAIN this is the snapshot *minus* every href owned by one of the
+    other subdevices in `subdevices` -- otherwise a sibling's own `/mode/vs/1`
+    would leak into the master's view under the same canonical key
+    ('/mode/vs/0') that the master's actual `/mode/vs/0` also maps to,
+    silently mixing two subdevices' state together. For an indexed/prefixed
+    subdevice it's the reverse: only the hrefs that subdevice owns, rewritten
+    back through `to_canonical`.
+
+    `subdevices` may or may not include MAIN itself -- MAIN.owns() is always
+    False, so including it is harmless.
+    """
+    if subdevice.kind == 'main':
+        owned_elsewhere = {
+            href for href in resources
+            if any(su.owns(href) for su in subdevices)
+        }
+        return {h: r for h, r in resources.items() if h not in owned_elsewhere}
+    return {
+        canon: resources[actual]
+        for actual in resources
+        if (canon := subdevice.to_canonical(actual)) is not None
+    }
+
+
+def normalize_seed_batch(subdevice: Subdevice, batch: dict[str, dict]) -> dict[str, dict]:
+    """Real, on-the-wire hrefs from one subdevice's seed-collection batch,
+    normalized so every href actually carries this subdevice's prefix/index.
+
+    Indexed subdevices need no change -- the device echoes the real `/x/<n>`
+    href in its own `/device/<n>` batch (confirmed against the Pattern A
+    reporter's dump). A prefixed subdevice's batch entries may or may not
+    already carry the `/<id>` prefix (unconfirmed which -- the Pattern B
+    reporter's board was never probed live before the subdevice id was
+    known), so it's added when missing.
+    """
+    if subdevice.kind != 'prefixed':
+        return batch
+    prefix = f'/{subdevice.key}'
+    return {
+        (href if href.startswith(prefix + '/') else f'{prefix}{href}'): rep
+        for href, rep in batch.items()
+    }
+
+
+def _iter_oic_res_hrefs(oic_res):
+    """Flatten /oic/res's raw shape into a flat iterable of link dicts.
+
+    Both captured dumps group links by `di` (`[{'di': ..., 'links': [...]}]`
+    -- see identity.py's read_identity/_get_links), so that's the shape
+    handled here. Tolerant of a flat link-list too (nothing in the OCF spec
+    rules it out, and _get_links' own posture already treats any list-shaped
+    body as possible) and of anything else by yielding nothing.
+    """
+    for entry in (oic_res or []):
+        if not isinstance(entry, dict):
+            continue
+        if 'links' in entry:
+            for link in entry.get('links') or []:
+                if isinstance(link, dict):
+                    yield link
+        elif 'href' in entry:
+            yield entry
+
+
+def _seed_href(path_segs: tuple[str, ...]) -> str:
+    """('device', '1') -> '/device/1' -- the leading-slash href form
+    `probe_log` and diagnostics report, built from the path-segment form
+    `sess.get` takes."""
+    return '/' + '/'.join(path_segs)
+
+
+def _get_raw(sess, path_segs: tuple[str, ...]):
+    """GET `path_segs` and CBOR-decode the payload, or None on any
+    missing/malformed response (a 4.04, a timeout, an empty payload) --
+    shared tolerated-absence posture for both callers below, which differ
+    only in which body shape they accept."""
+    try:
+        code, pl = sess.get(list(path_segs), timeout=10.0)
+        if code == 0x45 and pl:
+            return cbor2.loads(pl)
+    except Exception:
+        pass
+    return None
+
+
+def _get_batch(sess, path_segs: tuple[str, ...]) -> dict[str, dict]:
+    """GET a Samsung Collection resource and parse it the same way
+    /device/0 itself is parsed (parse_device0_batch): a [devcol-rep,
+    {href, rep}, ...] CBOR list, not a bare Property map."""
+    body = _get_raw(sess, path_segs)
+    return parse_device0_batch(body) if isinstance(body, list) else {}
+
+
+def _get_property(sess, path_segs: tuple[str, ...]) -> dict:
+    """GET a plain OCF Property-map resource (a bare dict, not a Collection
+    batch). Used for `/multidevice/vs/0` (issue #177 follow-up): listed in
+    `/oic/res` on the Pattern A reporter's board but absent from
+    `/device/0`'s batch, so it needs its own RETRIEVE, and it answers a
+    single Property map, not a [devcol-rep, ...] list."""
+    body = _get_raw(sess, path_segs)
+    return body if isinstance(body, dict) else {}
+
+
+def enumerate_subdevices(
+    sess,
+    resources: dict[str, dict],
+    oic_res_links,
+    probe_log: Optional[Callable[[str, bool], None]] = None,
+) -> tuple[list['Subdevice'], dict[str, dict]]:
+    """Discover every sibling indoor subdevice reachable over `sess`'s
+    connection.
+
+    Runs once, at first discovery, in an executor, under the coordinator's
+    session lock -- every GET here is a plain RETRIEVE (the write-contract
+    'don't guess' rule doesn't apply to reading an extra resource to find
+    out whether it's there). Returns the *candidate* subdevices and the resources
+    already fetched while probing them (already normalized to real hrefs),
+    so the coordinator's first discovery poll doesn't need to re-poll them.
+
+    `probe_log(seed_href, found)` fires for every seed attempted, whether or
+    not it answered -- so diagnostics (see diagnostics.py's subdevice_probes)
+    can tell "checked, nothing there" apart from "never checked", the same
+    posture the speculative-probe code this replaces used to document in
+    identity.py.
+
+    Every candidate whose seed answers with a non-empty batch is returned
+    here -- this function has no way to tell a real sibling from an unused
+    SmartThings slot that merely answers the same shape (the Pattern A
+    reporter's `/device/2`); that requires discovering+flattening the
+    candidate's own entities first, which is `discover_partitioned`'s job,
+    not this one's.
+    See this module's docstring.
+    """
+    subdevices: list[Subdevice] = []
+    fetched: dict[str, dict] = {}
+
+    def _probed(seed_href: str, batch: dict) -> None:
+        if probe_log is not None:
+            probe_log(seed_href, bool(batch))
+
+    # --- Pattern B: UUID-prefixed tree (TP2X_FAC_BORA_21K) ------------------
+    raw_ids = (resources.get('/subdevices/vs/0') or {}).get(
+        'x.com.samsung.da.subdeviceIdList')
+    # Tolerate anything but a list of strings -- this field is redaction-prone
+    # (it matches the 'deviceid' substring rule in redact.py) and the existing
+    # airconditioner_fac_bora fixture carries the literal string
+    # '**REDACTED**'/'REDACTED' there. That must yield zero subdevices, not a
+    # crash -- issue #177 is additive, it must never break an already-working
+    # single-climate-entity device.
+    ids = raw_ids if isinstance(raw_ids, list) else []
+    for sub_id in sorted(i for i in ids if isinstance(i, str) and i):
+        seed = (sub_id, 'device', '0')
+        batch = _get_batch(sess, seed)
+        _probed(_seed_href(seed), batch)
+        if batch:
+            subdevice = Subdevice(kind='prefixed', key=sub_id, seed_path=seed)
+            fetched.update(normalize_seed_batch(subdevice, batch))
+            subdevices.append(subdevice)
+            continue
+        # Fallback (issue #205): TP2X_FAC_BORA_21K itself -- the board this
+        # pattern was built against -- turns out not to always expose its own
+        # `/<uuid>/device/0` Collection either, so "every prefixed subdevice
+        # has one" doesn't hold even on the reference hardware. With no
+        # Collection to seed from and no per-UUID entry in `/oic/res` to
+        # enumerate hrefs from, the only signal left is that a composite
+        # device's siblings are the same physical board family as the
+        # subdevice this config entry already talks to -- so probe every
+        # href the master itself answered this cycle, individually, under
+        # this UUID's prefix, and keep whichever ones answer. Each is a
+        # plain tolerated-404 RETRIEVE, same posture as every other probe in
+        # this function.
+        #
+        # Known gap, not yet guarded against: a firmware that answers *any*
+        # request under an unrecognized prefix (echoing the master's own
+        # state back rather than 4.04ing) would pass every one of these
+        # probes and, if the echoed state also clears discover_partitioned's
+        # liveness gate, materialize a phantom duplicate of the master
+        # rather than a real sibling. Every board seen so far genuinely
+        # 4.04s on paths it doesn't own (issue #205's own unit answered only
+        # 1 of 31 probes), so this hasn't been built -- the one place it
+        # could hook in later is comparing a candidate's confirmed reps
+        # against the master's own values for those same canonical hrefs.
+        flat_hrefs = []
+        first = True
+        for href in sorted(resources):
+            if not first:
+                sess.pace()
+            first = False
+            actual = f'/{sub_id}{href}'
+            rep = _get_property(sess, tuple(actual.strip('/').split('/')))
+            _probed(actual, bool(rep))
+            if rep:
+                flat_hrefs.append(href)
+                fetched[actual] = rep
+        if not flat_hrefs:
+            continue
+        subdevices.append(Subdevice(
+            kind='prefixed', key=sub_id, seed_path=(),
+            flat_hrefs=tuple(flat_hrefs),
+        ))
+
+    # --- Pattern A: indexed siblings (ARTIK051_DONGLE_FAC_18K) --------------
+    indices = sorted({
+        int(m.group(1))
+        for link in _iter_oic_res_hrefs(oic_res_links)
+        for m in [_INDEXED_HREF_RE.match(link.get('href', ''))]
+        if m and int(m.group(1)) >= 1
+    })
+    if not indices:
+        # A board that hides its whole tree from /oic/res (Pattern B's
+        # reporter board does this too, but it has no /device/<n> to find
+        # regardless) gives us nothing to enumerate from -- fall back to the
+        # bounded speculative probe this replaces from identity.py.
+        indices = list(_SPECULATIVE_DEVICE_INDICES)
+    for n in indices:
+        seed = ('device', str(n))
+        batch = _get_batch(sess, seed)
+        _probed(_seed_href(seed), batch)
+        if not batch:
+            continue
+        subdevice = Subdevice(kind='indexed', key=str(n), seed_path=seed)
+        fetched.update(batch)  # already real /x/<n> hrefs, no normalization needed
+        subdevices.append(subdevice)
+
+    # /multidevice/vs/0 (issue #177 follow-up): the Pattern A reporter's
+    # board lists it in /oic/res but it never appears in /device/0's batch,
+    # so it needs its own RETRIEVE. It's a plain corroborating count
+    # (x.com.samsung.da.numofsubdevice), confirmed read-only (a write
+    # attempt returned CoAP 4.00) -- captured for diagnostics only, folded
+    # into the merged resources dict like any other href (see
+    # airconditioner._AC_IGNORED, which is what keeps it from surfacing as
+    # an unbound-href gap). NOT a gate: discover_partitioned's entity-level
+    # liveness check decides materialization correctly without it, and only
+    # this one board family is known to expose it at all. Whether it agrees
+    # with the number of subdevices actually materialized is the
+    # coordinator's call to log (it owns the logger; this module doesn't),
+    # not this function's.
+    multidevice_seed = ('multidevice', 'vs', '0')
+    multidevice = _get_property(sess, multidevice_seed)
+    _probed(_seed_href(multidevice_seed), multidevice)
+    if multidevice:
+        fetched['/multidevice/vs/0'] = multidevice
+
+    return subdevices, fetched
+
+
+@dataclass(frozen=True)
+class SkippedSubdevice:
+    """A candidate `enumerate_subdevices` found whose seed answered, but that
+    `discover_partitioned`'s entity-level liveness gate rejected -- an
+    unused SmartThings slot (the Pattern A reporter's `/device/2`), not a
+    real second subdevice. Kept around (rather than silently dropped) so a
+    caller can log/report what was skipped and why."""
+    subdevice: Subdevice
+    hrefs: tuple[str, ...]
+
+
+# Sensor kinds whose value is a running total the *appliance* keeps rather
+# than a reading of the subdevice's own hardware -- excluded from the
+# liveness gate below (issue #214). HA's own running-total state classes
+# cover most of them; the consumption device classes catch the rest, since a
+# descriptor may deliberately declare no state_class (common.ENERGY_METER's
+# monthly totals reset at each billing boundary, so they aren't
+# `total_increasing`).
+_METER_STATE_CLASSES = frozenset({'total', 'total_increasing'})
+_METER_DEVICE_CLASSES = frozenset({'energy', 'water', 'gas'})
+
+
+def _is_meter(desc) -> bool:
+    """True for a cumulative consumption/counter descriptor -- see the two
+    constants above. Only SensorDesc carries either attribute; everything
+    else answers False through the getattr defaults."""
+    return (
+        getattr(desc, 'state_class', None) in _METER_STATE_CLASSES
+        or getattr(desc, 'device_class', None) in _METER_DEVICE_CLASSES
+    )
+
+
+def _has_live_primary_entity(bound, state: dict) -> bool:
+    """True if flattening `bound` (one candidate subdevice's BoundEntity
+    list) produced at least one non-`None` value for a *primary* entity --
+    `entity_category` unset, HA's own "the user acts on or watches this"
+    tier (see the adding-device-support skill's entity-taxonomy section) --
+    that isn't a cumulative meter (`_is_meter`).
+
+    This is the materialization gate itself (see this module's docstring).
+    Two exclusions, both for the same reason -- the question this answers is
+    "is a physical subdevice installed at this slot?", and neither kind of
+    value can speak to it:
+
+    - **Non-primary entities.** The Pattern A reporter's `/device/2` does
+      flatten to one non-`None` value (`alarm_code`), but that entity is
+      `diagnostic`-category and derived from an empty `/alarms/vs/2` -- a
+      config/diagnostic entity reading "something" proves nothing about
+      whether hardware is there.
+    - **Cumulative meters** (issue #214). An unused slot on the issue #214
+      reporter's ARTIK051_KRAC_18K reports `/energy/consumption/vs/1` with a
+      populated `cumulativePower` while every operational rep on it
+      (`/power/1`, `/mode/1`, `/mode/vs/1`, `/temperature/current/1`,
+      `/temperature/desired/1`, `/airflow/1`, `/humidity/1`) is empty `{}` --
+      i.e. exactly the Pattern A `/device/2` shape plus a lifetime kWh
+      counter. That counter got the slot materialized as a phantom second
+      air conditioner. A single-split AC has one compressor and one energy
+      meter, so a whole-appliance total showing up under a second index is
+      the appliance's own bookkeeping, not evidence of a second indoor unit.
+      A genuinely installed subdevice reports its own operational state too
+      (the Pattern A reporter's real `/device/1` reports power, mode, both
+      temperatures and airflow), and that state is what still passes this
+      gate.
+    """
+    from .adapter import _key  # see discover_partitioned's deferred-import note
+    return any(
+        not b.desc.entity_category and not _is_meter(b.desc)
+        and state.get(_key(b)) is not None
+        for b in bound
+    )
+
+
+def discover_partitioned(
+    resources: dict[str, dict],
+    subdevices: list['Subdevice'],
+    resolve_registry: Callable[[dict], object],
+    fallback_capabilities: dict,
+    log: Optional[Callable[[str], None]] = None,
+    tier_log: Optional[Callable[[str, str], None]] = None,
+):
+    """Bind every href in `resources` (the merged, real-href snapshot -- main
+    plus every enumerated subdevice's seed) to entities, partitioned by which
+    subdevice owns it.
+
+    Main pass runs over hrefs owned by no subdevice -- otherwise every
+    `/mode/vs/1` would land in `unbound_hrefs` too (nothing in the main
+    device's registry claims that literal href) and raise a spurious
+    coverage-gap repair. Then one pass per *candidate* subdevice over its own
+    canonical view, resolving that subdevice's own device type from its own
+    `/information/vs/0` when it reports one (e.g. the Pattern B reporter's
+    wall subdevice reports `TP2X_FAC_BORA_RAC_21K` -> the 'RAC' board token ->
+    airconditioner), falling back to the master's registry otherwise --
+    every AC family shares the same resource surface, and a sibling that
+    fails to answer its own identity resource is still the same appliance
+    type as the subdevice this config entry was set up against.
+
+    Each candidate is discovered and flattened *twice*: once silently to
+    evaluate `_has_live_primary_entity` (this module's materialization
+    gate -- see its docstring and this module's own), and, only if that
+    passes, a second time with `log`/`tier_log` wired so its coverage gaps
+    and poll tiers actually count. A candidate that fails the gate
+    contributes nothing at all -- no bound entities, no unbound-href
+    report, no hot/warm href -- as if it had never answered its seed.
+    Discovering an unused slot's small, fixed resource set twice at
+    first-discovery time only is a non-issue; getting a phantom subdevice
+    silently counted into unbound_hrefs or hot/warm tiers is not.
+
+    Returns `(bound, device_type_name, materialized, skipped)`:
+    - `bound`: the concatenated BoundEntity list (main + every materialized
+      subdevice).
+    - `device_type_name`: the *master's* resolved device type (used for
+      logging/device naming; each subdevice's own resolved type only affects
+      which capabilities bind its hrefs, not this).
+    - `materialized`: the subset of `subdevices` that passed the gate, in the
+      same order -- what the caller should keep as its live subdevice roster
+      going forward (poll seeds, canonical_resources, device_info_for, ...).
+    - `skipped`: `SkippedSubdevice` entries for every candidate that didn't.
+    """
+    # Deferred import: discovery.py imports Subdevice/MAIN from this module at
+    # module scope, so importing discover() back here at module scope would
+    # be a circular import. By the time this function actually runs both
+    # modules are fully loaded. adapter.py imports discovery.py, so the same
+    # applies to flatten()/_key().
+    from .adapter import flatten
+    from .discovery import discover
+
+    # Same computation canonical_view does for MAIN (snapshot minus every
+    # other subdevice's owned hrefs) -- reuse it rather than re-deriving
+    # owned_elsewhere here too.
+    main_view = canonical_view(MAIN, resources, subdevices)
+
+    reg = resolve_registry(main_view)
+    caps, pats = (
+        (reg.capabilities, reg.pattern_capabilities) if reg is not None
+        else (fallback_capabilities, [])
+    )
+    # MAIN is never gated -- the config entry's own physical connection
+    # always materializes regardless of what its entities' values are.
+    bound = discover(main_view, caps, pats, log=log, tier_log=tier_log, subdevice=MAIN)
+    device_type_name = reg.name if reg is not None else None
+
+    materialized: list[Subdevice] = []
+    skipped: list[SkippedSubdevice] = []
+
+    for su in subdevices:
+        view = canonical_view(su, resources, subdevices)
+        su_reg = resolve_registry(view) or reg
+        su_caps, su_pats = (
+            (su_reg.capabilities, su_reg.pattern_capabilities) if su_reg is not None
+            else (fallback_capabilities, [])
+        )
+        probe_bound = discover(view, su_caps, su_pats, subdevice=su)
+        probe_state = flatten(probe_bound, resources)
+        if _has_live_primary_entity(probe_bound, probe_state):
+            materialized.append(su)
+            bound = bound + discover(
+                view, su_caps, su_pats, log=log, tier_log=tier_log, subdevice=su,
+            )
+        else:
+            skipped.append(SkippedSubdevice(
+                subdevice=su,
+                hrefs=tuple(sorted({b.href for b in probe_bound})),
+            ))
+
+    return bound, device_type_name, materialized, skipped

custom_components/localthings/select.py

@@ -11,6 +11,7 @@ from homeassistant.helpers.entity_platform import AddEntitiesCallback
 
 from .registry.entities import SelectDesc
 
+from .catalog import translated_states
 from .const import DOMAIN
 from .coordinator import LocalThingsCoordinator
 from .entity import LocalThingsEntity, _is_included
@@ -32,6 +33,22 @@ async def async_setup_entry(
 _CAMEL_BOUNDARY_RE = re.compile(r'(?<=[a-z0-9])(?=[A-Z])')
 
 
+def _translation_state(value: str, known: frozenset[str]) -> str | None:
+    """Return the catalog state `value` normalizes to, else None.
+
+    Samsung reports options in whatever casing the resource uses
+    ('Rinse_Hold', 'SpTtypeBeerDrinks', '1b'); Home Assistant looks state
+    translations up by a lowercase key. Only values the catalog actually
+    knows are normalized -- an unrecognized (or future) vendor value keeps
+    its own readable form rather than becoming an untranslatable slug.
+    """
+    direct = value.lower().replace(' ', '_')
+    if direct in known:
+        return direct
+    snake = _CAMEL_BOUNDARY_RE.sub('_', value).lower().replace(' ', '_')
+    return snake if snake in known else None
+
+
 def _display(value, translation_key: Optional[str]):
     """Turn a raw device option/state value into what's shown in the UI.
 
@@ -40,13 +57,13 @@ def _display(value, translation_key: Optional[str]):
     callers pass the resolved value, e.g. self.translation_key, not
     the raw descriptor field).
 
-    An entity with a translation_key looks its state up in strings.json,
-    and hassfest requires those keys to be lowercase -- so those values
+    An entity with a translation_key looks its state up in the shipped
+    translation catalog, whose state keys are lowercase -- so those values
     must be lowercased exactly to match, and the device still expects
     that same raw casing back on write (callers map the displayed value
     back to raw via _raw_options()).
 
-    Everything else has no strings.json lookup, so there's no reason to
+    Everything else has no catalog lookup, so there's no reason to
     destroy the device's own casing. Only two cosmetic fixups apply: a
     fully lowercase device-native token (e.g. "voice") is title-cased,
     and a PascalCase token (e.g. "ExtraHigh") gets a space inserted at
@@ -57,7 +74,15 @@ def _display(value, translation_key: Optional[str]):
     if not isinstance(value, str):
         return value
     if translation_key:
-        return value.lower()
+        known = translated_states('select', translation_key)
+        if not known:
+            # No state table for this key: either the entity isn't translated
+            # at all, or its name is translated but its options deliberately
+            # aren't (an unrecognized course table, say). Either way the
+            # opaque device value is the best thing to show.
+            return value
+        if translated := _translation_state(value, known):
+            return translated
     if value.islower():
         return value.replace('_', ' ').title()
     return _CAMEL_BOUNDARY_RE.sub(' ', value)
@@ -79,7 +104,9 @@ class LocalThingsSelect(LocalThingsEntity, SelectEntity):
             # list decoded from a sibling resource. There is no static
             # fallback: when that resource isn't populated the callable
             # returns [] and the entity's exists_fn suppresses it entirely.
-            return list(desc.options(self.coordinator.last_resources) or [])
+            # This entity's own subdevice's canonical view (issue #177), not
+            # the raw actual-href snapshot -- see LocalThingsEntity._resources.
+            return list(desc.options(self._resources) or [])
         if desc.options_field:
             rep = self.coordinator.last_resources.get(self._bound.href) or {}
             return list(rep.get(desc.options_field) or [])

custom_components/localthings/sensor.py

@@ -61,7 +61,6 @@ class LocalThingsConnectionModeSensor(CoordinatorEntity[LocalThingsCoordinator],
     Disabled by default — it's for troubleshooting, not everyday use."""
 
     _attr_has_entity_name = True
-    _attr_name = 'Connection mode'
     _attr_translation_key = 'connection_mode'
     _attr_entity_category = EntityCategory.DIAGNOSTIC
     _attr_entity_registry_enabled_default = False

custom_components/localthings/strings.json

@@ -1,302 +0,0 @@
-{
-  "entity": {
-    "select": {
-      "door_alert": {
-        "state": {
-          "1": "Alarm 1",
-          "2": "Alarm 2",
-          "3": "Alarm 3",
-          "4": "Alarm 4"
-        }
-      },
-      "brightness_level": {
-        "state": {
-          "33": "Low",
-          "66": "Medium",
-          "100": "High"
-        }
-      },
-      "range_hood_lamp_brightness": {
-        "state": {
-          "1": "Level 1",
-          "2": "Level 2"
-        }
-      },
-      "ice_type": {
-        "state": {
-          "off": "Off",
-          "whiskey_iceball_3": "3 Balls/Day",
-          "whiskey_iceball_6": "6 Balls/Day",
-          "whiskey_iceball_9": "9 Balls/Day"
-        }
-      },
-      "beverage_zone_mode": {
-        "state": {
-          "sp_ttype_beer_drinks": "Beverage",
-          "sp_ttype_wine_dessert": "Wine and Dessert"
-        }
-      },
-      "pantry_zone_mode": {
-        "state": {
-          "fdr_wine": "Wine",
-          "fdr_deli": "Deli",
-          "fdr_drinks": "Drinks"
-        }
-      },
-      "flex_zone_mode": {
-        "state": {
-          "cv_ttype_rf9000a_freeze": "Freeze",
-          "cv_ttype_rf9000a_softfreeze": "Soft Freeze",
-          "cv_ttype_rf9000a_meat_fish": "Meat/Fish",
-          "cv_ttype_rf9000a_fruit_veggies": "Fruit & Veggies",
-          "cv_ttype_rf9000a_beverage": "Beverage",
-          "cv_fdr_wine": "Wine",
-          "cv_fdr_deli": "Deli",
-          "cv_fdr_beverage": "Beverage",
-          "cv_fdr_meat": "Meat",
-          "cv_fdr_soft_freezer": "Soft Freezer"
-        }
-      },
-      "dishwasher_cycle": {
-        "state": {
-          "0e": "AI Wash",
-          "07": "Pre blast",
-          "90": "Self clean",
-          "86": "Normal",
-          "83": "Express 60",
-          "84": "Heavy",
-          "8d": "Pots and pans",
-          "80": "Delicate",
-          "8e": "Plastic",
-          "8f": "Baby Care"
-        }
-      },
-      "washer_cycle_table_02": {
-        "state": {
-          "1c": "Eco 40-60",
-          "1d": "Super Speed",
-          "21": "Colours",
-          "1b": "Cotton",
-          "1e": "15' Quick Wash",
-          "29": "Drum Clean+",
-          "24": "Towels",
-          "33": "Bedding",
-          "28": "Drain/Spin",
-          "26": "Delicates",
-          "27": "Rinse+Spin",
-          "22": "Wool",
-          "20": "Hygiene Steam",
-          "23": "Outdoor",
-          "25": "Synthetics",
-          "32": "Shirts",
-          "2f": "Activewear",
-          "2e": "Baby Care",
-          "30": "Cloudy Day",
-          "66": "Denim",
-          "2d": "Silent Wash",
-          "8f": "Intense Cold",
-          "96": "Less Microfiber",
-          "36": "Wash+Dry",
-          "37": "Air Wash",
-          "38": "Cotton Dry",
-          "39": "Synthetics Dry",
-          "1f": "Intense Cold"
-        }
-      },
-      "dryer_cycle_table_03": {
-        "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"
-        }
-      },
-      "washer_dry_level": {
-        "state": {
-          "none": "Off",
-          "cupboard": "Cupboard",
-          "30": "30 min",
-          "60": "1 hr",
-          "90": "1 hr 30",
-          "120": "2 hr",
-          "180": "3 hr",
-          "240": "4 hr"
-        }
-      }
-    },
-    "sensor": {
-      "ice_making_status": {
-        "state": {
-          "icestatus_stop": "Idle",
-          "icestatus_run": "Making ice"
-        }
-      },
-      "connection_mode": {
-        "state": {
-          "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"
-            }
-          }
-        }
-      }
-    }
-  },
-  "config": {
-    "step": {
-      "user": {
-        "title": "Add Samsung Appliance",
-        "description": "Enter the IP address of your Samsung appliance and the AC14K_M CA credentials used to mint device certificates. {reuse_note}",
-        "data": {
-          "host": "IP Address",
-          "ca_cert_pem": "CA Certificate (PEM)",
-          "ca_key_pem": "CA Private Key (PEM)"
-        },
-        "data_description": {
-          "host": "Local IP address of your Samsung appliance (e.g. 192.168.1.50).",
-          "ca_cert_pem": "The PEM-encoded AC14K_M CA certificate chain. Paste the full contents of your fullchain PEM including all BEGIN/END CERTIFICATE blocks.",
-          "ca_key_pem": "The PEM-encoded AC14K_M private key. Paste the full contents including the BEGIN/END PRIVATE KEY header and footer."
-        }
-      },
-      "confirm_unknown_type": {
-        "title": "Appliance type not recognized",
-        "description": "This appliance reported oneUiVersion \"{one_ui_version}\", which isn't a recognized type. It'll still be added, but only with common capabilities (power, alarms, etc. where present) rather than the full set for its family. You can help add full support afterward by downloading diagnostics for this device (Settings > Devices & Services > this device > the menu > Download diagnostics) and filing them in a new issue. Submit to add it anyway."
-      }
-    },
-    "error": {
-      "cannot_connect": "Cannot connect to the device. Verify the IP address is reachable and the CA credentials are correct.",
-      "invalid_ca": "The CA certificate or private key could not be loaded. Verify the PEM contents are correct and the key matches the certificate.",
-      "unknown": "Unexpected error. Check the Home Assistant logs for details."
-    },
-    "abort": {
-      "already_configured": "This device is already configured."
-    }
-  },
-  "options": {
-    "step": {
-      "init": {
-        "title": "Local Things Options",
-        "menu_options": {
-          "settings": "Remote control write settings",
-          "debug_write": "Debug: write to a resource"
-        }
-      },
-      "settings": {
-        "title": "Remote control write settings",
-        "description": "Some devices accept certain writes (e.g. default detergent/softener dosing on a washer) even while reporting remote control off. By default, LocalThings blocks every write with a clear error whenever a device reports remote control off, rather than letting the device silently reject it. Only enable this if you've confirmed writes actually work on this device with remote control off -- otherwise you'll trade that clear error for a silent failure.",
-        "data": {
-          "bypass_remote_control_lock": "Allow writes even when remote control is reported off"
-        }
-      },
-      "debug_write": {
-        "title": "Debug: write to a resource",
-        "description": "Power-user tool for pinning down device-specific write behavior. Pick the resource (href) you want to write to, or type a custom one that isn't listed. This bypasses the remote-control-off block and sends exactly the fields you provide -- it can misconfigure your appliance, so use it deliberately.",
-        "data": {
-          "href": "Resource href"
-        }
-      },
-      "debug_edit": {
-        "title": "Debug write: {href}",
-        "description": "Current value of `{href}`:\n```\n{current_value}\n```\nEnter ONLY the field(s) you want to change below. What you enter is sent to the device as-is (a partial update); it is NOT merged with the fields shown above, so don't paste the whole value back. Mind the types: a numeric string like \"1\" must stay quoted -- a bare 1 is sent as an integer, which some devices reject.",
-        "data": {
-          "payload": "Payload to write"
-        }
-      },
-      "debug_result": {
-        "title": "Debug write result",
-        "description": "The device returned CoAP code {code}. A 2.xx class means the write was accepted; 4.xx/5.xx means it was rejected. The resource now reads:\n```\n{new_value}\n```\nIf the value is unchanged, the device likely dropped the write. Pick what to do next:",
-        "menu_options": {
-          "debug_write": "Write another resource",
-          "finish": "Finish"
-        }
-      }
-    },
-    "error": {
-      "empty_payload": "Enter at least one field to write.",
-      "write_failed": "The write failed. Check the Home Assistant logs for details."
-    },
-    "abort": {
-      "not_loaded": "This device isn't connected yet. Try again once it has loaded."
-    }
-  },
-  "issues": {
-    "device_gap": {
-      "title": "Incomplete capability coverage for {device_name}",
-      "description": "This device is missing full capability coverage. Either its appliance type wasn't recognized, or some of the resources it exposes aren't modeled yet. It'll keep working with whatever is already supported. You can help expand support by going to Settings > Devices & Services > {device_name} > the menu (top right) > Download diagnostics, then filing it with the linked issue template."
-    }
-  }
-}

pyproject.toml

@@ -1,2 +1,5 @@
+[project]
+requires-python = ">=3.13"
+
 [tool.pytest.ini_options]
 asyncio_mode = "auto"

requirements-dev.txt

@@ -1,6 +1,7 @@
 # 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.
+# matching versions. pip resolves the newest home-assistant your interpreter
+# supports: Python 3.13 gets 0.13.316 (the floor below), 3.14 gets newer. On
+# 3.12 or older nothing resolves and the whole install fails.
 pytest-homeassistant-custom-component>=0.13.316
 
 # Integration runtime deps, needed to import the component under test

tests/conftest.py

@@ -16,6 +16,89 @@ def _load_device(name: str) -> dict[str, dict]:
     return _resources_from_dump(data)
 
 
+def _load_device_full(name: str):
+    """Like _load_device, but also returns the optional `oic_res`/`seeds`
+    keys a subdevice-capable fixture (issue #177) may carry alongside
+    `device0` -- see the two `airconditioner_*` fixtures with a
+    `seeds_note` field. `oic_res`/`seeds` default to `[]`/`{}` for every
+    other fixture, so this is safe to call on any fixture in the corpus.
+
+    Returns `(resources, oic_res, seeds)` where `seeds` is
+    `{seed_href: raw_batch_list}` -- the same [devcol-rep, {href, rep}, ...]
+    shape a real /device/<n> or /<id>/device/0 RETRIEVE returns, ready to
+    hand to a FakeCoapSession.
+
+    A fixture's optional `probes` map (plain Property-map resources that
+    belong to no batch, e.g. the hand-read /multidevice/vs/0 in the
+    ARTIK051_DONGLE_FAC_18K fixture) is folded into `seeds` here, since
+    FakeCoapSession answers both shapes off the same href key.
+    """
+    data = json.loads((FIXTURES / f'{name}_device.json').read_text())
+    resources = _resources_from_dump(data)
+    seeds = {**data.get('seeds', {}), **data.get('probes', {})}
+    return resources, data.get('oic_res', []), seeds
+
+
+class FakeCoapSession:
+    """Minimal stand-in for smartthings_local's DtlsCoapSession, backed by a
+    fixture's `seeds` map (raw device0-batch-shaped lists keyed by seed
+    href -- plus any `probes` entries, which are plain Property maps rather
+    than batch lists; both are just CBOR bodies at this layer, and the two
+    readers in registry.subdevices already type-check what they get back).
+    Enough surface for registry.subdevices.enumerate_subdevices and
+    LocalThingsCoordinator's blocking subdevice polls to run against fixture
+    data without a live device -- same idea as test_identity.py's
+    FakeSession, but keyed by href string (post path-join) rather than a
+    path tuple, since callers here pass a `seed_path` tuple straight
+    through.
+    """
+
+    def __init__(self, seeds: dict[str, list] | None = None):
+        self.seeds = seeds or {}
+
+    def get(self, path, timeout=None):
+        href = '/' + '/'.join(path)
+        body = self.seeds.get(href)
+        if body is None:
+            return 0x84, b''   # 4.04 not found -- tolerated absence
+        import cbor2
+        return 0x45, cbor2.dumps(body)
+
+    def pace(self):
+        pass
+
+
+def _discover_full(resources: dict[str, dict], oic_res, seeds: dict[str, list]):
+    """Run the *whole* subdevice-aware discovery pipeline against fixture
+    data, HA-free -- mirrors exactly what LocalThingsCoordinator does across
+    _enumerate_subdevices_blocking + _run_discovery (issue #177), so a test
+    exercising this exercises the real code path, not a re-implementation of
+    it. See the adding-device-support skill's section 2 for the plain
+    (non-subdevice) equivalent this extends.
+
+    Returns `(bound, materialized, skipped, full_resources, device_type_name)`:
+    - `bound`: every BoundEntity, main + every materialized subdevice.
+    - `materialized`/`skipped`: Subdevice / SkippedSubdevice lists straight from
+      discover_partitioned.
+    - `full_resources`: `resources` merged with every candidate's seed data
+      (actual hrefs) -- what a coordinator's cache would hold.
+    - `device_type_name`: the master's resolved registry name.
+    """
+    from custom_components.localthings.registry.by_type import resolve
+    from custom_components.localthings.registry.registry import CAPABILITIES
+    from custom_components.localthings.registry.subdevices import (
+        discover_partitioned, enumerate_subdevices,
+    )
+
+    sess = FakeCoapSession(seeds)
+    candidates, extra = enumerate_subdevices(sess, resources, oic_res)
+    full_resources = {**resources, **extra}
+    bound, device_type_name, materialized, skipped = discover_partitioned(
+        full_resources, candidates, resolve, CAPABILITIES,
+    )
+    return bound, materialized, skipped, full_resources, device_type_name
+
+
 def _load_resources(ip: str) -> dict[str, dict]:
     """Legacy IP-based loader — maps known IPs to named fixtures."""
     _ip_to_name = {
@@ -41,3 +124,18 @@ def fridge_resources() -> dict[str, dict]:
 @pytest.fixture
 def washer_resources() -> dict[str, dict]:
     return _load_device('washer')
+
+
+@pytest.fixture
+def all_device_fixtures() -> dict[str, dict[str, dict]]:
+    """Every scrubbed device dump, keyed by fixture name.
+
+    For invariants that must hold across the whole corpus rather than for one
+    device -- so a newly added dump exercises them automatically.
+    """
+    return {
+        path.name[:-len('_device.json')]: _resources_from_dump(
+            json.loads(path.read_text())
+        )
+        for path in sorted(FIXTURES.glob('*_device.json'))
+    }

tests/fixtures/air_dresser_device.json

@@ -0,0 +1,209 @@
+{
+  "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": "/configuration/vs/0",
+      "rep": {
+        "x.com.samsung.da.region": "0000000000",
+        "x.com.samsung.da.countryCode": "VN"
+      }
+    },
+    {
+      "href": "/course/vs/0",
+      "rep": {
+        "x.com.samsung.da.supportedModes": [
+          "HOMECARE_WIZARD_V2"
+        ],
+        "x.com.samsung.da.options": [
+          "DeviceType_015E",
+          "UpdateAllow_NotAllowed",
+          "Course_01",
+          "SteamPush_None",
+          "SeamlessControl_Disable",
+          "KidsLockBypass_On",
+          "WashingTimes_58",
+          "DrumCleanProposal_30",
+          "SpecialFunction_4",
+          "AvailableDelayTime_0",
+          "ProgressTimeSet_AA01E0AC00B4B20690",
+          "WrinklePreventRunning_Off",
+          "SendToDevice_Off",
+          "GMT_12",
+          "Alarm_Off",
+          "SilentSet_0F0FF0F0F0F0F0F0F0F00F0F0F0FF0F0F00FF0",
+          "Silent_Off",
+          "WrinklePreventSet_0F0F0F0F0F0F0F0FF0F00F0F0F0F0F0F0F0FF0",
+          "DelayEndSet_0F0F0F0FF00F0F0F0F0F0F0F0F0F0F0F0F0F0F",
+          "OneTimeCourse_761F00200000000000000000000000",
+          "DownloadCourseList_090A0B12100C140D0F",
+          "EnergyLevelSet_0502020104030204050405020303010302010305",
+          "MostUsed_01",
+          "UsagesDB_ok",
+          "EnergyKW_396",
+          "DrumCleanLog_2024-01-01T00:00:00",
+          "TimeSync_NotSupported"
+        ],
+        "x.com.samsung.da.supportedOptions": [
+          "001020403051A1B1C0708"
+        ]
+      }
+    },
+    {
+      "href": "/cycleinterface/vs/0",
+      "rep": {}
+    },
+    {
+      "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.instantaneousPowerUnit": "W",
+        "x.com.samsung.da.instantaneousPower": "-500",
+        "x.com.samsung.da.cumulativePower": "78200",
+        "x.com.samsung.da.cumulativeUnit": "Wh",
+        "x.com.samsung.da.cumulativeDate": "1785272400",
+        "x.com.samsung.da.cumulativeDateUTC": "1785240000"
+      }
+    },
+    {
+      "href": "/file/information/vs/0",
+      "rep": {
+        "x.com.samsung.timeoffset": "+09:00"
+      }
+    },
+    {
+      "href": "/information/vs/0",
+      "rep": {
+        "x.com.samsung.da.modelNum": "DA_DF_A51_20_COMMON|20261441|3801010200131100020100FF00000000",
+        "x.com.samsung.da.description": "DA_DF_A51_20_COMMON_DF8600T/DC92-02656A_0018",
+        "x.com.samsung.da.serialNum": "REDACTED",
+        "x.com.samsung.da.otnDUID": "REDACTED",
+        "x.com.samsung.da.items": [
+          {
+            "x.com.samsung.da.id": "0",
+            "x.com.samsung.da.description": "DA_DF_A51_20_COMMON|20261441|3801010200131100020100FF00000000",
+            "x.com.samsung.da.type": "Software",
+            "x.com.samsung.da.number": "02672A230710(E431)",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          },
+          {
+            "x.com.samsung.da.id": "1",
+            "x.com.samsung.da.description": "DA_DF_A51_20_COMMON",
+            "x.com.samsung.da.type": "Firmware",
+            "x.com.samsung.da.number": "20060507,20072702",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/kidslock/0",
+      "rep": {
+        "value": false
+      }
+    },
+    {
+      "href": "/kidslock/vs/0",
+      "rep": {
+        "x.com.samsung.da.kidsLock": "Ready"
+      }
+    },
+    {
+      "href": "/operational/state/0",
+      "rep": {
+        "currentMachineState": "REDACTED",
+        "machineStates": "REDACTED",
+        "jobStates": [
+          "None",
+          "Steaming",
+          "Airwashing",
+          "Drying",
+          "Finish"
+        ],
+        "currentJobState": "None",
+        "remainingTime": "00:39:00",
+        "progressPercentage": "1"
+      }
+    },
+    {
+      "href": "/operational/state/vs/0",
+      "rep": {
+        "x.com.samsung.da.state": "Ready",
+        "x.com.samsung.da.remainingTime": "00:39: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",
+          "Steaming",
+          "Airwashing",
+          "Drying",
+          "Finish"
+        ]
+      }
+    },
+    {
+      "href": "/power/0",
+      "rep": {
+        "value": true
+      }
+    },
+    {
+      "href": "/power/vs/0",
+      "rep": {
+        "x.com.samsung.da.power": "On"
+      }
+    },
+    {
+      "href": "/realtimenotiforclient/vs/0",
+      "rep": {
+        "x.com.samsung.da.timeforshortnoti": "10",
+        "x.com.samsung.da.periodicnotisubscription": "true"
+      }
+    },
+    {
+      "href": "/remotectrl/0",
+      "rep": {
+        "value": false
+      }
+    },
+    {
+      "href": "/remotectrl/vs/0",
+      "rep": {
+        "x.com.samsung.da.remoteControlEnabled": "false"
+      }
+    },
+    {
+      "href": "/washer/vs/0",
+      "rep": {
+        "x.com.samsung.da.wrinklePrevent": "Off"
+      }
+    },
+    {
+      "href": "/wm/jobbeginingstatus/vs/0",
+      "rep": {}
+    }
+  ]
+}

tests/fixtures/air_dresser_tp2_20_device.json

@@ -0,0 +1,282 @@
+{
+  "device0": [
+    {
+      "rt": [
+        "x.com.samsung.devcol",
+        "oic.wk.col"
+      ],
+      "if": [
+        "oic.if.baseline",
+        "oic.if.ll",
+        "oic.if.b"
+      ]
+    },
+    {
+      "href": "/airdresseroption/sanitize/vs/0",
+      "rep": {
+        "x.com.samsung.da.sanitize": "Off",
+        "x.com.samsung.da.supportedSanitize": [
+          "On",
+          "Off"
+        ]
+      }
+    },
+    {
+      "href": "/alarms/vs/0",
+      "rep": {}
+    },
+    {
+      "href": "/configuration/vs/0",
+      "rep": {
+        "x.com.samsung.da.region": "3171000000",
+        "x.com.samsung.da.countryCode": "KR"
+      }
+    },
+    {
+      "href": "/course/vs/0",
+      "rep": {
+        "x.com.samsung.da.supportedModes": [
+          "HOMECARE_WIZARD_V2"
+        ],
+        "x.com.samsung.da.options": [
+          "DeviceType_015E",
+          "UpdateAllow_NotAllowed",
+          "Course_22",
+          "AiOption_On",
+          "SteamPush_None",
+          "SeamlessControl_Disable",
+          "KidsLockBypass_On",
+          "FilterUsage_384019D5",
+          "WashingTimes_6",
+          "DrumCleanProposal_30",
+          "ProgressTimeSet_AA01A4AC00F0B20690",
+          "WrinklePreventRunning_Off",
+          "SendToDevice_Off",
+          "WeatherPush_Off",
+          "GMT_12",
+          "Alarm_Off",
+          "WrinklePreventSet_0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0FF00F0F0F0F0F0F0F0F0F0F0FF0F0",
+          "DelayEndSet_0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0FF0F0F00F0F0FF0F0F0F0F00F0F",
+          "EnergyLevelSet_0502010102010202030303010401040505050503030502040503030303030405",
+          "UsagesDB_ok",
+          "DrumCleanLog_2023-04-02T08:08:55|2023-10-02T03:38:19|2024-05-26T03:25:41|2024-10-01T01:07:20|2026-06-16T02:23:29"
+        ],
+        "x.com.samsung.da.supportedOptions": [
+          "12261062361020E61020961021261020C61021E61020B61021061020A61061461021361061661022462062562062F62062062040F62042761023061021561021A61021B61021C61022A61022B61022C61022D61022E6102076102086102"
+        ]
+      }
+    },
+    {
+      "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": "63600",
+        "x.com.samsung.da.cumulativeUnit": "Wh",
+        "x.com.samsung.da.cumulativeDate": "1784404800",
+        "x.com.samsung.da.cumulativeDateUTC": "1784372400"
+      }
+    },
+    {
+      "href": "/file/information/vs/0",
+      "rep": {
+        "x.com.samsung.timeoffset": "+09:00"
+      }
+    },
+    {
+      "href": "/information/vs/0",
+      "rep": {
+        "x.com.samsung.da.modelNum": "DA_DF_TP2_20_COMMON|20286141|380101010015110F0201000100010000",
+        "x.com.samsung.da.description": "DA_DF_TP2_20_COMMON_DF9500A/DC92-02888A_0002",
+        "x.com.samsung.da.serialNum": "REDACTED",
+        "x.com.samsung.da.otnDUID": "REDACTED",
+        "x.com.samsung.da.diagProtocolType": "WIFI_HTTPS",
+        "x.com.samsung.da.diagLogType": [
+          "errCode",
+          "dump"
+        ],
+        "x.com.samsung.da.diagDumpType": "file",
+        "x.com.samsung.da.diagEndPoint": "SSM",
+        "x.com.samsung.da.diagMnid": "0AJT",
+        "x.com.samsung.da.diagSetupid": "A00",
+        "x.com.samsung.da.diagMinVersion": "1.0",
+        "x.com.samsung.da.items": [
+          {
+            "x.com.samsung.da.id": "0",
+            "x.com.samsung.da.description": "DA_DF_TP2_20_COMMON|20286141|380101010015110F0201000100010000",
+            "x.com.samsung.da.type": "Software",
+            "x.com.samsung.da.number": "02673A250416(F822)",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          },
+          {
+            "x.com.samsung.da.id": "1",
+            "x.com.samsung.da.description": "Firmware_1_DB",
+            "x.com.samsung.da.type": "Firmware",
+            "x.com.samsung.da.number": "21020115,23030652",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          },
+          {
+            "x.com.samsung.da.id": "2",
+            "x.com.samsung.da.description": "Firmware_2_DB",
+            "x.com.samsung.da.type": "Firmware",
+            "x.com.samsung.da.number": "19111852,FFFFFFFF"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/kidslock/0",
+      "rep": {
+        "value": false
+      }
+    },
+    {
+      "href": "/kidslock/vs/0",
+      "rep": {
+        "x.com.samsung.da.kidsLock": "Ready"
+      }
+    },
+    {
+      "href": "/operational/state/0",
+      "rep": {
+        "currentMachineState": "REDACTED",
+        "machineStates": "REDACTED",
+        "jobStates": [
+          "None",
+          "Steaming",
+          "Airwashing",
+          "Drying",
+          "Finish"
+        ],
+        "currentJobState": "None",
+        "remainingTime": "00:39:00",
+        "progressPercentage": "1"
+      }
+    },
+    {
+      "href": "/operational/state/vs/0",
+      "rep": {
+        "x.com.samsung.da.state": "Ready",
+        "x.com.samsung.da.remainingTime": "00:39: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",
+          "Steaming",
+          "Airwashing",
+          "Drying",
+          "Finish"
+        ]
+      }
+    },
+    {
+      "href": "/otninformation/vs/0",
+      "rep": {
+        "x.com.samsung.da.target": "Micom",
+        "x.com.samsung.da.newVersionAvailable": "false"
+      }
+    },
+    {
+      "href": "/power/0",
+      "rep": {
+        "value": false
+      }
+    },
+    {
+      "href": "/power/vs/0",
+      "rep": {
+        "x.com.samsung.da.power": "Off"
+      }
+    },
+    {
+      "href": "/realtimenotiforclient/vs/0",
+      "rep": {
+        "x.com.samsung.da.timeforshortnoti": "0",
+        "x.com.samsung.da.periodicnotisubscription": "true"
+      }
+    },
+    {
+      "href": "/remotectrl/0",
+      "rep": {
+        "value": false
+      }
+    },
+    {
+      "href": "/remotectrl/vs/0",
+      "rep": {
+        "x.com.samsung.da.remoteControlEnabled": "false"
+      }
+    },
+    {
+      "href": "/st/airdressercourse/vs/0",
+      "rep": {
+        "x.com.samsung.da.st.airdresserMode": "Table_00_Course_22",
+        "x.com.samsung.da.st.courseTable": "Table_00"
+      }
+    },
+    {
+      "href": "/washer/vs/0",
+      "rep": {
+        "x.com.samsung.da.wrinklePrevent": "Off"
+      }
+    },
+    {
+      "href": "/wm/editcourse/vs/0",
+      "rep": {
+        "x.com.samsung.da.editCourseList": "EditCourseList_22230C10252F0F0E09121E0B0A14131624202730151A1B1C2A2B2C2D2E0708",
+        "x.com.samsung.da.fixedCourseList": "FixedCourseList_22270F"
+      }
+    },
+    {
+      "href": "/wm/jobbeginingstatus/vs/0",
+      "rep": {}
+    },
+    {
+      "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": "false",
+        "x.com.samsung.da.aiCourse": "false",
+        "x.com.samsung.da.isModelSettingPowerOnOff": "true"
+      }
+    },
+    {
+      "href": "/wm/welcomemsg/vs/0",
+      "rep": {}
+    }
+  ]
+}

tests/fixtures/air_purifier_avt_ww_device.json

@@ -0,0 +1,381 @@
+{
+  "device0": [
+    {
+      "rt": [
+        "x.com.samsung.devcol",
+        "oic.wk.col"
+      ],
+      "if": [
+        "oic.if.baseline",
+        "oic.if.ll",
+        "oic.if.b"
+      ]
+    },
+    {
+      "href": "/realtimenotiforclient/vs/0",
+      "rep": {
+        "x.com.samsung.da.timeforshortnoti": "0",
+        "x.com.samsung.da.longnotisubscription": "true",
+        "x.com.samsung.da.periodicnotisubscription": "true"
+      }
+    },
+    {
+      "href": "/airlevelcheck/vs/0",
+      "rep": {
+        "x.com.samsung.da.periodicSensingActivationState": "On",
+        "x.com.samsung.da.periodicSensingInterval": "600",
+        "x.com.samsung.da.startSensingOnce": "On",
+        "x.com.samsung.da.sensingState": "NonProcessing",
+        "x.com.samsung.da.lastSensingTime": "1785320820",
+        "x.com.samsung.da.lastSensingLevel": "Kr1",
+        "x.com.samsung.da.autoExeState": "Off",
+        "x.com.samsung.da.supportedAutoExeState": [
+          "Off",
+          "Airpurify",
+          "Alarm"
+        ],
+        "x.com.samsung.da.periodicSensingSkipStatus": "Off",
+        "x.com.samsung.da.periodicSensingSkipTime": "03002300"
+      }
+    },
+    {
+      "href": "/mode/convenient/vs/0",
+      "rep": {}
+    },
+    {
+      "href": "/wind/strength/vs/0",
+      "rep": {
+        "x.com.samsung.da.modes": "87",
+        "x.com.samsung.da.supportedModes": [
+          "87",
+          "89",
+          "90",
+          "91"
+        ],
+        "x.com.samsung.da.modesName": [
+          "SMART",
+          "MAX",
+          "WINDFREE",
+          "Sleep"
+        ]
+      }
+    },
+    {
+      "href": "/filter/hepafilter/vs/0",
+      "rep": {
+        "x.com.samsung.da.filterUsage": "30",
+        "x.com.samsung.da.filterUsageResolution": "1",
+        "x.com.samsung.da.filterStatus": "normal",
+        "x.com.samsung.da.filterCapacity": "8760",
+        "x.com.samsung.da.filterCapacityUnit": "Hour",
+        "x.com.samsung.da.filterResetType": [
+          "replaceable"
+        ]
+      }
+    },
+    {
+      "href": "/dnd/autosleep/vs/0",
+      "rep": {
+        "x.com.samsung.da.startTime": "15:00:00",
+        "x.com.samsung.da.endTime": "23:30:00",
+        "x.com.samsung.da.visible": "true",
+        "x.com.samsung.da.useTimeSetting": "true",
+        "x.com.samsung.da.functionState": "true"
+      }
+    },
+    {
+      "href": "/availablecontrolsets/vs/0",
+      "rep": {
+        "x.com.samsung.da.sets": "0000000000000000000000000000",
+        "x.com.samsung.da.id": "VTL",
+        "x.com.samsung.da.version": "1.0"
+      }
+    },
+    {
+      "href": "/da/softreset/vs/0",
+      "rep": {
+        "x.com.samsung.da.softwarereset": "false"
+      }
+    },
+    {
+      "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-29T10:34:52",
+            "x.com.samsung.da.state": "Deleted"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/energy/consumption/vs/0",
+      "rep": {
+        "x.com.samsung.da.cumulativePower": "48656",
+        "x.com.samsung.da.cumulativeSavedPower": "0",
+        "x.com.samsung.da.cumulativeDate": "1785353679",
+        "x.com.samsung.da.cumulativeDateUTC": "1785321279",
+        "x.com.samsung.da.cumulativeUnit": "Wh"
+      }
+    },
+    {
+      "href": "/energy/consumption/0",
+      "rep": {}
+    },
+    {
+      "href": "/mode/vs/0",
+      "rep": {
+        "x.com.samsung.da.options": [
+          "CountOfSlave_0",
+          "SlavePower01_NotSupported",
+          "Pollution_Off",
+          "SmartSave_Off",
+          "OptionCode_23418",
+          "SmartSleep_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 Dust",
+            "x.com.samsung.da.type": "Dust",
+            "x.com.samsung.da.value": [
+              "10",
+              "1"
+            ]
+          },
+          {
+            "x.com.samsung.da.id": "1",
+            "x.com.samsung.da.description": "Sensor for FineDust",
+            "x.com.samsung.da.type": "FineDust",
+            "x.com.samsung.da.value": [
+              "9",
+              "1"
+            ]
+          },
+          {
+            "x.com.samsung.da.id": "2",
+            "x.com.samsung.da.description": "Sensor for Odor",
+            "x.com.samsung.da.type": "Odor",
+            "x.com.samsung.da.value": [
+              "1"
+            ]
+          },
+          {
+            "x.com.samsung.da.id": "3",
+            "x.com.samsung.da.description": "Sensor for CleanLevel",
+            "x.com.samsung.da.type": "CleanLevel",
+            "x.com.samsung.da.value": [
+              "1"
+            ]
+          },
+          {
+            "x.com.samsung.da.id": "4",
+            "x.com.samsung.da.description": "Sensor for SuperFineDust",
+            "x.com.samsung.da.type": "SuperFineDust",
+            "x.com.samsung.da.value": [
+              "6",
+              "1"
+            ]
+          }
+        ],
+        "x.com.samsung.da.total": "5"
+      }
+    },
+    {
+      "href": "/information/vs/0",
+      "rep": {
+        "x.com.samsung.da.modelNum": "AVT-WW-TP1-23-AXX500|10238841|70000535001611CC0D10090301080000",
+        "x.com.samsung.da.description": "AVT-WW-TP1-23-AXX500",
+        "x.com.samsung.da.serialNum": "**REDACTED**",
+        "x.com.samsung.da.otnDUID": "**REDACTED**",
+        "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": "AC0",
+        "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": "Version",
+            "x.com.samsung.da.type": "Software",
+            "x.com.samsung.da.number": "02530A260327",
+            "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": "22120702,22022301",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          },
+          {
+            "x.com.samsung.da.id": "2",
+            "x.com.samsung.da.description": "Version",
+            "x.com.samsung.da.type": "Firmware",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/file/information/vs/0",
+      "rep": {
+        "x.com.samsung.timeoffset": "+09:00"
+      }
+    },
+    {
+      "href": "/configuration/vs/0",
+      "rep": {
+        "x.com.samsung.da.region": "2824500000",
+        "x.com.samsung.da.airconOptionList": [
+          "WELCOMECARE",
+          "AI_PURIFY"
+        ],
+        "x.com.samsung.da.countryCode": ""
+      }
+    },
+    {
+      "href": "/humidity/0",
+      "rep": {}
+    },
+    {
+      "href": "/humidity/vs/0",
+      "rep": {}
+    },
+    {
+      "href": "/devicespecificinfo/vs/0",
+      "rep": {
+        "x.com.samsung.da.deviceActive": true
+      }
+    },
+    {
+      "href": "/otninformation/vs/0",
+      "rep": {
+        "x.com.samsung.da.target": "",
+        "x.com.samsung.da.newVersionAvailable": "false",
+        "x.com.samsung.da.newVersionNo": "00000000",
+        "x.com.samsung.da.currentVersionInfo": "00000000",
+        "otnStatus": "None",
+        "flashingProgress": "",
+        "otnTarget": "main",
+        "otnCompleteDate": "noHistory",
+        "otnList": [
+          {
+            "type": "WIFI",
+            "modelId": "AVT-WW-TP1-23-AXX500",
+            "versions": [
+              "12260327"
+            ],
+            "visVersion": "260327"
+          },
+          {
+            "type": "Micom",
+            "modelId": "",
+            "versions": [
+              "22120702",
+              "22022301"
+            ],
+            "visVersion": "221207"
+          },
+          {
+            "type": "Micom",
+            "modelId": "",
+            "versions": [
+              "22120702",
+              "22022301"
+            ],
+            "visVersion": "221207"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/timezone/vs/0",
+      "rep": {
+        "timezoneid": "Asia/Seoul",
+        "offset": "+09:00",
+        "DST": "OFF"
+      }
+    },
+    {
+      "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": "/option/muteonce/vs/0",
+      "rep": {
+        "muteonce": "Off"
+      }
+    },
+    {
+      "href": "/wirelessinfo/vs/0",
+      "rep": {
+        "macaddressWiFi": "**REDACTED**",
+        "macaddressBLE": "**REDACTED**",
+        "connectedApSsid": "ASUS_2.4G"
+      }
+    },
+    {
+      "href": "/quickcontrol/info/vs/0",
+      "rep": {
+        "supportedVersion": "1.0"
+      }
+    }
+  ]
+}

tests/fixtures/air_purifier_tp1x_da_ac_air_device.json

@@ -0,0 +1,466 @@
+{
+  "device0": [
+    {
+      "rt": [
+        "x.com.samsung.devcol",
+        "oic.wk.col"
+      ],
+      "if": [
+        "oic.if.baseline",
+        "oic.if.ll",
+        "oic.if.b"
+      ]
+    },
+    {
+      "href": "/airlevelcheck/vs/0",
+      "rep": {
+        "x.com.samsung.da.sensingState": "NonProcessing",
+        "x.com.samsung.da.lastSensingTime": "1785157841",
+        "x.com.samsung.da.lastSensingLevel": "Kr1",
+        "x.com.samsung.da.periodicSensingSkipStatus": "Off",
+        "x.com.samsung.da.periodicSensingSkipTime": "00000000",
+        "x.com.samsung.da.periodicSensingActivationState": "On",
+        "x.com.samsung.da.autoExeState": "Off",
+        "x.com.samsung.da.supportedAutoExeState": [
+          "Off",
+          "Airpurify",
+          "Alarm"
+        ],
+        "x.com.samsung.da.startSensingOnce": "Off"
+      }
+    },
+    {
+      "href": "/alarms/vs/0",
+      "rep": {
+        "x.com.samsung.da.items": [
+          {
+            "x.com.samsung.da.id": "0",
+            "x.com.samsung.da.alarmType": "Device",
+            "x.com.samsung.da.code": "ErrorCode_OFF",
+            "x.com.samsung.da.triggeredTime": "2026-07-27T13:18:51",
+            "x.com.samsung.da.state": "Deleted"
+          }
+        ],
+        "rt": [
+          "x.com.samsung.da.alarms"
+        ],
+        "if": [
+          "oic.if.baseline",
+          "oic.if.a"
+        ]
+      }
+    },
+    {
+      "href": "/availablecontrolsets/vs/0",
+      "rep": {
+        "x.com.samsung.da.sets": "3B000100000A0000000000000000",
+        "x.com.samsung.da.id": "VTL",
+        "x.com.samsung.da.version": "1.0"
+      }
+    },
+    {
+      "href": "/configuration/vs/0",
+      "rep": {
+        "x.com.samsung.da.region": "2650000000",
+        "x.com.samsung.da.airconOptionList": [
+          "AI_PURIFY",
+          "WELCOMECARE",
+          "DR"
+        ]
+      }
+    },
+    {
+      "href": "/da/softreset/vs/0",
+      "rep": {
+        "x.com.samsung.da.softwarereset": "false"
+      }
+    },
+    {
+      "href": "/devicespecificinfo/vs/0",
+      "rep": {
+        "x.com.samsung.da.deviceActive": true
+      }
+    },
+    {
+      "href": "/display/vs/0",
+      "rep": {
+        "mode": "On",
+        "supportedModes": [
+          "On",
+          "Off"
+        ]
+      }
+    },
+    {
+      "href": "/dnd/autosleep/vs/0",
+      "rep": {
+        "x.com.samsung.da.visible": "true",
+        "x.com.samsung.da.startTime": "00:00:00",
+        "x.com.samsung.da.endTime": "00:00:00",
+        "x.com.samsung.da.useTimeSetting": "false",
+        "x.com.samsung.da.functionState": "false"
+      }
+    },
+    {
+      "href": "/drlc/vs/0",
+      "rep": {
+        "x.com.samsung.da.start": "1970-01-01T00:00:00Z",
+        "x.com.samsung.da.override": "Off",
+        "x.com.samsung.da.durationminutes": "0",
+        "x.com.samsung.da.drlcLevel": "0",
+        "x.com.samsung.da.realSaving": "Off"
+      }
+    },
+    {
+      "href": "/energy/consumption/vs/0",
+      "rep": {
+        "x.com.samsung.da.cumulativeDate": "1785158301",
+        "x.com.samsung.da.cumulativeSavedPower": "0",
+        "x.com.samsung.da.cumulativePower": "32428",
+        "x.com.samsung.da.cumulativeUnit": "Wh",
+        "x.com.samsung.da.instantaneousPowerUnit": "W",
+        "x.com.samsung.da.cumulativePowerType": "total"
+      }
+    },
+    {
+      "href": "/file/information/vs/0",
+      "rep": {
+        "x.com.samsung.timeoffset": "+09:00",
+        "x.com.samsung.supprtedtype": 1
+      }
+    },
+    {
+      "href": "/filter/hepafilter/vs/0",
+      "rep": {
+        "x.com.samsung.da.filterUsage": "70",
+        "x.com.samsung.da.filterUsageResolution": "1",
+        "x.com.samsung.da.filterCapacity": "8760",
+        "x.com.samsung.da.filterCapacityUnit": "Hour",
+        "x.com.samsung.da.filterResetType": [
+          "replaceable"
+        ],
+        "x.com.samsung.da.filterStatus": "normal"
+      }
+    },
+    {
+      "href": "/information/vs/0",
+      "rep": {
+        "x.com.samsung.da.otnDUID": "**REDACTED**",
+        "x.com.samsung.da.modelNum": "TP1X_DA-AC-AIR-01031_0000|10268241|70000721001813CC4D1A490301082100",
+        "x.com.samsung.da.description": "TP1X_DA-AC-AIR-01031_0000",
+        "x.com.samsung.da.serialNum": "**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": "02660A260401",
+            "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.newVersionAvailable": "0",
+            "x.com.samsung.da.number": "02682A25042102,02683A25031801"
+          }
+        ],
+        "x.com.samsung.da.diagDumpType": "file",
+        "x.com.samsung.da.diagEndPoint": "SSM",
+        "x.com.samsung.da.diagLogType": [
+          "errCode",
+          "dump"
+        ],
+        "x.com.samsung.da.diagMnid": "0AJT",
+        "x.com.samsung.da.diagSetupid": "AP2",
+        "x.com.samsung.da.diagProtocolType": "BLE_OCF",
+        "x.com.samsung.da.diagMinVersion": "3.0",
+        "x.com.samsung.da.diagTsId": "DA01"
+      }
+    },
+    {
+      "href": "/keepnormalstate/vs/0",
+      "rep": {
+        "x.com.samsung.da.keepnormal": 1
+      }
+    },
+    {
+      "href": "/kidslock/vs/0",
+      "rep": {
+        "x.com.samsung.da.kidsLock": "Ready"
+      }
+    },
+    {
+      "href": "/light/vs/0",
+      "rep": {
+        "mode": "On",
+        "supportedModes": [
+          "On",
+          "Off"
+        ]
+      }
+    },
+    {
+      "href": "/mode/vs/0",
+      "rep": {
+        "x.com.samsung.da.modes": [
+          "Smart"
+        ],
+        "x.com.samsung.da.supportedModes": [
+          "Smart",
+          "Max",
+          "Mid",
+          "WindFree",
+          "Sleep"
+        ],
+        "x.com.samsung.da.options": [
+          "OptionCode_23418",
+          "SmartSleep_Off",
+          "WelcomeCare_On",
+          "Pollution_Off",
+          "ProtectOperation_Off",
+          "UpdateAllow_NotAllowed"
+        ],
+        "rt": [
+          "x.com.samsung.da.mode"
+        ],
+        "if": [
+          "oic.if.baseline",
+          "oic.if.a"
+        ]
+      }
+    },
+    {
+      "href": "/option/muteonce/vs/0",
+      "rep": {
+        "muteonce": "Off"
+      }
+    },
+    {
+      "href": "/panel/vs/0",
+      "rep": {
+        "status": "Close"
+      }
+    },
+    {
+      "href": "/personality/presence/vs/0",
+      "rep": {}
+    },
+    {
+      "href": "/petfilteractivation/vs/0",
+      "rep": {
+        "status": "Off"
+      }
+    },
+    {
+      "href": "/power/vs/0",
+      "rep": {
+        "x.com.samsung.da.power": "On",
+        "operationNumber": "36",
+        "displayCondition": "Enable"
+      }
+    },
+    {
+      "href": "/realtimenotiforclient/vs/0",
+      "rep": {
+        "x.com.samsung.da.timeforshortnoti": "0",
+        "x.com.samsung.da.longnotisubscription": "true",
+        "x.com.samsung.da.periodicnotisubscription": "true"
+      }
+    },
+    {
+      "href": "/reserverulesets/vs/0",
+      "rep": {
+        "x.com.samsung.da.sets": "3F00000000000000000000",
+        "x.com.samsung.da.id": "VTL",
+        "x.com.samsung.da.version": "1.0"
+      }
+    },
+    {
+      "href": "/sensors/vs/0",
+      "rep": {
+        "x.com.samsung.da.cleanLevel": "1",
+        "x.com.samsung.da.total": "5",
+        "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": [
+              "1"
+            ]
+          },
+          {
+            "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": [
+              "1"
+            ]
+          },
+          {
+            "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": [
+              "5",
+              "1"
+            ]
+          },
+          {
+            "x.com.samsung.da.id": "3",
+            "x.com.samsung.da.description": "Sensor for FineDust",
+            "x.com.samsung.da.type": "FineDust",
+            "x.com.samsung.da.value": [
+              "5",
+              "1"
+            ]
+          },
+          {
+            "x.com.samsung.da.id": "4",
+            "x.com.samsung.da.description": "Sensor for SuperFineDust",
+            "x.com.samsung.da.type": "SuperFineDust",
+            "x.com.samsung.da.value": [
+              "5",
+              "1"
+            ]
+          }
+        ],
+        "rt": [
+          "x.com.samsung.da.sensors"
+        ],
+        "if": [
+          "oic.if.baseline",
+          "oic.if.s"
+        ]
+      }
+    },
+    {
+      "href": "/settings/sound/mode/vs/0",
+      "rep": {
+        "mode": "mute",
+        "supportedModes": [
+          "mute",
+          "buzzer"
+        ]
+      }
+    },
+    {
+      "href": "/settings/sound/output/vs/0",
+      "rep": {
+        "deviceType": "buzzer"
+      }
+    },
+    {
+      "href": "/settings/sound/volume/vs/0",
+      "rep": {
+        "level": "0",
+        "minLevel": "0",
+        "maxLevel": "3",
+        "resolution": "1"
+      }
+    },
+    {
+      "href": "/otninformation/vs/0",
+      "rep": {
+        "x.com.samsung.da.target": "Micom",
+        "x.com.samsung.da.newVersionAvailable": "false",
+        "x.com.samsung.da.newVersionNo": "12250421",
+        "x.com.samsung.da.currentVersionInfo": "10000000",
+        "otnStatus": "None",
+        "flashingProgress": "0",
+        "otnTarget": "main",
+        "otnCompleteDate": "noHistory",
+        "scheduledTime": "None",
+        "swVersionInfo": {
+          "platform": "Tizen Lite",
+          "oneUiVersion": "7.0 Air purifier",
+          "osVersion": "4.0"
+        },
+        "otnList": [
+          {
+            "type": "WIFI",
+            "modelId": "AVT-KR-TP1-24-AXXX00",
+            "versions": [
+              "12260401"
+            ],
+            "visVersion": "260401"
+          },
+          {
+            "type": "Micom",
+            "modelId": "895010268241FFFFFFFF",
+            "versions": [
+              "25042102",
+              "FFFFFFFF"
+            ],
+            "visVersion": "250421"
+          },
+          {
+            "type": "Micom",
+            "modelId": "09501026824110268341",
+            "versions": [
+              "25042102",
+              "25031801"
+            ],
+            "visVersion": "250421"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/timezone/vs/0",
+      "rep": {
+        "timezoneid": "Asia/Seoul",
+        "offset": "+09:00",
+        "DST": "OFF"
+      }
+    },
+    {
+      "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": "/wirelessinfo/vs/0",
+      "rep": {
+        "macaddressWiFi": "**REDACTED**",
+        "macaddressBLE": "**REDACTED**",
+        "connectedApSsid": "Branden_Summit"
+      }
+    },
+    {
+      "href": "/quickcontrol/info/vs/0",
+      "rep": {
+        "supportedVersion": "1.0"
+      }
+    }
+  ]
+}

tests/fixtures/air_purifier_vtww_device.json

@@ -0,0 +1,310 @@
+{
+  "device0": [
+    {
+      "rt": [
+        "x.com.samsung.devcol",
+        "oic.wk.col"
+      ],
+      "if": [
+        "oic.if.baseline",
+        "oic.if.ll",
+        "oic.if.b"
+      ]
+    },
+    {
+      "href": "/airlevelcheck/vs/0",
+      "rep": {
+        "x.com.samsung.da.periodicSensingActivationState": "Off",
+        "x.com.samsung.da.periodicSensingInterval": "600",
+        "x.com.samsung.da.startSensingOnce": "On",
+        "x.com.samsung.da.sensingState": "NonProcessing",
+        "x.com.samsung.da.lastSensingTime": "1785195000",
+        "x.com.samsung.da.lastSensingLevel": "Kr1",
+        "x.com.samsung.da.autoExeState": "Off",
+        "x.com.samsung.da.supportedAutoExeState": [
+          "Off",
+          "Airpurify",
+          "Alarm"
+        ],
+        "x.com.samsung.da.periodicSensingSkipStatus": "Off",
+        "x.com.samsung.da.periodicSensingSkipTime": "15002100"
+      }
+    },
+    {
+      "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": "2024-01-01T00:00:00",
+            "x.com.samsung.da.state": "Deleted"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/availablecontrolsets/vs/0",
+      "rep": {
+        "x.com.samsung.da.sets": "0000000000000000000000000000",
+        "x.com.samsung.da.id": "VTL",
+        "x.com.samsung.da.version": "1.0"
+      }
+    },
+    {
+      "href": "/configuration/vs/0",
+      "rep": {
+        "x.com.samsung.da.region": "3017000000",
+        "x.com.samsung.da.airconOptionList": [
+          "WELCOMECARE",
+          "AI_PURIFY"
+        ],
+        "x.com.samsung.da.countryCode": ""
+      }
+    },
+    {
+      "href": "/da/softreset/vs/0",
+      "rep": {
+        "x.com.samsung.da.softwarereset": "false"
+      }
+    },
+    {
+      "href": "/devicespecificinfo/vs/0",
+      "rep": {
+        "x.com.samsung.da.deviceActive": true
+      }
+    },
+    {
+      "href": "/dnd/autosleep/vs/0",
+      "rep": {
+        "x.com.samsung.da.startTime": "14:00:00",
+        "x.com.samsung.da.endTime": "22:00:00",
+        "x.com.samsung.da.visible": "true",
+        "x.com.samsung.da.useTimeSetting": "true",
+        "x.com.samsung.da.functionState": "true"
+      }
+    },
+    {
+      "href": "/energy/consumption/0",
+      "rep": {}
+    },
+    {
+      "href": "/energy/consumption/vs/0",
+      "rep": {
+        "x.com.samsung.da.cumulativePower": "196696",
+        "x.com.samsung.da.cumulativeDate": "1785245199",
+        "x.com.samsung.da.cumulativeDateUTC": "1785212799",
+        "x.com.samsung.da.cumulativeUnit": "Wh"
+      }
+    },
+    {
+      "href": "/file/information/vs/0",
+      "rep": {
+        "x.com.samsung.timeoffset": "+09:00"
+      }
+    },
+    {
+      "href": "/filter/hepafilter/vs/0",
+      "rep": {
+        "x.com.samsung.da.filterUsage": "0",
+        "x.com.samsung.da.filterUsageResolution": "1",
+        "x.com.samsung.da.filterStatus": "normal",
+        "x.com.samsung.da.filterCapacity": "8760",
+        "x.com.samsung.da.filterCapacityUnit": "Hour",
+        "x.com.samsung.da.filterResetType": [
+          "replaceable"
+        ]
+      }
+    },
+    {
+      "href": "/humidity/0",
+      "rep": {}
+    },
+    {
+      "href": "/humidity/vs/0",
+      "rep": {}
+    },
+    {
+      "href": "/information/vs/0",
+      "rep": {
+        "x.com.samsung.da.modelNum": "A-VTWW-TP2-21-COMMON|10231241|70000535001511EC0505090201000000",
+        "x.com.samsung.da.description": "A-VTWW-TP2-21-COMMON",
+        "x.com.samsung.da.serialNum": "REDACTED",
+        "x.com.samsung.da.otnDUID": "REDACTED",
+        "x.com.samsung.da.diagProtocolType": "WIFI_HTTPS",
+        "x.com.samsung.da.diagLogType": [
+          "errCode",
+          "dump"
+        ],
+        "x.com.samsung.da.diagDumpType": "file",
+        "x.com.samsung.da.diagEndPoint": "SSM",
+        "x.com.samsung.da.diagMnid": "0AJT",
+        "x.com.samsung.da.diagSetupid": "101",
+        "x.com.samsung.da.diagMinVersion": "1.0",
+        "x.com.samsung.da.items": [
+          {
+            "x.com.samsung.da.id": "0",
+            "x.com.samsung.da.description": "Version",
+            "x.com.samsung.da.type": "Software",
+            "x.com.samsung.da.number": "02308A260310",
+            "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": "21063003,21063002",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/mode/convenient/vs/0",
+      "rep": {}
+    },
+    {
+      "href": "/mode/vs/0",
+      "rep": {
+        "x.com.samsung.da.options": [
+          "CountOfSlave_0",
+          "SlavePower01_NotSupported",
+          "Pollution_Off",
+          "OptionCode_23418",
+          "SmartSleep_Off"
+        ]
+      }
+    },
+    {
+      "href": "/otninformation/vs/0",
+      "rep": {
+        "x.com.samsung.da.target": "",
+        "x.com.samsung.da.newVersionAvailable": "false",
+        "x.com.samsung.da.newVersionNo": "00000000",
+        "x.com.samsung.da.currentVersionInfo": "00000000",
+        "otnStatus": "None",
+        "flashingProgress": "",
+        "otnTarget": "main",
+        "otnCompleteDate": "noHistory",
+        "otnList": [
+          {
+            "type": "WIFI",
+            "modelId": "A-VTWW-TP2-21-COMMON",
+            "versions": [
+              "12260310"
+            ],
+            "visVersion": "260310"
+          },
+          {
+            "type": "Micom",
+            "modelId": "09501023124110231341",
+            "versions": [
+              "21063003",
+              "21063002"
+            ],
+            "visVersion": "210630"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/power/0",
+      "rep": {
+        "value": false
+      }
+    },
+    {
+      "href": "/power/vs/0",
+      "rep": {
+        "x.com.samsung.da.power": "Off"
+      }
+    },
+    {
+      "href": "/realtimenotiforclient/vs/0",
+      "rep": {
+        "x.com.samsung.da.timeforshortnoti": "7",
+        "x.com.samsung.da.longnotisubscription": "true",
+        "x.com.samsung.da.periodicnotisubscription": "true"
+      }
+    },
+    {
+      "href": "/sensors/vs/0",
+      "rep": {
+        "x.com.samsung.da.items": [
+          {
+            "x.com.samsung.da.id": "0",
+            "x.com.samsung.da.description": "Sensor for Dust",
+            "x.com.samsung.da.type": "Dust",
+            "x.com.samsung.da.value": [
+              "5",
+              "1"
+            ]
+          },
+          {
+            "x.com.samsung.da.id": "1",
+            "x.com.samsung.da.description": "Sensor for FineDust",
+            "x.com.samsung.da.type": "FineDust",
+            "x.com.samsung.da.value": [
+              "5",
+              "1"
+            ]
+          },
+          {
+            "x.com.samsung.da.id": "2",
+            "x.com.samsung.da.description": "Sensor for Odor",
+            "x.com.samsung.da.type": "Odor",
+            "x.com.samsung.da.value": [
+              "1"
+            ]
+          },
+          {
+            "x.com.samsung.da.id": "3",
+            "x.com.samsung.da.description": "Sensor for CleanLevel",
+            "x.com.samsung.da.type": "CleanLevel",
+            "x.com.samsung.da.value": [
+              "1"
+            ]
+          },
+          {
+            "x.com.samsung.da.id": "4",
+            "x.com.samsung.da.description": "Sensor for SuperFineDust",
+            "x.com.samsung.da.type": "SuperFineDust",
+            "x.com.samsung.da.value": [
+              "5",
+              "1"
+            ]
+          }
+        ],
+        "x.com.samsung.da.total": "5"
+      }
+    },
+    {
+      "href": "/timezone/vs/0",
+      "rep": {
+        "timezoneid": "Asia/Seoul",
+        "offset": "+09:00",
+        "DST": "OFF"
+      }
+    },
+    {
+      "href": "/wind/strength/vs/0",
+      "rep": {
+        "x.com.samsung.da.modes": "87",
+        "x.com.samsung.da.supportedModes": [
+          "87",
+          "89",
+          "90",
+          "91"
+        ],
+        "x.com.samsung.da.modesName": [
+          "SMART",
+          "MAX",
+          "WINDFREE",
+          "Sleep"
+        ]
+      }
+    }
+  ]
+}

tests/fixtures/airconditioner_ara_ww_tp1_22_device.json

@@ -0,0 +1,476 @@
+{
+  "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": "54",
+        "x.com.samsung.da.filterUsageResolution": "1",
+        "x.com.samsung.da.filterDesiredUsage": "500",
+        "x.com.samsung.da.filterStatus": "normal",
+        "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",
+          "Nano",
+          "NanoSleep"
+        ]
+      }
+    },
+    {
+      "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": "0",
+        "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": "Left_And_Right",
+        "x.com.samsung.da.supportedModes": [
+          "Fix",
+          "Up_And_Low",
+          "Left_And_Right",
+          "All"
+        ]
+      }
+    },
+    {
+      "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-27T06:07:25",
+            "x.com.samsung.da.state": "Deleted"
+          },
+          {
+            "x.com.samsung.da.id": "1",
+            "x.com.samsung.da.description": "Alarm",
+            "x.com.samsung.da.alarmType": "Device",
+            "x.com.samsung.da.code": "FilterAlarm_OFF",
+            "x.com.samsung.da.triggeredTime": "2026-07-27T06:07:25",
+            "x.com.samsung.da.state": "Deleted"
+          }
+        ]
+      }
+    },
+    {
+      "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": "26.0",
+            "x.com.samsung.da.current": "30.0",
+            "x.com.samsung.da.maximum": "30",
+            "x.com.samsung.da.minimum": "18",
+            "x.com.samsung.da.increment": "1.0",
+            "x.com.samsung.da.unit": "Celsius"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/temperature/current/0",
+      "rep": {
+        "range": [
+          16,
+          30
+        ],
+        "units": "C",
+        "temperature": 30.0
+      }
+    },
+    {
+      "href": "/temperature/desired/0",
+      "rep": {
+        "range": [
+          16,
+          30
+        ],
+        "units": "C",
+        "temperature": 26.0
+      }
+    },
+    {
+      "href": "/energy/consumption/vs/0",
+      "rep": {
+        "x.com.samsung.da.instantaneousPower": "0.000000",
+        "x.com.samsung.da.cumulativePower": "3193591",
+        "x.com.samsung.da.cumulativeSavedPower": "158331",
+        "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": [
+          "Auto",
+          "Cool",
+          "Dry",
+          "Wind"
+        ],
+        "x.com.samsung.da.modes": [
+          "Dry"
+        ],
+        "x.com.samsung.da.options": [
+          "Sleep_0",
+          "ArtificialWorking_Off",
+          "ComfortAICooling_Off",
+          "AiTempChanged_Off",
+          "AiTemp_270",
+          "OutdoorConnection_Connected",
+          "OutdoorTemp_88",
+          "CoolCapa_53",
+          "WarmCapa_0",
+          "Light_Off",
+          "Volume_100",
+          "StopAutoClean_Idle",
+          "Autoclean_Off",
+          "DiagnosisAI_Off",
+          "ProgressDiagnosisAI_1",
+          "ResultDiagnosisAI_Normal",
+          "SmartCoolClean_Off",
+          "ProgressSmartClean_0",
+          "FreezeAlarmSetting_On",
+          "DesiredFreezeAlarm_112",
+          "WashAlarm_Off",
+          "OptionCode_56440",
+          "ExtendOptionCode_246413",
+          "RacInfo_None",
+          "UpdateAllow_NotAllowed",
+          "DurationOn_0",
+          "WelcomeCoolingState_On"
+        ]
+      }
+    },
+    {
+      "href": "/power/vs/0",
+      "rep": {
+        "x.com.samsung.da.power": "Off",
+        "x.com.samsung.da.displaycondition": "Enable"
+      }
+    },
+    {
+      "href": "/power/0",
+      "rep": {
+        "value": false
+      }
+    },
+    {
+      "href": "/sensors/vs/0",
+      "rep": {}
+    },
+    {
+      "href": "/information/vs/0",
+      "rep": {
+        "x.com.samsung.da.modelNum": "ARA-WW-TP1-22-COMMON|10229641|60010535001511014600083200800000",
+        "x.com.samsung.da.description": "ARA-WW-TP1-22-COMMON",
+        "x.com.samsung.da.serialNum": "**REDACTED**",
+        "x.com.samsung.da.otnDUID": "**REDACTED**",
+        "x.com.samsung.da.diagProtocolType": "WIFI_HTTPS",
+        "x.com.samsung.da.diagLogType": [
+          "errCode",
+          "dump"
+        ],
+        "x.com.samsung.da.diagDumpType": "file",
+        "x.com.samsung.da.diagEndPoint": "SSM",
+        "x.com.samsung.da.diagMnid": "0AJT",
+        "x.com.samsung.da.diagSetupid": "010",
+        "x.com.samsung.da.diagMinVersion": "1.0",
+        "x.com.samsung.da.diagTsId": "DA01",
+        "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": "02378A260327",
+            "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": "102296A23012700",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          },
+          {
+            "x.com.samsung.da.id": "2",
+            "x.com.samsung.da.description": "Version",
+            "x.com.samsung.da.type": "Firmware",
+            "x.com.samsung.da.number": "102295A22113000,102299A10000300",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/file/information/vs/0",
+      "rep": {
+        "x.com.samsung.timeoffset": "+08: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_COOLONLY_3.0",
+          "AI_3.0",
+          "Auto_To_AI"
+        ]
+      }
+    },
+    {
+      "href": "/humidity/0",
+      "rep": {
+        "humidity": 0
+      }
+    },
+    {
+      "href": "/humidity/vs/0",
+      "rep": {
+        "x.com.samsung.da.humidity": "0",
+        "x.com.samsung.da.fivepercentHumidity": "64"
+      }
+    },
+    {
+      "href": "/drlc/0",
+      "rep": {
+        "DRLevel": 1,
+        "start": "2026-07-27T05:07:32Z",
+        "duration": 20,
+        "override": false
+      }
+    },
+    {
+      "href": "/drlc/vs/0",
+      "rep": {
+        "x.com.samsung.da.drlcLevel": "1",
+        "x.com.samsung.da.duration": "20:47:00",
+        "x.com.samsung.da.drlcStartTime": "2026-07-27T05:07:32Z",
+        "x.com.samsung.da.override": "Off",
+        "x.com.samsung.da.realSaving": "Off"
+      }
+    },
+    {
+      "href": "/availablecontrolsets/vs/0",
+      "rep": {
+        "x.com.samsung.da.sets": "000000B4012C016102490C000000",
+        "x.com.samsung.da.id": "RAC",
+        "x.com.samsung.da.version": "1.0"
+      }
+    },
+    {
+      "href": "/keepnormalstate/vs/0",
+      "rep": {
+        "x.com.samsung.da.keepnormal": 1
+      }
+    },
+    {
+      "href": "/otninformation/vs/0",
+      "rep": {
+        "x.com.samsung.da.target": "",
+        "x.com.samsung.da.newVersionAvailable": "false",
+        "x.com.samsung.da.newVersionNo": "00000000",
+        "x.com.samsung.da.currentVersionInfo": "00000000",
+        "otnStatus": "None",
+        "flashingProgress": "",
+        "otnTarget": "main",
+        "otnCompleteDate": "noHistory",
+        "otnList": [
+          {
+            "type": "WIFI",
+            "modelId": "ARA-WW-TP1-22-COMMON",
+            "versions": [
+              "11260327"
+            ],
+            "visVersion": "260327"
+          },
+          {
+            "type": "Micom",
+            "modelId": "",
+            "versions": [
+              "23012700",
+              "FFFFFFFF"
+            ],
+            "visVersion": "230127"
+          },
+          {
+            "type": "Micom",
+            "modelId": "",
+            "versions": [
+              "23012700",
+              "FFFFFFFF"
+            ],
+            "visVersion": "230127"
+          }
+        ]
+      }
+    },
+    {
+      "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": "/timezone/vs/0",
+      "rep": {
+        "timezoneid": "Asia/Kuala_Lumpur",
+        "offset": "+08:00",
+        "DST": "OFF"
+      }
+    },
+    {
+      "href": "/option/muteonce/vs/0",
+      "rep": {
+        "muteonce": "Off"
+      }
+    },
+    {
+      "href": "/aisleep/vs/0",
+      "rep": {
+        "x.com.samsung.da.displayNightMode": "Off",
+        "x.com.samsung.da.elapsedTime": "0",
+        "x.com.samsung.da.requestFeedback": "Off",
+        "x.com.samsung.da.resultFeedback": "0",
+        "x.com.samsung.da.statusFeedback": "Idle",
+        "x.com.samsung.da.sleepTime": "14002200"
+      }
+    },
+    {
+      "href": "/wirelessinfo/vs/0",
+      "rep": {
+        "macaddressWiFi": "**REDACTED**",
+        "macaddressBLE": "**REDACTED**",
+        "connectedApSsid": "dreamer"
+      }
+    }
+  ]
+}

tests/fixtures/airconditioner_artik051_krac_18k_device.json

@@ -0,0 +1,232 @@
+{
+  "device0": [
+    {
+      "rt": [
+        "x.com.samsung.devcol",
+        "oic.wk.col"
+      ],
+      "if": [
+        "oic.if.baseline",
+        "oic.if.ll",
+        "oic.if.b"
+      ]
+    },
+    {
+      "href": "/airflow/0",
+      "rep": {
+        "speed": 3,
+        "direction": "Fix"
+      }
+    },
+    {
+      "href": "/airflow/vs/0",
+      "rep": {
+        "x.com.samsung.da.speedLevel": "3",
+        "x.com.samsung.da.direction": "Fix"
+      }
+    },
+    {
+      "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-28T00:18:15",
+            "x.com.samsung.da.state": "Deleted"
+          },
+          {
+            "x.com.samsung.da.id": "1",
+            "x.com.samsung.da.description": "Alarm",
+            "x.com.samsung.da.alarmType": "Device",
+            "x.com.samsung.da.code": "FilterAlarm_OFF",
+            "x.com.samsung.da.triggeredTime": "2026-07-28T00:18:15",
+            "x.com.samsung.da.state": "Deleted"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/configuration/vs/0",
+      "rep": {
+        "x.com.samsung.da.region": "0000000000"
+      }
+    },
+    {
+      "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.cumulativePower": "0"
+      }
+    },
+    {
+      "href": "/file/information/vs/0",
+      "rep": {
+        "x.com.samsung.timeoffset": "+01:00",
+        "x.com.samsung.supprtedtype": 1
+      }
+    },
+    {
+      "href": "/humidity/0",
+      "rep": {
+        "humidity": 0
+      }
+    },
+    {
+      "href": "/humidity/vs/0",
+      "rep": {
+        "x.com.samsung.da.humidity": "0"
+      }
+    },
+    {
+      "href": "/information/vs/0",
+      "rep": {
+        "x.com.samsung.da.modelNum": "ARTIK051_KRAC_18K|10193441|60010119001111110200000000000000",
+        "x.com.samsung.da.description": "ARTIK051_KRAC_18K",
+        "x.com.samsung.da.serialNum": "**REDACTED**",
+        "x.com.samsung.da.otnDUID": "**REDACTED**",
+        "x.com.samsung.da.items": [
+          {
+            "x.com.samsung.da.id": "0",
+            "x.com.samsung.da.description": "Version",
+            "x.com.samsung.da.type": "Software",
+            "x.com.samsung.da.number": "02016A200825",
+            "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": "18020800,17120500",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/mode/0",
+      "rep": {
+        "supportedModes": [
+          "Cool",
+          "Dry",
+          "Wind",
+          "Auto",
+          "Heat",
+          "HOMECARE_WIZARD_V2"
+        ],
+        "modes": [
+          "Cool"
+        ]
+      }
+    },
+    {
+      "href": "/mode/vs/0",
+      "rep": {
+        "x.com.samsung.da.supportedModes": [
+          "Cool",
+          "Dry",
+          "Wind",
+          "Auto",
+          "Heat",
+          "HOMECARE_WIZARD_V2"
+        ],
+        "x.com.samsung.da.modes": [
+          "Cool"
+        ],
+        "x.com.samsung.da.options": [
+          "Comode_Off",
+          "Sleep_0",
+          "OutdoorTemp_74",
+          "CoolCapa_25",
+          "WarmCapa_32",
+          "Spi_Off",
+          "Autoclean_Off",
+          "Light_Off",
+          "Volume_100",
+          "AirMonitoring_Off",
+          "AutocleanProgress_1",
+          "StopAutoClean_Idle",
+          "FilterTime_1715",
+          "FilterAlarmTime_500",
+          "OptionCode_35882",
+          "ExtendOptionCode_7",
+          "RacInfo_None",
+          "UpdateAllow_NotAllowed"
+        ]
+      }
+    },
+    {
+      "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": "/power/0",
+      "rep": {
+        "value": false
+      }
+    },
+    {
+      "href": "/power/vs/0",
+      "rep": {
+        "x.com.samsung.da.power": "Off"
+      }
+    },
+    {
+      "href": "/temperature/current/0",
+      "rep": {
+        "range": [
+          16.0,
+          30.0
+        ],
+        "units": "C",
+        "temperature": 21.0
+      }
+    },
+    {
+      "href": "/temperature/desired/0",
+      "rep": {
+        "range": [
+          16.0,
+          30.0
+        ],
+        "units": "C",
+        "temperature": 20.0
+      }
+    },
+    {
+      "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": "20",
+            "x.com.samsung.da.current": "21",
+            "x.com.samsung.da.maximum": "30",
+            "x.com.samsung.da.minimum": "16",
+            "x.com.samsung.da.unit": "Celsius"
+          }
+        ]
+      }
+    }
+  ]
+}

tests/fixtures/airconditioner_artik051_krac_18k_slot_device.json

@@ -0,0 +1,357 @@
+{
+  "device0": [
+    {
+      "rt": [
+        "x.com.samsung.devcol",
+        "oic.wk.col"
+      ],
+      "if": [
+        "oic.if.baseline",
+        "oic.if.ll",
+        "oic.if.b"
+      ]
+    },
+    {
+      "href": "/airflow/0",
+      "rep": {
+        "speed": 3,
+        "direction": "Fix"
+      }
+    },
+    {
+      "href": "/airflow/vs/0",
+      "rep": {
+        "x.com.samsung.da.speedLevel": "3",
+        "x.com.samsung.da.direction": "Fix"
+      }
+    },
+    {
+      "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-28T00:18:15",
+            "x.com.samsung.da.state": "Deleted"
+          },
+          {
+            "x.com.samsung.da.id": "1",
+            "x.com.samsung.da.description": "Alarm",
+            "x.com.samsung.da.alarmType": "Device",
+            "x.com.samsung.da.code": "FilterAlarm_OFF",
+            "x.com.samsung.da.triggeredTime": "2026-07-28T00:18:15",
+            "x.com.samsung.da.state": "Deleted"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/configuration/vs/0",
+      "rep": {
+        "x.com.samsung.da.region": "0000000000"
+      }
+    },
+    {
+      "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.cumulativePower": "0"
+      }
+    },
+    {
+      "href": "/file/information/vs/0",
+      "rep": {
+        "x.com.samsung.timeoffset": "+01:00",
+        "x.com.samsung.supprtedtype": 1
+      }
+    },
+    {
+      "href": "/humidity/0",
+      "rep": {
+        "humidity": 0
+      }
+    },
+    {
+      "href": "/humidity/vs/0",
+      "rep": {
+        "x.com.samsung.da.humidity": "0"
+      }
+    },
+    {
+      "href": "/information/vs/0",
+      "rep": {
+        "x.com.samsung.da.modelNum": "ARTIK051_KRAC_18K|10193441|60010119001111110200000000000000",
+        "x.com.samsung.da.description": "ARTIK051_KRAC_18K",
+        "x.com.samsung.da.serialNum": "**REDACTED**",
+        "x.com.samsung.da.otnDUID": "**REDACTED**",
+        "x.com.samsung.da.items": [
+          {
+            "x.com.samsung.da.id": "0",
+            "x.com.samsung.da.description": "Version",
+            "x.com.samsung.da.type": "Software",
+            "x.com.samsung.da.number": "02016A200825",
+            "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": "18020800,17120500",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/mode/0",
+      "rep": {
+        "supportedModes": [
+          "Cool",
+          "Dry",
+          "Wind",
+          "Auto",
+          "Heat",
+          "HOMECARE_WIZARD_V2"
+        ],
+        "modes": [
+          "Cool"
+        ]
+      }
+    },
+    {
+      "href": "/mode/vs/0",
+      "rep": {
+        "x.com.samsung.da.supportedModes": [
+          "Cool",
+          "Dry",
+          "Wind",
+          "Auto",
+          "Heat",
+          "HOMECARE_WIZARD_V2"
+        ],
+        "x.com.samsung.da.modes": [
+          "Cool"
+        ],
+        "x.com.samsung.da.options": [
+          "Comode_Off",
+          "Sleep_0",
+          "OutdoorTemp_74",
+          "CoolCapa_25",
+          "WarmCapa_32",
+          "Spi_Off",
+          "Autoclean_Off",
+          "Light_Off",
+          "Volume_100",
+          "AirMonitoring_Off",
+          "AutocleanProgress_1",
+          "StopAutoClean_Idle",
+          "FilterTime_1715",
+          "FilterAlarmTime_500",
+          "OptionCode_35882",
+          "ExtendOptionCode_7",
+          "RacInfo_None",
+          "UpdateAllow_NotAllowed"
+        ]
+      }
+    },
+    {
+      "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": "/power/0",
+      "rep": {
+        "value": false
+      }
+    },
+    {
+      "href": "/power/vs/0",
+      "rep": {
+        "x.com.samsung.da.power": "Off"
+      }
+    },
+    {
+      "href": "/temperature/current/0",
+      "rep": {
+        "range": [
+          16.0,
+          30.0
+        ],
+        "units": "C",
+        "temperature": 21.0
+      }
+    },
+    {
+      "href": "/temperature/desired/0",
+      "rep": {
+        "range": [
+          16.0,
+          30.0
+        ],
+        "units": "C",
+        "temperature": 20.0
+      }
+    },
+    {
+      "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": "20",
+            "x.com.samsung.da.current": "21",
+            "x.com.samsung.da.maximum": "30",
+            "x.com.samsung.da.minimum": "16",
+            "x.com.samsung.da.unit": "Celsius"
+          }
+        ]
+      }
+    }
+  ],
+  "oic_res": [],
+  "seeds": {
+    "/device/1": [
+      {
+        "rt": [
+          "x.com.samsung.devcol",
+          "oic.wk.col"
+        ],
+        "if": [
+          "oic.if.baseline",
+          "oic.if.ll",
+          "oic.if.b"
+        ]
+      },
+      {
+        "href": "/airflow/vs/1",
+        "rep": {}
+      },
+      {
+        "href": "/airflow/1",
+        "rep": {}
+      },
+      {
+        "href": "/alarms/vs/1",
+        "rep": {}
+      },
+      {
+        "href": "/temperatures/vs/1",
+        "rep": {
+          "x.com.samsung.da.items": [
+            {
+              "x.com.samsung.da.id": "0",
+              "x.com.samsung.da.description": "Temperature"
+            }
+          ]
+        }
+      },
+      {
+        "href": "/temperature/current/1",
+        "rep": {}
+      },
+      {
+        "href": "/temperature/desired/1",
+        "rep": {}
+      },
+      {
+        "href": "/diagnosis/vs/1",
+        "rep": {}
+      },
+      {
+        "href": "/energy/consumption/vs/1",
+        "rep": {
+          "x.com.samsung.da.cumulativePower": "117520000",
+          "x.com.samsung.da.cumulativeDate": "1785420000"
+        }
+      },
+      {
+        "href": "/energy/consumption/1",
+        "rep": {}
+      },
+      {
+        "href": "/mode/vs/1",
+        "rep": {}
+      },
+      {
+        "href": "/mode/1",
+        "rep": {}
+      },
+      {
+        "href": "/power/vs/1",
+        "rep": {}
+      },
+      {
+        "href": "/power/1",
+        "rep": {}
+      },
+      {
+        "href": "/information/vs/1",
+        "rep": {
+          "x.com.samsung.da.modelNum": "ARTIK051_KRAC_18K|10193441|60010119001111110200000000000000",
+          "x.com.samsung.da.description": "ARTIK051_KRAC_18K",
+          "x.com.samsung.da.serialNum": "**REDACTED**",
+          "x.com.samsung.da.otnDUID": "**REDACTED**",
+          "x.com.samsung.da.items": [
+            {
+              "x.com.samsung.da.id": "0",
+              "x.com.samsung.da.description": "Version",
+              "x.com.samsung.da.type": "Software",
+              "x.com.samsung.da.number": "02016A200825",
+              "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": "18020800,17120500",
+              "x.com.samsung.da.newVersionAvailable": "0"
+            }
+          ]
+        }
+      },
+      {
+        "href": "/file/information/vs/1",
+        "rep": {
+          "x.com.samsung.timeoffset": "+03:00",
+          "x.com.samsung.supprtedtype": 1
+        }
+      },
+      {
+        "href": "/configuration/vs/1",
+        "rep": {
+          "x.com.samsung.da.region": "0000000000"
+        }
+      },
+      {
+        "href": "/humidity/1",
+        "rep": {}
+      },
+      {
+        "href": "/humidity/vs/1",
+        "rep": {}
+      }
+    ]
+  },
+  "seeds_note": "device0 is the ARTIK051_KRAC_18K capture from airconditioner_artik051_krac_18k_device.json, verbatim -- a real dump, but from a different physical unit than the issue #214 reporter's AR12NXWXCWKNEU (same board family, modelNum differing only in the third segment). The reporter's own master resources were not quoted in the issue, so the master half of this fixture is that unit's stand-in. The /device/1 seed is the reporter's real slot, read off the `subdevices` block of their v0.17.0 diagnostics download (issue #214 comment 5131166356) and re-indexed from the canonical hrefs diagnostics reports back onto the real /x/1 hrefs the board answers on -- every rep is their value verbatim, including the empty {} on every operational resource and the populated /energy/consumption/vs/1, which is the whole point of this fixture. Two deliberate deviations: /information/vs/1 carries *this* fixture's master /information/vs/0 rep rather than the reporter's modelNum, because what their dump shows is the slot echoing its own master's model verbatim (ARTIK051_KRAC_18K|10193441|60010123001111110100000000000000, identical to their master's) and pasting that string against a different unit's master would misrepresent the slot as reporting a *different* model, which is what a real sibling does (see airconditioner_artik051_dongle_fac_18k_device.json's FAC_RAC subdevice); and /file/information/vs/1's +03:00 offset is the reporter's, so it doesn't match this master's +01:00 -- an artifact of the two halves coming from different units, not something the board did. oic_res is empty because the reporter's wasn't quoted either: enumeration therefore reaches /device/1 through the speculative _SPECULATIVE_DEVICE_INDICES probe, which is the path any board that doesn't advertise a sibling in /oic/res gets. Expected outcome: the candidate is found, then correctly held back by discover_partitioned's liveness gate -- a lifetime kWh counter is not evidence of a second indoor unit (issue #214)."
+}

tests/fixtures/airconditioner_artik051_krac_energy_device.json

@@ -0,0 +1,231 @@
+{
+  "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": "/airflow/vs/0",
+      "rep": {
+        "x.com.samsung.da.speedLevel": "0",
+        "x.com.samsung.da.direction": "All"
+      }
+    },
+    {
+      "href": "/airflow/0",
+      "rep": {
+        "speed": 0,
+        "direction": "All"
+      }
+    },
+    {
+      "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-29T12:29:36",
+            "x.com.samsung.da.state": "Deleted"
+          },
+          {
+            "x.com.samsung.da.id": "1",
+            "x.com.samsung.da.description": "Alarm",
+            "x.com.samsung.da.alarmType": "Device",
+            "x.com.samsung.da.code": "FilterAlarm_OFF",
+            "x.com.samsung.da.triggeredTime": "2026-07-29T12:29:36",
+            "x.com.samsung.da.state": "Deleted"
+          }
+        ]
+      }
+    },
+    {
+      "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": "23",
+            "x.com.samsung.da.current": "23",
+            "x.com.samsung.da.maximum": "30",
+            "x.com.samsung.da.minimum": "16",
+            "x.com.samsung.da.unit": "Celsius"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/temperature/current/0",
+      "rep": {
+        "range": [
+          16.0,
+          30.0
+        ],
+        "units": "C",
+        "temperature": 23.0
+      }
+    },
+    {
+      "href": "/temperature/desired/0",
+      "rep": {
+        "range": [
+          16.0,
+          30.0
+        ],
+        "units": "C",
+        "temperature": 23.0
+      }
+    },
+    {
+      "href": "/diagnosis/vs/0",
+      "rep": {
+        "x.com.samsung.da.diagnosisStart": "Ready"
+      }
+    },
+    {
+      "href": "/energy/consumption/vs/0",
+      "rep": {
+        "x.com.samsung.da.cumulativePower": "117430000",
+        "x.com.samsung.da.cumulativeDate": "1785337200"
+      }
+    },
+    {
+      "href": "/energy/consumption/0",
+      "rep": {}
+    },
+    {
+      "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": [
+          "Comode_Off",
+          "Sleep_0",
+          "OutdoorTemp_85",
+          "CoolCapa_35",
+          "WarmCapa_35",
+          "Spi_Off",
+          "Autoclean_Off",
+          "Light_Off",
+          "Volume_100",
+          "AirMonitoring_Off",
+          "AutocleanProgress_0",
+          "StopAutoClean_Idle",
+          "FilterTime_1425",
+          "FilterAlarmTime_500",
+          "OptionCode_56378",
+          "ExtendOptionCode_7",
+          "RacInfo_None",
+          "UpdateAllow_NotAllowed"
+        ]
+      }
+    },
+    {
+      "href": "/mode/0",
+      "rep": {
+        "supportedModes": [
+          "Cool",
+          "Dry",
+          "Wind",
+          "Auto",
+          "Heat"
+        ],
+        "modes": [
+          "Cool"
+        ]
+      }
+    },
+    {
+      "href": "/power/vs/0",
+      "rep": {
+        "x.com.samsung.da.power": "On"
+      }
+    },
+    {
+      "href": "/power/0",
+      "rep": {
+        "value": true
+      }
+    },
+    {
+      "href": "/information/vs/0",
+      "rep": {
+        "x.com.samsung.da.modelNum": "ARTIK051_KRAC_18K|10193441|60010123001111110100000000000000",
+        "x.com.samsung.da.description": "ARTIK051_KRAC_18K",
+        "x.com.samsung.da.serialNum": "**REDACTED**",
+        "x.com.samsung.da.otnDUID": "**REDACTED**",
+        "x.com.samsung.da.items": [
+          {
+            "x.com.samsung.da.id": "0",
+            "x.com.samsung.da.description": "Version",
+            "x.com.samsung.da.type": "Software",
+            "x.com.samsung.da.number": "02016A200825",
+            "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": "17110700,17110600",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/file/information/vs/0",
+      "rep": {
+        "x.com.samsung.timeoffset": "+03:00",
+        "x.com.samsung.supprtedtype": 1
+      }
+    },
+    {
+      "href": "/configuration/vs/0",
+      "rep": {
+        "x.com.samsung.da.region": "0000000000"
+      }
+    },
+    {
+      "href": "/humidity/0",
+      "rep": {
+        "humidity": 0
+      }
+    },
+    {
+      "href": "/humidity/vs/0",
+      "rep": {
+        "x.com.samsung.da.humidity": "0"
+      }
+    }
+  ]
+}

tests/fixtures/airconditioner_cac_device.json

@@ -0,0 +1,919 @@
+{
+  "device0": [
+    {
+      "rt": [
+        "x.com.samsung.devcol",
+        "oic.wk.col"
+      ],
+      "if": [
+        "oic.if.baseline",
+        "oic.if.ll",
+        "oic.if.b"
+      ]
+    },
+    {
+      "href": "/airlevelcheck/vs/0",
+      "rep": {
+        "x.com.samsung.da.periodicSensingInterval": "1800",
+        "x.com.samsung.da.sensingState": "NonProcessing",
+        "x.com.samsung.da.lastSensingTime": "1785327477",
+        "x.com.samsung.da.lastSensingLevel": "Kr1",
+        "x.com.samsung.da.periodicSensingSkipStatus": "Off",
+        "x.com.samsung.da.periodicSensingSkipTime": "00000000",
+        "x.com.samsung.da.periodicSensingActivationState": "On",
+        "x.com.samsung.da.autoExeState": "Alarm",
+        "x.com.samsung.da.supportedAutoExeState": [
+          "Airpurify",
+          "Alarm",
+          "Sensing"
+        ],
+        "x.com.samsung.da.startSensingOnce": "Off",
+        "x.com.samsung.da.autoExeSetting": "On",
+        "x.com.samsung.da.supportedAutoExeSetting": [
+          "On",
+          "Off"
+        ]
+      }
+    },
+    {
+      "href": "/aisleep/vs/0",
+      "rep": {
+        "x.com.samsung.da.displayNightMode": "Off",
+        "x.com.samsung.da.elapsedTime": "0",
+        "x.com.samsung.da.requestFeedback": "Off",
+        "x.com.samsung.da.resultFeedback": 0,
+        "x.com.samsung.da.statusFeedback": "Idle",
+        "x.com.samsung.da.sleepTime": "14002200"
+      }
+    },
+    {
+      "href": "/alarms/vs/0",
+      "rep": {
+        "x.com.samsung.da.items": [
+          {
+            "x.com.samsung.da.id": "0",
+            "x.com.samsung.da.alarmType": "Device",
+            "x.com.samsung.da.code": "ErrorCode_OFF",
+            "x.com.samsung.da.triggeredTime": "2026-07-29T12:19:55",
+            "x.com.samsung.da.state": "Deleted"
+          },
+          {
+            "x.com.samsung.da.id": "1",
+            "x.com.samsung.da.alarmType": "Device",
+            "x.com.samsung.da.code": "FilterAlarm_OFF",
+            "x.com.samsung.da.triggeredTime": "2026-07-29T12:19:55",
+            "x.com.samsung.da.state": "Deleted"
+          },
+          {
+            "x.com.samsung.da.id": "2",
+            "x.com.samsung.da.alarmType": "Device",
+            "x.com.samsung.da.code": "DA_SAC_M_OFF",
+            "x.com.samsung.da.triggeredTime": "2026-07-29T12:19:55",
+            "x.com.samsung.da.state": "Deleted"
+          }
+        ],
+        "rt": [
+          "x.com.samsung.da.alarms"
+        ],
+        "if": [
+          "oic.if.baseline",
+          "oic.if.a"
+        ]
+      }
+    },
+    {
+      "href": "/availablecontrolsets/vs/0",
+      "rep": {
+        "x.com.samsung.da.sets": "000100B4012C0000B20001000000",
+        "x.com.samsung.da.id": "CAC",
+        "x.com.samsung.da.version": "1.0"
+      }
+    },
+    {
+      "href": "/configuration/vs/0",
+      "rep": {
+        "x.com.samsung.da.region": "4146100000",
+        "x.com.samsung.da.airconOptionList": [
+          "AI_KOREA_COOLONLY_4.0",
+          "HOMECARE_WIZARD_V2",
+          "CLEAN_OPTION_SUPPORT",
+          "DR",
+          "SingleCommand_1"
+        ]
+      }
+    },
+    {
+      "href": "/da/softreset/vs/0",
+      "rep": {
+        "x.com.samsung.da.softwarereset": "false"
+      }
+    },
+    {
+      "href": "/drlc/vs/0",
+      "rep": {
+        "x.com.samsung.da.start": "2026-07-29T07:26:56Z",
+        "x.com.samsung.da.override": "Off",
+        "x.com.samsung.da.durationminutes": "1019",
+        "x.com.samsung.da.drlcLevel": "1",
+        "x.com.samsung.da.realSaving": "Off"
+      }
+    },
+    {
+      "href": "/edgelighting/vs/0",
+      "rep": {
+        "status": "On",
+        "convenientMode": "On",
+        "operatingOption": "On",
+        "welcomeLightStatus": "Off",
+        "colorOption": "3000K",
+        "mode": "Smart",
+        "modeSupportedList": [
+          "Smart",
+          "High",
+          "Low"
+        ],
+        "colorSupportedList": [
+          "3000K",
+          "4000K",
+          "6500K"
+        ]
+      }
+    },
+    {
+      "href": "/energy/consumption/vs/0",
+      "rep": {
+        "x.com.samsung.da.cumulativeDate": "1785327589",
+        "x.com.samsung.da.instantaneousPower": "15",
+        "x.com.samsung.da.cumulativeSavedPower": "1611",
+        "x.com.samsung.da.cumulativePower": "84044",
+        "x.com.samsung.da.cumulativeUnit": "Wh",
+        "x.com.samsung.da.instantaneousPowerUnit": "W",
+        "x.com.samsung.da.cumulativePowerType": "individual"
+      }
+    },
+    {
+      "href": "/file/information/vs/0",
+      "rep": {
+        "x.com.samsung.timeoffset": "+09:00",
+        "x.com.samsung.supprtedtype": 1
+      }
+    },
+    {
+      "href": "/filter/airdustPM1filter/vs/0",
+      "rep": {
+        "x.com.samsung.da.filterUsageResolution": "1",
+        "x.com.samsung.da.filterCapacity": "2400",
+        "x.com.samsung.da.filterCapacityUnit": "Hour",
+        "x.com.samsung.da.filterResetType": [
+          "washable"
+        ],
+        "x.com.samsung.da.filterStatus": "normal",
+        "x.com.samsung.da.filterUsage": "11"
+      }
+    },
+    {
+      "href": "/filter/airdustfilter/vs/0",
+      "rep": {
+        "x.com.samsung.da.filterUsageResolution": "1",
+        "x.com.samsung.da.filterCapacity": "180",
+        "x.com.samsung.da.filterCapacityUnit": "Hour",
+        "x.com.samsung.da.filterResetType": [
+          "washable"
+        ],
+        "x.com.samsung.da.filterStatus": "normal",
+        "x.com.samsung.da.filterUsage": "26"
+      }
+    },
+    {
+      "href": "/humidity/vs/0",
+      "rep": {
+        "x.com.samsung.da.humidity": "0",
+        "x.com.samsung.da.fivepercentHumidity": "59"
+      }
+    },
+    {
+      "href": "/information/vs/0",
+      "rep": {
+        "x.com.samsung.da.otnDUID": "**REDACTED**",
+        "x.com.samsung.da.modelNum": "TP1X_DA-AC-CAC-01001_0000|10255541|60030748171811DF42005F2A00F2ED00",
+        "x.com.samsung.da.description": "TP1X_DA-AC-CAC-01001_0000",
+        "x.com.samsung.da.serialNum": "**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": "02706A260401",
+            "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.newVersionAvailable": "0",
+            "x.com.samsung.da.number": "02555A25052600,02556A24040200"
+          },
+          {
+            "x.com.samsung.da.id": "2",
+            "x.com.samsung.da.description": "Version",
+            "x.com.samsung.da.type": "Outdoor",
+            "x.com.samsung.da.newVersionAvailable": "0",
+            "x.com.samsung.da.number": "FFFFFFFFFFFFFF,FFFFFFFFFFFFFF"
+          }
+        ],
+        "x.com.samsung.da.diagDumpType": "file",
+        "x.com.samsung.da.diagEndPoint": "SSM",
+        "x.com.samsung.da.diagLogType": [
+          "errCode",
+          "dump"
+        ],
+        "x.com.samsung.da.diagMnid": "0AJT",
+        "x.com.samsung.da.diagSetupid": "AS3",
+        "x.com.samsung.da.diagProtocolType": "BLE_OCF",
+        "x.com.samsung.da.diagMinVersion": "3.0",
+        "x.com.samsung.da.diagTsId": "DA01"
+      }
+    },
+    {
+      "href": "/keepnormalstate/vs/0",
+      "rep": {
+        "x.com.samsung.da.keepnormal": 0
+      }
+    },
+    {
+      "href": "/light/stateful/vs/0",
+      "rep": {
+        "status": "On",
+        "mode": "Smart",
+        "supportedModes": [
+          "Smart",
+          "Low",
+          "High"
+        ]
+      }
+    },
+    {
+      "href": "/mds/absenceclean/vs/0",
+      "rep": {
+        "mode": "Off",
+        "supportedModes": [
+          "On",
+          "Off"
+        ]
+      }
+    },
+    {
+      "href": "/mds/absencemonitoring/vs/0",
+      "rep": {
+        "status": "Off"
+      }
+    },
+    {
+      "href": "/mds/absencepowersaving/vs/0",
+      "rep": {
+        "status": "On",
+        "modes": "Cooling",
+        "switchPowerSaveMode": "Normal",
+        "supportedModes": [
+          "Standby",
+          "Cooling"
+        ],
+        "supportedSwitchPowerSaveMode": [
+          "Eco",
+          "Normal",
+          "Comfort"
+        ]
+      }
+    },
+    {
+      "href": "/mds/absencestate/vs/0",
+      "rep": {
+        "status": "On",
+        "absenceTime": "0",
+        "maxDetectCount": [
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "3",
+          "3",
+          "3",
+          "2",
+          "3",
+          "0",
+          "0",
+          "3",
+          "0",
+          "3",
+          "3",
+          "3",
+          "0",
+          "3",
+          "1",
+          "2",
+          "3",
+          "3",
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "0",
+          "1",
+          "0",
+          "3",
+          "2",
+          "3",
+          "1",
+          "2",
+          "1",
+          "0",
+          "0",
+          "0",
+          "0"
+        ],
+        "supportedTimes": [
+          "0",
+          "30",
+          "60",
+          "120"
+        ]
+      }
+    },
+    {
+      "href": "/mode/convenient/vs/0",
+      "rep": {
+        "x.com.samsung.da.modes": "Off",
+        "x.com.samsung.da.supportedModes": [
+          "Off",
+          "Nano",
+          "LongWind",
+          "Speed",
+          "Sleep",
+          "NanoSleep"
+        ]
+      }
+    },
+    {
+      "href": "/mode/vs/0",
+      "rep": {
+        "x.com.samsung.da.modes": [
+          "Cool"
+        ],
+        "workingMode": "Cool",
+        "x.com.samsung.da.supportedModes": [
+          "AIComfort",
+          "Auto",
+          "Cool",
+          "Dry",
+          "Fan"
+        ],
+        "x.com.samsung.da.options": [
+          "OptionCode_512",
+          "Sleep_0",
+          "ArtificialWorking_Off",
+          "ComfortAICooling_Off",
+          "AiTempChanged_Off",
+          "AiTemp_240",
+          "welcomecareElapsedTime_0",
+          "welcomecareThresholdTemp_0",
+          "welcomecareStartDate_0000",
+          "welcomecareEndDate_0000",
+          "welcomecareSeason_None",
+          "welcomecare_Off",
+          "DiagnosisAI_Off",
+          "ProgressDiagnosisAI_0",
+          "ResultDiagnosisAI_Normal",
+          "SmartCoolClean_Off",
+          "ProgressSmartClean_0",
+          "FreezeAlarmSetting_On",
+          "DesiredFreezeAlarm_112",
+          "ExtendOptionCode_0",
+          "UpdateAllow_NotAllowed",
+          "DurationOn_0",
+          "OutdoorTemp_55",
+          "KeyInputPermit_On",
+          "ModePermit_NoLimit"
+        ],
+        "rt": [
+          "x.com.samsung.da.mode"
+        ],
+        "if": [
+          "oic.if.baseline",
+          "oic.if.a"
+        ],
+        "x.com.samsung.da.items": [
+          {
+            "x.com.samsung.da.id": "0",
+            "x.com.samsung.da.description": "Temperature",
+            "x.com.samsung.da.current": "28.5",
+            "x.com.samsung.da.desired": "28.0",
+            "x.com.samsung.da.minimum": "18",
+            "x.com.samsung.da.maximum": "30",
+            "x.com.samsung.da.increment": "0.5",
+            "x.com.samsung.da.unit": "Celsius"
+          }
+        ]
+      }
+    },
+    {
+      "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.supportedStatus": [
+          "Start",
+          "Stop"
+        ],
+        "x.com.samsung.da.progress": "0",
+        "x.com.samsung.da.settingStatus": "On",
+        "x.com.samsung.da.supportedSettingStatus": [
+          "On",
+          "Off"
+        ],
+        "defaultSettingStatus": "On"
+      }
+    },
+    {
+      "href": "/option/motiondetectwind/stateful/vs/0",
+      "rep": {
+        "status": "On",
+        "modes": "Indirect",
+        "supportedModes": [
+          "Indirect",
+          "Direct"
+        ]
+      }
+    },
+    {
+      "href": "/option/muteonce/vs/0",
+      "rep": {
+        "muteonce": "Off"
+      }
+    },
+    {
+      "href": "/personality/presence/vs/0",
+      "rep": {}
+    },
+    {
+      "href": "/power/vs/0",
+      "rep": {
+        "x.com.samsung.da.power": "Off",
+        "operationNumber": "46"
+      }
+    },
+    {
+      "href": "/realtimenotiforclient/vs/0",
+      "rep": {
+        "x.com.samsung.da.timeforshortnoti": "0",
+        "x.com.samsung.da.longnotisubscription": "true",
+        "x.com.samsung.da.periodicnotisubscription": "true"
+      }
+    },
+    {
+      "href": "/remotedatacontrol/vs/0",
+      "rep": {
+        "x.com.samsung.da.status": "Off",
+        "x.com.samsung.da.connectionStatus": "Disconnected"
+      }
+    },
+    {
+      "href": "/remotetemperature/vs/0",
+      "rep": {
+        "x.com.samsung.da.temperature": "",
+        "x.com.samsung.da.unit": "",
+        "x.com.samsung.da.error": ""
+      }
+    },
+    {
+      "href": "/reserverulesets/vs/0",
+      "rep": {
+        "x.com.samsung.da.sets": "1F121E121E121E121EFFFFFFFF010001000F0001000E0000001C3E",
+        "x.com.samsung.da.id": "CAC",
+        "x.com.samsung.da.version": "1.0"
+      }
+    },
+    {
+      "href": "/sac/installationinfo/vs/0",
+      "rep": {
+        "installationOptions": [
+          {
+            "id": "0",
+            "option": "184449945E0484800017"
+          },
+          {
+            "id": "1",
+            "option": "28010000010000000100"
+          },
+          {
+            "id": "2",
+            "option": "50000000000000000001"
+          },
+          {
+            "id": "3",
+            "option": "30000000000000000000"
+          }
+        ],
+        "installationDeviceNum": [
+          {
+            "id": "0",
+            "number": "0"
+          },
+          {
+            "id": "1",
+            "number": "5"
+          },
+          {
+            "id": "2",
+            "number": "0"
+          }
+        ],
+        "outdoorInfo": [
+          {
+            "id": "0",
+            "info": "02571A250514",
+            "serial": "**REDACTED**"
+          },
+          {
+            "id": "1",
+            "info": "000000000000",
+            "serial": "**REDACTED**"
+          },
+          {
+            "id": "2",
+            "info": "000000000000",
+            "serial": "**REDACTED**"
+          },
+          {
+            "id": "3",
+            "info": "000000000000",
+            "serial": "**REDACTED**"
+          }
+        ],
+        "mcuInfo": [
+          {
+            "id": "0",
+            "info": "000000000000"
+          },
+          {
+            "id": "1",
+            "info": "000000000000"
+          },
+          {
+            "id": "2",
+            "info": "000000000000"
+          },
+          {
+            "id": "3",
+            "info": "000000000000"
+          },
+          {
+            "id": "4",
+            "info": "000000000000"
+          },
+          {
+            "id": "5",
+            "info": "000000000000"
+          },
+          {
+            "id": "6",
+            "info": "000000000000"
+          },
+          {
+            "id": "7",
+            "info": "000000000000"
+          },
+          {
+            "id": "8",
+            "info": "000000000000"
+          },
+          {
+            "id": "9",
+            "info": "000000000000"
+          },
+          {
+            "id": "10",
+            "info": "000000000000"
+          },
+          {
+            "id": "11",
+            "info": "000000000000"
+          },
+          {
+            "id": "12",
+            "info": "000000000000"
+          },
+          {
+            "id": "13",
+            "info": "000000000000"
+          },
+          {
+            "id": "14",
+            "info": "000000000000"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/selfcheck/vs/0",
+      "rep": {
+        "x.com.samsung.da.start": "Cancel",
+        "x.com.samsung.da.status": "Ready",
+        "x.com.samsung.da.progress": "0",
+        "x.com.samsung.da.result": "NA",
+        "x.com.samsung.da.supportedActions": [
+          "Start",
+          "Cancel"
+        ],
+        "x.com.samsung.da.error": [
+          "DA_ERROR_NONE"
+        ]
+      }
+    },
+    {
+      "href": "/sensors/vs/0",
+      "rep": {
+        "x.com.samsung.da.cleanLevel": "1",
+        "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": [
+              "1"
+            ]
+          },
+          {
+            "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": [
+              "7",
+              "1"
+            ]
+          },
+          {
+            "x.com.samsung.da.id": "3",
+            "x.com.samsung.da.description": "Sensor for FineDust",
+            "x.com.samsung.da.type": "FineDust",
+            "x.com.samsung.da.value": [
+              "5",
+              "1"
+            ]
+          },
+          {
+            "x.com.samsung.da.id": "4",
+            "x.com.samsung.da.description": "Sensor for SuperFineDust",
+            "x.com.samsung.da.type": "SuperFineDust",
+            "x.com.samsung.da.value": [
+              "5",
+              "1"
+            ]
+          }
+        ]
+      }
+    },
+    {
+      "href": "/settings/sound/mode/vs/0",
+      "rep": {
+        "mode": "voice",
+        "supportedModes": [
+          "mute",
+          "tone",
+          "voice"
+        ]
+      }
+    },
+    {
+      "href": "/settings/sound/optimization/vs/0",
+      "rep": {
+        "status": "Off",
+        "supportedModes": [
+          "On",
+          "Off"
+        ]
+      }
+    },
+    {
+      "href": "/settings/sound/output/vs/0",
+      "rep": {
+        "deviceType": "speaker"
+      }
+    },
+    {
+      "href": "/settings/sound/volume/vs/0",
+      "rep": {
+        "level": "2",
+        "minLevel": "0",
+        "maxLevel": "3",
+        "resolution": "1"
+      }
+    },
+    {
+      "href": "/smartsensingcooling/vs/0",
+      "rep": {
+        "status": "On",
+        "supportedModes": [
+          "On",
+          "Off"
+        ]
+      }
+    },
+    {
+      "href": "/temperature/control/vs/0",
+      "rep": {
+        "x.com.samsung.da.increment": "0.5"
+      }
+    },
+    {
+      "href": "/temperatures/vs/0",
+      "rep": {
+        "x.com.samsung.da.items": [
+          {
+            "x.com.samsung.da.id": "0",
+            "x.com.samsung.da.description": "Temperature",
+            "x.com.samsung.da.current": "28.5",
+            "x.com.samsung.da.desired": "28.0",
+            "x.com.samsung.da.minimum": "18",
+            "x.com.samsung.da.maximum": "30",
+            "x.com.samsung.da.increment": "0.5",
+            "x.com.samsung.da.unit": "Celsius"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/uvled/vs/0",
+      "rep": {
+        "x.com.samsung.da.modes": "On",
+        "x.com.samsung.da.start": "Cancel",
+        "x.com.samsung.da.pushAlarmStatus": "Off",
+        "x.com.samsung.da.supportedModes": [
+          "On",
+          "Off"
+        ]
+      }
+    },
+    {
+      "href": "/wind/direction/vs/0",
+      "rep": {
+        "x.com.samsung.da.modes": "Fix",
+        "x.com.samsung.da.supportedModes": [
+          "Left_And_Right",
+          "All"
+        ]
+      }
+    },
+    {
+      "href": "/wind/strength/vs/0",
+      "rep": {
+        "x.com.samsung.da.modes": "0",
+        "x.com.samsung.da.supportedModes": [
+          "0",
+          "1",
+          "2",
+          "3"
+        ],
+        "x.com.samsung.da.modesName": [
+          "Auto",
+          "Low",
+          "Mid",
+          "High"
+        ]
+      }
+    },
+    {
+      "href": "/otninformation/vs/0",
+      "rep": {
+        "x.com.samsung.da.target": "",
+        "x.com.samsung.da.newVersionAvailable": "false",
+        "otnStatus": "None",
+        "flashingProgress": "0",
+        "otnCompleteDate": "noHistory",
+        "scheduledTime": "None",
+        "swVersionInfo": {
+          "platform": "Tizen Lite",
+          "oneUiVersion": "7.0 Air conditioner",
+          "osVersion": "4.0"
+        },
+        "otnList": [
+          {
+            "type": "WIFI",
+            "modelId": "ASA-WW-TP1-24-INFSAC",
+            "versions": [
+              "14260401"
+            ],
+            "visVersion": "260401"
+          },
+          {
+            "type": "Micom",
+            "modelId": "04001025554110255641",
+            "versions": [
+              "25052600",
+              "24040200"
+            ],
+            "visVersion": "250526"
+          },
+          {
+            "type": "Micom",
+            "modelId": "FGCAN2",
+            "versions": [
+              "",
+              ""
+            ],
+            "visVersion": "999999"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/timezone/vs/0",
+      "rep": {
+        "timezoneid": "Asia/Seoul",
+        "offset": "+09:00",
+        "DST": "OFF"
+      }
+    },
+    {
+      "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": "/wirelessinfo/vs/0",
+      "rep": {
+        "macaddressWiFi": "**REDACTED**",
+        "macaddressBLE": "**REDACTED**",
+        "connectedApSsid": "boksil"
+      }
+    },
+    {
+      "href": "/quickcontrol/info/vs/0",
+      "rep": {
+        "supportedVersion": "1.0"
+      }
+    },
+    {
+      "href": "/dginformation/vs/0",
+      "rep": {
+        "enrolmentstatus": "Unknown",
+        "devicestate": "Unknown",
+        "lockstatus": "Unknown",
+        "nextduedate": "",
+        "workingminutes": 0,
+        "paymentinfo": {
+          "emiplan": "Unknown",
+          "currency": "Unknown",
+          "totalemi": 0,
+          "totalemipaid": 0
+        }
+      }
+    }
+  ]
+}

tests/fixtures/airconditioner_fac_bora_205_flat_device.json

@@ -0,0 +1,720 @@
+{
+  "device0": [
+    {
+      "rt": [
+        "x.com.samsung.devcol",
+        "oic.wk.col"
+      ],
+      "if": [
+        "oic.if.baseline",
+        "oic.if.ll",
+        "oic.if.b"
+      ]
+    },
+    {
+      "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-30T01:48:51"
+          },
+          {
+            "x.com.samsung.da.id": "2",
+            "x.com.samsung.da.description": "Alarm",
+            "x.com.samsung.da.alarmType": "Device",
+            "x.com.samsung.da.code": "AC_V_0002_OFF",
+            "x.com.samsung.da.triggeredTime": "2026-07-30T01:48:51"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/availablecontrolsets/vs/0",
+      "rep": {
+        "x.com.samsung.da.sets": "000000B4012C0000404B04000000",
+        "x.com.samsung.da.id": "FAC",
+        "x.com.samsung.da.version": "1.0"
+      }
+    },
+    {
+      "href": "/configuration/vs/0",
+      "rep": {
+        "x.com.samsung.da.region": "3017000000",
+        "x.com.samsung.da.airconOptionList": [
+          "HOMECARE_WIZARD_V2",
+          "ENERGY_2.0",
+          "AI_2.0",
+          "DeviceTypeMaster",
+          "SingleCommand_1"
+        ]
+      }
+    },
+    {
+      "href": "/diagnosis/vs/0",
+      "rep": {}
+    },
+    {
+      "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"
+      }
+    },
+    {
+      "href": "/energy/consumption/0",
+      "rep": {
+        "energy": 800.0,
+        "power": 65278.0
+      }
+    },
+    {
+      "href": "/energy/consumption/vs/0",
+      "rep": {
+        "x.com.samsung.da.cumulativeConsumption": "800.000000",
+        "x.com.samsung.da.instantaneousPower": "65278.000000",
+        "x.com.samsung.da.usageThreshold": "0.000000",
+        "x.com.samsung.da.cumulativePower": "544088",
+        "x.com.samsung.da.cumulativeUnit": "Wh",
+        "x.com.samsung.da.instantaneousPowerUnit": "W",
+        "x.com.samsung.da.cumulativePowerType": "individual"
+      }
+    },
+    {
+      "href": "/file/information/vs/0",
+      "rep": {
+        "x.com.samsung.timeoffset": "+09:00",
+        "x.com.samsung.supprtedtype": 1
+      }
+    },
+    {
+      "href": "/filter/airdustfilter/vs/0",
+      "rep": {
+        "x.com.samsung.da.filterUsage": "0",
+        "x.com.samsung.da.filterUsageResolution": "1",
+        "x.com.samsung.da.filterDesiredUsage": "112",
+        "x.com.samsung.da.filterStatus": "normal",
+        "x.com.samsung.da.filterCapacity": "112",
+        "x.com.samsung.da.filterCapacityUnit": "Hour",
+        "x.com.samsung.da.filterResetType": [
+          "washable"
+        ],
+        "x.com.samsung.da.supportedFilterDesiredUsage": [
+          "112",
+          "224",
+          "336",
+          "448"
+        ]
+      }
+    },
+    {
+      "href": "/humidity/0",
+      "rep": {
+        "humidity": 0
+      }
+    },
+    {
+      "href": "/humidity/vs/0",
+      "rep": {
+        "x.com.samsung.da.humidity": "0.000000",
+        "x.com.samsung.da.fivepercentHumidity": "58"
+      }
+    },
+    {
+      "href": "/information/vs/0",
+      "rep": {
+        "x.com.samsung.da.modelNum": "TP2X_FAC_BORA_21K|10233041|600001110015110006000C1200830000",
+        "x.com.samsung.da.description": "TP2X_FAC_BORA_21K",
+        "x.com.samsung.da.serialNum": "**REDACTED**",
+        "x.com.samsung.da.otnDUID": "**REDACTED**",
+        "x.com.samsung.da.diagProtocolType": "WIFI_HTTPS",
+        "x.com.samsung.da.diagLogType": [
+          "errCode",
+          "dump"
+        ],
+        "x.com.samsung.da.diagDumpType": "file",
+        "x.com.samsung.da.diagEndPoint": "SSM",
+        "x.com.samsung.da.diagMnid": "0AJT",
+        "x.com.samsung.da.diagSetupid": "000",
+        "x.com.samsung.da.diagMinVersion": "1.0",
+        "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": "02337A260424",
+            "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": "2102240021022200",
+            "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": "2103300110000300"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/keepnormalstate/vs/0",
+      "rep": {
+        "x.com.samsung.da.keepnormal": 5
+      }
+    },
+    {
+      "href": "/mode/convenient/vs/0",
+      "rep": {
+        "x.com.samsung.da.modes": "Off",
+        "x.com.samsung.da.supportedModes": [
+          "Off",
+          "Sleep",
+          "Quiet",
+          "Speed"
+        ]
+      }
+    },
+    {
+      "href": "/mode/vs/0",
+      "rep": {
+        "x.com.samsung.da.supportedModes": [
+          "AIComfort",
+          "Cool",
+          "Dry",
+          "Wind"
+        ],
+        "x.com.samsung.da.modes": [
+          "Wind"
+        ],
+        "x.com.samsung.da.options": [
+          "Operation_Family",
+          "Blooming_0",
+          "OnTimer_0",
+          "OffTimer_0",
+          "Sleep_16",
+          "ArtificialWorking_Off",
+          "ComfortAICooling_Off",
+          "AiTempChanged_Off",
+          "AiTemp_270",
+          "welcomecare_Off",
+          "Panel_Close",
+          "Weather_Off",
+          "Volume_100",
+          "StopAutoClean_Idle",
+          "DiagnosisAI_Off",
+          "Display_Off",
+          "ProgressDiagnosisAI_1",
+          "ResultDiagnosisAI_Normal",
+          "Service_Off",
+          "SmartCoolClean_Off",
+          "ProgressSmartClean_0",
+          "OutDoorVentil_Off",
+          "FreezeAlarmSetting_Off",
+          "DesiredFreezeAlarm_240",
+          "OptionCode_529",
+          "ExtendOptionCode_16975",
+          "RacInfo_First",
+          "RacInfo_None_Second",
+          "ModelInfo_16K_BORA_VENT2",
+          "UpdateAllow_NotAllowed",
+          "EnergySaveIcon_Off",
+          "DurationOn_0",
+          "welcomecareElapsedTime_0",
+          "welcomecareThresholdTemp_0",
+          "welcomecareStartDate_0000",
+          "welcomecareEndDate_0000",
+          "welcomecareSeason_None"
+        ]
+      }
+    },
+    {
+      "href": "/option/autoclean/vs/0",
+      "rep": {
+        "x.com.samsung.da.status": "Stop",
+        "x.com.samsung.da.settingStatus": "On",
+        "x.com.samsung.da.progress": "0",
+        "x.com.samsung.da.supportedStatus": [
+          "Start",
+          "SpeedClean",
+          "QuietClean",
+          "Stop"
+        ],
+        "x.com.samsung.da.supportedSettingStatus": [
+          "On",
+          "SpeedClean",
+          "QuietClean",
+          "Off"
+        ]
+      }
+    },
+    {
+      "href": "/otninformation/vs/0",
+      "rep": {
+        "x.com.samsung.da.target": "",
+        "x.com.samsung.da.newVersionAvailable": "false",
+        "x.com.samsung.da.newVersionNo": "00000000",
+        "x.com.samsung.da.currentVersionInfo": "00000000",
+        "otnStatus": "None",
+        "flashingProgress": "",
+        "otnTarget": "main",
+        "otnCompleteDate": "noHistory",
+        "otnList": [
+          {
+            "type": "WIFI",
+            "modelId": "AFA-KR-TP2-21-AF9X00",
+            "versions": [
+              "10260424"
+            ],
+            "visVersion": "260424"
+          },
+          {
+            "type": "Micom",
+            "modelId": "04511023304110232941",
+            "versions": [
+              "21022400",
+              "21022200"
+            ],
+            "visVersion": "210224"
+          },
+          {
+            "type": "Micom",
+            "modelId": "04511022974110229941",
+            "versions": [
+              "21033001",
+              "10000300"
+            ],
+            "visVersion": "210330"
+          },
+          {
+            "type": "Micom",
+            "modelId": "045110230741FFFFFFFF",
+            "versions": [
+              "22050300",
+              "FFFFFFFF"
+            ],
+            "visVersion": "220503"
+          }
+        ]
+      }
+    },
+    {
+      "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": "/power/0",
+      "rep": {
+        "value": false
+      }
+    },
+    {
+      "href": "/power/vs/0",
+      "rep": {
+        "x.com.samsung.da.power": "Off"
+      }
+    },
+    {
+      "href": "/realtimenotiforclient/vs/0",
+      "rep": {
+        "x.com.samsung.da.timeforshortnoti": "0",
+        "x.com.samsung.da.longnotisubscription": "true",
+        "x.com.samsung.da.periodicnotisubscription": "true"
+      }
+    },
+    {
+      "href": "/runn/vs/0",
+      "rep": {
+        "x.com.samsung.da.runningMode": 0
+      }
+    },
+    {
+      "href": "/subdevices/vs/0",
+      "rep": {
+        "x.com.samsung.da.subdeviceIdList": [
+          "6c2dff6d-ee5c-dad1-6a5e-000000000001"
+        ]
+      }
+    },
+    {
+      "href": "/temperature/control/vs/0",
+      "rep": {
+        "x.com.samsung.da.increment": "1"
+      }
+    },
+    {
+      "href": "/temperature/current/0",
+      "rep": {
+        "range": [
+          18.0,
+          30.0
+        ],
+        "units": "C",
+        "temperature": 32.0
+      }
+    },
+    {
+      "href": "/temperature/desired/0",
+      "rep": {
+        "range": [
+          18.0,
+          30.0
+        ],
+        "units": "C",
+        "temperature": 24.0
+      }
+    },
+    {
+      "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": "32.0",
+            "x.com.samsung.da.maximum": "30",
+            "x.com.samsung.da.minimum": "18",
+            "x.com.samsung.da.increment": "1.0",
+            "x.com.samsung.da.unit": "Celsius"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/timezone/vs/0",
+      "rep": {
+        "timezoneid": "Asia/Seoul",
+        "offset": "+09:00",
+        "DST": "OFF"
+      }
+    },
+    {
+      "href": "/wind/direction/vs/0",
+      "rep": {
+        "x.com.samsung.da.modes": "NotSupported",
+        "x.com.samsung.da.supportedModes": [
+          "NotSupported"
+        ]
+      }
+    },
+    {
+      "href": "/wind/strength/vs/0",
+      "rep": {
+        "x.com.samsung.da.modes": "2",
+        "x.com.samsung.da.supportedModes": [
+          "0",
+          "2",
+          "3",
+          "4"
+        ],
+        "x.com.samsung.da.modesName": [
+          "Auto",
+          "Mid",
+          "High",
+          "Turbo"
+        ]
+      }
+    }
+  ],
+  "oic_res": [
+    {
+      "di": "**REDACTED**",
+      "links": [
+        {
+          "href": "/oic/sec/doxm",
+          "rt": [
+            "oic.r.doxm"
+          ],
+          "if": [
+            "oic.if.baseline"
+          ],
+          "p": {
+            "bm": 1,
+            "sec": true,
+            "port": 49154,
+            "x.org.iotivity.tls": 0
+          }
+        },
+        {
+          "href": "/oic/sec/pstat",
+          "rt": [
+            "oic.r.pstat"
+          ],
+          "if": [
+            "oic.if.baseline"
+          ],
+          "p": {
+            "bm": 1,
+            "sec": true,
+            "port": 49154,
+            "x.org.iotivity.tls": 0
+          }
+        },
+        {
+          "href": "/oic/d",
+          "rt": [
+            "oic.wk.d",
+            "oic.d.airconditioner"
+          ],
+          "if": [
+            "oic.if.baseline",
+            "oic.if.r"
+          ],
+          "p": {
+            "bm": 1,
+            "sec": false,
+            "x.org.iotivity.tcp": 0
+          }
+        },
+        {
+          "href": "/oic/p",
+          "rt": [
+            "oic.wk.p"
+          ],
+          "if": [
+            "oic.if.baseline",
+            "oic.if.r"
+          ],
+          "p": {
+            "bm": 1,
+            "sec": false,
+            "x.org.iotivity.tcp": 0
+          }
+        },
+        {
+          "href": "/hass/state/vs/0",
+          "rt": [
+            "x.com.samsung.da.hass.state"
+          ],
+          "if": [
+            "oic.if.baseline",
+            "oic.if.a"
+          ],
+          "p": {
+            "bm": 3,
+            "sec": false,
+            "x.org.iotivity.tcp": 0
+          }
+        },
+        {
+          "href": "/hass/command/vs/0",
+          "rt": [
+            "x.com.samsung.da.hass.command"
+          ],
+          "if": [
+            "oic.if.baseline",
+            "oic.if.a"
+          ],
+          "p": {
+            "bm": 3,
+            "sec": false,
+            "x.org.iotivity.tcp": 0
+          }
+        },
+        {
+          "href": "/file/transfer/chunk/vs/0",
+          "rt": [
+            "x.com.samsung.file.chunk"
+          ],
+          "if": [
+            "oic.if.baseline",
+            "oic.if.a"
+          ],
+          "p": {
+            "bm": 1,
+            "sec": false,
+            "x.org.iotivity.tcp": 0
+          }
+        },
+        {
+          "href": "/file/list/vs/0",
+          "rt": [
+            "x.com.samsung.file.list"
+          ],
+          "if": [
+            "oic.if.baseline",
+            "oic.if.s"
+          ],
+          "p": {
+            "bm": 1,
+            "sec": false,
+            "x.org.iotivity.tcp": 0
+          }
+        },
+        {
+          "href": "/file/transfer/vs/0",
+          "rt": [
+            "x.com.samsung.file.transfer"
+          ],
+          "if": [
+            "oic.if.baseline",
+            "oic.if.a"
+          ],
+          "p": {
+            "bm": 3,
+            "sec": false,
+            "x.org.iotivity.tcp": 0
+          }
+        },
+        {
+          "href": "/6c2dff6d-ee5c-dad1-6a5e-000000000001/file/list/vs/0",
+          "rt": [
+            "x.com.samsung.file.list"
+          ],
+          "if": [
+            "oic.if.baseline",
+            "oic.if.s"
+          ],
+          "p": {
+            "bm": 1,
+            "sec": false,
+            "x.org.iotivity.tcp": 0
+          }
+        },
+        {
+          "href": "/6c2dff6d-ee5c-dad1-6a5e-000000000001/file/transfer/vs/0",
+          "rt": [
+            "x.com.samsung.file.transfer"
+          ],
+          "if": [
+            "oic.if.baseline",
+            "oic.if.a"
+          ],
+          "p": {
+            "bm": 3,
+            "sec": false,
+            "x.org.iotivity.tcp": 0
+          }
+        },
+        {
+          "href": "/EasySetupResURI",
+          "rt": [
+            "oic.r.easysetup"
+          ],
+          "if": [
+            "oic.if.baseline",
+            "oic.if.ll",
+            "oic.if.b"
+          ],
+          "p": {
+            "bm": 1,
+            "sec": true,
+            "port": 49154,
+            "x.org.iotivity.tls": 0
+          }
+        },
+        {
+          "href": "/WiFiConfResURI",
+          "rt": [
+            "oic.wk.wifi"
+          ],
+          "if": [
+            "oic.if.baseline"
+          ],
+          "p": {
+            "bm": 1,
+            "sec": true,
+            "port": 49154,
+            "x.org.iotivity.tls": 0
+          }
+        },
+        {
+          "href": "/CoapCloudConfResURI",
+          "rt": [
+            "oic.wk.cloudserver"
+          ],
+          "if": [
+            "oic.if.baseline"
+          ],
+          "p": {
+            "bm": 1,
+            "sec": true,
+            "port": 49154,
+            "x.org.iotivity.tls": 0
+          }
+        },
+        {
+          "href": "/DevConfResURI",
+          "rt": [
+            "oic.wk.devconf"
+          ],
+          "if": [
+            "oic.if.baseline"
+          ],
+          "p": {
+            "bm": 1,
+            "sec": true,
+            "port": 49154,
+            "x.org.iotivity.tls": 0
+          }
+        },
+        {
+          "href": "/sec/provisioninginfo",
+          "rt": [
+            "x.com.samsung.provisioninginfo"
+          ],
+          "if": [
+            "oic.if.baseline",
+            "oic.if.a"
+          ],
+          "p": {
+            "bm": 1,
+            "sec": false,
+            "x.org.iotivity.tcp": 0
+          }
+        },
+        {
+          "href": "/sec/accesspointlist",
+          "rt": [
+            "x.com.samsung.accesspointlist"
+          ],
+          "if": [
+            "oic.if.baseline",
+            "oic.if.s"
+          ],
+          "p": {
+            "bm": 1,
+            "sec": false,
+            "x.org.iotivity.tcp": 0
+          }
+        }
+      ]
+    }
+  ],
+  "probes": {
+    "/6c2dff6d-ee5c-dad1-6a5e-000000000001/information/vs/0": {
+      "x.com.samsung.da.modelNum": "TP2X_FAC_BORA_RAC_21K|10233041|60010610001500014600081200810000",
+      "x.com.samsung.da.description": "TP2X_FAC_BORA_RAC_21K",
+      "x.com.samsung.da.serialNum": "TEST-SUBDEVICE-SERIAL-0000"
+    }
+  },
+  "seeds_note": "device0 and oic_res are real, captured from the reporter's issue #205 report. subdeviceIdList in device0's /subdevices/vs/0 is restored to the real ['6c2dff6d-ee5c-dad1-6a5e-000000000001'] (HA's diagnostics download redacts it, matching redact.py's 'deviceid' substring rule, not because it's account data -- same restoration airconditioner_fac_bora_2in1_device.json documents for the same field), and every other value is otherwise exactly what HA's download redacts (serials/otnDUID etc.) against the same physical TP2X_FAC_BORA_21K unit as airconditioner_fac_bora_2in1_device.json -- same subdeviceIdList UUID, same wall subdevice. Filed specifically because, contrary to the assumption that fixture's seed batch was built on, this unit's /6c2dff6d-ee5c-dad1-6a5e-000000000001/device/0 does NOT answer (subdevice_probes in the report shows it False), so the Collection-batch fallback this fixture exercises (registry.subdevices.enumerate_subdevices' per-href probe, issue #205) is what has to find the subdevice instead. The one probes entry, /6c2dff6d-ee5c-dad1-6a5e-000000000001/information/vs/0, is the same real capture already used in airconditioner_fac_bora_2in1_device.json's seed batch (issue #177 comment 5113518087) -- the only href ever actually confirmed to answer under this UUID prefix. No other /6c2dff6d-ee5c-dad1-6a5e-000000000001/* href has been confirmed live yet, so none are seeded here; this fixture's expected outcome is the candidate being found by the flat-href probe but then correctly held back by discover_partitioned's liveness gate (information alone binds no entity), matching where the real issue stands -- not a materialized climate entity, which would require guessing at unconfirmed hrefs. The probe's serialNum (\"TEST-SUBDEVICE-SERIAL-0000\") is a hand-placed placeholder for the real value, not HA's own redaction output -- same placeholder airconditioner_fac_bora_2in1_device.json uses for the identical field."
+}

tests/fixtures/airconditioner_fac_bora_2in1_device.json

@@ -0,0 +1,809 @@
+{
+  "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": "true",
+        "x.com.samsung.da.periodicnotisubscription": "true"
+      }
+    },
+    {
+      "href": "/filter/airdustfilter/vs/0",
+      "rep": {
+        "x.com.samsung.da.filterUsage": "0",
+        "x.com.samsung.da.filterUsageResolution": "1",
+        "x.com.samsung.da.filterDesiredUsage": "112",
+        "x.com.samsung.da.filterStatus": "normal",
+        "x.com.samsung.da.filterCapacity": "112",
+        "x.com.samsung.da.filterCapacityUnit": "Hour",
+        "x.com.samsung.da.filterResetType": [
+          "washable"
+        ],
+        "x.com.samsung.da.supportedFilterDesiredUsage": [
+          "112",
+          "224",
+          "336",
+          "448"
+        ]
+      }
+    },
+    {
+      "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",
+          "Speed"
+        ]
+      }
+    },
+    {
+      "href": "/option/autoclean/vs/0",
+      "rep": {
+        "x.com.samsung.da.status": "Stop",
+        "x.com.samsung.da.settingStatus": "On",
+        "x.com.samsung.da.progress": "0",
+        "x.com.samsung.da.supportedStatus": [
+          "Start",
+          "SpeedClean",
+          "QuietClean",
+          "Stop"
+        ],
+        "x.com.samsung.da.supportedSettingStatus": [
+          "On",
+          "SpeedClean",
+          "QuietClean",
+          "Off"
+        ]
+      }
+    },
+    {
+      "href": "/wind/strength/vs/0",
+      "rep": {
+        "x.com.samsung.da.modes": "2",
+        "x.com.samsung.da.supportedModes": [
+          "0",
+          "2",
+          "3",
+          "4"
+        ],
+        "x.com.samsung.da.modesName": [
+          "Auto",
+          "Mid",
+          "High",
+          "Turbo"
+        ]
+      }
+    },
+    {
+      "href": "/wind/direction/vs/0",
+      "rep": {
+        "x.com.samsung.da.modes": "NotSupported",
+        "x.com.samsung.da.supportedModes": [
+          "NotSupported"
+        ]
+      }
+    },
+    {
+      "href": "/subdevices/vs/0",
+      "rep": {
+        "x.com.samsung.da.subdeviceIdList": [
+          "6c2dff6d-ee5c-dad1-6a5e-000000000001"
+        ]
+      }
+    },
+    {
+      "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-29T04:31:31"
+          },
+          {
+            "x.com.samsung.da.id": "2",
+            "x.com.samsung.da.description": "Alarm",
+            "x.com.samsung.da.alarmType": "Device",
+            "x.com.samsung.da.code": "AC_V_0002_OFF",
+            "x.com.samsung.da.triggeredTime": "2026-07-29T04:31:31"
+          }
+        ]
+      }
+    },
+    {
+      "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": "33.0",
+            "x.com.samsung.da.maximum": "30",
+            "x.com.samsung.da.minimum": "18",
+            "x.com.samsung.da.increment": "1.0",
+            "x.com.samsung.da.unit": "Celsius"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/temperature/current/0",
+      "rep": {
+        "range": [
+          18.0,
+          30.0
+        ],
+        "units": "C",
+        "temperature": 33.0
+      }
+    },
+    {
+      "href": "/temperature/desired/0",
+      "rep": {
+        "range": [
+          18.0,
+          30.0
+        ],
+        "units": "C",
+        "temperature": 24.0
+      }
+    },
+    {
+      "href": "/diagnosis/vs/0",
+      "rep": {}
+    },
+    {
+      "href": "/energy/consumption/vs/0",
+      "rep": {
+        "x.com.samsung.da.cumulativeConsumption": "100.000000",
+        "x.com.samsung.da.instantaneousPower": "65278.000000",
+        "x.com.samsung.da.usageThreshold": "0.000000",
+        "x.com.samsung.da.cumulativePower": "544088",
+        "x.com.samsung.da.cumulativeUnit": "Wh",
+        "x.com.samsung.da.instantaneousPowerUnit": "W",
+        "x.com.samsung.da.cumulativePowerType": "individual"
+      }
+    },
+    {
+      "href": "/energy/consumption/0",
+      "rep": {
+        "energy": 100.0,
+        "power": 65278.0
+      }
+    },
+    {
+      "href": "/mode/vs/0",
+      "rep": {
+        "x.com.samsung.da.supportedModes": [
+          "AIComfort",
+          "Cool",
+          "Dry",
+          "Wind"
+        ],
+        "x.com.samsung.da.modes": [
+          "Wind"
+        ],
+        "x.com.samsung.da.options": [
+          "Operation_Family",
+          "Blooming_0",
+          "OnTimer_0",
+          "OffTimer_0",
+          "Sleep_16",
+          "ArtificialWorking_Off",
+          "ComfortAICooling_Off",
+          "AiTempChanged_Off",
+          "AiTemp_270",
+          "welcomecare_Off",
+          "Panel_Close",
+          "Weather_Off",
+          "Volume_100",
+          "StopAutoClean_Idle",
+          "DiagnosisAI_Off",
+          "Display_Off",
+          "ProgressDiagnosisAI_1",
+          "ResultDiagnosisAI_Normal",
+          "Service_Off",
+          "SmartCoolClean_Off",
+          "ProgressSmartClean_0",
+          "OutDoorVentil_Off",
+          "FreezeAlarmSetting_Off",
+          "DesiredFreezeAlarm_240",
+          "OptionCode_529",
+          "ExtendOptionCode_16975",
+          "RacInfo_First",
+          "RacInfo_None_Second",
+          "ModelInfo_16K_BORA_VENT2",
+          "UpdateAllow_NotAllowed",
+          "EnergySaveIcon_Off",
+          "DurationOn_0",
+          "welcomecareElapsedTime_0",
+          "welcomecareThresholdTemp_0",
+          "welcomecareStartDate_0000",
+          "welcomecareEndDate_0000",
+          "welcomecareSeason_None"
+        ]
+      }
+    },
+    {
+      "href": "/power/vs/0",
+      "rep": {
+        "x.com.samsung.da.power": "Off"
+      }
+    },
+    {
+      "href": "/power/0",
+      "rep": {
+        "value": false
+      }
+    },
+    {
+      "href": "/information/vs/0",
+      "rep": {
+        "x.com.samsung.da.modelNum": "TP2X_FAC_BORA_21K|10233041|600001110015110006000C1200830000",
+        "x.com.samsung.da.description": "TP2X_FAC_BORA_21K",
+        "x.com.samsung.da.serialNum": "REDACTED",
+        "x.com.samsung.da.otnDUID": "REDACTED",
+        "x.com.samsung.da.diagProtocolType": "WIFI_HTTPS",
+        "x.com.samsung.da.diagLogType": [
+          "errCode",
+          "dump"
+        ],
+        "x.com.samsung.da.diagDumpType": "file",
+        "x.com.samsung.da.diagEndPoint": "SSM",
+        "x.com.samsung.da.diagMnid": "0AJT",
+        "x.com.samsung.da.diagSetupid": "000",
+        "x.com.samsung.da.diagMinVersion": "1.0",
+        "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": "02337A260424",
+            "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": "2102240021022200",
+            "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": "2103300110000300"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/file/information/vs/0",
+      "rep": {
+        "x.com.samsung.timeoffset": "+09:00",
+        "x.com.samsung.supprtedtype": 1
+      }
+    },
+    {
+      "href": "/configuration/vs/0",
+      "rep": {
+        "x.com.samsung.da.region": "3017000000",
+        "x.com.samsung.da.airconOptionList": [
+          "HOMECARE_WIZARD_V2",
+          "ENERGY_2.0",
+          "AI_2.0",
+          "DeviceTypeMaster",
+          "SingleCommand_1"
+        ]
+      }
+    },
+    {
+      "href": "/humidity/0",
+      "rep": {
+        "humidity": 0
+      }
+    },
+    {
+      "href": "/humidity/vs/0",
+      "rep": {
+        "x.com.samsung.da.humidity": "0.000000",
+        "x.com.samsung.da.fivepercentHumidity": "58"
+      }
+    },
+    {
+      "href": "/drlc/0",
+      "rep": {
+        "DRLevel": 2,
+        "start": "2026-07-29T04:12:57Z",
+        "duration": 20,
+        "override": false
+      }
+    },
+    {
+      "href": "/drlc/vs/0",
+      "rep": {
+        "x.com.samsung.da.drlcLevel": "2",
+        "x.com.samsung.da.duration": "20:30:00",
+        "x.com.samsung.da.drlcStartTime": "2026-07-29T04:12:57Z",
+        "x.com.samsung.da.override": "Off"
+      }
+    },
+    {
+      "href": "/runn/vs/0",
+      "rep": {
+        "x.com.samsung.da.runningMode": 0
+      }
+    },
+    {
+      "href": "/availablecontrolsets/vs/0",
+      "rep": {
+        "x.com.samsung.da.sets": "000000B4012C0000404B04000000",
+        "x.com.samsung.da.id": "FAC",
+        "x.com.samsung.da.version": "1.0"
+      }
+    },
+    {
+      "href": "/keepnormalstate/vs/0",
+      "rep": {
+        "x.com.samsung.da.keepnormal": 5
+      }
+    },
+    {
+      "href": "/otninformation/vs/0",
+      "rep": {
+        "x.com.samsung.da.target": "",
+        "x.com.samsung.da.newVersionAvailable": "false",
+        "x.com.samsung.da.newVersionNo": "00000000",
+        "x.com.samsung.da.currentVersionInfo": "00000000",
+        "otnStatus": "None",
+        "flashingProgress": "",
+        "otnTarget": "main",
+        "otnCompleteDate": "noHistory",
+        "otnList": [
+          {
+            "type": "WIFI",
+            "modelId": "AFA-KR-TP2-21-AF9X00",
+            "versions": [
+              "10260424"
+            ],
+            "visVersion": "260424"
+          },
+          {
+            "type": "Micom",
+            "modelId": "04511023304110232941",
+            "versions": [
+              "21022400",
+              "21022200"
+            ],
+            "visVersion": "210224"
+          },
+          {
+            "type": "Micom",
+            "modelId": "04511022974110229941",
+            "versions": [
+              "21033001",
+              "10000300"
+            ],
+            "visVersion": "210330"
+          },
+          {
+            "type": "Micom",
+            "modelId": "045110230741FFFFFFFF",
+            "versions": [
+              "22050300",
+              "FFFFFFFF"
+            ],
+            "visVersion": "220503"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/timezone/vs/0",
+      "rep": {
+        "timezoneid": "Asia/Seoul",
+        "offset": "+09:00",
+        "DST": "OFF"
+      }
+    }
+  ],
+  "oic_res": [
+    {
+      "di": "**REDACTED**",
+      "links": [
+        {
+          "href": "/oic/sec/doxm",
+          "rt": [
+            "oic.r.doxm"
+          ],
+          "if": [
+            "oic.if.baseline"
+          ],
+          "p": {
+            "bm": 1,
+            "sec": true,
+            "port": 49154,
+            "x.org.iotivity.tls": 0
+          }
+        },
+        {
+          "href": "/oic/sec/pstat",
+          "rt": [
+            "oic.r.pstat"
+          ],
+          "if": [
+            "oic.if.baseline"
+          ],
+          "p": {
+            "bm": 1,
+            "sec": true,
+            "port": 49154,
+            "x.org.iotivity.tls": 0
+          }
+        },
+        {
+          "href": "/oic/d",
+          "rt": [
+            "oic.wk.d",
+            "oic.d.airconditioner"
+          ],
+          "if": [
+            "oic.if.baseline",
+            "oic.if.r"
+          ],
+          "p": {
+            "bm": 1,
+            "sec": false,
+            "x.org.iotivity.tcp": 0
+          }
+        },
+        {
+          "href": "/oic/p",
+          "rt": [
+            "oic.wk.p"
+          ],
+          "if": [
+            "oic.if.baseline",
+            "oic.if.r"
+          ],
+          "p": {
+            "bm": 1,
+            "sec": false,
+            "x.org.iotivity.tcp": 0
+          }
+        },
+        {
+          "href": "/hass/state/vs/0",
+          "rt": [
+            "x.com.samsung.da.hass.state"
+          ],
+          "if": [
+            "oic.if.baseline",
+            "oic.if.a"
+          ],
+          "p": {
+            "bm": 3,
+            "sec": false,
+            "x.org.iotivity.tcp": 0
+          }
+        },
+        {
+          "href": "/hass/command/vs/0",
+          "rt": [
+            "x.com.samsung.da.hass.command"
+          ],
+          "if": [
+            "oic.if.baseline",
+            "oic.if.a"
+          ],
+          "p": {
+            "bm": 3,
+            "sec": false,
+            "x.org.iotivity.tcp": 0
+          }
+        },
+        {
+          "href": "/file/transfer/chunk/vs/0",
+          "rt": [
+            "x.com.samsung.file.chunk"
+          ],
+          "if": [
+            "oic.if.baseline",
+            "oic.if.a"
+          ],
+          "p": {
+            "bm": 1,
+            "sec": false,
+            "x.org.iotivity.tcp": 0
+          }
+        },
+        {
+          "href": "/file/list/vs/0",
+          "rt": [
+            "x.com.samsung.file.list"
+          ],
+          "if": [
+            "oic.if.baseline",
+            "oic.if.s"
+          ],
+          "p": {
+            "bm": 1,
+            "sec": false,
+            "x.org.iotivity.tcp": 0
+          }
+        },
+        {
+          "href": "/file/transfer/vs/0",
+          "rt": [
+            "x.com.samsung.file.transfer"
+          ],
+          "if": [
+            "oic.if.baseline",
+            "oic.if.a"
+          ],
+          "p": {
+            "bm": 3,
+            "sec": false,
+            "x.org.iotivity.tcp": 0
+          }
+        },
+        {
+          "href": "/6c2dff6d-ee5c-dad1-6a5e-000000000001/file/list/vs/0",
+          "rt": [
+            "x.com.samsung.file.list"
+          ],
+          "if": [
+            "oic.if.baseline",
+            "oic.if.s"
+          ],
+          "p": {
+            "bm": 1,
+            "sec": false,
+            "x.org.iotivity.tcp": 0
+          }
+        },
+        {
+          "href": "/6c2dff6d-ee5c-dad1-6a5e-000000000001/file/transfer/vs/0",
+          "rt": [
+            "x.com.samsung.file.transfer"
+          ],
+          "if": [
+            "oic.if.baseline",
+            "oic.if.a"
+          ],
+          "p": {
+            "bm": 3,
+            "sec": false,
+            "x.org.iotivity.tcp": 0
+          }
+        },
+        {
+          "href": "/EasySetupResURI",
+          "rt": [
+            "oic.r.easysetup"
+          ],
+          "if": [
+            "oic.if.baseline",
+            "oic.if.ll",
+            "oic.if.b"
+          ],
+          "p": {
+            "bm": 1,
+            "sec": true,
+            "port": 49154,
+            "x.org.iotivity.tls": 0
+          }
+        },
+        {
+          "href": "/WiFiConfResURI",
+          "rt": [
+            "oic.wk.wifi"
+          ],
+          "if": [
+            "oic.if.baseline"
+          ],
+          "p": {
+            "bm": 1,
+            "sec": true,
+            "port": 49154,
+            "x.org.iotivity.tls": 0
+          }
+        },
+        {
+          "href": "/CoapCloudConfResURI",
+          "rt": [
+            "oic.wk.cloudserver"
+          ],
+          "if": [
+            "oic.if.baseline"
+          ],
+          "p": {
+            "bm": 1,
+            "sec": true,
+            "port": 49154,
+            "x.org.iotivity.tls": 0
+          }
+        },
+        {
+          "href": "/DevConfResURI",
+          "rt": [
+            "oic.wk.devconf"
+          ],
+          "if": [
+            "oic.if.baseline"
+          ],
+          "p": {
+            "bm": 1,
+            "sec": true,
+            "port": 49154,
+            "x.org.iotivity.tls": 0
+          }
+        },
+        {
+          "href": "/sec/provisioninginfo",
+          "rt": [
+            "x.com.samsung.provisioninginfo"
+          ],
+          "if": [
+            "oic.if.baseline",
+            "oic.if.a"
+          ],
+          "p": {
+            "bm": 1,
+            "sec": false,
+            "x.org.iotivity.tcp": 0
+          }
+        },
+        {
+          "href": "/sec/accesspointlist",
+          "rt": [
+            "x.com.samsung.accesspointlist"
+          ],
+          "if": [
+            "oic.if.baseline",
+            "oic.if.s"
+          ],
+          "p": {
+            "bm": 1,
+            "sec": false,
+            "x.org.iotivity.tcp": 0
+          }
+        }
+      ]
+    }
+  ],
+  "seeds": {
+    "/6c2dff6d-ee5c-dad1-6a5e-000000000001/device/0": [
+      {
+        "rt": [
+          "x.com.samsung.devcol",
+          "oic.wk.col"
+        ],
+        "if": [
+          "oic.if.baseline",
+          "oic.if.ll",
+          "oic.if.b"
+        ]
+      },
+      {
+        "href": "/information/vs/0",
+        "rep": {
+          "x.com.samsung.da.modelNum": "TP2X_FAC_BORA_RAC_21K|10233041|600001110015110006000C1200830000",
+          "x.com.samsung.da.description": "TP2X_FAC_BORA_RAC_21K",
+          "x.com.samsung.da.serialNum": "TEST-SUBDEVICE-SERIAL-0000"
+        }
+      },
+      {
+        "href": "/power/vs/0",
+        "rep": {
+          "x.com.samsung.da.power": "On"
+        }
+      },
+      {
+        "href": "/mode/vs/0",
+        "rep": {
+          "x.com.samsung.da.supportedModes": [
+            "Cool",
+            "Dry",
+            "Wind",
+            "Auto"
+          ],
+          "x.com.samsung.da.modes": [
+            "Cool"
+          ],
+          "x.com.samsung.da.options": []
+        }
+      },
+      {
+        "href": "/temperature/current/0",
+        "rep": {
+          "range": [
+            18.0,
+            30.0
+          ],
+          "units": "C",
+          "temperature": 26.0
+        }
+      },
+      {
+        "href": "/temperature/desired/0",
+        "rep": {
+          "range": [
+            18.0,
+            30.0
+          ],
+          "units": "C",
+          "temperature": 24.0
+        }
+      },
+      {
+        "href": "/wind/strength/vs/0",
+        "rep": {
+          "x.com.samsung.da.modes": "0",
+          "x.com.samsung.da.supportedModes": [
+            "0",
+            "2",
+            "3",
+            "4"
+          ],
+          "x.com.samsung.da.modesName": [
+            "Auto",
+            "Mid",
+            "High",
+            "Turbo"
+          ]
+        }
+      },
+      {
+        "href": "/wind/direction/vs/0",
+        "rep": {
+          "x.com.samsung.da.modes": [
+            "Fix"
+          ],
+          "x.com.samsung.da.supportedModes": [
+            "Fix",
+            "All"
+          ]
+        }
+      }
+    ]
+  },
+  "seeds_note": "device0 and oic_res are real, captured from the reporter's diagnostics dump for the TP2X_FAC_BORA_21K board (issue #177, the same physical device as tests/fixtures/airconditioner_fac_bora_device.json -- that fixture's redacted x.com.samsung.da.subdeviceIdList string is a deliberate, separate regression case and is NOT changed here). subdeviceIdList above is restored to the real ['6c2dff6d-ee5c-dad1-6a5e-000000000001'] reported in the issue thread (redacted in the raw capture the same way serialNum/otnDUID/deviceId are -- it matches redact.py's 'deviceid' substring rule, not because it's actually account data). The seed's /information/vs/0 rep is REAL, verbatim from the reporter's live debug-panel read of /6c2dff6d-.../information/vs/0 (serial replaced with a placeholder) -- modelNum TP2X_FAC_BORA_RAC_21K confirms this is the wall-mounted room subdevice, distinct from the master's floor subdevice TP2X_FAC_BORA_21K. Every other href in this seed batch is CONSTRUCTED (never read from this subdevice) so the subdevice's climate entity has a resource surface to bind -- per DESIGN-177.md section 4, retrieval for this pattern is batch-only, and confirming '/6c2dff6d-.../device/0' actually returns a full batch (as opposed to just answering the information probe the reporter tried by hand) is listed as a follow-up, not something this fixture can attest to."
+}

tests/fixtures/airconditioner_fac_bora_device.json

@@ -0,0 +1,446 @@
+{
+  "device0": [
+    {
+      "rt": [
+        "x.com.samsung.devcol",
+        "oic.wk.col"
+      ],
+      "if": [
+        "oic.if.baseline",
+        "oic.if.ll",
+        "oic.if.b"
+      ]
+    },
+    {
+      "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": "2024-01-01T00:00:00"
+          },
+          {
+            "x.com.samsung.da.id": "2",
+            "x.com.samsung.da.description": "Alarm",
+            "x.com.samsung.da.alarmType": "Device",
+            "x.com.samsung.da.code": "AC_V_0002_OFF",
+            "x.com.samsung.da.triggeredTime": "2024-01-01T00:00:00"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/availablecontrolsets/vs/0",
+      "rep": {
+        "x.com.samsung.da.sets": "000000B4012C0000404B0C000000",
+        "x.com.samsung.da.id": "FAC",
+        "x.com.samsung.da.version": "1.0"
+      }
+    },
+    {
+      "href": "/configuration/vs/0",
+      "rep": {
+        "x.com.samsung.da.region": "2824500000",
+        "x.com.samsung.da.airconOptionList": [
+          "HOMECARE_WIZARD_V2",
+          "ENERGY_2.0",
+          "AI_2.0",
+          "DeviceTypeMaster",
+          "SingleCommand_1"
+        ]
+      }
+    },
+    {
+      "href": "/diagnosis/vs/0",
+      "rep": {}
+    },
+    {
+      "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"
+      }
+    },
+    {
+      "href": "/energy/consumption/0",
+      "rep": {
+        "energy": 100.0,
+        "power": 65278.0
+      }
+    },
+    {
+      "href": "/energy/consumption/vs/0",
+      "rep": {
+        "x.com.samsung.da.cumulativeConsumption": "100.000000",
+        "x.com.samsung.da.instantaneousPower": "65278.000000",
+        "x.com.samsung.da.usageThreshold": "0.000000",
+        "x.com.samsung.da.cumulativePower": "1278818",
+        "x.com.samsung.da.cumulativeDate": "1785243600",
+        "x.com.samsung.da.cumulativeUnit": "Wh",
+        "x.com.samsung.da.instantaneousPowerUnit": "W",
+        "x.com.samsung.da.cumulativePowerType": "individual"
+      }
+    },
+    {
+      "href": "/file/information/vs/0",
+      "rep": {
+        "x.com.samsung.timeoffset": "+09:00",
+        "x.com.samsung.supprtedtype": 1
+      }
+    },
+    {
+      "href": "/filter/airdustfilter/vs/0",
+      "rep": {
+        "x.com.samsung.da.filterUsage": "100",
+        "x.com.samsung.da.filterUsageResolution": "1",
+        "x.com.samsung.da.filterDesiredUsage": "112",
+        "x.com.samsung.da.filterStatus": "wash",
+        "x.com.samsung.da.filterCapacity": "112",
+        "x.com.samsung.da.filterCapacityUnit": "Hour",
+        "x.com.samsung.da.filterResetType": [
+          "washable"
+        ],
+        "x.com.samsung.da.supportedFilterDesiredUsage": [
+          "112",
+          "224",
+          "336",
+          "448"
+        ]
+      }
+    },
+    {
+      "href": "/humidity/0",
+      "rep": {
+        "humidity": 0
+      }
+    },
+    {
+      "href": "/humidity/vs/0",
+      "rep": {
+        "x.com.samsung.da.humidity": "0.000000",
+        "x.com.samsung.da.fivepercentHumidity": "73"
+      }
+    },
+    {
+      "href": "/information/vs/0",
+      "rep": {
+        "x.com.samsung.da.modelNum": "TP2X_FAC_BORA_21K|10233041|600001110015110006000C1200830000",
+        "x.com.samsung.da.description": "TP2X_FAC_BORA_21K",
+        "x.com.samsung.da.serialNum": "REDACTED",
+        "x.com.samsung.da.otnDUID": "REDACTED",
+        "x.com.samsung.da.diagProtocolType": "WIFI_HTTPS",
+        "x.com.samsung.da.diagLogType": [
+          "errCode",
+          "dump"
+        ],
+        "x.com.samsung.da.diagDumpType": "file",
+        "x.com.samsung.da.diagEndPoint": "SSM",
+        "x.com.samsung.da.diagMnid": "0AJT",
+        "x.com.samsung.da.diagSetupid": "000",
+        "x.com.samsung.da.diagMinVersion": "1.0",
+        "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": "02337A260424",
+            "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": "2102240021022200",
+            "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": "2103300110000300"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/keepnormalstate/vs/0",
+      "rep": {
+        "x.com.samsung.da.keepnormal": 1
+      }
+    },
+    {
+      "href": "/mode/convenient/vs/0",
+      "rep": {
+        "x.com.samsung.da.modes": "Off",
+        "x.com.samsung.da.supportedModes": [
+          "Off",
+          "Sleep",
+          "Quiet",
+          "Speed"
+        ]
+      }
+    },
+    {
+      "href": "/mode/vs/0",
+      "rep": {
+        "x.com.samsung.da.supportedModes": [
+          "AIComfort",
+          "Cool",
+          "Dry",
+          "Wind"
+        ],
+        "x.com.samsung.da.modes": [
+          "AIComfort"
+        ],
+        "x.com.samsung.da.options": [
+          "Operation_Family",
+          "Blooming_0",
+          "OnTimer_0",
+          "OffTimer_0",
+          "Sleep_16",
+          "ArtificialWorking_Off",
+          "ComfortAICooling_Off",
+          "AiTempChanged_Off",
+          "AiTemp_270",
+          "welcomecare_Off",
+          "Panel_Close",
+          "Weather_Off",
+          "Volume_100",
+          "StopAutoClean_Idle",
+          "DiagnosisAI_Off",
+          "Display_Off",
+          "ProgressDiagnosisAI_1",
+          "ResultDiagnosisAI_Normal",
+          "Service_Off",
+          "SmartCoolClean_Off",
+          "ProgressSmartClean_0",
+          "OutDoorVentil_Off",
+          "FreezeAlarmSetting_On",
+          "DesiredFreezeAlarm_112",
+          "OptionCode_529",
+          "ExtendOptionCode_16975",
+          "RacInfo_First",
+          "RacInfo_None_Second",
+          "ModelInfo_16K_BORA_VENT2",
+          "UpdateAllow_NotAllowed",
+          "EnergySaveIcon_Off",
+          "DurationOn_0",
+          "welcomecareElapsedTime_0",
+          "welcomecareThresholdTemp_0",
+          "welcomecareStartDate_0000",
+          "welcomecareEndDate_0000",
+          "welcomecareSeason_None"
+        ]
+      }
+    },
+    {
+      "href": "/option/autoclean/vs/0",
+      "rep": {
+        "x.com.samsung.da.status": "Stop",
+        "x.com.samsung.da.settingStatus": "On",
+        "x.com.samsung.da.progress": "0",
+        "x.com.samsung.da.supportedStatus": [
+          "Start",
+          "SpeedClean",
+          "QuietClean",
+          "Stop"
+        ],
+        "x.com.samsung.da.supportedSettingStatus": [
+          "On",
+          "SpeedClean",
+          "QuietClean",
+          "Off"
+        ]
+      }
+    },
+    {
+      "href": "/otninformation/vs/0",
+      "rep": {
+        "x.com.samsung.da.target": "",
+        "x.com.samsung.da.newVersionAvailable": "false",
+        "x.com.samsung.da.newVersionNo": "00000000",
+        "x.com.samsung.da.currentVersionInfo": "00000000",
+        "otnStatus": "None",
+        "flashingProgress": "",
+        "otnTarget": "main",
+        "otnCompleteDate": "noHistory",
+        "otnList": [
+          {
+            "type": "WIFI",
+            "modelId": "AFA-KR-TP2-21-AF9X00",
+            "versions": [
+              "10260424"
+            ],
+            "visVersion": "260424"
+          },
+          {
+            "type": "Micom",
+            "modelId": "04511023304110232941",
+            "versions": [
+              "21022400",
+              "21022200"
+            ],
+            "visVersion": "210224"
+          },
+          {
+            "type": "Micom",
+            "modelId": "04511022974110229941",
+            "versions": [
+              "21033001",
+              "10000300"
+            ],
+            "visVersion": "210330"
+          },
+          {
+            "type": "Micom",
+            "modelId": "045110230741FFFFFFFF",
+            "versions": [
+              "22050300",
+              "FFFFFFFF"
+            ],
+            "visVersion": "220503"
+          }
+        ]
+      }
+    },
+    {
+      "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": "/power/0",
+      "rep": {
+        "value": false
+      }
+    },
+    {
+      "href": "/power/vs/0",
+      "rep": {
+        "x.com.samsung.da.power": "Off"
+      }
+    },
+    {
+      "href": "/realtimenotiforclient/vs/0",
+      "rep": {
+        "x.com.samsung.da.timeforshortnoti": "0",
+        "x.com.samsung.da.longnotisubscription": "true",
+        "x.com.samsung.da.periodicnotisubscription": "true"
+      }
+    },
+    {
+      "href": "/runn/vs/0",
+      "rep": {
+        "x.com.samsung.da.runningMode": 0
+      }
+    },
+    {
+      "href": "/subdevices/vs/0",
+      "rep": {
+        "x.com.samsung.da.subdeviceIdList": "REDACTED"
+      }
+    },
+    {
+      "href": "/temperature/control/vs/0",
+      "rep": {
+        "x.com.samsung.da.increment": "1"
+      }
+    },
+    {
+      "href": "/temperature/current/0",
+      "rep": {
+        "range": [
+          18.0,
+          30.0
+        ],
+        "units": "C",
+        "temperature": 31.0
+      }
+    },
+    {
+      "href": "/temperature/desired/0",
+      "rep": {
+        "range": [
+          18.0,
+          30.0
+        ],
+        "units": "C",
+        "temperature": 27.0
+      }
+    },
+    {
+      "href": "/temperatures/vs/0",
+      "rep": {
+        "x.com.samsung.da.items": [
+          {
+            "x.com.samsung.da.id": "0",
+            "x.com.samsung.da.description": "Temperature",
+            "x.com.samsung.da.desired": "27.0",
+            "x.com.samsung.da.current": "31.0",
+            "x.com.samsung.da.maximum": "30",
+            "x.com.samsung.da.minimum": "18",
+            "x.com.samsung.da.increment": "1.0",
+            "x.com.samsung.da.unit": "Celsius"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/timezone/vs/0",
+      "rep": {
+        "timezoneid": "Asia/Seoul",
+        "offset": "+09:00",
+        "DST": "OFF"
+      }
+    },
+    {
+      "href": "/wind/direction/vs/0",
+      "rep": {
+        "x.com.samsung.da.modes": "NotSupported",
+        "x.com.samsung.da.supportedModes": [
+          "NotSupported"
+        ]
+      }
+    },
+    {
+      "href": "/wind/strength/vs/0",
+      "rep": {
+        "x.com.samsung.da.modes": "0",
+        "x.com.samsung.da.supportedModes": [
+          "0",
+          "2",
+          "3",
+          "4"
+        ],
+        "x.com.samsung.da.modesName": [
+          "Auto",
+          "Mid",
+          "High",
+          "Turbo"
+        ]
+      }
+    }
+  ]
+}

tests/fixtures/airconditioner_lnx_rac_heatpump_device.json

@@ -0,0 +1,626 @@
+{
+  "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",
+          "MotionIndirect",
+          "MotionDirect",
+          "Nano",
+          "NanoSleep"
+        ]
+      }
+    },
+    {
+      "href": "/option/autoclean/vs/0",
+      "rep": {
+        "x.com.samsung.da.status": "Stop",
+        "x.com.samsung.da.settingStatus": "On",
+        "x.com.samsung.da.progress": "0",
+        "x.com.samsung.da.supportedStatus": [
+          "Start",
+          "Stop"
+        ],
+        "x.com.samsung.da.supportedSettingStatus": [
+          "On",
+          "Off"
+        ]
+      }
+    },
+    {
+      "href": "/wind/strength/vs/0",
+      "rep": {
+        "x.com.samsung.da.modes": "3",
+        "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",
+          "Up_And_Low",
+          "Left_And_Right",
+          "All"
+        ]
+      }
+    },
+    {
+      "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-28T19:55:08",
+            "x.com.samsung.da.state": "Deleted"
+          },
+          {
+            "x.com.samsung.da.id": "1",
+            "x.com.samsung.da.description": "Alarm",
+            "x.com.samsung.da.alarmType": "Device",
+            "x.com.samsung.da.code": "FilterAlarm",
+            "x.com.samsung.da.triggeredTime": "2026-07-28T19:55:08",
+            "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": "70.0",
+            "x.com.samsung.da.current": "69.0",
+            "x.com.samsung.da.maximum": "86",
+            "x.com.samsung.da.minimum": "47",
+            "x.com.samsung.da.increment": "1.0",
+            "x.com.samsung.da.unit": "Fahrenheit"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/temperature/current/0",
+      "rep": {
+        "range": [
+          47,
+          86
+        ],
+        "units": "F",
+        "temperature": 69.0
+      }
+    },
+    {
+      "href": "/temperature/desired/0",
+      "rep": {
+        "range": [
+          47,
+          86
+        ],
+        "units": "F",
+        "temperature": 70.0
+      }
+    },
+    {
+      "href": "/energy/consumption/vs/0",
+      "rep": {
+        "x.com.samsung.da.instantaneousPower": "0.000000",
+        "x.com.samsung.da.cumulativePower": "631483",
+        "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": [
+          "Auto",
+          "Cool",
+          "Dry",
+          "Fan",
+          "Heat"
+        ],
+        "x.com.samsung.da.modes": [
+          "Heat"
+        ],
+        "x.com.samsung.da.options": [
+          "Sleep_0",
+          "ArtificialWorking_Off",
+          "ComfortAICooling_Off",
+          "AiTempChanged_Off",
+          "AiTemp_990",
+          "OutdoorTemp_78",
+          "CoolCapa_35",
+          "WarmCapa_35",
+          "Volume_Mute",
+          "StopAutoClean_Set",
+          "Autoclean_On",
+          "DiagnosisAI_Off",
+          "ProgressDiagnosisAI_0",
+          "ResultDiagnosisAI_Normal",
+          "KeyInputPermit_On",
+          "ModePermit_NoLimit",
+          "SmartCoolClean_Off",
+          "ProgressSmartClean_0",
+          "FreezeAlarmSetting_Off",
+          "DesiredFreezeAlarm_240",
+          "WashAlarm_Off",
+          "OptionCode_56636",
+          "ExtendOptionCode_246669",
+          "RacInfo_None",
+          "UpdateAllow_NotAllowed",
+          "DurationOn_0",
+          "WelcomeCoolingState_Off"
+        ]
+      }
+    },
+    {
+      "href": "/power/vs/0",
+      "rep": {
+        "x.com.samsung.da.power": "Off",
+        "operationNumber": "48"
+      }
+    },
+    {
+      "href": "/power/0",
+      "rep": {
+        "value": false
+      }
+    },
+    {
+      "href": "/sensors/vs/0",
+      "rep": {}
+    },
+    {
+      "href": "/information/vs/0",
+      "rep": {
+        "x.com.samsung.da.modelNum": "TP1X_LNX-AC-RAC-01001_0000|10269441|60010523001811014E0048220090A000",
+        "x.com.samsung.da.description": "TP1X_LNX-AC-RAC-01001_0000",
+        "x.com.samsung.da.serialNum": "**REDACTED**",
+        "x.com.samsung.da.otnDUID": "**REDACTED**",
+        "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": "0AJV",
+        "x.com.samsung.da.diagSetupid": "AR2",
+        "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": "Version",
+            "x.com.samsung.da.type": "Software",
+            "x.com.samsung.da.number": "02646A260327",
+            "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": "102694A24062500",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          },
+          {
+            "x.com.samsung.da.id": "2",
+            "x.com.samsung.da.description": "Version",
+            "x.com.samsung.da.type": "Firmware",
+            "x.com.samsung.da.number": "102472A24042300,102579A10000200",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/file/information/vs/0",
+      "rep": {
+        "x.com.samsung.timeoffset": "-03: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",
+        "x.com.samsung.da.fivepercentHumidity": "45"
+      }
+    },
+    {
+      "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": "/availablecontrolsets/vs/0",
+      "rep": {
+        "x.com.samsung.da.sets": "000001D6035C016102490C0F0000",
+        "x.com.samsung.da.id": "RAC",
+        "x.com.samsung.da.version": "1.0"
+      }
+    },
+    {
+      "href": "/keepnormalstate/vs/0",
+      "rep": {
+        "x.com.samsung.da.keepnormal": 1
+      }
+    },
+    {
+      "href": "/remotedatacontrol/vs/0",
+      "rep": {
+        "x.com.samsung.da.status": "Off",
+        "x.com.samsung.da.connectionStatus": "Disconnected"
+      }
+    },
+    {
+      "href": "/remotetemperature/vs/0",
+      "rep": {
+        "x.com.samsung.da.temperature": "",
+        "x.com.samsung.da.unit": "",
+        "x.com.samsung.da.error": ""
+      }
+    },
+    {
+      "href": "/remotedeviceinfo/vs/0",
+      "rep": {
+        "x.com.samsung.da.didList": ""
+      }
+    },
+    {
+      "href": "/otninformation/vs/0",
+      "rep": {
+        "x.com.samsung.da.target": "",
+        "x.com.samsung.da.newVersionAvailable": "false",
+        "x.com.samsung.da.newVersionNo": "00000000",
+        "x.com.samsung.da.currentVersionInfo": "00000000",
+        "otnStatus": "None",
+        "flashingProgress": "",
+        "otnTarget": "main",
+        "otnCompleteDate": "noHistory",
+        "otnList": [
+          {
+            "type": "WIFI",
+            "modelId": "ARA-WW-TP1-24-ARXX00",
+            "versions": [
+              "11260327"
+            ],
+            "visVersion": "260327"
+          },
+          {
+            "type": "Micom",
+            "modelId": "045210269441FFFFFFFF",
+            "versions": [
+              "24062500",
+              "FFFFFFFF"
+            ],
+            "visVersion": "240625"
+          },
+          {
+            "type": "Micom",
+            "modelId": "04521024724110257941",
+            "versions": [
+              "24042300",
+              "10000200"
+            ],
+            "visVersion": "240423"
+          }
+        ]
+      }
+    },
+    {
+      "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": "/timezone/vs/0",
+      "rep": {
+        "timezoneid": "America/Halifax",
+        "offset": "-03:00",
+        "DST": "ON"
+      }
+    },
+    {
+      "href": "/option/muteonce/vs/0",
+      "rep": {
+        "muteonce": "Off"
+      }
+    },
+    {
+      "href": "/aisleep/vs/0",
+      "rep": {
+        "x.com.samsung.da.displayNightMode": "Off",
+        "x.com.samsung.da.elapsedTime": "0",
+        "x.com.samsung.da.requestFeedback": "Off",
+        "x.com.samsung.da.resultFeedback": "0",
+        "x.com.samsung.da.statusFeedback": "Idle",
+        "x.com.samsung.da.sleepTime": "14002200"
+      }
+    },
+    {
+      "href": "/reserverulesets/vs/0",
+      "rep": {
+        "x.com.samsung.da.sets": "AEFFFFFFFF3D564156FFFF2F56FFFF00001F001F00010000001F0000009C00FFFF1E00",
+        "x.com.samsung.da.id": "RAC",
+        "x.com.samsung.da.version": "1.0"
+      }
+    },
+    {
+      "href": "/light/vs/0",
+      "rep": {
+        "mode": "On",
+        "supportedModes": [
+          "On",
+          "Off"
+        ]
+      }
+    },
+    {
+      "href": "/mds/absencepowersaving/vs/0",
+      "rep": {
+        "status": "Off",
+        "modes": "Cooling_Heating",
+        "switchPowerSaveMode": "Normal",
+        "motionState": "Normal",
+        "supportedModes": [
+          "Cooling_Heating",
+          "Standby"
+        ],
+        "supportedSwitchPowerSaveMode": [
+          "Eco",
+          "Normal",
+          "Comfort"
+        ],
+        "supportedMotionState": [
+          "Normal",
+          "MotionNano",
+          "MotionSoftOff"
+        ]
+      }
+    },
+    {
+      "href": "/mds/absencestate/vs/0",
+      "rep": {
+        "status": "Off",
+        "maxDetectCount": [
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254",
+          "254"
+        ],
+        "supportedTime": [
+          "0",
+          "30",
+          "60"
+        ]
+      }
+    },
+    {
+      "href": "/option/motiondetectwind/stateful/vs/0",
+      "rep": {
+        "status": "Off",
+        "modes": "Indirect",
+        "supportedModes": [
+          "Direct",
+          "Indirect"
+        ]
+      }
+    },
+    {
+      "href": "/welcome/temperature/vs/0",
+      "rep": {
+        "operatingStatus": "None",
+        "requestId": "0000"
+      }
+    },
+    {
+      "href": "/wirelessinfo/vs/0",
+      "rep": {
+        "macaddressWiFi": "**REDACTED**",
+        "macaddressBLE": "**REDACTED**",
+        "connectedApSsid": "KG_IoT"
+      }
+    },
+    {
+      "href": "/quickcontrol/info/vs/0",
+      "rep": {
+        "supportedVersion": "1.0"
+      }
+    }
+  ]
+}

tests/fixtures/airconditioner_tp1x_rac_01001_device.json

@@ -0,0 +1,525 @@
+{
+  "device0": [
+    {
+      "rt": [
+        "x.com.samsung.devcol",
+        "oic.wk.col"
+      ],
+      "if": [
+        "oic.if.baseline",
+        "oic.if.ll",
+        "oic.if.b"
+      ]
+    },
+    {
+      "href": "/aisleep/vs/0",
+      "rep": {
+        "x.com.samsung.da.displayNightMode": "Off",
+        "x.com.samsung.da.elapsedTime": "0",
+        "x.com.samsung.da.requestFeedback": "Off",
+        "x.com.samsung.da.resultFeedback": "0",
+        "x.com.samsung.da.statusFeedback": "Idle",
+        "x.com.samsung.da.sleepTime": "14002200"
+      }
+    },
+    {
+      "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": "2024-01-01T00:00:00",
+            "x.com.samsung.da.state": "Deleted"
+          },
+          {
+            "x.com.samsung.da.id": "1",
+            "x.com.samsung.da.description": "Alarm",
+            "x.com.samsung.da.alarmType": "Device",
+            "x.com.samsung.da.code": "FilterAlarm_OFF",
+            "x.com.samsung.da.triggeredTime": "2024-01-01T00:00:00",
+            "x.com.samsung.da.state": "Deleted"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/availablecontrolsets/vs/0",
+      "rep": {
+        "x.com.samsung.da.sets": "1DBF00A0012C3F61024804000000",
+        "x.com.samsung.da.id": "RAC",
+        "x.com.samsung.da.version": "1.0"
+      }
+    },
+    {
+      "href": "/configuration/vs/0",
+      "rep": {
+        "x.com.samsung.da.region": "1150000000",
+        "x.com.samsung.da.airconOptionList": [
+          "SingleCommand_1",
+          "DR",
+          "HOMECARE_WIZARD_V2",
+          "AI_RAC_KOREA_COOLONLY_3.0",
+          "AI_3.0",
+          "Auto_To_AI"
+        ]
+      }
+    },
+    {
+      "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": "/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": "/energy/consumption/0",
+      "rep": {
+        "power": 338.0
+      }
+    },
+    {
+      "href": "/energy/consumption/vs/0",
+      "rep": {
+        "x.com.samsung.da.instantaneousPower": "338.000000",
+        "x.com.samsung.da.cumulativePower": "1362848",
+        "x.com.samsung.da.cumulativeSavedPower": "0",
+        "x.com.samsung.da.cumulativeUnit": "Wh",
+        "x.com.samsung.da.instantaneousPowerUnit": "W"
+      }
+    },
+    {
+      "href": "/file/information/vs/0",
+      "rep": {
+        "x.com.samsung.timeoffset": "+09:00",
+        "x.com.samsung.supprtedtype": 1
+      }
+    },
+    {
+      "href": "/filter/airdustfilter/vs/0",
+      "rep": {
+        "x.com.samsung.da.filterUsage": "2",
+        "x.com.samsung.da.filterUsageResolution": "1",
+        "x.com.samsung.da.filterDesiredUsage": "500",
+        "x.com.samsung.da.filterStatus": "normal",
+        "x.com.samsung.da.filterCapacity": "500",
+        "x.com.samsung.da.filterCapacityUnit": "Hour",
+        "x.com.samsung.da.filterResetType": [
+          "replaceable",
+          "washable"
+        ]
+      }
+    },
+    {
+      "href": "/humidity/0",
+      "rep": {
+        "humidity": 0
+      }
+    },
+    {
+      "href": "/humidity/vs/0",
+      "rep": {
+        "x.com.samsung.da.humidity": "0",
+        "x.com.samsung.da.fivepercentHumidity": "42"
+      }
+    },
+    {
+      "href": "/information/vs/0",
+      "rep": {
+        "x.com.samsung.da.modelNum": "TP1X_DA-AC-RAC-01001_0000|10250041|6001051C001711014E00482200912000",
+        "x.com.samsung.da.description": "TP1X_DA-AC-RAC-01001_0000",
+        "x.com.samsung.da.serialNum": "REDACTED",
+        "x.com.samsung.da.otnDUID": "REDACTED",
+        "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": "AR1",
+        "x.com.samsung.da.diagMinVersion": "3.0",
+        "x.com.samsung.da.diagTsId": "DA01",
+        "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": "02646A260327",
+            "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": "102500A23012700",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          },
+          {
+            "x.com.samsung.da.id": "2",
+            "x.com.samsung.da.description": "Version",
+            "x.com.samsung.da.type": "Firmware",
+            "x.com.samsung.da.number": "102472A22120800,102528A10000100",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/keepnormalstate/vs/0",
+      "rep": {
+        "x.com.samsung.da.keepnormal": 0
+      }
+    },
+    {
+      "href": "/light/vs/0",
+      "rep": {
+        "mode": "On",
+        "supportedModes": [
+          "On",
+          "Off"
+        ]
+      }
+    },
+    {
+      "href": "/mode/convenient/vs/0",
+      "rep": {
+        "x.com.samsung.da.modes": "Off",
+        "x.com.samsung.da.supportedModes": [
+          "Off",
+          "Sleep",
+          "Quiet",
+          "Smart",
+          "Nano",
+          "NanoSleep"
+        ]
+      }
+    },
+    {
+      "href": "/mode/vs/0",
+      "rep": {
+        "x.com.samsung.da.supportedModes": [
+          "AIComfort",
+          "Cool",
+          "Dry",
+          "Wind"
+        ],
+        "x.com.samsung.da.modes": [
+          "Cool"
+        ],
+        "x.com.samsung.da.options": [
+          "Sleep_16",
+          "ArtificialWorking_Off",
+          "ComfortAICooling_Off",
+          "AiTempChanged_Off",
+          "AiTemp_280",
+          "welcomecare_Off",
+          "OutdoorConnection_Connected",
+          "OutdoorTemp_86",
+          "CoolCapa_28",
+          "WarmCapa_0",
+          "Volume_100",
+          "StopAutoClean_Set",
+          "Autoclean_On",
+          "DiagnosisAI_Off",
+          "ProgressDiagnosisAI_0",
+          "ResultDiagnosisAI_Normal",
+          "SmartCoolClean_Off",
+          "ProgressSmartClean_0",
+          "FreezeAlarmSetting_Off",
+          "DesiredFreezeAlarm_240",
+          "WashAlarm_Off",
+          "OptionCode_56440",
+          "ExtendOptionCode_246479",
+          "RacInfo_None",
+          "UpdateAllow_NotAllowed",
+          "DurationOn_115",
+          "welcomecareElapsedTime_0",
+          "welcomecareThresholdTemp_0",
+          "welcomecareStartDate_0000",
+          "welcomecareEndDate_0000",
+          "welcomecareSeason_None"
+        ]
+      }
+    },
+    {
+      "href": "/option/autoclean/vs/0",
+      "rep": {
+        "x.com.samsung.da.status": "Stop",
+        "x.com.samsung.da.settingStatus": "On",
+        "x.com.samsung.da.progress": "0",
+        "x.com.samsung.da.supportedStatus": [
+          "Start",
+          "Stop"
+        ],
+        "x.com.samsung.da.supportedSettingStatus": [
+          "On",
+          "Off"
+        ]
+      }
+    },
+    {
+      "href": "/option/muteonce/vs/0",
+      "rep": {
+        "muteonce": "Off"
+      }
+    },
+    {
+      "href": "/otninformation/vs/0",
+      "rep": {
+        "x.com.samsung.da.target": "",
+        "x.com.samsung.da.newVersionAvailable": "false",
+        "x.com.samsung.da.newVersionNo": "00000000",
+        "x.com.samsung.da.currentVersionInfo": "00000000",
+        "otnStatus": "None",
+        "flashingProgress": "",
+        "otnTarget": "main",
+        "otnCompleteDate": "noHistory",
+        "otnList": [
+          {
+            "type": "WIFI",
+            "modelId": "ARA-WW-TP1-24-ARXX00",
+            "versions": [
+              "11260327"
+            ],
+            "visVersion": "260327"
+          },
+          {
+            "type": "Micom",
+            "modelId": "045210250041FFFFFFFF",
+            "versions": [
+              "23012700",
+              "FFFFFFFF"
+            ],
+            "visVersion": "230127"
+          },
+          {
+            "type": "Micom",
+            "modelId": "04521024724110252841",
+            "versions": [
+              "22120800",
+              "10000100"
+            ],
+            "visVersion": "221208"
+          }
+        ]
+      }
+    },
+    {
+      "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": "/power/0",
+      "rep": {
+        "value": true
+      }
+    },
+    {
+      "href": "/power/vs/0",
+      "rep": {
+        "x.com.samsung.da.power": "On",
+        "causeSource": "SMTS"
+      }
+    },
+    {
+      "href": "/quickcontrol/info/vs/0",
+      "rep": {
+        "supportedVersion": "1.0"
+      }
+    },
+    {
+      "href": "/realtimenotiforclient/vs/0",
+      "rep": {
+        "x.com.samsung.da.timeforshortnoti": "0",
+        "x.com.samsung.da.longnotisubscription": "true",
+        "x.com.samsung.da.periodicnotisubscription": "true"
+      }
+    },
+    {
+      "href": "/remotedatacontrol/vs/0",
+      "rep": {
+        "x.com.samsung.da.status": "Off",
+        "x.com.samsung.da.connectionStatus": "Disconnected"
+      }
+    },
+    {
+      "href": "/remotedeviceinfo/vs/0",
+      "rep": {
+        "x.com.samsung.da.didList": ""
+      }
+    },
+    {
+      "href": "/remotetemperature/vs/0",
+      "rep": {
+        "x.com.samsung.da.temperature": "",
+        "x.com.samsung.da.unit": "",
+        "x.com.samsung.da.error": ""
+      }
+    },
+    {
+      "href": "/reserverulesets/vs/0",
+      "rep": {
+        "x.com.samsung.da.sets": "1DFFFFFFFF101E121EFFFFFFFFFFFF01000000012F0100000F000000001C00",
+        "x.com.samsung.da.id": "RAC",
+        "x.com.samsung.da.version": "1.0"
+      }
+    },
+    {
+      "href": "/sensors/vs/0",
+      "rep": {}
+    },
+    {
+      "href": "/temperature/control/vs/0",
+      "rep": {
+        "x.com.samsung.da.increment": "1"
+      }
+    },
+    {
+      "href": "/temperature/current/0",
+      "rep": {
+        "range": [
+          16,
+          30
+        ],
+        "units": "C",
+        "temperature": 28.0
+      }
+    },
+    {
+      "href": "/temperature/desired/0",
+      "rep": {
+        "range": [
+          16,
+          30
+        ],
+        "units": "C",
+        "temperature": 25.0
+      }
+    },
+    {
+      "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": "25.0",
+            "x.com.samsung.da.current": "28.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": "/timezone/vs/0",
+      "rep": {
+        "timezoneid": "Asia/Seoul",
+        "offset": "+09:00",
+        "DST": "OFF"
+      }
+    },
+    {
+      "href": "/wind/direction/vs/0",
+      "rep": {
+        "x.com.samsung.da.modes": "Fix",
+        "x.com.samsung.da.supportedModes": [
+          "Fix",
+          "Up_And_Low",
+          "Left_And_Right",
+          "All"
+        ]
+      }
+    },
+    {
+      "href": "/wind/strength/vs/0",
+      "rep": {
+        "x.com.samsung.da.modes": "32",
+        "x.com.samsung.da.supportedModes": [
+          "0",
+          "31",
+          "32",
+          "33",
+          "34",
+          "35"
+        ],
+        "x.com.samsung.da.modesName": [
+          "Auto",
+          "1",
+          "2",
+          "3",
+          "4",
+          "MAX"
+        ]
+      }
+    },
+    {
+      "href": "/wirelessinfo/vs/0",
+      "rep": {
+        "macaddressWiFi": "REDACTED",
+        "macaddressBLE": "REDACTED",
+        "connectedApSsid": "REDACTED"
+      }
+    }
+  ]
+}

tests/fixtures/airconditioner_tp1x_rac_coolonly_device.json

@@ -0,0 +1,515 @@
+{
+  "meta": {
+    "model": "TP1X_DA-AC-RAC-01001_0000",
+    "device_type": "airconditioner",
+    "source": "user diagnostics (scrubbed)",
+    "note": "Cool-only global TP1X RAC variant (airconOptionList AI_RAC_GLOBAL_COOLONLY_3.0). Unlike the other TP1X_DA-AC-RAC dumps, its /otninformation/vs/0 ships no swVersionInfo block, so oneUiVersion is empty and detection must fall back to the hyphenated '-RAC-' modelNum token in for_device_by_model. Adds two hrefs absent from the other AC dumps -- /stepcontrol/vs/0 (manual airflow step) and /remotedeviceinfo/vs/0 (empty paired-device list), both ignored -- and exposes Samsung WindFree via the convenient-mode codes Nano/NanoSleep (in place of the Smart code on other boards; confirmed by an off-vs-on dump diff)."
+  },
+  "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",
+          "Speed",
+          "Nano",
+          "NanoSleep"
+        ]
+      }
+    },
+    {
+      "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": "0",
+        "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",
+          "Up_And_Low",
+          "Left_And_Right",
+          "All"
+        ]
+      }
+    },
+    {
+      "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-26T15:24:44",
+            "x.com.samsung.da.state": "Deleted"
+          },
+          {
+            "x.com.samsung.da.id": "1",
+            "x.com.samsung.da.description": "Alarm",
+            "x.com.samsung.da.alarmType": "Device",
+            "x.com.samsung.da.code": "FilterAlarm",
+            "x.com.samsung.da.triggeredTime": "2026-07-26T15:24:44",
+            "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": "25.0",
+            "x.com.samsung.da.current": "20.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,
+          30
+        ],
+        "units": "C",
+        "temperature": 20.0
+      }
+    },
+    {
+      "href": "/temperature/desired/0",
+      "rep": {
+        "range": [
+          16,
+          30
+        ],
+        "units": "C",
+        "temperature": 25.0
+      }
+    },
+    {
+      "href": "/energy/consumption/vs/0",
+      "rep": {
+        "x.com.samsung.da.instantaneousPower": "0.000000",
+        "x.com.samsung.da.cumulativePower": "445938",
+        "x.com.samsung.da.cumulativeSavedPower": "81528",
+        "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": [
+          "Auto",
+          "Cool",
+          "Dry",
+          "Wind"
+        ],
+        "x.com.samsung.da.modes": [
+          "Auto"
+        ],
+        "x.com.samsung.da.options": [
+          "Sleep_0",
+          "ArtificialWorking_Off",
+          "ComfortAICooling_Off",
+          "AiTempChanged_Off",
+          "AiTemp_240",
+          "OutdoorTemp_84",
+          "CoolCapa_35",
+          "WarmCapa_0",
+          "Light_Off",
+          "Volume_Mute",
+          "StopAutoClean_Idle",
+          "Autoclean_Off",
+          "DiagnosisAI_Off",
+          "ProgressDiagnosisAI_0",
+          "ResultDiagnosisAI_Normal",
+          "OptionCode_52344",
+          "ExtendOptionCode_230029",
+          "RacInfo_None",
+          "UpdateAllow_NotAllowed",
+          "DurationOn_0",
+          "WelcomeCoolingState_Off"
+        ]
+      }
+    },
+    {
+      "href": "/power/vs/0",
+      "rep": {
+        "x.com.samsung.da.power": "Off",
+        "causeSource": "DEFT",
+        "operationNumber": "0"
+      }
+    },
+    {
+      "href": "/power/0",
+      "rep": {
+        "value": false
+      }
+    },
+    {
+      "href": "/sensors/vs/0",
+      "rep": {}
+    },
+    {
+      "href": "/information/vs/0",
+      "rep": {
+        "x.com.samsung.da.modelNum": "TP1X_DA-AC-RAC-01001_0000|10247441|60010523001811014E00002200D00000",
+        "x.com.samsung.da.description": "TP1X_DA-AC-RAC-01001_0000",
+        "x.com.samsung.da.serialNum": "**REDACTED**",
+        "x.com.samsung.da.otnDUID": "**REDACTED**",
+        "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": "AR2",
+        "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": "Version",
+            "x.com.samsung.da.type": "Software",
+            "x.com.samsung.da.number": "02646A260327",
+            "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": "102474A23112200",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          },
+          {
+            "x.com.samsung.da.id": "2",
+            "x.com.samsung.da.description": "Version",
+            "x.com.samsung.da.type": "Firmware",
+            "x.com.samsung.da.number": "102702A24041900,102579A10000200",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/file/information/vs/0",
+      "rep": {
+        "x.com.samsung.timeoffset": "-03: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_COOLONLY_3.0",
+          "AI_3.0",
+          "Auto_To_AI"
+        ]
+      }
+    },
+    {
+      "href": "/humidity/0",
+      "rep": {
+        "humidity": 0
+      }
+    },
+    {
+      "href": "/humidity/vs/0",
+      "rep": {
+        "x.com.samsung.da.humidity": "0",
+        "x.com.samsung.da.fivepercentHumidity": "66"
+      }
+    },
+    {
+      "href": "/drlc/0",
+      "rep": {
+        "DRLevel": 1,
+        "start": "2026-07-26T12:01:41Z",
+        "duration": 23,
+        "override": false
+      }
+    },
+    {
+      "href": "/drlc/vs/0",
+      "rep": {
+        "x.com.samsung.da.drlcLevel": "1",
+        "x.com.samsung.da.duration": "23:59:00",
+        "x.com.samsung.da.drlcStartTime": "2026-07-26T12:01:41Z",
+        "x.com.samsung.da.override": "Off",
+        "x.com.samsung.da.realSaving": "Off"
+      }
+    },
+    {
+      "href": "/availablecontrolsets/vs/0",
+      "rep": {
+        "x.com.samsung.da.sets": "000000A0012C0161024904000000",
+        "x.com.samsung.da.id": "RAC",
+        "x.com.samsung.da.version": "1.0"
+      }
+    },
+    {
+      "href": "/stepcontrol/vs/0",
+      "rep": {
+        "x.com.samsung.da.modes": "Off",
+        "x.com.samsung.da.supportedModes": [
+          "Off",
+          "80",
+          "60",
+          "40",
+          "Power"
+        ]
+      }
+    },
+    {
+      "href": "/keepnormalstate/vs/0",
+      "rep": {
+        "x.com.samsung.da.keepnormal": 1
+      }
+    },
+    {
+      "href": "/remotedatacontrol/vs/0",
+      "rep": {
+        "x.com.samsung.da.status": "Off",
+        "x.com.samsung.da.connectionStatus": "Disconnected"
+      }
+    },
+    {
+      "href": "/remotetemperature/vs/0",
+      "rep": {
+        "x.com.samsung.da.temperature": "",
+        "x.com.samsung.da.unit": "",
+        "x.com.samsung.da.error": ""
+      }
+    },
+    {
+      "href": "/remotedeviceinfo/vs/0",
+      "rep": {
+        "x.com.samsung.da.didList": ""
+      }
+    },
+    {
+      "href": "/otninformation/vs/0",
+      "rep": {
+        "x.com.samsung.da.target": "",
+        "x.com.samsung.da.newVersionAvailable": "false",
+        "x.com.samsung.da.newVersionNo": "00000000",
+        "x.com.samsung.da.currentVersionInfo": "00000000",
+        "otnStatus": "None",
+        "flashingProgress": "",
+        "otnTarget": "main",
+        "otnCompleteDate": "noHistory",
+        "otnList": [
+          {
+            "type": "WIFI",
+            "modelId": "ARA-WW-TP1-24-ARXX00",
+            "versions": [
+              "11260327"
+            ],
+            "visVersion": "260327"
+          },
+          {
+            "type": "Micom",
+            "modelId": "045210247441FFFFFFFF",
+            "versions": [
+              "23112200",
+              "FFFFFFFF"
+            ],
+            "visVersion": "231122"
+          },
+          {
+            "type": "Micom",
+            "modelId": "04521027024110257941",
+            "versions": [
+              "24041900",
+              "10000200"
+            ],
+            "visVersion": "240419"
+          }
+        ]
+      }
+    },
+    {
+      "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": "/timezone/vs/0",
+      "rep": {
+        "timezoneid": "America/Sao_Paulo",
+        "offset": "-03:00",
+        "DST": "OFF"
+      }
+    },
+    {
+      "href": "/option/muteonce/vs/0",
+      "rep": {
+        "muteonce": "Off"
+      }
+    },
+    {
+      "href": "/aisleep/vs/0",
+      "rep": {
+        "x.com.samsung.da.displayNightMode": "Off",
+        "x.com.samsung.da.elapsedTime": "0",
+        "x.com.samsung.da.requestFeedback": "Off",
+        "x.com.samsung.da.resultFeedback": "0",
+        "x.com.samsung.da.statusFeedback": "Idle",
+        "x.com.samsung.da.sleepTime": "14002200"
+      }
+    },
+    {
+      "href": "/wirelessinfo/vs/0",
+      "rep": {
+        "macaddressWiFi": "**REDACTED**",
+        "macaddressBLE": "**REDACTED**",
+        "connectedApSsid": "**REDACTED**"
+      }
+    },
+    {
+      "href": "/quickcontrol/info/vs/0",
+      "rep": {
+        "supportedVersion": "1.0"
+      }
+    }
+  ]
+}

tests/fixtures/airconditioner_windfree_device.json

@@ -0,0 +1,380 @@
+{
+  "device0": [
+    {
+      "rt": [
+        "x.com.samsung.devcol",
+        "oic.wk.col"
+      ],
+      "if": [
+        "oic.if.baseline",
+        "oic.if.ll",
+        "oic.if.b"
+      ]
+    },
+    {
+      "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-25T08:19:03"
+          },
+          {
+            "x.com.samsung.da.id": "1",
+            "x.com.samsung.da.description": "Alarm",
+            "x.com.samsung.da.alarmType": "Device",
+            "x.com.samsung.da.code": "FilterAlarm_OFF",
+            "x.com.samsung.da.triggeredTime": "2026-07-25T08:19:03"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/configuration/vs/0",
+      "rep": {
+        "x.com.samsung.da.region": "0000000000",
+        "x.com.samsung.da.airconOptionList": [
+          "SingleCommand_1",
+          "HOMECARE_WIZARD_V2",
+          "PRODUCT_GLOBAL",
+          "AI_RAC_GLOBAL_2.0",
+          "AI_2.0",
+          "Auto_To_AI",
+          "AI_Heat"
+        ]
+      }
+    },
+    {
+      "href": "/diagnosis/vs/0",
+      "rep": {
+        "x.com.samsung.da.diagnosisStart": "Ready"
+      }
+    },
+    {
+      "href": "/energy/consumption/0",
+      "rep": {
+        "power": 0.0
+      }
+    },
+    {
+      "href": "/energy/consumption/vs/0",
+      "rep": {
+        "x.com.samsung.da.instantaneousPower": "0",
+        "x.com.samsung.da.cumulativePower": "320466",
+        "x.com.samsung.da.cumulativeUnit": "Wh",
+        "x.com.samsung.da.instantaneousPowerUnit": "W"
+      }
+    },
+    {
+      "href": "/file/information/vs/0",
+      "rep": {
+        "x.com.samsung.timeoffset": "+00:00",
+        "x.com.samsung.supprtedtype": 1
+      }
+    },
+    {
+      "href": "/filter/airdustfilter/vs/0",
+      "rep": {
+        "x.com.samsung.da.filterUsage": "41",
+        "x.com.samsung.da.filterUsageResolution": "1",
+        "x.com.samsung.da.filterDesiredUsage": "500",
+        "x.com.samsung.da.filterStatus": "normal",
+        "x.com.samsung.da.filterCapacity": "500",
+        "x.com.samsung.da.filterCapacityUnit": "Hour",
+        "x.com.samsung.da.filterResetType": [
+          "replaceable",
+          "washable"
+        ]
+      }
+    },
+    {
+      "href": "/humidity/0",
+      "rep": {
+        "humidity": 0
+      }
+    },
+    {
+      "href": "/humidity/vs/0",
+      "rep": {
+        "x.com.samsung.da.humidity": "0",
+        "x.com.samsung.da.fivepercentHumidity": "42"
+      }
+    },
+    {
+      "href": "/information/vs/0",
+      "rep": {
+        "x.com.samsung.da.modelNum": "ARTIK051_PRAC_20K|10217841|60010519001411010200001000000000",
+        "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": "20082000,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": "20091600,10000400"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/mode/convenient/vs/0",
+      "rep": {
+        "x.com.samsung.da.modes": "Off",
+        "x.com.samsung.da.supportedModes": [
+          "Off",
+          "Sleep",
+          "Quiet",
+          "Smart",
+          "Speed",
+          "MotionIndirect",
+          "MotionDirect",
+          "Nano",
+          "NanoSleep"
+        ]
+      }
+    },
+    {
+      "href": "/mode/vs/0",
+      "rep": {
+        "x.com.samsung.da.supportedModes": [
+          "Cool",
+          "Dry",
+          "Wind",
+          "Auto",
+          "Heat"
+        ],
+        "x.com.samsung.da.modes": [
+          "Dry"
+        ],
+        "x.com.samsung.da.options": [
+          "Sleep_0",
+          "ArtificialWorking_Off",
+          "ComfortAICooling_Off",
+          "MotionState_Normal",
+          "AiTempChanged_Off",
+          "AiTemp_240",
+          "OutdoorTemp_87",
+          "CoolCapa_25",
+          "WarmCapa_32",
+          "Light_Off",
+          "Volume_100",
+          "MotionMode_Default",
+          "OptionCode_56376",
+          "ExtendOptionCode_781",
+          "RacInfo_None",
+          "UpdateAllow_NotAllowed",
+          "DurationOn_0",
+          "WelcomeCoolingState_Off"
+        ]
+      }
+    },
+    {
+      "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": "On",
+        "x.com.samsung.da.progress": "0",
+        "x.com.samsung.da.supportedStatus": [
+          "Start",
+          "Stop"
+        ],
+        "x.com.samsung.da.supportedSettingStatus": [
+          "On",
+          "Off"
+        ]
+      }
+    },
+    {
+      "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": "/power/0",
+      "rep": {
+        "value": false
+      }
+    },
+    {
+      "href": "/power/vs/0",
+      "rep": {
+        "x.com.samsung.da.power": "Off"
+      }
+    },
+    {
+      "href": "/realtimenotiforclient/vs/0",
+      "rep": {
+        "x.com.samsung.da.timeforshortnoti": "0",
+        "x.com.samsung.da.longnotisubscription": "false",
+        "x.com.samsung.da.periodicnotisubscription": "true"
+      }
+    },
+    {
+      "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": "/temperature/control/vs/0",
+      "rep": {
+        "x.com.samsung.da.increment": "1"
+      }
+    },
+    {
+      "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": 26.0
+      }
+    },
+    {
+      "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": "26.0",
+            "x.com.samsung.da.current": "27.0",
+            "x.com.samsung.da.maximum": "30",
+            "x.com.samsung.da.minimum": "18",
+            "x.com.samsung.da.increment": "1.0",
+            "x.com.samsung.da.unit": "Celsius"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/timezone/vs/0",
+      "rep": {}
+    },
+    {
+      "href": "/wind/direction/vs/0",
+      "rep": {
+        "x.com.samsung.da.modes": "Fix",
+        "x.com.samsung.da.supportedModes": [
+          "Fix",
+          "All",
+          "Up_And_Low",
+          "Left_And_Right"
+        ]
+      }
+    },
+    {
+      "href": "/wind/strength/vs/0",
+      "rep": {
+        "x.com.samsung.da.modes": "0",
+        "x.com.samsung.da.supportedModes": [
+          "0",
+          "1",
+          "2",
+          "3",
+          "4"
+        ],
+        "x.com.samsung.da.modesName": [
+          "Auto",
+          "Low",
+          "Mid",
+          "High",
+          "Turbo"
+        ]
+      }
+    }
+  ]
+}

tests/fixtures/airconditioner_windfree_oscillation_device.json

@@ -0,0 +1,590 @@
+{
+  "device0": [
+    {
+      "rt": [
+        "x.com.samsung.devcol",
+        "oic.wk.col"
+      ],
+      "if": [
+        "oic.if.baseline",
+        "oic.if.ll",
+        "oic.if.b"
+      ]
+    },
+    {
+      "href": "/aisleep/vs/0",
+      "rep": {
+        "x.com.samsung.da.displayNightMode": "Off",
+        "x.com.samsung.da.elapsedTime": "0",
+        "x.com.samsung.da.requestFeedback": "Off",
+        "x.com.samsung.da.resultFeedback": 0,
+        "x.com.samsung.da.statusFeedback": "Idle",
+        "x.com.samsung.da.sleepTime": "14002200"
+      }
+    },
+    {
+      "href": "/alarms/vs/0",
+      "rep": {
+        "x.com.samsung.da.items": [
+          {
+            "x.com.samsung.da.id": "0",
+            "x.com.samsung.da.alarmType": "Device",
+            "x.com.samsung.da.code": "ErrorCode_OFF",
+            "x.com.samsung.da.triggeredTime": "2026-07-27T11:59:06",
+            "x.com.samsung.da.state": "Deleted"
+          }
+        ],
+        "rt": [
+          "x.com.samsung.da.alarms"
+        ],
+        "if": [
+          "oic.if.baseline",
+          "oic.if.a"
+        ]
+      }
+    },
+    {
+      "href": "/anomalyload/vs/0",
+      "rep": {
+        "operation": "Off",
+        "mode": "Alarm",
+        "supportedModes": [
+          "Alarm",
+          "PowerSaving"
+        ],
+        "savingTime": "20",
+        "supportedSavingTime": [
+          "20",
+          "40",
+          "60"
+        ]
+      }
+    },
+    {
+      "href": "/availablecontrolsets/vs/0",
+      "rep": {
+        "x.com.samsung.da.sets": "000000A0012C01610CC90C0F0000",
+        "x.com.samsung.da.id": "RAC",
+        "x.com.samsung.da.version": "1.0"
+      }
+    },
+    {
+      "href": "/configuration/vs/0",
+      "rep": {
+        "x.com.samsung.da.region": "0000000000",
+        "x.com.samsung.da.airconOptionList": [
+          "PRODUCT_GLOBAL",
+          "AI_GLOBAL_COOLONLY_4.0",
+          "AI_3.0",
+          "Auto_To_AI",
+          "ENERGY_2.0",
+          "HOMECARE_WIZARD_V2",
+          "DR",
+          "SingleCommand_1"
+        ],
+        "InstalledRoomSize": "0.0",
+        "SkipInstalledRoomSize": "false",
+        "RoomSizeMenuNumber": "Manual"
+      }
+    },
+    {
+      "href": "/da/softreset/vs/0",
+      "rep": {
+        "x.com.samsung.da.softwarereset": "false"
+      }
+    },
+    {
+      "href": "/drlc/vs/0",
+      "rep": {
+        "x.com.samsung.da.start": "1970-01-01T00:00:00Z",
+        "x.com.samsung.da.override": "Off",
+        "x.com.samsung.da.durationminutes": "0",
+        "x.com.samsung.da.drlcLevel": "0",
+        "x.com.samsung.da.realSaving": "Off"
+      }
+    },
+    {
+      "href": "/energy/consumption/vs/0",
+      "rep": {
+        "x.com.samsung.da.cumulativeDate": "1785153515",
+        "x.com.samsung.da.cumulativeSavedPower": "0",
+        "x.com.samsung.da.cumulativePower": "47536",
+        "x.com.samsung.da.cumulativeUnit": "Wh",
+        "x.com.samsung.da.instantaneousPowerUnit": "W",
+        "x.com.samsung.da.cumulativePowerType": "total"
+      }
+    },
+    {
+      "href": "/file/information/vs/0",
+      "rep": {
+        "x.com.samsung.timeoffset": "+08:00",
+        "x.com.samsung.supprtedtype": 1
+      }
+    },
+    {
+      "href": "/filter/airdustfilter/vs/0",
+      "rep": {
+        "x.com.samsung.da.filterUsageResolution": "1",
+        "x.com.samsung.da.filterCapacity": "180",
+        "x.com.samsung.da.filterCapacityUnit": "Hour",
+        "x.com.samsung.da.filterResetType": [
+          "replaceable",
+          "washable"
+        ],
+        "x.com.samsung.da.filterStatus": "normal",
+        "x.com.samsung.da.filterUsage": "44",
+        "x.com.samsung.da.filterDesiredUsage": "180",
+        "x.com.samsung.da.supportedFilterDesiredUsage": [
+          "180",
+          "300",
+          "500",
+          "700"
+        ]
+      }
+    },
+    {
+      "href": "/humidity/vs/0",
+      "rep": {
+        "x.com.samsung.da.humidity": "0",
+        "x.com.samsung.da.fivepercentHumidity": "46"
+      }
+    },
+    {
+      "href": "/information/vs/0",
+      "rep": {
+        "x.com.samsung.da.otnDUID": "**REDACTED**",
+        "x.com.samsung.da.modelNum": "TP1X_DA-AC-RAC-01011_0000|10281241|6001051A001911018E0049300002A900",
+        "x.com.samsung.da.description": "TP1X_DA-AC-RAC-01011_0000",
+        "x.com.samsung.da.serialNum": "**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": "02825A260401",
+            "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.newVersionAvailable": "0",
+            "x.com.samsung.da.number": "02812A25111800,FFFFFFFFFFFFFF"
+          },
+          {
+            "x.com.samsung.da.id": "2",
+            "x.com.samsung.da.description": "Version",
+            "x.com.samsung.da.type": "Firmware",
+            "x.com.samsung.da.newVersionAvailable": "0",
+            "x.com.samsung.da.number": "02813A25101500,FFFFFFFFFFFFFF"
+          },
+          {
+            "x.com.samsung.da.id": "3",
+            "x.com.samsung.da.description": "Version",
+            "x.com.samsung.da.type": "Firmware",
+            "x.com.samsung.da.newVersionAvailable": "0",
+            "x.com.samsung.da.number": "FFFFFFFFFFFFFF,FFFFFFFFFFFFFF"
+          }
+        ],
+        "x.com.samsung.da.diagDumpType": "file",
+        "x.com.samsung.da.diagEndPoint": "SSM",
+        "x.com.samsung.da.diagLogType": [
+          "errCode",
+          "dump"
+        ],
+        "x.com.samsung.da.diagMnid": "0AJT",
+        "x.com.samsung.da.diagSetupid": "AR2",
+        "x.com.samsung.da.diagProtocolType": "BLE_OCF",
+        "x.com.samsung.da.diagMinVersion": "3.0",
+        "x.com.samsung.da.diagTsId": "DA01"
+      }
+    },
+    {
+      "href": "/keepnormalstate/vs/0",
+      "rep": {
+        "x.com.samsung.da.keepnormal": 0
+      }
+    },
+    {
+      "href": "/light/vs/0",
+      "rep": {
+        "mode": "On",
+        "supportedModes": [
+          "On",
+          "Off"
+        ]
+      }
+    },
+    {
+      "href": "/mds/absencemonitoring/vs/0",
+      "rep": {}
+    },
+    {
+      "href": "/mds/absencestate/vs/0",
+      "rep": {}
+    },
+    {
+      "href": "/mode/convenient/vs/0",
+      "rep": {
+        "x.com.samsung.da.modes": "Off",
+        "x.com.samsung.da.supportedModes": [
+          "Off",
+          "Sleep",
+          "Quiet",
+          "Smart",
+          "Speed",
+          "Nano",
+          "NanoSleep",
+          "DryComfort"
+        ]
+      }
+    },
+    {
+      "href": "/mode/vs/0",
+      "rep": {
+        "x.com.samsung.da.modes": [
+          "Cool"
+        ],
+        "workingMode": "Cool",
+        "x.com.samsung.da.supportedModes": [
+          "Auto",
+          "Cool",
+          "Dry",
+          "Fan"
+        ],
+        "x.com.samsung.da.options": [
+          "OptionCode_56416",
+          "Sleep_0",
+          "SleepRemainTime_0",
+          "ArtificialWorking_Off",
+          "ComfortAICooling_Off",
+          "AiTempChanged_Off",
+          "AiTemp_240",
+          "Volume_100",
+          "DiagnosisAI_Off",
+          "ProgressDiagnosisAI_0",
+          "ResultDiagnosisAI_Normal",
+          "SmartCoolClean_Off",
+          "ProgressSmartClean_0",
+          "OutDoorVentil_Off",
+          "InDoorVentil_Off",
+          "FreezeAlarmSetting_Off",
+          "DesiredFreezeAlarm_240",
+          "WashAlarm_Off",
+          "ExtendOptionCode_246413",
+          "UpdateAllow_NotAllowed",
+          "DurationOn_0",
+          "WelcomeCoolingState_Off"
+        ],
+        "rt": [
+          "x.com.samsung.da.mode"
+        ],
+        "if": [
+          "oic.if.baseline",
+          "oic.if.a"
+        ]
+      }
+    },
+    {
+      "href": "/option/autoclean/vs/0",
+      "rep": {
+        "x.com.samsung.da.status": "Stop",
+        "x.com.samsung.da.supportedStatus": [
+          "Start",
+          "Stop"
+        ],
+        "x.com.samsung.da.progress": "0",
+        "x.com.samsung.da.settingStatus": "Off",
+        "x.com.samsung.da.supportedSettingStatus": [
+          "On",
+          "Off"
+        ],
+        "defaultSettingStatus": "On"
+      }
+    },
+    {
+      "href": "/option/muteonce/vs/0",
+      "rep": {
+        "muteonce": "Off",
+        "rt": [
+          "x.com.samsung.da.option.muteonce"
+        ],
+        "if": [
+          "oic.if.baseline",
+          "oic.if.a"
+        ]
+      }
+    },
+    {
+      "href": "/personality/presence/vs/0",
+      "rep": {}
+    },
+    {
+      "href": "/power/vs/0",
+      "rep": {
+        "x.com.samsung.da.power": "Off",
+        "operationNumber": "2",
+        "displayCondition": "Enable"
+      }
+    },
+    {
+      "href": "/realtimenotiforclient/vs/0",
+      "rep": {
+        "x.com.samsung.da.timeforshortnoti": "0",
+        "x.com.samsung.da.longnotisubscription": "false",
+        "x.com.samsung.da.periodicnotisubscription": "true"
+      }
+    },
+    {
+      "href": "/reserverulesets/vs/0",
+      "rep": {
+        "x.com.samsung.da.sets": "8EFFFFFFFF101E121EFFFFFFFFFFFF000001001F0001000000000000009C00FFFF1E00",
+        "x.com.samsung.da.id": "RAC",
+        "x.com.samsung.da.version": "1.0"
+      }
+    },
+    {
+      "href": "/selfcheck/vs/0",
+      "rep": {
+        "x.com.samsung.da.start": "Cancel",
+        "x.com.samsung.da.status": "Ready",
+        "x.com.samsung.da.progress": "0",
+        "x.com.samsung.da.result": "NA",
+        "x.com.samsung.da.supportedActions": [
+          "Start",
+          "Cancel"
+        ],
+        "x.com.samsung.da.error": [
+          "DA_ERROR_NONE"
+        ]
+      }
+    },
+    {
+      "href": "/temperature/control/vs/0",
+      "rep": {
+        "x.com.samsung.da.increment": "1"
+      }
+    },
+    {
+      "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.current": "29.0",
+            "x.com.samsung.da.desired": "18.0",
+            "x.com.samsung.da.minimum": "16",
+            "x.com.samsung.da.maximum": "30",
+            "x.com.samsung.da.increment": "1",
+            "x.com.samsung.da.unit": "Celsius"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/wind/oscillation/vs/0",
+      "rep": {
+        "vertical": "Fix",
+        "supportedVertical": [
+          "Swing",
+          "Fix"
+        ],
+        "verticalAngle": "4",
+        "supportedVerticalAngle": [
+          "1",
+          "2",
+          "3",
+          "4",
+          "5",
+          "6"
+        ],
+        "horizontal": "Fix",
+        "supportedHorizontal": [
+          "Swing",
+          "Fix"
+        ],
+        "horizontalSwingMode": "AllSwing",
+        "supportedHorizontalSwingMode": [
+          "AllSwing",
+          "LeftSwing",
+          "RightSwing"
+        ],
+        "horizontalAngle": "3",
+        "supportedHorizontalAngle": [
+          "1",
+          "2",
+          "3",
+          "4",
+          "5"
+        ]
+      }
+    },
+    {
+      "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": "/otninformation/vs/0",
+      "rep": {
+        "x.com.samsung.da.target": "",
+        "x.com.samsung.da.newVersionAvailable": "false",
+        "otnStatus": "None",
+        "flashingProgress": "0",
+        "otnCompleteDate": "noHistory",
+        "scheduledTime": "None",
+        "swVersionInfo": {
+          "platform": "Tizen Lite",
+          "oneUiVersion": "7.0 Air conditioner",
+          "osVersion": "4.0"
+        },
+        "otnList": [
+          {
+            "type": "WIFI",
+            "modelId": "ARA-WW-TP1-26-AR6X00MG",
+            "versions": [
+              "11260401"
+            ],
+            "visVersion": "260401"
+          },
+          {
+            "type": "Micom",
+            "modelId": "845241131741FFFFFFFF",
+            "versions": [
+              "25102900",
+              "FFFFFFFF"
+            ],
+            "visVersion": "251029"
+          },
+          {
+            "type": "Micom",
+            "modelId": "045210281241FFFFFFFF",
+            "versions": [
+              "25111800",
+              "FFFFFFFF"
+            ],
+            "visVersion": "251118"
+          },
+          {
+            "type": "Micom",
+            "modelId": "045210281341FFFFFFFF",
+            "versions": [
+              "25101500",
+              "FFFFFFFF"
+            ],
+            "visVersion": "251015"
+          },
+          {
+            "type": "Micom",
+            "modelId": "0452FFFFFFFFFFFFFFFF",
+            "versions": [
+              "FFFFFFFF",
+              "FFFFFFFF"
+            ],
+            "visVersion": "999999"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/timezone/vs/0",
+      "rep": {
+        "timezoneid": "Asia/Kuala_Lumpur",
+        "offset": "+08:00",
+        "DST": "OFF"
+      }
+    },
+    {
+      "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": "/wirelessinfo/vs/0",
+      "rep": {
+        "macaddressWiFi": "**REDACTED**",
+        "macaddressBLE": "**REDACTED**",
+        "connectedApSsid": "K9 Unit"
+      }
+    },
+    {
+      "href": "/quickcontrol/info/vs/0",
+      "rep": {
+        "supportedVersion": "1.0"
+      }
+    },
+    {
+      "href": "/dginformation/vs/0",
+      "rep": {
+        "enrolmentstatus": "Unknown",
+        "devicestate": "Unknown",
+        "lockstatus": "Unknown",
+        "nextduedate": "",
+        "workingminutes": 0,
+        "paymentinfo": {
+          "emiplan": "Unknown",
+          "currency": "Unknown",
+          "totalemi": 0,
+          "totalemipaid": 0
+        }
+      }
+    },
+    {
+      "href": "/temperature/desired/0",
+      "rep": {
+        "temperature": 25
+      }
+    },
+    {
+      "href": "/power/0",
+      "rep": {
+        "value": false
+      }
+    }
+  ]
+}

tests/fixtures/airconditioner_window_ac_device.json

@@ -0,0 +1,523 @@
+{
+  "device0": [
+    {
+      "rt": [
+        "x.com.samsung.devcol",
+        "oic.wk.col"
+      ],
+      "if": [
+        "oic.if.baseline",
+        "oic.if.ll",
+        "oic.if.b"
+      ]
+    },
+    {
+      "href": "/aisleep/vs/0",
+      "rep": {
+        "x.com.samsung.da.displayNightMode": "Off",
+        "x.com.samsung.da.elapsedTime": "0",
+        "x.com.samsung.da.requestFeedback": "Off",
+        "x.com.samsung.da.resultFeedback": "0",
+        "x.com.samsung.da.statusFeedback": "Idle",
+        "x.com.samsung.da.sleepTime": "14002200"
+      }
+    },
+    {
+      "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-26T06:26:40",
+            "x.com.samsung.da.state": "Deleted"
+          },
+          {
+            "x.com.samsung.da.id": "1",
+            "x.com.samsung.da.description": "Alarm",
+            "x.com.samsung.da.alarmType": "Device",
+            "x.com.samsung.da.code": "FilterAlarm_OFF",
+            "x.com.samsung.da.triggeredTime": "2026-07-26T06:26:40",
+            "x.com.samsung.da.state": "Deleted"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/availablecontrolsets/vs/0",
+      "rep": {
+        "x.com.samsung.da.sets": "8D0D00B4012C3F21064804000000",
+        "x.com.samsung.da.id": "RAC",
+        "x.com.samsung.da.version": "1.0"
+      }
+    },
+    {
+      "href": "/configuration/vs/0",
+      "rep": {
+        "x.com.samsung.da.region": "2647000000",
+        "x.com.samsung.da.airconOptionList": [
+          "SingleCommand_1",
+          "DR",
+          "HOMECARE_WIZARD_V2",
+          "AI_RAC_KOREA_COOLONLY_3.0",
+          "AI_3.0",
+          "Auto_To_AI"
+        ]
+      }
+    },
+    {
+      "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": "/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": "/energy/consumption/0",
+      "rep": {
+        "power": 244.0
+      }
+    },
+    {
+      "href": "/energy/consumption/vs/0",
+      "rep": {
+        "x.com.samsung.da.instantaneousPower": "244.000000",
+        "x.com.samsung.da.cumulativePower": "11001",
+        "x.com.samsung.da.cumulativeSavedPower": "0",
+        "x.com.samsung.da.cumulativeUnit": "Wh",
+        "x.com.samsung.da.instantaneousPowerUnit": "W",
+        "x.com.samsung.da.cumulativePowerType": "total"
+      }
+    },
+    {
+      "href": "/file/information/vs/0",
+      "rep": {
+        "x.com.samsung.timeoffset": "+09:00",
+        "x.com.samsung.supprtedtype": 1
+      }
+    },
+    {
+      "href": "/filter/airdustfilter/vs/0",
+      "rep": {
+        "x.com.samsung.da.filterUsage": "20",
+        "x.com.samsung.da.filterUsageResolution": "1",
+        "x.com.samsung.da.filterDesiredUsage": "500",
+        "x.com.samsung.da.filterStatus": "normal",
+        "x.com.samsung.da.filterCapacity": "500",
+        "x.com.samsung.da.filterCapacityUnit": "Hour",
+        "x.com.samsung.da.filterResetType": [
+          "replaceable",
+          "washable"
+        ]
+      }
+    },
+    {
+      "href": "/humidity/0",
+      "rep": {
+        "humidity": 0
+      }
+    },
+    {
+      "href": "/humidity/vs/0",
+      "rep": {
+        "x.com.samsung.da.humidity": "0",
+        "x.com.samsung.da.fivepercentHumidity": "60"
+      }
+    },
+    {
+      "href": "/information/vs/0",
+      "rep": {
+        "x.com.samsung.da.modelNum": "TP1X_DA_AC_WAC_01001_0000|10254341|60050000001711014E00402000002000",
+        "x.com.samsung.da.description": "TP1X_DA_AC_WAC_01001_0000",
+        "x.com.samsung.da.serialNum": "**REDACTED**",
+        "x.com.samsung.da.otnDUID": "**REDACTED**",
+        "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": "AW0",
+        "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": "Version",
+            "x.com.samsung.da.type": "Software",
+            "x.com.samsung.da.number": "02545A260601",
+            "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": "02543A24061800,FFFFFFFFFFFFFF",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          },
+          {
+            "x.com.samsung.da.id": "2",
+            "x.com.samsung.da.description": "Version",
+            "x.com.samsung.da.type": "Outdoor",
+            "x.com.samsung.da.number": "02580A10000100,FFFFFFFFFFFFFF"
+          },
+          {
+            "x.com.samsung.da.id": "3",
+            "x.com.samsung.da.description": "Version",
+            "x.com.samsung.da.type": "Touch IC",
+            "x.com.samsung.da.number": "02553A23031600,FFFFFFFFFFFFFF"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/keepnormalstate/vs/0",
+      "rep": {
+        "x.com.samsung.da.keepnormal": 0
+      }
+    },
+    {
+      "href": "/light/vs/0",
+      "rep": {
+        "mode": "On",
+        "supportedModes": [
+          "On",
+          "Off"
+        ]
+      }
+    },
+    {
+      "href": "/mode/convenient/vs/0",
+      "rep": {
+        "x.com.samsung.da.modes": "Off",
+        "x.com.samsung.da.supportedModes": [
+          "Off",
+          "Quiet",
+          "Nano",
+          "NanoSleep"
+        ]
+      }
+    },
+    {
+      "href": "/mode/vs/0",
+      "rep": {
+        "x.com.samsung.da.supportedModes": [
+          "AIComfort",
+          "Cool",
+          "Dry",
+          "Fan"
+        ],
+        "x.com.samsung.da.modes": [
+          "Cool"
+        ],
+        "x.com.samsung.da.options": [
+          "OnTimer_0",
+          "OffTimer_0",
+          "ArtificialWorking_Off",
+          "ComfortAICooling_Off",
+          "AiTempChanged_Off",
+          "AiTemp_230",
+          "Volume_Mute",
+          "OutdoorTemp_97",
+          "CoolCapa_0",
+          "StopAutoClean_Idle",
+          "Autoclean_Off",
+          "OptionCode_51320",
+          "ExtendOptionCode_230093",
+          "RacInfo_None",
+          "UpdateAllow_NotAllowed",
+          "DurationOn_93",
+          "WelcomeCoolingState_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": "/option/muteonce/vs/0",
+      "rep": {
+        "muteonce": "Off"
+      }
+    },
+    {
+      "href": "/otninformation/vs/0",
+      "rep": {
+        "x.com.samsung.da.target": "",
+        "x.com.samsung.da.newVersionAvailable": "false",
+        "x.com.samsung.da.newVersionNo": "00000000",
+        "x.com.samsung.da.currentVersionInfo": "00000000",
+        "otnStatus": "None",
+        "flashingProgress": "",
+        "otnTarget": "main",
+        "otnCompleteDate": "noHistory",
+        "otnList": [
+          {
+            "type": "WIFI",
+            "modelId": "AWA-KR-TP1-23-AW7000",
+            "versions": [
+              "15260601"
+            ],
+            "visVersion": "260601"
+          },
+          {
+            "type": "Micom",
+            "modelId": "042010254341FFFFFFFF",
+            "versions": [
+              "24061800",
+              "FFFFFFFF"
+            ],
+            "visVersion": "240618"
+          },
+          {
+            "type": "Micom",
+            "modelId": "042010258041FFFFFFFF",
+            "versions": [
+              "10000100",
+              "FFFFFFFF"
+            ],
+            "visVersion": "100001"
+          },
+          {
+            "type": "Micom",
+            "modelId": "042010255341FFFFFFFF",
+            "versions": [
+              "23031600",
+              "FFFFFFFF"
+            ],
+            "visVersion": "230316"
+          }
+        ]
+      }
+    },
+    {
+      "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": "/power/0",
+      "rep": {
+        "value": true
+      }
+    },
+    {
+      "href": "/power/vs/0",
+      "rep": {
+        "x.com.samsung.da.power": "On",
+        "causeSource": "SMTS"
+      }
+    },
+    {
+      "href": "/quickcontrol/info/vs/0",
+      "rep": {
+        "supportedVersion": "1.0"
+      }
+    },
+    {
+      "href": "/realtimenotiforclient/vs/0",
+      "rep": {
+        "x.com.samsung.da.timeforshortnoti": "0",
+        "x.com.samsung.da.longnotisubscription": "true",
+        "x.com.samsung.da.periodicnotisubscription": "true"
+      }
+    },
+    {
+      "href": "/reserverulesets/vs/0",
+      "rep": {
+        "x.com.samsung.da.sets": "8DFFFFFFFF121E121E0000FFFFFFFFFFFF01000000011F0000000000000000001F8C00",
+        "x.com.samsung.da.id": "WAC",
+        "x.com.samsung.da.version": "1.0"
+      }
+    },
+    {
+      "href": "/selfcheck/vs/0",
+      "rep": {
+        "x.com.samsung.da.start": "Cancel",
+        "x.com.samsung.da.status": "Ready",
+        "x.com.samsung.da.progress": "0",
+        "x.com.samsung.da.result": "NA",
+        "x.com.samsung.da.supportedActions": [
+          "Start",
+          "Cancel"
+        ],
+        "x.com.samsung.da.error": [
+          "DA_ERROR_NONE"
+        ]
+      }
+    },
+    {
+      "href": "/sensors/vs/0",
+      "rep": {}
+    },
+    {
+      "href": "/temperature/control/vs/0",
+      "rep": {
+        "x.com.samsung.da.increment": "1"
+      }
+    },
+    {
+      "href": "/temperature/current/0",
+      "rep": {
+        "range": [
+          16,
+          30
+        ],
+        "units": "C",
+        "temperature": 30.0
+      }
+    },
+    {
+      "href": "/temperature/desired/0",
+      "rep": {
+        "range": [
+          16,
+          30
+        ],
+        "units": "C",
+        "temperature": 30.0
+      }
+    },
+    {
+      "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": "30.0",
+            "x.com.samsung.da.current": "30.0",
+            "x.com.samsung.da.maximum": "30",
+            "x.com.samsung.da.minimum": "18",
+            "x.com.samsung.da.increment": "1.0",
+            "x.com.samsung.da.unit": "Celsius"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/timezone/vs/0",
+      "rep": {
+        "timezoneid": "Asia/Seoul",
+        "offset": "+09:00",
+        "DST": "OFF"
+      }
+    },
+    {
+      "href": "/welcome/temperature/vs/0",
+      "rep": {
+        "operatingStatus": "None",
+        "requestId": "0000"
+      }
+    },
+    {
+      "href": "/wind/direction/vs/0",
+      "rep": {
+        "x.com.samsung.da.modes": "Fix",
+        "x.com.samsung.da.supportedModes": [
+          "Fix",
+          "Left_And_Right"
+        ]
+      }
+    },
+    {
+      "href": "/wind/strength/vs/0",
+      "rep": {
+        "x.com.samsung.da.modes": "1",
+        "x.com.samsung.da.supportedModes": [
+          "0",
+          "1",
+          "2",
+          "3",
+          "4",
+          "5"
+        ],
+        "x.com.samsung.da.modesName": [
+          "Auto",
+          "1",
+          "2",
+          "3",
+          "4",
+          "5"
+        ]
+      }
+    },
+    {
+      "href": "/wirelessinfo/vs/0",
+      "rep": {
+        "macaddressWiFi": "**REDACTED**",
+        "macaddressBLE": "**REDACTED**",
+        "connectedApSsid": "**REDACTED**"
+      }
+    }
+  ]
+}

tests/fixtures/dehumidifier_device.json

@@ -0,0 +1,386 @@
+{
+  "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": "224",
+        "x.com.samsung.da.filterStatus": "wash",
+        "x.com.samsung.da.filterCapacity": "224",
+        "x.com.samsung.da.filterCapacityUnit": "Hour",
+        "x.com.samsung.da.filterResetType": [
+          "washable"
+        ],
+        "x.com.samsung.da.supportedFilterDesiredUsage": [
+          "224",
+          "300",
+          "500",
+          "700"
+        ]
+      }
+    },
+    {
+      "href": "/mode/convenient/vs/0",
+      "rep": {
+        "x.com.samsung.da.supportedModes": [
+          "Off",
+          "Sleep"
+        ]
+      }
+    },
+    {
+      "href": "/option/autoclean/vs/0",
+      "rep": {
+        "x.com.samsung.da.status": "Stop",
+        "x.com.samsung.da.settingStatus": "On",
+        "x.com.samsung.da.progress": "100",
+        "cleaningTime": "30",
+        "minCleaningTime": "10",
+        "maxCleaningTime": "60",
+        "cleaningTimeUnit": "10",
+        "x.com.samsung.da.supportedStatus": [
+          "Start",
+          "TimedClean",
+          "Stop"
+        ],
+        "x.com.samsung.da.supportedSettingStatus": [
+          "On",
+          "TimedClean",
+          "Off"
+        ]
+      }
+    },
+    {
+      "href": "/alarms/vs/0",
+      "rep": {
+        "x.com.samsung.da.items": [
+          {
+            "x.com.samsung.da.id": "0",
+            "x.com.samsung.da.description": "Alarm",
+            "x.com.samsung.da.alarmType": "Device",
+            "x.com.samsung.da.code": "ErrorCode_OFF",
+            "x.com.samsung.da.triggeredTime": "2026-07-26T10:35:53",
+            "x.com.samsung.da.state": "Deleted"
+          },
+          {
+            "x.com.samsung.da.id": "2",
+            "x.com.samsung.da.description": "Alarm",
+            "x.com.samsung.da.alarmType": "Device",
+            "x.com.samsung.da.code": "WaterTankFull_OFF",
+            "x.com.samsung.da.triggeredTime": "2026-07-26T10:35:53",
+            "x.com.samsung.da.state": "Deleted"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/energy/consumption/vs/0",
+      "rep": {
+        "x.com.samsung.da.instantaneousPower": "259.000000",
+        "x.com.samsung.da.cumulativePower": "183099",
+        "x.com.samsung.da.cumulativeSavedPower": "0",
+        "x.com.samsung.da.cumulativeUnit": "Wh",
+        "x.com.samsung.da.instantaneousPowerUnit": "W",
+        "x.com.samsung.da.cumulativePowerType": "total"
+      }
+    },
+    {
+      "href": "/mode/vs/0",
+      "rep": {
+        "x.com.samsung.da.supportedModes": [
+          "Smart",
+          "Max",
+          "High",
+          "Medium",
+          "Quiet",
+          "ClothesDrying"
+        ],
+        "x.com.samsung.da.modes": [
+          "Smart"
+        ],
+        "x.com.samsung.da.options": [
+          "Volume_Mute",
+          "RacInfo_None",
+          "UpdateAllow_NotAllowed",
+          "WelcomeCoolingState_Off"
+        ]
+      }
+    },
+    {
+      "href": "/power/vs/0",
+      "rep": {
+        "x.com.samsung.da.power": "On",
+        "causeSource": "SMTS"
+      }
+    },
+    {
+      "href": "/sensors/vs/0",
+      "rep": {}
+    },
+    {
+      "href": "/information/vs/0",
+      "rep": {
+        "x.com.samsung.da.modelNum": "TP1X_DA_AC_DHM_01001_0000|10253841|77000000001700000A00000000000000",
+        "x.com.samsung.da.description": "TP1X_DA_AC_DHM_01001_0000",
+        "x.com.samsung.da.serialNum": "**REDACTED**",
+        "x.com.samsung.da.otnDUID": "**REDACTED**",
+        "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": "AY0",
+        "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": "Version",
+            "x.com.samsung.da.type": "Software",
+            "x.com.samsung.da.number": "02544A260401",
+            "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": "02538A24032700,FFFFFFFFFFFFFF",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          },
+          {
+            "x.com.samsung.da.id": "2",
+            "x.com.samsung.da.description": "Version",
+            "x.com.samsung.da.type": "Outdoor",
+            "x.com.samsung.da.number": "02590A10000100,FFFFFFFFFFFFFF"
+          },
+          {
+            "x.com.samsung.da.id": "4",
+            "x.com.samsung.da.description": "Version",
+            "x.com.samsung.da.type": "Touch IC",
+            "x.com.samsung.da.number": "02552A23020200,FFFFFFFFFFFFFF"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/file/information/vs/0",
+      "rep": {
+        "x.com.samsung.timeoffset": "+09: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_2.0",
+          "AI_Heat"
+        ]
+      }
+    },
+    {
+      "href": "/humidity/vs/0",
+      "rep": {
+        "x.com.samsung.da.humidity": "47",
+        "x.com.samsung.da.desiredHumidity": "50",
+        "increment": "5",
+        "x.com.samsung.da.fivepercentHumidity": "46"
+      }
+    },
+    {
+      "href": "/drlc/vs/0",
+      "rep": {
+        "x.com.samsung.da.drlcLevel": "0",
+        "x.com.samsung.da.durationminutes": "0",
+        "x.com.samsung.da.start": "1970-01-01T00:00:00Z",
+        "x.com.samsung.da.override": "Off",
+        "x.com.samsung.da.realSaving": "Off"
+      }
+    },
+    {
+      "href": "/availablecontrolsets/vs/0",
+      "rep": {
+        "x.com.samsung.da.sets": "20001E46070A5A00000000000000",
+        "x.com.samsung.da.id": "DHM",
+        "x.com.samsung.da.version": "1.0"
+      }
+    },
+    {
+      "href": "/da/softreset/vs/0",
+      "rep": {
+        "x.com.samsung.da.softwarereset": "false"
+      }
+    },
+    {
+      "href": "/keepnormalstate/vs/0",
+      "rep": {
+        "x.com.samsung.da.keepnormal": 0
+      }
+    },
+    {
+      "href": "/otninformation/vs/0",
+      "rep": {
+        "x.com.samsung.da.target": "",
+        "x.com.samsung.da.newVersionAvailable": "false",
+        "x.com.samsung.da.newVersionNo": "00000000",
+        "x.com.samsung.da.currentVersionInfo": "00000000",
+        "otnStatus": "None",
+        "flashingProgress": "",
+        "otnTarget": "main",
+        "otnCompleteDate": "noHistory",
+        "otnList": [
+          {
+            "type": "WIFI",
+            "modelId": "ADH-WW-TP1-23-AY7100",
+            "versions": [
+              "18260401"
+            ],
+            "visVersion": "260401"
+          },
+          {
+            "type": "Micom",
+            "modelId": "042110253841FFFFFFFF",
+            "versions": [
+              "24032700",
+              "FFFFFFFF"
+            ],
+            "visVersion": "240327"
+          },
+          {
+            "type": "Micom",
+            "modelId": "042110259041FFFFFFFF",
+            "versions": [
+              "10000100",
+              "FFFFFFFF"
+            ],
+            "visVersion": "100001"
+          },
+          {
+            "type": "Micom",
+            "modelId": "042110255241FFFFFFFF",
+            "versions": [
+              "23020200",
+              "FFFFFFFF"
+            ],
+            "visVersion": "230202"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/timezone/vs/0",
+      "rep": {
+        "timezoneid": "Asia/Seoul",
+        "offset": "+09:00",
+        "DST": "OFF"
+      }
+    },
+    {
+      "href": "/option/muteonce/vs/0",
+      "rep": {
+        "muteonce": "Off"
+      }
+    },
+    {
+      "href": "/reserverulesets/vs/0",
+      "rep": {
+        "x.com.samsung.da.sets": "3F1E461E461E46FFFFFFFF1E4600",
+        "x.com.samsung.da.id": "DHM",
+        "x.com.samsung.da.version": "1.0"
+      }
+    },
+    {
+      "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": "/welcome/humidity/vs/0",
+      "rep": {
+        "requestId": "0000",
+        "operatingStatus": "None"
+      }
+    },
+    {
+      "href": "/wirelessinfo/vs/0",
+      "rep": {
+        "macaddressWiFi": "**REDACTED**",
+        "macaddressBLE": "**REDACTED**"
+      }
+    },
+    {
+      "href": "/quickcontrol/info/vs/0",
+      "rep": {
+        "supportedVersion": "1.0"
+      }
+    }
+  ]
+}

tests/fixtures/dryer_dve50a8600_device.json

@@ -0,0 +1,391 @@
+{
+  "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": "/configuration/vs/0",
+      "rep": {
+        "x.com.samsung.da.region": "0000000000",
+        "x.com.samsung.da.countryCode": "US"
+      }
+    },
+    {
+      "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_0152",
+          "UpdateAllow_NotAllowed",
+          "Course_01",
+          "AiOption_On",
+          "MixedLoadBell_Disable",
+          "MixedLoadBellNoti_Nothing",
+          "LaundryOutTime_0",
+          "SeamlessControl_Enable",
+          "KidsLockBypass_On",
+          "DetergentOnce_1",
+          "DetergentLeft_0",
+          "DetergentBase_5",
+          "DetergentAlarm_Off",
+          "DetergentType_3",
+          "DetergentTotal_0",
+          "SpecialFunction_20",
+          "AvailableDelayTime_39",
+          "LaundryPlannerUserSetTime_0",
+          "ProgressTimeSet_B20870B400B4",
+          "WrinklePreventRunning_Off",
+          "DryTime_0",
+          "SendToDevice_Off",
+          "GMT_F6",
+          "DryTimeSet_0A00000000500A005A00000000000000001E0A005A00000000000000001414005A000000000000000000000000000000000000000000000000000000000000000000000000140A005A280A005A",
+          "EnergyLevelSet_0504040504040205020204040305020203030103",
+          "MostUsed_068A3ED000",
+          "WrinklePreventSet_0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F",
+          "MixedLoadBellSet_02FF02FFFF02FFFFFF0202FF02FFFF02FFFFFF",
+          "GeoFenceAlarm",
+          "UsagesDB_ok",
+          "EnergyKW_396",
+          "DrumCleanLog_Empty",
+          "TimeSync_NotSupported"
+        ],
+        "x.com.samsung.da.supportedOptions": [
+          "2018410D33E06833ED0002F8520D33E178520D3083E8520D000078102D33E338520D520358520D000348520D0000E8520D33E058520D33E308410D308318410D33E098410D3080F8204D308328308D33E2E8102D308368000D0000D8102D000"
+        ]
+      }
+    },
+    {
+      "href": "/cycleinterface/vs/0",
+      "rep": {
+        "x.com.samsung.da.cycleInterfaceEnabled": "On"
+      }
+    },
+    {
+      "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": "2323800",
+        "x.com.samsung.da.cumulativeUnit": "Wh",
+        "x.com.samsung.da.cumulativeDate": "1784991600",
+        "x.com.samsung.da.cumulativeDateUTC": "1785009600"
+      }
+    },
+    {
+      "href": "/file/information/vs/0",
+      "rep": {
+        "x.com.samsung.timeoffset": "-05:00"
+      }
+    },
+    {
+      "href": "/information/vs/0",
+      "rep": {
+        "x.com.samsung.da.modelNum": "DA_WM_TP1_21_COMMON|20286441|300000010015110002A3031700000000",
+        "x.com.samsung.da.description": "DA_WM_TP1_21_COMMON_DVE50A8800_8600/DC92-02835A_0080",
+        "x.com.samsung.da.serialNum": "**REDACTED**",
+        "x.com.samsung.da.otnDUID": "**REDACTED**",
+        "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": "310",
+        "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|20286441|300000010015110002A3031700000000",
+            "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_20286441210514150FFFFF202835412105131904FFFF(01522028644120283541_30000000)(FileDown:0)(Type:0)",
+            "x.com.samsung.da.type": "Firmware",
+            "x.com.samsung.da.number": "02864A21051415,02835A21051319",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/kidslock/0",
+      "rep": {
+        "value": false
+      }
+    },
+    {
+      "href": "/kidslock/vs/0",
+      "rep": {
+        "x.com.samsung.da.kidsLock": "Ready"
+      }
+    },
+    {
+      "href": "/operational/state/0",
+      "rep": {
+        "currentMachineState": "**REDACTED**",
+        "machineStates": "**REDACTED**",
+        "jobStates": [
+          "None",
+          "Drying",
+          "Cooling",
+          "Finish"
+        ],
+        "currentJobState": "None",
+        "remainingTime": "01:15:00",
+        "progressPercentage": "1"
+      }
+    },
+    {
+      "href": "/operational/state/vs/0",
+      "rep": {
+        "x.com.samsung.da.state": "Ready",
+        "x.com.samsung.da.remainingTime": "01:15: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": "01522028644120283541",
+            "versions": [
+              "21051415",
+              "21051319"
+            ],
+            "visVersion": "210514"
+          }
+        ]
+      }
+    },
+    {
+      "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": "10",
+        "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": {
+        "x.com.samsung.da.supportedSetLanguage": [
+          "en_US",
+          "ko_KR",
+          "fr_CA",
+          "es_MX",
+          "pt_BR"
+        ],
+        "x.com.samsung.da.setLanguage": "en_US"
+      }
+    },
+    {
+      "href": "/st/dryercourse/vs/0",
+      "rep": {
+        "x.com.samsung.da.st.dryerMode": "Table_03_Course_01",
+        "x.com.samsung.da.st.courseTable": "Table_03"
+      }
+    },
+    {
+      "href": "/timezone/vs/0",
+      "rep": {
+        "timezoneid": "America/Chicago",
+        "offset": "-05:00",
+        "DST": "ON"
+      }
+    },
+    {
+      "href": "/washer/vs/0",
+      "rep": {
+        "x.com.samsung.da.wrinklePrevent": "Off",
+        "x.com.samsung.da.waterTemperature": "Medium",
+        "x.com.samsung.da.supportedWaterTemperature": [
+          "None",
+          "ExtraLow",
+          "Low",
+          "MediumLow",
+          "Medium",
+          "High"
+        ],
+        "x.com.samsung.da.dryLevel": "Normal",
+        "x.com.samsung.da.supportedDryLevel": [
+          "None",
+          "Damp",
+          "Less",
+          "Normal",
+          "More",
+          "Very"
+        ],
+        "x.com.samsung.da.dryerType": "Electricity"
+      }
+    },
+    {
+      "href": "/wirelessinfo/vs/0",
+      "rep": {
+        "macaddressWiFi": "**REDACTED**",
+        "macaddressBLE": "**REDACTED**"
+      }
+    },
+    {
+      "href": "/wm/editcourse/vs/0",
+      "rep": {
+        "x.com.samsung.da.editCourseList": "EditCourseList_0106",
+        "x.com.samsung.da.fixedCourseList": "FixedCourseList_0101"
+      }
+    },
+    {
+      "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(DVE50A8600V/A3)"
+      }
+    },
+    {
+      "href": "/wm/welcomemsg/vs/0",
+      "rep": {}
+    }
+  ]
+}

tests/fixtures/golden/air_dresser.json

@@ -0,0 +1,20 @@
+{
+  "state_keys": [
+    "alarm_code",
+    "child_lock",
+    "completion_minutes",
+    "cycle",
+    "cycle_active",
+    "delay_start_hours",
+    "diagnosis_status",
+    "energy_kwh",
+    "finish_time",
+    "job_beginning_status",
+    "machine_state",
+    "power_switch",
+    "progress",
+    "progress_percentage",
+    "remote_control",
+    "wrinkle_prevent"
+  ]
+}

tests/fixtures/golden/air_dresser_tp2_20.json

@@ -0,0 +1,22 @@
+{
+  "state_keys": [
+    "alarm_code",
+    "child_lock",
+    "completion_minutes",
+    "cycle",
+    "cycle_active",
+    "delay_start_hours",
+    "diagnosis_status",
+    "energy_kwh",
+    "finish_time",
+    "firmware_update",
+    "job_beginning_status",
+    "machine_state",
+    "power_switch",
+    "progress",
+    "progress_percentage",
+    "remote_control",
+    "sanitize",
+    "wrinkle_prevent"
+  ]
+}

tests/fixtures/golden/air_purifier.json

@@ -1,24 +1,18 @@
 {
   "state_keys": [
+    "airflow_fan",
     "alarm_code",
     "clean_level",
     "device_active",
     "diagnosis_status",
     "display_light",
     "dust",
-    "energy_kwh",
-    "energy_last_month_kwh",
-    "energy_saved_kwh",
-    "energy_this_month_kwh",
     "fan_direction",
-    "fan_speed_level",
     "filter_progress",
     "fine_dust",
     "odor",
     "operating_mode",
-    "power_energy_kwh",
     "power_switch",
-    "power_watts",
     "super_fine_dust"
   ]
 }

tests/fixtures/golden/air_purifier_avt_ww.json

@@ -0,0 +1,19 @@
+{
+  "state_keys": [
+    "alarm_code",
+    "clean_level",
+    "device_active",
+    "dust",
+    "energy_kwh",
+    "energy_saved_kwh",
+    "fine_dust",
+    "firmware_update",
+    "hepa_filter_status",
+    "hepa_filter_usage",
+    "mute_once",
+    "odor",
+    "power_switch",
+    "super_fine_dust",
+    "wind_strength_fan"
+  ]
+}

tests/fixtures/golden/air_purifier_tp1x_da_ac_air.json

@@ -0,0 +1,27 @@
+{
+  "state_keys": [
+    "alarm_code",
+    "child_lock",
+    "clean_level",
+    "device_active",
+    "display",
+    "display_light",
+    "dust",
+    "energy_kwh",
+    "energy_saved_kwh",
+    "fan",
+    "fine_dust",
+    "firmware_update",
+    "hepa_filter_status",
+    "hepa_filter_usage",
+    "mute_once",
+    "odor",
+    "panel_status",
+    "pet_filter_activation",
+    "power_switch",
+    "sound_mode",
+    "sound_output",
+    "sound_volume",
+    "super_fine_dust"
+  ]
+}

tests/fixtures/golden/air_purifier_vtww.json

@@ -0,0 +1,17 @@
+{
+  "state_keys": [
+    "alarm_code",
+    "clean_level",
+    "device_active",
+    "dust",
+    "energy_kwh",
+    "fine_dust",
+    "firmware_update",
+    "hepa_filter_status",
+    "hepa_filter_usage",
+    "odor",
+    "power_switch",
+    "super_fine_dust",
+    "wind_strength_fan"
+  ]
+}

tests/fixtures/golden/airconditioner.json

@@ -2,13 +2,24 @@
   "state_keys": [
     "air_filter_status",
     "air_filter_usage",
+    "air_filter_usage_hours",
     "air_purify",
     "alarm_code",
     "auto_clean",
+    "beep",
+    "clean_level",
     "climate",
+    "current_temperature_c",
     "diagnosis_status",
+    "display_light",
+    "dust",
     "energy_kwh",
     "energy_saved_kwh",
-    "power_watts"
+    "fine_dust",
+    "humidity",
+    "odor",
+    "power_watts",
+    "super_fine_dust",
+    "tropical_night_mode"
   ]
 }

tests/fixtures/golden/airconditioner_ara_ww_tp1_22.json

@@ -0,0 +1,20 @@
+{
+  "state_keys": [
+    "air_filter_status",
+    "air_filter_usage",
+    "air_filter_usage_hours",
+    "alarm_code",
+    "auto_clean",
+    "beep",
+    "climate",
+    "current_temperature_c",
+    "display_light",
+    "energy_kwh",
+    "energy_saved_kwh",
+    "firmware_update",
+    "humidity",
+    "mute_once",
+    "power_watts",
+    "tropical_night_mode"
+  ]
+}

tests/fixtures/golden/airconditioner_artik051_dongle_fac_18k.json

@@ -0,0 +1,27 @@
+{
+  "state_keys": [
+    "alarm_code",
+    "auto_clean_legacy",
+    "beep",
+    "clean_level",
+    "climate",
+    "current_temperature_c",
+    "diagnosis_status",
+    "dust",
+    "energy_kwh",
+    "fine_dust",
+    "good_sleep",
+    "humidity",
+    "odor",
+    "power_energy_kwh",
+    "power_watts",
+    "super_fine_dust",
+    "subdevice1_alarm_code",
+    "subdevice1_auto_clean_legacy",
+    "subdevice1_beep",
+    "subdevice1_climate",
+    "subdevice1_current_temperature_c",
+    "subdevice1_good_sleep",
+    "subdevice1_humidity"
+  ]
+}