Merge pull request #206 from mbillow/fix/subdevice-flat-href-fallback-205

fix(subdevices): fall back to per-href probing when a prefixed subdevice has no /device/0 Collection

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

@@ -10,7 +10,9 @@ description: >-
   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
@@ -25,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.
@@ -61,6 +77,12 @@ print('state_keys:', sorted(state))
 `exists_fn` and produces the final entity values. Use the same routine to
 regenerate a golden.
 
+**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
@@ -192,6 +214,19 @@ 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).
 
+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.
+
 ## 6. Select options: read them from the device, don't hardcode
 
 A `SelectDesc`'s `options` should come from the device's own advertised list
@@ -275,6 +310,17 @@ 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.
 
+- **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`
@@ -289,8 +335,27 @@ shared module rather than copying.
 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).
@@ -303,7 +368,73 @@ The new fixture is picked up automatically by the corpus-wide checks (the
 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) 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. If they're 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, which is exactly what the primary-entity filter exists to ignore.
+
 ## 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

@@ -185,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/climate.py

@@ -254,8 +254,7 @@ class LocalThingsClimate(LocalThingsEntity, ClimateEntity):
     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.coordinator.resource(MODE_HREF) or {}).get(
-            'x.com.samsung.da.options') or []
+        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]],
@@ -268,18 +267,26 @@ class LocalThingsClimate(LocalThingsEntity, ClimateEntity):
 
         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 last_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
+        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.coordinator.last_resources):
+        if not is_legacy_board(self._resources):
             return {}
-        return self.coordinator.resource(AIRFLOW_HREF) or {}
+        return self._rep(AIRFLOW_HREF)
 
     def _legacy_preset(self) -> bool:
         """Whether presets come from the Comode_* token rather than a resource.
@@ -288,12 +295,25 @@ class LocalThingsClimate(LocalThingsEntity, ClimateEntity):
         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.
         """
-        return (not self.coordinator.resource(CONVENIENT_HREF)
+        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:
-        rep = 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

custom_components/localthings/config_flow.py

@@ -194,7 +194,17 @@ 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:
@@ -238,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

custom_components/localthings/coordinator.py

@@ -30,10 +30,14 @@ from .registry.capabilities.common import (
     remote_control_enabled,
     remote_control_required_for_write,
 )
-from .registry.discovery import discover, BoundEntity
+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 (
@@ -161,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)
@@ -197,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
@@ -245,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
@@ -292,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."""
@@ -351,6 +532,72 @@ 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:
         # Reported for diagnostics only -- it names the firmware generation
         # ('7.0 Air conditioner' is Tizen Lite), which is useful when triaging
@@ -360,7 +607,6 @@ class LocalThingsCoordinator(DataUpdateCoordinator[dict[str, Any]]):
                                .get('swVersionInfo', {})
                                .get('oneUiVersion', ''))
         info = resources.get('/information/vs/0', {})
-        reg = resolve_registry(resources)
         unbound: list[str] = []
         hot, warm = set(), set()
 
@@ -372,11 +618,54 @@ class LocalThingsCoordinator(DataUpdateCoordinator[dict[str, Any]]):
 
         model_num = info.get('x.com.samsung.da.modelNum', '')
         description = info.get('x.com.samsung.da.description', '')
-        if reg is not None:
-            self._log.debug("device type: %s (modelNum=%r)", reg.name, model_num)
-            bound = discover(resources, reg.capabilities, reg.pattern_capabilities,
-                              log=unbound.append, tier_log=_tier_log)
-            self.device_type_name = reg.name
+
+        # 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:
             # Both fields: detection reads each of them (board token, then
             # consumer-model code), and this line is what a user pastes into
@@ -385,8 +674,7 @@ class LocalThingsCoordinator(DataUpdateCoordinator[dict[str, Any]]):
                 "unknown device type modelNum=%r description=%r; using common caps",
                 model_num, description,
             )
-            bound = discover(resources, CAPABILITIES, log=unbound.append, tier_log=_tier_log)
-            self.device_type_name = None
+        self.device_type_name = device_type_name
         self.bound = bound
         self._unbound_hrefs = unbound
 
@@ -396,7 +684,7 @@ class LocalThingsCoordinator(DataUpdateCoordinator[dict[str, Any]]):
         self.device_serial = serial
 
         ident = self._identity
-        device_type = reg.name.replace('_', ' ').title() if reg else 'Appliance'
+        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'
@@ -407,15 +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)
 
         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(
@@ -568,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
@@ -584,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()
@@ -671,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,

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(
@@ -36,9 +37,47 @@ async def async_get_config_entry_diagnostics(
     # 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 unit exposes more than one logical Device. See
+    # 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,
@@ -49,7 +88,71 @@ async def async_get_config_entry_diagnostics(
             "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

@@ -33,12 +33,19 @@ def _is_included(bound: BoundEntity, coordinator: 'LocalThingsCoordinator') -> b
     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 or is_stub_rep(rep):
             return True
@@ -122,9 +129,21 @@ class LocalThingsEntity(CoordinatorEntity[LocalThingsCoordinator]):
         """
         tk = self._bound.desc.translation_key
         if callable(tk):
-            return tk(self.coordinator.last_resources)
+            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

@@ -42,6 +42,7 @@ 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'
@@ -89,11 +90,13 @@ class LocalThingsRangeHoodFan(LocalThingsEntity, FanEntity):
     """
 
     _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)
@@ -119,7 +122,18 @@ class LocalThingsRangeHoodFan(LocalThingsEntity, FanEntity):
 
     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]:
         codes = self._all_speed_codes()
@@ -134,7 +148,7 @@ class LocalThingsRangeHoodFan(LocalThingsEntity, FanEntity):
 
     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
 
@@ -237,7 +251,7 @@ class LocalThingsAirPurifierFan(LocalThingsEntity, FanEntity):
         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.coordinator.last_resources
+        resources = self._resources
         target = POWER_VS_HREF if POWER_VS_HREF in resources else POWER_HREF
         return 'power', enabled, target
 
@@ -344,7 +358,7 @@ class LocalThingsAirflowFan(LocalThingsEntity, FanEntity):
         resources -- disagreeing until the next poll refreshes the other
         one (the same optimistic-apply lag coordinator.py's own comments
         warn about)."""
-        resources = self.coordinator.last_resources
+        resources = self._resources
         target = POWER_HREF if POWER_HREF in resources else POWER_VS_HREF
         return 'power', enabled, target
 

custom_components/localthings/manifest.json

@@ -12,5 +12,5 @@
     "pyOpenSSL>=23.0",
     "smartthings-local>=0.1.1"
   ],
-  "version": "0.15.0"
+  "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/by_type/__init__.py

@@ -75,17 +75,24 @@ _BOARD_TOKEN_TO_KEY: dict[str, str] = {
     # 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), and ARA-WW wall-mount (#115, #116, #117, #120).
+    # (#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',
@@ -129,8 +136,20 @@ def _board_family_key(value: str, cut_at: str) -> Optional[str]:
     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.
     """
-    for token in _board_tokens(value, cut_at):
+    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

custom_components/localthings/registry/by_type/air_purifier.py

@@ -16,6 +16,11 @@ match_fn discriminators that keep them from colliding):
   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).

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,7 +23,9 @@ 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,

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,

custom_components/localthings/registry/by_type/water_purifier.py

@@ -15,6 +15,11 @@ REGISTRY = DeviceRegistry(
         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/airconditioner.py

@@ -14,10 +14,13 @@ 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, NumberDesc, SelectDesc, SensorDesc, SwitchDesc,
 )
+from . import common
 from .common import filter_usage_percent, normalize_temp_unit
 from .laundry import option_write
 
@@ -285,17 +288,64 @@ def _option_token(rep, prefix):
 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 (Volume, 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. 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.
+    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)
@@ -445,14 +495,19 @@ CLIMATE = Capability(
                    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.
-        # Gated off the legacy ARTIK051 board generation (see is_legacy_board):
-        # that generation's own Volume_ token is already modeled as the
-        # buzzer_volume Number below, and both reading the same options[] slot
-        # into two entities would be redundant.
+        #
+        # 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: (
-                       not is_legacy_board(resources)
-                       and _option_token(rep, 'Volume') is not None),
+                   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.
@@ -498,11 +553,6 @@ CLIMATE = Capability(
                    exists_fn=_has_option_token('AirMonitoring'),
                    write_fn=_option_switch_write('AirMonitoring'),
                    icon='mdi:air-filter', entity_category='config'),
-        NumberDesc(key='buzzer_volume', rep_fn=_option_token_num('Volume'),
-                   exists_fn=_has_option_token('Volume'),
-                   write_fn=_option_number_write('Volume'),
-                   native_min=0, native_max=100, step=10,
-                   icon='mdi:volume-high', 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.
@@ -889,24 +939,34 @@ _AC_IGNORED = [
     '/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 unit over one shared local IP, e.g.
+    # *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. This integration talks to whichever
-    # single local endpoint the config entry was set up against; the
-    # second indoor unit isn't independently reachable through this
-    # resource (or any other in the dump) -- it would need its own local
-    # DTLS session/IP, which SmartThings pairing doesn't expose here.
+    # /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).

custom_components/localthings/registry/capabilities/common.py

@@ -259,6 +259,12 @@ 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.
@@ -277,6 +283,7 @@ POWER_GENERIC = Capability(
 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',
                    value_fn=lambda v: v == 'On',
@@ -604,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/fridge.py

@@ -108,6 +108,37 @@ TEMP_SETPOINT = Capability(
     ),
 )
 
+# ---------------------------------------------------------------------------
+# 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),
+    ),
+)
+
 # ---------------------------------------------------------------------------
 # Icemaker nighttime quiet mode
 # ---------------------------------------------------------------------------

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,
@@ -130,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
@@ -199,44 +222,19 @@ def _oven_mode_write(p, rep, href=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
 
 
 # ---------------------------------------------------------------------------
@@ -377,19 +375,38 @@ OVEN_MODE = Capability(
         SwitchDesc(key='lamp', field='x.com.samsung.da.options',
                    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',
                    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',
                    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',
                    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/water_purifier.py

@@ -1,8 +1,10 @@
 """Capabilities for the Samsung water-purifier family (TP2X_WATERPURIFIER-class,
-issue #90, model TP2X_WATERPURIFIER_20K).
+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 diagnostics dump.
+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
@@ -21,10 +23,23 @@ DISPENSE = Capability(
         # 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})),
@@ -190,6 +205,86 @@ COFFEE = Capability(
     ),
 )
 
+# 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',

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,6 +29,12 @@ 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:
@@ -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
     ]
 
@@ -74,6 +88,7 @@ def discover(
     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
@@ -81,7 +96,19 @@ def discover(
     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`."""
+    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():
@@ -97,10 +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(href, cap.poll_tier)
+                tier_log(subdevice.to_actual(href), cap.poll_tier)
 
         if matched:
             continue
@@ -117,13 +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(href, cap.poll_tier)
+                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/identity.py

@@ -70,11 +70,14 @@ def read_identity(sess, serial: Optional[str]) -> DeviceIdentity:
     # 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 unit -- one IP, one /oic/p -- exposing more than one logical
-    # Device, each as its own Collection resource, same rt shape as our own
-    # /device/0). Nothing consumes this yet; captured so a report from a
-    # multi-unit device shows us whether its firmware actually implements
-    # that model before any code assumes it does.
+    # 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',

custom_components/localthings/registry/subdevices.py

@@ -0,0 +1,562 @@
+"""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`) 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.
+"""
+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, ...]
+
+
+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).
+
+    This is the materialization gate itself (see this module's docstring):
+    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 a physical subdevice is actually
+    installed there, so it's deliberately excluded from this check.
+    """
+    from .adapter import _key  # see discover_partitioned's deferred-import note
+    return any(
+        not b.desc.entity_category 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

@@ -104,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/translations/en.json

@@ -73,6 +73,9 @@
       "pouring": {
         "name": "Pouring"
       },
+      "alarm_in_mute": {
+        "name": "Alarm in mute"
+      },
       "power_state": {
         "name": "Power state"
       },
@@ -158,9 +161,6 @@
       }
     },
     "number": {
-      "buzzer_volume": {
-        "name": "Beep volume"
-      },
       "cook_time": {
         "name": "Cook time"
       },
@@ -214,6 +214,9 @@
           "100": "High"
         }
       },
+      "cooler_temperature_setpoint": {
+        "name": "Cooler temperature"
+      },
       "day_brightness": {
         "name": "Cabinet brightness",
         "state": {
@@ -490,6 +493,14 @@
           "buzzer": "Buzzer"
         }
       },
+      "water_purifier_sound_mode": {
+        "name": "Sound mode",
+        "state": {
+          "voice": "Voice",
+          "fixedtone": "Fixed tone",
+          "mute": "Mute"
+        }
+      },
       "spin_speed": {
         "name": "Spin speed",
         "state": {
@@ -876,6 +887,15 @@
       "waterpurifier_status": {
         "name": "Status"
       },
+      "cup_state": {
+        "name": "Cup state"
+      },
+      "last_pour_type": {
+        "name": "Last pour type"
+      },
+      "last_pour_capacity": {
+        "name": "Last pour capacity"
+      },
       "machine_state": {
         "name": "Machine state",
         "state": {
@@ -1018,6 +1038,12 @@
       "natural_steam": {
         "name": "Natural steam"
       },
+      "energy_saving": {
+        "name": "Energy saving"
+      },
+      "cooktop_on_alert": {
+        "name": "Cooktop-on alert"
+      },
       "power_switch": {
         "name": "Power"
       },

custom_components/localthings/translations/nl.json

@@ -73,6 +73,9 @@
       "pouring": {
         "name": "Schenken"
       },
+      "alarm_in_mute": {
+        "name": "Alarm bij dempen"
+      },
       "power_state": {
         "name": "Voedingsstatus"
       },
@@ -158,9 +161,6 @@
       }
     },
     "number": {
-      "buzzer_volume": {
-        "name": "Zoemervolume"
-      },
       "cook_time": {
         "name": "Bereidingstijd"
       },
@@ -214,6 +214,9 @@
           "100": "Hoog"
         }
       },
+      "cooler_temperature_setpoint": {
+        "name": "Koeler temperatuur"
+      },
       "day_brightness": {
         "name": "Helderheid kast",
         "state": {
@@ -490,6 +493,14 @@
           "buzzer": "Zoemer"
         }
       },
+      "water_purifier_sound_mode": {
+        "name": "Geluidsmodus",
+        "state": {
+          "voice": "Spraak",
+          "fixedtone": "Vaste toon",
+          "mute": "Dempen"
+        }
+      },
       "spin_speed": {
         "name": "Centrifugesnelheid",
         "state": {
@@ -876,6 +887,15 @@
       "waterpurifier_status": {
         "name": "Status"
       },
+      "cup_state": {
+        "name": "Kopstatus"
+      },
+      "last_pour_type": {
+        "name": "Laatste schenktype"
+      },
+      "last_pour_capacity": {
+        "name": "Laatste schenkhoeveelheid"
+      },
       "machine_state": {
         "name": "Machinestatus",
         "state": {
@@ -1018,6 +1038,12 @@
       "natural_steam": {
         "name": "Natuurlijke stoom"
       },
+      "energy_saving": {
+        "name": "Energiebesparing"
+      },
+      "cooktop_on_alert": {
+        "name": "Waarschuwing kookplaat aan"
+      },
       "power_switch": {
         "name": "Voeding"
       },

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 = {

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/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/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/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"
+  ]
+}

tests/fixtures/golden/airconditioner_artik051_krac_18k.json

@@ -3,7 +3,7 @@
     "air_monitoring",
     "alarm_code",
     "auto_clean_legacy",
-    "buzzer_volume",
+    "beep",
     "climate",
     "current_temperature_c",
     "diagnosis_status",
@@ -15,4 +15,4 @@
     "outdoor_temperature",
     "spi"
   ]
-}
+}

tests/fixtures/golden/airconditioner_artik051_krac_energy.json

@@ -0,0 +1,18 @@
+{
+  "state_keys": [
+    "air_monitoring",
+    "alarm_code",
+    "auto_clean_legacy",
+    "beep",
+    "climate",
+    "current_temperature_c",
+    "diagnosis_status",
+    "display_light",
+    "energy_kwh",
+    "filter_time",
+    "good_sleep",
+    "humidity",
+    "outdoor_temperature",
+    "spi"
+  ]
+}

tests/fixtures/golden/airconditioner_cac.json

@@ -0,0 +1,30 @@
+{
+  "state_keys": [
+    "absence_power_saving_active",
+    "absence_power_saving_mode",
+    "air_filter_status",
+    "air_filter_usage",
+    "air_filter_usage_hours",
+    "air_purify",
+    "alarm_code",
+    "auto_clean",
+    "clean_level",
+    "climate",
+    "current_temperature_c",
+    "dust",
+    "energy_kwh",
+    "energy_saved_kwh",
+    "fine_dust",
+    "firmware_update",
+    "humidity",
+    "motion_detect_wind_active",
+    "motion_detect_wind_mode",
+    "mute_once",
+    "power_watts",
+    "selfcheck_error",
+    "selfcheck_result",
+    "selfcheck_status",
+    "super_fine_dust",
+    "tropical_night_mode"
+  ]
+}

tests/fixtures/golden/airconditioner_fac_bora_205_flat.json

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

tests/fixtures/golden/airconditioner_fac_bora_2in1.json

@@ -0,0 +1,22 @@
+{
+  "state_keys": [
+    "air_filter_status",
+    "air_filter_threshold",
+    "air_filter_usage",
+    "air_filter_usage_hours",
+    "alarm_code",
+    "auto_clean",
+    "beep",
+    "climate",
+    "current_temperature_c",
+    "diagnosis_status",
+    "energy_kwh",
+    "firmware_update",
+    "humidity",
+    "power_energy_kwh",
+    "power_watts",
+    "subdevice_6c2dff6dee5cdad16a5e000000000001_climate",
+    "subdevice_6c2dff6dee5cdad16a5e000000000001_current_temperature_c",
+    "tropical_night_mode"
+  ]
+}

tests/fixtures/golden/oven.json

@@ -7,12 +7,10 @@
     "current_temp_c",
     "cycle_active",
     "door_open",
-    "fast_preheat",
     "finish_time",
     "firmware_update",
     "lamp",
     "machine_state",
-    "natural_steam",
     "operation_time_minutes",
     "oven_mode",
     "oven_setpoint",
@@ -22,4 +20,4 @@
     "remote_control",
     "sound"
   ]
-}
+}

tests/fixtures/golden/range.json

@@ -27,12 +27,11 @@
     "current_temp_c",
     "cycle_active",
     "door_open",
-    "fast_preheat",
+    "energy_saving",
     "finish_time",
     "firmware_update",
     "lamp",
     "machine_state",
-    "natural_steam",
     "operation_time_minutes",
     "oven_mode",
     "oven_setpoint",
@@ -42,4 +41,4 @@
     "remote_control",
     "sound"
   ]
-}
+}

tests/fixtures/golden/range_ne63a6511.json

@@ -4,16 +4,16 @@
     "child_lock",
     "cloud_connected",
     "cook_time",
+    "cooktop_on_alert",
     "cooktop_running_state",
     "current_temp_c",
     "cycle_active",
     "door_open",
-    "fast_preheat",
+    "energy_saving",
     "finish_time",
     "firmware_update",
     "lamp",
     "machine_state",
-    "natural_steam",
     "operation_time_minutes",
     "oven_mode",
     "oven_setpoint",
@@ -24,4 +24,4 @@
     "sound",
     "warming_center_state"
   ]
-}
+}

tests/fixtures/golden/range_ne6516a.json

@@ -0,0 +1,27 @@
+{
+  "state_keys": [
+    "alarm_code",
+    "cooktop_on_alert",
+    "child_lock",
+    "cloud_connected",
+    "cook_time",
+    "cooktop_running_state",
+    "current_temp_c",
+    "cycle_active",
+    "door_open",
+    "energy_saving",
+    "finish_time",
+    "firmware_update",
+    "lamp",
+    "machine_state",
+    "operation_time_minutes",
+    "oven_mode",
+    "oven_setpoint",
+    "oven_state",
+    "power_switch",
+    "progress_percentage",
+    "remote_control",
+    "sound",
+    "warming_center_state"
+  ]
+}

tests/fixtures/golden/range_ne8300d.json

@@ -8,12 +8,11 @@
     "current_temp_c",
     "cycle_active",
     "door_open",
-    "fast_preheat",
+    "energy_saving",
     "finish_time",
     "firmware_update",
     "lamp",
     "machine_state",
-    "natural_steam",
     "operation_time_minutes",
     "oven_mode",
     "oven_setpoint",

tests/fixtures/golden/range_no_info.json

@@ -4,16 +4,16 @@
     "child_lock",
     "cloud_connected",
     "cook_time",
+    "cooktop_on_alert",
     "cooktop_running_state",
     "current_temp_c",
     "cycle_active",
     "door_open",
-    "fast_preheat",
+    "energy_saving",
     "finish_time",
     "firmware_update",
     "lamp",
     "machine_state",
-    "natural_steam",
     "operation_time_minutes",
     "oven_mode",
     "oven_setpoint",
@@ -24,4 +24,4 @@
     "sound",
     "warming_center_state"
   ]
-}
+}

tests/fixtures/golden/refrigerator_definite_cooler.json

@@ -0,0 +1,27 @@
+{
+  "state_keys": [
+    "ai_energy_level",
+    "alarm_code",
+    "auto_door_opener",
+    "brightness_level",
+    "cabinet_light_dim",
+    "cabinet_light_switch",
+    "cooler_temperature_setpoint",
+    "day_brightness",
+    "door_alert",
+    "door_cooler_open",
+    "energy_kwh",
+    "energy_saved_kwh",
+    "firmware_update",
+    "fridge_sound",
+    "night_end",
+    "night_start",
+    "power_energy_kwh",
+    "power_watts",
+    "rapid_freezing",
+    "rapid_fridge",
+    "selfcheck_error",
+    "selfcheck_result",
+    "selfcheck_status"
+  ]
+}

tests/fixtures/golden/water_purifier_ailite_25k.json

@@ -0,0 +1,36 @@
+{
+  "state_keys": [
+    "alarm_code",
+    "alarm_in_mute",
+    "buzz_lock",
+    "coffee_brew_status",
+    "coldwater_lock",
+    "cup_state",
+    "dispense_capacity",
+    "dispense_type",
+    "favorite_capacity",
+    "favorite_capacity_enabled",
+    "favorite_coffee_enabled",
+    "favorite_hotwater_temperature",
+    "filter_clean_remain_time",
+    "filter_door_status",
+    "filter_status",
+    "filter_usage",
+    "firmware_update",
+    "hotwater_lock",
+    "last_pour_capacity",
+    "last_pour_type",
+    "pouring",
+    "selfcheck_error",
+    "selfcheck_result",
+    "selfcheck_status",
+    "sound_mode",
+    "sound_output",
+    "sound_volume",
+    "sterilize_last_time",
+    "sterilize_period",
+    "sterilize_plan_time",
+    "sterilize_run_time",
+    "waterpurifier_status"
+  ]
+}

tests/fixtures/golden/water_purifier_coffee.json

@@ -15,7 +15,6 @@
     "filter_status",
     "filter_usage",
     "firmware_update",
-    "hot_water_temperature",
     "hotwater_lock",
     "pouring",
     "selfcheck_error",

tests/fixtures/refrigerator_definite_cooler_device.json

@@ -0,0 +1,401 @@
+{
+  "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": "/alarms/vs/0",
+        "rt": [
+          "x.com.samsung.da.alarms"
+        ],
+        "if": [
+          "oic.if.baseline",
+          "oic.if.a"
+        ]
+      }
+    },
+    {
+      "href": "/cabinet/light/total/vs/0",
+      "rep": {
+        "x.com.samsung.da.lightLevel": "100",
+        "x.com.samsung.da.lightResolution": "3",
+        "x.com.samsung.da.lightControl.off.include": "Off",
+        "x.com.samsung.da.lightControl": "Off",
+        "x.com.samsung.da.lightControl.hide": "true",
+        "light.dimming.status": "On",
+        "href": "/cabinet/light/total/vs/0",
+        "rt": [
+          "x.com.samsung.da.cabinetlight"
+        ],
+        "if": [
+          "oic.if.baseline",
+          "oic.if.a"
+        ]
+      }
+    },
+    {
+      "href": "/settings/sound/alert/door/vs/0",
+      "rep": {
+        "alert.door": "3",
+        "supportedAlert.door": [
+          "1",
+          "2",
+          "3",
+          "4"
+        ],
+        "href": "/settings/sound/alert/door/vs/0",
+        "rt": [
+          "x.com.samsung.alert.door"
+        ],
+        "if": [
+          "oic.if.baseline",
+          "oic.if.a"
+        ]
+      }
+    },
+    {
+      "href": "/cabinet/light/enhanced/vs/0",
+      "rep": {
+        "light.control.status": "Off",
+        "level.brightness.daytime": "100",
+        "level.brightness.nighttime": "100",
+        "night.starttime": "N/A",
+        "night.duration.minute": "N/A",
+        "timezone.offset": "-03:00",
+        "href": "/cabinet/light/enhanced/vs/0",
+        "rt": [
+          "x.com.samsung.da.light.enhanced"
+        ],
+        "if": [
+          "oic.if.baseline",
+          "oic.if.a"
+        ]
+      }
+    },
+    {
+      "href": "/configuration/vs/0",
+      "rep": {
+        "x.com.samsung.da.region": "",
+        "x.com.samsung.da.countryCode": "",
+        "href": "/configuration/vs/0"
+      }
+    },
+    {
+      "href": "/temperature/definite/cooler/vs/0",
+      "rep": {
+        "x.com.samsung.da.definite.desired": "2",
+        "x.com.samsung.da.definite.supportedList": [
+          "1",
+          "2",
+          "3",
+          "4",
+          "7"
+        ],
+        "x.com.samsung.da.unit": "Celsius",
+        "href": "/temperature/definite/cooler/vs/0"
+      }
+    },
+    {
+      "href": "/door/cooler/0",
+      "rep": {
+        "openState": "Close",
+        "href": "/door/cooler/0",
+        "rt": [
+          "oic.r.door"
+        ],
+        "if": [
+          "oic.if.baseline",
+          "oic.if.s"
+        ]
+      }
+    },
+    {
+      "href": "/doors/vs/0",
+      "rep": {
+        "x.com.samsung.da.items": [
+          {
+            "x.com.samsung.da.openState": "Close",
+            "x.com.samsung.da.id": "0",
+            "x.com.samsung.da.description": "Door"
+          },
+          {
+            "x.com.samsung.da.openState": "Close",
+            "x.com.samsung.da.id": "1",
+            "x.com.samsung.da.description": "Door"
+          }
+        ],
+        "href": "/doors/vs/0"
+      }
+    },
+    {
+      "href": "/drlc/vs/0",
+      "rep": {
+        "x.com.samsung.da.drlcLevel": "0",
+        "x.com.samsung.da.override": "Not_Supported",
+        "x.com.samsung.da.durationminutes": "0",
+        "x.com.samsung.da.realSaving": "Off",
+        "href": "/drlc/vs/0"
+      }
+    },
+    {
+      "href": "/energy/consumption/vs/0",
+      "rep": {
+        "x.com.samsung.da.cumulativeConsumption": "9",
+        "x.com.samsung.da.instantaneousPower": "51",
+        "x.com.samsung.da.cumulativePower": "593883",
+        "x.com.samsung.da.cumulativeSavedPower": "0",
+        "x.com.samsung.da.cumulativeUnit": "Wh",
+        "x.com.samsung.da.instantaneousPowerUnit": "W",
+        "href": "/energy/consumption/vs/0"
+      }
+    },
+    {
+      "href": "/file/information/vs/0",
+      "rep": {
+        "x.com.samsung.timeoffset": "-03:00",
+        "x.com.samsung.supprtedtype": 1,
+        "href": "/file/information/vs/0"
+      }
+    },
+    {
+      "href": "/refrigeration/vs/0",
+      "rep": {
+        "x.com.samsung.da.rapidFridge": "Off",
+        "x.com.samsung.da.rapidFreezing": "Off",
+        "href": "/refrigeration/vs/0",
+        "rt": [
+          "x.com.samsung.da.fridge"
+        ],
+        "if": [
+          "oic.if.baseline",
+          "oic.if.a"
+        ]
+      }
+    },
+    {
+      "href": "/energy/ailevel/vs/0",
+      "rep": {
+        "aiLevel": "1",
+        "supportedAiLevel": [
+          "1"
+        ],
+        "href": "/energy/ailevel/vs/0"
+      }
+    },
+    {
+      "href": "/information/vs/0",
+      "rep": {
+        "x.com.samsung.da.modelNum": "TP1X_REF_21K|00174941|0006012A001811304100000020010000",
+        "x.com.samsung.da.description": "TP1X_REF_21K",
+        "x.com.samsung.da.serialNum": "**REDACTED**",
+        "x.com.samsung.da.otnDUID": "**REDACTED**",
+        "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": "RT1",
+        "x.com.samsung.da.diagProtocolType": "BLE_OCF",
+        "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": "WiFi Module",
+            "x.com.samsung.da.type": "Software",
+            "x.com.samsung.da.number": "260617",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          },
+          {
+            "x.com.samsung.da.id": "1",
+            "x.com.samsung.da.description": "Micom",
+            "x.com.samsung.da.type": "Firmware",
+            "x.com.samsung.da.number": "24010202, FFFFFFFF",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          }
+        ],
+        "href": "/information/vs/0"
+      }
+    },
+    {
+      "href": "/status/lock/vs/0",
+      "rep": {
+        "x.com.samsung.da.device.sound": "On",
+        "x.com.samsung.da.childlock": "Locked",
+        "href": "/status/lock/vs/0",
+        "rt": [
+          "x.com.samsung.da.lockstatus"
+        ],
+        "if": [
+          "oic.if.baseline",
+          "oic.if.a"
+        ]
+      }
+    },
+    {
+      "href": "/mode/vs/0",
+      "rep": {
+        "x.com.samsung.da.supportedModes": [
+          "HOMECARE_WIZARD_V2",
+          "ENERGY_REPORT_MODEL",
+          "18K_REF_OUTDOOR_CONTROL_V2"
+        ],
+        "href": "/mode/vs/0",
+        "rt": [
+          "x.com.samsung.da.mode"
+        ],
+        "if": [
+          "oic.if.baseline",
+          "oic.if.a"
+        ]
+      }
+    },
+    {
+      "href": "/realtimenotiforclient/vs/0",
+      "rep": {
+        "x.com.samsung.da.timeforshortnoti": "0",
+        "x.com.samsung.da.periodicnotisubscription": "true",
+        "href": "/realtimenotiforclient/vs/0"
+      }
+    },
+    {
+      "href": "/runningmode/vs/0",
+      "rep": {
+        "x.com.samsung.da.runningMode": 0,
+        "href": "/runningmode/vs/0"
+      }
+    },
+    {
+      "href": "/selfcheck/vs/0",
+      "rep": {
+        "x.com.samsung.da.supportedActions": [
+          "Start"
+        ],
+        "x.com.samsung.da.status": "Ready",
+        "x.com.samsung.da.result": "Success",
+        "x.com.samsung.da.error": [
+          "ErrorCode_None"
+        ],
+        "href": "/selfcheck/vs/0"
+      }
+    },
+    {
+      "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 Refrigerator",
+          "osVersion": "4.0"
+        },
+        "otnList": [
+          {
+            "type": "WIFI",
+            "modelId": "A-RFWW-TP1-24-T4-COM",
+            "versions": [
+              "20260617"
+            ],
+            "visVersion": "260617"
+          },
+          {
+            "type": "Micom",
+            "modelId": "035000174941FFFFFFFF",
+            "versions": [
+              "24010202",
+              "FFFFFFFF"
+            ],
+            "visVersion": "240102"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/timezone/vs/0",
+      "rep": {
+        "timezoneid": "America/Sao_Paulo",
+        "offset": "-03: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": "Pumba_IoT"
+      }
+    },
+    {
+      "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/water_purifier_ailite_25k_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": "/selfcheck/vs/0",
+      "rep": {
+        "x.com.samsung.da.supportedActions": [
+          "Start"
+        ],
+        "x.com.samsung.da.result": "Success",
+        "x.com.samsung.da.error": [
+          "ErrorCode_None"
+        ],
+        "x.com.samsung.da.status": "Ready"
+      }
+    },
+    {
+      "href": "/realtimenotiforclient/vs/0",
+      "rep": {
+        "x.com.samsung.da.timeforshortnoti": "0",
+        "x.com.samsung.da.periodicnotisubscription": "true"
+      }
+    },
+    {
+      "href": "/configuration/vs/0",
+      "rep": {}
+    },
+    {
+      "href": "/filter/waterfilter/vs/0",
+      "rep": {
+        "x.com.samsung.da.filterUsage": "69",
+        "x.com.samsung.da.filterUsageResolution": "1",
+        "x.com.samsung.da.filterResetType": [
+          "replaceable"
+        ],
+        "x.com.samsung.da.lastResetDate": "2025-11-19T05:39:17",
+        "x.com.samsung.da.filterStatus": "normal"
+      }
+    },
+    {
+      "href": "/alarms/vs/0",
+      "rep": {}
+    },
+    {
+      "href": "/information/vs/0",
+      "rep": {
+        "x.com.samsung.da.modelNum": "AILITE_DA-REF-WATERPURIFIER-01011|70674641|900100000219130081088700001E0000",
+        "x.com.samsung.da.description": "AILITE_WATERPURIFIER_25K",
+        "x.com.samsung.da.serialNum": "**REDACTED**",
+        "x.com.samsung.da.otnDUID": "**REDACTED**",
+        "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": "RX0",
+        "x.com.samsung.da.diagProtocolType": "BLE_OCF",
+        "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": "WiFi Module",
+            "x.com.samsung.da.type": "Software",
+            "x.com.samsung.da.number": "251121",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          },
+          {
+            "x.com.samsung.da.id": "1",
+            "x.com.samsung.da.description": "Micom",
+            "x.com.samsung.da.type": "Firmware",
+            "x.com.samsung.da.number": "25071603, 2510140E, 22092302, FFFFFFFF, 25061700, FFFFFFFF",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          },
+          {
+            "x.com.samsung.da.id": "2",
+            "x.com.samsung.da.description": "Bixby",
+            "x.com.samsung.da.type": "Bixby",
+            "x.com.samsung.da.number": "1.2.2-rc.3",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/runningmode/vs/0",
+      "rep": {
+        "x.com.samsung.da.runningMode": 0
+      }
+    },
+    {
+      "href": "/setting/waterpurifier/vs/0",
+      "rep": {
+        "x.com.samsung.da.supportedTypes": [
+          "ambientwater",
+          "coldwater",
+          "hotwater"
+        ],
+        "x.com.samsung.da.desiredType": "coldwater",
+        "x.com.samsung.da.tempDesiredHotWater": "85",
+        "x.com.samsung.da.desiredCapacity": "120",
+        "x.com.samsung.da.hotwaterLevel": "5",
+        "x.com.samsung.da.hotwaterRange": [
+          "40",
+          "90"
+        ],
+        "x.com.samsung.da.tempUnit": "C",
+        "x.com.samsung.da.pourStatus": "Off",
+        "x.com.samsung.da.capacityUnit": "C",
+        "x.com.samsung.da.capacityResolution": "10",
+        "x.com.samsung.da.desiredCapacityRange": [
+          "50",
+          "2000"
+        ],
+        "x.com.samsung.da.triggerTime": "1785341896789"
+      }
+    },
+    {
+      "href": "/favorite/capacity/vs/0",
+      "rep": {
+        "x.com.samsung.da.switchCapacity": "On",
+        "x.com.samsung.da.defaultCapacity": "120",
+        "x.com.samsung.da.capacityList": [
+          "80",
+          "120",
+          "260",
+          "500",
+          "9999"
+        ],
+        "x.com.samsung.da.triggerTime": "1785341867176"
+      }
+    },
+    {
+      "href": "/status/waterpurifier/vs/0",
+      "rep": {
+        "x.com.samsung.da.filterCleanMaxTime": "14",
+        "x.com.samsung.da.sterilizeMaxTime": "10",
+        "x.com.samsung.da.sterilizeRunTime": "0",
+        "x.com.samsung.da.status": "Ready",
+        "x.com.samsung.da.sterilizePlanTime": "2026-07-31T17:00:00",
+        "x.com.samsung.da.sterilizeLastTime": "2026-07-28T17:08:36",
+        "x.com.samsung.da.sterilizeStartTime": "2026-07-31T17:00:00",
+        "x.com.samsung.da.sterilizePeriod": "3"
+      }
+    },
+    {
+      "href": "/status/lock/vs/0",
+      "rep": {
+        "x.com.samsung.da.coldwaterLock": "Unlocked",
+        "x.com.samsung.da.device.microphone": "On"
+      }
+    },
+    {
+      "href": "/favorite/hotwater/vs/0",
+      "rep": {
+        "x.com.samsung.da.favorite.revision": "0",
+        "x.com.samsung.da.favorite.defaultTemperature": "85",
+        "x.com.samsung.da.favorite.showList": [
+          "40",
+          "50",
+          "75",
+          "85",
+          "90"
+        ],
+        "x.com.samsung.da.favorite.supportedList": [
+          "40",
+          "75",
+          "85",
+          "90"
+        ],
+        "x.com.samsung.da.switchHotwater": "Unlocked",
+        "x.com.samsung.da.triggerTime": "1785341867177"
+      }
+    },
+    {
+      "href": "/settings/sound/volume/vs/0",
+      "rep": {
+        "level": "5",
+        "minLevel": "0",
+        "maxLevel": "15",
+        "resolution": "5"
+      }
+    },
+    {
+      "href": "/settings/sound/mode/vs/0",
+      "rep": {
+        "mode": "voice",
+        "supportedModes": [
+          "voice",
+          "fixedTone",
+          "mute"
+        ]
+      }
+    },
+    {
+      "href": "/settings/sound/output/vs/0",
+      "rep": {
+        "deviceType": "speaker",
+        "alarmInMute": "true"
+      }
+    },
+    {
+      "href": "/setting/vs/0",
+      "rep": {
+        "x.com.samsung.da.setLanguage": "ko_KR",
+        "x.com.samsung.da.supportedSetLanguage": [
+          "ko_KR"
+        ]
+      }
+    },
+    {
+      "href": "/automation/waterpurifier/vs/0",
+      "rep": {
+        "automation.supported.modes": [
+          "0"
+        ],
+        "automation.supported.options": [
+          "capacity"
+        ]
+      }
+    },
+    {
+      "href": "/favorite/coffee/vs/0",
+      "rep": {
+        "favorite.activate": "On",
+        "brew.status": "Suspend",
+        "favorite.enable.list": [
+          "0",
+          "1",
+          "2",
+          "3"
+        ]
+      }
+    },
+    {
+      "href": "/brand/recipe/info/vs/0",
+      "rep": {
+        "revision": "0",
+        "brand.num.max": "1"
+      }
+    },
+    {
+      "href": "/recipe/coffee/vs/0",
+      "rep": {}
+    },
+    {
+      "href": "/coffee/custom/recipe/vs/0",
+      "rep": {
+        "publisher": "0",
+        "cups": 1,
+        "favor": "223",
+        "numberOfStages": "2",
+        "stages": [
+          {
+            "temperature": 0,
+            "waterAmount": 30,
+            "timeSecond": 20,
+            "turnOver": 0
+          },
+          {
+            "temperature": 0,
+            "waterAmount": 30,
+            "timeSecond": 20,
+            "turnOver": 0
+          }
+        ],
+        "publisher.support": [
+          "1",
+          "2",
+          "3",
+          "4",
+          "5"
+        ]
+      }
+    },
+    {
+      "href": "/recipe/coffee/deletion/vs/0",
+      "rep": {}
+    },
+    {
+      "href": "/cup/state/vs/0",
+      "rep": {
+        "water.cup.state": "UnReady",
+        "water.cup.basis.revision": "0"
+      }
+    },
+    {
+      "href": "/statistic/pour/vs/0",
+      "rep": {
+        "last.type": "coldwater",
+        "last.capacity": "40"
+      }
+    },
+    {
+      "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 Water purifier",
+          "osVersion": "5.0"
+        },
+        "otnList": [
+          {
+            "type": "WIFI",
+            "modelId": "A-WPWW-AIL-25-COMMON",
+            "versions": [
+              "20251121"
+            ],
+            "visVersion": "251121"
+          },
+          {
+            "type": "Micom",
+            "modelId": "838070674741FFFFFFFF",
+            "versions": [
+              "2510140E",
+              "FFFFFFFF"
+            ],
+            "visVersion": "251014"
+          },
+          {
+            "type": "Micom",
+            "modelId": "838070674641FFFFFFFF",
+            "versions": [
+              "25071603",
+              "FFFFFFFF"
+            ],
+            "visVersion": "250716"
+          },
+          {
+            "type": "Micom",
+            "modelId": "03807067464170674741",
+            "versions": [
+              "25071603",
+              "2510140E"
+            ],
+            "visVersion": "251014"
+          },
+          {
+            "type": "Micom",
+            "modelId": "038000156141FFFFFFFF",
+            "versions": [
+              "22092302",
+              "FFFFFFFF"
+            ],
+            "visVersion": "220923"
+          },
+          {
+            "type": "Micom",
+            "modelId": "038070673941FFFFFFFF",
+            "versions": [
+              "25061700",
+              "FFFFFFFF"
+            ],
+            "visVersion": "250617"
+          }
+        ]
+      }
+    },
+    {
+      "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",
+          "5G"
+        ],
+        "calmConnectionCare": {
+          "version": "1.0",
+          "role": [
+            "things"
+          ]
+        }
+      }
+    },
+    {
+      "href": "/bixbyuservalidate/vs/0",
+      "rep": {
+        "x.com.samsung.da.items": [
+          {
+            "x.com.samsung.da.loginId": "**REDACTED**",
+            "x.com.samsung.da.isExpired": "false"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/bixby/status/vs/0",
+      "rep": {
+        "x.com.samsung.da.enable": "true"
+      }
+    },
+    {
+      "href": "/bixbyterms/vs/0",
+      "rep": {
+        "x.com.samsung.da.items": [
+          {
+            "x.com.samsung.da.accountInfo": "**REDACTED**",
+            "x.com.samsung.da.termsName": "AudioReview",
+            "x.com.samsung.da.termsStatus": "Agreed",
+            "x.com.samsung.da.termsType": "Optional",
+            "x.com.samsung.da.termsURL": "https://d264isyiyrfhr3.cloudfront.net/storage/tos/kor/1.0.1/1773704680415/kor/kor_kor_AudioRecordingReview.html"
+          },
+          {
+            "x.com.samsung.da.accountInfo": "**REDACTED**",
+            "x.com.samsung.da.termsName": "Datasharing",
+            "x.com.samsung.da.termsStatus": "Agreed",
+            "x.com.samsung.da.termsType": "Mandatory",
+            "x.com.samsung.da.termsURL": "https://d264isyiyrfhr3.cloudfront.net/storage/tos/kor/1.0.1/1690269284216/kor/kor_kor_DataSharingAgreement_v3.html"
+          },
+          {
+            "x.com.samsung.da.accountInfo": "**REDACTED**",
+            "x.com.samsung.da.termsName": "Personalization",
+            "x.com.samsung.da.termsStatus": "Agreed",
+            "x.com.samsung.da.termsType": "Optional",
+            "x.com.samsung.da.termsURL": "https://d264isyiyrfhr3.cloudfront.net/storage/tos/kor/1.0.2/1773644167282/kor/kor_kor_PersonalizationAgreement.html"
+          },
+          {
+            "x.com.samsung.da.accountInfo": "**REDACTED**",
+            "x.com.samsung.da.termsName": "PrivacyNotice",
+            "x.com.samsung.da.termsStatus": "Agreed",
+            "x.com.samsung.da.termsType": "Mandatory",
+            "x.com.samsung.da.termsURL": "https://d264isyiyrfhr3.cloudfront.net/storage/tos/kor/1.0.2/1726806774110/kor/kor_kor_pn.html"
+          },
+          {
+            "x.com.samsung.da.accountInfo": "**REDACTED**",
+            "x.com.samsung.da.termsName": "PrivacyPolicy",
+            "x.com.samsung.da.termsStatus": "Agreed",
+            "x.com.samsung.da.termsType": "Mandatory",
+            "x.com.samsung.da.termsURL": "https://d264isyiyrfhr3.cloudfront.net/storage/tos/kor/1.7.8/1783668586319/kor/kor_kor_pp.html"
+          },
+          {
+            "x.com.samsung.da.accountInfo": "**REDACTED**",
+            "x.com.samsung.da.termsName": "SamsungLocation",
+            "x.com.samsung.da.termsStatus": "Agreed",
+            "x.com.samsung.da.termsType": "Mandatory",
+            "x.com.samsung.da.termsURL": "https://static.bada.com/contents/legal/kor/kor/locationinfortnc.html"
+          },
+          {
+            "x.com.samsung.da.accountInfo": "**REDACTED**",
+            "x.com.samsung.da.termsName": "FMMPrivacyPolicy",
+            "x.com.samsung.da.termsStatus": "Agreed",
+            "x.com.samsung.da.termsType": "Mandatory",
+            "x.com.samsung.da.termsURL": "https://account.samsung.com/membership/policy/privacy/service/o12ht525e6"
+          },
+          {
+            "x.com.samsung.da.accountInfo": "**REDACTED**",
+            "x.com.samsung.da.termsName": "BixbyPrivacy",
+            "x.com.samsung.da.termsStatus": "NotOnboarding",
+            "x.com.samsung.da.termsType": "Optional",
+            "x.com.samsung.da.termsURL": ""
+          }
+        ],
+        "x.com.samsung.da.lastCheckedTime": "1785341867"
+      }
+    },
+    {
+      "href": "/bixby/vs/0",
+      "rep": {
+        "x.com.samsung.da.voiceWakeup": "Disable",
+        "x.com.samsung.da.multidevWakeup": "true"
+      }
+    },
+    {
+      "href": "/sec/networkaudio/audio/vs/0",
+      "rep": {
+        "volume": "4",
+        "mute": "false",
+        "maxVolume": "15",
+        "timestamp": "0"
+      }
+    },
+    {
+      "href": "/voice/feature/vs/0",
+      "rep": {
+        "voice.feature": {
+          "ContinuousConversation": {
+            "support": "true",
+            "value": "false",
+            "supportedValues": [
+              "true",
+              "false"
+            ]
+          },
+          "DiscoverBixby": {
+            "support": "false"
+          },
+          "LLMBixby": {
+            "support": "true"
+          },
+          "SimpleCommand": {
+            "support": "false",
+            "value": "false",
+            "supportedValues": [
+              "true",
+              "false"
+            ],
+            "description": [
+              "\ub0c9\uc7a5\uace0 \ubb38 \uc5f4\uc5b4\uc918"
+            ]
+          }
+        }
+      }
+    },
+    {
+      "href": "/voice/provisioning/vs/0",
+      "rep": {
+        "voice.provisioning.headers": {
+          "login_id": "**REDACTED**",
+          "voice.provisioning.headers.bixbyLanguage": "ko_KR",
+          "voice.provisioning.headers.bixbyType": "BixbyAgent",
+          "voice.provisioning.headers.bixbyVersion": "1.2.2-rc.3",
+          "voice.provisioning.headers.companioncountry": "KR",
+          "voice.provisioning.headers.csc": "920",
+          "voice.provisioning.headers.csciso": "KR",
+          "voice.provisioning.headers.deviceLanguage": "ko-KR",
+          "voice.provisioning.headers.deviceModelNameAsh": "RWP70F15ANW",
+          "voice.provisioning.headers.deviceModelNamePro": "BIXBY-LITE",
+          "voice.provisioning.headers.deviceSubType": "screenless_waterpurifier_lite",
+          "voice.provisioning.headers.deviceTypeAsh": "appliance",
+          "voice.provisioning.headers.deviceTypePro": "appliance",
+          "voice.provisioning.headers.mcc": "450",
+          "voice.provisioning.headers.osType": "Tizen Lite",
+          "voice.provisioning.headers.osVersion": "Tizen Lite",
+          "voice.provisioning.headers.requestTrackId": "1785341867293",
+          "voice.provisioning.headers.sspServerUrl": "us-auth2.samsungosp.com",
+          "voice.provisioning.headers.storecountry": "KR",
+          "voice.provisioning.headers.userType": "COMMERCIAL"
+        },
+        "voice.provisioning.termsstatechange": {
+          "voice.provisioning.termsstatechange.refresh": "",
+          "voice.provisioning.termsstatechange.state": "Agreed",
+          "voice.provisioning.termsstatechange.terms": ""
+        },
+        "voice.provisioning.deviceinfo": {
+          "voice.provisioning.deviceinfo.accesstoken": "**REDACTED**",
+          "voice.provisioning.deviceinfo.bixbyserver": "bxb3PrdUS",
+          "voice.provisioning.deviceinfo.bixbyserviceid": "US1DAAPPFD31232A4E4B40D6B83630AF58385719",
+          "voice.provisioning.deviceinfo.deviceid": "**REDACTED**",
+          "voice.provisioning.deviceinfo.gdprcountry": "false",
+          "voice.provisioning.deviceinfo.isSupportedCountry": "true",
+          "voice.provisioning.deviceinfo.userid": "**REDACTED**"
+        }
+      }
+    }
+  ]
+}

tests/localthings/test_config_flow.py

@@ -105,6 +105,47 @@ def test_find_live_ports_detects_silent_port(socket_enabled) -> None:
     assert result == [live_port]
 
 
+def test_find_live_ports_rescues_preferred_ports_the_sweep_missed(
+    socket_enabled, monkeypatch,
+) -> None:
+    """Issue #192: a segregated VLAN made the ICMP-based sweep call three
+    closed ports live while missing the one port (a historically confirmed
+    DTLS port) that nmap showed as genuinely open|filtered. The sweep's
+    verdict on a preferred port shouldn't be trusted blindly -- it must
+    always come back as a candidate even if the sweep marked it dead, so the
+    config flow gets a real handshake attempt against it.
+
+    Uses an OS-assigned port monkeypatched into PREFERRED_PROBE_PORTS rather
+    than the real 49154/49155, so this doesn't depend on those specific
+    system ports being free on whatever machine runs the suite.
+    """
+    import socket
+
+    from custom_components.localthings import config_flow
+    from custom_components.localthings.config_flow import _find_live_ports
+
+    # Bind an OS-assigned port and immediately close it, same technique
+    # test_find_live_ports_detects_silent_port uses for its "closed" ports --
+    # once closed, loopback refuses datagrams to it, standing in for the
+    # sweep wrongly ruling out a port we have strong prior evidence for.
+    reserved = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    reserved.bind(('127.0.0.1', 0))
+    preferred_port = reserved.getsockname()[1]
+    reserved.close()
+    monkeypatch.setattr(config_flow, 'PREFERRED_PROBE_PORTS', [preferred_port])
+
+    live_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    live_sock.bind(('127.0.0.1', 0))
+    live_port = live_sock.getsockname()[1]
+
+    try:
+        result = _find_live_ports('127.0.0.1', [preferred_port, live_port], 0.8)
+    finally:
+        live_sock.close()
+
+    assert set(result) == {preferred_port, live_port}
+
+
 async def test_probe_uses_discovered_low_port(hass: HomeAssistant, monkeypatch) -> None:
     """A device that only answers on 49153 — outside the historical
     49154/49155 pair — is found by the liveness sweep and its port is stored

tests/localthings/test_diagnostics.py

@@ -122,6 +122,42 @@ async def test_diagnostics_include_oic_res_links(
     assert links[1]['rt'] == ['x.com.samsung.devcol', 'oic.wk.col']
 
 
+async def test_diagnostics_include_speculative_device_probes(
+    hass: HomeAssistant, mock_entry, mock_coordinator_session
+) -> None:
+    """/device/1 and /device/2 (issue #177's Composite Device follow-up) ride
+    along in identity.raw the same {href: rep} shape as the main /device/0
+    dump under "resources" -- ordinary redaction, no special-casing needed."""
+    from custom_components.localthings.registry.identity import DeviceIdentity
+
+    await hass.config_entries.async_setup(mock_entry.entry_id)
+    await hass.async_block_till_done()
+
+    coordinator = hass.data[DOMAIN][mock_entry.entry_id]
+    coordinator._identity = DeviceIdentity(
+        manufacturer='Samsung Electronics',
+        model='RF9000B',
+        name='Family Hub',
+        serial=None,
+        device_types=('oic.wk.d', 'oic.d.refrigerator'),
+        raw={
+            '/oic/p': {}, '/oic/d': {}, '/oic/res': [],
+            '/device/1': {
+                '/information/vs/0': {'x.com.samsung.da.serialNum': 'SECRET123'},
+                '/power/vs/0': {'x.com.samsung.da.power': 'On'},
+            },
+            '/device/2': {},
+        },
+    )
+
+    diag = await async_get_config_entry_diagnostics(hass, mock_entry)
+
+    device1 = diag['identity']['resources']['/device/1']
+    assert device1['/information/vs/0']['x.com.samsung.da.serialNum'] == REDACTED
+    assert device1['/power/vs/0']['x.com.samsung.da.power'] == 'On'
+    assert diag['identity']['resources']['/device/2'] == {}
+
+
 async def test_diagnostics_identity_none_when_unavailable(
     hass: HomeAssistant, mock_entry, mock_coordinator_session
 ) -> None:

tests/test_air_purifier_airflow_fan.py

@@ -20,6 +20,12 @@ class _FakeCoordinator:
     def resource(self, href):
         return self.last_resources.get(href, {})
 
+    def canonical_resources(self, subdevice):
+        # Every bound entity in this test uses the default MAIN
+        # subdevice, so the canonical view is just the raw snapshot
+        # (issue #177 -- see LocalThingsEntity._resources).
+        return self.last_resources
+
     async def async_send_command(self, bound, payload):
         self.commands.append((bound, payload))
 

tests/test_air_purifier_avt_ww.py

@@ -0,0 +1,62 @@
+"""Tests for the AVT-WW-TP1-23-AXX500 air-purifier profile (issue #190).
+
+Next-gen BESPOKE Cube Air board -- same resource surface as the
+A-VTWW-TP2-21-COMMON family (issue #151), but the '-WW-' delimiter now falls
+one letter to the left ('A-VTWW-' -> 'AVT-WW-'), splitting into an 'AVT'/'WW'
+token pair the existing 'VTWW' whole-token entry can't see. The reporter's
+diagnostics showed device_type 'unknown' with empty oneUiVersion and every
+resource unbound -- once routed to the existing air_purifier registry, every
+resource here binds with zero gaps.
+"""
+from custom_components.localthings.registry.adapter import flatten
+from custom_components.localthings.registry.by_type import for_device_by_model
+from custom_components.localthings.registry.discovery import discover
+
+from tests.conftest import _load_device
+
+
+def _resources():
+    return _load_device('air_purifier_avt_ww')
+
+
+def _reg(resources):
+    info = resources['/information/vs/0']
+    return for_device_by_model(
+        info['x.com.samsung.da.modelNum'], info['x.com.samsung.da.description'])
+
+
+def test_resolves_to_air_purifier_registry():
+    assert _reg(_resources()).name == 'air_purifier'
+
+
+def test_no_unbound_hrefs():
+    resources = _resources()
+    reg = _reg(resources)
+    unbound = []
+    discover(resources, reg.capabilities, reg.pattern_capabilities, log=unbound.append)
+    assert unbound == []
+
+
+def test_wind_strength_fan_preset_names():
+    """This dump's /wind/strength/vs/0 reports the same numeric-code +
+    modesName shape as the original VTWW fixture (SMART/MAX/WINDFREE/Sleep),
+    confirming the shared WIND_STRENGTH_FAN capability applies unchanged."""
+    resources = _resources()
+    reg = _reg(resources)
+    bound = discover(resources, reg.capabilities, reg.pattern_capabilities)
+    state = flatten(bound, resources)
+    assert state['wind_strength_fan'] == '87'
+    wind = resources['/wind/strength/vs/0']
+    assert wind['x.com.samsung.da.modesName'] == ['SMART', 'MAX', 'WINDFREE', 'Sleep']
+
+
+def test_air_quality_and_filter_sensors_present():
+    resources = _resources()
+    reg = _reg(resources)
+    bound = discover(resources, reg.capabilities, reg.pattern_capabilities)
+    state = flatten(bound, resources)
+    assert state['dust'] == 10
+    assert state['fine_dust'] == 9
+    assert state['odor'] == 1
+    assert state['hepa_filter_usage'] == 0
+    assert state['hepa_filter_status'] == 'normal'

tests/test_air_purifier_vtww_fan.py

@@ -29,6 +29,12 @@ class _FakeCoordinator:
     def resource(self, href):
         return self.last_resources.get(href, {})
 
+    def canonical_resources(self, subdevice):
+        # Every bound entity in this test uses the default MAIN
+        # subdevice, so the canonical view is just the raw snapshot
+        # (issue #177 -- see LocalThingsEntity._resources).
+        return self.last_resources
+
     async def async_send_command(self, bound, payload):
         self.commands.append((bound, payload))
 

tests/test_airconditioner_artik051_krac.py

@@ -47,6 +47,12 @@ class _FakeCoordinator:
     def resource(self, href):
         return self.last_resources.get(href, {})
 
+    def canonical_resources(self, subdevice):
+        # Every bound entity in this test uses the default MAIN
+        # subdevice, so the canonical view is just the raw snapshot
+        # (issue #177 -- see LocalThingsEntity._resources).
+        return self.last_resources
+
     async def async_send_command(self, bound, payload):
         self.commands.append((bound, payload))
 
@@ -102,7 +108,7 @@ def test_token_entities_present_with_calibrated_values():
     assert state['filter_time'] == 171.5
     # token - 55 == 19 C, against a 19.4 C forecast at the time of the dump.
     assert state['outdoor_temperature'] == 19.0
-    assert state['buzzer_volume'] == 100.0
+    assert state['beep'] is True
     assert state['good_sleep'] == 0.0
     assert state['spi'] is False
     assert state['auto_clean_legacy'] is False
@@ -115,7 +121,7 @@ def test_token_entities_stay_off_newer_boards():
     token entities would duplicate them (auto clean) or apply a scale
     calibrated on another board generation (outdoor temperature)."""
     state = _state('airconditioner_tp1x_rac')
-    for key in ('spi', 'auto_clean_legacy', 'air_monitoring', 'buzzer_volume',
+    for key in ('spi', 'auto_clean_legacy', 'air_monitoring',
                 'good_sleep', 'outdoor_temperature', 'filter_time'):
         assert key not in state, key
 

tests/test_airconditioner_cac.py

@@ -0,0 +1,70 @@
+"""Tests for the TP1X_DA-AC-CAC-01001_0000 cassette AC (issue #191).
+
+0.16.0's device-type simplification dropped oneUiVersion detection on the
+assumption every device it typed was already reachable via a modelNum board
+token -- this board was the one exception (its oneUiVersion self-reports
+"7.0 Air conditioner", but 'CAC' had never been added to the board-token
+table), so it silently fell back to common caps and lost its climate entity.
+
+This dump is NOT fully covered yet -- ten hrefs remain unbound (edge
+lighting, PM1 filter, a second stateful light resource, absence-clean, four
+`/settings/sound/*` resources, smart-sensing-cooling, UV LED), all genuinely
+new to this board generation. That's a real device-support gap, left
+documented here rather than guessed at, per the 'don't guess' rule -- fixing
+the routing regression was the scope of #191.
+"""
+from custom_components.localthings.registry.adapter import flatten
+from custom_components.localthings.registry.by_type import for_device_by_model
+from custom_components.localthings.registry.discovery import discover
+
+from tests.conftest import _load_device
+
+_STILL_UNBOUND = frozenset({
+    '/edgelighting/vs/0',
+    '/filter/airdustPM1filter/vs/0',
+    '/light/stateful/vs/0',
+    '/mds/absenceclean/vs/0',
+    '/settings/sound/mode/vs/0',
+    '/settings/sound/optimization/vs/0',
+    '/settings/sound/output/vs/0',
+    '/settings/sound/volume/vs/0',
+    '/smartsensingcooling/vs/0',
+    '/uvled/vs/0',
+})
+
+
+def _resources():
+    return _load_device('airconditioner_cac')
+
+
+def _reg(resources):
+    info = resources['/information/vs/0']
+    return for_device_by_model(
+        info['x.com.samsung.da.modelNum'], info['x.com.samsung.da.description'])
+
+
+def test_resolves_to_airconditioner_registry():
+    assert _reg(_resources()).name == 'airconditioner'
+
+
+def test_documented_coverage_gap_is_exactly_this_set():
+    """Locks in the current, known-incomplete coverage so a future fix to
+    any of these hrefs shows up as a golden-regression diff (extra keys) to
+    update here, rather than silently shrinking this list unnoticed."""
+    resources = _resources()
+    reg = _reg(resources)
+    unbound = []
+    discover(resources, reg.capabilities, reg.pattern_capabilities, log=unbound.append)
+    assert set(unbound) == _STILL_UNBOUND
+
+
+def test_non_legacy_board_uses_the_generic_energy_scale():
+    """This board reports /wind/strength/vs/0 (not /airflow/vs/0), so
+    is_legacy_board() is False and it must use the plain wh_to_kwh scale,
+    not the /100000 correction added for the unrelated ARTIK051_KRAC-class
+    board in issue #193."""
+    resources = _resources()
+    reg = _reg(resources)
+    bound = discover(resources, reg.capabilities, reg.pattern_capabilities)
+    state = flatten(bound, resources)
+    assert state['energy_kwh'] == round(84044 / 1000.0, 2)

tests/test_airconditioner_capabilities.py

@@ -814,13 +814,61 @@ def test_sensor_item_value_picks_first_value():
 
 def test_beep_and_tropical_night_stay_off_legacy_krac_board():
     """ARTIK051_KRAC_18K (issue #136) reports both a Volume_ and a Sleep_
-    option token, but they're already modeled as buzzer_volume/good_sleep
-    (see airconditioner.CLIMATE) -- beep/tropical_night_mode must not also
-    bind there, or the same options[] slot would surface as two entities."""
+    option token. Volume_ is modeled as the shared 'beep' switch (issue #136's
+    buzzer_volume Number never correctly modeled this board -- see
+    test_legacy_krac_board_beep_is_a_switch_not_a_volume_number below);
+    Sleep_ is still good_sleep, not tropical_night_mode, on this board (see
+    airconditioner.CLIMATE)."""
     reg, resources = _resolve('airconditioner_artik051_krac_18k')
     state = flatten(
         discover(resources, reg.capabilities, reg.pattern_capabilities), resources)
-    assert 'beep' not in state
+    assert 'buzzer_volume' not in state
     assert 'tropical_night_mode' not in state
-    assert state['buzzer_volume'] == 100.0
+    assert state['beep'] is True
     assert state['good_sleep'] == 0.0
+
+
+def test_legacy_krac_board_beep_is_a_switch_not_a_volume_number():
+    """Issue #136: three real units across two reporters only ever reported
+    Volume_100 or Volume_Mute -- never an intermediate value -- and the old
+    buzzer_volume Number's write path (a plain integer string) could never
+    produce the literal 'Mute' token needed to turn it off. 'beep' now
+    applies uniformly across board generations instead of being gated off
+    the legacy board."""
+    reg, resources = _resolve('airconditioner_artik051_krac_18k')
+    state = flatten(
+        discover(resources, reg.capabilities, reg.pattern_capabilities), resources)
+    assert state['beep'] is True
+
+    resources['/mode/vs/0']['x.com.samsung.da.options'] = [
+        o.replace('Volume_100', 'Volume_Mute')
+        for o in resources['/mode/vs/0']['x.com.samsung.da.options']
+    ]
+    state = flatten(
+        discover(resources, reg.capabilities, reg.pattern_capabilities), resources)
+    assert state['beep'] is False
+
+    path, body = airconditioner._beep_write('Off', resources['/mode/vs/0'])
+    assert path == ['mode', 'vs', '0']
+    assert body == {'x.com.samsung.da.options': ['Volume_Mute']}
+
+
+def test_legacy_krac_board_energy_kwh_uses_centiwatt_hour_scale():
+    """Issue #193: this legacy ARTIK051 board reports cumulativePower in
+    centiwatt-hours (raw '117430000'), not the plain Wh common.wh_to_kwh
+    assumes -- confirmed against the reporter's own SmartThings-app reading
+    of 1,174.30 kWh. ENERGY_METER_LEGACY's /100000 scale must produce that
+    exact value, not the /1000-only 117430.0 the generic capability would."""
+    reg, resources = _resolve('airconditioner_artik051_krac_energy')
+    state = flatten(
+        discover(resources, reg.capabilities, reg.pattern_capabilities), resources)
+    assert state['energy_kwh'] == 1174.3
+
+
+def test_non_legacy_board_energy_kwh_still_uses_plain_wh_scale():
+    """The ENERGY_METER_GENERIC/LEGACY split must not change behavior for
+    every other AC board generation -- same value as plain wh_to_kwh."""
+    reg, resources = _ac()
+    state = flatten(
+        discover(resources, reg.capabilities, reg.pattern_capabilities), resources)
+    assert state['energy_kwh'] == round(1686632 / 1000.0, 2)

tests/test_airconditioner_tp1x_rac_01001_fan.py

@@ -34,6 +34,12 @@ class _FakeCoordinator:
     def resource(self, href):
         return self.last_resources.get(href, {})
 
+    def canonical_resources(self, subdevice):
+        # Every bound entity in this test uses the default MAIN
+        # subdevice, so the canonical view is just the raw snapshot
+        # (issue #177 -- see LocalThingsEntity._resources).
+        return self.last_resources
+
     async def async_send_command(self, bound, payload):
         self.commands.append((bound, payload))
 

tests/test_by_type.py

@@ -238,6 +238,19 @@ class TestForDeviceByModel:
         assert reg is not None
         assert reg.name == 'airconditioner'
 
+    def test_airconditioner_via_cac_token(self):
+        """Issue #191: a cassette AC (TP1X_DA-AC-CAC-01001_0000) regressed to
+        'unknown'/common-caps in 0.16.0 when oneUiVersion detection was
+        dropped -- 'CAC' had never been added to the modelNum board-token
+        table, only reachable before via oneUiVersion's '7.0 Air conditioner'."""
+        from custom_components.localthings.registry.by_type import for_device_by_model
+        reg = for_device_by_model(
+            'TP1X_DA-AC-CAC-01001_0000|10255541|60030748171811DF42005F2A00F2ED00',
+            'TP1X_DA-AC-CAC-01001_0000',
+        )
+        assert reg is not None
+        assert reg.name == 'airconditioner'
+
     def test_dehumidifier_via_dhm_token(self):
         """Issue #88: a dehumidifier (AY18CG7500GED) shares the DA_AC_ board
         family with the room-AC models but reports no oneUiVersion and
@@ -264,6 +277,33 @@ class TestForDeviceByModel:
         assert reg is not None
         assert reg.name == 'water_purifier'
 
+    def test_water_purifier_wins_over_ref_when_both_tokens_present(self):
+        """Issue #196: an AILITE water purifier (RWP70F15ANW) spells its
+        modelNum '...-REF-WATERPURIFIER-...', which would otherwise match the
+        bare 'REF' board token (refrigerator) before ever reaching
+        'WATERPURIFIER' -- misrouting it to the refrigerator registry, whose
+        resource surface shares almost nothing with a water purifier."""
+        from custom_components.localthings.registry.by_type import for_device_by_model
+        reg = for_device_by_model(
+            'AILITE_DA-REF-WATERPURIFIER-01011|70674641|'
+            '900100000219130081088700001E0000',
+            'AILITE_WATERPURIFIER_25K',
+        )
+        assert reg is not None
+        assert reg.name == 'water_purifier'
+
+    def test_bare_ref_token_still_resolves_refrigerator(self):
+        """Regression guard for the #196 carve-out above: a genuine
+        refrigerator modelNum with no 'WATERPURIFIER' token must still
+        resolve to 'refrigerator'."""
+        from custom_components.localthings.registry.by_type import for_device_by_model
+        reg = for_device_by_model(
+            'TP1X_REF_21K|00175941|00050126001811344100000020090000',
+            'TP1X_REF_21K',
+        )
+        assert reg is not None
+        assert reg.name == 'refrigerator'
+
     def test_airconditioner_via_wac_token(self):
         """Issue #87: a Bespoke Window AC (AW06C7155EWAZ) reports no
         oneUiVersion and a modelNum carrying the '_WAC_' (Window Air
@@ -474,6 +514,14 @@ class TestBoardTokenAmbiguity:
     safe while no real model string contains two tokens naming different
     device types. Guard that against every dump we have."""
 
+    # Issue #196: AILITE water-purifier boards spell their modelNum
+    # '...-REF-WATERPURIFIER-...' -- 'REF' names the shared cooling-subsystem
+    # board, not a refrigerator. `_board_family_key` carries an explicit
+    # carve-out resolving this one pair to 'water_purifier'; this is the one
+    # documented exception to the "no two board tokens ever co-occur"
+    # invariant the rest of this test enforces.
+    _ALLOWED_CONFLICTS = {frozenset({'refrigerator', 'water_purifier'})}
+
     def test_no_fixture_model_string_yields_two_conflicting_keys(self, all_device_fixtures):
         from custom_components.localthings.registry.by_type import (
             _BOARD_TOKEN_TO_KEY, _board_tokens,
@@ -489,7 +537,7 @@ class TestBoardTokenAmbiguity:
                     for t in _board_tokens(field, cut)
                     if t in _BOARD_TOKEN_TO_KEY
                 }
-                assert len(keys) <= 1, (
+                assert len(keys) <= 1 or frozenset(keys) in self._ALLOWED_CONFLICTS, (
                     f"{name}: {field!r} matches conflicting board tokens {keys}"
                 )
 

tests/test_climate_ac_modes.py

@@ -106,6 +106,11 @@ def test_fac_bora_wind_strength_codes_fit_the_standard_scale():
         def resource(self, href):
             return self.last_resources.get(href, {})
 
+        def canonical_resources(self, subdevice):
+            # This test's entity uses the default MAIN subdevice, so the
+            # canonical view is just the raw snapshot (issue #177).
+            return self.last_resources
+
     resources = _load_device('airconditioner_fac_bora')
     info = resources['/information/vs/0']
     reg = by_type.for_device_by_model(

tests/test_climate_subdevice.py

@@ -0,0 +1,105 @@
+"""Tests that a subdevice's LocalThingsClimate entity (issue #177) reads its
+*own* power/mode/temperature -- not the master's, and not some mix of the
+two -- and that the legacy-board test (is_legacy_board/_legacy_airflow) is
+evaluated per subdevice rather than once globally.
+
+Uses the issue #177 reporter's ARTIK051_DONGLE_FAC_18K fixture deliberately:
+it's a legacy `/airflow/vs/<n>` board (no `/wind/*` at all) on *both* the
+master and its materialized sibling, which is exactly the shape climate.py's
+own comments warn is easy to get wrong if the canonical view leaks between
+subdevices.
+"""
+from __future__ import annotations
+
+import pytest
+from homeassistant.components.climate import HVACMode
+from homeassistant.core import HomeAssistant
+
+from custom_components.localthings.climate import LocalThingsClimate
+from custom_components.localthings.registry.entities import ClimateDesc
+
+from tests.test_subdevice_discovery import _coordinator, _discover
+
+
+def _climate_entities(coordinator):
+    """{subdevice_key_or_None: LocalThingsClimate}, None standing for MAIN."""
+    from custom_components.localthings.registry.subdevices import MAIN
+    out = {}
+    for b in coordinator.bound:
+        if isinstance(b.desc, ClimateDesc):
+            key = None if b.subdevice == MAIN else b.subdevice.key
+            out[key] = LocalThingsClimate(coordinator, b)
+    return out
+
+
+@pytest.fixture
+async def climates(hass: HomeAssistant):
+    coordinator = _coordinator(hass)
+    await _discover(coordinator, 'airconditioner_artik051_dongle_fac_18k')
+    return _climate_entities(coordinator)
+
+
+async def test_subdevice_climate_reads_its_own_mode_and_power(climates):
+    """Master reports 'Auto'; the bedroom subdevice (/device/1) reports 'Cool' --
+    confirmed distinct in the real captured fixture. If the subdevice
+    entity's _rep() weren't translating through its own subdevice, it would
+    read the master's /mode/vs/0 instead and report the master's mode."""
+    main, sub1 = climates[None], climates['1']
+    assert main.hvac_mode == HVACMode.AUTO
+    assert sub1.hvac_mode == HVACMode.COOL
+
+
+async def test_subdevice_climate_reads_its_own_temperature(climates):
+    """Master: current 25.0 / desired 26.0. Subdevice 1: current 27.0 / desired
+    28.0 -- distinct values in the real fixture, so a href mix-up here
+    would show up as a wrong number, not just a wrong mode string."""
+    main, sub1 = climates[None], climates['1']
+    assert main.current_temperature == 25.0
+    assert main.target_temperature == 26.0
+    assert sub1.current_temperature == 27.0
+    assert sub1.target_temperature == 28.0
+
+
+async def test_subdevice_climate_reads_its_own_power_state(climates):
+    """Both subdevices happen to report power On in this fixture -- this at
+    least confirms _is_on() reads the *subdevice's own* /power/vs/<n>, not a
+    hardcoded /power/vs/0, by checking the entity resolves without falling
+    back to OFF (which _is_on() would do if it silently read an absent
+    href instead of the subdevice's actual one)."""
+    main, sub1 = climates[None], climates['1']
+    assert main.hvac_mode != HVACMode.OFF
+    assert sub1.hvac_mode != HVACMode.OFF
+
+
+async def test_legacy_board_test_is_evaluated_per_subdevice(climates):
+    """The reporter's board has no /wind/* resources at all on *either*
+    subdevice -- is_legacy_board(self._resources) must independently
+    evaluate True for the master's own canonical view and for the
+    subdevice's own canonical view. If is_legacy_board were fed the raw,
+    unpartitioned snapshot (or if canonical_view leaked one subdevice's
+    hrefs into the other's), this wouldn't distinguish "this subdevice is
+    legacy" from "some subdevice on this connection is legacy" -- and a
+    future board with one legacy + one modern subdevice sharing a
+    connection would silently read the wrong fan/swing channel on one
+    side."""
+    main, sub1 = climates[None], climates['1']
+    assert main._legacy_airflow() != {}
+    assert sub1._legacy_airflow() != {}
+    # Both resolve to *some* fan mode via the legacy path rather than the
+    # /wind/strength/vs/0 channel (absent on this board) -- confirms
+    # is_legacy_board(self._resources) actually gated fan_mode's branch,
+    # not just that _legacy_airflow() itself returned something.
+    assert main.fan_mode is not None
+    assert sub1.fan_mode is not None
+
+
+async def test_subdevice_climate_writes_are_scoped_to_its_own_bound_entity(climates):
+    """A sanity check that the two entities are backed by genuinely
+    different BoundEntity objects (different hrefs), which is what makes
+    per-subdevice reads/writes possible at all -- see async_send_command's
+    translation test in test_coordinator_send_command.py for the write
+    side of this."""
+    main, sub1 = climates[None], climates['1']
+    assert main._bound.href == '/mode/vs/0'
+    assert sub1._bound.href == '/mode/vs/1'
+    assert main._bound is not sub1._bound

tests/test_common_capabilities.py

@@ -152,6 +152,14 @@ class TestPowerFallback:
         assert switch.exists_fn(resources['/power/0'], resources) is True
         assert sensor.exists_fn(resources['/power/0'], resources) is False
 
+    def test_polled_warm_so_power_state_reflects_quickly(self):
+        """issue #56 follow-up: neither href had a poll_tier, so power state
+        only ever refreshed on the once-per-30s summary poll instead of the
+        subscribe/subpoll cadence 'warm'/'hot' hrefs get -- same reasoning
+        as REMOTE_CONTROL_GENERIC/VS_FALLBACK's own 'warm' tier."""
+        assert common.POWER_GENERIC.poll_tier == 'warm'
+        assert common.POWER_VS_FALLBACK.poll_tier == 'warm'
+
 
 class TestWmSetinfoFlags:
     def test_washer_fixture_carries_setinfo_from_device0(self):

tests/test_coordinator_send_command.py

@@ -25,7 +25,10 @@ from custom_components.localthings.const import (
 )
 from custom_components.localthings.coordinator import LocalThingsCoordinator
 from custom_components.localthings.registry.capabilities import laundry
+from custom_components.localthings.registry.capabilities.airconditioner import _climate_write
 from custom_components.localthings.registry.discovery import BoundEntity
+from custom_components.localthings.registry.entities import ClimateDesc
+from custom_components.localthings.registry.subdevices import Subdevice
 
 ENTRY_DATA = {
     CONF_HOST: '10.0.0.199',
@@ -92,3 +95,86 @@ async def test_options_write_optimistic_cache_keeps_sibling_tokens(coordinator)
     assert cached['x.com.samsung.da.options'] == [
         'DeviceType_0167', 'Course_1D', 'GMT_04',
     ]
+
+
+# ---------------------------------------------------------------------------
+# Subdevice write translation (issue #177): a composite-entity write_fn (here
+# airconditioner._climate_write) returns *canonical* path_segs
+# (['power', 'vs', '0']) -- async_send_command must translate that through
+# bound_entity.subdevice.to_actual before POSTing, applying the optimistic
+# value, and starting the settle guard, or a subdevice's climate card would
+# write to (and read confirmation from) the master's resource instead of
+# its own.
+# ---------------------------------------------------------------------------
+
+def _climate_bound(href: str, subdevice: Subdevice) -> BoundEntity:
+    desc = ClimateDesc(key='climate', translation_key='airconditioner',
+                        write_fn=_climate_write)
+    return BoundEntity(href=href, capability=None, desc=desc, subdevice=subdevice)
+
+
+async def test_indexed_subdevice_write_posts_to_translated_path(coordinator) -> None:
+    """A power write from the bedroom subdevice's (indexed '1') climate entity
+    must POST to /power/vs/1, not the master's /power/vs/0."""
+    sub1 = Subdevice(kind='indexed', key='1', seed_path=('device', '1'))
+    bound = _climate_bound('/mode/vs/1', sub1)
+
+    await coordinator.async_send_command(bound, ('power', True))
+
+    posted_path, posted_bytes = coordinator._session.post_calls[0]
+    assert posted_path == ['power', 'vs', '1']
+    assert cbor2.loads(posted_bytes) == {'x.com.samsung.da.power': 'On'}
+
+
+async def test_indexed_subdevice_write_applies_optimistic_value_to_translated_href(
+    coordinator,
+) -> None:
+    sub1 = Subdevice(kind='indexed', key='1', seed_path=('device', '1'))
+    bound = _climate_bound('/mode/vs/1', sub1)
+
+    await coordinator.async_send_command(bound, ('power', True))
+
+    # The optimistic apply + settle guard must land on /power/vs/1 -- the
+    # translated href a real device confirms this write against -- not on
+    # /mode/vs/1 (bound_entity.href) or /power/vs/0 (the master's resource).
+    assert coordinator._cache.get('/power/vs/1') == {'x.com.samsung.da.power': 'On'}
+    assert coordinator._cache.get('/power/vs/0') is None
+    # The settle guard is armed on that same translated href: a stale poll
+    # reporting the pre-write value must be dropped, not allowed to revert
+    # the optimistic 'On' (issue #27's regression, translated to a
+    # subdevice's own resource).
+    applied = coordinator._observe.apply(
+        '/power/vs/1', {'x.com.samsung.da.power': 'Off'}, source='poll',
+    )
+    assert applied is False
+    assert coordinator._cache.get('/power/vs/1') == {'x.com.samsung.da.power': 'On'}
+
+
+async def test_prefixed_subdevice_write_posts_to_translated_path(coordinator) -> None:
+    """A power write from a UUID-prefixed subdevice's climate entity must POST
+    to /<uuid>/power/vs/0, not the bare canonical href."""
+    sub_id = '6c2dff6d-ee5c-dad1-6a5e-000000000001'
+    subdevice = Subdevice(kind='prefixed', key=sub_id, seed_path=(sub_id, 'device', '0'))
+    bound = _climate_bound(f'/{sub_id}/mode/vs/0', subdevice)
+
+    await coordinator.async_send_command(bound, ('power', True))
+
+    posted_path, posted_bytes = coordinator._session.post_calls[0]
+    assert posted_path == [sub_id, 'power', 'vs', '0']
+    assert cbor2.loads(posted_bytes) == {'x.com.samsung.da.power': 'On'}
+    assert coordinator._cache.get(f'/{sub_id}/power/vs/0') == {
+        'x.com.samsung.da.power': 'On',
+    }
+
+
+async def test_main_climate_write_unaffected_by_subdevice_translation(coordinator) -> None:
+    """MAIN's to_actual is the identity transform -- a device with no
+    subdevices must keep posting to the exact same path as before this
+    translation step existed."""
+    from custom_components.localthings.registry.subdevices import MAIN
+    bound = _climate_bound('/mode/vs/0', MAIN)
+
+    await coordinator.async_send_command(bound, ('power', True))
+
+    posted_path, _ = coordinator._session.post_calls[0]
+    assert posted_path == ['power', 'vs', '0']

tests/test_diagnostics_subdevices.py

@@ -0,0 +1,129 @@
+"""Sanity check for diagnostics.py's issue #177 additions (subdevices,
+subdevices_skipped, subdevice_probes) against a real composite-device
+discovery run -- makes sure the new blocks are actually reachable/shaped
+right, not just that the coordinator's own attributes look correct in
+isolation (test_subdevice_discovery.py covers that)."""
+from __future__ import annotations
+
+from homeassistant.core import HomeAssistant
+
+from custom_components.localthings.const import DOMAIN
+from custom_components.localthings.diagnostics import (
+    async_get_config_entry_diagnostics,
+)
+
+from tests.test_subdevice_discovery import _coordinator, _discover
+
+
+async def test_diagnostics_reports_materialized_and_skipped_subdevices(
+    hass: HomeAssistant, enable_custom_integrations,
+) -> None:
+    coordinator = _coordinator(hass)
+    await _discover(coordinator, 'airconditioner_artik051_dongle_fac_18k')
+    hass.data.setdefault(DOMAIN, {})[coordinator._entry.entry_id] = coordinator
+
+    diag = await async_get_config_entry_diagnostics(hass, coordinator._entry)
+
+    subdevice_keys = {su['key'] for su in diag['subdevices']}
+    skipped_keys = {su['key'] for su in diag['subdevices_skipped']}
+    assert subdevice_keys == {'1'}
+    assert skipped_keys == {'2'}
+    assert diag['subdevices'][0]['bound_entity_count'] > 0
+    assert diag['subdevices_skipped'][0]['hrefs']
+    assert '/multidevice/vs/0' in diag['subdevice_probes']
+    # The reporter's hand-read value, carried in the fixture's `probes` map
+    # (it belongs to no batch -- see that fixture's seeds_note). Two real
+    # subdevices, master + bedroom, independently corroborating the gate's
+    # decision to skip /device/2. Reported on its own, never as a resource.
+    assert diag['multidevice'] == {'x.com.samsung.da.numofsubdevice': '2'}
+    assert '/multidevice/vs/0' not in diag['resources']
+
+
+async def test_top_level_resources_is_the_master_subdevice_only(
+    hass: HomeAssistant, enable_custom_integrations,
+) -> None:
+    """`resources` reports this subdevice's own hrefs and nothing else.
+
+    It used to be `last_resources` raw -- the union across every live subdevice,
+    keyed by real hrefs -- so a sibling's /mode/vs/1 sat in it alongside the
+    master's /mode/vs/0 with no attribution, contradicting both the module
+    docstring and the adding-device-support skill ("the parsed /device/0
+    snapshot"). Each sibling carries its own canonicalized block instead.
+    """
+    coordinator = _coordinator(hass)
+    await _discover(coordinator, 'airconditioner_artik051_dongle_fac_18k')
+    hass.data.setdefault(DOMAIN, {})[coordinator._entry.entry_id] = coordinator
+
+    diag = await async_get_config_entry_diagnostics(hass, coordinator._entry)
+
+    assert not [h for h in diag['resources'] if h.endswith('/1')]
+    assert '/mode/vs/0' in diag['resources']
+    # The sibling's own block carries its state, canonicalized -- '/mode/vs/0',
+    # not the '/mode/vs/1' it actually answers on.
+    sub1 = diag["subdevices"][0]
+    assert '/mode/vs/0' in sub1["resources"]
+    assert not [h for h in sub1['resources'] if h.endswith('/1')]
+    assert sub1["resources"]["/power/vs/0"]['x.com.samsung.da.power'] == 'On'
+
+
+async def test_rejected_candidate_reps_reach_diagnostics_but_not_the_cache(
+    hass: HomeAssistant, enable_custom_integrations,
+) -> None:
+    """A gate-rejected slot is never polled again, so anything applied to the
+    state cache for it would sit frozen at its first-discovery value while
+    looking as live as every other href. It's kept out of the cache entirely
+    and reported only under its own subdevices_skipped entry -- which is also
+    the only place a reader can go to second-guess the gate."""
+    coordinator = _coordinator(hass)
+    await _discover(coordinator, 'airconditioner_artik051_dongle_fac_18k')
+    hass.data.setdefault(DOMAIN, {})[coordinator._entry.entry_id] = coordinator
+
+    assert not [h for h in coordinator.last_resources if h.endswith('/2')]
+
+    diag = await async_get_config_entry_diagnostics(hass, coordinator._entry)
+    skipped = diag['subdevices_skipped'][0]
+    # Present, canonicalized, and visibly the empty state the gate rejected.
+    assert skipped['resources']['/power/vs/0'] == {}
+    assert skipped['resources']['/mode/vs/0'] == {}
+    assert skipped['resources']['/information/vs/0']
+
+
+async def test_diagnostics_reports_prefixed_subdevice(
+    hass: HomeAssistant, enable_custom_integrations,
+) -> None:
+    coordinator = _coordinator(hass)
+    await _discover(coordinator, 'airconditioner_fac_bora_2in1')
+    hass.data.setdefault(DOMAIN, {})[coordinator._entry.entry_id] = coordinator
+
+    diag = await async_get_config_entry_diagnostics(hass, coordinator._entry)
+
+    assert len(diag['subdevices']) == 1
+    assert diag['subdevices'][0]['kind'] == 'prefixed'
+    # diagnostics reports the raw modelNum field verbatim (board revision/
+    # capability-bitmap suffix included), unlike device_info_for's model
+    # (split at '|') -- confirms it's still the wall subdevice's own identity,
+    # not the master's TP2X_FAC_BORA_21K.
+    assert diag['subdevices'][0]['model'].startswith('TP2X_FAC_BORA_RAC_21K')
+    assert diag['subdevices_skipped'] == []
+
+
+async def test_diagnostics_reports_flat_hrefs_for_skipped_prefixed_candidate(
+    hass: HomeAssistant, enable_custom_integrations,
+) -> None:
+    """issue #205: a prefixed candidate found through the per-href flat
+    fallback (no working /<uuid>/device/0 Collection) has no meaningful
+    seed_path -- diagnostics reports None there instead of the misleading
+    bare "/" an empty tuple would otherwise join to, and lists the actual
+    hrefs the fallback confirmed instead."""
+    coordinator = _coordinator(hass)
+    await _discover(coordinator, 'airconditioner_fac_bora_205_flat')
+    hass.data.setdefault(DOMAIN, {})[coordinator._entry.entry_id] = coordinator
+
+    diag = await async_get_config_entry_diagnostics(hass, coordinator._entry)
+
+    assert diag['subdevices'] == []
+    assert len(diag['subdevices_skipped']) == 1
+    skipped = diag['subdevices_skipped'][0]
+    assert skipped['kind'] == 'prefixed'
+    assert skipped['seed_path'] is None
+    assert skipped['flat_hrefs'] == ['/information/vs/0']

tests/test_entity.py

@@ -17,6 +17,14 @@ class _FakeCoordinator:
     def __init__(self, last_resources):
         self.last_resources = last_resources
 
+    def canonical_resources(self, subdevice):
+        # Every bound entity in this test file uses the default MAIN
+        # subdevice (identity transform), so the canonical view is just the
+        # raw snapshot -- same shape as the real
+        # LocalThingsCoordinator.canonical_resources for a device with no
+        # subdevices (issue #177).
+        return self.last_resources
+
 
 def _bound(desc, href):
     capability = Capability(href=href, entities=(desc,))

tests/test_fridge_capabilities.py

@@ -230,6 +230,44 @@ class TestPantryZone:
         assert body == {'x.com.samsung.da.mode': 'FDR_WINE'}
 
 
+class TestDefiniteTemperatureCooler:
+    """Discrete cooler setpoint (RT42DG6630B1FZ, issue #186) -- a single-door
+    fridge whose /temperature/definite/cooler/vs/0 falls outside both
+    TEMP_CURRENT_GENERIC and TEMP_SETPOINT's href prefixes, so temperature
+    control was entirely unbound before this capability was added."""
+
+    def test_href(self):
+        assert fridge.DEFINITE_TEMPERATURE_COOLER.href == '/temperature/definite/cooler/vs/0'
+
+    def test_write(self):
+        desc = fridge.DEFINITE_TEMPERATURE_COOLER.entities[0]
+        path, body = desc.write_fn('3', {})
+        assert path == ['temperature', 'definite', 'cooler', 'vs', '0']
+        assert body == {'x.com.samsung.da.definite.desired': '3'}
+
+    def test_no_unbound_hrefs_and_discrete_options(self):
+        from custom_components.localthings.registry.adapter import flatten
+        from custom_components.localthings.registry.by_type import refrigerator
+        from custom_components.localthings.registry.discovery import discover
+        from tests.conftest import _load_device
+
+        resources = _load_device('refrigerator_definite_cooler')
+        unbound = []
+        bound = discover(
+            resources,
+            refrigerator.REGISTRY.capabilities,
+            refrigerator.REGISTRY.pattern_capabilities,
+            log=unbound.append,
+        )
+        assert unbound == []
+
+        state = flatten(bound, resources)
+        assert state['cooler_temperature_setpoint'] == '2'
+
+        rep = resources['/temperature/definite/cooler/vs/0']
+        assert rep['x.com.samsung.da.definite.supportedList'] == ['1', '2', '3', '4', '7']
+
+
 class TestKimchiZone:
     """Kimchi-refrigerator compartments (TP2X_REF_20K-class, issue #26) --
     top/middle/bottom each report an identically-shaped currentMode/

tests/test_golden_regression.py

@@ -138,10 +138,37 @@ def test_registry_reproduces_golden_state_keys_for_water_purifier():
     )
 
 
+def test_registry_reproduces_golden_state_keys_for_water_purifier_ailite_25k():
+    """AILITE_WATERPURIFIER_25K (issue #196, RWP70F15ANW) -- a coffee-capable
+    water purifier on an AILITE_DA-REF-WATERPURIFIER board, whose modelNum's
+    'REF' token would otherwise misroute it to the refrigerator registry (see
+    TestBoardTokenAmbiguity's carve-out). Also the first dump to expose
+    /cup/state/vs/0, /statistic/pour/vs/0, and the settings/sound/* trio on
+    this device type, and a hot_water_temperature select that must gate off
+    (no supportedHotTemperatures reported) rather than surface as 'unknown'."""
+    from tests.conftest import _load_device
+    resources = _load_device('water_purifier_ailite_25k')
+    golden = json.loads((GOLDEN / 'water_purifier_ailite_25k.json').read_text())
+    state_keys = _new_state_keys('water_purifier_ailite_25k', resources)
+    assert set(state_keys) == set(golden['state_keys']), (
+        f"state_keys mismatch:\n"
+        f"  extra:   {sorted(set(state_keys) - set(golden['state_keys']))}\n"
+        f"  missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
+    )
+
+
 def test_registry_reproduces_golden_state_keys_for_water_purifier_coffee():
     """TP2X_WATERPURIFIER_20K coffee-capable variant (issue #107) adds
     /favorite/coffee/vs/0, /favorite/hotwater/vs/0, and three static
-    coffee-recipe resources not present in issue #90's original dump."""
+    coffee-recipe resources not present in issue #90's original dump.
+
+    This fixture's /setting/waterpurifier/vs/0 turns out to report no
+    supportedHotTemperatures either (only hotwaterLevel/hotwaterRange, the
+    same shape issue #196 surfaced) -- so hot_water_temperature dropped out
+    of this golden when the #196 fix (see water_purifier.DISPENSE's
+    exists_fn) landed. This fixture was quietly hitting the same 'unknown'
+    bug all along; the registry-level golden just had no way to show it
+    since flatten()'s state dict doesn't model select option membership."""
     from tests.conftest import _load_device
     resources = _load_device('water_purifier_coffee')
     golden = json.loads((GOLDEN / 'water_purifier_coffee.json').read_text())
@@ -859,6 +886,182 @@ def test_registry_reproduces_golden_state_keys_for_airconditioner_fac_bora():
     )
 
 
+def _new_subdevice_aware_state_keys(name):
+    """Like _new_state_keys, but runs the full subdevice-aware pipeline
+    (enumerate_subdevices + discover_partitioned, issue #177) instead of a
+    single discover() call, so the golden for a composite-device fixture
+    captures every materialized subdevice's keys
+    (subdevice1_-/subdevice_<uuid>_-prefixed), not just the master's."""
+    from custom_components.localthings.registry.adapter import flatten
+    from tests.conftest import _discover_full, _load_device_full
+    resources, oic_res, seeds = _load_device_full(name)
+    bound, _materialized, _skipped, full_resources, _device_type_name = _discover_full(
+        resources, oic_res, seeds,
+    )
+    state = flatten(bound, full_resources)
+    return sorted(state.keys())
+
+
+def test_registry_reproduces_golden_state_keys_for_airconditioner_artik051_dongle_fac_18k():
+    """The reporter's ARTIK051_DONGLE_FAC_18K (issue #177, Pattern A -- indexed
+    siblings): a real v0.16.0 dump with a genuine second indoor subdevice at
+    `/device/1` (subdevice1_-prefixed keys below) and an unused SmartThings
+    slot at `/device/2` that answers its seed but never produces a
+    materialized subdevice (see DESIGN-177.md section 4 and
+    test_subdevice_discovery.py's explicit "/device/2 produces no entities"
+    assertion) -- so this golden has no `subdevice2_`-prefixed keys at all,
+    which is the point."""
+    name = 'airconditioner_artik051_dongle_fac_18k'
+    golden = json.loads((GOLDEN / f'{name}.json').read_text())
+    state_keys = _new_subdevice_aware_state_keys(name)
+    assert set(state_keys) == set(golden['state_keys']), (
+        f"state_keys mismatch:\n"
+        f"  extra:   {sorted(set(state_keys) - set(golden['state_keys']))}\n"
+        f"  missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
+    )
+
+
+def test_registry_reproduces_golden_state_keys_for_airconditioner_cac():
+    """TP1X_DA-AC-CAC-01001_0000 (issue #191) -- fell back to 'unknown' in
+    0.16.0 when oneUiVersion detection was dropped, since 'CAC' had never
+    been added to the modelNum board-token table. Resolved via the new 'CAC'
+    token onto the existing airconditioner registry. Not fully covered yet --
+    ten hrefs remain unbound (edge lighting, PM1 filter, stateful light,
+    absence-clean, four sound-settings resources, smart-sensing-cooling, UV
+    LED), all genuinely new to this board generation and out of scope for
+    the routing fix; see test_airconditioner_cac.py for the documented gap."""
+    from tests.conftest import _load_device
+    resources = _load_device('airconditioner_cac')
+    golden = json.loads((GOLDEN / 'airconditioner_cac.json').read_text())
+    state_keys = _new_state_keys('airconditioner_cac', resources)
+    assert set(state_keys) == set(golden['state_keys']), (
+        f"state_keys mismatch:\n"
+        f"  extra:   {sorted(set(state_keys) - set(golden['state_keys']))}\n"
+        f"  missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
+    )
+
+
+def test_registry_reproduces_golden_state_keys_for_airconditioner_fac_bora_2in1():
+    """The reporter's TP2X_FAC_BORA_21K (issue #177, Pattern B -- UUID-prefixed
+    tree): device0/oic_res are real; the wall-mounted subdevice's own
+    /information/vs/0 is real (confirmed live by the reporter), the rest of
+    its seed tree is constructed (see the fixture's own seeds_note) -- just
+    enough to bind a real climate card under the
+    `subdevice_6c2dff6dee5cdad16a5e000000000001_` prefix below. Distinct from
+    tests/fixtures/airconditioner_fac_bora_device.json, which is
+    deliberately left unchanged as the redacted-subdeviceIdList regression
+    case (zero subdevices)."""
+    name = 'airconditioner_fac_bora_2in1'
+    golden = json.loads((GOLDEN / f'{name}.json').read_text())
+    state_keys = _new_subdevice_aware_state_keys(name)
+    assert set(state_keys) == set(golden['state_keys']), (
+        f"state_keys mismatch:\n"
+        f"  extra:   {sorted(set(state_keys) - set(golden['state_keys']))}\n"
+        f"  missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
+    )
+
+
+def test_registry_reproduces_golden_state_keys_for_airconditioner_fac_bora_205_flat():
+    """The same reporter's same physical TP2X_FAC_BORA_21K unit as the _2in1
+    fixture above, but a later capture (issue #205) where /<uuid>/device/0 doesn't
+    answer -- contrary to what that fixture's own seed batch assumed the
+    Collection endpoint would do. device0/oic_res are real; the only
+    UUID-prefixed data is the one href ever actually confirmed live
+    (/information/vs/0, same real capture the _2in1 fixture uses), fed
+    through registry.subdevices.enumerate_subdevices' per-href flat
+    fallback instead of a Collection batch. /information/vs/0 alone binds
+    no entity, so the candidate is found but never materializes -- this
+    golden has no `subdevice_...`-prefixed keys at all, same shape as
+    tests/fixtures/golden/airconditioner_fac_bora.json, which is the point:
+    a device whose sibling can't yet be confirmed live must regress to
+    exactly the master-only state, never a phantom or partial subdevice."""
+    name = 'airconditioner_fac_bora_205_flat'
+    golden = json.loads((GOLDEN / f'{name}.json').read_text())
+    state_keys = _new_subdevice_aware_state_keys(name)
+    assert set(state_keys) == set(golden['state_keys']), (
+        f"state_keys mismatch:\n"
+        f"  extra:   {sorted(set(state_keys) - set(golden['state_keys']))}\n"
+        f"  missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
+    )
+
+
+def test_registry_reproduces_golden_state_keys_for_air_purifier_avt_ww():
+    """AVT-WW-TP1-23-AXX500 (issue #190) -- next-gen BESPOKE Cube Air board;
+    reports device_type 'unknown' with empty oneUiVersion because 'VTWW' as a
+    whole token doesn't match this board's 'AVT'/'WW' split. Resolved via the
+    new 'AVT' modelNum board-token fallback into the existing air_purifier
+    registry. Binds cleanly with zero unbound hrefs."""
+    from tests.conftest import _load_device
+    resources = _load_device('air_purifier_avt_ww')
+    golden = json.loads((GOLDEN / 'air_purifier_avt_ww.json').read_text())
+    state_keys = _new_state_keys('air_purifier_avt_ww', resources)
+    assert set(state_keys) == set(golden['state_keys']), (
+        f"state_keys mismatch:\n"
+        f"  extra:   {sorted(set(state_keys) - set(golden['state_keys']))}\n"
+        f"  missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
+    )
+
+
+def test_registry_reproduces_golden_state_keys_for_airconditioner_artik051_krac_energy():
+    """AR12NXWXCWKNEU/ARTIK051_KRAC_18K (issue #193) -- same legacy board
+    generation as the artik051_krac_18k fixture, but this dump has a nonzero
+    cumulativePower. Locks in state_keys; the actual /100000 scale fix is
+    asserted separately in test_airconditioner_capabilities.py since golden
+    only compares key sets, not values."""
+    from tests.conftest import _load_device
+    resources = _load_device('airconditioner_artik051_krac_energy')
+    golden = json.loads(
+        (GOLDEN / 'airconditioner_artik051_krac_energy.json').read_text()
+    )
+    state_keys = _new_state_keys('airconditioner_artik051_krac_energy', resources)
+    assert set(state_keys) == set(golden['state_keys']), (
+        f"state_keys mismatch:\n"
+        f"  extra:   {sorted(set(state_keys) - set(golden['state_keys']))}\n"
+        f"  missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
+    )
+
+
+def test_registry_reproduces_golden_state_keys_for_refrigerator_definite_cooler():
+    """RT42DG6630B1FZ (issue #186) -- a single-door "cooler only" fridge whose
+    /temperature/definite/cooler/vs/0 doesn't match either
+    TEMP_CURRENT_GENERIC's '/temperature/current/' or TEMP_SETPOINT's
+    '/temperature/desired/' href prefix, so temperature control was entirely
+    unbound. Resolved via the new DEFINITE_TEMPERATURE_COOLER capability
+    (a select over the device's own discrete supportedList, not a
+    continuous NumberDesc range -- 5 and 6 aren't valid setpoints on this
+    model). Binds cleanly with zero unbound hrefs."""
+    from tests.conftest import _load_device
+    resources = _load_device('refrigerator_definite_cooler')
+    golden = json.loads(
+        (GOLDEN / 'refrigerator_definite_cooler.json').read_text()
+    )
+    state_keys = _new_state_keys('refrigerator_definite_cooler', resources)
+    assert set(state_keys) == set(golden['state_keys']), (
+        f"state_keys mismatch:\n"
+        f"  extra:   {sorted(set(state_keys) - set(golden['state_keys']))}\n"
+        f"  missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
+    )
+
+
+def test_registry_reproduces_golden_state_keys_for_range_ne6516a():
+    """NE6516A-class range (issue #183) -- no /information/vs/0, resolved via
+    the same 'Bake'-in-supportedModes + /cooktopmonitoring/vs/0 signature as
+    the other no-info range fixtures. Its /mode/vs/0 options[] carries
+    EnergySaving_On and BurnerOnAlert_Off (previously unbound entirely) but
+    no fastpreheat_*/NaturalSteam_* tokens at all -- locks in that those two
+    switches now correctly stay unbound instead of binding as always-off,
+    does-nothing phantom controls."""
+    from tests.conftest import _load_device
+    resources = _load_device('range_ne6516a')
+    golden = json.loads((GOLDEN / 'range_ne6516a.json').read_text())
+    state_keys = _new_state_keys('range_ne6516a', resources)
+    assert set(state_keys) == set(golden['state_keys']), (
+        f"state_keys mismatch:\n"
+        f"  extra:   {sorted(set(state_keys) - set(golden['state_keys']))}\n"
+        f"  missing: {sorted(set(golden['state_keys']) - set(state_keys))}"
+    )
+
+
 def test_resources_from_batch_preferred_over_flat():
     from tests.conftest import _resources_from_dump
     dump = {

tests/test_identity.py

@@ -72,22 +72,31 @@ def test_read_identity_keeps_raw_payloads_for_diagnostics():
 
 
 def test_read_identity_captures_oic_res_links():
-    """/oic/res is OCF's discovery endpoint: a baseline RETRIEVE returns an
-    array of Link objects, one per Resource/Collection the endpoint hosts --
-    including, per the OCF 'Composite Device' model, a second logical
-    Device's Collection on a multi-unit system (issue #177). Nothing routes
-    on this yet; captured so a report from such a device shows us whether
-    its firmware actually exposes more than the one /device/0 seed href."""
+    """/oic/res is OCF's discovery endpoint. Real hardware (issue #177
+    follow-up, a TP1X_REF_21K fridge dump) groups the response by `di`: one
+    entry per logical Device, each carrying its own `links` array -- not a
+    flat array of individually-`di`-tagged links. Every entry that dump
+    returned had its discoverable policy bit set (`bm`'s bit 0); the whole
+    x.com.samsung.da.* tree (including /device/0 itself) did not appear at
+    all, meaning it's registered non-discoverable and simply invisible to
+    this endpoint -- see _SPECULATIVE_DEVICE_INDICES' docstring for why that
+    motivated probing /device/1 and /device/2 directly instead."""
     sess = FakeSession({
         ('oic', 'res'): [
-            {'di': 'aaaa', 'href': '/device/0', 'rt': ['x.com.samsung.devcol', 'oic.wk.col']},
-            {'di': 'bbbb', 'href': '/device/1', 'rt': ['x.com.samsung.devcol', 'oic.wk.col']},
+            {'di': 'aaaa', 'links': [
+                {'href': '/oic/d', 'rt': ['oic.wk.d', 'oic.d.refrigerator'],
+                 'p': {'bm': 1}},
+                {'href': '/oic/sec/doxm', 'rt': ['oic.r.doxm'], 'p': {'bm': 1}},
+            ]},
         ],
     })
     ident = read_identity(sess, serial=None)
     assert ident.raw['/oic/res'] == [
-        {'di': 'aaaa', 'href': '/device/0', 'rt': ['x.com.samsung.devcol', 'oic.wk.col']},
-        {'di': 'bbbb', 'href': '/device/1', 'rt': ['x.com.samsung.devcol', 'oic.wk.col']},
+        {'di': 'aaaa', 'links': [
+            {'href': '/oic/d', 'rt': ['oic.wk.d', 'oic.d.refrigerator'],
+             'p': {'bm': 1}},
+            {'href': '/oic/sec/doxm', 'rt': ['oic.r.doxm'], 'p': {'bm': 1}},
+        ]},
     ]
 
 

tests/test_range_hood_fan.py

@@ -19,6 +19,12 @@ class _FakeCoordinator:
     def resource(self, href):
         return self.last_resources.get(href, {})
 
+    def canonical_resources(self, subdevice):
+        # Every bound entity in this test uses the default MAIN
+        # subdevice, so the canonical view is just the raw snapshot
+        # (issue #177 -- see LocalThingsEntity._resources).
+        return self.last_resources
+
     async def async_send_command(self, bound, payload):
         self.commands.append((bound, payload))
 
@@ -218,3 +224,19 @@ async def test_microwave_vent_fan_set_percentage_zero_turns_off():
     await entity.async_set_percentage(0)
 
     assert coordinator.commands[-1][1] == ('speed', '0')
+
+
+def test_microwave_vent_fan_missing_supported_fan_speed_falls_back_to_settable_min_max():
+    """Hardware omitting supportedFanSpeed (e.g. ME8000T / issue #172) falls back
+    to building speed codes from settableMinFanSpeed ('0') and settableMaxFanSpeed ('3')."""
+    resources = _load_device('microwave_me7500d')
+    resources['/hood/fanspeed/vs/0'].pop('x.com.samsung.da.hood.supportedFanSpeed', None)
+    resources['/hood/fanspeed/vs/0']['x.com.samsung.da.hood.settableMinFanSpeed'] = '0'
+    resources['/hood/fanspeed/vs/0']['x.com.samsung.da.hood.settableMaxFanSpeed'] = '3'
+
+    entity = _microwave_entity(resources)
+    assert entity._all_speed_codes() == ['0', '1', '2', '3']
+    assert entity._active_speed_codes() == ['1', '2', '3']
+    assert entity.speed_count == 3
+    assert entity.supported_features & 1  # FanEntityFeature.SET_SPEED is present
+

tests/test_range_ne6516a_capabilities.py

@@ -0,0 +1,62 @@
+"""Tests for the NE6516A-class range (issue #183).
+
+Same no-/information/vs/0, no-burner-status shape as issues #74/#138. Its
+/mode/vs/0 options[] carries EnergySaving_On and BurnerOnAlert_Off -- both
+previously unbound entirely -- but no fastpreheat_*/NaturalSteam_* tokens at
+all, which is what exposed the pre-existing fast_preheat/natural_steam
+phantom-switch bug (both were shipped with no exists_fn, so they bound
+unconditionally, always read off, and any write went to a token this
+firmware never recognized).
+"""
+from custom_components.localthings.registry.adapter import flatten
+from custom_components.localthings.registry.by_type import for_device_by_resources
+from custom_components.localthings.registry.discovery import discover
+
+from tests.conftest import _load_device
+
+
+def _range():
+    resources = _load_device('range_ne6516a')
+    reg = for_device_by_resources(resources)
+    return reg, resources
+
+
+def _state():
+    reg, resources = _range()
+    bound = discover(resources, reg.capabilities, reg.pattern_capabilities)
+    return flatten(bound, resources)
+
+
+def test_resolves_to_range_registry():
+    reg, _ = _range()
+    assert reg is not None and reg.name == 'range'
+
+
+def test_no_unbound_hrefs():
+    reg, resources = _range()
+    unbound = []
+    discover(resources, reg.capabilities, reg.pattern_capabilities, log=unbound.append)
+    assert unbound == []
+
+
+def test_fast_preheat_and_natural_steam_absent_without_their_tokens():
+    """Neither token is in this dump's options[] -- both switches must stay
+    unbound rather than silently reading as an always-off phantom control."""
+    state = _state()
+    assert 'fast_preheat' not in state
+    assert 'natural_steam' not in state
+
+
+def test_energy_saving_and_cooktop_alert_present():
+    state = _state()
+    assert state['energy_saving'] is True
+    assert state['cooktop_on_alert'] is False
+
+
+def test_child_lock_already_reads_correctly():
+    """issue #183 also reported child lock as unreadable -- but this dump's
+    /kidslock/vs/0 ('Run') and /doors/vs/0's door lock field ('Lock') already
+    agree the door is locked, and the existing common.KIDS_LOCK_VS_FALLBACK
+    already reads that correctly with no code change needed."""
+    state = _state()
+    assert state['child_lock'] is True

tests/test_select_options.py

@@ -14,6 +14,12 @@ class _FakeCoordinator:
     def __init__(self, last_resources):
         self.last_resources = last_resources
 
+    def canonical_resources(self, subdevice):
+        # Every entity built by _make_select uses the default MAIN
+        # subdevice, so the canonical view is just the raw snapshot
+        # (issue #177 -- see LocalThingsEntity._resources).
+        return self.last_resources
+
 
 def _make_select(desc, href, last_resources):
     capability = Capability(href=href, entities=(desc,))

tests/test_subdevice_discovery.py

@@ -0,0 +1,452 @@
+"""End-to-end discovery tests for issue #177's two composite-device
+fixtures, against the real LocalThingsCoordinator (not the HA-free
+registry-level helpers test_subdevices.py/test_unique_ids.py use) -- this is
+what actually exercises _enumerate_subdevices_blocking + _run_discovery
+together, including device_info_for/via_device and the "no phantom
+/device/2 entities" guarantee.
+"""
+from __future__ import annotations
+
+import pytest
+from homeassistant.core import HomeAssistant
+from pytest_homeassistant_custom_component.common import MockConfigEntry
+
+from custom_components.localthings.const import (
+    CONF_HOST, CONF_LEAF_CERT_PEM, CONF_LEAF_KEY_PEM, CONF_PORT, DOMAIN,
+)
+from custom_components.localthings.coordinator import LocalThingsCoordinator
+from custom_components.localthings.registry.entities import ClimateDesc
+from custom_components.localthings.registry.identity import DeviceIdentity
+
+from tests.conftest import FakeCoapSession, _load_device_full
+
+ENTRY_DATA = {
+    CONF_HOST: '10.0.0.177',
+    CONF_PORT: 49154,
+    CONF_LEAF_CERT_PEM: '-----BEGIN CERTIFICATE-----\nTEST-LEAF\n-----END CERTIFICATE-----',
+    CONF_LEAF_KEY_PEM: '-----BEGIN PRIVATE KEY-----\nTEST-LEAF-KEY\n-----END PRIVATE KEY-----',
+}
+
+
+def _coordinator(hass: HomeAssistant) -> LocalThingsCoordinator:
+    entry = MockConfigEntry(
+        domain=DOMAIN, data=ENTRY_DATA, unique_id='localthings_SUBDEVICE-TEST',
+    )
+    entry.add_to_hass(hass)
+    return LocalThingsCoordinator(hass, entry)
+
+
+async def _discover_with(
+    coordinator: LocalThingsCoordinator, resources: dict, oic_res, seeds: dict,
+) -> None:
+    """Run the same two-step sequence _async_update_data's first cycle does
+    (enumerate, then discover) against arbitrary resources/oic_res/seeds,
+    without the polling/reconnect machinery around it -- see coordinator.py's
+    _enumerate_subdevices_blocking/_run_discovery. `_discover` below is the
+    fixture-file-backed convenience wrapper most tests want."""
+    coordinator._session = FakeCoapSession(seeds)
+    # _connect_session (skipped here -- the session is pre-set) is what
+    # normally populates _identity via read_identity; set it directly with
+    # the fixture's real /oic/res so enumeration sees the same links a live
+    # read_identity call would have captured.
+    coordinator._identity = DeviceIdentity(
+        manufacturer='Samsung Electronics', model='', name='', serial=None,
+        device_types=(), raw={'/oic/p': {}, '/oic/d': {}, '/oic/res': oic_res},
+    )
+    merged = await coordinator.hass.async_add_executor_job(
+        coordinator._enumerate_subdevices_blocking, resources,
+    )
+    # Mirror _async_update_data's first-cycle order exactly: discover, then
+    # drop the candidates the liveness gate rejected, then apply what's left
+    # to the observe/cache layer. The apply has to happen (canonical_resources
+    # -- device_info_for, is_legacy_board, ... -- reads the cache, not the
+    # dict passed to _run_discovery), but it has to happen *after* the gate,
+    # or a rejected slot's reps get frozen into the cache forever. Applying
+    # first here would leave this helper testing an ordering production no
+    # longer uses.
+    coordinator._run_discovery(merged)
+    for href, rep in coordinator._live_subdevice_resources(merged).items():
+        coordinator._observe.apply(href, rep, source='poll')
+
+
+async def _discover(coordinator: LocalThingsCoordinator, name: str) -> None:
+    """Fixture-file-backed convenience wrapper around _discover_with."""
+    resources, oic_res, seeds = _load_device_full(name)
+    await _discover_with(coordinator, resources, oic_res, seeds)
+
+
+def _climate_bound(coordinator, subdevice_key: str):
+    from custom_components.localthings.registry.subdevices import MAIN
+    for b in coordinator.bound:
+        if isinstance(b.desc, ClimateDesc):
+            if subdevice_key is None and b.subdevice == MAIN:
+                return b
+            if subdevice_key is not None and b.subdevice.key == subdevice_key:
+                return b
+    return None
+
+
+# ---------------------------------------------------------------------------
+# Pattern A reporter -- ARTIK051_DONGLE_FAC_18K, indexed siblings
+# ---------------------------------------------------------------------------
+
+async def test_pattern_a_materializes_master_and_bedroom_subdevice(hass: HomeAssistant):
+    coordinator = _coordinator(hass)
+    await _discover(coordinator, 'airconditioner_artik051_dongle_fac_18k')
+
+    assert [su.key for su in coordinator.subdevices] == ['1']
+
+    main_climate = _climate_bound(coordinator, None)
+    sub1_climate = _climate_bound(coordinator, '1')
+    assert main_climate is not None
+    assert sub1_climate is not None
+    assert main_climate.href == '/mode/vs/0'
+    assert sub1_climate.href == '/mode/vs/1'
+
+
+async def test_pattern_a_device_2_produces_no_entities_at_all(hass: HomeAssistant):
+    """The reporter's /device/2 is the unused SmartThings slot
+    (DESIGN-177.md section 4): it answers its seed with a full-shaped
+    batch, but every climate-state rep on it is empty. It must be recorded
+    as skipped, not materialized, and must contribute zero bound entities."""
+    coordinator = _coordinator(hass)
+    await _discover(coordinator, 'airconditioner_artik051_dongle_fac_18k')
+
+    assert '2' not in [su.key for su in coordinator.subdevices]
+    assert any(
+        skip.subdevice.kind == 'indexed' and skip.subdevice.key == '2'
+        for skip in coordinator._skipped_subdevices
+    )
+    assert not any(b.subdevice.key == '2' for b in coordinator.bound)
+    assert not any(href.endswith('/2') for href in coordinator._hot_hrefs)
+    assert not any(href.endswith('/2') for href in coordinator._warm_hrefs)
+
+
+async def test_hjcom_sub1_device_info_links_via_device_to_master(hass: HomeAssistant):
+    coordinator = _coordinator(hass)
+    await _discover(coordinator, 'airconditioner_artik051_dongle_fac_18k')
+
+    sub1 = next(su for su in coordinator.subdevices if su.key == '1')
+    info = coordinator.device_info_for(sub1)
+
+    master_serial = coordinator.device_serial
+    assert info['identifiers'] == {(DOMAIN, f'{master_serial}_1')}
+    assert info['via_device'] == (DOMAIN, master_serial)
+    # The subdevice's own /information/vs/1 (real, ARTIK051_DONGLE_FAC_RAC_18K)
+    # is what names/models this device, not the master's.
+    assert info['model'] == 'ARTIK051_DONGLE_FAC_RAC_18K'
+
+
+# ---------------------------------------------------------------------------
+# Issue #177's Pattern B reporter -- TP2X_FAC_BORA_21K, UUID-prefixed tree
+# ---------------------------------------------------------------------------
+
+_SUB_UUID = '6c2dff6d-ee5c-dad1-6a5e-000000000001'
+
+
+async def test_fac_bora_2in1_materializes_prefixed_wall_subdevice(hass: HomeAssistant):
+    coordinator = _coordinator(hass)
+    await _discover(coordinator, 'airconditioner_fac_bora_2in1')
+
+    assert [su.key for su in coordinator.subdevices] == [_SUB_UUID]
+    assert coordinator.subdevices[0].kind == 'prefixed'
+
+    main_climate = _climate_bound(coordinator, None)
+    sub_climate = _climate_bound(coordinator, _SUB_UUID)
+    assert main_climate is not None
+    assert sub_climate is not None
+    assert main_climate.href == '/mode/vs/0'
+    assert sub_climate.href == f'/{_SUB_UUID}/mode/vs/0'
+
+
+async def test_fac_bora_2in1_subdevice_device_info(hass: HomeAssistant):
+    coordinator = _coordinator(hass)
+    await _discover(coordinator, 'airconditioner_fac_bora_2in1')
+
+    subdevice = coordinator.subdevices[0]
+    info = coordinator.device_info_for(subdevice)
+
+    master_serial = coordinator.device_serial
+    assert info['identifiers'] == {(DOMAIN, f'{master_serial}_{_SUB_UUID}')}
+    assert info['via_device'] == (DOMAIN, master_serial)
+    # Confirmed live by the reporter (DESIGN-177.md section 1): the wall
+    # subdevice's own identity, distinct from the master's TP2X_FAC_BORA_21K.
+    assert info['model'] == 'TP2X_FAC_BORA_RAC_21K'
+
+
+async def test_fac_bora_2in1_unique_ids_include_subdevice_prefix(hass: HomeAssistant):
+    """The prefixed subdevice's unique_id carries the full subdevice UUID
+    (non-alphanumerics stripped), not a truncation or an ordinal -- see
+    Subdevice.key_prefix."""
+    coordinator = _coordinator(hass)
+    await _discover(coordinator, 'airconditioner_fac_bora_2in1')
+
+    from custom_components.localthings.entity import LocalThingsEntity
+    sub_climate = _climate_bound(coordinator, _SUB_UUID)
+    entity = LocalThingsEntity(coordinator, sub_climate)
+    expected_slug = _SUB_UUID.replace('-', '')
+    assert entity._attr_unique_id == (
+        f"{DOMAIN}_{coordinator.device_serial}_subdevice_{expected_slug}_climate"
+    )
+
+
+# ---------------------------------------------------------------------------
+# Same reporter and physical unit/UUID again -- issue #205, but this
+# time /<uuid>/device/0 doesn't answer. Exercises enumerate_subdevices'
+# per-href flat-probe fallback (registry/subdevices.py) against a real
+# capture instead of the synthetic sessions test_subdevices.py uses.
+# ---------------------------------------------------------------------------
+
+async def test_fac_bora_205_flat_fallback_finds_candidate_but_gate_holds_it_back(
+    hass: HomeAssistant,
+):
+    """The fixture's only seeded UUID-prefixed href is /information/vs/0 --
+    the one href ever actually confirmed live under this prefix (issue #177
+    comment 5113518087) -- since nothing else has been confirmed yet for
+    this unit. That's enough for the flat-probe fallback to find a
+    candidate, but /information/vs/0 binds no entity on its own (it's only
+    ever read for device-type resolution, never bound as a capability), so
+    discover_partitioned's liveness gate correctly holds it back rather than
+    materializing a phantom climate card from unconfirmed hrefs. This is the
+    honest current state of issue #205, not a guess at its resolution."""
+    coordinator = _coordinator(hass)
+    await _discover(coordinator, 'airconditioner_fac_bora_205_flat')
+
+    assert coordinator.subdevices == []
+    assert [s.subdevice.key for s in coordinator._skipped_subdevices] == [_SUB_UUID]
+    skipped = coordinator._skipped_subdevices[0].subdevice
+    assert skipped.kind == 'prefixed'
+    assert skipped.seed_path == ()
+    assert skipped.flat_hrefs == ('/information/vs/0',)
+
+    assert coordinator._subdevice_probes[f'/{_SUB_UUID}/device/0'] is False
+    assert coordinator._subdevice_probes[f'/{_SUB_UUID}/information/vs/0'] is True
+
+    # Confirms the master itself is completely unaffected by its sibling's
+    # Collection endpoint not answering -- same guarantee every other
+    # subdevice test in this file relies on.
+    assert _climate_bound(coordinator, None) is not None
+
+
+async def test_flat_subdevice_materializes_and_repolls_end_to_end(hass: HomeAssistant):
+    """Synthetic (not a real capture, unlike the fixture-driven test above) --
+    exercises the one path nothing else covers: a flat-mode prefixed
+    subdevice with *enough* confirmed hrefs to actually pass
+    discover_partitioned's liveness gate and materialize a real climate
+    entity, then a subsequent _poll_subdevice_seed re-poll refreshing its
+    state all the way through to canonical_resources -- the path a real
+    resolution of issue #205 (once more hrefs are confirmed live for some
+    unit) would actually need.
+
+    Also pins _poll_subdevice_flat_hrefs' hot/warm skip: climate-critical
+    hrefs (power/mode/temperature) land on the warm tier by discovery's own
+    rules, so they're already kept fresh every few seconds by _run_subpolls
+    -- re-fetching them again on this once-per-summary-poll pass would only
+    add GETs, not freshness, so they're the ones this method must skip.
+    /option/autoclean/vs/0 is cold-tier and is what actually needs this
+    path."""
+    resources, oic_res, _real_seeds = _load_device_full('airconditioner_fac_bora_2in1')
+    seeds = {
+        # No (_SUB_UUID, 'device', '0') entry -- forces the flat fallback,
+        # same as the real issue #205 capture above, but this time with
+        # enough hrefs answering to actually materialize. power/mode/
+        # temperature values copied verbatim from that fixture's own (real)
+        # Collection-batch seed, just served individually instead of
+        # batched, to isolate "does flat mode produce the same result as
+        # Collection mode" as the only variable.
+        f'/{_SUB_UUID}/power/vs/0': {'x.com.samsung.da.power': 'On'},
+        f'/{_SUB_UUID}/mode/vs/0': {
+            'x.com.samsung.da.supportedModes': ['Cool', 'Dry', 'Wind', 'Auto'],
+            'x.com.samsung.da.modes': ['Cool'],
+            'x.com.samsung.da.options': [],
+        },
+        f'/{_SUB_UUID}/temperature/current/0': {
+            'range': [18.0, 30.0], 'units': 'C', 'temperature': 26.0,
+        },
+        f'/{_SUB_UUID}/temperature/desired/0': {
+            'range': [18.0, 30.0], 'units': 'C', 'temperature': 24.0,
+        },
+        # Cold-tier -- not covered by _run_subpolls, so this is the href
+        # that actually depends on _poll_subdevice_flat_hrefs to ever
+        # refresh at all.
+        f'/{_SUB_UUID}/option/autoclean/vs/0': {
+            'x.com.samsung.da.settingStatus': 'Off',
+        },
+    }
+    coordinator = _coordinator(hass)
+    await _discover_with(coordinator, resources, oic_res, seeds)
+
+    assert [su.key for su in coordinator.subdevices] == [_SUB_UUID]
+    subdevice = coordinator.subdevices[0]
+    assert subdevice.seed_path == ()
+    assert subdevice.flat_hrefs != ()
+
+    sub_climate = _climate_bound(coordinator, _SUB_UUID)
+    assert sub_climate is not None
+
+    # Re-poll: a fresh reading under the prefix should reach
+    # canonical_resources through _poll_subdevice_seed's flat-mode branch,
+    # not just sit frozen at the one-time enumeration snapshot.
+    coordinator._session.seeds[f'/{_SUB_UUID}/temperature/current/0'] = {
+        'range': [18.0, 30.0], 'units': 'C', 'temperature': 27.5,
+    }
+    coordinator._session.seeds[f'/{_SUB_UUID}/option/autoclean/vs/0'] = {
+        'x.com.samsung.da.settingStatus': 'On',
+    }
+    refreshed = coordinator._poll_subdevice_seed(subdevice)
+
+    # The warm-tier temperature href is skipped here -- already covered by
+    # _run_subpolls at a faster cadence -- so it does NOT show up refreshed
+    # through this path.
+    assert f'/{_SUB_UUID}/temperature/current/0' not in refreshed
+    assert refreshed == {
+        f'/{_SUB_UUID}/option/autoclean/vs/0': {'x.com.samsung.da.settingStatus': 'On'},
+    }
+
+    for href, rep in refreshed.items():
+        coordinator._observe.apply(href, rep, source='poll')
+    res = coordinator.canonical_resources(subdevice)
+    assert res['/option/autoclean/vs/0']['x.com.samsung.da.settingStatus'] == 'On'
+    # Confirms the skip is about redundant re-fetching, not stale data --
+    # the warm-tier value from initial discovery is still there, untouched.
+    assert res['/temperature/current/0']['temperature'] == 26.0
+
+
+class _FakeCollectionSession:
+    """Minimal session that only ever answers a Collection GET -- used to
+    prove the flat-mode re-poll path (issue #205) is only taken when
+    flat_hrefs is actually set, not whenever seed_path happens to be
+    unusual."""
+
+    def __init__(self, table):
+        self.table = table
+        self.calls: list[tuple[str, ...]] = []
+
+    def get(self, path, timeout=10.0):
+        self.calls.append(tuple(path))
+        body = self.table.get(tuple(path))
+        if body is None:
+            return 0x84, b''
+        import cbor2
+        return 0x45, cbor2.dumps(body)
+
+    def pace(self):
+        pass
+
+
+def test_poll_subdevice_seed_collection_mode_unaffected_by_flat_fallback(
+    hass: HomeAssistant,
+):
+    """A subdevice with a working Collection endpoint (flat_hrefs empty)
+    keeps re-polling it with a single Collection GET, unchanged by issue
+    #205's fallback."""
+    from custom_components.localthings.registry.subdevices import Subdevice
+
+    coordinator = _coordinator(hass)
+    devcol_rep = {'rt': ['x.com.samsung.devcol', 'oic.wk.col']}
+    sess = _FakeCollectionSession({
+        (_SUB_UUID, 'device', '0'): [
+            devcol_rep, {'href': '/mode/vs/0', 'rep': {'mode': 'cool'}},
+        ],
+    })
+    coordinator._session = sess
+    subdevice = Subdevice(kind='prefixed', key=_SUB_UUID, seed_path=(_SUB_UUID, 'device', '0'))
+
+    result = coordinator._poll_subdevice_seed(subdevice)
+
+    assert result == {f'/{_SUB_UUID}/mode/vs/0': {'mode': 'cool'}}
+    assert sess.calls == [(_SUB_UUID, 'device', '0')]
+
+
+def test_poll_subdevice_seed_flat_mode_polls_each_href_individually(
+    hass: HomeAssistant,
+):
+    """A flat-mode subdevice (issue #205) has no Collection to batch-refresh
+    through, so each confirmed href is GET individually under the prefix on
+    every re-poll -- a href that stops answering just drops out, same
+    "never fail the master's poll over a sibling" posture as the Collection
+    path."""
+    from custom_components.localthings.registry.subdevices import Subdevice
+
+    coordinator = _coordinator(hass)
+    sess = _FakeCollectionSession({
+        (_SUB_UUID, 'mode', 'vs', '0'): {'mode': 'cool'},
+        # (_SUB_UUID, 'power', 'vs', '0') deliberately absent -> drops out.
+    })
+    coordinator._session = sess
+    subdevice = Subdevice(
+        kind='prefixed', key=_SUB_UUID, seed_path=(),
+        flat_hrefs=('/mode/vs/0', '/power/vs/0'),
+    )
+
+    result = coordinator._poll_subdevice_seed(subdevice)
+
+    assert result == {f'/{_SUB_UUID}/mode/vs/0': {'mode': 'cool'}}
+    assert sess.calls == [
+        (_SUB_UUID, 'mode', 'vs', '0'), (_SUB_UUID, 'power', 'vs', '0'),
+    ]
+
+
+def test_poll_subdevice_seed_flat_mode_skips_hrefs_covered_by_hot_warm_subpolls(
+    hass: HomeAssistant,
+):
+    """A flat href already in the hot/warm sub-poll tiers is refreshed every
+    few seconds by _run_subpolls -- re-fetching it again on this
+    once-per-summary-poll pass would only add GETs, not freshness, so
+    _poll_subdevice_flat_hrefs must not even attempt it."""
+    from custom_components.localthings.registry.subdevices import Subdevice
+
+    coordinator = _coordinator(hass)
+    sess = _FakeCollectionSession({
+        (_SUB_UUID, 'mode', 'vs', '0'): {'mode': 'cool'},
+        (_SUB_UUID, 'power', 'vs', '0'): {'power': 'On'},
+    })
+    coordinator._session = sess
+    coordinator._warm_hrefs = [f'/{_SUB_UUID}/mode/vs/0']
+    subdevice = Subdevice(
+        kind='prefixed', key=_SUB_UUID, seed_path=(),
+        flat_hrefs=('/mode/vs/0', '/power/vs/0'),
+    )
+
+    result = coordinator._poll_subdevice_seed(subdevice)
+
+    assert result == {f'/{_SUB_UUID}/power/vs/0': {'power': 'On'}}
+    assert sess.calls == [(_SUB_UUID, 'power', 'vs', '0')]
+
+
+async def test_multidevice_probe_never_reaches_discovery_or_the_cache(
+    hass: HomeAssistant,
+):
+    """/multidevice/vs/0 is probed on every device but is metadata, not state.
+
+    It has to stay out of the resources dict on both counts. Discovery would
+    otherwise report it as an unbound href on every family whose registry
+    doesn't ignore that path -- only the AC one does -- raising a spurious
+    "incomplete capability coverage" repair for, say, a washer whose
+    firmware happens to answer it. And nothing polls it after discovery, so
+    anything applied to the state cache would sit frozen there forever.
+
+    Driven with a washer fixture precisely because the AC registry's own
+    ignore entry would mask the coverage half of this on an AC.
+    """
+    resources, _oic, _seeds = _load_device_full('washer_flexwash')
+    coordinator = _coordinator(hass)
+    coordinator._session = FakeCoapSession({
+        '/multidevice/vs/0': {'x.com.samsung.da.numofsubdevice': '2'},
+    })
+    coordinator._identity = DeviceIdentity(
+        manufacturer='Samsung Electronics', model='', name='', serial=None,
+        device_types=(), raw={'/oic/p': {}, '/oic/d': {}, '/oic/res': []},
+    )
+    merged = await hass.async_add_executor_job(
+        coordinator._enumerate_subdevices_blocking, resources,
+    )
+    coordinator._run_discovery(merged)
+    for href, rep in coordinator._live_subdevice_resources(merged).items():
+        coordinator._observe.apply(href, rep, source='poll')
+
+    assert '/multidevice/vs/0' not in merged
+    assert '/multidevice/vs/0' not in coordinator._unbound_hrefs
+    assert '/multidevice/vs/0' not in coordinator.last_resources
+    # Still captured, just not as device state.
+    assert coordinator._multidevice == {'x.com.samsung.da.numofsubdevice': '2'}

tests/test_subdevices.py

@@ -0,0 +1,681 @@
+"""Tests for registry/subdevices.py -- multi-indoor-subdevice ("composite
+device") support, issue #177. See DESIGN-177.md for the two board patterns
+(`ARTIK051_DONGLE_FAC_18K`'s indexed siblings, `TP2X_FAC_BORA_21K`'s
+UUID-prefixed tree) this module unifies.
+"""
+from __future__ import annotations
+
+import cbor2
+
+from custom_components.localthings.registry.capability import Capability
+from custom_components.localthings.registry.entities import BinarySensorDesc, SensorDesc
+from custom_components.localthings.registry.subdevices import (
+    MAIN, Subdevice, canonical_view, discover_partitioned, enumerate_subdevices,
+    normalize_seed_batch,
+)
+
+_UUID = '6c2dff6d-ee5c-dad1-6a5e-000000000001'
+
+
+def _indexed(n: str) -> Subdevice:
+    return Subdevice(kind='indexed', key=n, seed_path=('device', n))
+
+
+def _prefixed(sub_id: str) -> Subdevice:
+    return Subdevice(kind='prefixed', key=sub_id, seed_path=(sub_id, 'device', '0'))
+
+
+# ---------------------------------------------------------------------------
+# Subdevice.to_actual / to_canonical / owns / key_prefix
+# ---------------------------------------------------------------------------
+
+class TestMainIsIdentity:
+    def test_to_actual_unchanged(self):
+        assert MAIN.to_actual('/mode/vs/0') == '/mode/vs/0'
+
+    def test_to_canonical_unchanged(self):
+        assert MAIN.to_canonical('/mode/vs/0') == '/mode/vs/0'
+
+    def test_owns_is_always_false(self):
+        """MAIN never "owns" a href by this definition -- it gets whatever's
+        left after every other subdevice's hrefs are excluded (canonical_view)."""
+        assert MAIN.owns('/mode/vs/0') is False
+        assert MAIN.owns('/mode/vs/1') is False
+
+    def test_key_prefix_is_empty(self):
+        """The master's flattened state keys must stay byte-identical
+        to every device shipped before issue #177 -- see adapter._key."""
+        assert MAIN.key_prefix == ''
+
+
+class TestIndexedTransform:
+    def test_to_actual_rewrites_trailing_zero(self):
+        subdevice = _indexed('1')
+        assert subdevice.to_actual('/mode/vs/0') == '/mode/vs/1'
+        assert subdevice.to_actual('/device/0') == '/device/1'
+
+    def test_to_actual_leaves_non_zero_trailing_segment_alone(self):
+        """Deliberately not a "replace any trailing digit" rule -- a genuine
+        multi-instance resource (the fridge's pattern-cap hrefs, e.g.
+        '/door/vs/1') must not be misread as a subdevice's own href."""
+        subdevice = _indexed('1')
+        assert subdevice.to_actual('/door/vs/1') == '/door/vs/1'
+
+    def test_to_canonical_round_trips(self):
+        subdevice = _indexed('1')
+        assert subdevice.to_canonical(subdevice.to_actual('/mode/vs/0')) == '/mode/vs/0'
+
+    def test_to_canonical_rejects_wrong_index(self):
+        subdevice = _indexed('1')
+        assert subdevice.to_canonical('/mode/vs/2') is None
+
+    def test_to_canonical_rejects_index_zero(self):
+        """Index 0 belongs to MAIN, never to an indexed subdevice."""
+        subdevice = _indexed('1')
+        assert subdevice.to_canonical('/mode/vs/0') is None
+
+    def test_owns(self):
+        subdevice = _indexed('1')
+        assert subdevice.owns('/mode/vs/1') is True
+        assert subdevice.owns('/mode/vs/0') is False
+        assert subdevice.owns('/mode/vs/2') is False
+
+    def test_key_prefix(self):
+        assert _indexed('1').key_prefix == 'subdevice1_'
+        assert _indexed('2').key_prefix == 'subdevice2_'
+
+
+class TestPrefixedTransform:
+    def test_to_actual_prepends_id(self):
+        subdevice = _prefixed(_UUID)
+        assert subdevice.to_actual('/mode/vs/0') == f'/{_UUID}/mode/vs/0'
+
+    def test_to_canonical_round_trips(self):
+        subdevice = _prefixed(_UUID)
+        assert subdevice.to_canonical(subdevice.to_actual('/mode/vs/0')) == '/mode/vs/0'
+
+    def test_to_canonical_rejects_missing_prefix(self):
+        subdevice = _prefixed(_UUID)
+        assert subdevice.to_canonical('/mode/vs/0') is None
+
+    def test_to_canonical_requires_path_boundary(self):
+        """A different, longer id that merely starts with the same
+        characters must not be mistaken for this one's own href."""
+        subdevice = _prefixed(_UUID)
+        assert subdevice.to_canonical(f'/{_UUID}extra/mode/vs/0') is None
+
+    def test_owns(self):
+        subdevice = _prefixed(_UUID)
+        assert subdevice.owns(f'/{_UUID}/mode/vs/0') is True
+        assert subdevice.owns('/mode/vs/0') is False
+
+    def test_key_prefix_strips_non_alphanumerics(self):
+        assert _prefixed(_UUID).key_prefix == 'subdevice_6c2dff6dee5cdad16a5e000000000001_'
+
+
+# ---------------------------------------------------------------------------
+# canonical_view
+# ---------------------------------------------------------------------------
+
+class TestCanonicalView:
+    def test_main_with_no_subdevices_is_unchanged(self):
+        resources = {'/mode/vs/0': {'a': 1}, '/power/vs/0': {'b': 2}}
+        assert canonical_view(MAIN, resources, []) == resources
+
+    def test_main_excludes_subdevice_owned_hrefs(self):
+        """A sibling's own /mode/vs/1 must not leak into the master's
+        canonical /mode/vs/0 view -- otherwise exists_fn/is_legacy_board
+        checks that scan the whole dict would see two subdevices' state mixed
+        together under one key."""
+        resources = {
+            '/mode/vs/0': {'unit': 'main'},
+            '/mode/vs/1': {'unit': 'sibling'},
+        }
+        sub1 = _indexed('1')
+        view = canonical_view(MAIN, resources, [sub1])
+        assert view == {'/mode/vs/0': {'unit': 'main'}}
+
+    def test_indexed_view_is_rewritten_to_canonical_hrefs(self):
+        resources = {
+            '/mode/vs/0': {'unit': 'main'},
+            '/mode/vs/1': {'unit': 'sibling'},
+            '/power/vs/1': {'p': 'On'},
+        }
+        sub1 = _indexed('1')
+        view = canonical_view(sub1, resources, [sub1])
+        assert view == {
+            '/mode/vs/0': {'unit': 'sibling'},
+            '/power/vs/0': {'p': 'On'},
+        }
+
+    def test_prefixed_view_is_rewritten_to_canonical_hrefs(self):
+        resources = {
+            f'/{_UUID}/mode/vs/0': {'unit': 'sub'},
+            '/mode/vs/0': {'unit': 'main'},
+        }
+        subdevice = _prefixed(_UUID)
+        view = canonical_view(subdevice, resources, [subdevice])
+        assert view == {'/mode/vs/0': {'unit': 'sub'}}
+
+    def test_including_main_in_subdevices_is_harmless(self):
+        """MAIN.owns() is always False, so passing the full roster
+        (including MAIN itself) to canonical_view must not change anything."""
+        resources = {'/mode/vs/0': {'unit': 'main'}, '/mode/vs/1': {'unit': 'sib'}}
+        sub1 = _indexed('1')
+        assert (canonical_view(MAIN, resources, [MAIN, sub1])
+                == canonical_view(MAIN, resources, [sub1]))
+
+
+# ---------------------------------------------------------------------------
+# normalize_seed_batch
+# ---------------------------------------------------------------------------
+
+def test_normalize_seed_batch_indexed_is_a_no_op():
+    subdevice = _indexed('1')
+    batch = {'/mode/vs/1': {'a': 1}}
+    assert normalize_seed_batch(subdevice, batch) == batch
+
+
+def test_normalize_seed_batch_prefixed_adds_missing_prefix():
+    subdevice = _prefixed(_UUID)
+    batch = {'/mode/vs/0': {'a': 1}}
+    assert normalize_seed_batch(subdevice, batch) == {f'/{_UUID}/mode/vs/0': {'a': 1}}
+
+
+def test_normalize_seed_batch_prefixed_leaves_already_prefixed_alone():
+    subdevice = _prefixed(_UUID)
+    batch = {f'/{_UUID}/mode/vs/0': {'a': 1}}
+    assert normalize_seed_batch(subdevice, batch) == batch
+
+
+# ---------------------------------------------------------------------------
+# enumerate_subdevices
+# ---------------------------------------------------------------------------
+
+class _FakeSession:
+    """path-tuple -> raw batch list, cbor-encoded on GET -- same shape as
+    test_identity.py's FakeSession, extended to serve Collection batches
+    (a CBOR list), not just a bare Property map."""
+
+    def __init__(self, table):
+        self.table = table
+
+    def get(self, path, timeout=10.0):
+        body = self.table.get(tuple(path))
+        if body is None:
+            return 0x84, b''
+        return 0x45, cbor2.dumps(body)
+
+    def pace(self):
+        pass
+
+
+_DEVCOL_REP = {'rt': ['x.com.samsung.devcol', 'oic.wk.col']}
+
+
+def test_enumerate_indexed_from_oic_res_links():
+    oic_res = [{'di': 'aaaa', 'links': [
+        {'href': '/device/0'}, {'href': '/device/1'}, {'href': '/device/2'},
+    ]}]
+    sess = _FakeSession({
+        ('device', '1'): [_DEVCOL_REP, {'href': '/mode/vs/1', 'rep': {'m': 1}}],
+        ('device', '2'): [_DEVCOL_REP, {'href': '/mode/vs/2', 'rep': {'m': 2}}],
+    })
+    subdevices, extra = enumerate_subdevices(sess, {}, oic_res)
+    assert sorted((u.kind, u.key) for u in subdevices) == [
+        ('indexed', '1'), ('indexed', '2'),
+    ]
+    assert extra == {'/mode/vs/1': {'m': 1}, '/mode/vs/2': {'m': 2}}
+
+
+def test_enumerate_indexed_falls_back_to_speculative_probe_when_oic_res_hides_the_tree():
+    """A board whose /oic/res doesn't reveal a second logical Device (e.g.
+    it hides the whole tree, TP2X_FAC_BORA_21K-style) falls back to probing
+    /device/1 and /device/2 directly -- the same bound the old
+    identity.py-level probe used."""
+    sess = _FakeSession({
+        ('device', '1'): [_DEVCOL_REP, {'href': '/mode/vs/1', 'rep': {'m': 1}}],
+        # /device/2 not in the table -> 4.04 -> not materialized.
+    })
+    subdevices, extra = enumerate_subdevices(sess, {}, oic_res_links=[])
+    assert [(u.kind, u.key) for u in subdevices] == [('indexed', '1')]
+    assert extra == {'/mode/vs/1': {'m': 1}}
+
+
+def test_enumerate_indexed_only_materializes_subdevices_with_a_non_empty_batch():
+    """Per issue #177's design call: any seed that answers with a non-empty
+    batch is materialized, but an empty ({}) answer is not -- no separate
+    "is this subdevice real" gate."""
+    sess = _FakeSession({})   # neither /device/1 nor /device/2 answers
+    subdevices, extra = enumerate_subdevices(sess, {}, oic_res_links=[])
+    assert subdevices == []
+    assert extra == {}
+
+
+def test_enumerate_prefixed_from_subdevice_id_list():
+    resources = {
+        '/subdevices/vs/0': {'x.com.samsung.da.subdeviceIdList': [_UUID]},
+    }
+    sess = _FakeSession({
+        (_UUID, 'device', '0'): [
+            _DEVCOL_REP, {'href': '/mode/vs/0', 'rep': {'m': 'cool'}},
+        ],
+    })
+    subdevices, extra = enumerate_subdevices(sess, resources, oic_res_links=[])
+    assert [(u.kind, u.key) for u in subdevices] == [('prefixed', _UUID)]
+    # Batch echoed the bare (unprefixed) href -- normalized to carry the id.
+    assert extra == {f'/{_UUID}/mode/vs/0': {'m': 'cool'}}
+
+
+def test_enumerate_prefixed_falls_back_to_flat_hrefs_when_device0_collection_is_empty():
+    """issue #205: not every prefixed subdevice exposes its own
+    /<uuid>/device/0 Collection -- not even TP2X_FAC_BORA_21K, the board
+    this pattern was built against, always does. When it doesn't,
+    enumeration probes every href the master itself answered this cycle,
+    individually, under the UUID prefix, and keeps whichever ones answer."""
+    resources = {
+        '/subdevices/vs/0': {'x.com.samsung.da.subdeviceIdList': [_UUID]},
+        '/mode/vs/0': {'m': 'cool'},
+        '/power/vs/0': {'p': 'On'},
+    }
+    sess = _FakeSession({
+        # (_UUID, 'device', '0') deliberately absent -> Collection probe fails.
+        (_UUID, 'mode', 'vs', '0'): {'mode': 'cool'},
+        # (_UUID, 'power', 'vs', '0') deliberately absent -> drops out.
+    })
+    subdevices, extra = enumerate_subdevices(sess, resources, oic_res_links=[])
+    assert len(subdevices) == 1
+    subdevice = subdevices[0]
+    assert (subdevice.kind, subdevice.key) == ('prefixed', _UUID)
+    assert subdevice.seed_path == ()
+    assert subdevice.flat_hrefs == ('/mode/vs/0',)
+    assert extra == {f'/{_UUID}/mode/vs/0': {'mode': 'cool'}}
+
+
+def test_enumerate_prefixed_flat_fallback_materializes_nothing_when_no_href_answers():
+    """Same posture as every other candidate check in this module: nothing
+    answering means no candidate, not a crash."""
+    resources = {
+        '/subdevices/vs/0': {'x.com.samsung.da.subdeviceIdList': [_UUID]},
+        '/mode/vs/0': {'m': 'cool'},
+    }
+    subdevices, extra = enumerate_subdevices(_FakeSession({}), resources, oic_res_links=[])
+    assert subdevices == []
+    assert extra == {}
+
+
+def test_enumerate_prefixed_flat_fallback_probe_log_reports_every_href_tried():
+    resources = {
+        '/subdevices/vs/0': {'x.com.samsung.da.subdeviceIdList': [_UUID]},
+        '/mode/vs/0': {'m': 'cool'},
+    }
+    sess = _FakeSession({
+        (_UUID, 'mode', 'vs', '0'): {'mode': 'cool'},
+    })
+    probes: dict[str, bool] = {}
+    enumerate_subdevices(sess, resources, oic_res_links=[], probe_log=probes.__setitem__)
+    assert probes[f'/{_UUID}/device/0'] is False
+    assert probes[f'/{_UUID}/mode/vs/0'] is True
+
+
+def test_enumerate_prefixed_flat_fallback_with_no_master_hrefs_to_probe_is_a_no_op():
+    """The master itself having nothing but /subdevices/vs/0 in its own
+    resources this cycle (e.g. a very first, mostly-empty poll) must not
+    crash the fallback loop -- the only href in `resources` is
+    /subdevices/vs/0 itself, which the fake session doesn't answer under
+    the prefix either, so nothing materializes."""
+    resources = {
+        '/subdevices/vs/0': {'x.com.samsung.da.subdeviceIdList': [_UUID]},
+    }
+    subdevices, extra = enumerate_subdevices(_FakeSession({}), resources, oic_res_links=[])
+    assert subdevices == []
+    assert extra == {}
+
+
+def test_enumerate_prefixed_flat_fallback_does_not_cross_contaminate_a_second_uuid():
+    """Two prefixed candidates in the same subdeviceIdList, one whose
+    Collection endpoint works and one that needs the flat fallback -- each
+    must end up with only its own hrefs, no bleed between them."""
+    uuid_a, uuid_b = _UUID, '11111111-1111-1111-1111-111111111111'
+    resources = {
+        '/subdevices/vs/0': {'x.com.samsung.da.subdeviceIdList': [uuid_a, uuid_b]},
+        '/mode/vs/0': {'m': 'cool'},
+    }
+    sess = _FakeSession({
+        (uuid_a, 'device', '0'): [
+            _DEVCOL_REP, {'href': '/mode/vs/0', 'rep': {'m': 'a-collection'}},
+        ],
+        # uuid_b's Collection deliberately absent -> falls back to the flat
+        # per-href probe.
+        (uuid_b, 'mode', 'vs', '0'): {'m': 'b-flat'},
+    })
+    subdevices, extra = enumerate_subdevices(sess, resources, oic_res_links=[])
+
+    by_key = {u.key: u for u in subdevices}
+    assert set(by_key) == {uuid_a, uuid_b}
+    assert by_key[uuid_a].seed_path == (uuid_a, 'device', '0')
+    assert by_key[uuid_a].flat_hrefs == ()
+    assert by_key[uuid_b].seed_path == ()
+    assert by_key[uuid_b].flat_hrefs == ('/mode/vs/0',)
+    assert extra == {
+        f'/{uuid_a}/mode/vs/0': {'m': 'a-collection'},
+        f'/{uuid_b}/mode/vs/0': {'m': 'b-flat'},
+    }
+
+
+def test_enumerate_prefixed_tolerates_redacted_string_id_list():
+    """subdeviceIdList matches redact.py's 'deviceid' substring rule, and the
+    real airconditioner_fac_bora_device.json fixture carries the literal
+    redacted string there -- this must yield zero subdevices, not crash."""
+    resources = {
+        '/subdevices/vs/0': {'x.com.samsung.da.subdeviceIdList': 'REDACTED'},
+    }
+    subdevices, extra = enumerate_subdevices(_FakeSession({}), resources, oic_res_links=[])
+    assert subdevices == []
+    assert extra == {}
+
+
+def test_enumerate_no_subdevices_resource_at_all():
+    subdevices, extra = enumerate_subdevices(_FakeSession({}), {}, oic_res_links=[])
+    assert subdevices == []
+    assert extra == {}
+
+
+def test_enumerate_indexed_materializes_candidate_regardless_of_content():
+    """enumerate_subdevices itself has no way to tell a real sibling from an
+    unused slot that merely answers the same shape (the reporter's
+    /device/2) -- that's discover_partitioned's job (see its own tests
+    below). A same-shaped batch of otherwise-empty reps is still returned
+    as a candidate here."""
+    oic_res = [{'di': 'a', 'links': [{'href': '/device/2'}]}]
+    sess = _FakeSession({
+        ('device', '2'): [_DEVCOL_REP, {'href': '/power/vs/2', 'rep': {}},
+                           {'href': '/configuration/vs/2', 'rep': {'region': '123'}}],
+    })
+    subdevices, extra = enumerate_subdevices(sess, {}, oic_res)
+    assert [(u.kind, u.key) for u in subdevices] == [('indexed', '2')]
+    assert extra == {'/power/vs/2': {}, '/configuration/vs/2': {'region': '123'}}
+
+
+def test_enumerate_probe_log_reports_every_attempt():
+    oic_res = [{'di': 'aaaa', 'links': [{'href': '/device/1'}]}]
+    sess = _FakeSession({
+        ('device', '1'): [_DEVCOL_REP, {'href': '/mode/vs/1', 'rep': {'m': 1}}],
+    })
+    probes: dict[str, bool] = {}
+    enumerate_subdevices(sess, {}, oic_res, probe_log=probes.__setitem__)
+    # /multidevice/vs/0 is always probed too (issue #177 follow-up) -- not
+    # in this session's table, so it reports "checked, nothing there".
+    assert probes == {'/device/1': True, '/multidevice/vs/0': False}
+
+
+def test_enumerate_probe_log_reports_empty_answers_too():
+    """Distinguishes "checked, nothing there" from "never checked" (the
+    posture the speculative-probe code this replaced used to document
+    directly in identity.py)."""
+    probes: dict[str, bool] = {}
+    enumerate_subdevices(_FakeSession({}), {}, oic_res_links=[], probe_log=probes.__setitem__)
+    assert probes == {
+        '/device/1': False, '/device/2': False, '/multidevice/vs/0': False,
+    }
+
+
+def test_enumerate_multidevice_vs_0_is_captured_for_diagnostics_not_a_gate():
+    """/multidevice/vs/0 (issue #177 follow-up) is corroborating evidence
+    only -- captured into the merged resources so diagnostics can report
+    it, never consulted by the liveness gate itself."""
+    sess = _FakeSession({
+        ('multidevice', 'vs', '0'): {'x.com.samsung.da.numofsubdevice': '2'},
+    })
+    subdevices, extra = enumerate_subdevices(sess, {}, oic_res_links=[])
+    assert subdevices == []   # no /device/<n> or subdevice id answered
+    assert extra == {
+        '/multidevice/vs/0': {'x.com.samsung.da.numofsubdevice': '2'},
+    }
+
+
+def test_enumerate_both_patterns_checked_independently():
+    """No board needs disambiguation logic -- enumeration just checks both
+    signals and takes whatever answers."""
+    resources = {
+        '/subdevices/vs/0': {'x.com.samsung.da.subdeviceIdList': [_UUID]},
+    }
+    oic_res = [{'di': 'a', 'links': [{'href': '/device/1'}]}]
+    sess = _FakeSession({
+        (_UUID, 'device', '0'): [_DEVCOL_REP, {'href': '/mode/vs/0', 'rep': {'m': 1}}],
+        ('device', '1'): [_DEVCOL_REP, {'href': '/mode/vs/1', 'rep': {'m': 2}}],
+    })
+    subdevices, extra = enumerate_subdevices(sess, resources, oic_res)
+    assert sorted((u.kind, u.key) for u in subdevices) == [
+        ('indexed', '1'), ('prefixed', _UUID),
+    ]
+
+
+# ---------------------------------------------------------------------------
+# discover_partitioned
+# ---------------------------------------------------------------------------
+
+class _FakeRegistry:
+    def __init__(self, name, capabilities, pattern_capabilities=()):
+        self.name = name
+        self.capabilities = capabilities
+        self.pattern_capabilities = list(pattern_capabilities)
+
+
+def test_discover_partitioned_binds_main_and_subdevice_separately():
+    mode_cap = Capability(
+        href='/mode/vs/0',
+        entities=(BinarySensorDesc(key='mode', field='m'),),
+    )
+    registry = {'/mode/vs/0': [mode_cap]}
+    reg = _FakeRegistry('airconditioner', registry)
+
+    sub1 = _indexed('1')
+    resources = {
+        '/mode/vs/0': {'m': 'main'},
+        '/mode/vs/1': {'m': 'sibling'},
+    }
+
+    def resolve(_resources):
+        return reg
+
+    bound, device_type_name, materialized, skipped = discover_partitioned(
+        resources, [sub1], resolve, fallback_capabilities={},
+    )
+
+    assert device_type_name == 'airconditioner'
+    assert materialized == [sub1]
+    assert skipped == []
+    by_href = {b.href: b for b in bound}
+    assert set(by_href) == {'/mode/vs/0', '/mode/vs/1'}
+    assert by_href['/mode/vs/0'].subdevice == MAIN
+    assert by_href['/mode/vs/1'].subdevice == sub1
+
+
+def test_discover_partitioned_main_pass_excludes_subdevice_hrefs_from_unbound():
+    """A subdevice's own /mode/vs/1 must not land in the main pass's unbound
+    list -- otherwise it raises a spurious coverage-gap repair for a href
+    nothing in the main registry claims literally, even though the *same*
+    canonical /mode/vs/0 href is properly claimed for both subdevices.
+
+    A registry that binds /mode/vs/0 (so both the main pass and the
+    subdevice pass over their own canonical views have something to claim
+    it) makes this unambiguous: if partitioning were broken -- e.g. the
+    main pass iterating unfiltered `resources` instead of `main_view` --
+    /mode/vs/1 would show up in `unbound` because nothing in the registry
+    is keyed on the literal string '/mode/vs/1'. With correct partitioning
+    the main pass never sees that href at all (canonical_view excludes it),
+    and the subdevice pass resolves it via its own canonical '/mode/vs/0'."""
+    cap = Capability(href='/mode/vs/0', entities=(BinarySensorDesc(key='mode', field='m'),))
+    reg = _FakeRegistry('airconditioner', {'/mode/vs/0': [cap]})
+    sub1 = _indexed('1')
+    resources = {
+        '/mode/vs/0': {'m': 'main'},
+        '/mode/vs/1': {'m': 'sibling'},
+    }
+
+    unbound = []
+    discover_partitioned(
+        resources, [sub1], lambda r: reg, fallback_capabilities={},
+        log=unbound.append,
+    )
+    assert unbound == []
+
+
+def test_discover_partitioned_subdevice_resolves_its_own_registry():
+    """A subdevice reporting its own /information/vs/0 resolves its own
+    device type (issue #177's real wall subdevice: TP2X_FAC_BORA_RAC_21K ->
+    RAC -> airconditioner) independent of the master's."""
+    main_cap = Capability(href='/mode/vs/0', entities=(BinarySensorDesc(key='m', field='x'),))
+    sub_cap = Capability(href='/mode/vs/0', entities=(BinarySensorDesc(key='m2', field='x'),))
+    main_reg = _FakeRegistry('main_type', {'/mode/vs/0': [main_cap]})
+    sub_reg = _FakeRegistry('sub_type', {'/mode/vs/0': [sub_cap]})
+
+    sub1 = _indexed('1')
+    resources = {'/mode/vs/0': {'x': 1}, '/mode/vs/1': {'x': 2}}
+
+    def resolve(view):
+        # The subdevice's canonical view is exactly {'/mode/vs/0': {'x': 2}}.
+        return sub_reg if view.get('/mode/vs/0', {}).get('x') == 2 else main_reg
+
+    bound, device_type_name, materialized, skipped = discover_partitioned(
+        resources, [sub1], resolve, fallback_capabilities={},
+    )
+    assert device_type_name == 'main_type'
+    assert materialized == [sub1]
+    assert skipped == []
+    keys = {(b.href, b.desc.key) for b in bound}
+    assert ('/mode/vs/0', 'm') in keys
+    assert ('/mode/vs/1', 'm2') in keys
+
+
+def test_discover_partitioned_subdevice_falls_back_to_master_registry():
+    """A subdevice that reports no identity of its own resolves through the
+    master's registry instead of the global fallback -- the master itself
+    must actually resolve here (it reports /information/vs/0), or there is
+    no master registry for the fallback to reach for."""
+    cap = Capability(href='/mode/vs/0', entities=(BinarySensorDesc(key='m', field='x'),))
+    main_reg = _FakeRegistry('airconditioner', {'/mode/vs/0': [cap]})
+    sub1 = _indexed('1')
+    resources = {
+        '/information/vs/0': {'model': 'main'},
+        '/mode/vs/0': {'x': 1},
+        '/mode/vs/1': {'x': 2},
+    }
+
+    def resolve(view):
+        return main_reg if view.get('/information/vs/0') else None
+
+    bound, _, materialized, skipped = discover_partitioned(
+        resources, [sub1], resolve, fallback_capabilities={},
+    )
+    assert materialized == [sub1]
+    assert skipped == []
+    hrefs = {b.href for b in bound}
+    assert '/mode/vs/1' in hrefs
+
+
+def test_discover_partitioned_no_subdevices_matches_plain_discover():
+    """For a device with no subdevices this must be exactly the single
+    discover() call it replaces -- the hard regression guard the whole
+    design exists to protect."""
+    from custom_components.localthings.registry.discovery import discover
+
+    cap = Capability(href='/mode/vs/0', entities=(BinarySensorDesc(key='m', field='x'),))
+    reg = _FakeRegistry('airconditioner', {'/mode/vs/0': [cap]})
+    resources = {'/mode/vs/0': {'x': 1}}
+
+    bound_via_helper, _, materialized, skipped = discover_partitioned(
+        resources, [], lambda r: reg, fallback_capabilities={},
+    )
+    bound_direct = discover(resources, reg.capabilities, reg.pattern_capabilities)
+
+    assert bound_via_helper == bound_direct
+    assert materialized == []
+    assert skipped == []
+
+
+# ---------------------------------------------------------------------------
+# discover_partitioned's materialization gate: a candidate is only kept if
+# it produced at least one *primary* (no entity_category) bound entity whose
+# flattened value isn't None. This is what tells the reporter's real
+# /device/1 sibling apart from the unused /device/2 slot that answers the
+# same shape.
+# ---------------------------------------------------------------------------
+
+def test_discover_partitioned_skips_candidate_with_no_live_primary_entity():
+    """A candidate whose only populated entity is diagnostic-category
+    doesn't count -- exactly the reporter's /device/2 shape (an alarm_code
+    sensor reading something even though the subdevice itself is empty)."""
+    diag_cap = Capability(
+        href='/alarms/vs/0',
+        entities=(SensorDesc(key='alarm_code', field='code', entity_category='diagnostic'),),
+    )
+    reg = _FakeRegistry('airconditioner', {'/alarms/vs/0': [diag_cap]})
+    unit2 = _indexed('2')
+    resources = {
+        '/alarms/vs/0': {'code': 'main-alarm'},
+        '/alarms/vs/2': {'code': 'ErrorCode_OFF'},   # populated, but diagnostic-only
+    }
+
+    bound, _, materialized, skipped = discover_partitioned(
+        resources, [unit2], lambda r: reg, fallback_capabilities={},
+    )
+    assert materialized == []
+    assert len(skipped) == 1
+    assert skipped[0].subdevice == unit2
+    assert skipped[0].hrefs == ('/alarms/vs/2',)
+    # The candidate contributes nothing at all -- not even its diagnostic
+    # entity -- once skipped.
+    assert all(b.subdevice != unit2 for b in bound)
+
+
+def test_discover_partitioned_materializes_candidate_with_live_primary_entity():
+    """A candidate with a populated *primary* (no entity_category) entity
+    is materialized, even alongside an all-empty diagnostic sibling href --
+    exactly the reporter's /device/1 shape."""
+    climate_cap = Capability(
+        href='/mode/vs/0',
+        entities=(BinarySensorDesc(key='mode', field='m'),),   # no entity_category -> primary
+    )
+    diag_cap = Capability(
+        href='/alarms/vs/0',
+        entities=(SensorDesc(key='alarm_code', field='code', entity_category='diagnostic'),),
+    )
+    reg = _FakeRegistry(
+        'airconditioner', {'/mode/vs/0': [climate_cap], '/alarms/vs/0': [diag_cap]},
+    )
+    sub1 = _indexed('1')
+    resources = {
+        '/mode/vs/0': {'m': 'main'},
+        '/alarms/vs/0': {'code': 'main-alarm'},
+        '/mode/vs/1': {'m': 'Cool'},
+        '/alarms/vs/1': {},   # empty -- not what makes this subdevice live
+    }
+
+    bound, _, materialized, skipped = discover_partitioned(
+        resources, [sub1], lambda r: reg, fallback_capabilities={},
+    )
+    assert materialized == [sub1]
+    assert skipped == []
+    hrefs = {b.href for b in bound if b.subdevice == sub1}
+    assert hrefs == {'/mode/vs/1', '/alarms/vs/1'}
+
+
+def test_discover_partitioned_skipped_candidate_contributes_no_hot_warm_hrefs():
+    """A skipped candidate's hrefs must not appear via tier_log either --
+    'no entities, no hot/warm hrefs' (the skip is total, not just
+    entity-level)."""
+    cap = Capability(href='/mode/vs/0', poll_tier='warm',
+                      entities=(SensorDesc(key='alarm_code', field='code',
+                                            entity_category='diagnostic'),))
+    reg = _FakeRegistry('airconditioner', {'/mode/vs/0': [cap]})
+    unit2 = _indexed('2')
+    resources = {'/mode/vs/0': {'code': 'x'}, '/mode/vs/2': {'code': 'y'}}
+
+    tiers = []
+    discover_partitioned(
+        resources, [unit2], lambda r: reg, fallback_capabilities={},
+        tier_log=lambda href, tier: tiers.append(href),
+    )
+    assert '/mode/vs/2' not in tiers

tests/test_unique_ids.py

@@ -0,0 +1,82 @@
+"""Corpus-wide invariant: adapter._key must be unique across every bound
+entity that would actually be registered as an HA entity, for every fixture
+in the corpus -- issue #177's whole Subdevice/key_prefix design exists to
+protect this (see DESIGN-177.md section 3/6). Run over the entire fixture
+set, not just the two new subdevice fixtures, so a future dump -- subdevice-
+capable or not -- exercises it automatically.
+"""
+from collections import Counter
+
+import pytest
+
+from custom_components.localthings.entity import _is_included
+from custom_components.localthings.registry.adapter import _key
+from custom_components.localthings.registry.entities import PLATFORM_OF
+
+from tests.conftest import FIXTURES, _discover_full, _load_device_full
+
+_FIXTURE_NAMES = sorted(
+    p.name[:-len('_device.json')] for p in FIXTURES.glob('*_device.json')
+)
+
+
+class _FakeCoordinator:
+    """Just enough of LocalThingsCoordinator's surface for entity.py's
+    _is_included -- the same one-time entity-creation gate every platform's
+    async_setup_entry runs (see entity.py's own module docstring)."""
+
+    def __init__(self, resources: dict[str, dict], subdevices):
+        self.last_resources = resources
+        self._subdevices = list(subdevices)
+
+    def canonical_resources(self, subdevice):
+        from custom_components.localthings.registry.subdevices import canonical_view
+        return canonical_view(subdevice, self.last_resources, self._subdevices)
+
+
+@pytest.mark.parametrize('name', _FIXTURE_NAMES)
+def test_key_is_unique_across_all_bound_entities(name):
+    """`_key(b)` only has to be unique among entities `_is_included` would
+    actually register -- discover() alone can (deliberately) produce two
+    BoundEntity rows sharing a key on the same href when they're gated by
+    mutually-exclusive `exists_fn`s (see fridge.py's
+    REFRIGERATION_FALLBACK.defrost_active, which only exists when
+    DEFROST_BLOCK_STATUS's own `/defrost/block/vs/0` href is absent) --
+    only one of the two is ever actually included for a real device, so
+    checking the raw `bound` list would flag devices that have always
+    worked correctly. It also only has to be unique *within one HA
+    platform* -- unique_id collisions are scoped by (integration, platform)
+    in HA's entity registry (see entity.py's `_attr_unique_id`, which
+    doesn't itself encode the platform), and several devices in this corpus
+    deliberately bind the same key to the same href on two different
+    platforms discriminated the same way (e.g. a SwitchDesc and a
+    BinarySensorDesc both named 'power_switch' on /power/0).
+    """
+    resources, oic_res, seeds = _load_device_full(name)
+    bound, materialized, skipped, full_resources, device_type_name = _discover_full(
+        resources, oic_res, seeds,
+    )
+    coordinator = _FakeCoordinator(full_resources, materialized)
+    included = [b for b in bound if _is_included(b, coordinator)]
+    keys = [(PLATFORM_OF[type(b.desc)], _key(b)) for b in included]
+    dupes = {k: n for k, n in Counter(keys).items() if n > 1}
+    assert not dupes, (
+        f"{name}: duplicate (platform, _key) values across {len(included)} "
+        f"included entities (materialized subdevices: "
+        f"{[su.key for su in materialized]}): {dupes}"
+    )
+
+
+def test_subdevice_capable_fixtures_actually_exercise_a_subdevice():
+    """A meta-check on the test above: if both subdevice fixtures somehow
+    stopped materializing any subdevice (a regression in enumeration or the
+    materialization gate), the corpus-wide uniqueness test above would keep
+    passing vacuously -- it never gets to check a single collision. Assert
+    the two fixtures this design added actually produce a materialized
+    subdevice, so that silent-vacuous-pass failure mode is caught here
+    instead."""
+    for name in ('airconditioner_artik051_dongle_fac_18k',
+                 'airconditioner_fac_bora_2in1'):
+        resources, oic_res, seeds = _load_device_full(name)
+        _, materialized, _, _, _ = _discover_full(resources, oic_res, seeds)
+        assert materialized, f"{name}: expected at least one materialized subdevice"

tests/test_water_purifier_capabilities.py

@@ -295,3 +295,98 @@ def test_coffee_recipe_hrefs_are_ignored_not_guessed():
     for href in ('/brand/recipe/info/vs/0', '/coffee/custom/recipe/vs/0',
                  '/recipe/coffee/vs/0', '/recipe/coffee/deletion/vs/0'):
         assert href in ignored_hrefs, href
+
+
+# ---------------------------------------------------------------------------
+# AILITE_DA-REF-WATERPURIFIER board (issue #196, RWP70F15ANW) -- a
+# coffee-capable variant on a different board family than issue #90/#107's
+# TP2X_WATERPURIFIER_20K, whose modelNum's 'REF' token would otherwise
+# misroute it to the refrigerator registry (see test_by_type.py's
+# TestBoardTokenAmbiguity carve-out). Also the first dump to expose
+# /cup/state/vs/0, /statistic/pour/vs/0, and the settings/sound/* trio on
+# this device type.
+# ---------------------------------------------------------------------------
+
+def _water_purifier_ailite():
+    resources = _load_device('water_purifier_ailite_25k')
+    info = resources['/information/vs/0']
+    reg = for_device_by_model(
+        info['x.com.samsung.da.modelNum'], info['x.com.samsung.da.description'],
+    )
+    return reg, resources
+
+
+def _bound_ailite():
+    reg, resources = _water_purifier_ailite()
+    return discover(resources, reg.capabilities, reg.pattern_capabilities), resources
+
+
+def _state_ailite():
+    bound, resources = _bound_ailite()
+    return flatten(bound, resources)
+
+
+def _desc_ailite(key):
+    bound, _ = _bound_ailite()
+    return next(b.desc for b in bound if b.desc.key == key)
+
+
+def test_ailite_model_resolves_to_water_purifier_not_refrigerator():
+    reg, _ = _water_purifier_ailite()
+    assert reg is not None and reg.name == 'water_purifier'
+
+
+def test_ailite_no_unbound_hrefs():
+    reg, resources = _water_purifier_ailite()
+    unbound = []
+    discover(resources, reg.capabilities, reg.pattern_capabilities, log=unbound.append)
+    assert unbound == []
+
+
+def test_ailite_expected_state_keys_present():
+    state = _state_ailite()
+    for key in ('cup_state', 'sound_mode', 'sound_output', 'sound_volume',
+                'alarm_in_mute', 'last_pour_type', 'last_pour_capacity'):
+        assert key in state, key
+
+
+def test_ailite_hot_water_temperature_gated_off_without_supported_list():
+    """This board reports tempDesiredHotWater but no
+    supportedHotTemperatures (only a hotwaterRange/hotwaterLevel pair whose
+    write contract isn't confirmed) -- the exact shape that used to make
+    HA's select show 'unknown' (issue #196), since current_option isn't in
+    an empty options list. The descriptor must gate off entirely rather than
+    register with empty options."""
+    state = _state_ailite()
+    assert 'hot_water_temperature' not in state
+
+
+def test_ailite_sound_mode_options_come_from_live_supported_modes():
+    """This board's supportedModes (voice/fixedTone/mute) differs from both
+    laundry.SOUND_MODE's hardcoded voice/tone/mute and air_purifier.SOUND_MODE's
+    mute/buzzer -- reusing either would reject a value this device actually
+    supports, per the oven._OVEN_MODES lesson from issue #138."""
+    desc = _desc_ailite('sound_mode')
+    assert desc.options_field == 'supportedModes'
+    assert desc.translation_key == 'water_purifier_sound_mode'
+
+
+def test_ailite_sound_volume_bounds_come_live_not_hardcoded():
+    desc = _desc_ailite('sound_volume')
+    assert isinstance(desc, NumberDesc)
+    assert desc.native_min is None and desc.native_max is None
+    rep = {'minLevel': '0', 'maxLevel': '15', 'resolution': '5'}
+    assert desc.native_min_fn(rep) == 0
+    assert desc.native_max_fn(rep) == 15
+    assert desc.step_fn(rep) == 5
+
+
+def test_ailite_alarm_in_mute_is_read_only():
+    """No sibling field advertises alarmInMute as user-settable -- surfaced
+    as a read-only diagnostic per the 'don't guess' rule rather than an
+    invented switch."""
+    from custom_components.localthings.registry.entities import BinarySensorDesc
+    desc = _desc_ailite('alarm_in_mute')
+    assert isinstance(desc, BinarySensorDesc)
+    assert desc.value_fn('true') is True
+    assert desc.value_fn('false') is False