Merge pull request #401 from vmonkey/feature/add-wash

Add AddWash controls and sensors for washers

CONTRIBUTING.md

@@ -19,6 +19,40 @@ file covers how changes get committed.
   assistant, or tool that helped produce the change. The commit is
   attributed entirely to the accountable human.
 
+## Code comments
+
+This codebase reverse-engineers undocumented device APIs, so comments
+recording *why* a decision was made (a calibration, a rejected write, an
+issue number a quirk was confirmed against) are genuinely valuable — more
+valuable than in most codebases. That's exactly why comments here need
+discipline: it's easy for "explain the reasoning" to slide into "narrate
+the whole investigation," and a file where every line has a paragraph
+under it is as hard to read as one with no comments at all. Keep the
+conclusion; cut the journey.
+
+- **Comment the "why," never the "what."** If a comment just restates what
+  the next line already says, delete it. Code should read clearly enough
+  on its own that comments are only needed for the non-obvious.
+- **One or two sentences, not an essay.** State the conclusion and the one
+  piece of evidence that makes it credible (an issue number, a model name,
+  a single confirming observation). Don't reproduce the full
+  investigation — every dump checked, every attempt that failed, every
+  hypothesis considered and discarded. A future reader needs to trust the
+  conclusion and know where to look if they need to redo the work, not
+  relive it.
+- **A pointer, not a re-derivation.** Cite the issue/model once; don't
+  re-explain a sibling function's already-documented reasoning. Reference
+  it (`same reasoning as X above`) instead of restating it.
+- **Module/class docstrings are a short orientation, not a design doc.**
+  A few lines on purpose and any cross-cutting invariant is enough.
+- **Failed-attempt logs don't belong inline.** If an investigation into an
+  unsolved problem produced real negative results worth preserving (e.g. a
+  reset mechanism nobody could find), put them in an issue or docs, not a
+  block comment several times longer than the code it sits above.
+- **When in doubt, cut.** If deleting a comment wouldn't lose real
+  understanding, it's noise. Prefer trimming an existing comment over
+  adding a new one.
+
 ## For AI coding agents
 
 See `AGENTS.md`.

Dockerfile

@@ -6,4 +6,4 @@ FROM ghcr.io/home-assistant/home-assistant:stable
 # repeats the install attempt on every container recreate. Baking
 # smartthings-local into the image keeps the dev container usable
 # offline and avoids relying on that runtime install path.
-RUN pip3 install --no-cache-dir "smartthings-local>=0.1.2"
+RUN pip3 install --no-cache-dir "smartthings-local>=0.1.8"

README.md

@@ -85,7 +85,7 @@ This repo doesn't include the needed CA bundle. For an example of how to obtain
 5. The flow sends a DTLS `ClientHello` to every port in the `49152-49160` range at once and keeps the one that answers -- a real DTLS server identifies itself in about one round trip, and the probe stops there, so nothing is left behind on the appliance. Only that port is then given a real certificate handshake: it fetches the current UUID from Samsung's cloud gateway, mints a leaf cert signed by your CA, and reads the device's identity and `/device/0`. On success it creates the config entry, already knowing the appliance's serial, model, and type.
 6. Every subsequent device only asks for the host IP. The stored CA credentials are reused, and so is the leaf cert itself -- every appliance accepts the same one -- so adding a second appliance doesn't depend on Samsung's cloud being reachable at all. If a device rejects the reused cert (the UUID behind it does rotate), the flow mints a fresh one and retries by itself.
 
-Entities appear under one HA device per appliance, named for the appliance's type and model. Rename freely: the device is keyed on its serial, not its name.
+Entities appear under one HA device per appliance, named for the appliance's type and model. Rename freely: the device is keyed on the appliance's own OCF device ID, not its name. (Some Samsung models ship the same serial number on every unit of a model, so the serial can't tell two of them apart -- the OCF device ID can.)
 
 ---
 
@@ -95,6 +95,73 @@ Each device has its own **Configure** option in Settings > Devices & Services, u
 
 - **Allow writes even when remote control is reported off** — by default, LocalThings blocks every write with a clear error whenever a device reports remote control off, rather than letting the device silently reject it. Some devices accept certain writes anyway (e.g. default detergent/softener dosing on a washer) even while reporting remote control off. Only enable this if you've confirmed writes actually work on your device with remote control off — otherwise you trade a clear error for a silent failure.
 - **Estimated finish -- minimum change (minutes)** — a washer/dryer/dishwasher's `finish_time` sensor is recomputed from the device's own remaining-time estimate on every poll, which commonly drifts or gets revised by a minute or two between updates. This setting holds `finish_time` at its last reported value until a new estimate differs by at least this many minutes, cutting down on Home Assistant history/logbook noise from a value that hasn't meaningfully changed. Defaults to `3`; set it to `0` to report every computed change.
+- **Remember modes the device reports but doesn't advertise** — some firmware reports a current mode it never lists as supported. Issue #327's air conditioner sits in `Quiet` while offering only `Off/Sleep/Speed/Nano/NanoSleep`, so Home Assistant showed the preset as active but refused to select it. LocalThings remembers any such mode it sees and keeps offering it afterwards, stored on the config entry so it survives a restart — the device only names the mode while it is in it, and you shouldn't have to reach for the physical remote after every reboot. Defaults to on. Turning it off offers only what the device advertises, without discarding what was already learned.
+
+The same **Configure** menu has a **Forget remembered modes** step, which clears what has been learned for that device. Use it if a mode was learned that turns out not to be selectable — otherwise, by design, it stays forever.
+
+---
+
+## Part 5: Reading and writing resources directly
+
+Two HA actions, `localthings.write_resource` and `localthings.read_resource`, talk to a device's OCF resources directly instead of through this integration's entity model. They exist for two overlapping jobs: pinning down a device-specific write contract (the reverse-engineering work `docs/investigations/` and the provenance comments throughout `registry/capabilities/` are all about), and driving a resource this integration doesn't model as an entity yet, without waiting on a release.
+
+Both take a `device_id` (a device picker filtered to this integration) and resolve to exactly one appliance — a target that expands to more than one LocalThings device is rejected rather than silently fanned out across all of them. `href` is always canonical (e.g. `/mode/vs/0`); if the device you targeted is a subdevice — an oven's second cavity, an AC's second indoor unit — it's translated to the real on-the-wire href for you (`/mode/vs/1`, say), and the response reports both forms so there's no ambiguity about what was actually sent.
+
+`write_resource` exists because a single write, one at a time, isn't enough to probe some boards. Issue #300's Samsung wall oven answers `2.04 Changed` to a settings write while idle and then silently reverts it — the write only sticks once a cycle is already running. Finding what actually triggers a cycle needs an *ordered sequence* of writes to different resources, with real delays between them, and a way to check afterward whether anything actually held:
+
+```yaml
+action: localthings.write_resource
+data:
+  device_id: abc123...
+  writes:
+    - href: /mode/vs/0
+      payload:
+        x.com.samsung.da.modes: ["Bake"]
+      settle: 5
+    - href: /operational/state/vs/0
+      payload:
+        x.com.samsung.da.state: "Run"
+  verify_after: 30
+```
+
+Mind the shapes: what you write is sent verbatim, so the field names and types have to be the ones that resource actually uses. `/mode/vs/0` takes `modes` as an *array* on this board; a bare string, or the singular `mode`, is a different field the device will simply ignore. `read_resource` (below) with no `href` is the quickest way to see the real shape of everything before you write to any of it.
+
+Each write in `writes` (1-10 of them) needs `href` and a non-empty `payload`, sent verbatim as a partial-rep POST — this bypasses the remote-control-off block and every `write_fn`/`validate_fn` a normal entity write goes through, and sends exactly the fields you give it, so it can misconfigure your appliance if you get it wrong. `settle` (0-30s, default 0) is how long to wait *after* that write before starting the next one.
+
+By default the whole sequence holds the device session from the first write to the last, settle delays included, so a routine poll or another entity's write can't land between two steps and blur which write the appliance was reacting to. The cost is that nothing else on that device updates until the sequence ends — up to 10 × 30s if you ask for the maximum of both. Set `hold_session_lock: false` to take the session per write and release it across the waits instead, trading that certainty for a device whose entities keep updating throughout.
+
+The response has one `results` entry per write, with `before`/`after` reps and a `changed` flag (every key/value in `payload` present and equal in the immediate readback):
+
+```json
+{
+  "device_id": "abc123...",
+  "results": [
+    {"href": "/mode/vs/0", "actual_href": "/mode/vs/0", "code": "2.04", "raw_code": 68,
+     "accepted": true, "before": {...}, "after": {...}, "changed": true},
+    ...
+  ],
+  "verified": {
+    "/mode/vs/0": {"code": "2.05", "raw_code": 69, "rep": {...}, "held": false}
+  }
+}
+```
+
+`verify_after` (0-60s, default 0, omit to skip) is what actually answers the "did it stick" question: after the sequence finishes, it waits that long and then re-reads every distinct href the sequence touched, reporting the result under `verified`, keyed by canonical href. `changed` tells you the write was accepted and reflected immediately; `held` tells you whether it was still there N seconds later, or whether the board quietly put it back — issue #300's exact symptom. Where an href was written more than once in a sequence, `held` compares against the *last* payload sent to it. A `held` of `null` means the re-read itself didn't come back (check `code` next to it) — unknown, deliberately not reported as a revert.
+
+If the session drops partway through a sequence, the action raises rather than returning, and the error names how many writes completed and which — the appliance is left holding a partial sequence, so knowing where it stopped is the difference between a usable result and starting over blind.
+
+`read_resource` is the read half, and it's deliberately not just a cache lookup:
+
+```yaml
+action: localthings.read_resource
+data:
+  device_id: abc123...
+  href: /mode/vs/0
+```
+
+returning `{"href", "actual_href", "code", "raw_code", "rep"}` off a **live GET straight from the device**, not the cache — which can be up to a poll interval stale, exactly the staleness that would make `held` above meaningless. A sixth key, `body`, appears only when the response isn't a Property map: a Collection (`/device/0`, and the `x.com.samsung.devcol` siblings some boards expose) answers a CBOR list, which `rep` can't carry, and which would otherwise read as an accepted-but-empty resource. Omit `href` and you get `{"resources": {href: rep, ...}}`, the cached snapshot of everything this integration currently tracks on that device, with no GET at all — useful for seeing what's there before you start writing to it, without hammering the appliance.
+
+The **Debug write** panel under a device's Configure menu (Part 4) is the friendlier single-write path over this same machinery — pick an href, type a payload, see the result — for when you don't need a sequence.
 
 ---
 
@@ -135,6 +202,8 @@ custom_components/localthings/
   coordinator.py          Polling + push update coordination, stale-state fallback, write dispatch
   observe.py              CoAP OBSERVE (push-mode) support layered on the coordinator
   diagnostics.py           Redacted diagnostics download (device state + coverage metadata)
+  services.py              write_resource/read_resource actions (device resolution, href translation)
+  services.yaml            Selectors/descriptions for the two services above
   const.py                 Domain, config keys, probe ports
   entity.py                Base entity wiring capability registry -> HA entity
   sensor.py / binary_sensor.py / switch.py / number.py / select.py / button.py / time.py / fan.py / climate.py / water_heater.py
@@ -168,10 +237,16 @@ docker-compose.yml / ha_config/   Local HA dev environment
 If your appliance's type isn't recognized, or it exposes resources this integration doesn't model yet, a Repairs
 issue appears under Settings > System > Repairs pointing you at Settings > Devices & Services > this device >
 the menu > Download diagnostics. That download is already redacted of account/network identifiers (Bixby login
-email, access tokens, device IDs, MAC addresses, serial numbers) before it's generated, so it's safe to attach
+email, access tokens, hashed device IDs, MAC addresses, serial numbers, and the owner-set device name) before it's
+generated, so it's safe to attach
 directly to a new issue using the linked device-support template. This is the fastest way to help add or expand
 support for hardware the maintainers don't have.
 
+When a diagnostics dump alone isn't enough to pin down how a resource actually behaves — whether a write sticks,
+what order things need to happen in, whether the device reverts a change on its own — the `localthings.write_resource`
+and `localthings.read_resource` actions from Part 5 are the tool for probing it directly and reporting back what
+you found.
+
 ---
 
 ## Adding a new appliance type
@@ -194,6 +269,14 @@ 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.
 
+Deregistering a device in SmartThings causes a reset of its network settings as soon as it accesses Samsung's servers, dropping it off Wi-Fi until it's re-onboarded through the SmartThings app. As such, consider keeping devices registered even if egress-blocked, to avoid them resetting upon brief internet access.
+
+### Restarting while an appliance is powered off
+
+If Home Assistant restarts while an appliance is unplugged or switched off at the wall, its device and entities still load — restored from the last successful discovery, showing `unavailable` until the appliance answers again. Automations and dashboards keep referring to entities that exist, and the integration retries in the background, so the device comes back on its own within a poll cycle of being powered on. Entities read `unavailable` rather than their last known values on purpose: the integration can't verify what a disconnected appliance is doing, and recorded history is kept by the recorder either way.
+
+This only applies to an appliance the integration has reached at least once. A brand-new device that has never answered has nothing to restore from, so setting it up still requires it to be reachable.
+
 ### 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.

custom_components/localthings/__init__.py

@@ -2,46 +2,70 @@
 
 from __future__ import annotations
 
+import inspect
 import logging
+import re
+from typing import Any
 
+from homeassistant import const as ha_const
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import EVENT_HOMEASSISTANT_STOP
 from homeassistant.core import Event, HomeAssistant, callback
 from homeassistant.exceptions import ConfigEntryNotReady
 from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers import entity_registry as er
+from homeassistant.helpers.typing import ConfigType
 
-from .const import CONF_HOST, CONF_PORT, CONF_SERIAL, DOMAIN, PLATFORMS
+from .const import CONF_DEVICE_TYPE, CONF_HOST, CONF_PORT, CONF_SERIAL, DOMAIN, PLATFORMS
-from .coordinator import LocalThingsCoordinator
+from .coordinator import LocalThingsCoordinator, snapshot_store
 from .registry.identity import resolve_serial
+from .rekey import rekey_entry
+from .services import async_setup_services
 
 _LOGGER = logging.getLogger(__name__)
 
+# UnitOfDensity is the non-deprecated home for this value from whichever HA
+# release introduces it; CONCENTRATION_MICROGRAMS_PER_CUBIC_METER logs a
+# removal warning (2027.8) on those releases every time it's accessed.
+# hacs.json's floor (2025.1.0) predates UnitOfDensity existing at all, so
+# this is a runtime getattr rather than a static import ty could only ever
+# resolve against one HA generation -- see _relabel_particulate_statistics'
+# own new_unit_class feature-detection below for the same pattern. The
+# getattr short-circuits before the deprecated name is ever touched on a
+# release new enough to have UnitOfDensity.
+_unit_of_density = getattr(ha_const, "UnitOfDensity", None)
+PARTICULATE_UNIT = (
+    _unit_of_density.MICROGRAMS_PER_CUBIC_METER
+    if _unit_of_density is not None
+    else ha_const.CONCENTRATION_MICROGRAMS_PER_CUBIC_METER
+)
+
+
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    # Services are process-global, registered once here rather than per
+    # config entry (issue #300) -- see services.async_setup_services.
+    async_setup_services(hass)
+    return True
+
 
 def _serial_from_unique_id(entry: ConfigEntry) -> str:
     """The device identity a pre-v2 entry was created with.
 
     The config flow has always keyed the entry's unique_id on the serial the
     probe read (`localthings_<serial>`), so that string is the identity the
-    entry's registry entries were minted from -- there is no need to reach the
+    entry's registry entries were minted from -- no need to reach the device
-    device to recover it. Anything we can't recover one from resolves to the
+    to recover it. Anything unrecoverable resolves to the host, matching
-    host, which is what the coordinator seeded such an entry with anyway.
+    what the coordinator seeded such an entry with anyway.
 
     The recovered string goes back through resolve_serial rather than being
-    taken at face value, because the unique_id records what the flow believed
+    taken at face value: entries created before the placeholder rules
-    at the time it ran, not what the registry holds now. Entries created
+    (issues #83/#189) were keyed on the placeholder itself, while the
-    before the placeholder rules landed (issues #83/#189) were keyed on the
+    coordinator has since resolved those same boards to the host.
-    placeholder itself -- `localthings_Nothing(SVC)`, `localthings_FFFF...` --
+    Re-keying onto the placeholder would reintroduce the collision those
-    while the coordinator has since been resolving those same boards to the
+    issues are about -- two units of a family sharing the same placeholder
-    host. Re-keying the registry onto the placeholder to match the unique_id
+    would share entity unique_ids again. A later wrinkle, same root cause:
-    would reintroduce the collision those issues are about: two units of that
+    for a stretch the flow wrote `host:port` while the coordinator wrote
-    family report the *same* placeholder, so they'd share entity unique_ids
+    `host`; collapsed here to the coordinator's form too.
-    again.
-
-    A later wrinkle, same root cause: for a stretch the two sides disagreed on
-    which fallback to use, the flow writing `host:port` while the coordinator
-    wrote `host`. Collapse that to the coordinator's form too -- the registry
-    is what has to keep working.
     """
     host = entry.data[CONF_HOST]
     prefix = f"{DOMAIN}_"
@@ -59,81 +83,143 @@ def _repair_placeholder_keys(hass: HomeAssistant, entry: ConfigEntry, serial: st
     """Re-key registry entries this entry minted from the placeholder identity.
 
     Before the identity moved onto the config entry, the coordinator seeded
-    `device_serial` with the host and only replaced it after the first
+    its device key with the host and only replaced it after the first poll.
-    successful poll. Anything that registered in between -- the connection-mode
+    Anything that registered in between -- the connection-mode sensor
-    sensor especially, since it is added unconditionally rather than from
+    especially, added unconditionally rather than from `bound` -- was
-    `bound` -- was written into the registry keyed on the IP address
+    written into the registry keyed on the IP permanently, orphaned the
-    permanently, and was orphaned the moment the serial-keyed identity
+    moment the serial-keyed identity appeared (issue #236). Deleting the
-    appeared (issue #236). Deleting the orphans by hand didn't help: the next
+    orphans by hand didn't help: the next restart that lost the same race
-    restart that lost the same race recreated them.
+    recreated them.
-
-    Rewriting beats deleting where it's possible -- an entity keeps its
-    entity_id, name, area and every automation that references it. It's only
-    possible when the serial-keyed key is still free, though; where both exist
-    the placeholder-keyed one is the dead duplicate (it has been unavailable
-    since the restart that created it), so it goes.
     """
     host = entry.data[CONF_HOST]
     if serial == host:
-        # A board with no usable serial resolves *to* the host, so its keys
+        # A board with no usable serial resolves to the host, so its keys
-        # were never placeholders -- there is nothing here to re-key.
+        # were never placeholders.
         return
+    rekey_entry(hass, entry, host, serial)
+
+
+# Registries whose Dust/FineDust/SuperFineDust sensors gained pm10/pm25/pm1
+# and a unit in the release that introduced entry version 3. Deliberately
+# not every family reading /sensors/vs/0: range_hood and airconditioner
+# still declare no unit for their identically-named sensors, and relabelling
+# their statistics to µg/m³ would assert a unit those entities don't report
+# -- creating the very mismatch this migration exists to prevent.
+_PARTICULATE_TYPED_IN_V3 = frozenset({"air_purifier", "air_monitor"})
+
+# unique_id is f"{DOMAIN}_{serial}_{state_key}"; state_key is the descriptor
+# key, optionally carrying a subdevice prefix and a trailing `_<n>` instance
+# (registry/adapter._key, discovery.instance_suffix). Matching the tail rather
+# than rebuilding the whole id keeps this working for a renamed entity, whose
+# entity_id -- and so its statistic_id -- no longer follows from the key.
+_PARTICULATE_KEY_RE = re.compile(r"_(?:super_fine_dust|fine_dust|dust)(?:_\d+)?$")
+
+
+@callback
+def _relabel_particulate_statistics(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Point existing particulate statistics at the unit they always were.
+
+    These sensors recorded long-term statistics with no unit, and the
+    release carrying this migration gives them µg/m³. Home Assistant treats
+    that as a unit change it can't convert and *suppresses statistics
+    generation entirely* for the entity until someone resolves the repair
+    (sensor.recorder._update_issues -> UNITS_CHANGED_ISSUE, and the matching
+    `continue` in its compile path). Silently freezing the history we just
+    finished labelling is the worst of both outcomes, so the metadata is
+    corrected up front instead.
+
+    Only the metadata row is rewritten, never the recorded values. The
+    readings were always µg/m³ concentrations (issue #325); what was missing
+    was the label, so there is nothing to convert and no way for this to
+    distort history. That is also why it uses
+    `async_update_statistics_metadata` and not `change_statistics_unit`,
+    which would scale every stored value.
+
+    A no-op when this device family isn't one that gained the unit, or when
+    the device never recorded any statistics -- the underlying UPDATE simply
+    matches no rows.
+
+    Returns False only when the recorder wasn't loaded, meaning the caller
+    should leave the entry on its old version and try again next start.
+    """
+    if entry.data.get(CONF_DEVICE_TYPE) not in _PARTICULATE_TYPED_IN_V3:
+        return True
+    if "recorder" not in hass.config.components:
+        # after_dependencies orders the recorder ahead of us when it's
+        # configured, so this is either an install without it (nothing to
+        # relabel, and the retry costs one set lookup per start) or a boot
+        # where it failed to come up. Not distinguishable here, and burning
+        # the one-shot migration on the second case would leave the
+        # statistics suppressed for good.
+        _LOGGER.debug("recorder not loaded, deferring statistics relabel")
+        return False
+
+    from homeassistant.components.recorder.statistics import (
+        STATISTIC_UNIT_TO_UNIT_CONVERTER,
+        async_update_statistics_metadata,
+    )
+
+    kwargs: dict[str, Any] = {"new_unit_of_measurement": PARTICULATE_UNIT}
+    # `new_unit_class` only exists from HA 2025.11; hacs.json still supports
+    # 2025.1, where passing it is a TypeError -- which would propagate out of
+    # async_migrate_entry and fail the whole entry. Where it is supported it
+    # must be named, since omitting it is deprecated from HA 2026.11. µg/m³
+    # has a converter, so the value is 'concentration' rather than None.
+    if "new_unit_class" in inspect.signature(async_update_statistics_metadata).parameters:
+        converter = STATISTIC_UNIT_TO_UNIT_CONVERTER.get(PARTICULATE_UNIT)
+        kwargs["new_unit_class"] = converter.UNIT_CLASS if converter is not None else None
 
     ent_reg = er.async_get(hass)
-    stale_prefix = f"{DOMAIN}_{host}_"
+    for registry_entry in er.async_entries_for_config_entry(ent_reg, entry.entry_id):
-    for entity in list(er.async_entries_for_config_entry(ent_reg, entry.entry_id)):
+        if registry_entry.domain != "sensor":
-        if not entity.unique_id.startswith(stale_prefix):
             continue
-        new_unique_id = f"{DOMAIN}_{serial}_{entity.unique_id[len(stale_prefix) :]}"
+        if not _PARTICULATE_KEY_RE.search(registry_entry.unique_id):
-        if ent_reg.async_get_entity_id(entity.domain, DOMAIN, new_unique_id):
-            _LOGGER.debug("removing orphaned entity %s", entity.entity_id)
-            ent_reg.async_remove(entity.entity_id)
-        else:
-            _LOGGER.debug("re-keying entity %s to %s", entity.entity_id, new_unique_id)
-            ent_reg.async_update_entity(entity.entity_id, new_unique_id=new_unique_id)
-
-    dev_reg = dr.async_get(hass)
-    for device in list(dr.async_entries_for_config_entry(dev_reg, entry.entry_id)):
-        # `host` for the master, `host_<key>` for a subdevice (device_info_for).
-        stale = {
-            ident
-            for ident in device.identifiers
-            if ident[0] == DOMAIN and (ident[1] == host or ident[1].startswith(f"{host}_"))
-        }
-        if not stale:
             continue
-        fresh = {(DOMAIN, f"{serial}{ident[1][len(host) :]}") for ident in stale}
+        _LOGGER.debug("relabelling statistics unit for %s", registry_entry.entity_id)
-        existing = dev_reg.async_get_device(identifiers=fresh)
+        try:
-        if existing is not None and existing.id != device.id:
+            async_update_statistics_metadata(hass, registry_entry.entity_id, **kwargs)
-            # Removing a device takes its entities with it. Anything still
+        except Exception:
-            # attached here came through the pass above re-keyed rather than
+            # Relabelling is a convenience: without it the user gets Home
-            # removed -- i.e. it's the surviving copy, not a duplicate -- so
+            # Assistant's own units_changed repair, which is where they were
-            # move it onto the device it now belongs to first. Otherwise the
+            # before this migration existed. Never worth failing setup over,
-            # rewrite that was supposed to preserve an entity_id, name and
+            # so no recorder-side surprise can cost them the integration.
-            # area destroys them a few lines later.
+            _LOGGER.warning(
-            for entity in er.async_entries_for_device(
+                "Could not relabel statistics unit for %s; Home Assistant will "
-                ent_reg, device.id, include_disabled_entities=True
+                "offer a units-changed repair for it instead",
-            ):
+                registry_entry.entity_id,
-                ent_reg.async_update_entity(entity.entity_id, device_id=existing.id)
+                exc_info=True,
-            _LOGGER.debug("removing orphaned device %s", device.id)
-            dev_reg.async_remove_device(device.id)
-        else:
-            _LOGGER.debug("re-keying device %s to %s", device.id, fresh)
-            dev_reg.async_update_device(
-                device.id, new_identifiers=(device.identifiers - stale) | fresh
             )
+            return True
+    return True
 
 
 async def async_migrate_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Migrate an entry to the current version.
 
-    v1 -> v2 stores the device's identity on the entry so the coordinator can
+    v1 -> v2 stores the device's identity on the entry so the coordinator
-    key its registry entries before the first poll (issue #236), and repairs
+    can key its registry entries before the first poll (issue #236), and
-    whatever the old placeholder-keyed registration already orphaned.
+    repairs whatever the old placeholder-keyed registration already
+    orphaned.
+
+    v2 -> v3 relabels the recorded statistics for the particulate sensors,
+    which gained a device_class/unit in the same release (issue #325).
+
+    v3 -> v4 moves the entry off the serialNum as its identity and onto the
+    OCF device UUID (issue #381). Deliberately almost a no-op here: the
+    UUID lives on the device, and this runs before any I/O -- and before
+    the device is even known to be reachable, since an entry can load
+    entirely from its snapshot while the appliance is off (issue #295).
+    So the migration only guarantees CONF_SERIAL is populated, which is
+    what the coordinator rewrites *from* once a live poll finally hands it
+    a UUID to rewrite *to*.
+
+    The version is still bumped now rather than at that point, because the
+    bump's real job is the `entry.version > 4` downgrade guard below: an
+    entry re-keyed onto a UUID and then loaded by a release that reads
+    CONF_SERIAL as the key would silently orphan every entity it has.
     """
-    if entry.version > 2:
+    if entry.version > 4:
-        # Downgrade: this release doesn't know the newer entry's shape.
+        return False  # downgrade: this release doesn't know the newer shape
-        return False
 
     if entry.version == 1:
         serial = entry.data.get(CONF_SERIAL) or _serial_from_unique_id(entry)
@@ -146,40 +232,74 @@ async def async_migrate_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         _repair_placeholder_keys(hass, entry, serial)
         _LOGGER.debug("migrated entry %s to version 2 (serial=%s)", entry.entry_id, serial)
 
+    if entry.version == 2 and _relabel_particulate_statistics(hass, entry):
+        hass.config_entries.async_update_entry(entry, version=3)
+        _LOGGER.debug("migrated entry %s to version 3", entry.entry_id)
+
+    if entry.version == 3:
+        # `or host` mirrors what the coordinator has always fallen back to,
+        # so the recorded legacy key is the one this entry's registry
+        # entries were actually minted under even if CONF_SERIAL never got
+        # written (a v1 entry whose migration predates it). Both being
+        # absent shouldn't happen for an entry the config flow created, but
+        # an exception raised here fails the whole entry -- so it bumps the
+        # version and leaves the data alone rather than taking that risk
+        # for a value the coordinator re-derives on its next poll anyway.
+        legacy_key = entry.data.get(CONF_SERIAL) or entry.data.get(CONF_HOST)
+        hass.config_entries.async_update_entry(
+            entry,
+            data={**entry.data, CONF_SERIAL: legacy_key} if legacy_key else entry.data,
+            version=4,
+        )
+        _LOGGER.debug(
+            "migrated entry %s to version 4 (legacy key=%s, awaiting a poll to adopt "
+            "the OCF device id)",
+            entry.entry_id,
+            legacy_key,
+        )
+
     return True
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     hass.data.setdefault(DOMAIN, {})
     coordinator = LocalThingsCoordinator(hass, entry)
+
+    # Before the first refresh, so the coordinator keeps rescheduling even
+    # when that refresh fails and leaves nothing subscribed: the base class
+    # only re-arms its timer while it has listeners, and an offline load can
+    # legitimately have zero live entities (every one of them disabled, say).
+    # Without this the entry loads once and never polls again (issue #295).
+    entry.async_on_unload(coordinator.async_add_listener(lambda: None))
+
     try:
         await coordinator.async_config_entry_first_refresh()
-    except Exception as err:
+    except ConfigEntryNotReady:
-        # `_poll_once` deliberately leaves the session up on a `TimeoutError`
+        # An entry that has polled successfully before comes up on its last
-        # (the transfer may just be slow -- see its docstring), so a refresh
+        # known entity set and keeps retrying on the normal poll interval,
-        # that fails that way ends here with a live, bound UDP socket that
+        # rather than sitting in setup-retry with a device that reads as
-        # nothing would ever close. HA retries setup on its own backoff with
+        # broken and entities that exist only as registry rows (issue #295).
-        # a *new* coordinator, and each device's source port is fixed by
+        #
-        # design (`_local_source_port`), so an abandoned socket squats the
+        # An entry that has never reached the device has no snapshot, so
-        # exact port the next attempt binds -- SO_REUSEADDR lets that bind
+        # there is nothing to show and no device metadata to name it with --
-        # succeed, leaving two sockets racing for the device's datagrams.
+        # that case still fails, which is also what keeps the door open for
-        await coordinator.async_close()
+        # setup flows that need to interact with the device (issue #168).
-        raise ConfigEntryNotReady(f"Cannot connect to device: {err}") from err
+        if not await coordinator.async_rehydrate():
+            await coordinator.async_close()
+            raise
+
     hass.data[DOMAIN][entry.entry_id] = coordinator
 
     # Send the DTLS close_notify on Core shutdown, not just on unload (issue
-    # #254). `async_close` otherwise only runs via `async_unload_entry`, and
+    # #254): HA doesn't unload entries on a plain Core restart, so a restart
-    # HA does not unload entries on a plain Core restart -- so a restart left
+    # left the previous run's association orphaned, making the next
-    # the previous run's association orphaned on the appliance, which is what
+    # handshake time out. Complements the fixed source port, which covers
-    # makes the *next* run's handshake time out. Complements the fixed source
+    # the unclean-exit case this can't.
-    # port, which covers the unclean-exit case this cannot (see
-    # `_local_source_port`).
     #
     # A coroutine listener, not one that spawns its own task: the event bus
-    # runs it as a hass-tracked job, so the close is awaited by the
+    # runs it as a hass-tracked job, awaited by `async_block_till_done()`
-    # `async_block_till_done()` inside `hass.async_stop`. A detached task
+    # inside `hass.async_stop`. A detached task would likely be cancelled
-    # would likely be cancelled mid-shutdown -- the exact no-close_notify
+    # mid-shutdown -- the exact case this exists to prevent.
-    # case this exists to prevent.
     async def _async_close_on_stop(_event: Event) -> None:
         await coordinator.async_close()
 
@@ -187,6 +307,25 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, _async_close_on_stop)
     )
 
+    # Nothing else reacts to an options-flow save (issue #364): the cloud-
+    # courses Repair and canonical-view cache are only refreshed from
+    # _on_cloud_courses_changed, which only runs when a poll/observe
+    # actually reports new data. Without this, turning "Download cycles"
+    # off would leave an already-open Repair sitting there -- and an
+    # already-named program still offered as a cycle -- until the next
+    # unrelated change happened to fire it, indistinguishable from the
+    # toggle not working. Every other option (CONF_LEARN_MODES,
+    # CONF_BYPASS_REMOTE_CONTROL, ...) is read live on its own next use and
+    # has no comparable standing state to refresh, so this listener exists
+    # for cloud courses specifically rather than as a general
+    # options-changed hook. Must be a coroutine function -- HA wraps
+    # whatever an update listener returns in async_create_task, which raises
+    # on a plain callback's None.
+    async def _async_options_updated(_hass: HomeAssistant, _entry: ConfigEntry) -> None:
+        coordinator._on_cloud_courses_changed()
+
+    entry.async_on_unload(entry.add_update_listener(_async_options_updated))
+
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
     return True
 
@@ -198,37 +337,42 @@ async def async_remove_config_entry_device(
 ) -> bool:
     """Allow deleting a device this entry no longer provides (issue #214).
 
-    Defining this at all is what makes Home Assistant offer the "Delete
+    Defining this at all is what makes HA offer the "Delete device" action;
-    device" action for our devices; without it a device registry entry
+    without it, a device belonging to a loaded config entry can never be
-    belonging to a loaded config entry can never be removed from the UI. That
+    removed from the UI. That matters because a subdevice's HA device
-    matters because a subdevice's HA device outlives the discovery that
+    outlives the discovery that created it: a candidate materialized under
-    created it: a candidate that materialized under an older release (issue
+    an older release (issue #214's phantom second air conditioner, born
-    #214's phantom second air conditioner, born from an unused /device/1 slot
+    from an unused slot reporting the appliance's energy counter -- see
-    reporting the appliance's energy counter -- see
+    registry/subdevices.py's liveness gate) leaves a device entry nothing
-    registry/subdevices.py's liveness gate) leaves a device entry behind that
+    recreates or cleans up once the gate stops materializing it. Same for a
-    nothing recreates and nothing cleans up once the gate stops materializing
+    sibling a firmware update stops exposing.
-    it. Same for a sibling that a firmware update stops exposing.
 
-    Removal is refused for devices this entry *does* currently provide --
+    Removal is refused for devices this entry does currently provide -- HA
-    HA would recreate them on the next entity add, so allowing it would look
+    would recreate them on the next entity add. Deliberately no automatic
-    like the delete silently failed. Deliberately no automatic pruning at
+    pruning at discovery time: a sibling can fail to answer for a single
-    discovery time: subdevice enumeration is one-shot and a sibling can fail
+    poll (issue #205), so auto-removal would throw away a real subdevice's
-    to answer for a poll (issue #205 is exactly that on the reference
+    name/area/automations on a transient miss. The user gets the button;
-    hardware), so auto-removal would throw away a real subdevice's name,
+    the integration doesn't guess.
-    area and automation references on a transient miss. The user gets the
-    button; the integration doesn't guess.
     """
     coordinator: LocalThingsCoordinator | None = hass.data.get(DOMAIN, {}).get(entry.entry_id)
     if coordinator is None:
-        # Entry not loaded (or already unloaded) -- nothing is claiming this
+        return True  # entry not loaded -- nothing claims this device
-        # device, so there's nothing to protect it from being removed.
-        return True
     live = set(coordinator.device_info.get("identifiers") or set())
     for subdevice in coordinator.subdevices:
         live |= set(coordinator.device_info_for(subdevice).get("identifiers") or set())
     return not (device.identifiers & live)
 
 
+async def async_remove_entry(hass: HomeAssistant, entry: ConfigEntry) -> None:
+    """Delete the discovery snapshot this entry accumulated (issue #295).
+
+    Nothing else would: the store is keyed on entry_id, so re-adding the same
+    appliance mints a new one and the old file would linger in .storage
+    forever.
+    """
+    await snapshot_store(hass, entry).async_remove()
+
+
 async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     unloaded = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
     if unloaded:

custom_components/localthings/climate.py

@@ -1,26 +1,27 @@
 """Climate platform for Local Things.
 
-The first composite entity in this integration: a single HA climate card that
+The first composite entity in this integration: a single HA climate card
-unifies several OCF resources of a Samsung air conditioner. Unlike every other
+that unifies several OCF resources of a Samsung air conditioner. Unlike
-platform here (one descriptor -> one resource field), a climate entity reads
+every other platform here (one descriptor -> one resource field), a climate
-power, HVAC mode, current/target temperature, fan (wind) strength, swing (wind
+entity reads power, HVAC mode, current/target temperature, fan (wind)
-direction) and the convenient-mode preset from *different* resources.
+strength, swing (wind direction) and the convenient-mode preset from
+*different* resources.
 
-It binds one primary `BoundEntity` (the `/mode/vs/0` capability) so the registry
+It binds one primary `BoundEntity` (the `/mode/vs/0` capability) so the
-still tracks it, and reads the sibling resources straight from the coordinator
+registry still tracks it, and reads the sibling resources straight from the
-snapshot via `coordinator.resource(href)` -- the same cross-resource read that
+coordinator snapshot via `coordinator.resource(href)`.
-`number.py` (live range/unit) and `select.py` (options callable) already do.
 
-Writes go through `coordinator.async_send_command(bound, (kind, value))`: the
+Writes go through `coordinator.async_send_command(bound, (kind, value))`:
-CLIMATE capability's `write_fn` maps each `(kind, value)` payload to the right
+the CLIMATE capability's `write_fn` maps each `(kind, value)` payload to the
-`(path_segs, body)`, and `async_send_command` POSTs to those path_segs and
+right `(path_segs, body)`, and `async_send_command` applies the optimistic
-applies the optimistic value/settle guard to that same href -- not the bound
+value/settle guard to that resource's own href -- not the bound
-`/mode/vs/0` href -- so one descriptor drives writes to, and gets fresh state
+`/mode/vs/0` href -- so one descriptor drives writes across power, mode,
-back for, power, mode, temperature and wind resources alike.
+temperature and wind resources alike.
 """
 
 from __future__ import annotations
 
+import asyncio
 import logging
 
 from homeassistant.components.climate import (
@@ -57,9 +58,6 @@ from .registry.capabilities.airconditioner import (
 from .registry.capabilities.airconditioner import (
     HREF_POWER_VS as POWER_VS_HREF,
 )
-from .registry.capabilities.airconditioner import (
-    HREF_TEMP_CONTROL as TEMP_CONTROL_HREF,
-)
 from .registry.capabilities.airconditioner import (
     HREF_TEMP_CURRENT as TEMP_CURRENT_HREF,
 )
@@ -79,7 +77,12 @@ from .registry.capabilities.airconditioner import (
     HREF_WIND_STRENGTH as WIND_STRENGTH_HREF,
 )
 from .registry.capabilities.airconditioner import (
+    _temperature_step,
+    extend_option_code_bit,
+    has_extend_option_code,
+    has_option_code,
     is_legacy_board,
+    option_code_bit,
 )
 from .registry.capabilities.common import normalize_temp_unit
 from .registry.entities import ClimateDesc
@@ -95,56 +98,46 @@ _SUPPORTED_FIELD = "x.com.samsung.da.supportedModes"
 _DEVICE_TO_HVAC: dict[str, HVACMode] = {
     "Cool": HVACMode.COOL,
     "Dry": HVACMode.DRY,
-    # Fan-only is spelled 'Wind' on some boards (e.g. TP1X_DA-AC-RAC-01001) and
+    # Fan-only is spelled 'Wind' on some boards and 'Fan' on others; both map
-    # 'Fan' on others (e.g. TP1X_DA-AC-RAC-01011); both map to FAN_ONLY. The
+    # to FAN_ONLY. _device_code_for_hvac() resolves the write-side code from
-    # reverse write can't rely on this map alone (two codes, one HA value) --
+    # the unit's own supportedModes, so this reverse map is only a fallback
-    # _device_code_for_hvac() resolves the code from the unit's own
+    # for a unit with no supportedModes at all. 'Fan' listed first so the
-    # supportedModes, so this is only a fallback for a unit reporting no
+    # {v: k} comprehension below has 'Wind' win that fallback (last-key-wins,
-    # supportedModes at all. 'Fan' is listed first so the {v: k} reverse
+    # preserving the original single-spelling behavior).
-    # comprehension below has 'Wind' win that fallback (last-key-wins),
-    # preserving the original single-spelling behavior rather than silently
-    # flipping it when 'Fan' was added.
     "Fan": HVACMode.FAN_ONLY,
     "Wind": HVACMode.FAN_ONLY,
-    # The device's 'Auto' is a single-setpoint "device decides" mode -> HA
+    # A single-setpoint "device decides" mode -> HA AUTO, not HEAT_COOL
-    # HVACMode.AUTO (renders "Auto"). Not HEAT_COOL: that renders "Heat/cool"
+    # (which implies a two-setpoint heat+cool range these units don't have).
-    # and implies a two-setpoint heat+cool range these single-setpoint units
-    # (including cool-only models) don't have.
     "Auto": HVACMode.AUTO,
     "Heat": HVACMode.HEAT,
 }
 _HVAC_TO_DEVICE = {v: k for k, v in _DEVICE_TO_HVAC.items()}
 
-# AI-driven auto-comfort mode (issue #93, A-CAWW-TP2-20-COMMON). Not a flat
+# AI-driven auto-comfort mode (issue #93, A-CAWW-TP2-20-COMMON): 'AIComfort'
-# _DEVICE_TO_HVAC entry: 'AIComfort' isn't a distinct thermodynamic operation
+# isn't a distinct thermodynamic operation like Cool/Dry/Heat, it's an AI
-# like Cool/Dry/Heat, it's an AI overlay on top of the device's own 'Auto'
+# overlay on the device's own 'Auto' -- the unit reports both as separate,
-# behavior -- confirmed by this unit reporting both 'Auto' and 'AIComfort' as
+# mutually-exclusive supportedModes entries. hvac_mode reports AUTO (same as
-# separate, mutually-exclusive entries in /mode/vs/0's supportedModes. Modeled
+# plain 'Auto') and a dedicated 'ai_comfort' preset carries the distinction.
-# the idiomatic HA way instead: hvac_mode reports AUTO (same as the plain
+# Not reachable via async_set_hvac_mode -- entered/left only through the
-# 'Auto' code maps to) and a dedicated 'ai_comfort' preset carries the
+# preset, since there's no HVACMode value for it to write back to.
-# distinction a bare hvac_mode can't. Not reachable via async_set_hvac_mode --
-# entered/left only through the preset, since there's no dedicated HVACMode
-# value for it to write back to.
 _AI_COMFORT_MODE = "AIComfort"
 PRESET_AI_COMFORT = "ai_comfort"
 
-# Codes that appear in /mode/vs/0's supportedModes but are option/capability
+# Codes in /mode/vs/0's supportedModes that are option/capability flags, not
-# flags rather than selectable thermodynamic operations -- dropped silently
+# selectable thermodynamic operations -- dropped silently rather than
-# (no _warn_unmapped call) rather than every owner of an affected unit
+# tripping the issue #93 unmapped-code warning on every start.
-# tripping the issue #93 warning on every start.
 #
-# HOMECARE_WIZARD_V2 (issue #235, TP2X_RAC_20K): also appears in
+# HOMECARE_WIZARD_V2 (issue #235, TP2X_RAC_20K) also appears in
-# /configuration/vs/0's x.com.samsung.da.airconOptionList alongside
+# /configuration/vs/0's airconOptionList alongside other capability flags,
-# PRODUCT_GLOBAL/AI_3.0/SingleCommand_1 -- clearly a capability flag, not a
+# and the unit's own current `modes` never reported it active -- consistent
-# mode, on that resource. The unit's own `modes` (current mode) never
+# with an echoed capability flag, not a genuine mode. Unlike _AI_COMFORT_MODE,
-# reported it as active across the reporter's logs, only ever a real
+# not modeled as a preset either: nothing confirms it's user-selectable.
-# thermodynamic mode -- consistent with it being echoed into supportedModes
-# rather than genuinely selectable. Unlike _AI_COMFORT_MODE above, it isn't
-# modeled as a preset: there's no confirmation it's user-selectable at all,
-# so silently dropping it (rather than guessing a write contract) is the
-# 'don't guess' rule applied to a mode code instead of a resource field.
 _NON_HVAC_OPTION_CODES = frozenset({"HOMECARE_WIZARD_V2"})
 
+# Seconds to let a legacy board settle into Cool before the WindFree token is
+# written after it -- see _legacy_preset_needs_cool for the measurement.
+_NANO_AFTER_MODE_DELAY = 3
+
 # Fan (wind strength): device codes "0".."4" -> HA standard fan constants where
 # a clean match exists so they auto-localize; "turbo" is custom (translated).
 _DEVICE_TO_FAN: dict[str, str] = {
@@ -166,11 +159,9 @@ _DEVICE_TO_SWING: dict[str, str] = {
 _SWING_TO_DEVICE = {v: k for k, v in _DEVICE_TO_SWING.items()}
 
 
-# Swing fallback via /wind/oscillation/vs/0 (issue #126) -- boards without
+# Swing fallback via /wind/oscillation/vs/0 (issue #126): boards without
-# WIND_DIRECTION_HREF at all report two independent Swing|Fix toggles
+# WIND_DIRECTION_HREF report two independent Swing|Fix toggles instead of
-# instead of one combined code. Same HA vocabulary as _DEVICE_TO_SWING
+# one combined code. Same HA vocabulary as _DEVICE_TO_SWING above.
-# above (off/vertical/horizontal/both), just read from/written to a pair
-# of fields rather than a single one.
 def _oscillation_swing(rep: dict) -> str | None:
     vertical = rep.get("vertical")
     horizontal = rep.get("horizontal")
@@ -189,13 +180,12 @@ def _oscillation_swing(rep: dict) -> str | None:
 
 def _wind_strength_label(code, rep: dict) -> str:
     """Human label for a /wind/strength/vs/0 code from the device's own
-    modesName array (parallel-indexed with supportedModes), lowercased for
+    modesName array (parallel-indexed with supportedModes), lowercased --
-    HA -- used only for codes _DEVICE_TO_FAN doesn't already cover (issue
+    used only for codes _DEVICE_TO_FAN doesn't already cover (issue #155:
-    #155, TP1X_DA-AC-RAC-01001_0000: codes "0"/"31"-"35" instead of the
+    a board using codes "0"/"31"-"35" instead of the "0"-"4" scale
-    "0"-"4" scale _DEVICE_TO_FAN was built from, with modesName giving
+    _DEVICE_TO_FAN was built from, with modesName giving the real labels).
-    "Auto"/"1"/"2"/"3"/"4"/"MAX"). No per-model numeric map -- mirrors
+    Falls back to the raw code lowercased when modesName is absent or
-    preset_mode's dynamic code->str resolution. Falls back to the raw code
+    misaligned."""
-    lowercased when modesName is absent or misaligned."""
     supported = rep.get("x.com.samsung.da.supportedModes") or []
     names = rep.get("x.com.samsung.da.modesName") or []
     if code in supported and len(names) == len(supported):
@@ -204,15 +194,10 @@ def _wind_strength_label(code, rep: dict) -> str:
 
 
 # Preset (convenient mode): resolved dynamically from the device's own
-# /mode/convenient/vs/0 supportedModes -- no per-model table. The device 'Off'
+# /mode/convenient/vs/0 supportedModes -- no per-model table. Device 'Off'
-# code maps to HA's PRESET_NONE ("no preset active"); every other code is
+# maps to PRESET_NONE; every other code is exposed lowercased and labelled
-# exposed as its lowercased self and labelled in translations
+# in translations, so any board's convenient modes surface without code
-# (entity.climate.airconditioner.state_attributes.preset_mode.state.<code>),
+# changes, and an unlabelled code renders as its raw value.
-# so any board's convenient modes surface without code changes, and an
-# unlabelled code just renders as its raw value until a label is added.
-# (Samsung's WindFree still-air cooling shows up here as the 'Nano'/
-# 'NanoSleep' codes on cool-only global RAC boards -- that's just a
-# translation label, not a hard-coded mode.)
 def _preset_to_ha(code) -> str:
     return PRESET_NONE if code == "Off" else str(code).lower()
 
@@ -248,12 +233,11 @@ def _num(value):
 def _temps_vs_item(rep: dict) -> dict:
     """First item of the vendor `/temperatures/vs/0` items[] array.
 
-    Newer AC firmware (Tizen Lite, oneUiVersion "7.0 Air conditioner", e.g.
+    Newer AC firmware (Tizen Lite) doesn't expose the OCF-standard
-    model TP1X_DA-AC-RAC-01011) does NOT expose the OCF-standard
+    /temperature/current/0 + /temperature/desired/0 pair; it packs current/
-    /temperature/current/0 + /temperature/desired/0 pair; it reports current
+    desired/minimum/maximum/increment/unit into this one resource's
-    and target under a single `/temperatures/vs/0` resource whose
+    items[0] instead. Returns {} when absent, so callers fall through
-    `x.com.samsung.da.items[0]` carries current/desired/minimum/maximum/
+    cleanly.
-    increment/unit. Returns {} when absent, so callers fall through cleanly.
     """
     items = rep.get("x.com.samsung.da.items")
     if isinstance(items, (list, tuple)) and items and isinstance(items[0], dict):
@@ -264,16 +248,12 @@ def _temps_vs_item(rep: dict) -> dict:
 class LocalThingsClimate(LocalThingsEntity, ClimateEntity):
     """Composite climate entity for a Samsung air conditioner."""
 
-    # translation_key comes from the ClimateDesc (base __init__ sets
+    # Opts out of the deprecated auto-added TURN_ON/OFF backwards compat.
-    # _attr_translation_key from bound.desc), resolving the state_attributes
-    # translations under entity.climate.airconditioner.
-    # Modern climate entities opt out of the deprecated auto-added TURN_ON/OFF.
     _enable_turn_on_off_backwards_compatibility = False
 
     def __init__(self, coordinator: LocalThingsCoordinator, bound) -> None:
         super().__init__(coordinator, bound)
-        # Primary/main entity for the device: no name suffix, just the device name.
+        self._attr_name = None  # primary entity: no name suffix
-        self._attr_name = None
         self._attr_supported_features = (
             ClimateEntityFeature.TARGET_TEMPERATURE
             | ClimateEntityFeature.FAN_MODE
@@ -283,9 +263,8 @@ class LocalThingsClimate(LocalThingsEntity, ClimateEntity):
             | ClimateEntityFeature.TURN_OFF
         )
         # (href, raw device code) pairs already logged by _warn_unmapped --
-        # these properties are read on every coordinator refresh, so an
+        # these properties are read on every refresh, so an un-deduped
-        # un-deduped warning would spam the log for any device with a
+        # warning would spam the log for a genuinely unrecognized code.
-        # genuinely unrecognized code.
         self._warned_unmapped: set[tuple[str, str]] = set()
 
     # -- resource helpers ---------------------------------------------------
@@ -295,100 +274,197 @@ class LocalThingsClimate(LocalThingsEntity, ClimateEntity):
     # Nano=windFree, Quiet, Comfort, 2Step, Speed=Fast Turbo, Off=none.
     _LEGACY_PRESET_CODES = ("Off", "Nano", "Quiet", "Comfort", "2Step", "Speed")
 
+    # Good Sleep occupies the same Comode_ slot as the presets above, so a unit
+    # running it reports Comode_Sleep -- or Comode_NanoSleep, which the board
+    # will produce by itself when nano wind is asked for while the timer runs.
+    # Neither is in the list above, and a preset_mode outside preset_modes is
+    # not a state HA allows, so they are added for boards that have the Sleep_
+    # token these codes come with.
+    _LEGACY_SLEEP_PRESET_CODES = ("Sleep", "NanoSleep")
+
+    # HVAC modes _legacy_preset_codes() has a rule for. Anything else is a mode
+    # this transcription has never seen, which is the same "cannot judge" case as
+    # a board that publishes no capability map -- and gets the same fallback.
+    _LEGACY_KNOWN_HVAC = frozenset(
+        {"Cool", "Heat", "HeatClean", "Dry", "Fan", "Wind", "Auto", _AI_COMFORT_MODE}
+    )
+
+    # Which comfort modes a legacy board offers in which HVAC mode, and which of
+    # them it has at all. Both come from the appliance rather than from a table
+    # per model: the unit publishes its capabilities as two bit maps in
+    # /mode/vs/0's options (OptionCode, ExtendOptionCode), and its own app gates
+    # each item on a bit plus the current mode. _legacy_preset_codes() below is
+    # that logic, transcribed from the app's updateOptionsList() so the two can be
+    # compared line by line, with the bit each rule reads named in the comment.
+    #
+    # Confirmed against an ARTIK051_KRAC_18K whose owner read the same lists off
+    # the remote and the app: WindFree in Cool/Dry/Fan and (being an 18K model)
+    # Auto but never Heat, and Fast Turbo and Comfort in Heat because oc[12] is
+    # set. d'light Cool is gated the same way on oc[2], which is zero here -- and
+    # the appliance refuses the token locally too.
+    #
+    # Single User is deliberately not modelled, though the app does gate it on
+    # oc[3] / oc[11]: it has no token of its own. The app's own Single User
+    # command sends `Comode_Smart` -- the Smart Saver token -- with a hardcoded
+    # 24 desired alongside it, so there is nothing to write that would be
+    # distinguishable from the Smart preset below, and no name to give it that
+    # the appliance would recognise.
+
+    def _legacy_preset_codes(self, hvac: str, options: list) -> list[str]:
+        """Comfort-mode codes this unit offers in this HVAC mode.
+
+        Derived only for boards that publish *both* capability maps. One map on
+        its own is not enough: every eoc-gated rule would then read None, and
+        None means "this board does not publish the map", never "the feature is
+        absent". The FAC/CAC boards on record carry only the older map, with
+        values small enough that RAC bit positions all read as zeros, so
+        requiring both also keeps these rules inside the family they were
+        documented for.
+
+        Within the derived path, a bit that cannot be read (a malformed or
+        over-wide token) is treated as permission rather than denial for the
+        codes the unconditional list already carried -- losing a working preset
+        to a parsing failure is worse than offering one too many. Codes that were
+        never in that list (d'light) still need their bit to be explicitly set.
+        """
+        rep = self._rep(MODE_HREF)
+        if (
+            not has_option_code(rep)
+            or not has_extend_option_code(rep)
+            or hvac not in self._LEGACY_KNOWN_HVAC
+        ):
+            return list(self._LEGACY_PRESET_CODES)
+
+        cool = hvac in ("Cool", _AI_COMFORT_MODE)
+        heat = hvac in ("Heat", "HeatClean")
+        codes = ["Off"]
+        # WindFree: shown on eoc[31]; disabled in Heat, in AIComfort, and in Auto
+        # unless this is an 18K model (eoc[30]), where the app switches to Cool for
+        # it instead -- which is what _legacy_preset_needs_cool does.
+        nano_mode_ok = not heat and hvac != _AI_COMFORT_MODE
+        if hvac == "Auto":
+            nano_mode_ok = extend_option_code_bit(rep, 30) is not False
+        if extend_option_code_bit(rep, 31) is not False and nano_mode_ok:
+            codes.append("Nano")
+        if cool or (heat and option_code_bit(rep, 12) is not False):  # Fast Turbo
+            codes.append("Speed")
+        if cool:
+            codes.append("2Step")
+        if cool and option_code_bit(rep, 2):  # d'light Cool -- needs the bit set
+            codes.append("DlightCool")
+        # Quiet reads oc[10] with no mode condition in the app, but the owner of
+        # the unit above sees it in Cool and Heat only, on the remote as well as
+        # in the app -- the observation wins over the reading.
+        if option_code_bit(rep, 10) is not False and (cool or heat):
+            codes.append("Quiet")
+        if cool or (heat and option_code_bit(rep, 12) is not False):  # Comfort
+            codes.append("Comfort")
+        # Smart Saver has no bit of its own and the app hides it from every single
+        # RAC outright (showSaverOption = false), yet the appliance accepts it and
+        # behaves as Samsung documents -- so absence from the app is not absence
+        # from the hardware. Cool-only, per that documentation.
+        if hvac == "Cool":
+            codes.append("Smart")
+        # Good Sleep, which shares this slot: the app enables it in Cool, Heat and
+        # AIComfort only. Both codes, because the board turns Sleep into NanoSleep
+        # by itself when WindFree is running.
+        if (cool or heat) and any(
+            isinstance(option, str) and option.startswith("Sleep_") for option in options
+        ):
+            codes += self._LEGACY_SLEEP_PRESET_CODES
+        return codes
+
     def _legacy_convenient(self) -> dict:
         """A /mode/convenient/vs/0-shaped rep built from the Comode_* token in
         /mode/vs/0's options, for boards that have no convenient resource."""
         options = self._rep(MODE_HREF).get("x.com.samsung.da.options") or []
-        for option in options:
+        active = next(
-            if isinstance(option, str) and option.startswith("Comode_"):
+            (o.split("_", 1)[1] for o in options if isinstance(o, str) and o.startswith("Comode_")),
-                return {
+            None,
-                    _MODES_FIELD: [option.split("_", 1)[1]],
+        )
-                    _SUPPORTED_FIELD: list(self._LEGACY_PRESET_CODES),
+        if active is None:
-                }
+            return {}
-        return {}
+
+        codes = self._legacy_preset_codes(_first(self._rep(MODE_HREF).get(_MODES_FIELD)), options)
+        # Whatever the unit is actually running has to be listed whether the
+        # rules expect it there or not -- a preset_mode outside preset_modes is
+        # not a state HA allows, and the appliance has the last word on what it
+        # is doing (a remote can put it in a mode these rules would not offer).
+        if active not in codes:
+            codes.append(active)
+        return {_MODES_FIELD: [active], _SUPPORTED_FIELD: codes}
 
     def _legacy_airflow(self) -> dict:
-        """The /airflow/vs/0 rep, but only when it is the fan/swing channel to
+        """The /airflow/vs/0 rep, but only when it is the fan/swing channel
-        use -- i.e. this board has no /wind/strength/vs/0.
+        to use -- i.e. this board has no /wind/strength/vs/0.
 
         Delegates the board-generation test to is_legacy_board (the same
-        test capabilities/airconditioner.py's token entities are gated on)
+        test the token entities in capabilities/airconditioner.py use)
-        instead of re-implementing it. Uses self._resources (this unit's own
+        instead of re-implementing it, using self._resources (issue #177)
-        canonical view, issue #177 -- see LocalThingsEntity._resources)
+        rather than a presence dict built from coordinator.resource()'s
-        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
+        but empty" to the same falsy value, while is_legacy_board tests key
-        (and discover()'s own binding) test key membership, not truthiness. A
+        membership. Reads through self._rep, not coordinator.resource()
-        presence dict built from truthiness alone would disagree with the
+        directly, so a subdevice's own /airflow/vs/1 gets translated first,
-        token entities on a board reporting a genuinely empty /airflow/vs/0,
+        like every other sibling read below.
-        silently reintroducing the drift this delegation exists to prevent.
-
-        Reads the actual href through self._rep rather than
-        coordinator.resource() directly -- on a subdevice (a legacy-board
-        sibling has its own /airflow/vs/1, or /<id>/airflow/vs/0), the
-        canonical AIRFLOW_HREF must be translated through this bound
-        entity's own subdevice first, exactly like every other sibling read
-        below.
         """
         if not is_legacy_board(self._resources):
             return {}
         return self._rep(AIRFLOW_HREF)
 
     def _legacy_preset(self) -> bool:
-        """Whether presets come from the Comode_* token rather than a resource.
+        """Whether presets come from the Comode_* token rather than a
+        resource. Gated on the same board test as _legacy_airflow, not on
+        the convenient rep being empty alone: newer boards carry Comode
+        tokens too, so a momentarily empty /mode/convenient/vs/0 must not
+        silently switch the preset path over.
 
-        Gated on the same board test as _legacy_airflow, not on the convenient
+        Reads the raw href directly rather than through self._rep's own
-        rep being empty alone: newer boards carry Comode tokens too, so a
+        CONVENIENT_HREF fallback -- that fallback IS the legacy_convenient()
-        momentarily empty /mode/convenient/vs/0 there must not silently switch
+        rep this method is deciding whether to use, so routing through it
-        the preset read (and write) over to the token path.
+        would make the resource never look empty.
-
-        Deliberately reads the *raw* href (translated through this bound
-        entity's own subdevice, not through self._rep) rather than going
-        through _rep's own CONVENIENT_HREF fallback branch -- that fallback
-        is exactly the legacy_convenient() rep this method is deciding
-        whether to use, so routing through it here would make the resource
-        never look empty and this always resolve to the wrong side.
         """
         convenient_href = self._bound.subdevice.to_actual(CONVENIENT_HREF)
         return not self.coordinator.resource(convenient_href) and bool(self._legacy_airflow())
 
     def _rep(self, href: str) -> dict:
-        """`href` is one of this module's canonical HREF_* constants --
+        """`href` is one of this module's canonical HREF_* constants,
-        translated through this bound entity's own subdevice (issue #177) to
+        translated through this bound entity's own subdevice (issue #177)
-        the real, on-the-wire href before the single-href cache lookup
+        to the real on-the-wire href -- identity for MAIN."""
-        (identity for MAIN, so a device with no subdevices reads exactly the
-        href it always did)."""
         rep = self.coordinator.resource(self._bound.subdevice.to_actual(href)) or {}
         if not rep and href == CONVENIENT_HREF and self._legacy_airflow():
             return self._legacy_convenient()
         return rep
 
     def _is_on(self) -> bool:
-        # Prefer the vendor /power/vs/0 (present on every observed board and
+        # Prefer the vendor /power/vs/0 -- the OCF /power/0 is absent on many
-        # the resource writes target -- see airconditioner._climate_write).
+        # boards and a stale mirror on some, so reading it first showed
-        # The OCF /power/0 is absent on many boards and a stale mirror on
+        # pre-write state after a power toggle (issue #53).
-        # some, so reading it first showed pre-write state after a power
-        # toggle (issue #53: "can turn on but not off").
         power = self._rep(POWER_VS_HREF).get("x.com.samsung.da.power")
         if power is not None:
             return str(power).lower() == "on"
         return bool(self._rep(POWER_HREF).get("value"))
 
     def _supported(self, href: str) -> list[str]:
-        return list(self._rep(href).get(_SUPPORTED_FIELD) or [])
+        """The resource's own supportedModes, plus any code this unit has
+        been seen in but never advertised (issue #327, learned.py).
+
+        Both the option lists (preset_modes, fan_modes, ...) and the write
+        paths resolve codes through here, so a learned code is selectable
+        and writable by virtue of appearing in one list.
+        """
+        supported = list(self._rep(href).get(_SUPPORTED_FIELD) or [])
+        learned = self.coordinator.learned_modes(self._bound.subdevice.to_actual(href))
+        return supported + [code for code in learned if code not in supported]
 
     def _warn_unmapped(self, href: str, code: str) -> None:
         """Log once per (href, code) when a device-reported mode has no
-        entry in the relevant device<->HA map, so a real device gap surfaces
+        entry in the relevant device<->HA map, so a real gap surfaces in
-        in the log instead of silently vanishing (issue #93).
+        the log instead of silently vanishing (issue #93).
 
         Falls back to `unique_id` when `entity_id` is unset (issue #235):
-        this fires during setup's first discovery pass, before the entity is
+        this can fire during setup's first discovery pass, before the
-        added to hass, so `entity_id` is always None at that point --
+        entity is added to hass, when entity_id is still None."""
-        indistinguishable across multiple same-type devices in the log.
-        `unique_id` is set eagerly in `__init__` (see entity.py), so it's
-        always available here even though `entity_id` isn't.
-        """
         key = (href, code)
         if key in self._warned_unmapped:
             return
@@ -420,11 +496,10 @@ class LocalThingsClimate(LocalThingsEntity, ClimateEntity):
 
     def _ocf_temp_authoritative(self) -> bool:
         """True when the OCF /temperature/{current,desired}/0 pair is the
-        authoritative temperature channel -- signalled by
+        authoritative channel, signalled by /temperature/current/0 being
-        /temperature/current/0 being present. Those boards honour reads/
+        present. Those boards honor reads/writes on /temperature/desired/0
-        writes on /temperature/desired/0 and ignore the vendor
+        and ignore the vendor /temperatures/vs/0; boards without the pair
-        /temperatures/vs/0; boards without the pair (only a desired stub, or
+        are the reverse. Confirmed on live units of both kinds."""
-        nothing) are the reverse. Confirmed on live units of both kinds."""
         return bool(self._rep(TEMP_CURRENT_HREF))
 
     def _temps_vs(self) -> dict:
@@ -481,12 +556,11 @@ class LocalThingsClimate(LocalThingsEntity, ClimateEntity):
 
     @property
     def target_temperature_step(self) -> float:
-        return (
+        # Shared with the write path (airconditioner._climate_write) so a
-            _num(self._rep(TEMP_CONTROL_HREF).get("increment"))
+        # step read here always matches the step a write is quantized to --
-            or _num(self._rep(TEMP_CONTROL_HREF).get("x.com.samsung.da.increment"))
+        # self._resources is this entity's own subdevice's canonical view
-            or _num(self._temps_vs().get("x.com.samsung.da.increment"))
+        # (issue #177), the same shape _temperature_step expects.
-            or 1.0
+        return _temperature_step(self._resources) or 1.0
-        )
 
     # -- hvac mode ----------------------------------------------------------
 
@@ -597,11 +671,9 @@ class LocalThingsClimate(LocalThingsEntity, ClimateEntity):
         return _HVAC_TO_DEVICE.get(hvac_mode)
 
     async def async_set_temperature(self, **kwargs) -> None:
-        # HA's set_temperature service forwards an optional hvac_mode here; honour
+        # HA's set_temperature service can carry an optional hvac_mode;
-        # it (set the mode first -- that also powers the unit on when it was off),
+        # honor it (setting the mode also powers the unit on) so a dashboard
-        # matching the climate contract other integrations follow. Without this a
+        # "turn on to Auto 24" button doesn't set the setpoint alone.
-        # set_temperature call carrying hvac_mode (e.g. a dashboard "turn on to
-        # Auto 24" button) set the setpoint but never changed mode or powered on.
         hvac_mode = kwargs.get("hvac_mode")
         if hvac_mode is not None:
             await self.async_set_hvac_mode(hvac_mode)
@@ -647,12 +719,11 @@ class LocalThingsClimate(LocalThingsEntity, ClimateEntity):
         supported = self._supported(WIND_STRENGTH_HREF)
         device = _FAN_TO_DEVICE.get(fan_mode)
         # A static hit is only trustworthy if this unit's own supportedModes
-        # actually includes that code -- a board can use non-standard codes
+        # includes that code -- a board can use non-standard codes (issue
-        # (issue #155's "31"-"35") while still spelling a standard label
+        # #155) while still spelling a standard label in modesName, so the
-        # ("Low"/"High") in modesName, in which case _FAN_TO_DEVICE.get would
+        # static guess could be a plausible code the device never
-        # return a plausible-looking code ('1'/'3') the device never
+        # advertised. Fall through to the live scan when it isn't one of
-        # advertised at all. Fall through to the live scan whenever the
+        # this unit's own codes.
-        # static guess isn't actually one of this unit's own codes.
         if device is None or (supported and device not in supported):
             rep = self._rep(WIND_STRENGTH_HREF)
             for code in supported:
@@ -674,6 +745,38 @@ class LocalThingsClimate(LocalThingsEntity, ClimateEntity):
         if self._rep(WIND_OSCILLATION_HREF):
             await self.coordinator.async_send_command(self._bound, ("oscillation", swing_mode))
 
+    async def _legacy_preset_needs_cool(self, code: str) -> None:
+        """Switch a legacy board to Cool first when the preset needs it.
+
+        WindFree does not exist in Auto: `["Comode_Nano"]` written while the unit
+        is in Auto is answered 2.04 Changed and dropped (measured, still
+        Comode_Off at +8s and +45s), and putting `modes: Cool` in the *same* POST
+        does not help -- the mode moves and the token is still dropped, so the
+        board judges the option against the mode it was in. Sent as its own write
+        first, it holds. The appliance's own app pairs `modes: Cool` with its nano
+        command for the same reason.
+
+        Auto only. The app's builder also covers AIComfort, but its
+        `updateOptionsList()` disables the WindFree button there outright, so that
+        pairing can never fire -- and `_legacy_preset_codes()` likewise does not
+        offer `Nano` in AIComfort, which would leave such a branch unreachable.
+
+        The pause is measured, not padding: back to back (same session, no gap at
+        all) the token was dropped again, two seconds apart it held. Three is that
+        with a little margin, and it only ever runs for this one preset in this
+        one HVAC mode.
+        """
+        if not self._legacy_preset() or code != "Nano":
+            return
+        if _first(self._rep(MODE_HREF).get(_MODES_FIELD)) != "Auto":
+            return
+        # Same resolver the rest of the platform uses -- the device code for an HA
+        # mode is read off the unit's own supportedModes rather than assumed.
+        await self.coordinator.async_send_command(
+            self._bound, ("mode", self._device_code_for_hvac(HVACMode.COOL))
+        )
+        await asyncio.sleep(_NANO_AFTER_MODE_DELAY)
+
     async def async_set_preset_mode(self, preset_mode: str) -> None:
         if preset_mode == PRESET_AI_COMFORT:
             # Writes the primary mode resource, not the convenient one --
@@ -685,6 +788,7 @@ class LocalThingsClimate(LocalThingsEntity, ClimateEntity):
         # a fixed transform of the HA value -- e.g. 'NanoSleep' -> 'nanosleep').
         for code in self._supported(CONVENIENT_HREF):
             if _preset_to_ha(code) == preset_mode:
+                await self._legacy_preset_needs_cool(code)
                 kind = "preset_legacy" if self._legacy_preset() else "preset"
                 await self.coordinator.async_send_command(self._bound, (kind, code))
                 return

custom_components/localthings/cloudcourse.py

@@ -0,0 +1,377 @@
+"""Cloud "Download" programs on a laundry device (issue #342).
+
+Some course tables carry a course whose recipe isn't fixed in firmware --
+selecting it runs whichever program was last pushed down from the
+SmartThings cloud ("Download" / "Downloaded" in the course catalog). Three
+tokens on ``/course/vs/0``'s ``x.com.samsung.da.options`` array drive it:
+
+  ``CloudExtraCourse_<slot><slot>...``  the device's own list of downloaded
+      program slots, one byte each -- the cloud counterpart of
+      ``EditCourseList_`` for local courses.
+  ``CloudCourse_<blob>``               the persisted default program.
+  ``OneTimeCloudCourse_<blob>``        a this-run-only override.
+
+A ``<blob>`` is an opaque fixed-width payload whose byte 2 is the slot id
+it belongs to. Confirmed on two independent DA_WM_TP1_21_COMMON washers:
+the issue #342 reporter's, whose ``CloudExtraCourse_0A5C286B2D0C55301A``
+enumerates nine slots matching byte 2 of all nine of its programs exactly,
+and the WA55A7700AV dump in ``tests/fixtures``, whose two-slot
+``CloudExtraCourse_5958`` likewise matches its ``CloudCourse`` blob's byte
+2. Blob width is *not* fixed across boards (20 bytes vs 16), which is one
+reason nothing here ever synthesizes one.
+
+``CloudExtraCourse_`` does not mean the same thing on every family, so
+nothing keys off it directly -- see ``cloud_slots``, which is what the rest
+of this module and its callers gate on. Even then, a device can advertise a
+slot whose payload has never been observed, so ``cloud_slots`` answers
+"which exist" while the store answers "which are usable"; the two are
+deliberately allowed to disagree.
+
+What this module does and deliberately does not do
+--------------------------------------------------
+The device advertises *which* slots exist but never what any of them is
+called, and never the full blob for a slot other than the one currently
+loaded. A blob is only observable while the device happens to be sitting on
+that program, so the full payload is *learned by observation* and persisted
+(same rationale as learned.py's mode store), and the human-readable name is
+supplied by the user in the options flow. Nothing is hardcoded: no catalog
+of program ids, no table of blobs, no assumed Download course code. A
+hardcoded catalog was considered and rejected -- a blob is cloud-assigned
+per account/region, so one user's captured payload is not evidence about
+anyone else's device.
+
+Blobs are replayed byte-for-byte, exactly as captured, and never
+decomposed or rebuilt. (Bytes 5/7/9 of the reporter's blobs do decode
+cleanly to that program's temperature/rinse/spin, but the same offsets
+produce nonsense against the WA55A7700AV blob, so that decode is recorded
+in docs/investigations/download-cycle.md rather than shipped.)
+"""
+
+from __future__ import annotations
+
+import threading
+
+from .const import CONF_CLOUD_COURSES
+from .registry.capabilities.common import hex_pairs, option_value
+
+COURSE_HREF = "/course/vs/0"
+
+EXTRA_PREFIX = "CloudExtraCourse"
+DEFAULT_PREFIX = "CloudCourse"
+ONESHOT_PREFIX = "OneTimeCloudCourse"
+COURSE_PREFIX = "Course"
+
+# Synthetic, integration-owned field the coordinator merges onto
+# /course/vs/0's rep so the registry's exists_fn/rep_fn/options/write_fn all
+# reach this store through their existing signatures -- rep_fn in particular
+# receives only its own href's rep, never the resource snapshot, so a
+# sibling-resource lookup isn't available to it. Namespaced away from
+# Samsung's own 'x.com.samsung.da.' fields so it can never collide with one,
+# and merged at read time only: it is never written to the state cache, never
+# sent to the device, and never part of a diagnostics dump.
+FIELD = "x.localthings.cloudCourses"
+
+# Raw-value namespace for a cloud program in the cycle select. A slot id is
+# itself two hex chars, exactly like a local course code, so the two would be
+# indistinguishable (and could collide outright) as bare select values.
+RAW_PREFIX = "cloud:"
+
+# A blob whose first two bytes are FFFF means "no program loaded" rather than
+# naming one -- WA55A7700AV reports
+# OneTimeCloudCourse_FFFF010049004D004A804C0037F0AC00 while sitting on a
+# perfectly ordinary local course, and its byte 2 (01) is not one of the slots
+# its own CloudExtraCourse_ advertises.
+_SENTINEL_PREFIX = "FFFF"
+
+# Distinct from None, which is a real observation that carried no payload.
+# Only "never observed" suppresses a candidate; absent-then-loaded is a
+# genuine transition and should count.
+_UNOBSERVED = object()
+
+# Byte offset within a blob that carries its slot id.
+_SLOT_BYTE = 2
+_MIN_BLOB_BYTES = 4
+
+
+def _hex_bytes(blob):
+    if not isinstance(blob, str) or len(blob) % 2 or len(blob) < _MIN_BLOB_BYTES * 2:
+        return []
+    try:
+        int(blob, 16)
+    except ValueError:
+        return []
+    return hex_pairs(blob.upper())
+
+
+def is_loaded(blob) -> bool:
+    """True when `blob` names an actual program rather than 'none'."""
+    return _slot_and_loaded(blob)[1]
+
+
+def slot_of(blob) -> str | None:
+    """The slot id `blob` belongs to, or None if it names no program."""
+    slot, loaded = _slot_and_loaded(blob)
+    return slot if loaded else None
+
+
+def _slot_and_loaded(blob) -> tuple[str | None, bool]:
+    """Both answers off one parse -- the public pair above needs the same
+    byte split, and observe() asks for both about the same payload."""
+    parts = _hex_bytes(blob)
+    if not parts:
+        return None, False
+    if "".join(parts[:2]) == _SENTINEL_PREFIX:
+        return None, False
+    return parts[_SLOT_BYTE], True
+
+
+def advertised_slots(rep) -> list[str]:
+    """Slot ids this device says it has downloaded programs in, from its own
+    CloudExtraCourse_ token. The authority on *which* programs exist -- this
+    is never inferred from what has been learned so far, so "3 of 9
+    discovered" is answerable."""
+    raw = option_value(rep.get("x.com.samsung.da.options"), EXTRA_PREFIX)
+    if not isinstance(raw, str) or len(raw) % 2:
+        return []
+    # Preserve the device's own order (first-seen wins) while dropping any
+    # repeat, so the flow lists slots the way the appliance does.
+    return list(dict.fromkeys(hex_pairs(raw.upper())))
+
+
+def cloud_slots(rep, courses) -> list[str]:
+    """Advertised slots that are not already selectable courses.
+
+    `CloudExtraCourse_` does not mean the same thing on every family. On the
+    washers its bytes are opaque payload slots sharing nothing with the
+    device's own course list, and selecting one needs the full payload. On
+    the DW5000C dishwasher all four of its bytes *are* course codes in that
+    device's own list (8E/8D/8F/02 -- Plastic, Pots and pans, Baby Care, and
+    one untranslated), so there it is tagging which of its ordinary courses
+    came from the cloud. Those are already selectable as plain `Course_`
+    writes and need nothing from this module.
+
+    Subtracting the course list tells the two apart without having to guess
+    the family: what remains is slots that cannot be selected any other way,
+    which is exactly the set this module exists for.
+    """
+    known = {c.upper() for c in courses or ()}
+    return [slot for slot in advertised_slots(rep) if slot not in known]
+
+
+def supports_cloud_courses(rep, courses) -> bool:
+    """True for a device with downloaded programs it cannot otherwise run."""
+    return bool(cloud_slots(rep, courses))
+
+
+def loaded_slot(rep) -> str | None:
+    """The slot whose payload the appliance currently holds -- the one-time
+    override when one is set, else the saved default.
+
+    Deliberately not gated on the course being Download: the guided setup
+    flow watches this before the Download course has been confirmed, and
+    during that walk a change here *is* the signal that the user selected a
+    different program. A stale token can't produce a false positive because
+    the flow waits for a change from its own baseline, not for a value.
+    """
+    options = rep.get("x.com.samsung.da.options")
+    return slot_of(option_value(options, ONESHOT_PREFIX)) or slot_of(
+        option_value(options, DEFAULT_PREFIX)
+    )
+
+
+def _coerce(stored) -> tuple[str | None, dict[str, dict[str, str]]]:
+    """Restore the persisted record, dropping anything not the shape this
+    module writes -- it round-trips through the config entry as plain JSON
+    and a hand-edited .storage file must not be able to crash setup (same
+    posture as learned._coerce)."""
+    if not isinstance(stored, dict):
+        return None, {}
+    download = stored.get("download_course")
+    if not isinstance(download, str) or not download:
+        download = None
+    slots: dict[str, dict[str, str]] = {}
+    raw_slots = stored.get("slots")
+    if isinstance(raw_slots, dict):
+        for slot, record in raw_slots.items():
+            if not isinstance(slot, str) or not isinstance(record, dict):
+                continue
+            blob = record.get("blob")
+            if not is_loaded(blob) or slot_of(blob) != slot.upper():
+                continue
+            name = record.get("name")
+            slots[slot.upper()] = {
+                "blob": blob.upper(),
+                "name": name if isinstance(name, str) and name.strip() else "",
+            }
+    return download, slots
+
+
+def persist(hass, entry, record: dict) -> None:
+    """Write `record` onto the entry. Runs on the event loop, which
+    async_update_entry requires."""
+    hass.config_entries.async_update_entry(entry, data={**entry.data, CONF_CLOUD_COURSES: record})
+
+
+class CloudCourses:
+    """Per-device store of discovered cloud programs.
+
+    Mutated from whichever thread applied the update (the DTLS reader for an
+    OBSERVE notify, an executor thread for a poll -- see ObserveManager.apply),
+    so every access takes the lock; persistence is the caller's job, on the
+    event loop.
+    """
+
+    def __init__(self, stored_record=None) -> None:
+        self._lock = threading.Lock()
+        download, slots = _coerce(stored_record)
+        self._download_course = download
+        self._slots = slots
+        # Course codes seen at the moment a one-time override was *loaded* --
+        # candidates for "which course means Download on this board", pending
+        # user confirmation (see download_candidates).
+        self._candidates: dict[str, int] = {}
+        # Last one-time payload seen, so a load can be told from a poll that
+        # merely re-reports one. _UNOBSERVED until the first rep arrives.
+        self._last_oneshot: object = _UNOBSERVED
+
+    # -- learning ---------------------------------------------------------
+
+    def observe(self, rep: dict) -> bool:
+        """Learn from one applied /course/vs/0 rep; True if anything changed.
+
+        Two facts are learnable here. A blob is recorded against the slot its
+        own byte 2 names, so a program only has to be sitting loaded once --
+        on either token -- to be replayable forever after.
+
+        The Download course code is only ever taken as a *candidate*, and
+        only at the moment the one-time payload actually *changes* to a
+        loaded value. That instant is the one the device is known to accept a
+        program on, so the course selected then is real evidence. Counting
+        every poll instead would rank by dwell time: tokens in this array are
+        replaced by prefix and never evicted, so a stale OneTimeCloudCourse_
+        outlives its run and sits there through however many polls the
+        appliance spends on some ordinary course afterwards -- which is
+        exactly the course that would then be suggested. A candidate is still
+        never applied without confirmation in the options flow, but a
+        confident wrong suggestion is most of the way to a wrong write, and a
+        wrong write here starts a real wash cycle.
+        """
+        options = rep.get("x.com.samsung.da.options")
+        if not options:
+            return False
+        known_slots = advertised_slots(rep)
+        oneshot = option_value(options, ONESHOT_PREFIX)
+        with self._lock:
+            # Compared once, at the end, against where this pass started --
+            # not set per assignment. The two tokens can name the same slot
+            # with different payloads (a downloaded program with its settings
+            # tweaked for one run is exactly that shape), and a per-assignment
+            # flag would then report a change on every single poll forever:
+            # each pass writes the default's payload and then the one-shot's
+            # over it, so neither is ever "already stored". Every one of those
+            # reports rewrites the config entry, which on the SD-card installs
+            # this integration runs on is the one cost here that really bites.
+            # The end state is stable (the one-shot is written last and wins),
+            # so comparing start to end settles after the first pass.
+            before = {slot: record["blob"] for slot, record in self._slots.items()}
+            for prefix in (DEFAULT_PREFIX, ONESHOT_PREFIX):
+                blob = option_value(options, prefix)
+                slot = slot_of(blob)
+                # A blob whose slot the device doesn't advertise is not a
+                # program this appliance offers -- don't record it.
+                if slot is None or (known_slots and slot not in known_slots):
+                    continue
+                record = self._slots.get(slot)
+                if record is None:
+                    self._slots[slot] = {"blob": blob.upper(), "name": ""}
+                else:
+                    record["blob"] = blob.upper()
+            changed = before != {slot: rec["blob"] for slot, rec in self._slots.items()}
+
+            course = option_value(options, COURSE_PREFIX)
+            # Only a transition we actually watched happen counts. On the
+            # first observation there is nothing to compare against, so a
+            # payload sitting there is equally consistent with "just loaded"
+            # and "left over from last week" -- and on a board that doesn't
+            # clear the token when leaving Download, believing the former
+            # proposes whatever ordinary course the appliance happens to be
+            # on. Accepting that prefill would start a real wash cycle.
+            # (The two dumps in the corpus taken off the Download course both
+            # show the appliance clearing it to the FFFF sentinel, so this
+            # may never fire in practice -- which is not a reason to rely on
+            # it.) Restores don't persist _last_oneshot, so every restart
+            # re-enters this first-observation state deliberately.
+            first_ever = self._last_oneshot is _UNOBSERVED
+            if course and is_loaded(oneshot) and not first_ever and oneshot != self._last_oneshot:
+                self._candidates[course] = self._candidates.get(course, 0) + 1
+            self._last_oneshot = oneshot
+        return changed
+
+    # -- reads ------------------------------------------------------------
+
+    def download_candidates(self) -> list[str]:
+        """Course codes seen at the moment a one-time program was loaded,
+        most-observed first -- what the options flow offers as the likely
+        Download course. Never used for a write on its own."""
+        with self._lock:
+            ranked = sorted(self._candidates.items(), key=lambda kv: (-kv[1], kv[0]))
+        return [code for code, _ in ranked]
+
+    def named(self) -> dict[str, str]:
+        """Slots that are both learned and named -- the only ones offerable
+        as a cycle option. An unnamed slot has no label that isn't either
+        invented or an opaque hex id, so it stays out of the UI until the
+        user supplies one."""
+        with self._lock:
+            return {slot: record["name"] for slot, record in self._slots.items() if record["name"]}
+
+    def snapshot(self) -> dict:
+        with self._lock:
+            return {
+                "download_course": self._download_course,
+                "slots": {slot: dict(record) for slot, record in self._slots.items()},
+            }
+
+    def view(self) -> dict:
+        """What the registry sees under FIELD: only what a write or a label
+        can actually be built from, so a descriptor never has to re-apply
+        this module's rules."""
+        with self._lock:
+            if not self._download_course:
+                return {}
+            return {
+                "download_course": self._download_course,
+                "programs": {
+                    slot: {"blob": record["blob"], "name": record["name"]}
+                    for slot, record in self._slots.items()
+                    if self._is_usable(record)
+                },
+            }
+
+    # -- writes -----------------------------------------------------------
+
+    def set_download_course(self, code: str | None) -> None:
+        with self._lock:
+            self._download_course = code or None
+
+    def set_name(self, slot: str, name: str) -> None:
+        with self._lock:
+            record = self._slots.get(slot.upper())
+            if record is not None:
+                record["name"] = name.strip()
+
+    @staticmethod
+    def _is_usable(record) -> bool:
+        """A slot is offerable once it has a name. The device supplies the
+        payload; only the user can supply the label, so this is the whole
+        rule and it is stated once."""
+        return bool(record["name"])
+
+
+def undiscovered(rep: dict, record: dict, courses) -> list[str]:
+    """Cloud slots that aren't yet usable -- unlearned or unnamed. What the
+    Repairs issue counts, and what the options flow asks the user to walk the
+    appliance through. Counts against cloud_slots, not every advertised byte:
+    a slot that is already a selectable course is nothing to set up."""
+    programs = record.get("slots") or {}
+    return [s for s in cloud_slots(rep, courses) if not (programs.get(s) or {}).get("name")]

custom_components/localthings/const.py

@@ -20,86 +20,118 @@ CONF_CA_KEY_PEM = "ca_key_pem"
 CONF_LEAF_CERT_PEM = "leaf_cert_pem"
 CONF_LEAF_KEY_PEM = "leaf_key_pem"
 
-# Device identity, resolved once by the config flow's probe and persisted on
+# Device identity, resolved once by the config flow's probe and persisted
-# the entry (issue #236). These are what the coordinator mints registry keys
+# on the entry (issue #236) -- what the coordinator mints registry keys
-# from at __init__ time, before any poll has happened -- see
+# from at __init__ time, before any poll has happened. Without them,
-# LocalThingsCoordinator.__init__. Without them the coordinator had to seed
+# anything registering before the first poll (e.g. the connection-mode
-# `device_serial` with the host and rebuild its DeviceInfo after the first
+# sensor) got keyed on the IP address permanently.
-# successful poll, so anything that registered in between (the connection-mode
-# sensor, which is added unconditionally rather than from `bound`) was written
-# into the entity/device registry keyed on the IP address permanently.
 #
-# CONF_SERIAL is the *resolved* serial -- registry.identity.resolve_serial's
+# CONF_SERIAL is the resolved serial (registry.identity.resolve_serial's
-# output, i.e. the host itself for a board that reports a placeholder serial
+# output, the host itself for a placeholder-serial board -- issues
-# (issues #83/#189) -- so it matches what _run_discovery computes on the first
+# #83/#189), so it matches what _run_discovery computes on the first poll.
-# poll exactly, and the device identity never changes underneath the registry.
 CONF_SERIAL = "serial"
+# What this entry's devices and entities are keyed on -- normally the OCF
+# device UUID (issue #381). CONF_SERIAL stays alongside it as the pre-v4
+# key to re-key from, and as what corroborates a later change of UUID.
+# Absent until the first live poll, since only the device can report it.
+CONF_DEVICE_KEY = "device_key"
 CONF_MODEL = "model"
 CONF_MANUFACTURER = "manufacturer"
 CONF_DEVICE_TYPE = "device_type"
 
-# Options-flow key (entry.options, not entry.data): lets a user override the
+# entry.data key: modes this device reported itself in but never advertised
-# device-wide remote-control-off write block for a specific device (issue
+# in the same resource's supportedModes (issue #327). Stored on the entry
-# #54). Some devices report remote control off yet still accept certain
+# rather than kept in memory so a mode the device only names while it is
-# writes (e.g. default detergent/softener dosing on a washer, applied even
+# active survives a restart -- see learned.py. Shape:
-# to the built-in programs) -- the block exists to give a clear error
+# {actual_href: [code, ...]}.
-# instead of a silent device-side rejection, but that assumption doesn't
+CONF_LEARNED_MODES = "learned_modes"
-# hold for every model. Defaults to False (block stays on) everywhere it's
+
-# read, so devices this doesn't apply to see no behavior change.
+# Options-flow key: whether learned modes are remembered and offered.
+# Defaults to on; turning it off stops both halves at once (nothing new is
+# learned, nothing already learned is offered) without discarding what was
+# already remembered -- the options flow's reset step does that.
+CONF_LEARN_MODES = "learn_device_modes"
+DEFAULT_LEARN_MODES = True
+
+# entry.data key: cloud "Download" programs discovered on a laundry device
+# (issue #342). Same rationale as CONF_LEARNED_MODES -- a program's full
+# replay payload is only ever visible while the device happens to be sitting
+# on it, so it has to survive a restart -- but a richer shape, because a
+# cloud program also needs a user-supplied name and the device's own
+# Download course code. See cloudcourse.py, which owns the shape. Shape:
+# {"download_course": "87"|null, "slots": {slot: {"blob": ..., "name": ...}}}
+CONF_CLOUD_COURSES = "cloud_courses"
+
+# Options-flow key: whether downloaded programs are offered as selectable
+# cycles and nagged about via the "not set up yet" Repair (issue #364).
+# Defaults to on. Unlike CONF_LEARN_MODES this does not also stop passive
+# observation -- a device that merely *advertises* download slots without
+# the owner ever meaning to use them (SmartThings appears to seed one from
+# the cloud automatically, per #364's reporters) is exactly the case this
+# exists for, and turning it off is the fix. Guided/manual setup stay
+# reachable and still record what they see either way: they are a deliberate
+# per-session action, not the passive background behavior this silences, and
+# leaving them working means flipping the option back on immediately surfaces
+# anything set up in the meantime instead of asking the user to redo it. See
+# coordinator.cloud_courses_enabled for exactly what it gates.
+CONF_CLOUD_COURSES_ENABLED = "cloud_courses_enabled"
+DEFAULT_CLOUD_COURSES_ENABLED = True
+
+# Options-flow key (entry.options, not entry.data): lets a user override
+# the device-wide remote-control-off write block for a specific device
+# (issue #54). Some devices accept certain writes even while reporting
+# remote control off (e.g. a washer's default detergent dosing), so the
+# blanket-block assumption doesn't hold everywhere. Defaults to False
+# (block stays on).
 CONF_BYPASS_REMOTE_CONTROL = "bypass_remote_control_lock"
 
 # Options-flow key: minimum change (in minutes) required before a
-# hysteresis-gated timestamp sensor (currently just finish_time) is allowed
+# hysteresis-gated timestamp sensor (currently just finish_time) reports a
-# to report a new value. Devices commonly revise their own remaining-time
+# new value. Devices commonly revise their remaining-time estimate by a
-# estimate by a minute or two throughout a cycle, and finish_time = now() +
+# minute or two throughout a cycle, and finish_time = now() + remaining
-# remaining drifts by the poll interval between those revisions -- both push
+# drifts with the poll interval between revisions -- both push a fresh
-# a fresh state (and a recorder/logbook entry) far more often than the
+# state far more often than the estimate is meaningfully different. 0
-# estimate is meaningfully different. 0 disables the gate (every computed
+# disables the gate.
-# change is reported, today's behavior).
 CONF_FINISH_TIME_HYSTERESIS_MINUTES = "finish_time_hysteresis_minutes"
 DEFAULT_FINISH_TIME_HYSTERESIS_MINUTES = 3
 
-# The DTLS/CoAP local API binds somewhere in this ephemeral range; which port
+# The DTLS/CoAP local API binds somewhere in this ephemeral range,
-# depends on firmware. Newer builds answer on 49154/49155, but older ones have
+# depending on firmware (newer builds answer on 49154/49155, older ones as
-# been seen as low as 49153, so we sweep the whole range for a live UDP port
+# low as 49153) -- swept for a live UDP port before the expensive DTLS
-# before attempting the (expensive) DTLS handshake.
+# handshake.
 PROBE_PORT_RANGE = list(range(49152, 49161))
 
-# Ports we've historically seen complete a DTLS handshake. When more than one
+# Ports we've historically seen complete a DTLS handshake; tried first when
-# port in the range looks live, these are tried first.
+# more than one port in the range looks live.
 PREFERRED_PROBE_PORTS = [49154, 49155]
 
 # Per-port timeout for the cheap UDP liveness sweep. Closed ports return an
 # ICMP port-unreachable almost immediately; a live-but-silent port is only
-# detected by this timeout elapsing, so keep it short. Only reached now as the
+# detected by this timeout elapsing, so keep it short. Only reached as the
 # fallback for when the ClientHello probe below confirms nothing.
 LIVENESS_PROBE_TIMEOUT_S = 1.5
 
-# Per-port budget for the DTLS ClientHello probe (smartthings-local >= 0.1.2),
+# Per-port budget for the DTLS ClientHello probe (smartthings-local >=
-# the primary port-detection gate. A real DTLS server answers with a
+# 0.1.2), the primary port-detection gate. A real server answers with a
-# HelloVerifyRequest in ~1 RTT, so a live port resolves well inside this; the
+# HelloVerifyRequest in ~1 RTT; the budget only bounds how long a silent
-# budget only bounds how long a *silent* port takes to give up, since the
+# port takes to give up. 3s covers two retransmits on a slow LAN.
-# probe services OpenSSL's retransmit timer rather than reading one dropped
-# ClientHello as dead. 3s covers two retransmits on a slow LAN.
 CLIENTHELLO_PROBE_TIMEOUT_S = 3.0
 CLIENTHELLO_PROBE_RETRIES = 2
 
-# The whole port range is probed at once: each stateless probe is bounded by
+# The whole port range is probed at once: each stateless probe is bounded
-# CLIENTHELLO_PROBE_TIMEOUT_S (unlike a full handshake's 12s), so the sweep
+# by CLIENTHELLO_PROBE_TIMEOUT_S (unlike a full handshake's 12s), so the
-# costs one probe's wall clock rather than the sum of the range. Capped so a
+# sweep costs one probe's wall clock, not the sum of the range. Capped so a
 # widened PROBE_PORT_RANGE can't spawn an unbounded thread pool.
 PROBE_MAX_WORKERS = 12
 
-# Deadline for the blockwise /device/0 GET during the config-flow probe. The
+# Deadline for the blockwise /device/0 GET during the config-flow probe.
-# slowest device observed returns a full dump in ~8s, so 10s leaves headroom
+# The slowest device observed returns a full dump in ~8s.
-# without stalling setup; it matches the per-resource read timeout elsewhere.
 PROBE_GET_TIMEOUT_S = 10.0
 
 # Base for the local (client-side) DTLS source port, distinct from the
-# destination probe ports above. See coordinator._local_source_port for why a
+# destination probe ports above -- see coordinator._local_source_port for
-# fixed per-device source port matters and how the per-device offset is
+# why a fixed per-device source port matters. Mirrors the upstream
-# derived. Base mirrors the upstream smartthings-local reference bridge.
+# smartthings-local reference bridge. Requires smartthings-local >= 0.1.1.
-# Requires smartthings-local >= 0.1.1.
 DTLS_LOCAL_PORT_BASE = 49700
 
 SUMMARY_INTERVAL_S = 30.0
@@ -107,3 +139,9 @@ SUMMARY_INTERVAL_S = 30.0
 DEVICE_SUPPORT_ISSUE_URL = (
     "https://github.com/mbillow/localthings/issues/new?template=device-support.yml"
 )
+
+# Service names (services.py), shared with config_flow.py so the
+# options-flow debug panel calls the exact same service a user could call
+# from an automation (issue #300) -- one code path performs a raw write.
+SERVICE_WRITE_RESOURCE = "write_resource"
+SERVICE_READ_RESOURCE = "read_resource"

custom_components/localthings/diagnostics.py

@@ -16,8 +16,10 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.loader import async_get_integration
 
+from . import cloudcourse
 from .const import DOMAIN
 from .coordinator import LocalThingsCoordinator
+from .registry.capabilities.laundry import cycle_options
 from .registry.redact import redact_resources
 from .registry.subdevices import MAIN
 
@@ -32,36 +34,30 @@ async def async_get_config_entry_diagnostics(
     # disk (listdir + open + read_text), which trips HA's event-loop blocking
     # detector when called inline here. Offload it to the executor.
     stl_version = await hass.async_add_executor_job(pkg_version, "smartthings-local")
+    cloud_courses = coordinator.cloud_courses.snapshot()
 
     # /oic/p, /oic/d, and /oic/res sit outside the /device/0 batch captured
     # below, so they'd otherwise never reach an issue report. /oic/d's `rt`
-    # is OCF's standard device-type declaration; /oic/res is OCF's
+    # is OCF's device-type declaration; /oic/res is OCF's discovery
-    # discovery endpoint, listing every href/Collection the connection
+    # endpoint, relevant to the "Composite Device" model (issue #177). See
-    # hosts -- relevant to the "Composite Device" model (issue #177) where
-    # a single physical device exposes more than one logical subdevice. See
     # registry/identity.py.
     identity = coordinator._identity
 
     def _seed_diag(su) -> dict:
-        # A flat-mode subdevice (issue #205 -- no working /<uuid>/device/0
+        # A flat-mode subdevice (issue #205: no working /<uuid>/device/0
-        # Collection, so its state comes from individually-polled hrefs
+        # Collection, state comes from individually-polled hrefs instead)
-        # instead) has no meaningful seed_path; report the flat_hrefs list
+        # has no meaningful seed_path; report flat_hrefs in its place.
-        # 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
+        # `model` reads modelNum off the already-redacted `resources` rather
-        # the distinct hrefs), and one redaction of this subdevice's canonical
+        # than redacting /information/vs/0 again -- modelNum never matches
-        # view -- `model` reads modelNum off the already-redacted `resources`
+        # redact.py's substring rules, so the value is the same either way.
-        # 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))
+        res = redact_resources(coordinator.device_resources(su))
         return {
             "kind": su.kind,
             "key": su.key,
@@ -69,13 +65,10 @@ async def async_get_config_entry_diagnostics(
             "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
+            # Keyed by this subdevice's canonical hrefs ('/mode/vs/0'), not
-            # it answers on -- '/mode/vs/0' rather than '/mode/vs/1' or
+            # the real ones it answers on ('/mode/vs/1', '/<uuid>/mode/vs/0')
-            # '/<uuid>/mode/vs/0'. That's the form the registry and every
+            # -- the form the registry is written against, so a sibling's
-            # capability are written against, so a sibling's block can be
+            # block reads exactly like the master's `resources` below.
-            # 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,
         }
 
@@ -91,49 +84,34 @@ async def async_get_config_entry_diagnostics(
         if identity is not None
         else None,
         "unbound_hrefs": sorted(coordinator._unbound_hrefs),
-        # This subdevice's own resources, and only this subdevice's -- what
+        # This subdevice's own resources, and only this subdevice's. On a
-        # the module docstring and the adding-device-support skill have
+        # composite device (issue #177) `last_resources` is the union
-        # always described it as ("the parsed /device/0 snapshot"). On a
+        # across every live subdevice keyed by real hrefs, so reporting it
-        # composite device (issue #177) `last_resources` is the union across
+        # raw here would mix a sibling's /mode/vs/1 with the master's
-        # every live subdevice keyed by real hrefs, so reporting it raw here
+        # /mode/vs/0 under no attribution. Each sibling reports its own
-        # would mix a sibling's /mode/vs/1 in with the master's /mode/vs/0
+        # resources in `subdevices` below instead. For a device with no
-        # under no attribution at all. Each sibling reports its own
+        # subdevices, this is byte-identical to `last_resources`.
-        # resources in its own `subdevices` entry below instead. For a
+        "resources": redact_resources(coordinator.device_resources(MAIN)),
-        # 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
+        # #177). subdeviceIdList (the UUID a prefixed subdevice's key comes
-        # to it, so a report shows whether a composite device's subdevice
+        # from) is deliberately NOT redacted here, unlike elsewhere in
-        # was found at all and what it resolved to. subdeviceIdList (the
+        # `resources` -- it's an appliance-internal pairing id, not account
-        # UUID a prefixed subdevice's key comes from) is deliberately NOT
+        # data, and reporting it is what makes this block actionable.
-        # 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
+        # liveness gate rejected -- an unused SmartThings slot, not a real
-        # (the issue #177 reporter's /device/2) that still answers a
+        # second subdevice. Reported alongside subdevices above so a report
-        # same-shaped batch, not a real second subdevice. Reported alongside
+        # shows what was found and why it didn't become an entity.
-        # 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
+                # The reps the liveness gate actually judged -- the one
-                # like the materialized subdevices above. These are the one
+                # thing a reader needs to second-guess a skip, and they
-                # thing a reader needs to second-guess a skip ("is my second
+                # exist nowhere else in this dump: a rejected candidate is
-                # subdevice really absent, or did the gate get it wrong?"),
+                # never polled again or entered into the state cache.
-                # 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
@@ -146,18 +124,41 @@ async def async_get_config_entry_diagnostics(
         ],
         # 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
+        # there" from "never checked".
-        # /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
+        # Reported on its own, not inside `resources`, since it's metadata
-        # metadata about the connection rather than state of any one
+        # about the connection rather than one subdevice's state, and
-        # subdevice -- and because nothing polls it after discovery, so it
+        # nothing polls it after discovery so it would go stale in there.
-        # would go stale in there. Its numofsubdevice count is what
-        # independently corroborates the subdevices/subdevices_skipped split
-        # above.
         "multidevice": redact_resources(coordinator._multidevice),
+        # Modes this unit reported itself in but never advertised (issue
+        # #327). Reported separately from `resources` on purpose: the dump
+        # above stays exactly what the device said, so a triager can still
+        # see the gap these codes were inferred from. Keyed by actual href,
+        # like the store itself.
+        "learned_modes": {
+            "enabled": coordinator.learning_enabled,
+            "codes": coordinator.learned_snapshot(),
+        },
+        # Cloud "Download" programs discovered on this device (issue #342),
+        # reported separately from `resources` for the same reason as
+        # learned_modes above -- the dump there stays exactly what the device
+        # said, and this is what the integration made of it.
+        #
+        # Reported in full, names included. Half of what can go wrong with
+        # this feature is a configuration question -- which programs got
+        # named, which Download course was confirmed, whether a payload was
+        # ever captured for a slot the device advertises -- and none of that
+        # is answerable from the payloads alone. The names are the user's own
+        # words, so this is the one place they appear; they reach a dump only
+        # because its owner chose to download and share it.
+        "cloud_courses": {
+            "advertised_slots": cloudcourse.advertised_slots(coordinator.cloud_course_rep()),
+            "cloud_slots": cloudcourse.cloud_slots(
+                coordinator.cloud_course_rep(), cycle_options(coordinator.device_resources(MAIN))
+            ),
+            **cloud_courses,
+        },
         "integration_version": integration.version,
         "smartthings_local_version": stl_version,
         "observe_mode": coordinator.observe_mode,

custom_components/localthings/entity.py

@@ -18,34 +18,33 @@ from .registry.discovery import BoundEntity, _snake_to_title
 def _is_included(bound: BoundEntity, coordinator: LocalThingsCoordinator) -> bool:
     """Return False if the entity should not be registered for this device.
 
-    Explicit exists_fn takes priority. Otherwise, if the entity has a field,
+    Explicit exists_fn takes priority. Otherwise, if the entity has a
-    require that field to be present in the resource rep so that optional
+    field, require that field to be present in the resource rep so that
-    fields on shared resources don't create phantom entities.
+    optional fields on shared resources don't create phantom entities.
 
-    A stub rep (is_stub_rep — /device/0's "resource exists, no data fetched
+    A stub rep (is_stub_rep) is included anyway so it can be populated by
-    yet" marker) is included anyway so it can be populated by sub-polls. A
+    sub-polls. A genuinely empty {} rep is included too by this default
-    genuinely empty {} rep is included too by this default gate -- whether
+    gate: whether empty means "not populated yet" or "permanently
-    empty means "not populated yet" or "permanently unsupported" needs
+    unsupported" needs per-field domain knowledge this generic gate
-    per-field domain knowledge this generic gate doesn't have: /alarms/vs/0's
+    doesn't have (e.g. /alarms/vs/0's {} is fridge.py's documented normal
-    {} is fridge.py's documented *normal* no-alarm state (see
+    no-alarm state, not an absence signal). Only a capability whose author
-    _active_alarm_codes), not an absence signal, and it's far from the only
+    has verified a field is genuinely never populated opts into stricter
-    resource like that. Only a capability whose author has actually verified
+    gating with its own exists_fn (see common.ENERGY_METER, issue #127).
-    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
+    `bound.href` is already the actual href (issue #177); `exists_fn` gets
-    BoundEntity/Subdevice), so the direct cache lookup below is correct as-is;
+    `bound`'s own subdevice's canonical view instead of the raw snapshot,
-    `exists_fn` gets `bound`'s own subdevice's *canonical* view instead of the
+    same rule as everywhere else a whole-resources-dict scan happens --
-    raw snapshot, same rule as everywhere else a whole-resources-dict scan
+    this is a free function, so it can't use self._resources.
-    happens (coordinator.canonical_resources) -- this is a free function, not
+
-    an LocalThingsEntity method, so it can't use self._resources.
+    Reads `discovery_resources`, not `last_resources`: on an offline load
+    (issue #295) the live cache is still empty, and judging existence
+    against it would filter every rehydrated entity away.
     """
-    rep = coordinator.last_resources.get(bound.href)
+    rep = coordinator.discovery_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.canonical_resources(bound.subdevice))
+        return bound.desc.exists_fn(rep, coordinator.discovery_canonical(bound.subdevice))
     if bound.desc.field:
         if not rep or is_stub_rep(rep):
             return True
@@ -89,7 +88,7 @@ class LocalThingsEntity(CoordinatorEntity[LocalThingsCoordinator]):
         super().__init__(coordinator)
         self._bound = bound
         self._state_key = _key(bound)
-        self._attr_unique_id = f"{DOMAIN}_{coordinator.device_serial}_{self._state_key}"
+        self._attr_unique_id = f"{DOMAIN}_{coordinator.device_key}_{self._state_key}"
         if bound.desc.translation_placeholders is not None:
             self._attr_translation_placeholders = dict(bound.desc.translation_placeholders)
         elif bound.desc.use_instance_name:
@@ -97,12 +96,10 @@ class LocalThingsEntity(CoordinatorEntity[LocalThingsCoordinator]):
                 "instance_name": _instance_display_name(bound, self._state_key)
             }
 
-        # _attr_name is deliberately left unset: Home Assistant gives an
+        # _attr_name is deliberately left unset: HA gives an explicitly-set
-        # explicitly-set name precedence over the translation catalog, so
+        # name precedence over the translation catalog, so setting it here
-        # setting it here would make every entity untranslatable. Every
+        # would make every entity untranslatable. A platform that wants the
-        # descriptor resolves to a catalog entry (see translation_key below);
+        # bare device name sets _attr_name = None itself (see fan.py).
-        # a platform that wants the bare device name instead sets
-        # _attr_name = None itself, as fan.py does for the hood's main entity.
         self._attr_icon = bound.desc.icon
         raw_cat = bound.desc.entity_category
         self._attr_entity_category = EntityCategory(raw_cat) if raw_cat else None
@@ -112,18 +109,12 @@ class LocalThingsEntity(CoordinatorEntity[LocalThingsCoordinator]):
     def translation_key(self) -> str | None:
         """The descriptor's catalog key, defaulting to its own `key`.
 
-        Overrides Entity.translation_key (a property upstream, not a plain
+        Overrides Entity.translation_key so a callable descriptor (e.g.
-        attribute) so a callable descriptor -- e.g. laundry.cycle_select's
+        laundry.cycle_select's table-id-gated resolver) is re-evaluated
-        table-id-gated resolver -- is re-evaluated against live coordinator
+        against live coordinator data on every access, not resolved once
-        data on every access, not resolved once at construction time.
+        at construction time -- a static resolution would risk baking in
-
+        a permanent None if the first poll handed a sibling an empty stub
-        Discovery runs on the first /device/0 poll, which the entity
+        rep (see _is_included's docstring) before it populated.
-        registry already documents can hand a sibling resource an empty
-        stub rep before it's actually been fetched (see _is_included's
-        docstring) -- a static one-time resolution here would risk baking
-        in a permanent None (no translation) for the entity's whole
-        lifetime if that stub hadn't populated yet, even once the real
-        value arrives on a later poll.
         """
         tk = self._bound.desc.translation_key
         if callable(tk):
@@ -133,12 +124,11 @@ class LocalThingsEntity(CoordinatorEntity[LocalThingsCoordinator]):
     @property
     def _resources(self) -> dict:
         """This entity's own subdevice's canonical resources view (issue
-        #177) -- see coordinator.canonical_resources. Every platform
+        #177) -- see coordinator.canonical_resources. Any platform property
-        property that needs the *whole* resources dict, as opposed to one
+        needing the whole resources dict, not one href via
-        href via `coordinator.resource(href)`, must read through this
+        `coordinator.resource(href)`, must read through this instead of
-        instead of `coordinator.last_resources`, or a sibling subdevice's own
+        `coordinator.last_resources`, or a sibling subdevice's own hrefs
-        actual hrefs would leak into (or be missing from) this entity's
+        could leak into this entity's view. For MAIN this is exactly
-        view. For MAIN (every device with no subdevices) this is exactly
         `coordinator.last_resources`."""
         return self.coordinator.canonical_resources(self._bound.subdevice)
 

custom_components/localthings/fan.py

@@ -4,15 +4,14 @@ Four FanDesc-bound hrefs exist, dispatched by href in async_setup_entry
 below since each needs different HA fan semantics: the range hood's fan
 speed and the older ARTIK051_TVTL air-purifier family's Auto/Sleep/Low/
 Medium/High (issue #56) are both an ordered set of numeric levels
-(SET_SPEED) -- the latter confirmed monotonic in capabilities/
+(SET_SPEED), confirmed monotonic in capabilities/air_purifier.py's module
-air_purifier.py's module docstring, with no named-mode list to preserve
+docstring, with no named-mode list since this board never self-reports one.
-since this board never self-reports one. The TP1X air-purifier family's
+The TP1X air-purifier family's modes (Smart/Max/Mid/WindFree/Sleep, issue
-modes (Smart/Max/Mid/WindFree/Sleep, issue #130) and the A-VTWW-TP2-21
+#130) and the A-VTWW-TP2-21 family's /wind/strength/vs/0 modes (issue #151)
-family's /wind/strength/vs/0 modes (issue #151) are both named behaviors
+are both named behaviors with no linear order (PRESET_MODE) --
-with no linear order (PRESET_MODE) -- LocalThingsAirPurifierFan handles
+LocalThingsAirPurifierFan handles both hrefs, the only difference being
-both hrefs, the only difference being whether the label comes straight
+whether the label comes from supportedModes or a parallel modesName array
-from supportedModes or from a parallel modesName array (see
+(see _label_for_code)."""
-_label_for_code)."""
 
 from __future__ import annotations
 
@@ -76,19 +75,14 @@ class LocalThingsRangeHoodFan(LocalThingsEntity, FanEntity):
 
     Some boards that reuse this capability (built-in microwave vent fans,
     issues #137/#142) report no sibling `/power/0` or `/power/vs/0`
-    resource at all -- fan speed 0 is itself the off state there, with no
+    resource at all -- fan speed 0 is itself the off state there.
-    separate power toggle to write. `_speed_zero_is_off` detects that
+    `_speed_zero_is_off` detects that shape and switches every method
-    shape from the hood resource's own settableMinFanSpeed/
+    below to drive off/on purely through the fanSpeed field.
-    supportedFanSpeed fields and switches every method below to drive
-    off/on purely through the fanSpeed field, including '0' in the
-    ordered speed codes as the off step instead of assuming every
-    advertised code is an active speed.
 
-    This is deliberately not the same question as `_has_separate_power`,
+    Deliberately not the same question as `_has_separate_power`, which
-    which only proves *some* power resource exists on the device --  on a
+    only proves some power resource exists on the device -- on a combi
-    combi appliance (e.g. an over-the-range microwave) that resource can
+    appliance that resource can belong to the cavity, not the vent fan,
-    belong to the cavity, not the vent fan, and toggling it from here
+    and toggling it from here would turn off the whole appliance.
-    would turn off the whole appliance instead of just the fan.
     """
 
     _enable_turn_on_off_backwards_compatibility = False
@@ -112,10 +106,9 @@ class LocalThingsRangeHoodFan(LocalThingsEntity, FanEntity):
 
     def _speed_zero_is_off(self) -> bool:
         """Whether fan speed '0' is itself this hood's off step, with no
-        separate power resource to toggle. The board says so directly:
+        separate power resource to toggle -- settableMinFanSpeed '0', or
-        settableMinFanSpeed '0', or '0' inside supportedFanSpeed. The
+        '0' inside supportedFanSpeed. False for the standalone hood, whose
-        standalone hood's codes start at 14 and it carries a real /power
+        codes start at 14 and which carries a real /power resource."""
-        resource instead, so this is False there."""
         rep = self._rep(self._bound.href)
         return (
             str(rep.get(_MIN_FAN_SPEED_FIELD, "")) == _OFF_SPEED_CODE
@@ -140,12 +133,10 @@ class LocalThingsRangeHoodFan(LocalThingsEntity, FanEntity):
     def _active_speed_codes(self) -> list[str]:
         codes = self._all_speed_codes()
         if self._speed_zero_is_off():
-            # No separate power resource: '0' is the off step, not a speed.
             return [code for code in codes if code != _OFF_SPEED_CODE]
-        # Power is carried by the separate /power resource.  fanSpeed
+        # Power is carried by the separate /power resource; fanSpeed
-        # retains the selected setting while power is off (as the
+        # retains the selected setting while power is off, so every
-        # lamp's `current` field does), so every advertised code is an
+        # advertised code is an active ordered speed.
-        # active ordered speed.
         return codes
 
     def _power_payload(self, enabled: bool) -> tuple[str, bool, str]:
@@ -268,15 +259,12 @@ class LocalThingsAirPurifierFan(LocalThingsEntity, FanEntity):
     def _label_for_code(self, code) -> str:
         """Lowercased HA preset label for a device mode code.
 
-        The TP1X_DA-AC-AIR board (issue #130) reports its named modes
+        The TP1X_DA-AC-AIR board (issue #130) reports named modes directly
-        directly as supportedModes ('Smart'/'Max'/...), so the code IS the
+        as supportedModes, so the code IS the label. The A-VTWW-TP2-21
-        label. The A-VTWW-TP2-21 board (issue #151) instead reports numeric
+        board (issue #151) instead reports numeric wind-strength codes with
-        wind-strength codes ('87'/'89'/...) with a separate modesName array
+        a separate modesName array giving the real names -- same shape as
-        (parallel-indexed with supportedModes) giving the actual names --
+        climate.py's _wind_strength_label, and coincidentally the same word
-        same shape as climate.py's _wind_strength_label, and coincidentally
+        set, so both generations land on identical HA preset values."""
-        the same word set (Smart/Max/WindFree/Sleep), so both board
-        generations land on identical HA preset values without needing
-        their own translation catalog entry."""
         rep = self._mode_rep()
         supported = list(rep.get(_SUPPORTED_MODES_FIELD, ()))
         names = rep.get(_MODES_NAME_FIELD)
@@ -327,11 +315,8 @@ class LocalThingsAirPurifierFan(LocalThingsEntity, FanEntity):
 
 _AIRFLOW_SPEED_FIELD = "speed"
 # Raw `speed` codes, low-to-high -- confirmed monotonic (Auto=0, Sleep=1,
-# Low=2, Medium=3, High=4) via air_purifier.py's module docstring. Ordered
+# Low=2, Medium=3, High=4) via air_purifier.py's module docstring. Treated
-# as plain strings, same as _all_speed_codes above, so
+# as plain ordered strings, same as the range hood's numeric levels.
-# ordered_list_item_to_percentage/percentage_to_ordered_list_item can treat
-# it exactly like the range hood's numeric levels -- no named-preset table
-# needed since this board never reports mode names to hang one off of.
 _AIRFLOW_SPEED_CODES = ["0", "1", "2", "3", "4"]
 
 
@@ -354,14 +339,11 @@ class LocalThingsAirflowFan(LocalThingsEntity, FanEntity):
     def _power_payload(self, enabled: bool) -> tuple[str, bool, str]:
         """Prefer /power/0 like LocalThingsRangeHoodFan above, NOT
         LocalThingsAirPurifierFan's vs/0-first order -- that order is only
-        harmless for the TP1X board because it never reports /power/0 at
+        harmless for the TP1X board because it never reports /power/0.
-        all. This family's dumps carry both hrefs, and common.POWER_GENERIC
+        This family's dumps carry both hrefs, and common.POWER_GENERIC is
-        (the power_switch entity) is unconditionally bound to /power/0
+        unconditionally bound to /power/0 when present, so writing to
-        whenever it's present, so writing here to /power/vs/0 first would
+        /power/vs/0 first would leave power_switch and this fan
-        leave power_switch and this fan reading/writing two different
+        disagreeing until the next poll."""
-        resources -- disagreeing until the next poll refreshes the other
-        one (the same optimistic-apply lag coordinator.py's own comments
-        warn about)."""
         resources = self._resources
         target = POWER_HREF if POWER_HREF in resources else POWER_VS_HREF
         return "power", enabled, target

custom_components/localthings/learned.py

@@ -0,0 +1,128 @@
+"""Modes a device reports itself in but never advertises as supported.
+
+Some firmwares report a current mode that is missing from the same
+resource's own supported list (issue #327: an ARTIK051 air conditioner
+sitting in 'Quiet' with supportedModes [Off, Sleep, Speed, Nano,
+NanoSleep]). The mode is real -- the remote and the SmartThings app select
+it, and the unit accepts it written back -- so once the device has been
+seen in it, it is remembered and offered alongside the advertised ones.
+
+Learning is deliberately not global. A current value that isn't a
+selectable option is common across this corpus -- an oven idling in
+'NoOperation', a fridge's /mode/vs/0 carrying capability tokens like
+'WATERFILTER_DISABLE' -- and remembering one of those permanently would
+put an option in the UI that the device can only reject. LEARNABLE names
+the canonical hrefs where a reported mode is known to be genuinely
+selectable, and the coordinator narrows it further to the hrefs this
+device actually binds a climate entity to (see _refresh_learnable_hrefs):
+the same href is declared explicitly unmodeled on a dehumidifier and
+empty on an air purifier, and learning for those would persist a code
+nothing ever offers.
+
+This module also owns the entry key the store persists under, so the
+shape lives in exactly one place.
+"""
+
+from __future__ import annotations
+
+import threading
+
+from .const import CONF_LEARNED_MODES
+from .registry.capabilities.airconditioner import HREF_CONVENIENT
+
+MODES_FIELD = "x.com.samsung.da.modes"
+SUPPORTED_FIELD = "x.com.samsung.da.supportedModes"
+
+# Convenient (preset) mode: firmware omits an active preset (e.g. Quiet)
+# from its own supportedModes -- a reporting gap, not a capability
+# difference (issue #327).
+LEARNABLE: frozenset[str] = frozenset({HREF_CONVENIENT})
+
+
+def _codes(value) -> list[str]:
+    """Mode codes from a `modes`-style field, which some firmwares send as
+    a bare string rather than an array."""
+    if isinstance(value, str):
+        return [value]
+    if isinstance(value, (list, tuple)):
+        return [v for v in value if isinstance(v, str)]
+    return []
+
+
+def _coerce(stored) -> dict[str, list[str]]:
+    """Restore the persisted map, dropping anything that isn't the shape
+    this module writes. It round-trips through the config entry as plain
+    JSON, and a hand-edited .storage file shouldn't be able to crash
+    setup."""
+    if not isinstance(stored, dict):
+        return {}
+    restored = {}
+    for href, codes in stored.items():
+        if isinstance(href, str) and (valid := [c for c in _codes(codes) if c]):
+            restored[href] = valid
+    return restored
+
+
+def stored(entry) -> dict[str, list[str]]:
+    """What `entry` has persisted, coerced -- for a reader that can't go
+    through a coordinator (the options flow, on an unloaded entry)."""
+    return _coerce(entry.data.get(CONF_LEARNED_MODES))
+
+
+def persist(hass, entry, codes: dict[str, list[str]]) -> None:
+    """Write `codes` onto the entry. Runs on the event loop, which
+    async_update_entry requires."""
+    hass.config_entries.async_update_entry(entry, data={**entry.data, CONF_LEARNED_MODES: codes})
+
+
+class LearnedModes:
+    """Per-device store of learned codes, keyed by actual (on-the-wire)
+    href so two subdevices of one composite appliance learn separately.
+
+    Mutated from whichever thread applied the update (the DTLS reader for
+    an OBSERVE notify, an executor thread for a poll -- see
+    ObserveManager.apply), so every access takes the lock; persistence is
+    the caller's job, on the event loop.
+    """
+
+    def __init__(self, stored=None) -> None:
+        self._lock = threading.Lock()
+        self._learned = _coerce(stored)
+
+    def observe(self, actual_href: str, rep: dict) -> list[str]:
+        """Learn from one applied rep; returns the codes newly learned, so
+        an empty list means there is nothing to persist.
+
+        A rep that carries no supported list teaches nothing: "missing from
+        the list" is only meaningful against a list that exists, and
+        inventing one for a device that publishes none would offer options
+        nothing ever said were selectable. `rep` is the merged rep
+        ObserveManager.apply stores, so a partial notify carrying `modes`
+        alone (issue #27) still sees the supported list from the last full
+        poll.
+        """
+        supported = _codes(rep.get(SUPPORTED_FIELD))
+        if not supported:
+            return []
+        with self._lock:
+            known = self._learned.get(actual_href, [])
+            new = [
+                code
+                for code in _codes(rep.get(MODES_FIELD))
+                if code and code not in supported and code not in known
+            ]
+            if new:
+                self._learned[actual_href] = [*known, *new]
+        return new
+
+    def codes(self, actual_href: str) -> list[str]:
+        with self._lock:
+            return list(self._learned.get(actual_href, ()))
+
+    def snapshot(self) -> dict[str, list[str]]:
+        with self._lock:
+            return {href: list(codes) for href, codes in self._learned.items()}
+
+    def clear(self) -> None:
+        with self._lock:
+            self._learned = {}

custom_components/localthings/manifest.json

@@ -1,6 +1,7 @@
 {
   "domain": "localthings",
   "name": "LocalThings",
+  "after_dependencies": ["recorder"],
   "codeowners": ["@mbillow"],
   "config_flow": true,
   "dependencies": [],
@@ -10,7 +11,7 @@
   "requirements": [
     "cbor2>=5.4.6",
     "pyOpenSSL>=23.0",
-    "smartthings-local>=0.1.2"
+    "smartthings-local>=0.1.8"
   ],
-  "version": "0.19.0"
+  "version": "0.24.0"
 }

custom_components/localthings/observe.py

@@ -14,6 +14,7 @@ from __future__ import annotations
 import logging
 import threading
 import time
+from collections.abc import Callable
 
 import cbor2
 from smartthings_local.ocf.observe_refresh import ObserveRefreshTask
@@ -55,6 +56,26 @@ SUCCESS_FRACTION = 0.8
 PUSH_HEALTH_WINDOW_S = 60.0
 
 
+def _is_alarms_href(href: str) -> bool:
+    """True for /alarms/vs/<index> in any subdevice-translated shape --
+    the canonical MAIN form (/alarms/vs/0), an indexed subdevice's
+    renumbered instance (/alarms/vs/<key>), or a prefixed subdevice's
+    UUID-qualified form (/<uuid>/alarms/vs/0). `Subdevice.to_actual`
+    (registry/subdevices.py) only ever rewrites the trailing index
+    segment or prepends a prefix -- it never touches the 'alarms/vs'
+    stem -- so matching that fixed segment plus a wildcard tail catches
+    every shape without this module needing to be subdevice-aware.
+
+    See `ObserveManager.apply`'s use of this for why the href matters:
+    unlike most resources, /alarms/vs/0's `x.com.samsung.da.items` array
+    is a complete snapshot of every currently-active alarm, not a
+    possibly-partial field update -- so it must never be merged onto a
+    stale prior rep (issue #348).
+    """
+    head, _, _ = href.rpartition("/")
+    return head.endswith("/alarms/vs")
+
+
 class ObserveManager:
     """Per-device observe-mode state: mode, write-settle guard, and (later)
     subscription/staleness tracking. Pure sync logic — safe to call from
@@ -74,13 +95,31 @@ class ObserveManager:
         self._notified: set[str] = set()
         self._last_notify_ts: float | None = None
         # Wakes try_enter_observe_mode's grace wait early once enough hrefs
-        # have notified. Guards only `_notified` mutations + the `wait_for`.
+        # have notified. Guards `_notified` mutations, the `wait_for`, and
+        # fallback_hrefs (enter_observe_mode assignment, on_notification
+        # discard).
         self._notify_cond = threading.Condition()
+        # Idle while polling, except after downgrade_to_poll (every href
+        # that was subscribed). While in observe mode this is the set of
+        # subscribed hrefs that have not yet notified (issue #92) -- they
+        # stay on the hot/warm sub-poll cadence. on_notification discards
+        # an href once it pushes, so a late first notify self-corrects.
         self.fallback_hrefs: set[str] = set()
+        self._on_applied: Callable[[str, dict, str], None] | None = None
         self._refresh_task: ObserveRefreshTask | None = None
         self._refresh_stop: threading.Event | None = None
         self._refresh_thread: threading.Thread | None = None
 
+    def set_on_applied(self, callback: Callable[[str, dict, str], None]) -> None:
+        """Hook run after every accepted rep, on the applying thread.
+
+        Unlike StateCache.set_on_change it carries the href and rep, and
+        fires even when the rep is unchanged -- which learned.py needs, a
+        device sitting in an unadvertised mode re-sending the same rep
+        every poll.
+        """
+        self._on_applied = callback
+
     def mark_write_pending(self, href: str, settle_s: float = DEFAULT_SETTLE_S) -> None:
         with self._settle_lock:
             self._settle_until[href] = time.monotonic() + settle_s
@@ -110,6 +149,20 @@ class ObserveManager:
         comes through, even though nothing about the device's actual
         supported options changed.
 
+        `_is_alarms_href` is the one exception to that merge (issue #348):
+        /alarms/vs/0's `items` array is always sent as a complete
+        snapshot of every currently-active alarm, never a partial delta
+        -- confirmed by a live `read_resource` GET returning `{}` (no
+        `items` key at all) the moment a washer's board actually clears
+        an alarm, which entity.py already documents as this resource's
+        normal no-alarm shape. Merging that `{}` onto the prior rep the
+        same way as everywhere else silently kept the stale `items`
+        entry forever: an absent key merges as "unchanged" everywhere
+        else, but on this href absent specifically means "cleared".
+        Every family that exposes an alarm sensor shares this href
+        (common.ALARMS, range_hood's own copy), so this is a full
+        replace for all of them, not a washer-specific carve-out.
+
         `apply()` is the sole path StateCache mutations flow through in
         this component (poll, sweep, and OBSERVE notify all funnel here),
         so `_cache_lock` serializes the read-then-write across those
@@ -137,8 +190,15 @@ class ObserveManager:
             self.log.debug("dropping %s update for %s (settling)", source, href)
             return False
         with self._cache_lock:
-            merged = {**(self.cache.get(href) or {}), **rep}
+            merged = dict(rep) if _is_alarms_href(href) else {**(self.cache.get(href) or {}), **rep}
-            return self.cache.apply_rep(href, merged, source=source)
+            changed = self.cache.apply_rep(href, merged, source=source)
+        # Outside the cache lock -- the hook takes locks of its own and
+        # never reads the cache back. `source` is passed along rather than
+        # filtered here: which sources are worth acting on is the hook's
+        # policy, not this manager's.
+        if self._on_applied is not None:
+            self._on_applied(href, merged, source)
+        return changed
 
     def on_notification(self, href: str, payload: bytes) -> None:
         """Wired as DtlsCoapSession.on_notification. Runs on the DTLS
@@ -152,6 +212,10 @@ class ObserveManager:
             return
         with self._notify_cond:
             self._notified.add(href)
+            # Snapshot in enter_observe_mode is at the 80% quorum, not the
+            # full grace period -- a late first push (blockwise refetch)
+            # must drop the href so we don't keep GET-polling a live one.
+            self.fallback_hrefs.discard(href)
             self._last_notify_ts = time.monotonic()
             self._notify_cond.notify_all()
         self.log.debug("observe notify: %s", href)
@@ -171,17 +235,16 @@ class ObserveManager:
             self._last_notify_ts is not None and time.monotonic() - self._last_notify_ts < window_s
         )
 
-    def try_enter_observe_mode(
+    def subscribe_hrefs(self, session, hrefs: list[str]) -> set[str]:
-        self,
+        """Register OBSERVE on every href; returns the ones that took.
-        session,
+        Blocking — run in an executor.
-        hrefs: list[str],
+
-        grace_period_s: float = GRACE_PERIOD_S,
+        Split from the grace wait below (issue #294) so the coordinator can
-        success_fraction: float = SUCCESS_FRACTION,
+        hold its session lock for just these sends -- each is a fire-and-
-    ) -> bool:
+        forget UDP datagram (DtlsCoapSession.subscribe doesn't wait for the
-        """Blocking — subscribes to every href then waits up to
+        device's ack), unlike the wait, which can block for the whole grace
-        `grace_period_s`, returning early once `success_fraction` of hrefs
+        period and must not hold a lock a command write is also waiting on.
-        have notified. Caller must run this in an executor, never on the
+        """
-        event loop."""
         with self._notify_cond:
             self._notified.clear()
         subscribed: set[str] = set()
@@ -192,30 +255,72 @@ class ObserveManager:
                 subscribed.add(href)
             except Exception as e:
                 self.log.warning("subscribe %s failed: %s", href, e)
+        return subscribed
+
+    def await_observe_notifies(
+        self,
+        subscribed: set[str],
+        grace_period_s: float = GRACE_PERIOD_S,
+        success_fraction: float = SUCCESS_FRACTION,
+    ) -> bool:
+        """Blocking — waits up to `grace_period_s`, returning early once
+        `success_fraction` of `subscribed` have notified. Touches no
+        session; safe to run without holding a session lock."""
         if not subscribed:
-            self._stop_refresh_task()
-            self._set_mode(MODE_POLL)
-            self.subscribed_hrefs = set()
             return False
 
         def _fraction_reached() -> bool:
             return len(set(self._notified) & subscribed) / len(subscribed) >= success_fraction
 
         with self._notify_cond:
-            reached = self._notify_cond.wait_for(
+            return self._notify_cond.wait_for(_fraction_reached, timeout=grace_period_s)
-                _fraction_reached,
-                timeout=grace_period_s,
-            )
 
-        if reached:
+    def enter_observe_mode(self, session, subscribed: set[str]) -> None:
-            self.subscribed_hrefs = subscribed
+        """Commit a successful attempt. Caller must have re-confirmed
-            self._set_mode(MODE_OBSERVE)
+        `session` is still the live one under its session lock (issue
-            self.start_refresh_task(session)
+        #294) -- committing against a session a reconnect already replaced
-            return True
+        would claim observe mode with nothing left to notice it's dead."""
+        self.subscribed_hrefs = set(subscribed)
+        # Issue #92: subscribed-but-silent hrefs are counted as covered by
+        # push if we drop this, but they never emit a notify. Keep them on
+        # the poll cadence via fallback_hrefs (otherwise idle in observe).
+        # Same lock as on_notification's discard so a notify in this window
+        # cannot land on a set object that is about to be replaced.
+        with self._notify_cond:
+            self.fallback_hrefs = set(subscribed) - self._notified
+        self._set_mode(MODE_OBSERVE)
+        self.start_refresh_task(session)
 
+    def abandon_observe_attempt(self) -> None:
+        """Drop a failed or stale attempt: no subscriptions worth keeping."""
         self._stop_refresh_task()
         self.subscribed_hrefs = set()
         self._set_mode(MODE_POLL)
+
+    def try_enter_observe_mode(
+        self,
+        session,
+        hrefs: list[str],
+        grace_period_s: float = GRACE_PERIOD_S,
+        success_fraction: float = SUCCESS_FRACTION,
+    ) -> bool:
+        """Blocking — subscribes to every href then waits up to
+        `grace_period_s`, returning early once `success_fraction` of hrefs
+        have notified. Caller must run this in an executor, never on the
+        event loop.
+
+        Single-threaded convenience wrapper around the phase split above
+        (subscribe_hrefs / await_observe_notifies / enter_observe_mode /
+        abandon_observe_attempt) for callers -- direct and most existing
+        tests -- that don't need the lock-scoping those phases exist for."""
+        subscribed = self.subscribe_hrefs(session, hrefs)
+        if not subscribed:
+            self.abandon_observe_attempt()
+            return False
+        if self.await_observe_notifies(subscribed, grace_period_s, success_fraction):
+            self.enter_observe_mode(session, subscribed)
+            return True
+        self.abandon_observe_attempt()
         return False
 
     def _set_mode(self, mode: str) -> None:

custom_components/localthings/registry/batch.py

@@ -18,12 +18,17 @@ def is_stub_rep(rep: dict) -> bool:
 def parse_device0_batch(device0: list) -> dict[str, dict]:
     """Extract {href: rep} from a /device/0 CBOR list response.
 
+    Most devices put a collection representation without an ``href`` at
+    index 0, while some firmware starts directly with resource entries.
+    Iterate the whole list and let the existing href check ignore collection
+    metadata so the first real resource is preserved in either shape.
+
     A stub rep is passed through unchanged rather than collapsed to {} --
     downstream code (entity._is_included, capability exists_fns) uses
     is_stub_rep to tell "not fetched yet" apart from a confirmed-empty {}.
     """
     out = {}
-    for entry in device0[1:]:  # skip [0] (device-level rep)
+    for entry in device0:
         if not isinstance(entry, dict):
             continue
         href = entry.get("href")

custom_components/localthings/registry/by_type/__init__.py

@@ -63,9 +63,9 @@ _REGISTRY_BY_KEY: dict[str, DeviceRegistry] = {
 
 # Consumer-model prefix (first two letters of the '_'-delimited token in
 # `description` right before any '/board-info' suffix) -> registry key.
-# NOT derived from `modelNum` -- washer and dryer share the same 'DA_WM_'
+# NOT derived from `modelNum`: washer and dryer share the same 'DA_WM_'
-# internal board-family prefix there, and dishwasher's modelNum contains
+# board-family prefix there, and dishwasher's modelNum contains the
-# the substring 'WW', so a modelNum-only rule misroutes both.
+# substring 'WW', so a modelNum-only rule misroutes both.
 _CONSUMER_PREFIX_TO_KEY: dict[str, str] = {
     "WW": "washer",
     "WD": "washer",
@@ -79,48 +79,39 @@ _CONSUMER_PREFIX_TO_KEY: dict[str, str] = {
 # Board-family token -> registry key, matched against whole tokens of
 # `modelNum`/`description` (see `_board_tokens`).
 #
-# Tokenizing instead of substring-matching is what keeps this a table rather
+# Tokenizing instead of substring-matching keeps this a table rather than a
-# than a ladder of hand-written rules. Samsung spells the same board family
+# ladder of hand-written rules: Samsung spells the same board family with
-# with either delimiter -- 'TP1X_DA-AC-RAC-01001' and 'TP2X_RAC_20K' are the
+# either delimiter ('TP1X_DA-AC-RAC-01001' vs 'TP2X_RAC_20K', both RAC), so
-# same RAC family -- so a substring rule has to be written once per spelling
+# a substring rule would need writing once per spelling, and a token with
-# ('_RAC_' *and* '-RAC-'), and a token that lands at the end of the
+# no trailing delimiter ('ARTIK051_DONGLE_REF') would match neither.
-# pipe-prefix with no trailing delimiter ('ARTIK051_DONGLE_REF', issues #77
-# and #83) matches no '_TOKEN_' spelling at all. Whole-token matching sees
-# every one of those as a single entry.
 #
-# Entries must name the *specific* device type, never the board family that
+# Entries must name the specific device type, never the board family that
 # contains it: 'DA-AC-' prefixes RAC/WAC/DHM/AIR alike, so a bare 'AC' entry
 # would swallow the dehumidifier and the air purifier. Where two families
-# genuinely share a resource surface they share a registry (all the
+# genuinely share a resource surface they share a registry (the
-# air-conditioner spellings below), which is a statement about the hardware,
+# air-conditioner spellings below), which is a statement about the
-# not a shortcut.
+# hardware, not a shortcut.
 _BOARD_TOKEN_TO_KEY: dict[str, str] = {
     "REF": "refrigerator",
-    # Air conditioners. Every one of these is a distinct board family with
+    # Air conditioners: distinct board families sharing one resource
-    # the same resource surface: room (issues #37, #91), package, Korean
+    # surface -- room, package, Korean (#136), window (#87), 2-in-1
-    # (#136), window (#87), 2-in-1 floor+wall (#150, #153), system/commercial
+    # floor+wall (#150/#153), system/commercial (#52), cassette (#191), and
-    # (#52), cassette (#191), and ARA-WW wall-mount (#115, #116, #117, #120).
+    # ARA-WW wall-mount (#115-120).
     "RAC": "airconditioner",
     "PRAC": "airconditioner",
     "KRAC": "airconditioner",
     "WAC": "airconditioner",
     "FAC": "airconditioner",
     "CAWW": "airconditioner",
-    "CAC": "airconditioner",  # issue #191 -- TP1X_DA-AC-CAC-01001_0000
+    "CAC": "airconditioner",  # issue #191
     "ARA": "airconditioner",
     "DHM": "dehumidifier",  # issue #88 -- target humidity, no climate
-    "EHS": "ehs",  # Eco Heating System air-to-water heat pump --
+    "EHS": "ehs",  # heat pump: zone1 heating/cooling + domestic hot water
-    # zone1 space heating/cooling + dhw domestic
-    # hot water, its own /mode/*/vs/0 and
-    # /temperatures/*/vs/0 resource shapes
     "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
+    # issue #190: same lineage as VTWW, but the '-WW-' delimiter falls one
-    # next-gen BESPOKE Cube Air board; same
+    # letter left ('A-VTWW-' -> 'AVT-WW-'), splitting into a different token.
-    # lineage as VTWW above but the '-WW-'
+    "AVT": "air_purifier",
-    # 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,13 +120,12 @@ _BOARD_TOKEN_TO_KEY: dict[str, str] = {
     "OVEN": "oven",  # issue #55 -- wall oven, no burners
     "MICROWAVE": "microwave",  # issues #66, #121
     "COOKTOP": "induction_cooktop",  # issue #86 -- standalone, no oven
-    # Legacy ARTIK051 gas cooktops ('ARTIK051_GB_CT_001'), whose burner state
+    # Legacy ARTIK051 gas cooktops ('ARTIK051_GB_CT_001'): burner state
-    # lives in /mode/vs/0's options array. Deliberately a bare two-letter
+    # lives in /mode/vs/0's options array. Deliberately the loosest entry
-    # token, and so the loosest entry in this table -- it is only ever
+    # here -- reached only when nothing more specific matched, since its
-    # reached by a device that matched nothing more specific, and its
+    # description ('ARTIK051_GLOBAL_COOKTOP') would otherwise read as an
-    # `description` ('ARTIK051_GLOBAL_COOKTOP') would otherwise read as an
+    # induction cooktop via COOKTOP above (see for_device_by_model's field
-    # induction cooktop via the COOKTOP entry above. See `for_device_by_model`
+    # ordering).
-    # for the field ordering that makes that resolve correctly.
     "CT": "cooktop",
     "VSKR": "vacuum_station",  # issue #131 -- stick-vacuum clean station
     "DF": "air_dresser",  # issue #162
@@ -161,20 +151,16 @@ def _board_tokens(value: str, cut_at: str) -> list[str]:
 def _board_family_key(value: str, cut_at: str) -> str | None:
     """First `_BOARD_TOKEN_TO_KEY` hit among `value`'s tokens, or None.
 
-    No known modelNum or description yields two *conflicting* board keys, so
+    No known modelNum or description yields two conflicting board keys, so
-    which token is found first doesn't matter within one field -- the table is
+    which token is found first doesn't matter within one field -- the
-    a flat lookup, not a priority list. Adding an entry that could co-occur
+    table is a flat lookup, not a priority list.
-    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
+    spell their modelNum '...-REF-WATERPURIFIER-...', where 'REF' names
-    shared cooling-subsystem board, not the refrigerator device type --
+    the shared cooling-subsystem board, not the refrigerator type --
-    'WATERPURIFIER' is the actual, more specific type here. Rather than drop
+    'WATERPURIFIER' is the actual, more specific type. This one known
-    or rename either entry (both are correct on their own for the model
+    co-occurrence resolves to 'water_purifier'; TestBoardTokenAmbiguity
-    strings that exist today), this one known co-occurrence resolves to
+    carries a matching carve-out for this exact pair.
-    'water_purifier'; TestBoardTokenAmbiguity's blanket check carries a
-    matching carve-out for this exact pair.
     """
     tokens = _board_tokens(value, cut_at)
     if "REF" in tokens and "WATERPURIFIER" in tokens:
@@ -191,25 +177,19 @@ def _consumer_model_key(description: str) -> str | None:
 
     Usually that token is the last '_'-delimited segment before any
     '/board-info' suffix (e.g. '..._WW90DG6U25LEU4' -> 'WW90DG6U25LEU4').
-    But issue #79's dryer pairs two model numbers in one description --
+    But issue #79's dryer pairs two model numbers in one description, so
-    '..._DVE50A8800_8600/DC92-...' -- so the true consumer token
+    the true consumer token sits one segment before the actual last
-    ('DVE50A8800') sits one segment *before* the actual last segment
+    segment -- scan from the end and take the first segment that resolves.
-    ('8600', a bare second model number with no recognizable prefix). Scan
-    segments from the end and take the first one that resolves, rather
-    than assuming the last segment is always it.
 
-    Splits on '_' only, unlike `_board_tokens` above: these are two-letter
+    Splits on '_' only, unlike `_board_tokens` above: widening the split to
-    prefixes matched against the *start* of a segment, so widening the split
+    '-' would start reading board-family segments as consumer models (the
-    to '-' as well would start reading board-family segments as consumer
+    dishwasher's 'ADW-WW-RTL-24-AILITE' would offer up a bare 'WW' and
-    models -- the dishwasher's 'ADW-WW-RTL-24-AILITE' would offer up a bare
+    route to washer).
-    'WW' segment and route to washer.
 
-    Only a 2-letter *prefix* match -- e.g. 'WAC' (the Window Air Conditioner
+    Only a 2-letter prefix match, so e.g. 'WAC' (Window AC, issue #87) also
-    board-family token, issue #87) also starts with 'WA' (the top-load-washer
+    matches 'WA' (top-load washer, issue #106) at this granularity --
-    prefix, issue #106) at this granularity. for_device_by_model() consults
+    for_device_by_model() consults the board-family table first and this
-    the board-family table first and this function only as a fallback, so
+    only as a fallback, so that ambiguity resolves correctly.
-    that ambiguity resolves correctly without this function needing to know
-    about unrelated device families.
     """
     segments = (description or "").split("/", 1)[0].split("_")
     for segment in reversed(segments):
@@ -220,61 +200,50 @@ def _consumer_model_key(description: str) -> str | None:
 
 
 # /oic/d's `rt` (OCF's own device-type declaration, see registry/identity.py)
-# -> registry key. This is the device naming its own type -- no board-part
+# -> registry key. The device naming its own type, no board-part guessing --
-# guessing involved -- so it's consulted before modelNum/description at all.
+# consulted before modelNum/description.
 #
 # Every value must already be a key in `_REGISTRY_BY_KEY` (checked by
-# `test_every_oic_type_resolves_to_a_real_registry`). That's why this list
+# `test_every_oic_type_resolves_to_a_real_registry`) -- this deliberately
-# stops well short of the full OCF/SmartThings device-type vocabulary: a
+# stops short of the full OCF/SmartThings vocabulary, since most of it (lights,
-# compiled list of `x.com.st.d.*` types will include plenty of device
+# locks, cameras, TVs, ...) has no registry here to point at, and
-# categories (lights, switches, sensors, locks, cameras, TVs, generic energy
+# 'oic.d.robotcleaner' names an actual robot vacuum, a different product from
-# meters, ...) no Samsung DA appliance dump could ever report and this
+# the clean/auto-empty *station* `vacuum_station` covers.
-# integration has no registry for -- and 'oic.d.robotcleaner' names an
-# actual robot vacuum, a different product from the clean/auto-empty
-# *station* `vacuum_station` covers (see that registry's own module
-# docstring); mapping it there would misroute a genuine robot-vacuum dump
-# into a registry with no vacuum-body capabilities at all. Add a row only
-# once there's a real registry key on the right-hand side to point at.
 #
 # `x.com.st.d.*` entries are SmartThings' own vendor extension to the OCF
-# device-type vocabulary (used for categories with no `oic.d.*` equivalent),
+# device-type vocabulary, for categories with no `oic.d.*` equivalent.
-# same prefix convention as the `x.com.samsung.da.*` resource fields
-# elsewhere in this codebase.
 #
-# `oic.d.cooktop` is deliberately absent, and is the one measured type left out.
+# `oic.d.cooktop` is deliberately absent: a TP1X_DA-KS-COOKTOP induction
-# A TP1X_DA-KS-COOKTOP induction reports it, but `cooktop` and
+# reports it, but `cooktop` and `induction_cooktop` are unrelated registries
-# `induction_cooktop` are two unrelated registries that happen to share the
+# sharing the English word (see by_type/cooktop.py's docstring) -- the OCF
-# English word (see by_type/cooktop.py's docstring: the NA9300K gas family keeps
+# type doesn't distinguish them, and as the primary signal it would override
-# burner state in /mode/vs/0's options array, a completely different OCF
+# a correct `COOKTOP`/`CT` board token. No unambiguous key to point at, so no
-# surface). The OCF type does not distinguish them, so mapping it to either key
+# row.
-# would silently misroute the other -- and as the *primary* signal it would
-# override a `COOKTOP`/`CT` board token that had it right. Same reasoning as
-# `oic.d.robotcleaner` above: no unambiguous key to point at, so no row.
 _OIC_TYPE_TO_KEY: dict[str, str] = {
     "oic.d.airconditioner": "airconditioner",
     "oic.d.airpurifier": "air_purifier",
     "oic.d.dishwasher": "dishwasher",
     "oic.d.dryer": "dryer",
     "oic.d.oven": "oven",
+    "oic.d.range": "range",  # issue #324 -- oven+cooktop combo, no /information/vs/0
     "oic.d.refrigerator": "refrigerator",
+    "oic.d.krefrigerator": "refrigerator",  # issue #328 -- kimchi refrigerator
     "oic.d.washer": "washer",
     "x.com.st.d.airqualitysensor": "air_monitor",
     "x.com.st.d.dehumidifier": "dehumidifier",
     "x.com.st.d.hood": "range_hood",  # AHD-WW-TP1-22-COMMON
     "x.com.st.d.stickcleaner": "vacuum_station",
     "x.com.st.d.steamcloset": "air_dresser",
+    "x.com.st.d.winecellar": "refrigerator",  # issue #328 -- same TP1X_REF_21K board
 }
 
 
 def for_device_by_oic_type(device_types: Sequence[str]) -> DeviceRegistry | None:
     """Device-type detection from /oic/d's `rt` -- OCF's own device-type
-    declaration.
+    declaration. The primary path when a dump carries it, since the device
-
+    names its own type. Most hardware still doesn't populate `/oic/d`
-    The primary path when a dump carries it: the device names its own type,
+    usefully, so `for_device_by_model`/`for_device_by_resources` remain
-    so there's nothing to infer from board part numbers. Most hardware still
+    load-bearing for everything else.
-    doesn't populate `/oic/d` usefully -- see `resolve()`'s docstring -- so
-    this only ever helps a minority of dumps, and `for_device_by_model`/
-    `for_device_by_resources` remain load-bearing for everything else.
     """
     for device_type in device_types:
         key = _OIC_TYPE_TO_KEY.get(device_type)
@@ -323,15 +292,15 @@ def for_device_by_model(model_num: str, description: str) -> DeviceRegistry | No
 def for_device_by_resources(resources: dict[str, dict]) -> DeviceRegistry | None:
     """Detect a device family from a distinctive local-resource signature.
 
-    This runs first as an override path for non-standard devices, not because
+    Runs first as an override path for non-standard devices -- not because
-    resource signatures are inherently more trustworthy than OIC/model
+    resource signatures are more trustworthy than OIC/model metadata, but
-    metadata. It also types boards that ship no ``/information/vs/0`` at all,
+    because it also types boards with no ``/information/vs/0`` at all.
-    leaving `for_device_by_model` nothing to read. Some newer cooktops are the
+    Some newer cooktops were the original case: their mode resource still
-    original case: their mode resource still identifies them, carrying a
+    identifies them via a DeviceType option and multiple per-burner
-    DeviceType option and multiple per-burner OperationState options.
+    OperationState options.
 
-    Require two independent shapes for every signature here, never one, so
+    Every signature here requires two independent shapes, never one, so
-    putting this ahead of OIC/model metadata cannot let a common resource
+    running this ahead of OIC/model metadata can't let a common resource
     misclassify an unrelated family.
     """
     mode = resources.get("/mode/vs/0", {})
@@ -347,12 +316,10 @@ def for_device_by_resources(resources: dict[str, dict]) -> DeviceRegistry | None
     if "/hood/fanspeed/vs/0" in resources and "/hood/lamp/vs/0" in resources:
         return _REGISTRY_BY_KEY["range_hood"]
     # Oven/range/microwave boards that report no /information/vs/0 at all
-    # (issue #74's NE63B8411SS, issue #172's ME8000T -- the resource is simply
+    # (issues #74, #172) can't be matched via modelNum tokens either. Mode
-    # absent from the dump, not just empty) can't be matched via
+    # vocabulary alongside the oven cavity resource (/oven/vs/0) is a safe
-    # for_device_by_model's modelNum tokens either. Mode vocabulary alongside
+    # two-resource signature; it also corrects Qooker's generic oic.d.oven
-    # the oven cavity resource (/oven/vs/0) is a safe two-resource signature;
+    # metadata (PR #225) since resource detection runs before it.
-    # it also corrects Qooker's generic oic.d.oven / OVEN metadata (issue
-    # PR #225) when resource detection runs before metadata.
     supported_modes = mode.get("x.com.samsung.da.supportedModes") or ()
     if not isinstance(supported_modes, (list, tuple)):
         supported_modes = ()
@@ -379,20 +346,18 @@ def resolve(
     flow's probe and the golden-regression harness all call this, so the
     order can't drift between what ships and what the tests assert.
 
-    Distinctive resource signatures run first because they describe the live
+    Distinctive resource signatures run first, since they describe the
-    capability surface a registry must bind. They are deliberately strict in
+    live capability surface a registry must bind; `for_device_by_resources`
-    `for_device_by_resources`: each requires multiple independent details, so
+    is deliberately strict (multiple independent details required) so this
-    this can correct misleading metadata (Qooker's generic ``oic.d.oven``)
+    can correct misleading metadata without a common href overriding an
-    without a common href overriding an unrelated family. When no signature
+    unrelated family. When no signature matches, `/oic/d`'s `rt` wins over
-    matches, `/oic/d`'s `rt` (read separately from the /device/0 dump -- see
+    model-string parsing.
-    registry/identity.py) wins over model-string parsing.
 
-    `/otninformation/vs/0`'s oneUiVersion is deliberately not consulted. It
+    `/otninformation/vs/0`'s oneUiVersion is deliberately not consulted:
-    reads like the obvious signal -- the device naming its own type, e.g.
+    only a minority of hardware populates it, every device that does is
-    '7.0 Dishwasher' -- but only a minority of hardware populates it, every
+    already typed by its modelNum board token, and no device-support issue
-    device that does is already typed by its modelNum board token, and no
+    has ever needed it. Still reported in diagnostics as a firmware
-    device-support issue has ever been fixed by adding a mapping for it. It
+    marker.
-    is still reported in diagnostics as a firmware-generation marker.
     """
     info = resources.get("/information/vs/0", {})
     return (

custom_components/localthings/registry/by_type/air_purifier.py

@@ -22,6 +22,12 @@ match_fn discriminators that keep them from colliding):
   resource surface as A-VTWW-TP2-21-COMMON above; no new capabilities
   needed.
 
+AIR_LEVEL_CHECK ("AI Purify" -- the periodic air-quality sensing engine on
+/airlevelcheck/vs/0) is shared by the last three of those: their dumps all
+carry the resource with the same field names, and only the TVTL family has no
+such href. It was covered as opaque plumbing until two AVT-WW-TP1 dumps
+(issues #84 and #190) showed it drives a real user-facing feature.
+
 Reuses dishwasher.DIAGNOSIS for /diagnosis/vs/0 (identical field/write
 contract).
 """
@@ -38,6 +44,7 @@ REGISTRY = DeviceRegistry(
             *common.POWER,
             dishwasher.DIAGNOSIS,
             air_purifier.AIR_QUALITY,
+            air_purifier.AIR_LEVEL_CHECK,
             air_purifier.FILTER,
             air_purifier.DEVICE_ACTIVE,
             air_purifier.AIRFLOW_GENERIC,

custom_components/localthings/registry/by_type/airconditioner.py

@@ -17,7 +17,7 @@ uses unconditionally.
 Reuses dishwasher.DIAGNOSIS for /diagnosis/vs/0.
 """
 
-from ..capabilities import airconditioner, common, dishwasher, ignored
+from ..capabilities import air_purifier, airconditioner, common, dishwasher, ignored
 from ._base import DeviceRegistry, _build
 
 REGISTRY = DeviceRegistry(
@@ -46,6 +46,28 @@ REGISTRY = DeviceRegistry(
             airconditioner.CURRENT_TEMPERATURE,
             airconditioner.CURRENT_TEMPERATURE_VS,
             airconditioner.HUMIDITY,
+            # TP1X_DA-AC-FAC-class (issue #319): shares its /display/vs/0,
+            # /settings/sound/output/vs/0 and /settings/sound/volume/vs/0
+            # shape with the sibling TP1X_DA-AC-AIR board in air_purifier.py.
+            air_purifier.DISPLAY,
+            air_purifier.SOUND_OUTPUT,
+            air_purifier.SOUND_VOLUME,
+            airconditioner.SOUND_MODE,
+            airconditioner.ABSENCE_CLEAN,
+            airconditioner.MDS_ABSENCE_CLEAN,
+            airconditioner.ENERGY_SAVING,
+            airconditioner.EDGE_LIGHTING,
+            airconditioner.LIGHT_STATEFUL,
+            # System Fresh Air Ventilator (PR #316, ACA-KR-TP2-21-AN9000):
+            # WINDFREE/WINDSLEEP are this device's own hrefs; HEPA_FILTER/
+            # DEVICE_ACTIVE reuse air_purifier.py's identical shapes.
+            # AIR_LEVEL_CHECK is not this-device-specific -- see its
+            # removal from _AC_IGNORED above.
+            airconditioner.WINDFREE,
+            airconditioner.WINDSLEEP,
+            air_purifier.HEPA_FILTER,
+            air_purifier.DEVICE_ACTIVE,
+            air_purifier.AIR_LEVEL_CHECK,
             *airconditioner.COVERAGE,
         ]
     ),

custom_components/localthings/registry/by_type/cooktop.py

@@ -22,6 +22,12 @@ REGISTRY = DeviceRegistry(
             cooktop.COOKTOP_CONNECTED,
             cooktop.PAIRED_HOOD_STATUS,
             common.FIRMWARE_UPDATE,
+            # issue #314: /alarms/vs/0 and /kidslock/vs/0 are the same
+            # generic shapes common.UNIVERSAL already models elsewhere --
+            # picked individually rather than pulling in all of UNIVERSAL,
+            # matching this registry's existing hand-picked-common style.
+            common.ALARMS,
+            common.KIDS_LOCK_VS_FALLBACK,
         ]
     ),
 )

custom_components/localthings/registry/by_type/oven.py

@@ -1,6 +1,6 @@
 """Oven device registry."""
 
-from ..capabilities import common, ignored, oven
+from ..capabilities import common, dishwasher, ignored, oven
 from ._base import DeviceRegistry, _build
 
 REGISTRY = DeviceRegistry(
@@ -18,6 +18,9 @@ REGISTRY = DeviceRegistry(
             oven.OVEN_CONNECTED,
             oven.OVEN_SPEC,
             oven.OVEN_RECIPE_COOK,
+            # issue #300: /diagnosis/vs/0 is the same diagnosisStart shape
+            # dishwasher.py and airconditioner.py already reuse.
+            dishwasher.DIAGNOSIS,
         ]
     ),
 )

custom_components/localthings/registry/by_type/refrigerator.py

@@ -13,6 +13,11 @@ REGISTRY = DeviceRegistry(
             fridge.STATUS_LOCK,
             fridge.DOOR_ALERT,
             common.WATER_FILTER,
+            fridge.AIR_FILTER,
+            fridge.DEODOR_FILTER,
+            fridge.AUTO_DOOR_TIMER,
+            fridge.WINECELLAR_PANTRY_ZONE,
+            fridge.WINECELLAR_INFO,
             dishwasher.DIAGNOSIS,
             fridge.ICEMAKER_NIGHTTIME,
             fridge.FLEX_ZONE,
@@ -43,5 +48,6 @@ REGISTRY = DeviceRegistry(
         fridge.DOOR_GENERIC,
         fridge.KIMCHI_ZONE,
         fridge.KIMCHI_DOOR_GENERIC,
+        fridge.AUTO_DOOR_VARIANT,
     ],
 )

custom_components/localthings/registry/by_type/vacuum_station.py

@@ -1,9 +1,7 @@
-"""Stick-vacuum clean/auto-empty station device registry (issue #131).
+"""Stick-vacuum clean/auto-empty station device registry (issues #131 / #219).
 
-See capabilities/vacuum_station.py's module docstring for why this only
+Station dustbag/dustbin/UV-sanitize state plus, when present (VS9700),
-covers the station's own dustbag/dustbin/UV-sanitize state and not any
+wand battery/charging via `/status/stick/vs/0`. No suction/room-map control.
-vacuum-body control (suction, battery, cleaning mode) -- the diagnostics
-dump this was built from reports none of that.
 """
 
 from ..capabilities import common, ignored, vacuum_station
@@ -20,6 +18,7 @@ REGISTRY = DeviceRegistry(
             vacuum_station.DUSTBAG_USAGE,
             vacuum_station.DUSTBIN_SETTING,
             vacuum_station.CLEANSTATION_STATUS,
+            vacuum_station.STICK_BODY,
         ]
     ),
 )

custom_components/localthings/registry/capabilities/air_monitor.py

@@ -7,29 +7,29 @@ only); this registry deliberately doesn't include common.POWER.
 air_purifier.AIR_QUALITY and range_hood.AIR_QUALITY already read via
 common.sensor_item_value -- reused here rather than re-decoded, including
 the same dust/fine_dust/super_fine_dust/odor/clean_level keys so this
-device shares those capabilities' catalog entries. This board additionally
+device shares those capabilities' catalog entries. This board reports a
-reports a CO2 reading the other two families don't.
+CO2 reading; air_purifier.AIR_QUALITY now models the same type when a
+purifier lists it (issue #387).
 
-A second `value` list element on the particulate-matter types (e.g. Dust's
+A second `value` list element on the particulate-matter types (Dust's
-`['31', '2']`) reads like a coarse quality-grade code, but nothing on this
+`['31', '2']`) is the device's own graded air-quality level for that
-board (no `supportedGrades`/similar field, no repeated dump to compare
+reading -- see common.sensor_item_value. Still unbound here: the grade's
-against) confirms what its scale means -- left unbound rather than guessed,
+floor differs by board family, and CleanLevel already carries the
-per the adding-device-support skill's "still never invent... from nothing"
+aggregate. This board's own readings are load-bearing evidence for the
-rule. Same reasoning `air_purifier.AIR_QUALITY` already applies to this
+PM mapping, though: 23 grading one step above the floor as FineDust is
-shape; index 0 is the only slot any family has ever read.
+what rules out a PM10-width band for that field.
 
-Dust/FineDust/SuperFineDust aren't assigned an HA `device_class`
+Dust/FineDust/SuperFineDust carry the same HA `device_class`/`unit` as the
-(pm10/pm25/pm1) or `unit` despite the values reading like plausible
+purifier family (issue #325, Dust=PM10 / FineDust=PM2.5 /
-ug/m3 particulate readings in a physically consistent order (coarser
+SuperFineDust=PM1 in μg/m³). The mapping rests on device-side grading this
->= finer): Samsung's own two-tier Korean convention (i.e. "fine dust"/
+board shares rather than on anything purifier-specific, so typing one
-"ultra-fine dust") maps only to a PM10/PM2.5 pair, and this board's
+family and not the other would have been an inconsistency, not caution.
-three-tier naming doesn't confirm where the extra tier or a PM1 reading
+
-actually fits. The adding-device-support skill's read-side rule says
+These sensors have recorded *unitless* long-term statistics since issue
-leave unit/device_class unset when the dump gives no field that
+#210, though, and Home Assistant suppresses statistics generation outright
-nominates one -- a wrong guess would silently mislabel every reading
+for an entity whose unit no longer matches its recorded metadata -- so
-forever, and the write-side rejection safety net doesn't cover reads.
+stamping a unit on would have silently stopped the history it was meant to
-Exposed as plain `measurement` sensors named after the device's own
+label. __init__.py's v2->v3 entry migration relabels that metadata first.
-field instead (matching air_purifier.AIR_QUALITY's existing precedent).
 """
 
 from datetime import time as dt_time
@@ -39,6 +39,15 @@ from ..entities import BinarySensorDesc, SensorDesc, SwitchDesc, TimeDesc
 from .air_purifier import _AIR_QUALITY_SENSORS
 from .common import int_or_none, sensor_item_value
 
+# device_class/unit are taken from the shared rows; state_class deliberately
+# is not. air_purifier leaves Odor/CleanLevel unstamped because they read as
+# graded indices on that family, while this board has stamped all five as
+# `measurement` since it was added (issue #210) -- consuming that column
+# would silently drop long-term statistics for two sensors on shipped
+# devices. The pm10/pm25/pm1 labels carry over cleanly, though: they rest on
+# device-side grading this board shares (see the module docstring), and
+# __init__.py's v2->v3 entry migration relabels the unitless statistics
+# these five have been recording so the new unit doesn't suppress them.
 SENSORS = Capability(
     href="/sensors/vs/0",
     poll_tier="warm",
@@ -49,9 +58,11 @@ SENSORS = Capability(
                 field="x.com.samsung.da.items",
                 icon=icon,
                 state_class="measurement",
+                device_class=device_class,
+                unit=unit,
                 value_fn=lambda items, t=sensor_type: sensor_item_value(items, t),
             )
-            for key, icon, sensor_type in _AIR_QUALITY_SENSORS
+            for key, icon, sensor_type, _state_class, device_class, unit in _AIR_QUALITY_SENSORS
         ),
         SensorDesc(
             key="co2",
@@ -134,13 +145,10 @@ def _dnd_time_write(field):
     return _write
 
 
-# Issue #210: no idle-vs-active dump pair exists for this href (only one
+# Issue #210: only one dump exists (DND never toggled in it), so this write
-# dump total, DND never toggled in it), so this write contract is an
+# contract is an educated guess -- symmetric with the read side's own
-# educated guess, not a confirmed one -- symmetric with the read side
+# 'true'/'false' and 'HH:MM:SS' formats, but still needs a reporter to
-# (writing the same 'true'/'false' string shape and 'HH:MM:SS' format the
+# confirm it on real hardware.
-# device itself reports back) rather than invented from nothing, but still
-# needs a reporter to actually flip it on real hardware and confirm. See
-# the adding-device-support skill's "Educated guesses are fine" section.
 DND = Capability(
     href="/dnd/vs/0",
     poll_tier="cold",

custom_components/localthings/registry/capabilities/air_purifier.py

@@ -1,63 +1,29 @@
 """Capabilities for the Samsung ARTIK051_TVTL-class air purifier family
 (model AX60R5080WD/SE, issue #56).
 
-Power, kids-lock, remote-control, alarms, and the energy meter are the shared
+Power, kids-lock, remote-control, alarms, and the energy meter are the
-common.py capabilities (this family exposes the standard /power/0+/power/vs/0
+shared common.py capabilities; /diagnosis/vs/0 reuses dishwasher.DIAGNOSIS
-pair and /alarms/vs/0, /energy/consumption/vs/0). /diagnosis/vs/0 reuses
+(identical field/write contract).
-dishwasher.DIAGNOSIS -- identical field/write contract
-(x.com.samsung.da.diagnosisStart, 'Ready' on both dumps).
 
-/mode/vs/0's x.com.samsung.da.options array packs multiple independent
+/mode/vs/0's options[] packs several '<Prefix>_<value>' flags, the same
-'<Prefix>_<value>' flags into one list -- the same packed-list contract
+packed-list contract as laundry.py's option_value/option_write. Light_On/
-laundry.py's option_value/option_write already model for /course/vs/0's
+Light_Off is a real on/off switch here -- NOT the same polarity as the AC
-options[] (reused directly below, just against this family's own href). Per
+family's own Light_On/Light_Off token on its own /mode/vs/0, which is
-issue #56's follow-up (five diagnostics dumps captured with the physical unit
+inverted (airconditioner._display_light_on). Comode_Off reads 'Off' on
-set to Auto/Sleep/Low/Medium/High):
+every setting (Auto/Sleep/Low/Medium/High), ruling out the original
-  Light_On / Light_Off  -- a plain on/off flag; MODE below models it as a
+"fan speed selector" guess; exposed read-only. OptionCode_* and Blooming_*
-                            real switch, RMW-replacing just that one entry.
+are unmodeled: confirmed opaque / not app-facing.
-                            NOT the same polarity as the AC family's own
-                            Light_On/Light_Off token on its own /mode/vs/0
-                            (airconditioner._display_light_on) -- that one is
-                            confirmed inverted (Light_Off means the panel is
-                            lit) on live hardware. Same token name, same
-                            resource name, different device type and
-                            opposite meaning -- don't unify them.
-  Comode_Off            -- read 'Off' on *every* one of the five dumps,
-                            including High/Low/Medium/Auto -- confirms this
-                            is NOT the fan-speed selector (ruling out the
-                            original guess); exposed read-only since its
-                            actual purpose is still unconfirmed.
-  OptionCode_60282       -- confirmed opaque/not user-facing in the
-                            SmartThings app; not modeled (same treatment as
-                            range_hood's OptionCode_* token on the same
-                            href).
-  Blooming_*             -- confirmed to have no corresponding SmartThings
-                            app setting; dropped entirely rather than kept
-                            as an unexplained diagnostic (it did track 1:1
-                            with Sleep mode across the five dumps -- 0 in
-                            Sleep, 6 otherwise -- so it's plausibly an
-                            automatic side effect of sleep mode, e.g. a
-                            display-dimming level, but that's still a guess).
 
-/airflow/0's `speed` is now a real fan-speed control (issue #56 follow-up).
+/airflow/0's `speed` is a real fan-speed control: two independent units,
-The first round of five dumps above wasn't conclusive -- it read 0 for both
+sampled 60-90s apart per setting, confirmed a clean monotonic 0-4 mapping
-Auto *and* High, and 3 for Low/Medium *and* Sleep, likely because all five
+across Auto/Sleep/Low/Medium/High. AIRFLOW_GENERIC below builds an
-were captured within about a minute of each other, faster than this
+ordered-speed fan off that range. /airflow/vs/0's vendor `speedLevel` is
-integration's own ~30s poll cycle could settle each change. A second round,
+NOT used for the same purpose -- unreliable on both units in the same
-captured 60-90s apart per setting on two independent units, confirmed a
+round (collided Low/Medium on one, stuck at 0 on the other).
-clean monotonic mapping instead: Auto=0, Sleep=1, Low=2, Medium=3, High=4.
-AIRFLOW_GENERIC below builds an ordered-speed fan off that confirmed 0-4
-range -- same SET_SPEED shape as range_hood.py's fan, mapping HA's
-percentage steps straight onto the raw code, no named-preset table needed
-(unlike the TP1X family's FAN, which exposes real named modes because its
-board actually reports a supportedModes list to hang names off of).
-
-/airflow/vs/0's vendor `speedLevel` is NOT used for the same purpose -- it
-was unreliable on both units in that second round (Low/Medium collided on
-one unit, stuck at 0 throughout on the other), so AIRFLOW_VS_FALLBACK below
-stays a plain read-only diagnostic even after this change.
 """
 
+import datetime
+
 from ..capability import Capability
 from ..entities import (
     BinarySensorDesc,
@@ -66,18 +32,22 @@ from ..entities import (
     SelectDesc,
     SensorDesc,
     SwitchDesc,
+    TimeDesc,
+)
+from .common import (
+    epoch_to_utc,
+    filter_usage_percent,
+    has_sensor_type,
+    int_or_none,
+    sensor_item_value,
 )
-from .common import filter_usage_percent, int_or_none, sensor_item_value
 from .laundry import bool_option_exists, bool_option_value, option_value, option_write
 
-# Newer TP1X_DA-AC-AIR-class boards (e.g. TP1X_DA-AC-AIR-01031_0000, issue
+# Newer TP1X_DA-AC-AIR-class boards (issue #130) report fan modes directly
-# #130) report fan modes directly on /mode/vs/0's top-level `modes`/
+# on /mode/vs/0's top-level modes/supportedModes instead of packing
-# `supportedModes` fields (Smart/Max/Mid/WindFree/Sleep) instead of packing
+# everything into options[] like the older ARTIK051_TVTL family. Both
-# everything into the options[] array the way the older ARTIK051_TVTL
+# generations share this href; FAN and MODE below are mutually exclusive
-# family above does -- that older family's /mode/vs/0 has no top-level
+# via presence of supportedModes.
-# supportedModes at all (see the module docstring's Comode_Off finding).
-# Both board generations share the /mode/vs/0 href, so FAN and MODE below
-# are mutually exclusive via this presence check rather than colliding.
 HREF_MODE = "/mode/vs/0"
 HREF_AIRFLOW = "/airflow/0"
 HREF_WIND_STRENGTH = "/wind/strength/vs/0"
@@ -87,25 +57,90 @@ def _has_top_level_modes(rep, resources):
     return isinstance(rep.get("x.com.samsung.da.supportedModes"), (list, tuple))
 
 
+# Columns: key, icon, device item type, state_class, device_class, unit.
+# state_class is what makes Home Assistant keep long-term statistics --
+# without one, a reading is only in the short-term recorder history and
+# disappears with the next purge (10 days by default), so it can't back a
+# long-range air-quality graph. The values are already numeric
+# (sensor_item_value returns int); three sensors in this same module
+# (filter_progress, fan_speed_level, hepa_filter_usage) already declare one.
+#
+# Only the three particulate readings get it. They fall monotonically with
+# particle size on three independent board families -- 11/9/5 on ARTIK051_TVTL
+# (issue #56), 10/9/6 on AVT-WW-TP1 (issue #190), 18/14/9 on the range hood --
+# which is concentration behaviour, and an average over time is meaningful for
+# it. Odor and CleanLevel read 0-2 on every fixture and look like graded
+# indices instead, where the mean of a grade isn't obviously meaningful; left
+# without a state_class rather than guessing.
+#
+# device_class/unit: Dust=PM10, FineDust=PM2.5, SuperFineDust=PM1, all
+# μg/m³ (issue #325). Three independent lines, none of them naming order --
+# which is what the earlier "plausible but unconfirmed" note rejected:
+#
+#  1. The device grades its own readings. Each dust item's value[] is
+#     [concentration, grade] (see common.sensor_item_value); the grade band
+#     is not shared across the three fields -- a reading of 18 grades one
+#     step *above* the floor as SuperFineDust (air_monitor fixture) but *at*
+#     the floor as Dust (range_hood fixture), both 1-based families. So the
+#     firmware itself treats them as three different scales ordered
+#     coarse-to-fine, rather than one repeated measurement.
+#  2. Where each field's floor/second-band boundary falls brackets the
+#     Korean CAI bands: Dust good at 18, graded up at 31 (CAI PM10 breaks
+#     at 30/31); FineDust good at 14, graded up at 23 (CAI PM2.5 breaks at
+#     15/16); SuperFineDust good at 9, graded up at 18 (PM2.5-style, which
+#     is what a PM1 reading gets -- there is no standard PM1 index).
+#  3. A live ARTIK051_TVTL read against the SmartThings app at the same
+#     moment: Dust matched the app's PM10 exactly, the other two were 1
+#     μg/m³ off in the same order, and the app shows exactly these three
+#     tiers, so there is no fourth candidate to assign.
+#
+# Dust >= FineDust >= SuperFineDust holds on all 11 fixtures that report
+# this resource, which is the cumulative-mass ordering PM10 >= PM2.5 >= PM1
+# requires by definition. The unit literal must stay HA's own spelling of
+# μg/m³ (U+03BC GREEK SMALL LETTER MU, not U+00B5 MICRO SIGN) -- they render
+# alike but only U+03BC is in DEVICE_CLASS_UNITS, and the mismatch is a
+# runtime warning per entity, not a test failure. Pinned by
+# tests/test_sensor_device_class_units.py.
 _AIR_QUALITY_SENSORS = (
-    ("dust", "mdi:blur", "Dust"),
+    ("dust", "mdi:blur", "Dust", "measurement", "pm10", "μg/m³"),
-    ("fine_dust", "mdi:blur", "FineDust"),
+    ("fine_dust", "mdi:blur", "FineDust", "measurement", "pm25", "μg/m³"),
-    ("super_fine_dust", "mdi:blur", "SuperFineDust"),
+    ("super_fine_dust", "mdi:blur", "SuperFineDust", "measurement", "pm1", "μg/m³"),
-    ("odor", "mdi:scent", "Odor"),
+    ("odor", "mdi:scent", "Odor", None, None, None),
-    ("clean_level", "mdi:air-filter", "CleanLevel"),
+    ("clean_level", "mdi:air-filter", "CleanLevel", None, None, None),
 )
 
 AIR_QUALITY = Capability(
     href="/sensors/vs/0",
     poll_tier="warm",
-    entities=tuple(
+    entities=(
+        *(
+            SensorDesc(
+                key=key,
+                field="x.com.samsung.da.items",
+                icon=icon,
+                state_class=state_class,
+                device_class=device_class,
+                unit=unit,
+                value_fn=lambda items, t=sensor_type: sensor_item_value(items, t),
+            )
+            for key, icon, sensor_type, state_class, device_class, unit in _AIR_QUALITY_SENSORS
+        ),
+        # CO2 (issue #387) -- same field/shape air_monitor.SENSORS already
+        # models with device_class='carbon_dioxide'/unit='ppm'. Gated on the
+        # type being listed so boards that don't report it (every current
+        # fixture) don't grow an empty entity. Disabled by default for the
+        # same reason as airconditioner.AIR_QUALITY (issue #166).
         SensorDesc(
-            key=key,
+            key="co2",
             field="x.com.samsung.da.items",
-            icon=icon,
+            icon="mdi:molecule-co2",
-            value_fn=lambda items, t=sensor_type: sensor_item_value(items, t),
+            device_class="carbon_dioxide",
-        )
+            state_class="measurement",
-        for key, icon, sensor_type in _AIR_QUALITY_SENSORS
+            unit="ppm",
+            exists_fn=has_sensor_type("CO2"),
+            enabled_default=False,
+            value_fn=lambda items: sensor_item_value(items, "CO2"),
+        ),
     ),
 )
 
@@ -119,12 +154,9 @@ def _consumable_state(items, name):
     return None
 
 
-# FilterProgress is a 0-100 percentage counting up as the filter wears --
+# FilterProgress counts UP as the filter wears (100 = "needs changing",
-# confirmed via issue #56: the SmartThings app shows "Filter needs changing"
+# confirmed via the SmartThings app) -- named after the raw field rather
-# once this reaches 100, so 100 means fully used, not "brand new." Named
+# than "filter life," which would imply the opposite direction.
-# after the raw field (matching the AC/range_hood filterUsage convention,
-# which counts the same direction) rather than "filter life," which would
-# imply the opposite direction.
 FILTER = Capability(
     href="/consumable/vs/0",
     poll_tier="cold",
@@ -157,11 +189,9 @@ DEVICE_ACTIVE = Capability(
 
 
 def _power_write(power_href, value):
-    """Shared 'power' payload handling for this family's three FanDesc write
+    """Shared 'power' payload handling for this family's FanDescs -- targets
-    functions -- targets whichever power href fan.py's _power_payload picked
+    whichever power href fan.py picked (the board may only report
-    (the board may only report /power/0); a hardcoded vendor href here would
+    /power/0)."""
-    silently no-op on such a board even though the entity's own is_on
-    already falls back to reading it correctly."""
     if power_href == "/power/0":
         return ["power", "0"], {"value": bool(value)}
     return (["power", "vs", "0"], {"x.com.samsung.da.power": "On" if value else "Off"})
@@ -176,24 +206,14 @@ def _airflow_fan_write(payload, rep, href=None):
     return None
 
 
-# Confirmed via issue #56's second, properly-spaced round of diagnostics
+# Confirmed monotonic 0-4 speed code (see module docstring) backs a real
-# (two independent units, 60-90s apart per setting): /airflow/0's `speed` is
+# ordered-speed fan, same SET_SPEED shape as the range hood's. `direction`
-# a clean, monotonic 0-4 code across Auto/Sleep/Low/Medium/High, so it now
+# stays a diagnostic: every dump reads 'Off' regardless of fan setting.
-# backs a real ordered-speed fan (fan.py's LocalThingsAirflowFan, same
-# SET_SPEED shape as the range hood's) instead of a read-only sensor --
-# no named-preset table needed, since HA's percentage steps map onto the
-# raw 0-4 code directly, the same way the range hood's numeric levels do.
-# `direction` stays a plain diagnostic: every dump seen (both rounds, both
-# units) reads 'Off' for it regardless of fan setting, so there's nothing
-# confirmed to control there yet.
 #
-# Keyed 'airflow_fan', not 'fan' -- FAN below (bound to the shared
+# Keyed 'airflow_fan', not 'fan' -- FAN below shares this registry and also
-# /mode/vs/0 href) also uses 'fan', and BoundEntity's unique_id is built
+# uses key 'fan'; unique_id is built from key alone, so a shared key would
-# from key alone (entity.py's _key), not href. FAN and AIRFLOW_GENERIC are
+# collide if a board ever reported both (empirically mutually exclusive,
-# only *empirically* mutually exclusive (every dump seen has one board
+# not architecturally enforced the way same-href caps are).
-# generation's shape or the other, never both), not architecturally
-# enforced the way same-href caps are by _build()'s match_fn check -- a
-# same key would collide if a future board ever reported both.
 AIRFLOW_GENERIC = Capability(
     href=HREF_AIRFLOW,
     poll_tier="warm",
@@ -208,10 +228,8 @@ AIRFLOW_GENERIC = Capability(
     ),
 )
 
-# Left exactly as a read-only fallback -- speedLevel is NOT the same
+# Read-only fallback: speedLevel is unreliable (see module docstring),
-# confirmed-reliable field as /airflow/0's speed above (see module
+# unlike /airflow/0's speed.
-# docstring): it collided Low/Medium on one unit and stuck at 0 throughout
-# on the other in the same properly-spaced round.
 AIRFLOW_VS_FALLBACK = Capability(
     href="/airflow/vs/0",
     match_fn=lambda rep, resources: "/airflow/0" not in resources,
@@ -236,12 +254,9 @@ AIRFLOW_VS_FALLBACK = Capability(
 
 
 def _light_write(payload, rep, href=None):
-    # option_write's single-token write is confirmed on a washer's
+    # option_write's single-token merge is confirmed on a washer's
-    # /course/vs/0 (issue #54), NOT independently on this family's
+    # /course/vs/0 (issue #54); extrapolated here on the assumption the
-    # /mode/vs/0 -- extrapolated on the assumption the same vendor field
+    # same vendor field merges the same way on this family's /mode/vs/0.
-    # merges the same way everywhere. If some unit replaces the field
-    # outright instead, this would drop Comode/OptionCode alongside it on
-    # the next light toggle; revisit if a real device report surfaces that.
     return ["mode", "vs", "0"], {
         "x.com.samsung.da.options": option_write("Light", payload),
     }
@@ -283,9 +298,8 @@ def _fan_write(payload, rep, href=None):
 
 
 def _first_fan_mode(rep):
-    """Representative scalar for the fan entity in the flattened state
+    """Representative scalar for the flattened golden state; the real
-    (golden/regression), mirroring airconditioner.py's own _first_mode --
+    entity reads live coordinator state instead."""
-    the real entity computes its state from live coordinator reads."""
     modes = rep.get("x.com.samsung.da.modes")
     if isinstance(modes, (list, tuple)):
         return modes[0] if modes else None
@@ -293,10 +307,8 @@ def _first_fan_mode(rep):
 
 
 # Named preset modes (Smart/Max/Mid/WindFree/Sleep), not an ordered
-# percentage -- WindFree/Smart/Sleep are named behaviors, not
+# percentage -- these are named behaviors, not "faster/slower" positions,
-# "faster/slower" positions relative to Max/Mid, so fan.py's entity for
+# so fan.py only exposes PRESET_MODE here.
-# this only exposes PRESET_MODE, matching how the AC family's own named
-# convenient modes are modeled as a preset rather than a speed number.
 FAN = Capability(
     href=HREF_MODE,
     poll_tier="warm",
@@ -321,19 +333,14 @@ def _wind_strength_fan_write(payload, rep, href=None):
     return None
 
 
-# A-VTWW-TP2-21-COMMON (issue #151): named preset modes like FAN above, but
+# A-VTWW-TP2-21-COMMON (issue #151): named presets like FAN above, but on a
-# on a distinct href with numeric codes ("87"/"89"/"90"/"91") instead of
+# distinct href with numeric codes ("87"/"89"/"90"/"91") instead of
 # self-describing supportedModes -- x.com.samsung.da.modesName gives the
-# actual names (SMART/MAX/WINDFREE/Sleep), read live by fan.py's
+# real names, read live by fan.py rather than a hardcoded map. `modes` is a
-# LocalThingsAirPurifierFan._label_for_code rather than a hardcoded
+# bare string here, not a single-element list like HREF_MODE's.
-# per-model map. modes here is a bare string ('87'), not a single-element
-# list like HREF_MODE's -- _wind_strength_fan_write writes it back as-is.
 #
-# key is 'wind_strength_fan', NOT 'fan' -- FAN above shares this registry
+# key is 'wind_strength_fan', not 'fan' -- same unique_id collision hazard
-# and also uses a FanDesc; BoundEntity's unique_id is built from key alone
+# as AIRFLOW_GENERIC above.
-# (entity.py's _key), not href, so two same-key FanDescs in one registry
-# would collide if a board ever bound both (see AIRFLOW_GENERIC's own
-# comment on this exact hazard -- missed here in the initial cut).
 WIND_STRENGTH_FAN = Capability(
     href=HREF_WIND_STRENGTH,
     poll_tier="warm",
@@ -347,15 +354,12 @@ WIND_STRENGTH_FAN = Capability(
     ),
 )
 
-# ---------------------------------------------------------------------------
+# TP1X_DA-AC-AIR-class additions (issue #130): resources the older
-# TP1X_DA-AC-AIR-class additions (issue #130). This board reports several
+# ARTIK051_TVTL family never reported.
-# resources the older ARTIK051_TVTL family never did.
-# ---------------------------------------------------------------------------
 
-# Screen/indicator-panel on/off -- distinct from LIGHT below (ambient mood
+# Screen/indicator panel on/off, distinct from the display_light switch
-# light): both report the same {mode, supportedModes: [On, Off]} shape on
+# above (ambient mood light) -- two independent controls on separate hrefs
-# separate hrefs on this dump, so they're two independent physical controls,
+# with the same {mode, supportedModes: [On, Off]} shape.
-# not a duplicate encoding of one.
 DISPLAY = Capability(
     href="/display/vs/0",
     poll_tier="cold",
@@ -374,10 +378,8 @@ DISPLAY = Capability(
     ),
 )
 
-# Same filterUsage/filterCapacity/filterStatus shape as the AC family's own
+# Same filterUsage/filterCapacity/filterStatus shape as the AC family's
-# AIR_FILTER (airconditioner.py) -- confirmed normal/wash/replace values not
+# AIR_FILTER; the normal/wash/replace option list is reused as-is.
-# seen on this one dump, so the option list there is reused as-is rather
-# than re-deriving it from a single sample.
 HEPA_FILTER = Capability(
     href="/filter/hepafilter/vs/0",
     poll_tier="cold",
@@ -403,10 +405,9 @@ HEPA_FILTER = Capability(
     ),
 )
 
-# Physical panel/cover status -- meaning of the one value seen ('Close') is
+# Physical panel/cover status ('Close' seen, plausibly the HEPA-filter
-# plausible (the HEPA-filter access cover) but unconfirmed, and no
+# cover) -- unconfirmed, and no supportedStatus list to check against, so a
-# supportedStatus list is present to check against -- exposed as a plain
+# plain diagnostic rather than an asserted binary_sensor.
-# diagnostic sensor rather than an asserted binary_sensor polarity.
 PANEL_STATUS = Capability(
     href="/panel/vs/0",
     poll_tier="cold",
@@ -440,22 +441,18 @@ PET_FILTER_ACTIVATION = Capability(
     ),
 )
 
-# Sound mode/volume shapes look like laundry.py's SOUND_MODE/SOUND_VOLUME at
+# Sound mode/volume look like laundry.py's SOUND_MODE/SOUND_VOLUME but this
-# a glance, but this board's actual values differ (supportedModes here is
+# board's actual values differ (supportedModes here is ['mute', 'buzzer'],
-# ['mute', 'buzzer'], not laundry's hardcoded voice/tone/mute; volume range
+# not laundry's voice/tone/mute; volume is 0-3, not laundry's fixed 0-15) --
-# is 0-3, not laundry's fixed 0-15) -- reusing those would either reject a
+# separate descriptors reading live supported values instead of reusing
-# valid write ('buzzer') or expose the wrong number range, so these are
+# laundry's hardcoded table.
-# separate descriptors reading the live supported values instead of a
-# hardcoded table.
 SOUND_MODE = Capability(
     href="/settings/sound/mode/vs/0",
     poll_tier="cold",
     entities=(
         # Distinct translation_key from laundry.SOUND_MODE's shared
-        # 'sound_mode' catalog entry -- that one's state table is
+        # 'sound_mode' catalog ({voice, tone, mute}) -- this board's
-        # {voice, tone, mute}, but this board's supportedModes is
+        # {mute, buzzer} doesn't overlap it.
-        # {mute, buzzer}. Sharing the key would leave 'buzzer' unlabelled
-        # (falls through to the raw code) since the catalogs don't overlap.
         SelectDesc(
             key="sound_mode",
             translation_key="air_purifier_sound_mode",
@@ -495,6 +492,10 @@ SOUND_VOLUME = Capability(
             field="level",
             icon="mdi:volume-medium",
             entity_category="config",
+            # Some boards (issue #319's AC) report minLevel/resolution but no
+            # maxLevel -- native_max_fn would silently collapse to 0, giving a
+            # slider with no real range instead of no entity at all.
+            exists_fn=lambda rep, resources: "maxLevel" in rep,
             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,
@@ -507,35 +508,229 @@ SOUND_VOLUME = Capability(
     ),
 )
 
-# /humidity/0 and /humidity/vs/0 are empty {} on both dumps this family has
+# AI Purify -- /airlevelcheck/vs/0 (issues #84, #190). Not scheduler
-# been verified against -- covered here (not globally, per ignored.py's
+# plumbing: it drives the SmartThings app's "AI Purify" feature (the unit
-# module docstring) since those hrefs collide with fridge/AC schemas
+# wakes on a timer, samples air, optionally acts). Reported with the same
-# elsewhere. Same two hrefs and reasoning as airconditioner.py's _AC_IGNORED.
+# field names by three of this registry's four board families (TP1X_DA-AC-AIR
+# #130, A-VTWW-TP2 #151, AVT-WW-TP1 #84/#190); ARTIK051_TVTL has no such
+# href. Bound unconditionally since it's safe to no-op where absent.
 #
-# The next six hrefs (issue #130, TP1X_DA-AC-AIR board) are the exact same
+# Two independent knobs, one entity each rather than folded into one
-# resources, same shapes, same reasoning as airconditioner.py's
+# select: periodicSensingActivationState (is it running) and autoExeState
-# _AC_IGNORED on the shared DA-AC- board family -- duplicated here rather
+# (what it does with a bad reading, Off/Airpurify/Alarm) -- mirrors the
-# than promoted to the global ignored.py list, since that would require
+# appliance's own UI. Folding them lost information: a configured action
-# also removing them from _AC_IGNORED in the same change (a global entry
+# became invisible while off, and no option could toggle the feature
-# colliding with a family-local bare Capability on the same href raises in
+# without also overwriting the action. The two "off"s are NOT
-# _build()); left as a possible follow-up DRY cleanup.
+# interchangeable: the switch's off stops sampling entirely; the select's
+# "Off" keeps sampling but doesn't act on it (the app calls that
+# "sensing only").
+#
+# range_hood.AIR_LEVEL_CHECK models the same href's read-only fields
+# (reused verbatim below) but is deliberately not imported: it exposes
+# periodic_air_sensing as a read-only BinarySensorDesc where this board
+# needs it writable, and reusing it would migrate every hood user's entity
+# to a different platform.
+#
+# Every write below was exercised on AVT-WW-TP1-23-AXX500 hardware and
+# verified by surviving a reconnect (this board 2.04s writes it silently
+# discards, so an echo proves nothing). The other two families get the same
+# writes on field-shape grounds only.
+#
+# Deferred: startSensingOnce looks like a one-shot "sense now" trigger but
+# stays unbound until its side effect (not just the echo) is confirmed.
+
+
+def _interval_minutes(seconds):
+    """Device stores the interval in seconds; the entity is in minutes.
+    Rounds up (not to nearest) so a sub-minute value can't floor to 0."""
+    secs = int_or_none(seconds)
+    if secs is None:
+        return None
+    return -(-secs // 60) if secs > 0 else 0
+
+
+def _interval_write(payload, rep, href=None):
+    # Minutes in the UI -> seconds on the wire. Modeled as a free Number,
+    # not the app's three fixed choices, since the resource advertises no
+    # constraint for this field (unlike supportedAutoExeState beside it)
+    # and accepts finer values than the app offers (60s drove an observed
+    # ~60s sensing cycle on hardware). One-minute floor matches this
+    # board's own reporting resolution (lastSensingTime lands on exact
+    # minutes). Zero is refused: unlike a real "no timer" 0 elsewhere in
+    # this repo, nothing establishes what 0 does here. Silent no-op via
+    # None, same shape as range_hood._lamp_level_write.
+    minutes = round(float(payload))
+    if minutes < 1:
+        return None
+    return ["airlevelcheck", "vs", "0"], {
+        "x.com.samsung.da.periodicSensingInterval": str(minutes * 60)
+    }
+
+
+def _periodic_sensing_write(payload, rep, href=None):
+    # Master on/off; leaves autoExeState alone so the configured action
+    # survives the feature being toggled off -- the select can't do that,
+    # since every option write sets an action too.
+    return ["airlevelcheck", "vs", "0"], {
+        "x.com.samsung.da.periodicSensingActivationState": ("On" if payload == "On" else "Off")
+    }
+
+
+def _skip_status_write(payload, rep, href=None):
+    return ["airlevelcheck", "vs", "0"], {
+        "x.com.samsung.da.periodicSensingSkipStatus": ("On" if payload == "On" else "Off")
+    }
+
+
+# Daily skip window, stored as one HHMMHHMM string
+# (periodicSensingSkipTime). Cross-confirmed on two units (inert
+# '00000000' vs a real '03002300'). Split into two HA time entities; each
+# write reads the other half back out of the live rep so the pair
+# round-trips -- confirmed in both directions on hardware.
+def _skip_time_read(part):
+    def _read(value):
+        raw = str(value or "")
+        chunk = raw[0:4] if part == "start" else raw[4:8]
+        if len(chunk) == 4 and chunk.isdigit():
+            try:
+                return datetime.time(int(chunk[:2]), int(chunk[2:]))
+            except ValueError:
+                return None
+        return None
+
+    return _read
+
+
+def _skip_half(raw, part):
+    """The half this write isn't setting, normalized. An unparseable half
+    becomes '0000' rather than carrying a malformed value back to the
+    device."""
+    chunk = (str(raw or "") + "00000000")[:8]
+    other = chunk[4:8] if part == "start" else chunk[0:4]
+    return other if _skip_time_read("end" if part == "start" else "start")(chunk) else "0000"
+
+
+def _skip_time_write(part):
+    def _write(value, rep, href=None):
+        raw = rep.get("x.com.samsung.da.periodicSensingSkipTime", "")
+        hhmm = f"{value.hour:02d}{value.minute:02d}"
+        other = _skip_half(raw, part)
+        new = hhmm + other if part == "start" else other + hhmm
+        return ["airlevelcheck", "vs", "0"], {"x.com.samsung.da.periodicSensingSkipTime": new}
+
+    return _write
+
+
+AIR_LEVEL_CHECK = Capability(
+    href="/airlevelcheck/vs/0",
+    poll_tier="warm",
+    entities=(
+        SwitchDesc(
+            key="periodic_air_sensing",
+            field="x.com.samsung.da.periodicSensingActivationState",
+            icon="mdi:radar",
+            entity_category="config",
+            value_fn=lambda v: str(v).lower() == "on",
+            write_fn=_periodic_sensing_write,
+        ),
+        # Options come off supportedAutoExeState rather than a typed table,
+        # so an unrecognized fourth value still reaches the user.
+        SelectDesc(
+            key="sensing_mode",
+            field="x.com.samsung.da.autoExeState",
+            options_field="x.com.samsung.da.supportedAutoExeState",
+            translation_key="sensing_mode",
+            icon="mdi:radar",
+            entity_category="config",
+            write_fn=lambda p, rep, href=None: (
+                ["airlevelcheck", "vs", "0"],
+                {"x.com.samsung.da.autoExeState": p},
+            ),
+        ),
+        # The one field that varies across families: TP1X_DA-AC-AIR (#130)
+        # omits it, so that board runs sensing on a fixed, unexposed
+        # interval.
+        NumberDesc(
+            key="sensing_interval",
+            field="x.com.samsung.da.periodicSensingInterval",
+            icon="mdi:timer-cog",
+            entity_category="config",
+            native_min=1,
+            native_max=60,
+            step=1,
+            unit="min",
+            exists_fn=lambda rep, resources: "x.com.samsung.da.periodicSensingInterval" in rep,
+            value_fn=_interval_minutes,
+            write_fn=_interval_write,
+        ),
+        SwitchDesc(
+            key="periodic_sensing_skip_status",
+            field="x.com.samsung.da.periodicSensingSkipStatus",
+            icon="mdi:sleep",
+            entity_category="config",
+            value_fn=lambda v: str(v).lower() == "on",
+            write_fn=_skip_status_write,
+        ),
+        TimeDesc(
+            key="sensing_skip_start",
+            field="x.com.samsung.da.periodicSensingSkipTime",
+            icon="mdi:clock-start",
+            entity_category="config",
+            value_fn=_skip_time_read("start"),
+            write_fn=_skip_time_write("start"),
+        ),
+        TimeDesc(
+            key="sensing_skip_end",
+            field="x.com.samsung.da.periodicSensingSkipTime",
+            icon="mdi:clock-end",
+            entity_category="config",
+            value_fn=_skip_time_read("end"),
+            write_fn=_skip_time_write("end"),
+        ),
+        # Read-only status, same keys as range_hood.AIR_LEVEL_CHECK.
+        SensorDesc(
+            key="air_sensing_state",
+            field="x.com.samsung.da.sensingState",
+            icon="mdi:radar",
+            entity_category="diagnostic",
+        ),
+        SensorDesc(
+            key="last_air_sensing_time",
+            field="x.com.samsung.da.lastSensingTime",
+            device_class="timestamp",
+            entity_category="diagnostic",
+            value_fn=epoch_to_utc,
+        ),
+        # 'Kr1' on both dumps -- a region-prefixed, undocumented grade;
+        # stays a raw diagnostic rather than an asserted enum.
+        SensorDesc(
+            key="last_air_sensing_level",
+            field="x.com.samsung.da.lastSensingLevel",
+            icon="mdi:air-filter",
+            entity_category="diagnostic",
+        ),
+    ),
+)
+
+# /humidity/0 and /humidity/vs/0 are empty on both dumps -- covered here
+# (not globally) since they collide with fridge/AC schemas elsewhere, same
+# reasoning as airconditioner.py's _AC_IGNORED. The next six hrefs (issue
+# #130) are the exact same DA-AC- board resources as _AC_IGNORED,
+# duplicated here rather than promoted to the global list (a possible
+# follow-up DRY cleanup).
 COVERAGE = [
     Capability(href="/humidity/0"),
     Capability(href="/humidity/vs/0"),
-    Capability(href="/airlevelcheck/vs/0"),  # periodic air-quality sensing scheduler plumbing
     Capability(href="/availablecontrolsets/vs/0"),  # opaque hex-encoded control-set bitmap
     Capability(href="/da/softreset/vs/0"),  # soft-reset trigger plumbing
     Capability(href="/keepnormalstate/vs/0"),  # internal keep-normal flag
     Capability(href="/personality/presence/vs/0"),  # presence-personalization plumbing (empty here)
     Capability(href="/reserverulesets/vs/0"),  # opaque hex-encoded schedule reservation blob
-    # Do-not-disturb/auto-sleep schedule (visible/startTime/endTime/
+    # Do-not-disturb/auto-sleep schedule -- every field reads its inert
-    # useTimeSetting/functionState) -- every field reads its inert default
+    # default on the only dump seen. Needs a multi-field schedule editor,
-    # on the only dump seen (times both '00:00:00', useTimeSetting/
+    # same as fridge.py's /defrost/reservation/vs/0.
-    # functionState both 'false'). Same "needs a multi-field schedule
-    # editor" treatment as fridge.py's /defrost/reservation/vs/0.
     Capability(href="/dnd/autosleep/vs/0"),
-    # Empty ({}) on the A-VTWW-TP2-21 dump (issue #151) -- this board's
+    # Empty on the A-VTWW-TP2-21 dump (issue #151) -- this board's
-    # convenient-mode-equivalent behavior lives entirely in WIND_STRENGTH_FAN
+    # convenient-mode equivalent lives in WIND_STRENGTH_FAN instead.
-    # above instead.
     Capability(href="/mode/convenient/vs/0"),
 ]

custom_components/localthings/registry/capabilities/common.py

@@ -49,12 +49,10 @@ def wh_to_kwh(v):
 
 
 def parse_iso_utc(raw):
-    """ISO datetime defaulting to UTC when the string carries no timezone
+    """ISO datetime defaulting to UTC when the string carries no timezone of
-    of its own (this integration's convention for other bare ISO datetime
+    its own. A few boards ship a 'Z'/offset suffix already (fromisoformat
-    fields -- see washer.py's drum-clean-log comment). A few boards do
+    parses that natively since Python 3.11) -- only fill in UTC when parsing
-    ship a 'Z'/offset suffix (fromisoformat parses that natively since
+    left the result naive."""
-    Python 3.11) -- only fill in UTC when parsing left the result naive,
-    rather than unconditionally overwriting whatever offset was parsed."""
     if not raw:
         return None
     try:
@@ -64,24 +62,42 @@ def parse_iso_utc(raw):
     return dt if dt.tzinfo is not None else dt.replace(tzinfo=UTC)
 
 
-def filter_usage_percent(rep):
+def epoch_to_utc(value):
-    """Filter usage as a percentage of rated capacity. Several families
+    """Unix epoch seconds -> aware UTC datetime, for boards that report a
-    (AC, air purifier) report `filterUsage` as a raw count in
+    bare epoch rather than the ISO string parse_iso_utc handles."""
-    `filterCapacityUnit` (Hours, e.g. 100 of a 500 capacity), so a plain
+    try:
-    value with a '%' unit would be wrong -- normalize to used/capacity.
+        return datetime.fromtimestamp(float(value), tz=UTC)
-    Returns None when capacity is missing/zero."""
+    except (TypeError, ValueError, OSError):
-    used = _num(rep.get("x.com.samsung.da.filterUsage"))
-    cap = _num(rep.get("x.com.samsung.da.filterCapacity"))
-    if used is None or not cap:
         return None
-    return round(used / cap * 100)
+
+
+def filter_usage_percent(rep):
+    """Filter usage as a percentage. `filterUsage` is already 0-100 on every
+    family confirmed so far, including ARTIK051_PRAC (issue #330): its own
+    fixture and three live heads all show `filterStatus == 'wash'` at
+    `filterUsage == '100'` regardless of `filterCapacity` (60/224/500 across
+    other families' fixtures), which only holds if `filterUsage` is already
+    a percent -- dividing by capacity again would read that filter as fresh
+    at 20%."""
+    return int_or_none(rep.get("x.com.samsung.da.filterUsage"))
+
+
+def filter_usage_hours(rep):
+    """Elapsed filter hours, derived from the percentage and capacity rather
+    than read off `filterUsage` directly -- `filterUsage` is a percent, not
+    an hour count (issue #330). Returns None when capacity is missing/zero."""
+    pct = filter_usage_percent(rep)
+    cap = _num(rep.get("x.com.samsung.da.filterCapacity"))
+    if pct is None or not cap:
+        return None
+    return round(pct / 100 * cap, 1)
 
 
 def normalize_temp_unit(raw, default="°F"):
     """'C'/'Celsius' -> '°C', 'F'/'Fahrenheit' -> '°F'. Falls back to
     `default` for any other/missing value. Shared by fridge.py and oven.py,
-    both of which read a per-device unit off a `/temperature*` resource
+    which both read a per-device unit off a `/temperature*` resource
-    instead of assuming one (see fridge.py's module docstring, issue #7)."""
+    instead of assuming one (issue #7)."""
     raw = (raw or "").strip().upper()
     if raw.startswith("C"):
         return "°C"
@@ -96,25 +112,17 @@ def _ml_to_l(v):
 
 
 def _active_alarm_codes(items):
-    """Join active alarm codes; skip retained rows Samsung leaves as Deleted,
+    """Join active alarm codes; skip retained rows Samsung leaves as
-    and any code ending in '_OFF'.
+    Deleted, and any code ending in '_OFF'.
 
     Laundry boards keep a Deleted ErrorCode row in /alarms/vs/0 after the
-    condition clears (see WD7000B diagnostics). Surface only live alarms so
+    condition clears. Samsung also pre-populates this array with one row
-    HA doesn't stick on a stale ErrorCode.
+    per alarm *type* the board supports, each carrying its own
-
+    '<Name>_OFF' placeholder when that alarm isn't firing -- confirmed
-    Samsung pre-populates this array with one row per alarm *type* the board
+    across independent families. A firing alarm instead reports a plain,
-    supports, each carrying its own '<Name>_OFF' placeholder code when that
+    unsuffixed code (FilterAlarm, DoorA_Opened, ...); issue #166 shows both
-    alarm isn't firing -- confirmed across independent device families
+    in one dump. Generalizes what range hood used to special-case as just
-    (ErrorCode_OFF, FilterAlarm_OFF, OV_E_OFF, CT_E_OFF, WaterTankFull_OFF,
+    the literal 'ErrorCode_OFF' string.
-    AC_V_0002_OFF all appear in fixtures with no corresponding active
-    condition). An alarm that's actually firing instead reports a plain,
-    unsuffixed code (FilterAlarm, DoorA_Opened, SNSF_Reached) -- issue #166's
-    AC dump has both a FilterAlarm_OFF placeholder and shows what a live
-    filter alert looks like: code 'FilterAlarm' (no suffix), state
-    'Created'. Range-hood previously special-cased only the literal
-    'ErrorCode_OFF' string in its own stricter helper; this generalizes
-    the same rule to the whole '_OFF' suffix convention.
     """
     if not items or not isinstance(items, list):
         return "none"
@@ -128,18 +136,38 @@ def _active_alarm_codes(items):
     return ", ".join(codes) if codes else "none"
 
 
+def hex_pairs(codes):
+    """'1C1D21...' -> ['1C', '1D', '21', ...]."""
+    return [codes[i : i + 2] for i in range(0, len(codes) - 1, 2)]
+
+
+def option_value(options, prefix):
+    """Find `<prefix>_<value>` in an options[] array and return <value>.
+
+    Lives here rather than in laundry.py, which is where it grew, because
+    cloudcourse.py needs it too and laundry.py imports *that* -- so the
+    reverse import would be a module cycle. The coordinator already imports
+    from this module, so nothing about the dependency direction is unusual;
+    it is specifically the laundry/cloudcourse pair that can't reach each
+    other. Anchored at position 0 so 'Course_' never matches
+    'CloudCourse_'/'OneTimeCloudCourse_'.
+    """
+    for o in options or []:
+        if isinstance(o, str) and o.startswith(prefix + "_"):
+            return o.split("_", 1)[1]
+    return None
+
+
 def merge_options_field(cached, new_tokens):
     """Merge freshly-written `<Prefix>_<Value>` tokens into a cached
     x.com.samsung.da.options[]-style array the same way the device itself
     merges them: match by prefix, replace if present, append if not.
 
-    Confirmed on real hardware (issue #54) that a write only needs to carry
+    Confirmed on hardware (issue #54) that a write only needs to carry the
-    the changed token(s), not the whole array -- see laundry.option_write /
+    changed token(s), not the whole array -- see laundry.option_write /
-    oven._option_write for the write side. This is the read side of that
+    oven._option_write for the write side. coordinator.async_send_command
-    same fact: coordinator.async_send_command uses it to keep the
+    uses this read-side counterpart to keep the optimistic cache entry
-    optimistic cache entry for the written href complete (every sibling
+    complete during the write-settle window."""
-    option still present) during the write-settle window, since the wire
-    body it applies straight to the cache no longer carries them."""
     merged = list(cached or [])
     for token in new_tokens or ():
         if not isinstance(token, str) or "_" not in token:
@@ -157,18 +185,15 @@ def merge_options_field(cached, new_tokens):
 
 def merge_items_field(cached, new_items):
     """Merge a partial x.com.samsung.da.items[]-style write (matched by
-    x.com.samsung.da.id) into a cached items array -- the read-side
+    x.com.samsung.da.id) into a cached items array -- the items[]
-    counterpart of merge_options_field above, for the items[] shape instead
+    counterpart of merge_options_field above.
-    of the packed options[] shape.
 
-    Confirmed on hardware that a write only needs to carry the array item
+    Confirmed on hardware that a write only needs to carry the item with
-    with the changed id plus the field(s) being changed; the device merges
+    the changed id plus the field(s) being changed (see
-    the rest itself (same fact as the options[] case, different array --
+    airconditioner._climate_write's vendor temperature write). Fields
-    see airconditioner._climate_write's vendor temperature write). Fields
     within the matched item are merged, not replaced outright, so a
     setpoint-only write doesn't wipe current/minimum/maximum/unit from the
-    optimistic cache entry for the settle window. An id with no match in
+    optimistic cache entry. An id with no match in `cached` is appended."""
-    `cached` is appended."""
     merged = [dict(i) if isinstance(i, dict) else i for i in (cached or [])]
     for new_item in new_items or ():
         if not isinstance(new_item, dict):
@@ -184,22 +209,19 @@ def merge_items_field(cached, new_items):
 
 
 # /wm/setinfo/vs/0 -- laundry-family firmware capability flags. Present on
-# washers, dryers, and dishwashers; absent on fridge/oven/AC. Static for the
+# washers, dryers, and dishwashers; absent on fridge/oven/AC. Static for
-# life of a given board, so reading them from the /device/0 seed (no dedicated
+# the life of a board, so reading it from the /device/0 seed is enough.
-# poll_tier) is enough.
 _SETINFO_HREF = "/wm/setinfo/vs/0"
 _POWER_ON_OFF_FIELD = "x.com.samsung.da.isModelSettingPowerOnOff"
 _WITHOUT_SC_FIELD = "x.com.samsung.da.isModelSettingWithoutSC"
 
 
 def model_allows_power_on_off(resources: dict) -> bool:
-    """True unless firmware explicitly declares remote power on/off unsupported.
+    """True unless firmware explicitly declares remote power on/off
-
+    unsupported. isModelSettingPowerOnOff is "false" on many laundry
-    `/wm/setinfo/vs/0`.`isModelSettingPowerOnOff` is `"false"` on many laundry
+    boards: /power/0 and /power/vs/0 still report state, but CoAP writes
-    boards (washers/dryers): `/power/0` and `/power/vs/0` still report state,
+    are ignored. Absent setinfo (non-laundry families) keeps the writable
-    but CoAP writes are ignored. Absent setinfo (non-laundry families) keeps
+    switch."""
-    the writable switch -- current behavior.
-    """
     setinfo = resources.get(_SETINFO_HREF)
     if setinfo is None:
         return True
@@ -210,13 +232,11 @@ def model_allows_power_on_off(resources: dict) -> bool:
 
 
 def model_setting_without_sc(resources: dict) -> bool:
-    """True when firmware declares settings writable without Smart Control.
+    """True when firmware declares settings writable without Smart
-
+    Control. isModelSettingWithoutSC is "true" on washers/dryers that
-    `/wm/setinfo/vs/0`.`isModelSettingWithoutSC` is `"true"` on washers/dryers
+    accept temperature/spin/cycle-option writes while remote control is
-    that accept temperature/spin/cycle-option writes while remote control is
+    off; cycle start/pause/stop still need Smart Control on those
-    off. Cycle start/pause/stop still need Smart Control on those boards --
+    boards."""
-    the flag name is settings-specific, not a blanket remote-control bypass.
-    """
     setinfo = resources.get(_SETINFO_HREF) or {}
     return str(setinfo.get(_WITHOUT_SC_FIELD, "")).lower() == "true"
 
@@ -229,13 +249,42 @@ def _power_sensor_exists(rep, resources):
     return not model_allows_power_on_off(resources)
 
 
+def diagnosis_status(value):
+    """'Ready' -> the catalog's 'ready'; anything else is left raw.
+
+    Shared by dishwasher and dryer, which report the same field.
+    """
+    return "ready" if value == "Ready" else value
+
+
 def sensor_item_value(items, sensor_type, index=0):
     """Pull one reading out of a `/sensors/vs/0`-style items[] list -- each
-    item is `{type, value: [...]}`; `index` picks which slot of a possibly
+    item is `{type, value: [...]}`; `index` picks which slot to read
-    multi-value reading to read (index 0 is the raw measurement on every
+    (index 0 is the raw measurement on every family seen so far). Shared
-    family seen so far). Shared by range_hood.AIR_QUALITY,
+    by range_hood.AIR_QUALITY, air_purifier.AIR_QUALITY, and
-    air_purifier.AIR_QUALITY, and air_monitor.SENSORS, which all read the
+    air_monitor.SENSORS, which all read the same resource shape.
-    same resource shape against the same {type, sensor_type} keys."""
+
+    value[] is 2-element on the fields that carry a magnitude
+    (Dust/FineDust/SuperFineDust/CO2) and 1-element on Odor/CleanLevel.
+    That asymmetry is what index 1 means: it is the device's own graded
+    air-quality level for that reading -- the same kind of value Odor and
+    CleanLevel already *are*, which is why those two have no second slot.
+    It reads 0-2 against index 0's observed 0-31, tracks index 0 within a
+    device, and CleanLevel equals the highest per-field grade on 9 of the
+    11 fixtures reporting this resource (the range hood and one RAC report
+    a higher CleanLevel than any dust grade, so they fold in something
+    else).
+
+    Index 1 is deliberately left unbound rather than exposed as an entity:
+    its floor is not portable. ARTIK051_TVTL grades good air as 0, while
+    AVT-WW-TP1 / A-VTWW-TP2 / TP1X / ASM-KR-TP1 / AHD-WW-TP1 all grade it
+    as 1, so a shared descriptor would need a per-family offset to mean
+    anything, and CleanLevel already carries the aggregate. The grade is
+    still load-bearing as *evidence*: it is what confirms the three dust
+    fields are three different scales rather than one repeated reading --
+    see air_purifier._AIR_QUALITY_SENSORS and
+    tests/test_air_quality_grade_column.py.
+    """
     for item in items or ():
         if not isinstance(item, dict):
             continue
@@ -250,26 +299,42 @@ def sensor_item_value(items, sensor_type, index=0):
     return None
 
 
-# OCF-native / vendor '-vs' fallback pairs for power, kids-lock, remote control.
+def has_sensor_type(type_):
-#
+    """True when /sensors/vs/0's items[] lists an item of this type.
-# These three controls exist as both a standard OCF resource (/power/0,
+
-# oic.r.switch.binary, plain boolean 'value') and a Samsung vendor resource
+    This only proves the type is *listed*, not that the reading is real:
-# (/power/vs/0, x.com.samsung.da.power) -- Samsung advertises both as its
+    issue #166 (ARTIK051_PRAC_20K) lists all five types with permanent-zero
-# firmware migrates onto the OCF standard model. Prefer the OCF-standard href
+    values on units the reporter confirmed don't have the hardware. So
-# when the device exposes it; the '-vs' href (a string-encoded duplicate for
+    entities gated on this stay disabled by default rather than
-# these three) binds only when the generic href is absent, via match_fn. Older
+    existence-gated further, to avoid silently dropping real readings on
-# firmware has only the '-vs' resource, so the pair is behaviour-identical to a
+    hardware not yet seen.
-# lone '-vs' cap there. See the adding-device-support skill's "OCF-standard vs
+
-# vendor" section for why this is preferred-non-vs-with-fallback, not a blanket
+    is_stub_rep(rep) keeps the stub carve-out (see entity._is_included /
-# choice. Every device registry lists both caps of each pair.
+    ENERGY_METER, issue #127): an explicit exists_fn otherwise bypasses it
+    and would drop the entity when /device/0 returns a not-yet-fetched stub.
+    """
+
+    def fn(rep, resources):
+        return is_stub_rep(rep) or any(
+            isinstance(i, dict) and i.get("x.com.samsung.da.type") == type_
+            for i in (rep.get("x.com.samsung.da.items") or [])
+        )
+
+    return fn
+
+
+# OCF-native / vendor '-vs' fallback pairs for power, kids-lock, remote
+# control: each exists as both a standard OCF resource (/power/0,
+# oic.r.switch.binary, plain boolean 'value') and a Samsung vendor
+# resource (/power/vs/0, x.com.samsung.da.power), since Samsung advertises
+# both while its firmware migrates onto the OCF standard model. Prefer the
+# OCF-standard href when present; the '-vs' href binds only when it's
+# absent, via match_fn. Older firmware has only the '-vs' resource. See
+# the adding-device-support skill's "OCF-standard vs vendor" section.
+# Every device registry lists both caps of each pair.
 
 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
@@ -319,16 +384,14 @@ POWER_VS_FALLBACK = Capability(
 KIDS_LOCK_GENERIC = Capability(
     href="/kidslock/0",
     entities=(
-        # Read-only like KIDS_LOCK_VS_FALLBACK (issues #181/#183) -- not a
+        # Read-only like KIDS_LOCK_VS_FALLBACK (issues #181/#183): HA's
-        # SwitchDesc. SwitchDesc's `device_class='lock'` was never honored
+        # switch platform never honored SwitchDesc's device_class='lock'
-        # by HA (its switch platform only accepts 'outlet'/'switch'),
+        # ('outlet'/'switch' only), leaving a plain switch whose 'On' meant
-        # leaving a plain switch whose 'On' state meant different things
+        # different things on different boards. As a BinarySensorDesc with
-        # on different boards. As a BinarySensorDesc with `device_class='lock'`,
+        # device_class='lock', both surfaces read with the same polarity
-        # both kids-lock surfaces read with the same polarity: 'On' means
+        # ('On' = open/unlocked, per HA convention); value_fn here inverts
-        # open/unlocked, per HA's lock device_class. The inversion in
+        # the wire value to match (value=False on /kidslock/0 means kids
-        # value_fn here (and in the fallback below) keeps the on-the-wire
+        # lock is NOT active).
-        # truth (value=False on /kidslock/0, kidsLock='Ready' on /kidslock/vs/0
-        # both mean kids lock NOT active) consistent with that polarity.
         BinarySensorDesc(
             key="child_lock", field="value", device_class="lock", value_fn=lambda v: not bool(v)
         ),
@@ -339,16 +402,11 @@ KIDS_LOCK_VS_FALLBACK = Capability(
     href="/kidslock/vs/0",
     match_fn=lambda rep, resources: "/kidslock/0" not in resources,
     entities=(
-        # Read-only, not a SwitchDesc (issues #181/#183): the write side of
+        # Read-only, not a SwitchDesc (issues #181/#183): the old write
-        # this capability wrote 'Enable', a value no dump in the fixture
+        # side wrote 'Enable', a value no dump ever reports back (every one
-        # corpus has ever reported back -- every one reports either 'Ready'
+        # is 'Ready' or 'Run'), and #181's reporter confirmed writing the
-        # or 'Run', so it was never a confirmed contract. #181's reporter
+        # correct value ('Run') still 4.05s -- genuinely read-only on this
-        # confirmed this directly: writing the *correct* value ('Run')
+        # hardware. Polarity matches KIDS_LOCK_GENERIC ('On' = unlocked).
-        # still 4.05s, and the SmartThings app itself has no control for
-        # it either -- the resource is genuinely read-only on this
-        # hardware, not just wrong-valued. Polarity matches
-        # KIDS_LOCK_GENERIC above -- 'On' means open/unlocked, so
-        # kidsLock='Ready' (kids lock NOT active) renders as 'On'.
         BinarySensorDesc(
             key="child_lock",
             field="x.com.samsung.da.kidsLock",
@@ -361,15 +419,11 @@ KIDS_LOCK_VS_FALLBACK = Capability(
 
 def remote_control_enabled(resources: dict) -> bool:
     """Single source of truth for the /remotectrl on/off signal, mirroring
-    REMOTE_CONTROL_GENERIC/_VS_FALLBACK's href/field pair and precedence
+    REMOTE_CONTROL_GENERIC/_VS_FALLBACK's href/field precedence. Used both
-    below. Used both to render the read-only Smart Control binary_sensor
+    to render the read-only Smart Control binary_sensor and, from
-    (via those two descriptors) and, from coordinator.async_send_command,
+    coordinator.async_send_command, to block writes when remote control is
-    to block writes outright when remote control is off. Both hrefs are
+    off. True (assume enabled) when neither href is present -- most device
-    poll_tier='warm' below so that gate reads recent state (subscribed
+    types don't report this capability at all."""
-    when observe is live, subpolled every ~6s otherwise) rather than a
-    once-per-30s cold summary poll. True (assume enabled) when neither
-    href is present -- most device types don't report this capability
-    at all."""
     generic = resources.get("/remotectrl/0")
     if generic is not None:
         return bool(generic.get("value"))
@@ -434,26 +488,21 @@ ALARMS = Capability(
     ),
 )
 
-# instantaneousPower is a dead field on DA_WM_-class laundry dumps (washers and
+# instantaneousPower is a dead field on DA_WM_-class laundry dumps and
-# the issue #14 dryer) and on dishwashers too: the literal sentinel '-500',
+# dishwashers: the literal sentinel '-500', unchanged across off/idle/
-# unchanged across off/idle/running. clamp_power floors it to a misleading
+# running. clamp_power would floor it to a misleading "0 W". Gate
-# "0 W" that reads as a real idle measurement. Gate power_watts out when the
+# power_watts out when the sentinel is seen, but only then, so a device
-# sentinel is seen -- but only then, so a device reporting a real value (e.g. a
+# reporting a real value (e.g. a fridge's 93 W) still shows it (issue #6).
-# fridge's 93 W) still shows it (issue #6). cumulativePower is absent on at
-# least one washer model; the exists_fn makes that explicit rather than relying
-# on the generic field-presence gate.
 _DEAD_INSTANTANEOUS_POWER = "-500"
 
 ENERGY_METER = Capability(
     href="/energy/consumption/vs/0",
     entities=(
-        # `is_stub_rep(rep)` keeps the stub carve-out (see entity._is_included):
+        # is_stub_rep(rep) keeps the stub carve-out (see
-        # an explicit exists_fn otherwise bypasses it, which would drop the
+        # entity._is_included): an explicit exists_fn otherwise bypasses
-        # entity when /device/0 returns a not-yet-fetched stub. A genuinely
+        # it and would drop the entity when /device/0 returns a
-        # empty {} rep is NOT a stub -- it's the device's confirmed (if empty)
+        # not-yet-fetched stub. A genuinely empty {} rep is NOT a stub, so
-        # answer, so it falls through to the normal field/sentinel checks like
+        # it still falls through to the normal field/sentinel checks.
-        # any populated rep. On a populated rep, hide power only for the dead
-        # sentinel or an absent field.
         SensorDesc(
             key="power_watts",
             field="x.com.samsung.da.instantaneousPower",
@@ -481,11 +530,7 @@ ENERGY_METER = Capability(
             ),
         ),
         # cumulativeConsumption is a second, independently-varying running
-        # total alongside cumulativePower -- some fridges (issue #26) report
+        # total some fridges (issue #26) report alongside cumulativePower.
-        # both. Self-gates off where only cumulativePower is present. The
-        # `is_stub_rep(rep) or` keeps the same stub carve-out as power_watts/
-        # energy_kwh above -- without it, an exists_fn permanently drops the
-        # entity if setup happens to land on a not-yet-fetched stub.
         SensorDesc(
             key="power_energy_kwh",
             field="x.com.samsung.da.cumulativeConsumption",
@@ -498,8 +543,8 @@ ENERGY_METER = Capability(
             ),
         ),
         # AI Energy Mode's lifetime savings estimate vs. an unoptimized
-        # baseline -- present on some models (e.g. TP1X_REF_21K, issue #21/
+        # baseline -- present on some models (issue #21/#27), absent on
-        # #27) and absent on others (issue #20/#26), unlike cumulativePower.
+        # others (issue #20/#26).
         SensorDesc(
             key="energy_saved_kwh",
             field="x.com.samsung.da.cumulativeSavedPower",
@@ -511,9 +556,8 @@ ENERGY_METER = Capability(
                 is_stub_rep(rep) or "x.com.samsung.da.cumulativeSavedPower" in rep
             ),
         ),
-        # Monthly billing-cycle totals -- the completed prior month and the
+        # Monthly billing-cycle totals -- completed prior month and
-        # in-progress current month. Not ever-increasing (each resets at
+        # in-progress current month. Not ever-increasing, so no state_class.
-        # month boundary), so no state_class.
         SensorDesc(
             key="energy_last_month_kwh",
             field="x.com.samsung.da.monthlyConsumption",
@@ -574,26 +618,21 @@ WATER_FILTER = Capability(
     ),
 )
 
-# AI energy-saving level -- '0' is off, and supportedAiLevel lists the
+# AI energy-saving level -- '0' is off, supportedAiLevel lists the
-# additional level(s) the device offers ('1' meaning just "on" on most
+# additional level(s) offered ('1' meaning just "on" on most hardware,
-# hardware, but multi-level boards have been reported). Verified cross-family:
+# multi-level on some). Verified cross-family: fridge (issue #21) and
-# fridge (issue #21) and washer (issue #40) both expose this href.
+# washer (issue #40). Most hardware's supportedAiLevel is a single-entry
-#
+# list, so a select there would offer only one real choice against an
-# supportedAiLevel is a single-entry list on most captured hardware, where a
+# implicit "off" -- shown as a switch instead; '0' is never in
-# select would offer only one real choice against an implicit "off" -- shown
+# supportedAiLevel but is the observed off value, so the select
-# as a switch instead. '0' itself is never in supportedAiLevel but has been
+# synthesizes it back in as an explicit option. No translation_key:
-# observed live as the off value of aiLevel, so the select synthesizes it
+# aiLevel's values are plain digit strings, and select.py already renders
-# back in as an explicit option rather than leaving no way to turn off.
+# an untranslated numeric string as-is.
-#
-# No translation_key: aiLevel's values are plain digit strings, and
-# select.py's _display() already renders an untranslated numeric string
-# as-is -- there's nothing a catalog entry adds that's worth maintaining
-# against an unknown, growing number of future levels.
 
 
 def _ai_energy_supported_levels(rep):
-    """supportedAiLevel as a list -- a stray scalar (e.g. a string) must not
+    """supportedAiLevel as a list -- a stray scalar must not be
-    be len()-checked as if it were a list."""
+    len()-checked as if it were one."""
     sl = rep.get("supportedAiLevel")
     return list(sl) if isinstance(sl, (list, tuple)) else []
 
@@ -618,21 +657,15 @@ AI_ENERGY_LEVEL = Capability(
     poll_tier="cold",
     entities=(
         # No is_stub_rep carve-out on either side, unlike most exists_fn
-        # gates in this file -- entity creation only ever runs once, against
+        # gates in this file: entity creation runs once against whichever
-        # whichever snapshot happens to be current the moment platforms are
+        # snapshot is current at platform setup, while flatten() re-checks
-        # set up (see entity._is_included / __init__.py's
+        # exists_fn every poll against live data. Both descriptors share
-        # async_config_entry_first_refresh-before-forward-entry-setups
+        # key='ai_energy_level' -- a stub carve-out could let one win at
-        # ordering), while flatten() re-evaluates exists_fn every poll
+        # setup and the other win once real data lands, feeding the
-        # against live data. Both descriptors share key='ai_energy_level',
+        # instantiated entity a value shaped for the other platform.
-        # so if a stub carve-out let one of them win at setup time while the
+        # Requiring populated data on both sides keeps the two decisions in
-        # other wins once real data lands, flatten() would feed the
+        # permanent agreement, at the cost of the entity not appearing
-        # instantiated entity a value shaped for the other platform (e.g. a
+        # until a reload if the first poll stubs this cold-tier href.
-        # bool into a Select). Requiring real, populated data on both sides
-        # keeps the entity-creation decision and the live-value decision in
-        # permanent agreement -- the cost is this entity doesn't appear
-        # until a reload if the device's very first poll stubs this
-        # cold-tier href, the same reload already required to fix which
-        # platform got picked in that case.
         SwitchDesc(
             key="ai_energy_level",
             field="aiLevel",
@@ -708,37 +741,27 @@ SELF_CHECK = Capability(
     ),
 )
 
-# ---------------------------------------------------------------------------
 # Cross-family bundles, unpacked into every by_type registry's _build([...])
-# call the same way ignored.IGNORED is (*common.UNIVERSAL / *common.POWER).
+# call the same way ignored.IGNORED is. discover() only binds a capability
-# discover() only binds a capability whose href is actually present in a
+# whose href is actually present in a given device's dump, so listing one
-# given device's resource dump, so listing one here for a family that
+# here for a family that doesn't expose the href is a no-op, not a phantom
-# doesn't expose the href is a no-op, not a phantom entity -- see the
+# entity -- see the adding-device-support skill's coverage-discipline
-# adding-device-support skill's coverage-discipline section.
+# section.
 #
-# UNIVERSAL holds every capability with no known family that both (a) has
+# UNIVERSAL holds every capability with no known family that both has the
-# the href and (b) needs to model it some other way -- broadening one of
+# href and needs to model it some other way.
-# these to a new family is a safe, harmless guess (issue #40's AI energy
-# level: 2 of 6 families confirmed, blanket-added everywhere else).
 #
-# POWER is kept separate -- airconditioner is the one family that opts out
+# POWER is kept separate: airconditioner opts out of it entirely, since
-# of it entirely. Canonical reason (see by_type/airconditioner.py and its
+# its climate entity already owns /power/0 and /power/vs/0 via bare
-# test for pointers back here, not restatements): AC's climate entity
+# no-entity Capability objects (airconditioner.COVERAGE), and a second
-# already owns /power/0 and /power/vs/0 via bare, no-entity Capability
+# real cap on the same href would make _build() raise (see
-# objects (airconditioner.COVERAGE), and a second, real POWER_GENERIC/
+# by_type/airconditioner.py). Kids-lock/remote-control have no such
-# POWER_VS_FALLBACK cap on the same href would make _build() raise (a href
+# conflict, so they stay in UNIVERSAL.
-# 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
+# Airconditioner also partially opts out of UNIVERSAL itself: issue #193
-# POWER: issue #193 needs ENERGY_METER's cumulativePower scale to differ by
+# needs ENERGY_METER's cumulativePower scale to differ by board
-# board generation, so by_type/airconditioner.py excludes just that one
+# generation, so by_type/airconditioner.py excludes just that one member
-# member (`*[c for c in common.UNIVERSAL if c is not common.ENERGY_METER]`)
+# and substitutes its own ENERGY_METER_GENERIC/ENERGY_METER_LEGACY.
-# and substitutes airconditioner.ENERGY_METER_GENERIC/ENERGY_METER_LEGACY in
-# its place -- every other registry still unpacks UNIVERSAL wholesale.
-# ---------------------------------------------------------------------------
 
 UNIVERSAL = (
     ALARMS,

custom_components/localthings/registry/capabilities/dehumidifier.py

@@ -15,8 +15,8 @@ from .common import int_or_none
 
 def _first_mode(rep):
     """Representative scalar for the operating-mode select. `modes` is a
-    single-element list on every dump seen so far, mirroring
+    single-element list on every dump seen, mirroring
-    airconditioner._first_mode's handling of the same field shape."""
+    airconditioner._first_mode."""
     modes = rep.get("x.com.samsung.da.modes")
     if isinstance(modes, (list, tuple)):
         return modes[0] if modes else None
@@ -40,14 +40,11 @@ MODE = Capability(
     ),
 )
 
-# Target humidity is this device's primary control (the issue-#88 dump's
+# Target humidity is this device's primary control (issue #88's equivalent
-# equivalent of a thermostat setpoint). No min/max range field is present in
+# of a thermostat setpoint). No min/max range field is present in any dump
-# any dump seen so far -- native_min/native_max are deliberately left unset
+# seen, so native_min/native_max are left unset, falling back to HA's own
-# so the number entity falls back to HA's own 0-100 default, the natural
+# 0-100 default rather than a bound guessed from one unit's spec sheet.
-# bound for a percentage field, rather than a bound guessed from one unit's
+# Step comes live from the device's own `increment` field.
-# spec sheet (see the adding-device-support skill's "never hard-code the one
-# dump's values" section). Step comes live from the device's own `increment`
-# field.
 HUMIDITY = Capability(
     href="/humidity/vs/0",
     poll_tier="warm",
@@ -77,15 +74,13 @@ HUMIDITY = Capability(
     ),
 )
 
-# Water-tank ambient light (issues #271/#231, TP1X_DA_AC_DHM_01001_0000):
+# Water-tank ambient light (issues #271/#231): on/off, color, and
-# on/off, color, and brightness are three independent controls on this one
+# brightness are three independent controls on this one resource.
-# resource. `waterfullAlarmStatus` differs between the two dumps that
+# `waterfullAlarmStatus` differs between the two dumps that reported this
-# reported this href (On vs. Off) so it's a real live flag, not a constant --
+# href, so it's a real live flag, but its exact meaning (tank full vs. the
-# but its exact meaning (tank actually full vs. the chime feature merely
+# chime feature merely enabled) isn't confirmed, and /alarms/vs/0 already
-# enabled) isn't confirmed by either dump alone, and /alarms/vs/0's
+# surfaces a live WaterTankFull condition -- exposed read-only as a plain
-# alarm_code already surfaces a live WaterTankFull condition when one fires
+# diagnostic rather than guessed at as a binary_sensor.
-# (see common._active_alarm_codes), so this is exposed read-only as a plain
-# diagnostic value rather than guessed at as a binary_sensor.
 WATERTANK_LIGHTING = Capability(
     href="/watertank/lighting/vs/0",
     poll_tier="cold",
@@ -131,13 +126,10 @@ WATERTANK_LIGHTING = Capability(
     ),
 )
 
-# ---------------------------------------------------------------------------
+# Dehumidifier-scoped coverage: vendor plumbing with no user-actionable
-# Dehumidifier-scoped coverage: vendor plumbing with no user-actionable state
+# state, following the same rule as airconditioner._AC_IGNORED (same
-# or no documented write contract, following the same 'don't guess' rule as
+# DA_AC_ board family). Not in the global ignored.IGNORED since some hrefs
-# airconditioner._AC_IGNORED (this is the same DA_AC_ board family). Not in
+# collide with other families' schemas.
-# the global ignored.IGNORED since some of these hrefs collide with other
-# families' schemas.
-# ---------------------------------------------------------------------------
 _DHM_IGNORED = [
     "/availablecontrolsets/vs/0",  # opaque hex-encoded control-set bitmap (id: DHM)
     "/da/softreset/vs/0",  # soft-reset trigger plumbing

custom_components/localthings/registry/capabilities/dishwasher.py

@@ -9,7 +9,12 @@ wash, auto release dry) are read locally here.
 
 from ..capability import Capability
 from ..entities import ButtonDesc, SelectDesc, SensorDesc, SwitchDesc
-from .laundry import bool_option_switch, cycle_select
+from .common import diagnosis_status
+from .laundry import (
+    bool_option_switch,
+    cycle_select,
+    drum_clean_cycles_remaining,
+)
 
 # ---------------------------------------------------------------------------
 # /dishwasher/vs/0 — cycle wash/dry settings
@@ -41,26 +46,29 @@ DISHWASHER_SETTINGS = Capability(
     ),
 )
 
-# ---------------------------------------------------------------------------
+# /course/vs/0 -- cycle selection (shared laundry.cycle_select) plus the
-# /course/vs/0 — cycle selection (shared laundry.cycle_select) plus the
+# dishwasher-only StormWashZone / AutoDoorRelease toggles riding in the same
-# dishwasher-only StormWashZone / AutoDoorRelease toggles that ride in the
+# options array (shared laundry.bool_option_switch). Course display names
-# same options array (shared laundry.bool_option_switch, same options[]
+# live in translations under entity.select.dishwasher_cycle.
-# boolean-toggle contract washer's bubble-soak/pre-wash/intensive switches
-# use). Course display names live in translations under
-# entity.select.dishwasher_cycle (see laundry.cycle_select).
 #
-# '83'/'86' were transposed in that catalog until issue #226: both the
+# '83'/'86' were transposed in that catalog until issue #226: the original
-# original DW9000F-class fixture this table was built from and the issue
+# fixture's own live editCourseList puts them back to back, exactly the
-# #226 reporter's board report the identical DeviceType_0812 (a real
+# kind of adjacent pair a manual screenshot transcription slips on. The
-# per-board-generation id also seen on unrelated washer/dryer fixtures, so
+# reporter's live confirmation (selecting 'Normal' ran the physical Express
-# this is one shared course table, not a Table_02/Table_03-style generation
+# 60 program and vice versa) settled it: '86' is Express 60, '83' is Normal.
-# split), and the original fixture's own live editCourseList
+#
-# ('EditCourseList_0E07908683848D808E8F') puts '86' and '83' back to back at
+# Drum Clean+ maintenance tracking reuses washer.py/dryer.py's (issues #9,
-# positions 4-5 -- exactly the kind of adjacent pair a manual screenshot
+# #258) DrumCleanProposal_/WashingTimes_/DrumCleanLog_ tokens riding on this
-# transcription slips on. The reporter's live confirmation (selecting
+# same options[] array -- a live dump confirmed the dishwasher reports the
-# 'Normal' ran the physical Express 60 program and vice versa) settles
+# identical trio (WashingTimes_18/DrumCleanProposal_20, plus a '|'-joined
-# which way: '86' is Express 60, '83' is Normal.
+# DrumCleanLog_ history matching the dryer's multi-entry shape), so
-# ---------------------------------------------------------------------------
+# laundry.drum_clean_cycles_remaining applies unchanged.
+#
+# laundry.drum_clean_last_cleaned (DrumCleanLog_'s own newest entry) is
+# deliberately NOT wired up here (issue #398): a live dishwasher dump
+# showed it moving every 30-90s on its own, including well after a cycle
+# had already finished -- unlike the washer/dryer reports this reader was
+# built from (issues #9, #258), it never settles on a value worth showing.
 
 CYCLE_OPTIONS = Capability(
     href="/course/vs/0",
@@ -70,6 +78,14 @@ CYCLE_OPTIONS = Capability(
         bool_option_switch(
             "auto_release_dry", "mdi:door-open", "AutoDoorRelease", gate_on_presence=True
         ),
+        SensorDesc(
+            key="drum_clean_cycles_remaining",
+            unit="cycles",
+            icon="mdi:dishwasher-alert",
+            state_class="measurement",
+            exists_fn=lambda rep, resources: drum_clean_cycles_remaining(rep) is not None,
+            rep_fn=drum_clean_cycles_remaining,
+        ),
     ),
 )
 
@@ -86,6 +102,9 @@ DIAGNOSIS = Capability(
             field="x.com.samsung.da.diagnosisStart",
             icon="mdi:stethoscope",
             entity_category="diagnostic",
+            device_class="enum",
+            options=("ready",),
+            value_fn=diagnosis_status,
         ),
         ButtonDesc(
             key="diagnosis_start",

custom_components/localthings/registry/capabilities/dryer.py

@@ -11,6 +11,7 @@ the /course/vs/0 cycle select -- lives in laundry.py.
 
 from ..capability import Capability
 from ..entities import SensorDesc, SwitchDesc
+from .common import diagnosis_status
 from .laundry import cycle_select, drum_clean_cycles_remaining, drum_clean_last_cleaned
 
 
@@ -26,7 +27,17 @@ DRYER_SETTINGS = Capability(
     entities=(
         SensorDesc(key="dry_level", field="x.com.samsung.da.dryLevel", icon="mdi:water-percent"),
         SensorDesc(key="dry_time", field="x.com.samsung.da.dryTime", icon="mdi:timer"),
-        SensorDesc(key="dryer_type", field="x.com.samsung.da.dryerType", icon="mdi:tumble-dryer"),
+        SensorDesc(
+            key="dryer_type",
+            field="x.com.samsung.da.dryerType",
+            icon="mdi:tumble-dryer",
+            device_class="enum",
+            # Only 'Electricity' confirmed across shipped fixtures (#366); an
+            # unrecognized value still passes through raw via sensor.py's
+            # options property rather than breaking the entity.
+            options=("electricity",),
+            value_fn=lambda v: v.lower() if isinstance(v, str) else v,
+        ),
         SwitchDesc(
             key="wrinkle_prevent",
             field="x.com.samsung.da.wrinklePrevent",
@@ -38,27 +49,32 @@ DRYER_SETTINGS = Capability(
 )
 
 # /course/vs/0 -- cycle selection, shared with washer/dishwasher via
-# laundry.cycle_select (options read live from /wm/editcourse/vs/0, written as
+# laundry.cycle_select. Course display names live in translations under
-# an RMW on the options array). Course display names live in translations
+# entity.select.dryer_cycle (Table_03, DV5000-class). Codes '01' Normal and
-# under entity.select.dryer_cycle (Table_03, DV5000-class, captured
+# '06' Time dry were confirmed on a DVE50A8600V/A3 by selecting each cycle
-# 2026-05-29). Codes '01' Normal and '06' Time dry were confirmed on a
+# on the appliance and reading back the raw code (issue #80); '51' Eco
-# DVE50A8600V/A3 (also Table_03) by selecting each cycle on the physical
+# Cotton, '53' AI Dry+, and '4e' Self Dry the same way on a DV90DG6845LHU5
-# appliance and reading back the raw code from the entity's state (issue
+# (issue #244). /st/dryercourse/vs/0 re-encodes the same selected course
-# #80). Codes '51' Eco Cotton, '53' AI Dry+, and '4e' Self Dry were
+# and is ignored (ignored.py), mirroring /st/washercourse/vs/0 for washers.
-# confirmed the same way on a DV90DG6845LHU5 (issue #244). The
+#
-# /st/dryercourse/vs/0 resource re-encodes the same selected course and is
+# dryer_cycle_table_00 is a separate, older course-code family reported by
-# ignored (ignored.py) -- the mirror of how /st/washercourse/vs/0 is ignored
+# a DVE45R6300W/A3 (issue #357), confirmed the same way: the reporter
-# for washers.
+# selected each cycle on the appliance and read back the resulting raw
+# code. It shares no codes with Table_03 above -- 'a5' Bedding here and
+# '01' Normal are both table-scoped, so a Table_03 dryer never picks up a
+# Table_00 label or vice versa (see laundry.cycle_select's table_href).
+# A DV6800N -- same DA_WM_A51_20_COMMON board, also Table_00 -- confirmed
+# 14 more courses the same way (issue #394); its /course/vs/0 supportedOptions
+# only advertises a different subset of this same table (each model exposes
+# whichever courses its hardware supports), not a conflicting code family --
+# the one code both reporters confirmed, 'a5', means Bedding on both. Folded
+# into the same catalog entry below rather than a new one.
 #
 # Drum Clean+ maintenance tracking (issue #258) reuses washer.py's
 # DrumCleanProposal_/WashingTimes_/DrumCleanLog_ tokens on this same
 # options[] array -- see laundry.drum_clean_cycles_remaining/
-# drum_clean_last_cleaned's docstrings for the field contract, including
+# drum_clean_last_cleaned. No separate heat-exchanger-clean tracking was
-# the dryer-specific '|'-joined multi-entry DrumCleanLog_ shape. No
+# found on either dump #258 supplied, so if the app surfaces that reminder,
-# separate heat-exchanger-clean tracking was found on either dump #258
-# supplied (DV90BB7445GES7, DV91T6440LE/SA) -- no HeatExchanger*-prefixed
-# token, nor any other options[] entry that looks like a second maintenance
-# counter -- so if the Samsung app surfaces that reminder for these units,
 # it isn't computed from anything this integration can read locally.
 DRYER_COURSE = Capability(
     href="/course/vs/0",
@@ -92,7 +108,12 @@ DRYER_DIAGNOSIS = Capability(
     poll_tier="warm",
     entities=(
         SensorDesc(
-            key="diagnosis", field="x.com.samsung.da.diagnosisStart", entity_category="diagnostic"
+            key="diagnosis",
+            field="x.com.samsung.da.diagnosisStart",
+            entity_category="diagnostic",
+            device_class="enum",
+            options=("ready",),
+            value_fn=diagnosis_status,
         ),
     ),
 )

custom_components/localthings/registry/capabilities/ehs.py

@@ -9,11 +9,10 @@ vocabulary with the room-AC family in airconditioner.py beyond the DA_AC_
 board prefix -- EHS reports its own /mode/*/vs/0 and /temperatures/*/vs/0
 shapes, not airconditioner.py's HREF_MODE/HREF_TEMP* OCF-pattern hrefs.
 
-zone1 has no HA platform with matching semantics (it's a leaving-water-
+zone1 has no HA platform with matching semantics (a leaving-water-
-temperature setpoint, not a thermostat with HVAC modes airconditioner.py's
+temperature setpoint, not a thermostat with HVAC modes), so it stays
-climate.py would fit), so it stays switch/select/number/sensor -- same shape
+switch/select/number/sensor -- same shape as dehumidifier.py's power/mode/
-as dehumidifier.py's power/mode/humidity split. dhw is a real HA
+humidity split. dhw is a real HA water_heater.py entity (see DHW below),
-water_heater.py -- see DHW below and water_heater.py's module docstring --
 following the same primary-resource-plus-sibling-reads pattern as
 airconditioner.py's CLIMATE/climate.py.
 
@@ -35,8 +34,7 @@ def _num(v):
 
 def _first_mode(rep):
     """Representative scalar for a mode select -- `modes` is a single-element
-    list on every dump seen so far, mirroring airconditioner._first_mode /
+    list on every dump seen, mirroring airconditioner._first_mode."""
-    dehumidifier._first_mode's handling of the same field shape."""
     modes = rep.get("x.com.samsung.da.modes")
     if isinstance(modes, (list, tuple)):
         return modes[0] if modes else None
@@ -48,14 +46,9 @@ def _temp_unit(rep):
 
 
 def _bounds(rep, default_min, default_max):
-    """The resource's own (minimum, maximum) pair, or the defaults.
+    """The resource's own (minimum, maximum) pair, or the defaults. Both
-
+    ends together or neither -- a board reporting only one would otherwise
-    Both ends together or neither -- a board reporting only one would
+    pair a real bound with an invented default, silently wrong."""
-    otherwise pair a real device bound with an invented default, which
-    looks plausible and is silently wrong. Same rule as
-    climate._range()/water_heater._range(), and the same reason
-    oven._setpoint_bounds resolves its pair in one place.
-    """
     lo = _num(rep.get("x.com.samsung.da.minimum"))
     hi = _num(rep.get("x.com.samsung.da.maximum"))
     return (lo, hi) if (lo is not None and hi is not None) else (default_min, default_max)
@@ -102,8 +95,8 @@ ZONE_MODE = Capability(
 )
 
 # type=Water/unit=Celsius on this dump names the space-heating loop's flow/
-# room setpoint, not a literal water temperature -- Samsung EHS zone control
+# room setpoint, not a literal water temperature -- EHS zone control is
-# is leaving-water-temperature-based, same convention as the dhw loop below.
+# leaving-water-temperature-based, same convention as the dhw loop below.
 ZONE_TEMPERATURE = Capability(
     href="/temperatures/indoor/vs/0",
     poll_tier="warm",
@@ -134,12 +127,10 @@ ZONE_TEMPERATURE = Capability(
     ),
 )
 
-# Canonical dhw resource hrefs. water_heater.py binds the primary HREF_DHW_MODE
+# Canonical dhw resource hrefs. water_heater.py binds HREF_DHW_MODE via DHW
-# via DHW below and reads the sibling power/temperature hrefs off the
+# below and reads the sibling power/temperature hrefs off the coordinator
-# coordinator snapshot -- same primary-plus-siblings shape as
+# snapshot -- same primary-plus-siblings shape as airconditioner.py's
-# airconditioner.py's HREF_MODE/CLIMATE_CONSUMED_HREFS. Declared once here
+# HREF_MODE/CLIMATE_CONSUMED_HREFS.
-# and imported by water_heater.py, so a new sibling read can't drift out of
-# sync with its DHW_CONSUMED_HREFS coverage entry below.
 HREF_DHW_POWER = "/power/dhw/vs/0"  # on/off
 HREF_DHW_MODE = "/mode/dhw/vs/0"  # primary (bound by DHW) -- current_operation
 HREF_DHW_TEMPERATURE = "/temperatures/dhw/vs/0"  # current/target temperature
@@ -150,8 +141,7 @@ DHW_CONSUMED_HREFS = [HREF_DHW_POWER, HREF_DHW_TEMPERATURE]
 def _dhw_write(payload, rep, href=None):
     """Map a (kind, value) command from the water_heater platform to the
     (path_segs, body) for that one sub-write -- same contract as
-    airconditioner._climate_write, just across the dhw loop's three
+    airconditioner._climate_write, across the dhw loop's three resources."""
-    resources instead of the AC's power/mode/temperature/wind set."""
     kind, value = payload
     if kind == "power":
         return (["power", "dhw", "vs", "0"], {"x.com.samsung.da.power": "On" if value else "Off"})
@@ -174,19 +164,15 @@ DHW = Capability(
 
 # Power and temperature are read by the composite DHW entity above, not
 # given their own entities -- coverage-only caps so discover() reports no
-# gap (see airconditioner.py's CLIMATE_CONSUMED_HREFS for the same pattern).
+# gap (see airconditioner.py's CLIMATE_CONSUMED_HREFS).
 DHW_CONSUMED = [Capability(href=h, poll_tier="warm") for h in DHW_CONSUMED_HREFS]
 
 # Deliberately a plain config switch, not water_heater's AWAY_MODE feature.
-# HA core's smartthings water_heater does wire this same Samsung capability
+# HA core's smartthings integration wires this same Samsung capability up
-# (CUSTOM_OUTING_MODE) up to WaterHeaterEntityFeature.AWAY_MODE, and the DHW
+# to WaterHeaterEntityFeature.AWAY_MODE, so the divergence is worth
-# operation-mode map above is taken from that integration -- so the
+# stating: /option/outgoing/vs/0 is device-wide (one `away` flag covering
-# divergence is worth stating. /option/outgoing/vs/0 is device-wide: one
+# zone1 too, with no dhw-scoped sibling href). Hanging it off the DHW card
-# `away` flag covering the whole unit, zone1 included (it has no dhw-scoped
+# would present a device-wide setting as hot-water-only.
-# sibling href, unlike every other resource in this loop). Hanging it off
-# the DHW card would present a device-wide setting as if it only affected
-# hot water. It stays a switch until a board turns up with a per-loop away
-# resource to bind instead.
 AWAY_MODE = Capability(
     href="/option/outgoing/vs/0",
     poll_tier="cold",
@@ -205,13 +191,9 @@ AWAY_MODE = Capability(
     ),
 )
 
-# ---------------------------------------------------------------------------
+# EHS-scoped coverage: opaque vendor plumbing or resources with no
-# EHS-scoped coverage: opaque vendor plumbing (hex-encoded factory/cycle/
+# confirmed write contract on this dump. Not in the global ignored.IGNORED
-# schedule blobs) or resources with no confirmed write contract on this
+# since these are EHS-only shapes needing their own verification elsewhere.
-# dump, following the same 'don't guess' rule as dehumidifier._DHM_IGNORED.
-# Not in the global ignored.IGNORED since these are EHS-only shapes that
-# would need their own verification on other device families.
-# ---------------------------------------------------------------------------
 _EHS_IGNORED = [
     "/availablecontrolsets/vs/0",  # opaque hex-encoded control-set bitmap (id: EHS)
     "/da/softreset/vs/0",  # soft-reset trigger plumbing

custom_components/localthings/registry/capabilities/fridge.py

@@ -3,17 +3,15 @@
 Resources verified against the dump at local-tools/dumps/10.0.0.254.json.
 
 Temperature unit is read live from each resource, not assumed: the RF9000B
-dump reports Fahrenheit ("units": "F" / "x.com.samsung.da.unit": "Fahrenheit"),
+dump reports Fahrenheit, but a TP1X_REF_21K dump (issue #7) reports the same
-but a TP1X_REF_21K dump (issue #7) reports the same fields in Celsius for the
+fields in Celsius for the exact same resources -- the device tells you which
-exact same resources — the device tells you which one it is, it's just never
+one it is. See `_temp_unit`/`_temp_item_unit` below.
-been read before. See `_temp_unit`/`_temp_item_unit` below. Setpoints are
-NumberDesc with direct-write write_fn — generic caps derive the CoAP PUT path
-from href at write time.
 
-Multi-instance note: the two door resources (/door/cooler/0 and
+Multi-instance note: the two door resources (/door/cooler/0,
-/door/freezer/0) and the two ice-maker resources (/icemaker/one/vs/0 and
+/door/freezer/0) and the two ice-maker resources (/icemaker/one/vs/0,
-/icemaker/two/vs/0) use named path segments, so they are modelled via
+/icemaker/two/vs/0) use named path segments, so they are modeled via
-pattern capabilities that auto-derive distinct entity keys from href segments.
+pattern capabilities that auto-derive distinct entity keys from href
+segments.
 """
 
 import datetime
@@ -27,13 +25,11 @@ from ..entities import (
     SwitchDesc,
     TimeDesc,
 )
-from .common import normalize_temp_unit
+from .common import int_or_none, normalize_temp_unit
 
 # Display names for the beverage zone, flex zone, ice type, and
-# ice-making-status enums below live in translations/en.json,
+# ice-making-status enums below live in translations/en.json, keyed by the
-# keyed by the lowercased raw device value — select.py and SensorDesc.options
+# lowercased raw device value.
-# normalize to lowercase for HA's translation lookup and map back to this
-# original casing before writing to the device.
 
 
 def _int(v):
@@ -44,14 +40,13 @@ def _int(v):
 
 
 def _temp_unit(rep):
-    """'units': 'C'/'F' (or 'Celsius'/'Fahrenheit') -> '°C'/'°F'. Defaults to
+    """'units': 'C'/'F' (or 'Celsius'/'Fahrenheit') -> '°C'/'°F'. Defaults
-    °F (this module's original assumption) if the device omits the field."""
+    to °F if the device omits the field."""
     return normalize_temp_unit(rep.get("units"))
 
 
-# ---------------------------------------------------------------------------
+# Temperature (generic -- covers /temperature/current/* and
-# Temperature (generic — covers /temperature/current/* and /temperature/desired/*)
+# /temperature/desired/*)
-# ---------------------------------------------------------------------------
 
 TEMP_CURRENT_GENERIC = Capability(
     href=None,
@@ -74,14 +69,10 @@ TEMP_CURRENT_GENERIC = Capability(
 
 
 def _temp_setpoint_write(p, rep, href=None, resources=None):
-    """Write temperature — prefer vendor /temperatures/vs/0 when available,
+    """Prefer vendor /temperatures/vs/0 when present, else the direct OCF
-    fall back to direct OCF /temperature/desired/ write otherwise.
+    /temperature/desired/ write -- on some models only the vendor path
-
+    commits. Item IDs follow the Samsung convention: "0" = Freezer,
-    Samsung fridges expose both OCF-standard /temperature/desired/* and vendor
+    "1" = Fridge/Cooler."""
-    /temperatures/vs/0. On some models only the vendor path commits the change;
-    on others both work. Using the vendor path when present is always correct.
-    Item IDs follow the Samsung convention: "0" = Freezer, "1" = Fridge/Cooler.
-    """
     if not href:
         return None
     if resources and "/temperatures/vs/0" in resources:
@@ -127,18 +118,12 @@ TEMP_SETPOINT = Capability(
     ),
 )
 
-# ---------------------------------------------------------------------------
+# Discrete cooler setpoint (issue #186): single-door "cooler only" fridges
-# Discrete cooler setpoint (issue #186) -- some single-door ("cooler only")
+# report no /temperature/current|desired/* pair, only this vendor resource
-# fridges report no /temperature/current|desired/* pair at all (this href
+# bundling the live desired value with the specific values the unit
-# doesn't match TEMP_CURRENT_GENERIC/TEMP_SETPOINT's '/temperature/current/'
+# accepts. supportedList (e.g. ['1','2','3','4','7']) is not a contiguous
-# or '/temperature/desired/' prefixes), only this one vendor resource that
+# range, so this is a select reading its own live options rather than a
-# bundles the live desired value together with the *specific* values the
+# NumberDesc with min/max/step.
-# 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):
@@ -171,11 +156,8 @@ def _definite_freezer_write(p, rep, href=None):
     )
 
 
-# Freezer half of the same discrete-setpoint pattern (issue #229): a
+# Freezer half of the same discrete-setpoint pattern (issue #229) -- same
-# fridge/freezer combo reporting no /temperature/current|desired/freezer
+# shape as DEFINITE_TEMPERATURE_COOLER, negative supportedList values.
-# pair, only this bundled vendor resource -- identical shape to
-# DEFINITE_TEMPERATURE_COOLER above (down to the field names), just negative
-# supportedList values (e.g. ['-23','-21','-19','-17','-15']).
 DEFINITE_TEMPERATURE_FREEZER = Capability(
     href="/temperature/definite/freezer/vs/0",
     poll_tier="warm",
@@ -191,10 +173,6 @@ DEFINITE_TEMPERATURE_FREEZER = Capability(
     ),
 )
 
-# ---------------------------------------------------------------------------
-# Icemaker nighttime quiet mode
-# ---------------------------------------------------------------------------
-
 ICEMAKER_NIGHTTIME = Capability(
     href="/icemaker/nighttime/vs/0",
     poll_tier="warm",
@@ -213,18 +191,13 @@ ICEMAKER_NIGHTTIME = Capability(
     ),
 )
 
-# ---------------------------------------------------------------------------
+# Icemaker (generic -- covers /icemaker/one/vs/0, /icemaker/two/vs/0).
-# Icemaker (generic — covers /icemaker/one/vs/0, /icemaker/two/vs/0)
+# /icemaker/status/vs/0 is an exact-href cap and binds first;
-# /icemaker/status/vs/0 is kept as exact-href cap and binds first.
 # /icemaker/nighttime/vs/0 is excluded by match_fn (lacks iceMaker.state).
-#
 # Entity names interpolate x.com.samsung.da.iceMaker.name ("CUBED_ICE",
-# "ICE_BITES") -- read via name_field, reaching the translated name as the
+# "ICE_BITES") via name_field, not the href's "one"/"two" segment -- these
-# {instance_name} placeholder -- not the href's "one"/"two" segment. These two
+# two makers can both be enabled at once (issue #27), so they stay
-# ice makers are independent on/off toggles that can both be enabled at once
+# separate entities rather than one ice-type select.
-# (issue #27), so they stay separate entities rather than a single ice-type
-# select, but users still want them labeled with the device's own names.
-# ---------------------------------------------------------------------------
 
 
 def _icemaker_write(field):
@@ -273,10 +246,6 @@ ICEMAKER_GENERIC = Capability(
     ),
 )
 
-# ---------------------------------------------------------------------------
-# Door alert tone
-# ---------------------------------------------------------------------------
-
 DOOR_ALERT = Capability(
     href="/settings/sound/alert/door/vs/0",
     poll_tier="warm",
@@ -296,9 +265,38 @@ DOOR_ALERT = Capability(
     ),
 )
 
-# ---------------------------------------------------------------------------
+
-# Status/lock — auto door opener and fridge sound
+# Internal deodorizing filter (issue #318, TP1X_REF_21K). Same
-# ---------------------------------------------------------------------------
+# filterUsage/filterStatus field pair as common.WATER_FILTER, but
+# filterUsage here is already a 0-100 percentage with no filterCapacity to
+# divide by (confirmed by filterStatus=="wash" at filterUsage=="100") --
+# 'air_'-prefixed keys so a fridge with both a water and an air filter gets
+# two distinct entities rather than a unique_id collision.
+AIR_FILTER = Capability(
+    href="/filter/airdustfilter/vs/0",
+    poll_tier="cold",
+    entities=(
+        SensorDesc(
+            key="air_filter_usage",
+            field="x.com.samsung.da.filterUsage",
+            unit="%",
+            state_class="measurement",
+            icon="mdi:air-filter",
+            entity_category="diagnostic",
+            value_fn=int_or_none,
+        ),
+        SensorDesc(
+            key="air_filter_status",
+            field="x.com.samsung.da.filterStatus",
+            device_class="enum",
+            options=("normal", "wash", "replace"),
+            translation_key="filter_status",
+            icon="mdi:air-filter",
+            entity_category="diagnostic",
+            value_fn=lambda v: v.lower() if isinstance(v, str) else v,
+        ),
+    ),
+)
 
 
 def _status_lock_write(field):
@@ -328,21 +326,159 @@ STATUS_LOCK = Capability(
             value_fn=lambda v: v == "On",
             write_fn=_status_lock_write("x.com.samsung.da.device.sound"),
         ),
+        # Auto Door Open's own voice/sound feedback toggles (issue #328,
+        # TP1X_REF_21K family) -- siblings of auto_door_opener above, not
+        # duplicates of fridge_sound (device.sound is the general appliance
+        # beep, these two gate ado's own prompts). Only seen on the
+        # auto-door-equipped variants (single/kimchi/winecellar), not the
+        # earlier TP1X_REF_21K dumps that predate that feature -- gated on
+        # each field's own presence rather than assumed universal.
+        SwitchDesc(
+            key="auto_door_voice_control",
+            field="x.com.samsung.da.ado.voicecontrol",
+            icon="mdi:microphone",
+            entity_category="config",
+            value_fn=lambda v: v == "On",
+            write_fn=_status_lock_write("x.com.samsung.da.ado.voicecontrol"),
+            exists_fn=lambda rep, resources: "x.com.samsung.da.ado.voicecontrol" in rep,
+        ),
+        SwitchDesc(
+            key="auto_door_sound_control",
+            field="x.com.samsung.da.ado.soundcontrol",
+            icon="mdi:volume-medium",
+            entity_category="config",
+            value_fn=lambda v: v == "On",
+            write_fn=_status_lock_write("x.com.samsung.da.ado.soundcontrol"),
+            exists_fn=lambda rep, resources: "x.com.samsung.da.ado.soundcontrol" in rep,
+        ),
     ),
 )
 
-# ---------------------------------------------------------------------------
+# Auto Door Open's paired delay setting (issue #328, TP1X_REF_21K family):
-# Defrost delay / active-defrost status
+# how long the door stays held open before it re-closes, on/off itself is
+# STATUS_LOCK.auto_door_opener above. Same discrete-options-select shape as
+# DEFINITE_TEMPERATURE_COOLER/FREEZER. Unit unconfirmed -- no supportedList
+# field states it and the report carried no app screenshot -- so this is a
+# raw-code select rather than a guessed seconds/minutes NumberDesc.
+
+
+def _auto_door_timer_write(p, rep, href=None):
+    return ["autodoor", "timer", "vs", "0"], {"x.com.samsung.da.time.desired": p}
+
+
+AUTO_DOOR_TIMER = Capability(
+    href="/autodoor/timer/vs/0",
+    poll_tier="warm",
+    entities=(
+        SelectDesc(
+            key="auto_door_timer",
+            field="x.com.samsung.da.time.desired",
+            icon="mdi:timer-outline",
+            translation_key="auto_door_timer",
+            entity_category="config",
+            options_field="x.com.samsung.da.time.supportedOptions",
+            write_fn=_auto_door_timer_write,
+        ),
+    ),
+)
+
+# /autodoor/<variant>/vs/0 -- one per fridge sub-type sharing the Auto Door
+# Open feature (single-door, kimchi, winecellar seen so far; issue #328).
+# Each reports only x.com.samsung.da.ado.openOptions, declaring which open
+# styles that variant supports -- every dump seen so far carries exactly
+# one option ('Single') with no paired desired/current field to make a
+# choice against, the same "no real choice to expose yet" shape as
+# ignored.py's /mode/0. Bound with no entities to record coverage; revisit
+# if a device ever reports more than one option.
 #
+# A pattern cap rather than one entry per variant: match_fn (not just the
+# prefix) is what actually gates this, so a future variant href needs no
+# code change to stay covered, and /autodoor/timer/vs/0's own exact-href
+# AUTO_DOOR_TIMER above always wins for that href regardless (discover()
+# only falls through to pattern caps when no exact cap matched). This is
+# registry-scoped, not global -- unlike ignored.IGNORED, the unknown-
+# device-type fallback never reaches it, so the prefix caveat in
+# ignored.py's own docstring doesn't apply here.
+AUTO_DOOR_VARIANT = Capability(
+    href=None,
+    href_prefix="/autodoor/",
+    match_fn=lambda rep, resources: "x.com.samsung.da.ado.openOptions" in rep,
+)
+
+# Wine-cellar variant (x.com.st.d.winecellar, issue #328) of the same
+# deodorizing filter AIR_FILTER models -- filterUsage/filterStatus at a
+# different href, same 0-100-percentage-already shape (see AIR_FILTER's own
+# comment). filterUsage reads '-1' on the only dump seen (filterStatus
+# 'normal'), relayed as-is rather than special-cased -- no second dump to
+# confirm whether that's a real sentinel or this unit just not tracking it.
+# Own 'deodor_'-prefixed keys rather than reusing AIR_FILTER.entities
+# verbatim -- same collision AIR_FILTER's own 'air_' prefix was chosen to
+# avoid against WATER_FILTER, and both filters are plausible on one unit
+# (this device's own board reports an internal air filter on other
+# TP1X_REF_21K variants).
+DEODOR_FILTER = Capability(
+    href="/filter/deodorfilter/vs/0",
+    poll_tier="cold",
+    entities=(
+        SensorDesc(
+            key="deodor_filter_usage",
+            field="x.com.samsung.da.filterUsage",
+            unit="%",
+            state_class="measurement",
+            icon="mdi:air-filter",
+            entity_category="diagnostic",
+            value_fn=int_or_none,
+        ),
+        SensorDesc(
+            key="deodor_filter_status",
+            field="x.com.samsung.da.filterStatus",
+            device_class="enum",
+            options=("normal", "wash", "replace"),
+            translation_key="filter_status",
+            icon="mdi:air-filter",
+            entity_category="diagnostic",
+            value_fn=lambda v: v.lower() if isinstance(v, str) else v,
+        ),
+    ),
+)
+
+# Wine-cellar multi-compartment pantry select (issue #328): same
+# mode/supportedOptions shape as PANTRY_ZONE, at its own href with a 5-way
+# option set (Processed_Meat/Cheese/Nuts/Fruit/Wine) instead of PANTRY_ZONE's.
+# Only a "one" instance seen -- not generalized to a pattern cap, same
+# discipline as PANTRY_ZONE itself.
+
+
+def _winecellar_pantry_write(p, rep, href=None):
+    return ["status", "winecellar", "pantry", "one", "vs", "0"], {"x.com.samsung.da.mode": p}
+
+
+WINECELLAR_PANTRY_ZONE = Capability(
+    href="/status/winecellar/pantry/one/vs/0",
+    poll_tier="warm",
+    entities=(
+        SelectDesc(
+            key="winecellar_pantry_zone_mode",
+            field="x.com.samsung.da.mode",
+            icon="mdi:glass-wine",
+            translation_key="winecellar_pantry_zone_mode",
+            entity_category="config",
+            options_field="x.com.samsung.da.supportedOptions",
+            write_fn=_winecellar_pantry_write,
+        ),
+    ),
+)
+
+# Wine-cellar internal table-revision marker (issue #328) -- versioning
+# metadata, not appliance state. Same treatment as ignored.py's
+# /wm/setinfo/vs/0.
+WINECELLAR_INFO = Capability(href="/information/winecellar/vs/0")
+
 # /defrost/delay/vs/0 is the writable toggle to postpone a scheduled
-# defrost. /defrost/block/vs/0 is an unrelated, independently-varying
+# defrost. /defrost/block/vs/0 is unrelated: despite the "block" naming,
-# status: despite its "block" naming (originally assumed to mean "defrost
+# live dumps confirm DEFROST_BLOCK_ON means the defrost cycle is actively
-# is being withheld"), live dumps confirm DEFROST_BLOCK_ON means the
+# running right now (seen with defrost_delay off) -- "block" refers to the
-# defrost cycle is *actively running* right now, seen with defrost_delay
+# evaporator/coil block being defrosted, not a prevention state.
-# off -- i.e. "block" refers to the evaporator/coil block being defrosted,
-# not a blocking/prevention state. Exposed as a read-only diagnostic
-# binary sensor.
-# ---------------------------------------------------------------------------
 
 DEFROST_DELAY = Capability(
     href="/defrost/delay/vs/0",
@@ -362,10 +498,9 @@ DEFROST_DELAY = Capability(
     ),
 )
 
-# OCF-native boolean mirror of DEFROST_DELAY.  The captured TP1X_REF_21K
+# OCF-native boolean mirror of DEFROST_DELAY -- only the vendor resource
-# firmware publishes the same state on both hrefs, but only the vendor resource
+# above has a confirmed write contract, so bind this without another
-# above has a confirmed write contract.  Bind the native mirror without another
+# entity to record it as an intentional duplicate.
-# entity so discovery records it as an intentional duplicate.
 DEFROST_DELAY_NATIVE_DUPLICATE = Capability(
     href="/defrost/delay/0",
 )
@@ -384,10 +519,6 @@ DEFROST_BLOCK_STATUS = Capability(
     ),
 )
 
-# ---------------------------------------------------------------------------
-# Refrigeration modes (rapid cooling)
-# ---------------------------------------------------------------------------
-
 
 def _refrigeration_write(field_name):
     def _write(p, rep, href=None):
@@ -421,10 +552,6 @@ REFRIGERATION = Capability(
     ),
 )
 
-# ---------------------------------------------------------------------------
-# Autofill
-# ---------------------------------------------------------------------------
-
 
 def _autofill_write(p, rep, href=None):
     if p not in ("On", "Off"):
@@ -447,10 +574,6 @@ AUTOFILL = Capability(
     ),
 )
 
-# ---------------------------------------------------------------------------
-# Welcome lighting (proximity-triggered cabinet light)
-# ---------------------------------------------------------------------------
-
 WELCOME_LIGHTING = Capability(
     href="/proximity/vs/0",
     poll_tier="warm",
@@ -469,14 +592,11 @@ WELCOME_LIGHTING = Capability(
     ),
 )
 
-# ---------------------------------------------------------------------------
+# Enhanced cabinet light nighttime schedule: night.starttime is an ISO
-# Enhanced cabinet light — nighttime lighting schedule
+# datetime (only the time portion matters), night.duration.minute is the
-#
+# window length. End time is derived so both time entities write back to
-# night.starttime is an ISO datetime; only the time portion is meaningful.
+# the same resource without stepping on each other: writing start
-# night.duration.minute encodes the window length.  End time is derived so
+# preserves duration; writing end recalculates it.
-# both time entities write back to the same resource without stepping on each
-# other: writing start preserves duration; writing end recalculates duration.
-# ---------------------------------------------------------------------------
 
 _NIGHT_BRIGHTNESS_OPTIONS = ("33", "66", "100")
 
@@ -600,10 +720,6 @@ CABINET_LIGHT_ENHANCED = Capability(
     ),
 )
 
-# ---------------------------------------------------------------------------
-# Cabinet light
-# ---------------------------------------------------------------------------
-
 
 def _cabinet_light_write(p, rep, href=None):
     if p not in ("On", "Off"):
@@ -638,10 +754,6 @@ CABINET_LIGHT = Capability(
     ),
 )
 
-# ---------------------------------------------------------------------------
-# Sabbath mode
-# ---------------------------------------------------------------------------
-
 
 def _sabbath_write(p, rep, href=None):
     if p not in ("On", "Off"):
@@ -664,10 +776,6 @@ SABBATH = Capability(
     ),
 )
 
-# ---------------------------------------------------------------------------
-# Beverage zone
-# ---------------------------------------------------------------------------
-
 
 def _bzone_write(p, rep, href=None):
     return ["specialzone", "one", "vs", "0"], {"roomDesiredMode": p}
@@ -689,16 +797,11 @@ BEVERAGE_ZONE = Capability(
     ),
 )
 
-# ---------------------------------------------------------------------------
 # Pantry / Cool Select Zone -- a convertible compartment toggled between
-# wine/deli/drinks temperature presets (issue #20). Same shape as
+# wine/deli/drinks presets (issue #20). Same shape as BEVERAGE_ZONE but a
-# BEVERAGE_ZONE (a controllable named sub-zone with a mode + supported-modes
+# distinct field set (x.com.samsung.da.mode/supportedOptions vs
-# list) but a distinct resource/field set -- x.com.samsung.da.mode /
+# roomDesiredMode/roomSupportedModes). Only a "one" instance seen; not
-# x.com.samsung.da.supportedOptions on /status/pantry/one/vs/0, rather than
+# generalized to a pattern cap until a second instance turns up.
-# roomDesiredMode/roomSupportedModes on /specialzone/one/vs/0. Only a "one"
-# instance has been seen; not generalized to a pattern cap until a second
-# instance turns up.
-# ---------------------------------------------------------------------------
 
 
 def _pantry_write(p, rep, href=None):
@@ -721,18 +824,13 @@ PANTRY_ZONE = Capability(
     ),
 )
 
-# ---------------------------------------------------------------------------
+# Flex zone (convertible drawer -- /mode/vs/0 on RF9000-class fridges):
-# Flex zone (convertible drawer — /mode/vs/0 on RF9000-class fridges)
+# x.com.samsung.da.modes holds several orthogonal flags in one list; the
-#
+# flex-zone entry is whichever item also appears in supportedOptions (the
-# x.com.samsung.da.modes holds multiple orthogonal flags in one list; the
+# other flags, WATERFILTER_*/DEFROST_BLOCK_*/CVN_*_ZONE, never do). The
-# flex-zone entry is whichever item is also a member of supportedOptions --
+# prefix on that item varies by family (CV_TTYPE_RF9000A_ vs CV_FDR_ on
-# the other flags (WATERFILTER_*, DEFROST_BLOCK_*, the CVN_*_ZONE marker)
+# Bespoke, issues #27/#26), so match by list membership instead of a
-# never appear there. The prefix on that item varies by fridge family
+# hardcoded prefix. Write replaces only that item.
-# (CV_TTYPE_RF9000A_ on RF9000-class, CV_FDR_ on Bespoke-class -- issue #27 /
-# #26, where the old CV_TTYPE_RF9000A_-only match left this entity bound but
-# stuck on None), so match by list membership instead of a hardcoded prefix.
-# Write replaces only that item; other flags are preserved.
-# ---------------------------------------------------------------------------
 
 
 def _flex_zone_supported(rep):
@@ -740,10 +838,9 @@ def _flex_zone_supported(rep):
 
 
 def _flex_zone_current(rep):
-    # Every dump seen has at most one modes/supportedOptions overlap, so
+    # Every dump seen has at most one modes/supportedOptions overlap; a
-    # "first match" and "strip all matches" (in the write below) agree. If a
+    # future device reporting two would read the first and the write below
-    # future device ever reports two, this reads the first and the write
+    # would drop both.
-    # would drop both -- revisit if that turns up.
     modes = rep.get("x.com.samsung.da.modes") or []
     supported = _flex_zone_supported(rep)
     return next((m for m in modes if m in supported), None)
@@ -767,15 +864,11 @@ FLEX_ZONE = Capability(
             entity_category="config",
             options_field="x.com.samsung.da.supportedOptions",
             # A nonempty supportedOptions alone isn't sufficient: the
-            # kimchi-refrigerator family (issue #26) also populates
+            # kimchi-refrigerator family (issue #26) also populates both
-            # /mode/vs/0's modes/supportedOptions with real data, but
+            # fields, but its tokens carry a "_[n]:[n]" suffix on
-            # its tokens carry a "_[n]:[n]" parameter suffix on
+            # supportedOptions that modes never repeats, so nothing ever
-            # supportedOptions that modes never repeats, so no item
+            # overlaps there. Require an actual resolvable value so this
-            # ever overlaps -- the RF9000/Bespoke-class overlap this
+            # stays absent on that family instead of stuck on "unknown".
-            # capability was built for never happens there. Require an
-            # actual resolvable value instead of just a populated
-            # list, so this stays absent on that family rather than
-            # showing a select permanently stuck on "unknown".
             exists_fn=lambda rep, resources: _flex_zone_current(rep) is not None,
             rep_fn=_flex_zone_current,
             write_fn=_flex_zone_write,
@@ -783,18 +876,13 @@ FLEX_ZONE = Capability(
     ),
 )
 
-# ---------------------------------------------------------------------------
+# Generic door pattern capability (href=None -- use as pattern_cap only)
-# Generic door pattern capability (href=None — use as pattern_cap only)
-# ---------------------------------------------------------------------------
 
 
 def _door_open_state(rep):
     """Most /door/* resources report bare `openState`, but the
-    ARTIK051_DONGLE_REF family's /door/onedoorfreezer/vs/0 (issues #77, #83)
+    ARTIK051_DONGLE_REF family's /door/onedoorfreezer/vs/0 (issues #77,
-    reports the vendor-prefixed `x.com.samsung.da.openState` instead. This
+    #83) reports `x.com.samsung.da.openState` instead -- check both."""
-    capability still binds either way (href_prefix match doesn't care about
-    field names), but a plain `field=` lookup against the wrong key means
-    the entity exists and is permanently unavailable -- check both."""
     v = rep.get("openState")
     if v is None:
         v = rep.get("x.com.samsung.da.openState")
@@ -816,45 +904,27 @@ DOOR_GENERIC = Capability(
     ),
 )
 
-# ---------------------------------------------------------------------------
+# Kimchi refrigerator compartments (TP2X_REF_20K-class 3-compartment
-# Kimchi refrigerator compartments (TP2X_REF_20K-class 3-compartment kimchi
+# units, issue #26): top/middle/bottom each report their own storage mode
-# units, issue #26) -- top/middle/bottom each report their own storage mode
+# plus a ripening status/timer on /status/kimchi/<slot>/vs/0, modeled as a
-# plus a ripening status/timer on /status/kimchi/<slot>/vs/0, all three in
+# pattern capability the same way DOOR_GENERIC is. Only the top
-# an identical shape; modeled as a pattern capability the same way
+# compartment's door is reported separately (kimchidoors); middle/bottom
-# DOOR_GENERIC/TEMP_CURRENT_GENERIC above are, deriving the per-compartment
+# apparently have no contact switch, hence the narrower KIMCHI_DOOR_GENERIC
-# key and {instance_name} from the href's top/middle/bottom segment. Only
+# below rather than assuming it's universal.
-# the top compartment's door has been seen reported separately (kimchidoors);
-# middle/bottom apparently have no contact switch of their own, so that's
-# its own narrower pattern cap rather than assumed universal.
 #
-# The same state is also mirrored -- packed into single tokens like
+# The same state is also packed into single tokens (e.g.
-# "KIMCHIT_KIMCHI_STORAGE_NORMAL" (T/M/B prefix per compartment) with
+# "KIMCHIT_KIMCHI_STORAGE_NORMAL") on /mode/vs/0, the resource FLEX_ZONE
-# bracketed parameters -- on /mode/vs/0, the same resource FLEX_ZONE reads
+# reads for RF9000-class fridges -- this binds to /status/kimchi/<slot>/
-# for RF9000-class fridges. /status/kimchi/<slot>/vs/0's plain currentMode/
+# vs/0's plain, self-describing currentMode/supportMode instead.
-# supportMode fields are unpacked and self-describing, so that's what this
-# binds to instead.
 #
-# Write path is unconfirmed (no live write against a real unit) -- same
+# Write path is unconfirmed on real hardware; same "write the field back to
-# "write the same field back to the entity's own href" convention as
+# the entity's own href" convention as PANTRY_ZONE/BEVERAGE_ZONE.
-# PANTRY_ZONE/BEVERAGE_ZONE above, first real-world write is also the test.
 #
-# translations/en.json's kimchi_zone_mode state labels were translated
+# translations/en.json's kimchi_zone_mode labels were translated directly
-# directly from the reporter's own (Korean-language) SmartThings app
+# from the reporter's own Korean SmartThings app screenshots (not guessed),
-# screenshots, not guessed from the codes or from their English paraphrase.
+# and cross-checked against supportMode order to confirm the on-screen
-# Cross-checking the screenshots against supportMode confirms the on-screen
+# option order matches the array order throughout -- so COLD/WARM
-# option order matches the array order everywhere it's verifiable: the top
+# consistently means Strong/Weak everywhere that suffix appears.
-# compartment's freezer triplet (표준/강냉/약냉 = Standard/Strong/Weak, at
-# -19/-21/-17°C) lines up 1:1 with STORAGE_FREEZER_NORMAL/COLD/WARM, and the
-# middle/bottom compartments' full 8-entry kimchi-storage list, 2-entry
-# ripening list, and 4-entry custom-storage list each line up 1:1 with their
-# supportMode order too -- so COLD/WARM consistently means Strong/Weak (a
-# colder or warmer preset around the NORMAL setpoint) everywhere that suffix
-# appears, including on STORAGE_FRIDGE_* and the low-salt kimchi variants,
-# which weren't directly screenshotted but share the same NORMAL/COLD/WARM
-# vocabulary as the two confirmed triplets. CRUNFCH (아삭, "crisp/crunchy")
-# and BUY (구입, "purchased") are also confirmed exact matches, not
-# abbreviation guesses.
-# ---------------------------------------------------------------------------
 
 
 def _kimchi_mode_write(p, rep, href=None):
@@ -896,9 +966,8 @@ KIMCHI_ZONE = Capability(
             icon="mdi:timer-sand",
             translation_key="kimchi_ripening_remaining",
             entity_category="diagnostic",
-            # No dump has this nonzero (ripeStatus is always "Off" so
+            # No dump has this nonzero (ripeStatus is always "Off" so far)
-            # far) -- device-reported unit unconfirmed, so this stays
+            # -- unit unconfirmed, so this stays a bare number.
-            # a bare number rather than asserting minutes or hours.
             value_fn=_int,
         ),
         SensorDesc(
@@ -921,12 +990,11 @@ KIMCHI_DOOR_GENERIC = Capability(
     poll_tier="hot",
     entities=(
         # Not deduped against DOORS_FALLBACK below: on the one reporter
-        # (refrigerator_tp2x_ref_20k_kimchi) this binds alongside, the
+        # this binds alongside, /doors/vs/0's aggregate carries a single
-        # /doors/vs/0 aggregate carries a single generic item (id "4", no
+        # generic item (id "4", no /door/<instance> siblings) that doesn't
-        # /door/<instance> siblings for DOORS_FALLBACK's match_fn to see)
+        # share this compartment's "top" numbering -- a distinct
-        # that doesn't share this compartment's "top" instance numbering --
+        # main-cabinet door, not this drawer's contact switch reported
-        # a distinct main-cabinet door, not this kimchi drawer's own contact
+        # twice.
-        # switch reported twice.
         BinarySensorDesc(
             key="open",
             rep_fn=_door_open_state,
@@ -937,19 +1005,12 @@ KIMCHI_DOOR_GENERIC = Capability(
     ),
 )
 
-# ---------------------------------------------------------------------------
+# Aggregate-resource fallbacks: /doors/vs/0, /temperatures/vs/0, and
-# Aggregate-resource fallbacks
+# /icemaker/status/vs/0 each duplicate information the per-instance hrefs
-#
+# above expose more precisely, on hardware that has them -- not every
-# /doors/vs/0, /temperatures/vs/0, and /icemaker/status/vs/0 each duplicate
+# fridge does. Each fallback's match_fn checks for the richer sibling
-# information exposed more precisely by per-instance hrefs (DOOR_GENERIC,
+# hrefs and only binds when they're absent, so it's a no-op wherever the
-# TEMP_CURRENT_GENERIC/TEMP_SETPOINT_GENERIC, ICEMAKER_GENERIC) on hardware
+# richer hrefs exist and a real (coarser) source where they don't.
-# that has them. Not every fridge does — a simpler model may only ever
-# advertise the aggregate resource. Each fallback's match_fn checks the
-# full resource set for the richer sibling hrefs and only binds when
-# they're absent, so it's a no-op (not a gap — see discovery.py) wherever
-# the richer hrefs exist, and a real (if coarser) source of the same data
-# where they don't.
-# ---------------------------------------------------------------------------
 
 
 def _any_door_generic(resources):
@@ -1045,23 +1106,19 @@ ICEMAKER_STATUS_FALLBACK = Capability(
     ),
 )
 
-# OCF-native aggregate mirror of ICEMAKER_STATUS_FALLBACK.  On the captured
+# OCF-native aggregate mirror of ICEMAKER_STATUS_FALLBACK. On the captured
-# TP1X_REF_21K it duplicates both the vendor aggregate and the richer per-unit
+# TP1X_REF_21K it duplicates both the vendor aggregate and the richer
-# /icemaker/one|two/vs/0 resources.  Its write contract is not advertised, so
+# per-unit hrefs; its write contract isn't advertised, so bind it as a
-# keep the proven per-unit/vendor controls and bind this as a duplicate only.
+# duplicate only.
 ICEMAKER_STATUS_NATIVE_DUPLICATE = Capability(
     href="/icemaker/status/0",
 )
 
-# OCF-native /refrigeration/0 (issue #7's unbound_hrefs) -- the odd one out
+# OCF-native /refrigeration/0 (issue #7): its three fields duplicate two
-# in this section: its three fields duplicate two *different* richer
+# different richer hrefs (REFRIGERATION's rapidFridge/rapidFreezing,
-# hrefs (REFRIGERATION's rapidFridge/rapidFreezing and
+# DEFROST_BLOCK_STATUS's defrost_active), each absent independently, so
-# DEFROST_BLOCK_STATUS's defrost_active), each absent independently, so a
+# gating is per-entity (exists_fn) rather than one capability-level
-# single capability-level match_fn can't express it. Gated per-entity
+# match_fn. No write path confirmed, so these stay read-only.
-# (exists_fn) instead: rapid_fridge/rapid_freezing back off only when
-# REFRIGERATION's href is present; defrost_active only when
-# DEFROST_BLOCK_STATUS's is. No write path confirmed for this href, so
-# these are read-only, unlike REFRIGERATION's switches.
 REFRIGERATION_FALLBACK = Capability(
     href="/refrigeration/0",
     poll_tier="warm",
@@ -1078,7 +1135,7 @@ REFRIGERATION_FALLBACK = Capability(
             key="rapid_fridge",
             field="rapidCool",
             icon="mdi:fridge-industrial",
-            entity_category="config",
+            entity_category="diagnostic",
             value_fn=lambda v: bool(v),
             exists_fn=lambda rep, resources: "/refrigeration/vs/0" not in resources,
         ),
@@ -1086,7 +1143,7 @@ REFRIGERATION_FALLBACK = Capability(
             key="rapid_freezing",
             field="rapidFreeze",
             icon="mdi:snowflake",
-            entity_category="config",
+            entity_category="diagnostic",
             value_fn=lambda v: bool(v),
             exists_fn=lambda rep, resources: "/refrigeration/vs/0" not in resources,
         ),

custom_components/localthings/registry/capabilities/ignored.py

@@ -19,9 +19,9 @@ here would silently do nothing on that path. Enumerate each known href
 instead; it's a short, stable list.
 
 This list is maintainer-curated only; there is no per-installation
-override. Grow it as real /device/0 dumps surface more universal noise —
+override. Grow it as real /device/0 dumps surface more universal noise --
-do not add a href here on a guess. If a href's relevance is unclear, leave
+never on a guess. If a href's relevance is unclear, leave it unbound so it
-it unbound so it surfaces as a gap for a human to look at.
+surfaces as a gap for a human to look at.
 """
 
 from ..capability import Capability
@@ -61,12 +61,9 @@ IGNORED: list[Capability] = [
     # Redundant with capabilities already declared elsewhere.
     # /speakersound/vs/0 duplicates /settings/sound/volume/vs/0 (laundry.SOUND_VOLUME).
     Capability(href="/speakersound/vs/0"),
-    # /wm/editcourse/vs/0 has no entities of its own -- x.com.samsung.da.
+    # No entities of its own -- editCourseList is read directly out of the
-    # editCourseList is read directly out of the resource snapshot by
+    # resource snapshot by dishwasher.CYCLE_OPTIONS/washer.WASHER_COURSE's
-    # dishwasher.CYCLE_OPTIONS's and washer.WASHER_COURSE's cycle select
+    # cycle selects to build the device's supported course list.
-    # (options=_cycle_options) to build that device's actual supported
-    # course list, rather than exposing this href's raw byte string
-    # through its own entity.
     Capability(href="/wm/editcourse/vs/0"),
     # Bixby audio feedback (chime + volume played when Bixby starts/stops
     # listening) — only meaningful with Bixby enabled, which this
@@ -96,17 +93,13 @@ IGNORED: list[Capability] = [
     # Temperature-unit display preference, redundant with HA's own units.
     Capability(href="/wm/submode/vs/0"),
     # Read-only re-encoding of the course already exposed by
-    # washer.WASHER_COURSE at /course/vs/0 (x.com.samsung.da.st.washerMode
+    # washer.WASHER_COURSE at /course/vs/0 (same hex code, just prefixed
-    # is literally "Table_02_Course_<same hex code>").
+    # "Table_02_Course_").
     Capability(href="/st/washercourse/vs/0"),
-    # Dryer counterpart of the above: re-encoding of the course already
+    # Dryer counterpart: re-encodes dryer.DRYER_COURSE's /course/vs/0.
-    # exposed by dryer.DRYER_COURSE at /course/vs/0
-    # (x.com.samsung.da.st.dryerMode is "Table_03_Course_<same hex code>").
     Capability(href="/st/dryercourse/vs/0"),
-    # AirDresser counterpart of the above (issue #157): read only for its
+    # AirDresser counterpart (issue #157): read only for its courseTable id
-    # courseTable id (air_dresser.AIR_DRESSER_COURSE's table_href), no
+    # (air_dresser.AIR_DRESSER_COURSE's table_href), no entity of its own.
-    # entity of its own -- same "no entity, just the table id" role as
-    # /st/washercourse/vs/0 and /st/dryercourse/vs/0.
     Capability(href="/st/airdressercourse/vs/0"),
     # Empty on every washer dump seen so far.
     Capability(href="/wm/welcomemsg/vs/0"),
@@ -114,29 +107,21 @@ IGNORED: list[Capability] = [
     # state without a multi-slot editor; revisit if that becomes valuable.
     Capability(href="/wm/personalcourse/vs/0"),
     # OCF-native energy resource is empty ({}) on washer hardware seen so
-    # far, unlike /power/0, /kidslock/0, /remotectrl/0 which do carry real
+    # far -- common.ENERGY_METER on /energy/consumption/vs/0 is the only
-    # data -- common.ENERGY_METER on /energy/consumption/vs/0 is the only
+    # real source.
-    # real source for this control.
     Capability(href="/energy/consumption/0"),
     # Empty ({}) on every washer dump seen so far -- nothing to expose.
     Capability(href="/cycleinterface/vs/0"),
     # OCF-native duplicate of /drlc/vs/0 above -- same utility-program
     # dependency this integration doesn't support locally.
     Capability(href="/drlc/0"),
-    # OCF-native duplicate of /operational/state/vs/0, which is already
+    # OCF-native duplicate of /operational/state/vs/0, already modeled by
-    # modeled by operational.OPERATIONAL_STATE (a richer, write-capable
+    # operational.OPERATIONAL_STATE (richer, write-capable, used by washer,
-    # capability with start/pause/stop buttons and a delay-start control)
+    # dishwasher, dryer, oven). This generic href is read-only overlapping
-    # used by washer, dishwasher, dryer, and oven. This generic href only
+    # data with no verified write contract worth building around.
-    # carries read-only overlapping data (current job state, remaining
-    # time, progress percentage) with no write path -- not worth building a
-    # parallel write-capable capability around an unverified generic OCF
-    # write contract.
     Capability(href="/operational/state/0"),
-    # Cooktop guided-cooking/recipe status (issue #86, TP1X_DA-KS-COOKTOP
+    # Cooktop guided-cooking/recipe status (issue #86): every field
-    # family): sequenceNumber, operationBurnerNumber, a stageInfo block, and
+    # empty/zero on the only dump seen (device idle). Same "don't guess"
-    # a textData.menu string -- every field empty/zero on the only dump
+    # treatment as the microwave family's /recipe/cook/vs/0.
-    # seen so far (device idle, no guided-cooking program active). Same
-    # "don't guess" treatment as the microwave family's /recipe/cook/vs/0.
-    # Revisit if a dump with an active recipe surfaces.
     Capability(href="/cooktop/recipe/status/vs/0"),
 ]

custom_components/localthings/registry/capabilities/laundry.py

@@ -23,9 +23,11 @@ Door-LED keys use NO `x.com.samsung.da.` prefix -- `setBrightness` /
 from datetime import UTC, datetime
 from datetime import time as dt_time
 
+from ... import cloudcourse
 from ...catalog import has_entity_translation
 from ..capability import Capability
 from ..entities import NumberDesc, SelectDesc, SensorDesc, SwitchDesc, TimeDesc
+from .common import hex_pairs, option_value
 
 _LED_LEVELS = ("Low", "High")
 _SOUND_MODES = ("voice", "tone", "mute")
@@ -178,38 +180,24 @@ BUZZER_SOUND = Capability(
     ),
 )
 
-# ---------------------------------------------------------------------------
 # Cycle selection over /course/vs/0.
 #
 # The selected course and every other user-tunable option ride in the
-# x.com.samsung.da.options array on /course/vs/0 as `<Prefix>_<value>` tokens.
+# x.com.samsung.da.options array as `<Prefix>_<value>` tokens. Confirmed on
-# Confirmed on real hardware (issue #54): a write only needs to carry the one
+# real hardware (issue #54): a write only needs to carry the one changed
-# changed token -- `{'x.com.samsung.da.options': ['SoftenerLevelCtrl_2']}` --
+# token -- the device matches by prefix, evicts the stale token, and merges
-# the device matches by prefix, evicts the stale token, and merges the result
+# the result itself (see option_write). The set of selectable courses is
-# into the array itself. No read-modify-write of the whole array needed (see
+# read live from editCourseList on /wm/editcourse/vs/0 (cycle_options), not
-# option_write). The set of *selectable* courses is not hardcoded -- it's read
+# hardcoded. Course codes are uppercase hex; display names live in
-# live from
+# translations under entity.select.<translation_key>.state.<id lowercased>.
-# x.com.samsung.da.editCourseList on /wm/editcourse/vs/0 (cycle_options), so we
-# never show a course a given model doesn't have or hide one it does. Course
-# codes are uppercase hex; display names live in translations under
-# entity.select.<translation_key>.state.<id lowercased> so they can be
-# localized -- every device-enum select in this integration works this way.
-# washer.py's course comment has the byte-level evidence for why the options[]
-# MostUsed_* entry is *not* a trustworthy second source.
 #
 # Some boards populate /wm/editcourse/vs/0 without ever filling in
-# editCourseList itself (issue #1) -- cycle_options() falls back to deriving
+# editCourseList itself (issue #1) -- cycle_options() falls back to
-# the same list from /course/vs/0's own supportedOptions in that case; see
+# deriving the list from /course/vs/0's own supportedOptions in that case;
-# _course_codes_from_supported_options for the byte-level evidence.
+# see _course_codes_from_supported_options.
 #
-# Shared verbatim by washer, dishwasher, and dryer -- all DA_WM_-family boards
+# Shared verbatim by washer, dishwasher, and dryer -- all DA_WM_-family
-# expose the same /course/vs/0 options contract.
+# boards expose the same /course/vs/0 options contract.
-# ---------------------------------------------------------------------------
-
-
-def hex_pairs(codes):
-    """'1C1D21...' -> ['1C', '1D', '21', ...]."""
-    return [codes[i : i + 2] for i in range(0, len(codes) - 1, 2)]
 
 
 def parse_edit_course_list(raw):
@@ -227,23 +215,13 @@ def cycle_options(resources):
     return _course_codes_from_supported_options(resources.get("/course/vs/0") or {})
 
 
-def option_value(options, prefix):
-    """Find `<prefix>_<value>` in the options array and return <value>."""
-    for o in options or []:
-        if isinstance(o, str) and o.startswith(prefix + "_"):
-            return o.split("_", 1)[1]
-    return None
-
-
 # Drum Clean+ maintenance tracking, from the same options[] array as the
 # selected course -- shared by washer.py (issue #9) and dryer.py (issue
-# #258); both families use identical DrumCleanProposal_/WashingTimes_/
+# #258), identical DrumCleanProposal_/WashingTimes_/DrumCleanLog_ tokens.
-# DrumCleanLog_ tokens. DrumCleanProposal_<N> is the wash/dry-cycle interval
+# DrumCleanProposal_<N> is the cycle interval between recommended cleans;
-# between recommended cleans; WashingTimes_<N> is the count since the last
+# WashingTimes_<N> is the count since the last one -- their difference is
-# one -- their difference is exactly the "N cycles until due" figure the
+# the "N cycles until due" figure the app shows (verified: 40 - 3 == 37,
-# Samsung app shows (verified on a washer: DrumCleanProposal_40 -
+# matching a live app screenshot).
-# WashingTimes_3 == 37, matching a live app screenshot's "Potreba cistenia
-# po 37 cykloch").
 def drum_clean_cycles_remaining(rep):
     opts = rep.get("x.com.samsung.da.options") or []
     proposal = option_value(opts, "DrumCleanProposal")
@@ -257,14 +235,10 @@ def drum_clean_cycles_remaining(rep):
 
 
 # DrumCleanLog_ is the clean-history field: a washer reports one bare ISO
-# datetime (the last clean, verified against the same app screenshot's "10
+# datetime (the last clean); a dryer (issue #258) instead reports a
-# days ago"); a dryer (issue #258's Dillton-reported dump) instead reports a
+# '|'-joined history of every past clean in increasing order. Splitting on
-# '|'-joined history of every past clean, ten deep on that dump, in
+# '|' and taking the last element handles both shapes identically. No
-# strictly increasing order. Splitting on '|' and taking the last element
+# timezone accompanies either shape, so it's treated as UTC.
-# handles both shapes identically -- a no-'|' value is unaffected. No
-# explicit timezone field accompanies either shape, so it's treated as UTC,
-# matching this integration's convention for other bare ISO datetime fields
-# (see fridge.py's night-light schedule comment).
 def drum_clean_last_cleaned(rep):
     raw = option_value(rep.get("x.com.samsung.da.options"), "DrumCleanLog")
     if not raw:
@@ -278,41 +252,27 @@ def drum_clean_last_cleaned(rep):
 
 def _course_codes_from_supported_options(course_rep):
     """Fallback for an empty/missing editCourseList: derive the selectable
-    course list from /course/vs/0's own x.com.samsung.da.supportedOptions
+    course list from /course/vs/0's own supportedOptions instead (issue #1:
-    instead (issue #1: some DA_WM_TP1/TP2-class boards populate the
+    some boards populate /wm/editcourse/vs/0 but never fill in
-    /wm/editcourse/vs/0 href but never fill in editCourseList itself).
+    editCourseList itself).
 
     supportedOptions is a 1-hex-nibble header followed by one fixed-width
     record per selectable course, self-indexed rather than positional --
-    the first byte of every record is that course's own hex code, just in
+    the first byte of every record is that course's own hex code.
-    the firmware's own internal order, not editCourseList's. Confirmed
+    Confirmed against six independent real-world dumps: every one divides
-    against six independent real-world washer/dryer/dishwasher dumps: every
+    evenly into `header + N * K bytes` with fully unique first bytes across
-    one divides evenly into `header + N * K bytes` with fully unique first
+    all N records, at the record's true byte width.
-    bytes across all N records, at the record's true byte width. (What the
-    rest of each record encodes is still unconfirmed -- this only uses the
-    course-code byte.)
 
-    Two guards, deliberately conservative rather than guessing further: the
+    Two conservative guards rather than guessing further: the derived codes
-    derived codes must (a) all be distinct -- a real course table, not
+    must all be distinct, and must include whatever course is currently
-    noise -- and (b) include whatever course is currently selected
+    selected. If no split satisfies both, this returns [].
-    (x.com.samsung.da.options' Course_<code> token), which must always be a
-    member of its own device's valid list. If no split satisfies both, this
-    returns [] rather than guess.
 
-    Among splits that satisfy both, the *smallest* passing K wins, rather
+    Among splits that satisfy both, the smallest passing K wins -- more
-    than requiring a single unambiguous one -- more than one K reliably
+    than one K reliably passes on real data, and smallest-K-wins matches
-    does pass on real data (e.g. the shipped dishwasher fixture: true
+    the confirmed answer on all six dumps checked, though it's a heuristic
-    K=7 passes, but so do 10, 14, and 35, none of which are multiples of
+    rather than a proof. Not guarded further: course tables are typically
-    7 -- position 0 always lands on the same real course code regardless
+    large enough that colliding by chance on both checks is unlikely, and
-    of K, which is enough on its own to satisfy the current-course guard
+    no device seen so far needs it.
-    for several unrelated splits). Smallest-K-wins is a heuristic, not a
-    proof: it matches the confirmed answer on every one of six independent
-    real-world dumps this was checked against, but a coincidentally
-    unique, current-course-inclusive *smaller* K is not mathematically
-    impossible on some future device, and would be picked silently. Not
-    guarded against further here, since course tables are typically large
-    enough (double digits) that colliding by chance on both checks is
-    unlikely, and no device seen so far actually needs it.
     """
     raw = course_rep.get("x.com.samsung.da.supportedOptions")
     hexstr = raw[0] if isinstance(raw, list) and raw else raw
@@ -338,57 +298,205 @@ def _course_codes_from_supported_options(course_rep):
     return []
 
 
+def option_tokens(*pairs):
+    """[(prefix, value), ...] -> ['<prefix>_<value>', ...] -- the general
+    form of option_write, for the one write that needs two tokens to land in
+    the same options[] array together (see cycle_write's cloud branch)."""
+    return [f"{prefix}_{value}" for prefix, value in pairs]
+
+
 def option_write(prefix, new_value):
     """A one-token x.com.samsung.da.options write -- see the module comment
-    above cycle_options for why this doesn't read/rewrite the whole array."""
+    above for why this doesn't read/rewrite the whole array."""
-    return [f"{prefix}_{new_value}"]
+    return option_tokens((prefix, new_value))
+
+
+# ---------------------------------------------------------------------------
+# Cloud "Download" programs, folded into this same cycle select (issue #342).
+#
+# A device that has downloaded programs advertises them on the same
+# /course/vs/0 options array; cloudcourse.py owns the token shapes, the
+# learned store, and the reasoning for all of it. Everything below is just
+# how that store reaches the select: the coordinator merges it onto this
+# href's rep under cloudcourse.FIELD, so the option list, current value,
+# label, and write path each read it from the rep or snapshot they already
+# receive.
+#
+# They ride in the cycle select rather than a select of their own because
+# that is what they are to a user -- on the appliance's own controls,
+# "Download" occupies one position among the ordinary courses, and picking a
+# downloaded program is picking a cycle. Their raw values are namespaced
+# ('cloud:<slot>') so they can never be confused with, or collide with, a
+# two-hex-char local course code.
+#
+# Bound by whichever families declare it. Washers are where this was worked
+# out, but a DW5000C dishwasher advertises the same token (see
+# cloudcourse.py), so nothing below is washer-specific.
+#
+# Confirmed on hardware before any of this was written (issue #342): writing
+# the program token alone, while some other course is selected, is silently
+# ignored -- the course token has to switch to Download in the *same* write.
+# Hence the two-token write, the only one in this module.
+
+
+def _cloud_state(rep):
+    return rep.get(cloudcourse.FIELD) or {}
+
+
+def cloud_options(rep):
+    """Namespaced raw values for every named, learned cloud program."""
+    return [
+        f"{cloudcourse.RAW_PREFIX}{slot}" for slot in sorted(_cloud_state(rep).get("programs", {}))
+    ]
+
+
+def cloud_label(value, resources):
+    """The user's own name for a 'cloud:<slot>' value.
+
+    Cloud program names are user-supplied, never translated: the appliance
+    reports only an opaque slot id, and inventing an English label for one
+    is exactly what this module refuses to do for unrecognized local course
+    codes (see washer_cycle_fallback).
+    """
+    if not isinstance(value, str) or not value.startswith(cloudcourse.RAW_PREFIX):
+        return None
+    slot = value[len(cloudcourse.RAW_PREFIX) :]
+    rep = resources.get(cloudcourse.COURSE_HREF) or {}
+    program = _cloud_state(rep).get("programs", {}).get(slot)
+    return program["name"] if program else None
+
+
+def cloud_current(rep):
+    """'cloud:<slot>' when a named cloud program is the live selection.
+
+    Gated on the course actually being this device's confirmed Download
+    course: tokens in this array are replaced by prefix and never evicted, so
+    a one-time program token outlives the run it belonged to and would
+    otherwise report "Jeans" while an ordinary cotton cycle runs.
+    """
+    state = _cloud_state(rep)
+    download = state.get("download_course")
+    options = rep.get("x.com.samsung.da.options")
+    if not download or option_value(options, "Course") != download:
+        return None
+    blob = option_value(options, cloudcourse.ONESHOT_PREFIX)
+    slot = cloudcourse.slot_of(blob)
+    if slot is None:
+        # No one-time override loaded: the appliance falls back to whatever
+        # the persisted default holds (confirmed with the issue #342
+        # reporter -- leaving Download and returning to it re-selects the
+        # saved program, not the last one-time one).
+        slot = cloudcourse.slot_of(option_value(options, cloudcourse.DEFAULT_PREFIX))
+    if slot is None or slot not in state.get("programs", {}):
+        return None
+    return f"{cloudcourse.RAW_PREFIX}{slot}"
 
 
 def cycle_write(p, rep, href=None):
     if not rep.get("x.com.samsung.da.options"):
         return None
+    if isinstance(p, str) and p.startswith(cloudcourse.RAW_PREFIX):
+        return _cloud_cycle_write(p, rep)
     return ["course", "vs", "0"], {
         "x.com.samsung.da.options": option_write("Course", p),
     }
 
 
+def _cloud_cycle_write(p, rep):
+    state = _cloud_state(rep)
+    download = state.get("download_course")
+    program = state.get("programs", {}).get(p[len(cloudcourse.RAW_PREFIX) :])
+    if not download or program is None:
+        return None
+    # Order matches what the appliance was confirmed to accept.
+    return ["course", "vs", "0"], {
+        "x.com.samsung.da.options": option_tokens(
+            ("Course", download), (cloudcourse.ONESHOT_PREFIX, program["blob"])
+        ),
+    }
+
+
+def personal_course_labels(resources, href="/wm/personalcourse/vs/0"):
+    """Return device-provided personal course names keyed by course code.
+
+    Populated entries use a small TLV payload. The leading field is
+    ``01 <UTF-8-byte-length> <name>``; later fields contain a description and
+    settings and are intentionally left uninterpreted. Empty slots are
+    encoded as ``<code>_00``. Malformed or undecodable entries are ignored so
+    opaque device data can never become a misleading label.
+    """
+    rep = resources.get(href) or {}
+    labels = {}
+    for entry in rep.get("x.com.samsung.da.courses") or []:
+        if not isinstance(entry, str) or "_" not in entry:
+            continue
+        code, encoded = entry.split("_", 1)
+        try:
+            payload = bytes.fromhex(encoded)
+        except ValueError:
+            continue
+        if len(payload) < 3 or payload[0] != 0x01:
+            continue
+        name_length = payload[1]
+        if name_length == 0 or len(payload) < 2 + name_length:
+            continue
+        try:
+            name = payload[2 : 2 + name_length].decode("utf-8")
+        except UnicodeDecodeError:
+            continue
+        if name.strip() and name.isprintable():
+            labels[code.upper()] = name
+    return labels
+
+
+def washer_cycle_fallback(value, resources):
+    """Label a personal washer course from its device-provided name.
+
+    No fallback for an unrecognized standard code -- an invented English
+    label would defeat translation (PR #251 review); the raw code displays
+    instead, same as before this function existed.
+    """
+    if not isinstance(value, str):
+        return None
+    return personal_course_labels(resources).get(value.upper())
+
+
 def _table_id(resources, table_href):
     rep = resources.get(table_href) or {}
     return rep.get("x.com.samsung.da.st.courseTable")
 
 
-def cycle_select(*, translation_key, icon, table_href=None):
+def cycle_select(*, translation_key, icon, table_href=None, display_fn=None):
     """A 'Cycle' select over /course/vs/0, labelled from `translation_key`.
 
-    The option list, current value, and write path are all shared across
+    The option list, current value, and write path are shared across
-    washer/dryer/dishwasher; only the translation is family- (and, for
+    washer/dryer/dishwasher; only the translation is family/board-specific.
-    washer/dryer, board-) specific.
 
-    table_href (washer/dryer only -- see washer.py/dryer.py's call sites)
+    table_href (washer/dryer only) suffixes translation_key with the
-    suffixes translation_key with the device's own course-table id, read
+    device's own course-table id, read from /st/washercourse/vs/0 or
-    from /st/washercourse/vs/0 or /st/dryercourse/vs/0's
+    /st/dryercourse/vs/0's courseTable (e.g. 'washer_cycle' + 'Table_02' ->
-    x.com.samsung.da.st.courseTable (e.g. 'washer_cycle' + 'Table_02' ->
+    'washer_cycle_table_02'). This matters because course codes are NOT
-    'washer_cycle_table_02'). An absent or unrecognized table id gets the
+    guaranteed consistent across board generations sharing the same
-    name-only ``cycle`` translation key while the raw course code remains
+    /course/vs/0 contract: washer_cycle_table_02 was confirmed against
-    visible and writable.
+    Table_02 devices, but FlexWash's older board reports Table_00, where
+    the same hex code could mean a different course. An absent or
+    unrecognized table id falls back to the name-only ``cycle`` key
+    instead of borrowing a label from another board generation --
+    translating a new table is a translations-only change.
 
-    This matters because course codes are NOT guaranteed consistent across
+    The raw course code remains writable regardless; its display uses
-    board generations sharing the same /course/vs/0 contract: every code in
+    display_fn when supplied, otherwise it remains raw. display_fn is an
-    washer_cycle_table_02 was confirmed against Table_02-reporting devices
+    optional family-specific fallback for untranslated raw values --
-    (DA_WM_TP1/TP2 boards); FlexWash's older DA_WM_A51 board reports
+    select.py applies it after catalog lookup to both state and options.
-    Table_00 instead, so the same hex code could mean a different course
-    there for all we've verified. So a table-specific key is used only when
-    the shipped catalog actually has one; any other table (Table_00 today,
-    whatever ships next) falls back to the name-only ``cycle`` key, which
-    shows the raw course code rather than a label borrowed from another
-    board generation. Translating a new table is therefore a
-    translations-only change -- add the ``<family>_cycle_<table>`` entry and
-    this resolver picks it up.
 
     Left at its default for dishwasher, which has no equivalent table-id
-    resource in any dump seen and no evidence its course codes vary by
+    resource and no evidence its codes vary by table the way washer/
-    table the way washer/dryer's do -- there's nothing to build a
+    dryer's do.
-    table-specific key from.
+
+    Any cloud "Download" programs the user has discovered and named join the
+    same option list, after the local courses -- see the cloud section above.
+    A device with none (or one whose owner hasn't named any yet) gets exactly
+    the list it got before they existed.
     """
     key = translation_key
     if table_href is not None:
@@ -400,25 +508,40 @@ def cycle_select(*, translation_key, icon, table_href=None):
             candidate = f"{translation_key}_{table.lower()}"
             return candidate if has_entity_translation("select", candidate) else "cycle"
 
+    def options(resources):
+        rep = resources.get(cloudcourse.COURSE_HREF) or {}
+        # Local courses first: a user-supplied cloud name that happens to
+        # match a translated course name resolves back to the real local
+        # course on write, which is the safer of the two. The options flow
+        # rejects such a name outright, so this is a backstop, not the fix.
+        return [*cycle_options(resources), *cloud_options(rep)]
+
+    def current(rep):
+        return cloud_current(rep) or option_value(rep.get("x.com.samsung.da.options"), "Course")
+
+    def label(value, resources):
+        cloud = cloud_label(value, resources)
+        if cloud is not None:
+            return cloud
+        return display_fn(value, resources) if display_fn is not None else None
+
     return SelectDesc(
         key="cycle",
         icon=icon,
         translation_key=key,
-        options=cycle_options,
+        options=options,
-        exists_fn=lambda rep, resources: bool(cycle_options(resources)),
+        exists_fn=lambda rep, resources: bool(options(resources)),
-        rep_fn=lambda rep: option_value(rep.get("x.com.samsung.da.options"), "Course"),
+        rep_fn=current,
+        display_fn=label,
         write_fn=cycle_write,
     )
 
 
-# ---------------------------------------------------------------------------
 # Plain boolean toggles over /course/vs/0's options[] array: a
-# '<prefix>_On'/'<prefix>_Off' token, read-modify-written the same way as
+# '<prefix>_On'/'<prefix>_Off' token, merged the same way as the 'Course'
-# the 'Course' token above. Shared by washer (bubble soak, pre-wash,
+# token above. Shared by washer (bubble soak, pre-wash, intensive -- issue
-# intensive -- issue #22) and dishwasher (storm wash, auto release dry) --
+# #22) and dishwasher (storm wash, auto release dry), just with different
-# both families ride this exact contract, just with different prefixes and
+# prefixes and presence/validation needs on top.
-# different presence/validation needs on top.
-# ---------------------------------------------------------------------------
 
 
 def bool_option_write(prefix):
@@ -450,12 +573,11 @@ def bool_option_switch(
     """A SwitchDesc over a '<prefix>_On'/'<prefix>_Off' options[] token.
 
     gate_on_presence self-gates the entity off on models that never report
-    the token at all (washer's bubble soak/pre-wash/intensive); leave False
+    the token (washer's bubble soak/pre-wash/intensive); leave False for a
-    for a toggle every device in the family reports (dishwasher's storm
+    toggle every device in the family reports (dishwasher's storm wash).
-    wash). validate_fn is passed straight through to SwitchDesc for callers
+    validate_fn passes straight through to SwitchDesc for callers that need
-    that need to reject a write against live device state (e.g. washer's
+    to reject a write against live state -- this factory has no opinion on
-    per-course availability check) -- this factory has no opinion on it and
+    it.
-    building one, if needed, is the caller's job.
     """
     return SwitchDesc(
         key=key,
@@ -468,14 +590,11 @@ def bool_option_switch(
     )
 
 
-# ---------------------------------------------------------------------------
 # /wm/jobbeginingstatus/vs/0 -- the "why did the cycle not start" reason
-# (e.g. door open, no water). The vendor field is x.com.samsung.da.currentStatus
+# (e.g. door open, no water), x.com.samsung.da.currentStatus on every dump
-# on every laundry dump that populates it (washer + DA_WM_TP1 dryer). An
+# that populates it. An earlier dryer descriptor read
-# earlier dryer descriptor read x.com.samsung.da.jobBeginingStatus, but no dump
+# x.com.samsung.da.jobBeginingStatus instead, which no dump ever carried,
-# ever carried that field, so the dryer sensor was always blank -- fixed by
+# so the dryer sensor was always blank -- fixed by sharing this one reader.
-# sharing this one reader.
-# ---------------------------------------------------------------------------
 
 JOB_BEGINNING_STATUS = Capability(
     href="/wm/jobbeginingstatus/vs/0",

custom_components/localthings/registry/capabilities/microwave.py

@@ -8,33 +8,25 @@ oven.py in by_type/microwave.py rather than duplicated. What's genuinely
 different from an oven, and defined fresh here:
 
   * Cooking-mode vocabulary: MicroWave/MicroWaveGrill/MicroWaveConvection/
-    KeepWarm never appear on an oven's /mode/vs/0, and this family spells
+    KeepWarm never appear on an oven's /mode/vs/0, and some shared-sounding
-    some shared-sounding modes differently than oven.py's own constants
+    modes are spelled differently (e.g. 'AirFryer', not oven.py's
-    (e.g. 'AirFryer', not oven.py's 'AirFry') -- a distinct SelectDesc and
+    'AirFry') -- a distinct SelectDesc and mode list, not oven.OVEN_MODE.
-    mode list, not oven.OVEN_MODE.
   * Setpoint bounds: this family's Convection/MicroWaveConvection modeSpec
-    (issue #121's MW7300B dump) reports 40-200 C / step 5, not oven.py's
+    (issue #121) reports 40-200°C / step 5, not oven.py's 30-270°C range.
-    30-270 C range (verified against a different, bake-oven-class board).
+  * Cavity: /oven/vs/0 here also carries a `powerLevel` field (100W-900W)
-  * Cavity: /oven/vs/0 here also carries a `powerLevel` field (100W-900W
+    that plain ovens don't report -- exposed as its own sensor.
-    on the MicroWave mode's powerListData) that plain ovens don't report --
+  * Lamp: this family's option-array token is bare 'Lamp' (issue #137), not
-    exposed as its own sensor.
+    oven.py's 'UpperLamp', and genuinely absent on the combi dump (issue
-  * Lamp: this family's option-array token is bare 'Lamp' (issue #137's
+    #121), so it's exists_fn-gated rather than assumed universal. 'On' has
-    'Lamp_Off'), not oven.py's 'UpperLamp' -- and it's genuinely absent on
+    never been observed as a value; the only confirmed non-Off token is
-    the combi dump (issue #121), so it's gated with exists_fn rather than
+    'High' (issue #152) -- the switch treats any non-Off/non-None value as
-    assumed universal like oven.py's lamp switch. Issue #137's dump only
+    "on" for reads and writes back 'High'/'Off'.
-    ever showed 'Off', so 'On' was a guess at the paired value; issue #152's
-    ME7500D dump is the first to show a real non-Off value, and it's 'High'
-    (a brightness level, not literally 'On') -- the switch now treats any
-    non-Off/non-None value as "on" for reads, and writes back 'High'/'Off'
-    (the two confirmed tokens) rather than the never-confirmed 'On'.
   * Filter reminder / end signal reminder: bare 'FilterRemind'/'RemindBeep'
-    option-array tokens (issue #181), both with On and Off observed live
+    option-array tokens (issue #181), gated with exists_fn like Lamp since
-    (issue #152's ME7500D fixtures) -- gated with exists_fn like Lamp since
     the MW7300B combi dump has neither.
 
-Note: cooking-mode writes are unproven here, same caveat as oven.py's
+Cooking-mode writes are unproven here, same caveat as oven.py's OVEN_MODE
-OVEN_MODE -- exposed as a SelectDesc for fidelity, first real-world write
+-- exposed as a SelectDesc for fidelity, first real-world write is the test.
-is also the test.
 """
 
 from ..capability import Capability
@@ -46,13 +38,10 @@ from .laundry import option_value, option_write
 # Constants
 # ---------------------------------------------------------------------------
 
-# Union of every mode seen across the two known dumps: issue #121's combi
+# Union of every mode seen across the two known dumps (issues #121, #137).
-# MW7300B (NoOperation/Autocook/AutocookCustom/Convection/AirFryer/Grill/
+# No dump has shown every mode below on one device -- the select surfaces
-# MicroWave/MicroWaveGrill/MicroWaveConvection/Deodorization) and issue #137's
+# whatever a given board's own supportedModes reports; an entry here a
-# plain ME7500D (NoOperation/MicroWave/Autocook/KeepWarm). No dump has shown
+# device never sends just never gets picked.
-# every mode below on one device -- the select surfaces whatever a given
-# board's own /mode/vs/0 supportedModes reports; an entry here that a device
-# never sends just never gets picked.
 _MICROWAVE_MODES = (
     "NoOperation",
     "MicroWave",
@@ -67,22 +56,18 @@ _MICROWAVE_MODES = (
     "KeepWarm",
 )
 
-# Convection/MicroWaveConvection modeSpec on issue #121's dump: tempMinC 40,
+# Convection/MicroWaveConvection modeSpec on issue #121's dump: 40-200°C,
-# tempMaxC 200, tempIntervalC 5. No Fahrenheit dump exists for this family;
+# step 5. No Fahrenheit dump exists for this family, unlike oven.py's own
-# unlike oven.py's own SETPOINT_MIN_F/MAX_F/STEP_F (independently verified
+# independently-verified F bounds, so this module only exposes the
-# against issue #44's range dump), there's nothing to verify a microwave's
+# setpoint control when the live unit is Celsius (see _microwave_temp_unit).
-# Fahrenheit bounds against, so this module only exposes the setpoint
-# control when the live unit is Celsius (see _microwave_temp_unit below).
 SETPOINT_MIN_C = 40
 SETPOINT_MAX_C = 200
 SETPOINT_STEP_C = 5
 
 
 def _microwave_temp_unit(rep):
-    """Same shape as oven.py's _oven_temp_unit: /temperatures/vs/0 items[]
+    """Same shape as oven.py's _oven_temp_unit. Both known dumps report
-    carries a per-item x.com.samsung.da.unit field. Both known dumps for
+    'Celsius'; kept live rather than hardcoded (issue #7)."""
-    this family report 'Celsius'; kept live rather than hardcoded per the
-    fridge/oven convention (issue #7)."""
     items = rep.get("x.com.samsung.da.items") or []
     unit = items[0].get("x.com.samsung.da.unit") if items else None
     return normalize_temp_unit(unit, default="°C")
@@ -90,8 +75,7 @@ def _microwave_temp_unit(rep):
 
 def _setpoint_write(p, rep, href=None):
     """RMW write to /temperatures/vs/0 items array -- unproven for this
-    family (no live write confirmed against a real unit), same "exposed for
+    family, same "exposed for fidelity" caveat as the mode select."""
-    fidelity" caveat as the mode select."""
     try:
         temp = float(p)
     except (TypeError, ValueError):
@@ -118,12 +102,11 @@ def _power_level_watts(v):
 
 
 def _cooking_mode_options(resources):
-    """Live mode list from the device's own /mode/vs/0 supportedModes when
+    """Live mode list from the device's own supportedModes when reported
-    it reports one (both known dumps do); the union-of-all-dumps
+    (both known dumps do); the union-of-all-dumps _MICROWAVE_MODES guess
-    _MICROWAVE_MODES guess otherwise. Same live-first, static-fallback
+    otherwise. Same live-first, static-fallback pattern as
-    pattern as oven._oven_mode_options -- a fixed list here would offer
+    oven._oven_mode_options -- a fixed list would offer modes a unit
-    users modes their own unit doesn't have (issue #152's ME7500D reports
+    doesn't have (issue #152 reports only 4 of _MICROWAVE_MODES' 11)."""
-    only 4 of _MICROWAVE_MODES' 11)."""
     rep = resources.get("/mode/vs/0") or {}
     live = rep.get("x.com.samsung.da.supportedModes")
     return list(live) if live else list(_MICROWAVE_MODES)
@@ -163,9 +146,8 @@ def _lamp_write(p, rep, href=None):
         return None
     if not rep.get("x.com.samsung.da.options"):
         return None
-    # 'High' and 'Off' are the two tokens actually confirmed on live dumps
+    # 'High'/'Off' are the two confirmed tokens (see module docstring);
-    # (issues #137/#152) -- 'On' has never been observed and the device
+    # 'On' has never been observed and likely isn't recognized.
-    # likely doesn't recognize it (see module docstring).
     token = "High" if p == "On" else "Off"
     return ["mode", "vs", "0"], {
         "x.com.samsung.da.options": option_write("Lamp", token),
@@ -271,11 +253,9 @@ MICROWAVE_MODE = Capability(
             value_fn=lambda opts: option_value(opts, "Lamp") not in (None, "Off"),
             write_fn=_lamp_write,
         ),
-        # issue #181: Filter Reminder / End Signal Reminder toggles,
+        # issue #181: Filter Reminder / End Signal Reminder toggles, only on
-        # confirmed present (both On and Off observed across dumps -- see
+        # boards carrying the FilterRemind_*/RemindBeep_* tokens; gated off
-        # issue #152's ME7500D fixtures) but only on boards that carry the
+        # elsewhere (the MW7300B combi dump has neither).
-        # FilterRemind_*/RemindBeep_* tokens; gated off elsewhere (e.g. the
-        # MW7300B combi dump has neither) rather than assumed universal.
         SwitchDesc(
             key="filter_remind",
             field="x.com.samsung.da.options",

custom_components/localthings/registry/capabilities/operational.py

@@ -6,6 +6,7 @@ Shared by dryer/dishwasher/oven/washer families.
 import math
 from datetime import UTC, datetime, timedelta
 
+from ...catalog import translated_states
 from ..capability import Capability
 from ..entities import BinarySensorDesc, ButtonDesc, NumberDesc, SensorDesc
 
@@ -25,7 +26,7 @@ def _to_ocf(v):
 
 
 def _progress(v):
-    return "Idle" if v in (None, "None") else v
+    return "idle" if v in (None, "None") else str(v).lower()
 
 
 def _int(v):
@@ -35,12 +36,48 @@ def _int(v):
         return None
 
 
+def _state_is_active(rep):
+    return _SAMSUNG_STATE_TO_OCF.get(rep.get("x.com.samsung.da.state")) == "active"
+
+
 def _is_active(rep):
     """Check if appliance is actively running and cycle is not finished."""
-    return (
+    return _state_is_active(rep) and rep.get("x.com.samsung.da.progress") != "Finish"
-        _SAMSUNG_STATE_TO_OCF.get(rep.get("x.com.samsung.da.state")) == "active"
+
-        and rep.get("x.com.samsung.da.progress") != "Finish"
+
-    )
+def _just_finished(rep):
+    """progress/progress_percentage's sticky_fn (issue #345, see sensor.py's
+    _apply_sticky): arms their grace window the moment `progress` reads
+    'Finish'.
+
+    Deliberately not also requiring `state == 'active'` in the same rep,
+    unlike _is_active above: #345 reports a washer whose `state` can
+    already read idle by the time `progress` is observed at 'Finish' --
+    the same-family dryer's firmware apparently keeps `state` at 'active'
+    longer, per the report -- so requiring both together risked the arm
+    condition never actually firing on the one device this fixes.
+    _apply_sticky's edge-triggering (only a fresh False->True transition
+    (re)arms) is what keeps a `progress` stuck at 'Finish' indefinitely
+    (the same class of quirk `_completion_minutes` below already works
+    around) from holding this open forever instead."""
+    return rep.get("x.com.samsung.da.progress") == "Finish"
+
+
+def _new_cycle_running(rep):
+    """progress/progress_percentage's sticky_bypass_fn: drop the #345 hold
+    early once a new cycle is genuinely running.
+
+    Gated on `state == 'active'`, unlike _just_finished's arm condition
+    above: issue #358's dryer resets `progress` to its course's first
+    stage ('Drying') in the same moment `state` goes idle, ~4s before
+    settling to 'None' -- confirmed by the reporter's machine_state
+    history, which flips to idle on the exact second progress reads
+    'Drying', in both captured cycles. A bypass keyed on the progress
+    code alone read that as a new cycle and republished it. Releasing
+    late costs nothing -- an unreleased hold still expires on its own --
+    so this side takes the stronger signal."""
+    v = rep.get("x.com.samsung.da.progress")
+    return _state_is_active(rep) and v is not None and v not in ("None", "Finish")
 
 
 def _remaining_seconds(raw):
@@ -75,7 +112,7 @@ def _delay_hours(v):
 def _format_delay(hours):
     total_minutes = round(max(float(hours), 0) * 60)
     h, m = divmod(total_minutes, 60)
-    return f"{h}:{m:02d}:00"
+    return f"{h:02d}:{m:02d}:00"
 
 
 def _delay_field(rep):
@@ -98,11 +135,9 @@ def _finish_time(rep):
     if not total_s:
         return None
     # Round to whole minutes -- remainingTime itself only has minute
-    # resolution, but datetime.now() always carries fresh seconds/
+    # resolution, but datetime.now()'s fresh seconds/microseconds would
-    # microseconds, so an unrounded result changes on nearly every poll
+    # otherwise change the result on nearly every poll, flooding the
-    # even when the device-reported remaining time hasn't. That floods
+    # recorder with values that look identical once the UI rounds them.
-    # the recorder history/logbook with values that look identical once
-    # the UI rounds them down for display.
     finish = datetime.now(UTC) + timedelta(seconds=total_s)
     return finish.replace(second=0, microsecond=0)
 
@@ -147,31 +182,38 @@ OPERATIONAL_STATE = Capability(
             translation_key="machine_state",
             value_fn=_to_ocf,
         ),
-        # cycle_active is a bool derived from machine_state; used by the
+        # cycle_active is a bool derived from machine_state, gated on
-        # adapter to gate oven writes (cycle_active_field='cycle_active').
+        # progress too since firmware keeps state='Run' after progress
-        # Harmless for non-oven appliances — just an extra bool in state.
+        # reaches 'Finish' (a stuck 'Running' indication otherwise). Named
-        # Samsung firmware keeps state='Run' after progress reaches 'Finish',
+        # 'Running' in the catalog, not 'Cycle active' -- this href is
-        # so we also gate on progress to avoid a stuck 'Running' indication.
+        # shared with oven, and 'cycle' is laundry-specific vocabulary.
-        # Named 'Running' in the catalog rather than 'Cycle active' -- this href (and the
-        # start/pause/stop buttons below) is shared across the dryer/
-        # dishwasher/oven/washer families, and 'cycle' is laundry-specific
-        # vocabulary that doesn't fit an oven's bake/roast/etc.
         BinarySensorDesc(
             key="cycle_active",
             device_class="running",
-            rep_fn=lambda rep: (
+            rep_fn=_is_active,
-                _SAMSUNG_STATE_TO_OCF.get(rep.get("x.com.samsung.da.state")) == "active"
-                and rep.get("x.com.samsung.da.progress") != "Finish"
-            ),
         ),
+        # sticky_* (issue #345): once progress reads 'Finish', keep
+        # showing Finish/100 for a grace window even after machine_state
+        # reverts, rather than falling to Idle/0 the instant it does --
+        # see sensor.py's _apply_sticky. rep_fn below is unchanged and
+        # stays the only definition of a live value -- the hold decides
+        # only *whether* to freeze. A second, ungated one here is what
+        # let issue #358's post-Finish tail reach the entity.
         SensorDesc(
             key="progress",
             icon="mdi:progress-wrench",
+            device_class="enum",
+            options=tuple(sorted(translated_states("sensor", "progress"))),
             rep_fn=lambda rep: (
-                "Idle"
+                "idle"
-                if _SAMSUNG_STATE_TO_OCF.get(rep.get("x.com.samsung.da.state")) != "active"
+                if not _state_is_active(rep)
                 else _progress(rep.get("x.com.samsung.da.progress"))
             ),
+            sticky_fn=_just_finished,
+            # The catalog key, not the device's 'Finish': rep_fn is normalized
+            # now, and a held value outside `options` is what HA rejects.
+            sticky_value_fn=lambda rep: "finish",
+            sticky_bypass_fn=_new_cycle_running,
         ),
         SensorDesc(
             key="progress_percentage",
@@ -179,13 +221,15 @@ OPERATIONAL_STATE = Capability(
             state_class="measurement",
             rep_fn=lambda rep: (
                 0
-                if _SAMSUNG_STATE_TO_OCF.get(rep.get("x.com.samsung.da.state")) != "active"
+                if not _state_is_active(rep)
                 else _int(rep.get("x.com.samsung.da.progressPercentage"))
             ),
+            sticky_fn=_just_finished,
+            sticky_value_fn=lambda rep: 100,
+            sticky_bypass_fn=_new_cycle_running,
         ),
-        # Only show finish time when machine is actively running. Samsung
+        # Only show finish time while actively running -- firmware leaves a
-        # firmware leaves a stale remainingTime after a cycle ends, and
+        # stale remainingTime after a cycle ends, frozen at '00:01:00'.
-        # freezes it at '00:01:00' when progress reaches 'Finish'.
         SensorDesc(
             key="finish_time", device_class="timestamp", hysteresis=True, rep_fn=_finish_time
         ),

custom_components/localthings/registry/capabilities/oven.py

@@ -1,26 +1,19 @@
 """Capabilities for the oven family (Samsung NV7000BS-class).
 
-Resources verified against the live device via DTLS-CoAP.
+Resources verified against the live device via DTLS-CoAP. See
-See `local-tools/comparisons/oven-tree.md` for the full field reference.
+`local-tools/comparisons/oven-tree.md` for the full field reference.
 
-Write surfaces this module exposes:
+Proven write: lamp, via /mode/vs/0 options RMW, works even with Remote
+Control off. Unproven (first HA use is also the test): sound/fastPreheat/
+naturalSteam (same RMW pattern), setpoint via /temperatures/vs/0 items RMW,
+cook time via /operational/state/vs/0's operationTime/remainingTime, mode
+select via /mode/vs/0.modes (mid-cook acceptance unknown), stop via
+state='Ready'.
 
-  proven:
+Cycle start is not implemented: local-OCF cycle start isn't reproducible on
-    * Lamp via /mode/vs/0 options RMW (probe_oven_lamp_toggle.py)
+this firmware. Mode writes are also unreliable -- the oven rolls them back
-      — works even with Remote Control off.
+once a cycle is active, so OVEN_MODE's SelectDesc is effectively read-only
-
+in practice.
-  unproven (first HA use is also the test):
-    * Sound, FastPreheat, NaturalSteam — same RMW pattern as lamp.
-    * Setpoint via /temperatures/vs/0 items RMW.
-    * Cook time via /operational/state/vs/0 operationTime/remainingTime.
-    * Mode select via /mode/vs/0 .modes — mid-cook acceptance unknown.
-    * Stop via /operational/state/vs/0 state='Ready'.
-
-Note: Cycle start is not implemented. Reverse-engineering shows local-OCF
-cycle start is not reproducible on this firmware (see project_oven_remote
-_start_open.md). Mode writes are also unreliable — the oven rolls them back
-once a cycle is active. OVEN_MODE is provided as a SelectDesc for fidelity
-but is effectively read-only in practice.
 """
 
 from datetime import UTC, datetime, timedelta
@@ -45,26 +38,18 @@ SETPOINT_MIN_C = 30
 SETPOINT_MAX_C = 270
 SETPOINT_STEP_C = 5
 
-# Verified against issue #44's range dump (NSI6DG9100SRAA, unit reported as
+# Verified against issue #44's range dump: Bake mode's modeSpec reports
-# "Fahrenheit" on /temperatures/vs/0): Bake mode's modeSpec on /mode/vs/0
+# tempMinF/tempMaxF/tempIntervalF = 175/550/5. Kept separate rather than
-# reports tempMinF/tempMaxF/tempIntervalF = 175/550/5. Kept as a separate
+# converted from the Celsius bounds above, which are themselves unverified.
-# constant set rather than converted from the Celsius bounds above, which
-# are themselves unverified (no live dump; see module docstring).
 SETPOINT_MIN_F = 175
 SETPOINT_MAX_F = 550
 SETPOINT_STEP_F = 5
 
-# Mode options seen on NV7000BS-class. No dump exists so this list is inferred
+# Mode options seen on NV7000BS-class. No dump exists so this list is
-# from Samsung documentation and firmware observations. The firmware will
+# inferred from Samsung documentation and firmware observations; the
-# reject unknown modes; missing entries here are a coverage gap, not a bug.
+# firmware rejects unknown modes, so a missing entry is a coverage gap, not
-#
+# a bug. Fallback only, used when a device's own /mode/vs/0 doesn't report
-# This is a fallback only, used when a device's own /mode/vs/0 doesn't report
+# supportedModes at all -- see _oven_mode_options/_oven_mode_write below.
-# x.com.samsung.da.supportedModes at all -- see _oven_mode_options/
-# _oven_mode_write below. issue #138's range dump (NE63A6511SS/AA) reports
-# ConvectionRoast/KeepWarm/BreadProof/AirFryer/Dehydrate/SelfClean/SteamClean
-# in its own supportedModes; those are read live rather than added here, per
-# the adding-device-support skill's preference for device-reported option
-# lists over hardcoded ones.
 _OVEN_MODES = (
     "NoOperation",
     "Bake",
@@ -138,22 +123,18 @@ def _option_value(options, prefix):
 
 
 def _has_option(prefix):
-    """exists_fn for an options-array switch: bind only when the device's own
+    """exists_fn for an options-array switch: bind only when the device's
-    options[] actually carries a `<prefix>_<value>` token.
+    own options[] actually carries a `<prefix>_<value>` token.
 
-    fast_preheat/natural_steam were shipped unconditionally (no exists_fn) as
+    fast_preheat/natural_steam were shipped unconditionally (no exists_fn)
-    an unverified guess (see module docstring) -- issue #183's dump (model
+    as an unverified guess -- issue #183's dump reports neither token in
-    NE6516A) reports neither `fastpreheat_*` nor `NaturalSteam_*` in its
+    its options[] at all, so both switches were phantom controls that
-    options[] at all, so both switches were phantom controls: always read as
+    "don't appear to do anything."
-    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
+    identical exists_fn: a stub /device/0 seed rep has no options[] at all,
-    /device/0 seed rep (not yet sub-polled) has no options[] at all, and
+    and without this a genuinely-present token would never get a first
-    without this an entity whose token is genuinely present would never get
+    chance to bind.
-    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
@@ -163,13 +144,10 @@ def _has_option(prefix):
 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
-    #54 only confirmed prefix-merge-on-write for a washer's /course/vs/0.
+    #54 only confirmed prefix-merge-on-write for a washer's /course/vs/0;
-    This extrapolates that same vendor field/contract to the oven's
+    this extrapolates the same contract here. If some oven replaces the
-    /mode/vs/0, on the assumption the firmware handles the array the same
+    field outright instead of merging, this would drop every other option
-    way there. If that assumption is wrong for some oven, a device that
+    on the next write -- revisit if a real device report surfaces that."""
-    replaces the field outright instead of merging would drop every other
-    option in it (Sound/fastpreheat/etc.) on the next write -- revisit if a
-    real device report surfaces that."""
     return [f"{prefix}_{new_value}"]
 
 
@@ -318,13 +296,11 @@ OVEN_CAVITY = Capability(
 
 
 def _oven_temp_unit(rep):
-    """Same shape/risk as fridge.py's TEMPERATURES_FALLBACK: this is the
+    """Same shape/risk as fridge.py's TEMPERATURES_FALLBACK: this aggregate
-    same aggregate `/temperatures/vs/0` items[] resource type, which on
+    `/temperatures/vs/0` items[] resource carries a per-item `unit` field
-    fridge hardware carries a per-item `x.com.samsung.da.unit` field
+    that was previously hardcoded away (issue #7). Keeps the verified '°C'
-    ('Celsius'/'Fahrenheit') that was previously hardcoded away (issue #7).
+    default when the field is absent, but reads it live -- issue #44's
-    Keeps the verified '°C' default when the field is absent (the original
+    range dump is the first to report 'Fahrenheit' here."""
-    NV7000BS-class dump this module was written against), but reads it live
-    -- issue #44's range dump is the first to report 'Fahrenheit' here."""
     items = rep.get("x.com.samsung.da.items") or []
     unit = items[0].get("x.com.samsung.da.unit") if items else None
     return normalize_temp_unit(unit, default="°C")
@@ -404,17 +380,12 @@ OVEN_CONNECTED = Capability(
     ),
 )
 
-# Static cavity capability metadata (count/type/supported features) -- no
+# Static cavity capability metadata -- no per-cavity data varies at runtime
-# per-cavity data varies at runtime on any dump seen so far (issue #44's
+# on any dump seen so far. Bound with no entities purely for coverage.
-# range: single cavity, no supportedFeatureList entries). Bound with no
-# entities purely for coverage; revisit if a multi-cavity dump surfaces
-# fields worth exposing.
 OVEN_SPEC = Capability(href="/oven/spec/vs/0")
 
-# Quick-recipe display blob (combi microwave, issue #121) -- a JSON-encoded
+# Quick-recipe display blob (combi microwave, issue #121) -- every field
-# string (language/menu/servingSize/option) with every field blank on the
+# blank on the only dump seen, no documented write contract.
-# only dump seen, and no documented write contract. No entity to bind per
-# the 'don't guess' rule; a bare Capability still marks the href covered.
 OVEN_RECIPE_COOK = Capability(href="/recipe/cook/vs/0")
 
 OVEN_MODE = Capability(
@@ -430,10 +401,17 @@ OVEN_MODE = Capability(
             value_fn=lambda v: v[0] if v else None,
             write_fn=_oven_mode_write,
         ),
+        # No exists_fn on the NV7000BS-class board this was proven against
+        # (UpperLamp_ is always in its options[]) -- but issue #300's
+        # steam-oven-class WALLOVEN board's options[] has no UpperLamp_
+        # token at all, so this was a phantom, always-off, write-does-
+        # nothing switch there. Same fastpreheat/NaturalSteam-class gap
+        # issue #183 already fixed on the other switches below.
         SwitchDesc(
             key="lamp",
             field="x.com.samsung.da.options",
             icon="mdi:track-light",
+            exists_fn=_has_option("UpperLamp"),
             value_fn=lambda opts: _option_value(opts, "UpperLamp") == "On",
             write_fn=_option_switch_write("UpperLamp"),
         ),
@@ -462,9 +440,8 @@ OVEN_MODE = Capability(
             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 --
+        # this unit's options[] -- unlike fast_preheat/natural_steam above,
-        # unlike fast_preheat/natural_steam above, this token is real on this
+        # this token is real on this hardware, just previously unbound.
-        # hardware, just previously unbound entirely.
         SwitchDesc(
             key="energy_saving",
             field="x.com.samsung.da.options",

custom_components/localthings/registry/capabilities/range.py

@@ -1,36 +1,32 @@
 """Capabilities for the cooktop half of range/combo appliances (issue #44,
 model TP1X_DA-KS-RANGE-0102X).
 
-Not to be confused with PR #23's registry/capabilities/cooktop.py, which
+Not to be confused with registry/capabilities/cooktop.py, which covers an
-covers an unrelated standalone-cooktop product (NA9300K-class) that encodes
+unrelated standalone-cooktop product (NA9300K-class) that encodes burner
-burner state as strings inside /mode/vs/0's options array instead of the
+state as strings inside /mode/vs/0's options array instead of the
-structured /cooktop/status/vs/0 resource this module reads -- two different
+structured /cooktop/status/vs/0 resource this module reads -- two
-OCF surfaces that happen to share the English word "cooktop".
+different OCF surfaces that happen to share the English word "cooktop".
 
 Unlike the rest of the OCF surface, these hrefs use plain camelCase field
-names (no `x.com.samsung.da.` prefix) -- `/cooktop/status/vs/0` already
+names (no `x.com.samsung.da.` prefix).
-looks like a vendor resource migrated onto OCF-standard-shaped field naming.
 
-`/cooktop/status/vs/0` carries every burner's live state in one `burnerList`
+`/cooktop/status/vs/0` carries every burner's live state in one
-array (indexed by `burnerNumber`, not by a separate href per burner like
+`burnerList` array (indexed by `burnerNumber`), so per-burner entities are
-fridge ice makers), so per-burner entities are hardcoded up to MAX_BURNERS
+hardcoded up to MAX_BURNERS and gated by exists_fn against whichever
-and gated by exists_fn against whichever indices the device actually
+indices the device actually reports -- an index absent from burnerList
-reports -- harmless over-declaration, per common.py's UNIVERSAL note, since
+just never binds.
-an index absent from burnerList just never binds.
 
 Write surfaces here are unproven (no live device to verify against, same
-caveat as oven.py's RMW writes) -- power level uses the same read-modify-
+caveat as oven.py's RMW writes) -- power level uses the same
-write pattern already proven safe elsewhere in this codebase (oven setpoint,
+read-modify-write pattern already proven safe elsewhere in this codebase.
-icemaker toggles).
 """
 
 from ..capability import Capability
 from ..entities import BinarySensorDesc, SelectDesc, SensorDesc, SwitchDesc
 from .common import normalize_temp_unit
 
-# Observed as high as 4 (this issue's dump); user-reported hardware with 5
+# Observed as high as 4; user-reported hardware with 5 burners exists.
-# burners exists. Kept a little above both since exists_fn gates unused
+# Kept a little above both since exists_fn gates unused slots out.
-# slots out -- see module docstring.
 MAX_BURNERS = 6
 
 
@@ -140,11 +136,10 @@ COOKTOP_STATUS = Capability(
     poll_tier="hot",
     entities=(
         SensorDesc(key="cooktop_state", field="operationState", icon="mdi:pot-steam"),
-        # The cooktop section's own on/off (issue #86) -- distinct from
+        # The cooktop section's own on/off (issue #86), distinct from
-        # common.POWER's /power/0 or /power/vs/0, which some boards in this
+        # common.POWER's whole-appliance switch. Read-only: no live device
-        # family (the range combo) additionally carry for the whole
+        # to confirm remotely turning it on wouldn't leave a burner active
-        # appliance. Read-only: no live device to confirm remotely turning
+        # unattended.
-        # a cooktop on wouldn't leave a burner active unattended.
         BinarySensorDesc(
             key="cooktop_power",
             field="power",
@@ -153,12 +148,13 @@ COOKTOP_STATUS = Capability(
             value_fn=lambda v: str(v).lower() == "on",
         ),
         # Safe to write -- a lock toggle, not a heat control -- via a
-        # direct single-field PUT (no RMW needed; unlike burnerList this
+        # direct single-field PUT, no RMW needed. No device_class:
-        # is a lone scalar, not an array of siblings to preserve).
+        # SwitchDeviceClass only has 'outlet'/'switch', not 'lock' --
+        # passing it crashed switch platform setup for the whole device
+        # (issue #349, same bug as water_purifier.py's lock switches).
         SwitchDesc(
             key="cooktop_child_lock",
             field="childLock",
-            device_class="lock",
             entity_category="config",
             icon="mdi:lock",
             value_fn=lambda v: str(v).lower() == "on",
@@ -169,16 +165,14 @@ COOKTOP_STATUS = Capability(
 )
 
 # Static burner-count/power-level-list metadata, read directly by
-# COOKTOP_STATUS's power-level select (options=_power_level_options) rather
+# COOKTOP_STATUS's power-level select (options=_power_level_options)
-# than exposed through its own entity -- same "informs another capability,
+# rather than exposed through its own entity.
-# no entity of its own" pattern as /wm/editcourse/vs/0 (ignored.py).
 COOKTOP_SPEC = Capability(href="/cooktop/spec/vs/0")
 
 # settingTime (seconds) is the hot-surface auto-shutoff timer's configured
-# duration (1200s = 20 min in issue #44's dump); state on/off is whether the
+# duration; state on/off is whether the feature itself is enabled -- not a
-# feature itself is enabled -- not a live "surface is hot right now" alert
+# live "surface is hot right now" alert (that's COOKTOP_STATUS's per-burner
-# (that's COOKTOP_STATUS's per-burner hot_surface). No write contract
+# hot_surface). No write contract verified, so read-only for now.
-# verified, so read-only for now.
 COOKTOP_SAFETY = Capability(
     href="/cooktop/settings/status/vs/0",
     poll_tier="warm",
@@ -186,7 +180,7 @@ COOKTOP_SAFETY = Capability(
         BinarySensorDesc(
             key="cooktop_safety_shutoff_enabled",
             field="safetyAlert",
-            entity_category="config",
+            entity_category="diagnostic",
             value_fn=lambda v: (v or {}).get("state") == "on",
         ),
     ),
@@ -194,9 +188,8 @@ COOKTOP_SAFETY = Capability(
 
 # Bluetooth meat probe (issue #86). All-idle sentinel values when
 # disconnected (operationBurnerNumber -1, temperatures 0) -- no special
-# gating on those, matching cooktop.PAIRED_HOOD_STATUS's own precedent of
+# gating, matching cooktop.PAIRED_HOOD_STATUS's precedent of showing a
-# showing a disconnected accessory's fields plainly rather than hiding the
+# disconnected accessory's fields plainly rather than hiding the capability.
-# whole capability.
 PROBE_STATUS = Capability(
     href="/bluetooth/probe/status/vs/0",
     poll_tier="warm",
@@ -232,14 +225,12 @@ PROBE_STATUS = Capability(
     ),
 )
 
-# Some range boards (issue #74's NE63B8411SS) report no /cooktop/status/vs/0
+# Some range boards (issue #74) report no /cooktop/status/vs/0 burner
-# burner array at all -- their local API only exposes this coarse
+# array at all -- their local API only exposes this coarse monitoring
-# monitoring resource for the cooktop half, with no per-burner detail.
+# resource, with no per-burner detail. Meaning of `cooktopMonitoring`
-# Meaning of `cooktopMonitoring` (a bare "0" on the only dump seen) and
+# (bare "0" on the only dump seen) and `warmingCenterState`'s full value
-# `warmingCenterState`'s full value set aren't confirmed, so both are
+# set aren't confirmed, so both are plain sensors rather than a guessed
-# exposed as plain sensors rather than guessed at as a switch/select --
+# switch/select.
-# `supportedHoodLampStateList` has no corresponding live-state field on
-# this resource, so nothing to bind it to yet.
 COOKTOP_MONITORING = Capability(
     href="/cooktopmonitoring/vs/0",
     poll_tier="warm",

custom_components/localthings/registry/capabilities/range_hood.py

@@ -7,8 +7,6 @@ brightness remain separate controls because the device advertises them as two
 independent fields.
 """
 
-from datetime import UTC, datetime
-
 from ..batch import is_stub_rep
 from ..capability import Capability
 from ..entities import (
@@ -19,14 +17,7 @@ from ..entities import (
     SensorDesc,
     SwitchDesc,
 )
-from .common import int_or_none, sensor_item_value
+from .common import epoch_to_utc, int_or_none, sensor_item_value
-
-
-def _timestamp(value):
-    try:
-        return datetime.fromtimestamp(float(value), tz=UTC)
-    except (TypeError, ValueError, OSError):
-        return None
 
 
 def _active_alarm_codes(items):
@@ -191,18 +182,13 @@ HOOD_FILTER = Capability(
 )
 
 
-# After Run (issue #147): the hood keeps the fan running at low speed for a
+# After Run (issue #147): the hood keeps the fan running at low speed after
-# while after it's switched off, to clear residual cooking smoke -- a
+# it's switched off, to clear residual cooking smoke -- a feature a user
-# feature a user actively watches and cancels, not passive diagnostics, so
+# actively watches and cancels, so none of the three entities below carry
-# none of the three entities below carry entity_category. No
+# entity_category. No supported-values list is advertised for
-# supported-values list is advertised for activationState, so it's modeled
+# activationState, so it's read-only monitoring rather than an invented
-# read-only (monitoring, not an invented "enable" write) per the 'don't
+# "enable" write; runningCancel's only observed value is the command name
-# guess' rule; runningCancel's only observed value is the command name
+# itself ('Cancel'), the same shape as operational.STOP_BUTTON.
-# itself ('Cancel'), the same self-describing command-field shape as
-# operational.STOP_BUTTON. runningProgress's own name states its domain
-# (a percentage of the cycle completed), so it's modeled as one rather than
-# left an opaque passthrough -- unlike activationState/runningCancel, there's
-# no ambiguous field name or missing-write-contract question here to hedge on.
 AFTER_RUN = Capability(
     href="/afterrun/vs/0",
     poll_tier="warm",
@@ -286,7 +272,7 @@ AIR_LEVEL_CHECK = Capability(
             field="x.com.samsung.da.lastSensingTime",
             device_class="timestamp",
             entity_category="diagnostic",
-            value_fn=_timestamp,
+            value_fn=epoch_to_utc,
         ),
         SensorDesc(
             key="last_air_sensing_level",

custom_components/localthings/registry/capabilities/vacuum_station.py

@@ -1,19 +1,14 @@
 """Capabilities for the Samsung stick-vacuum clean/auto-empty station
-(model A-VSKR-TP1-22-VS9500AL, "Bespoke Jet" clean station, issue #131).
+(models A-VSKR-TP1-22-VS9500AL / A-VSWW-TP1-23-VS9700, issues #131 / #219).
 
-The reporter's diagnostics dump shows no vacuum-body state at all (no
+The WiFi/DTLS module lives in the clean station. Older VS9500 dumps
-suction level, no battery, no cleaning-mode/room-mapping control, no
+(#131) exposed only dustbag/dustbin/UV-C station state. VS9700 dumps
-docked/undocked status even) -- only the clean station's own dustbag,
+(#219) additionally expose `/status/stick/vs/0` with the wand's battery
-dustbin auto-empty settings, and UV-C sanitizing-cycle status. This
+%, cleaning/charging status, and BLE link -- still no suction/room-map
-strongly suggests the WiFi/DTLS module lives in the station, not the
+control. Modeled as its own device type -- these hrefs don't overlap with
-handheld stick: the station is the only "device" this integration's local
+any existing family (see registry/by_type/__init__.py's docstring).
-API can see, and the wand's own controls are unrelated hardware not
-reachable this way. Modeled as its own device type -- these hrefs don't
-overlap with any existing family, so there's no shared-href ambiguity to
-resolve against another type (see registry/by_type/__init__.py's
-docstring for that rule).
 
-Resources verified against the issue #131 diagnostics dump.
+Resources verified against issue #131 and #219 diagnostics dumps.
 """
 
 from ..capability import Capability
@@ -156,3 +151,43 @@ CLEANSTATION_STATUS = Capability(
         ),
     ),
 )
+
+# Wand body state reported through the station (VS9700 / issue #219). Absent
+# on the older VS9500 dump (#131) -- discovery drops entities when the href
+# is missing.
+STICK_BODY = Capability(
+    href="/status/stick/vs/0",
+    poll_tier="warm",
+    entities=(
+        SensorDesc(
+            key="battery",
+            field="x.com.samsung.da.stickbattery",
+            device_class="battery",
+            state_class="measurement",
+            unit="%",
+            value_fn=int_or_none,
+        ),
+        BinarySensorDesc(
+            key="battery_charging",
+            field="x.com.samsung.da.stickcleaningstatus",
+            device_class="battery_charging",
+            value_fn=lambda v: v == "Charging",
+        ),
+        SensorDesc(
+            key="stick_cleaning_status",
+            field="x.com.samsung.da.stickcleaningstatus",
+            icon="mdi:vacuum",
+        ),
+        SensorDesc(
+            key="stick_operation_mode",
+            field="x.com.samsung.da.stickoperationmode",
+            icon="mdi:broom",
+        ),
+        BinarySensorDesc(
+            key="stick_ble_connected",
+            field="x.com.samsung.da.stickbleconnection",
+            device_class="connectivity",
+            value_fn=lambda v: v == "On",
+        ),
+    ),
+)

custom_components/localthings/registry/capabilities/washer.py

@@ -16,7 +16,7 @@ array.
 """
 
 from ..capability import Capability
-from ..entities import BinarySensorDesc, SelectDesc, SensorDesc
+from ..entities import BinarySensorDesc, SelectDesc, SensorDesc, SwitchDesc
 from .laundry import (
     bool_option_exists,
     bool_option_switch,
@@ -27,64 +27,56 @@ from .laundry import (
     hex_pairs,
     option_value,
     option_write,
+    washer_cycle_fallback,
 )
 
-# ---------------------------------------------------------------------------
+# Course_XX hex code labels (translations/en.json,
-# Course_XX hex codes. 23 of the codes named in translations/en.json
+# washer_cycle_table_02.state.<id>) come from several devices, cross-checked
-# under entity.select.washer_cycle_table_02.state.<id, lowercased> were captured
+# rather than guessed: 23 codes from a live WW90DG6U25LEU4's editCourseList,
-# from a live WW90DG6U25LEU4's x.com.samsung.da.editCourseList
+# matched positionally against a user's app screenshots and the printed
-# (EditCourseList_1C1D211B1E29243328262722202325322F2E30662D8F96), matched
+# manual (issue #2); 5 more (Wash+Dry, Air Wash, Cotton Dry, Synthetics Dry,
-# positionally against a Slovak-UI user's screenshots of their app's course
+# a second distinct '1F' Intense Cold) from a WD90T654DBN/S1 combo's own
-# list (same order, same count -- see issue #2) and cross-checked against
+# editCourseList and screenshots (issue #22, a combo's own course set, not
-# the printed user manual's course table (confirming e.g. '8F' as 'Intense
+# implying anything about a plain washer's '1F'); 3 more (Eco Cold, Towels,
-# Cold', not the position-adjacent-looking but distinct 'Mixed Load', a
+# Self Clean+) verified directly on a WF50A8600AV/US by reading back the raw
-# cycle the manual marks "applicable models only" and that does not appear
+# code after selecting each cycle on the appliance (issue #80). 2 more
-# in this device's editCourseList -- nor does 'AI Wash', also "applicable
+# ('0A' Towels, 'B0' Mixed Load) reported for a WW90DG5G34ABLE on the same
-# models only"). FixedCourseList_1C29 (the two courses always pinned in the
+# Table_02 family (issue #363). Several codes legitimately share a label
-# app) maps to '1C'/'29' = Eco 40-60 and Drum Clean+, which matches what
+# across different course tables -- '21'/'65' Colors, '27'/'5E'/'78'
-# you'd expect to be pinned (default cycle + maintenance cycle),
+# Rinse+Spin, '0A'/'33'/'54'/'70' Towels -- not typos. (This list said
-# corroborating the positional match.
+# "'24' Towels" until issue #343 found 24/33 transposed; 24 is Bedding.)
 #
-# A further 5 codes -- '36' Wash+Dry, '37' Air Wash, '38' Cotton Dry,
+# No static fallback list is kept here: other models have different actual
-# '39' Synthetics Dry, and a second, distinct '1F' Intense Cold (not the
+# course sets, so hardcoding one device's list would show/hide the wrong
-# same code as '8F' above) -- came from a WD90T654DBN/S1 washer/dryer
+# options elsewhere. laundry.cycle_options() reads only the live
-# combo's editCourseList and were named from that user's app screenshot
+# x.com.samsung.da.editCourseList; a device that doesn't populate it gets no
-# (issue #22). Combo units carry their own course set, so these codes
+# cycle select at all (see cycle_select's exists_fn). x.com.samsung.da.
-# don't imply anything about '1F' on a plain washer.
+# options' MostUsed_* entry was considered as a fallback source (its first
+# byte matches the selected Course_XX on both dumps), but the remaining
+# bytes don't decode to any confirmed course code, so it isn't used.
 #
-# Three more -- '52' Eco Cold, '54' Towels, '60' Self Clean+ -- came from a
+# The owner of a Korean Table_02 washer confirmed the names for its newer
-# WF50A8600AV/US, verified directly rather than by inference: the reporter
+# 69/6A-79/88 course-code family, including Course_69 as AI Wash. Those names
-# selected each cycle on the physical appliance and read back the resulting
+# live only in the table-scoped translation catalog; a code not confirmed by
-# raw code from the cycle_select entity's state (issue #80). '54' shares a
+# the owner or device metadata falls back to washer_cycle_fallback, which
-# display name with the existing '24' Towels -- a different code on a
+# surfaces a personal-course name only -- no invented English label for an
-# different course table legitimately landing on the same label, not a typo
+# unrecognized standard code (PR #251 review).
-# (same pattern as '21'/'65' Colors and '27'/'5E' Rinse+Spin above).
 #
-# No static fallback list of those codes is kept here, deliberately: other
+# washer_cycle_table_00 (issue #357) is a separate, older course-code family
-# washer models have a different actual course set (a second dump's active
+# reported by a WF45R6300AW/US -- confirmed by the reporter selecting each
-# course, '65', isn't even in the list above; models with 'AI Wash'/'Mixed
+# cycle on the appliance and reading back the raw code, the same method used
-# Load' -- both "applicable models only" per the manual -- would have yet
+# for Table_02's WF50A8600AV/US codes above. A device reporting Table_00 with
-# another set), so hardcoding one device's list would show/hide the wrong
+# an unconfirmed code (FlexWash's washer_flexwash_device fixture, for
-# options on a different model. laundry.cycle_options() reads only the live
+# instance) still renders that code raw rather than borrowing a Table_02
-# x.com.samsung.da.editCourseList; if a device doesn't populate that
+# label -- the two tables are unrelated code spaces despite a handful of
-# resource, the cycle select isn't created at all (see cycle_select's
+# overlapping hex values.
-# exists_fn). x.com.samsung.da.options' MostUsed_* entry was considered as a
-# fallback source (its first byte reliably equals the currently-selected
-# Course_XX on both dumps we have), but the bytes after that don't
-# correspond to any confirmed course code on either device -- e.g. dump 1's
-# MostUsed_1C8410923FA67F00000000000000 decodes to
-# ['1C','84','10','92','3F','A6','7F',...] and only '1C' is a real code --
-# so it isn't trustworthy as a list of selectable courses and isn't used.
 # ---------------------------------------------------------------------------
 
-# ---------------------------------------------------------------------------
+# /washer/vs/0 -- wash temperature, spin speed, rinse cycle count.
-# /washer/vs/0 -- wash temperature, spin speed, rinse cycle count
-#
 # Despite the shared href, this is unrelated to dryer.DRYER_SETTINGS (also
 # bound to '/washer/vs/0') -- an artifact of Samsung reusing the same OCF
 # path for different device families. Only one of the two ever binds for a
 # given device, since dryer and washer are separate by_type registries.
-# ---------------------------------------------------------------------------
 
 WASHER_SETTINGS = Capability(
     href="/washer/vs/0",
@@ -123,9 +115,8 @@ WASHER_SETTINGS = Capability(
             ),
         ),
         # Washer/dryer combo units carry a dryLevel field on the wash
-        # resource itself (no separate dryer device/course) -- see issue
+        # resource itself (issue #22). Self-gates off on plain washers,
-        # #22. Self-gates off on plain washers, which never report
+        # which never report supportedDryLevel.
-        # supportedDryLevel.
         SelectDesc(
             key="dry_level",
             field="x.com.samsung.da.dryLevel",
@@ -142,12 +133,9 @@ WASHER_SETTINGS = Capability(
     ),
 )
 
-# ---------------------------------------------------------------------------
 # /course/vs/0 -- the cycle select is the shared laundry.cycle_select; the
-# drum-clean and dispenser-dosing entities below are washer-specific reads off
+# drum-clean and dispenser-dosing entities below are washer-specific reads
-# the same options array.
+# off the same options array.
-# ---------------------------------------------------------------------------
-
 
 # Drum Clean+ maintenance tracking (issue #9): drum_clean_cycles_remaining/
 # drum_clean_last_cleaned live in laundry.py, shared with dryer.py (issue
@@ -157,30 +145,17 @@ WASHER_SETTINGS = Capability(
 
 # Detergent/softener auto-dispense dosing, from the same options[] array
 # (issue #9). '<Prefix>LevelCtrl_<code>' is the selected dose quantity;
-# '<Prefix>Level2Ctrl_<code>' is a second dial -- water hardness for
+# '<Prefix>Level2Ctrl_<code>' is a second dial (water hardness for
-# detergent, concentration for softener -- matching the SmartThings app's
+# detergent, concentration for softener), matching the app's two-field
-# two-field dispenser screens ("Distributeur de lessive": Quantité + Dureté
+# dispenser screens. 'Supported<Prefix>Ctrl_<hexpairs>' lists the valid raw
-# de l'eau; "Distributeur d'adoucissant": Quantité + Concentration, per
+# codes, same hex-pair shape as EditCourseList. '<Prefix>Alarm_<On/Off>' is
-# issue #9's screenshots). 'Supported<Prefix>Ctrl_<hexpairs>' lists the
+# a low-reservoir warning flag.
-# valid raw codes for its field, same hex-pair shape as EditCourseList.
-# '<Prefix>Alarm_<On/Off>' is a low-reservoir warning flag.
 #
-# Label mapping (entity.select.{detergent,softener}_quantity /
+# Label mapping (translations/en.json's {detergent,softener}_quantity /
-# detergent_water_hardness / softener_concentration in translations/en.json) is an
+# detergent_water_hardness / softener_concentration) is an assumed reading
-# assumed, not cross-device-verified, reading of the single issue #9 dump +
+# of the single issue #9 dump + screenshots, cross-checked against the
-# screenshots: LevelCtrl's 4 codes as None/Low/Medium/High (00 has no
+# selected value on both dispensers, not independently verified per code --
-# on-screen equivalent -- the app's Quantité picker only offers
+# revisit if a second device's dump contradicts it.
-# Faible/Moyen/Élevé, i.e. codes 01-03; 00 is assumed to be what
-# "Activation" off collapses to) matches DetergentLevelCtrl_3/
-# SoftenerLevelCtrl_3 = "Élevé" on both dispensers. Level2Ctrl's 3 codes as
-# Soft/Medium/Hard for detergent (Dureté de l'eau: Douce/Moyenne/Dure)
-# matches DetergentLevel2Ctrl_2 = "Moyenne". The same 3-code shape as
-# 1x/2x/3x for softener concentration does *not* cleanly match
-# SoftenerLevel2Ctrl_2 against the screenshot's "3x" -- assumed to be a
-# setting the user changed in the app between the dump (issue body) and the
-# screenshots (a later comment), not a different code scheme, since it's
-# otherwise identical in shape to the detergent side. Revisit if a second
-# device's dump contradicts this.
 def _supported_level_options(resources, prefix):
     rep = resources.get("/course/vs/0") or {}
     raw = option_value(rep.get("x.com.samsung.da.options"), f"Supported{prefix}")
@@ -192,15 +167,13 @@ def _level_options(prefix):
 
 
 def _dosing_level(prefix):
-    """Current dose code, normalized to the `Supported<prefix>` code format.
+    """Current dose code, normalized to the `Supported<prefix>` code
-
+    format. The device reports the selected level as `<prefix>_<code>`
-    The device reports the selected level as `<prefix>_<code>` with the code
+    un-padded (e.g. '3'), but the select's own options come from
-    un-padded (e.g. '3'), but the valid codes -- which are also this select's
+    `Supported<prefix>_<hexpairs>` as zero-padded hex pairs (e.g. '03').
-    options and its translation keys -- come from `Supported<prefix>_<hexpairs>`
+    Left as '3', the value sits outside the select's own option list and
-    as zero-padded hex pairs (e.g. '03'). Left as '3', the current value sits
+    HA renders it 'unknown' (issue #9) -- resolve it to the matching
-    outside the select's own option list, so HA renders it 'unknown' (issue #9).
+    zero-padded code instead."""
-    Resolve it to the supported code with the same integer value so
-    current_option matches an option (and its translation)."""
 
     def fn(rep):
         opts = rep.get("x.com.samsung.da.options")
@@ -227,9 +200,8 @@ def _level_write(prefix):
     def write(p, rep, href=None):
         if not rep.get("x.com.samsung.da.options"):
             return None
-        # `p` is the zero-padded supported code the UI selected (e.g. '03');
+        # `p` is the zero-padded supported code (e.g. '03'); the device
-        # the device stores the level un-padded (e.g. '3'), matching how it
+        # stores it un-padded (e.g. '3'), matching how it's reported.
-        # reports it, so write it back in that native shape.
         try:
             native = format(int(p, 16), "X")
         except (TypeError, ValueError):
@@ -248,37 +220,28 @@ def _dosing_low(prefix):
 
 
 # Bubble soak / pre-wash / intensive-wash toggles, from the same options[]
-# array (issue #22 follow-up on a WD90T654DBN/S1 combo). Each rides as a
+# array (issue #22 follow-up). Each rides as a plain '<Prefix>_On'/'_Off'
-# plain '<Prefix>_On'/'<Prefix>_Off' token, confirmed by a dump taken with
+# token, confirmed against a dump taken with Bubble Soak switched on in the
-# Bubble Soak switched on in the app (BubbleSoak_On) -- the same On/Off shape
+# app -- the same shape as AiOption/KidsLockBypass in this array.
-# already used by AiOption and KidsLockBypass in this same array, so
-# PreWashSetting/IntensiveSetting are assumed to follow suit.
 #
-# Each also has a differently-named hex-pair availability field that lines up
+# Each also has a hex-pair availability field positional with
-# positionally with editCourseList: BubbleSoakSet, PreWashAvailableSet,
+# editCourseList (BubbleSoakSet, PreWashAvailableSet,
-# IntensiveAvailableSet. On the reporter's dump (course '30' at position 1 of
+# IntensiveAvailableSet): on the reporter's dump 'F0' at a course's
-# 24), all three read 'F0' at that position and the toggle was writable --
+# position matched the app enabling the control there, '00' matched it
-# and the same dump's earlier state (course '1C' at position 0, 'BubbleSoak
+# grayed out. exists_fn only runs once at setup, so it can't do this
-# Off') decodes to '00' for that course, matching the app graying the
+# per-course check -- validate_fn runs on every write attempt instead,
-# control out there. 'F0'/'00' is treated as available/unavailable on that
+# rejecting an on-write for a course whose byte isn't 'F0' with a
-# evidence. exists_fn (device-level presence) still only runs once, against
+# user-facing error rather than silently no-opping. The read/write/
-# the setup-time snapshot, so it isn't a fit for this per-course check --
+# presence machinery is laundry.bool_option_switch, shared with
-# validate_fn runs on every write attempt instead (dispatched from
+# dishwasher's storm-wash/auto-release-dry toggles; only this per-course
-# coordinator.async_send_command, ahead of write_fn), rejecting an on-write
+# gating is washer-only.
-# for a course whose byte isn't 'F0' with a user-facing error rather than
-# silently no-opping against the device. The read/write/presence machinery
-# itself is laundry.bool_option_switch, shared with dishwasher's storm-wash/
-# auto-release-dry toggles -- only this per-course gating is washer-only, so
-# it stays here rather than in laundry.py (see laundry.bool_option_switch's
-# docstring: it takes a prebuilt validate_fn and has no opinion on it).
 def _bool_option_switch(key, icon, prefix, availability_field):
     def validate(p, rep, resources):
         """Reject turning on when the selected course's byte in
-        `availability_field` isn't 'F0'. Turning off is never blocked. Falls
+        `availability_field` isn't 'F0'. Turning off is never blocked.
-        back to allowing the write whenever the availability data can't be
+        Falls back to allowing the write whenever the availability data
-        resolved (unrecognized course, missing/mismatched-length bitmap)
+        can't be resolved (unrecognized course, missing/mismatched-length
-        rather than guessing -- a false rejection is worse than an
+        bitmap) -- a false rejection is worse than an occasional no-op."""
-        occasional no-op write."""
         if p != "On":
             return None
         opts = rep.get("x.com.samsung.da.options") or []
@@ -301,6 +264,105 @@ def _bool_option_switch(key, icon, prefix, availability_field):
     )
 
 
+# AddWash -- the little door for adding a forgotten sock mid-cycle -- rides
+# three independent tokens on the same options[] array:
+#
+#   AddWashSet_<0-7>         the alarm setting, and the only writable one:
+#                            a 3-bit mask over the moments it fires, bit 0
+#                            rinse, bit 1 final rinse, bit 2 spin.
+#   AddWashAvailable_<0-7>   the same three bits, but what the running
+#                            course still permits.
+#   AddWashIndicator_On/Off  the panel lamp: laundry may go in right now.
+#
+# Bit order confirmed by watching a WW6500 run a cycle: AddWashAvailable
+# shed one bit as each moment passed (7 through Rinse, then 6, 4, and 0 as
+# Spin began) and reset to 7 at the end, while the lamp tracked the phase
+# with the alarm switched off throughout.
+
+
+def _add_wash_mask(rep, prefix):
+    """One of the 3-bit AddWash masks, or None when its token is absent,
+    malformed, or outside 0-7. Never 0 for a missing token: 0 is a real
+    value, and a mask this model can't represent is a wrong model rather
+    than something to write back."""
+    raw = option_value(rep.get("x.com.samsung.da.options"), prefix)
+    try:
+        mask = int(raw)
+    except (TypeError, ValueError):
+        return None
+    return mask if 0 <= mask <= 0b111 else None
+
+
+def _add_wash_any(prefix):
+    """Whether any of the three moments is set in `prefix`'s mask."""
+
+    def read(rep):
+        mask = _add_wash_mask(rep, prefix)
+        return None if mask is None else mask != 0
+
+    return read
+
+
+def _add_wash_set_write(mask):
+    return ["course", "vs", "0"], {
+        "x.com.samsung.da.options": option_write("AddWashSet", str(mask)),
+    }
+
+
+def _add_wash_alarm_write(p, rep, href=None):
+    # Gated on the mask being readable, like the per-moment writes: a device
+    # reporting a wider mask than these three bits would otherwise have it
+    # truncated to 7 here, silently dropping a moment it supports.
+    mask = _add_wash_mask(rep, "AddWashSet")
+    if p not in ("On", "Off") or mask is None:
+        return None
+    if p == "On" and mask:
+        # Already on, so "on" is a no-op rather than a rewrite to 7. Home
+        # Assistant calls turn_on regardless of current state, so an
+        # automation asserting the alarm on over a rinse-only mask would
+        # otherwise widen it to all three moments with no state change on
+        # this switch to point at. Distinct from the off-then-on case in
+        # _add_wash_bit_switch, where there is no subset left to keep.
+        return None
+    return _add_wash_set_write(0b111 if p == "On" else 0)
+
+
+def _add_wash_bit_switch(key, icon, bit):
+    """One moment the alarm fires at, as its own bit of the mask.
+
+    The mask is the only state, so switching the last moment off lands on 0
+    and takes the alarm with it, and switching one on from 0 turns the alarm
+    back on. The corollary is that switching the master off and on again
+    writes 7, resetting a rinse-only selection to all three moments -- the
+    appliance remembers no previous subset either, so there is nothing to
+    restore.
+    """
+
+    def read(rep):
+        mask = _add_wash_mask(rep, "AddWashSet")
+        return None if mask is None else bool(mask >> bit & 1)
+
+    def write(p, rep, href=None):
+        mask = _add_wash_mask(rep, "AddWashSet")
+        if p not in ("On", "Off") or mask is None:
+            return None
+        return _add_wash_set_write(mask | 1 << bit if p == "On" else mask & ~(1 << bit))
+
+    return SwitchDesc(
+        key=key,
+        icon=icon,
+        entity_category="config",
+        exists_fn=bool_option_exists("AddWashSet"),
+        rep_fn=read,
+        write_fn=write,
+    )
+
+
+def _add_wash_indicator(rep):
+    raw = option_value(rep.get("x.com.samsung.da.options"), "AddWashIndicator")
+    return raw.lower() == "on" if isinstance(raw, str) else None
+
+
 WASHER_COURSE = Capability(
     href="/course/vs/0",
     entities=(
@@ -308,6 +370,7 @@ WASHER_COURSE = Capability(
             translation_key="washer_cycle",
             icon="mdi:washing-machine",
             table_href="/st/washercourse/vs/0",
+            display_fn=washer_cycle_fallback,
         ),
         SensorDesc(
             key="drum_clean_cycles_remaining",
@@ -386,5 +449,33 @@ WASHER_COURSE = Capability(
         _bool_option_switch(
             "intensive", "mdi:washing-machine", "IntensiveSetting", "IntensiveAvailableSet"
         ),
+        SwitchDesc(
+            key="add_wash_alarm",
+            icon="mdi:bell-ring",
+            entity_category="config",
+            exists_fn=bool_option_exists("AddWashSet"),
+            rep_fn=_add_wash_any("AddWashSet"),
+            write_fn=_add_wash_alarm_write,
+        ),
+        _add_wash_bit_switch("add_wash_alarm_rinse", "mdi:water", 0),
+        _add_wash_bit_switch("add_wash_alarm_final_rinse", "mdi:water-check", 1),
+        _add_wash_bit_switch("add_wash_alarm_spin", "mdi:sync", 2),
+        # On at rest: an idle washer reports AddWashAvailable_7 and the mask
+        # only empties as the cycle consumes each moment. This says the cycle
+        # permits AddWash, not that laundry can go in now -- that is
+        # add_wash_indicator.
+        BinarySensorDesc(
+            key="add_wash_available",
+            icon="mdi:tshirt-crew-outline",
+            entity_category="diagnostic",
+            exists_fn=bool_option_exists("AddWashAvailable"),
+            rep_fn=_add_wash_any("AddWashAvailable"),
+        ),
+        BinarySensorDesc(
+            key="add_wash_indicator",
+            icon="mdi:door-open",
+            exists_fn=bool_option_exists("AddWashIndicator"),
+            rep_fn=_add_wash_indicator,
+        ),
     ),
 )

custom_components/localthings/registry/capabilities/water_purifier.py

@@ -25,19 +25,13 @@ DISPENSE = Capability(
                 {"x.com.samsung.da.desiredType": p},
             ),
         ),
-        # Only a handful of discrete temperatures are selectable (not a
+        # Only a handful of discrete temperatures are selectable -- a select
-        # continuous range) -- a select over the live-reported set, not a
+        # over the live-reported set, not a number with invented bounds.
-        # number with invented bounds.
+        # Newer boards (issue #196) don't populate supportedHotTemperatures
-        #
+        # at all, reporting a hotwaterRange/hotwaterLevel pair instead with
-        # Newer boards (issue #196, RWP70F15ANW) don't populate
+        # no confirmed write contract -- gate the entity off entirely there
-        # supportedHotTemperatures at all -- they report a hotwaterRange
+        # rather than guess at that pair's meaning (an empty options list
-        # (min/max) and a hotwaterLevel (step count?) instead, with no
+        # otherwise left current_option rendering "unknown").
-        # 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",
@@ -53,12 +47,10 @@ DISPENSE = Capability(
             ),
         ),
         # Bounds and step come live from the device's own
-        # desiredCapacityRange/capacityResolution fields, not a hardcoded
+        # desiredCapacityRange/capacityResolution, not a hardcoded constant.
-        # constant -- see the adding-device-support skill's "never hard-code
+        # No unit is set: capacityUnit reads "C" on this dump, which can't
-        # the one dump's values" section. No unit is set: capacityUnit reads
+        # be right for a volume field, so it's left unset rather than
-        # "C" on this dump, which can't be right for a volume field, so per
+        # assumed to be mL.
-        # the 'don't guess' rule the unit is left unset rather than assumed
-        # to be mL.
         NumberDesc(
             key="dispense_capacity",
             field="x.com.samsung.da.desiredCapacity",
@@ -159,24 +151,16 @@ FAVORITE_CAPACITY = Capability(
     ),
 )
 
-# Coffee-capable variant (issue #107) -- a "favorite" supported-list select
-# for the hot water dispensed alongside brewing, same shape as
-# FAVORITE_CAPACITY above.
-
 
 def _status_lock_definitely_lacks_hotwater_field(resources: dict) -> bool:
-    """Three-way read of /status/lock/vs/0's hotwaterLock field, favouring
+    """Three-way read of /status/lock/vs/0's hotwaterLock field, favoring
     LOCK.hotwater_lock (the primary descriptor) whenever the outcome is
-    still ambiguous:
+    still ambiguous: href absent -> True (fallback may claim the entity);
-
+    href present but an unfetched stub ({}) -> False (pending, not
-    - href entirely absent from this device -> definitely no clash, the
+    confirmed absence -- LOCK's own exists_fn optimistically includes
-      switchHotwater fallback below may claim the entity.
+    itself through a stub too, so returning True would register both
-    - href present but an unfetched stub ({}) -> outcome pending, *not* a
+    descriptors under one key until the next poll); href present and
-      confirmed absence. LOCK's own exists_fn optimistically includes itself
+    fetched -> the real answer."""
-      through a stub (matching entity.py's default), so returning True here
-      too would register both descriptors -- as SwitchDescs sharing one key,
-      with identical unique_ids -- until the next poll resolves it.
-    - href present and fetched -> the real answer."""
     rep = resources.get("/status/lock/vs/0")
     if rep is None:
         return True
@@ -189,28 +173,24 @@ FAVORITE_HOTWATER = Capability(
     href="/favorite/hotwater/vs/0",
     poll_tier="cold",
     entities=(
-        # Despite the resource/field naming, switchHotwater's value domain is
+        # Despite the naming, switchHotwater's value domain is
-        # Locked/Unlocked, not an enable flag (issue #144) -- it's the same
+        # Locked/Unlocked, not an enable flag (issue #144) -- the same
-        # hot-water lock as LOCK.hotwater_lock below, just surfaced through
+        # hot-water lock as LOCK.hotwater_lock below, surfaced through this
-        # this href on boards that don't populate /status/lock/vs/0's
+        # href on boards that don't populate /status/lock/vs/0's
-        # hotwaterLock field. Shares that descriptor's key so only one "Hot
+        # hotwaterLock. Shares that descriptor's key so only one "Hot water
-        # water lock" entity ever appears.
+        # lock" entity appears; both halves need an exists_fn since
-        #
+        # adapter.flatten() only ever honors exists_fn, not entity.py's
-        # Both halves of this fallback pair need an exists_fn, not just this
+        # implicit field-presence default -- without it, whichever
-        # one: adapter.flatten() (the coordinator.data source every entity's
+        # same-keyed descriptor is processed last would silently win.
-        # is_on reads) only ever honours exists_fn, never entity.py's
+        # No device_class: SwitchDeviceClass only has 'outlet'/'switch',
-        # implicit "require own field present" default that gates plain
+        # not 'lock' -- passing it crashed switch platform setup entirely
-        # registration. Two same-keyed descriptors with only one of them
+        # for the whole device (issue #349), same bug KIDS_LOCK_GENERIC
-        # gated still both land in flatten()'s output dict -- whichever is
+        # dodged by switching to BinarySensorDesc (issues #181/#183). This
-        # processed last silently wins, decided by device-reported href
+        # entity stays a SwitchDesc since it's genuinely writable.
-        # order, not by which one is actually correct. So this exists_fn
-        # also re-asserts its own field's presence (switchHotwater), the
-        # gate a bare `field=` used to get for free before it had to share a
-        # key with LOCK's descriptor.
         SwitchDesc(
             key="hotwater_lock",
             field="x.com.samsung.da.switchHotwater",
-            device_class="lock",
+            icon="mdi:lock",
             entity_category="config",
             value_fn=lambda v: v != "Unlocked",
             exists_fn=lambda rep, resources: (
@@ -222,18 +202,12 @@ FAVORITE_HOTWATER = Capability(
                 {"x.com.samsung.da.switchHotwater": "Locked" if p == "On" else "Unlocked"},
             ),
         ),
-        # Issue #196: `supportedList` is only the four *fixed* presets
+        # Issue #196: `supportedList` is only the four fixed presets -- the
-        # (e.g. ['40', '75', '85', '90']) -- the SmartThings app also lets
+        # app also lets the user add one custom value to their own display
-        # the user add one custom value to their own display list via its
+        # list, which shows up in `showList` but never in `supportedList`.
-        # "temperatures to display" editor (a wheel picker bounded by
+        # Reading from `supportedList` meant a unit whose current default
-        # /setting/waterpurifier/vs/0's hotwaterRange, separate resource),
+        # was that custom value rendered as "unknown"; `showList` is a
-        # and that custom value shows up in `showList`
+        # superset that always includes the actual current default.
-        # (['40', '50', '75', '85', '90'] here) but never in
-        # `supportedList`. Reading options from `supportedList` meant a
-        # unit whose current default *was* that custom value rendered as
-        # "unknown" -- not a coverage gap, just the wrong field. `showList`
-        # is a superset of `supportedList` that always includes whatever
-        # the current default actually is, custom or not.
         SelectDesc(
             key="favorite_hotwater_temperature",
             field="x.com.samsung.da.favorite.defaultTemperature",
@@ -291,11 +265,9 @@ CUP_STATE = Capability(
 )
 
 # Sound mode/output/volume (issue #196). Shapes echo laundry.py/
-# air_purifier.py's same-named hrefs, but this board's own values differ
+# air_purifier.py's same-named hrefs, but this board's own supportedModes
-# from both (supportedModes here is voice/fixedTone/mute, not laundry's
+# (voice/fixedTone/mute) differs from both, so these read the device's own
-# voice/tone/mute nor air_purifier's mute/buzzer) -- reusing either would
+# supported list/range rather than reusing either.
-# 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",
@@ -359,9 +331,8 @@ SOUND_VOLUME = Capability(
 )
 
 # Last-pour statistics (issue #196). last.capacity's unit isn't confirmed
-# (no sibling unit field on this resource, unlike DISPENSE.dispense_capacity
+# (no sibling unit field on this resource) so it's left unitless rather
-# which at least has an -- albeit suspect -- capacityUnit) so it's left
+# than assumed to be mL.
-# unitless rather than assumed to be mL.
 STATISTIC_POUR = Capability(
     href="/statistic/pour/vs/0",
     poll_tier="cold",
@@ -387,16 +358,14 @@ LOCK = Capability(
     poll_tier="warm",
     entities=(
         # Shares its key with FAVORITE_HOTWATER's switchHotwater fallback
-        # above (issue #144); see the comment there for why this half also
+        # above (issue #144); see the comment there. A stub rep ({}) still
-        # needs an explicit exists_fn now that the two share a key in
+        # counts as "present" here, matching entity.py's own default. No
-        # adapter.flatten()'s output. A stub rep ({}) still counts as
+        # device_class on any of the three locks below -- see the
-        # "present" here (matches entity.py's own default for a field-less
+        # device_class note on FAVORITE_HOTWATER's hotwater_lock (issue #349).
-        # gate) since the alternative -- treating an unfetched resource as
-        # confirmed-absent -- is what let both descriptors register at once.
         SwitchDesc(
             key="hotwater_lock",
             field="x.com.samsung.da.hotwaterLock",
-            device_class="lock",
+            icon="mdi:lock",
             entity_category="config",
             value_fn=lambda v: v != "Unlocked",
             exists_fn=lambda rep, resources: not rep or "x.com.samsung.da.hotwaterLock" in rep,
@@ -408,7 +377,7 @@ LOCK = Capability(
         SwitchDesc(
             key="coldwater_lock",
             field="x.com.samsung.da.coldwaterLock",
-            device_class="lock",
+            icon="mdi:lock",
             entity_category="config",
             value_fn=lambda v: v != "Unlocked",
             write_fn=lambda p, rep, href=None: (
@@ -419,7 +388,7 @@ LOCK = Capability(
         SwitchDesc(
             key="buzz_lock",
             field="x.com.samsung.da.buzzLock",
-            device_class="lock",
+            icon="mdi:lock",
             entity_category="config",
             value_fn=lambda v: v != "Unlocked",
             write_fn=lambda p, rep, href=None: (
@@ -430,29 +399,21 @@ LOCK = Capability(
     ),
 )
 
-# ---------------------------------------------------------------------------
 # Water-purifier-scoped coverage: hrefs with no user-actionable state or no
 # confirmed contract, following the 'don't guess' rule.
-# ---------------------------------------------------------------------------
 _WP_IGNORED = [
-    # supportedModes carries a single opaque wizard-workflow token
+    # supportedModes carries a single opaque wizard-workflow token and
-    # ('HOMECARE_WIZARD_V2') and modes reports a completely different,
+    # modes reports an unrelated value not even in supportedModes --
-    # unrelated value ('WATERFILTER_DISABLE') not even present in
+    # internal plumbing, not a real mode select.
-    # supportedModes -- internal plumbing, not a real user-facing mode
-    # select. OCF-standard /mode/0 mirrors the same vendor resource but is
-    # already covered by the global ignored.IGNORED (fridge's OCF-native
-    # vacation-mode flag shares that href).
     "/mode/vs/0",
-    # Static support-flags blob (automation.supported.modes/options) -- no
+    # Static support-flags blob -- no live "current setting" field.
-    # live "current automation setting" field to expose.
     "/automation/waterpurifier/vs/0",
-    # Coffee-capable variant (issue #107). All four are static
+    # Coffee-capable variant (issue #107): static capability-advertisement
-    # capability-advertisement blobs or empty -- no live "current recipe" /
+    # blobs or empty, unlike /favorite/coffee/vs/0 (COFFEE above) which
-    # "current custom slot" field to expose, unlike /favorite/coffee/vs/0
+    # does carry live brew status.
-    # (COFFEE above), which does carry live brew status.
     "/brand/recipe/info/vs/0",  # revision + max-brand-count metadata
-    "/coffee/custom/recipe/vs/0",  # publisher.support: allowed custom-recipe slot IDs
+    "/coffee/custom/recipe/vs/0",  # allowed custom-recipe slot IDs
-    "/recipe/coffee/vs/0",  # same publisher.support shape, no per-recipe content
+    "/recipe/coffee/vs/0",  # same shape, no per-recipe content
     "/recipe/coffee/deletion/vs/0",  # empty {} on this dump
 ]
 

custom_components/localthings/registry/discovery.py

@@ -31,10 +31,9 @@ class BoundEntity:
     key_override: str | None = None
     instance_name: str | None = None
     # Which logical indoor subdevice (issue #177) this entity belongs to.
-    # `href` above is always the *actual*, on-the-wire href for that
+    # `href` above is always the actual, on-the-wire href for that
-    # subdevice -- MAIN's
+    # subdevice -- MAIN's to_actual is the identity transform, so a device
-    # to_actual is the identity transform, so every device with no subdevices
+    # with no subdevices is unaffected.
-    # behaves exactly as before this field existed.
     subdevice: Subdevice = MAIN
 
 
@@ -101,24 +100,19 @@ def discover(
     tier_log: Callable[[str, str], None] | None = None,
     subdevice: Subdevice = MAIN,
 ) -> list[BoundEntity]:
-    """`tier_log(href, poll_tier)` fires for every href a capability actually
+    """`tier_log(href, poll_tier)` fires for every href a capability
-    matches, even a no-entity "coverage-only" capability (see COVERAGE lists
+    actually matches, even a no-entity "coverage-only" capability that
-    in capabilities/*.py) that `_bind()` turns into zero `BoundEntity` rows.
+    `_bind()` turns into zero `BoundEntity` rows. Callers that need a
-    Callers that need a href's poll cadence (the coordinator's hot/warm
+    href's poll cadence must use this, not `bound` -- a coverage-only
-    sub-poll and OBSERVE-attempt lists) must use this, not `bound` -- a
+    capability's `poll_tier` would otherwise never appear in `bound`.
-    coverage-only capability's `poll_tier` would otherwise be silently
-    dropped since it never appears in `bound`.
 
-    `resources` is always keyed by *canonical* hrefs -- for a subdevice
+    `resources` is always keyed by canonical hrefs -- for a subdevice
-    (issue #177) that means its own canonical view (see
+    (issue #177), its own canonical view (see subdevices.canonical_view),
-    subdevices.canonical_view), the same shape as a plain single-subdevice
+    the same shape as a single-subdevice device's resources dict, so
-    device's resources dict, so registry lookups/rt_filter/match_fn/
+    registry lookups behave identically regardless of which subdevice is
-    instance_suffix all behave identically regardless of which subdevice is
+    being discovered. `subdevice` only affects the href stamped onto each
-    being discovered.
+    BoundEntity and the href `log`/`tier_log` report -- the real,
-    `subdevice` only affects the *href* stamped onto each BoundEntity (via
+    subscribable/pollable path, not the canonical one.
-    `_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] = []
 

custom_components/localthings/registry/entities.py

@@ -19,6 +19,7 @@ WriteFn = Callable[[Any, dict], "tuple[list[str], dict] | None"] | None
 # cross-resource lookups exists_fn needs (e.g. reading a sibling href's live
 # option list).
 ValidateFn = Callable[[Any, dict, dict], "str | None"] | None
+DisplayFn = Callable[[Any, dict], Any] | None
 
 
 def _identity(v: Any) -> Any:
@@ -33,10 +34,10 @@ class SamsungEntityDescription:
     # here, so a descriptor only sets this to share one catalog entry across
     # several descriptors, or to point at a differently-named one.
     translation_key: Any = None  # str | Callable[[dict[str, dict]], Optional[str]]
-    # callable form receives the coordinator's full href->rep resource
+    # callable form receives the full href->rep snapshot and returns the key
-    # snapshot and returns the key to use -- for a descriptor shared across
+    # to use -- for a descriptor shared across board generations whose
-    # board generations whose state-code meaning isn't guaranteed consistent
+    # state-code meaning isn't consistent between them; see
-    # between them; see laundry.cycle_select's table-id-gated resolver.
+    # laundry.cycle_select's table-id-gated resolver.
     translation_placeholders: Mapping[str, str] | None = None
     # Dynamic resources such as fridge compartments and ice makers use a
     # device-provided or href-derived instance label inside a translated name.
@@ -59,11 +60,22 @@ class SensorDesc(SamsungEntityDescription):
     unit: str | None = None
     unit_fn: Callable[[dict], str] | None = None  # overrides `unit` from the live rep, when set
     options: tuple | None = None  # required by HA when device_class == 'enum'
-    # Opt-in: gate this sensor's reported value behind the user-configurable
+    # Opt-in: gate this value behind CONF_FINISH_TIME_HYSTERESIS_MINUTES
-    # CONF_FINISH_TIME_HYSTERESIS_MINUTES threshold (see sensor.py). Only for
+    # (see sensor.py). Only for values expected to jitter between
-    # values that are expected to jitter around their "true" value between
+    # device-side revisions -- not a general-purpose flag.
-    # device-side revisions -- not a general-purpose flag every sensor should set.
     hysteresis: bool = False
+    # Opt-in, entity-instance-only hold -- see sensor.py's _apply_sticky
+    # for the full contract (arm/value/bypass semantics, one window per
+    # bypass, why this never touches the coordinator cache).
+    # sticky_fn arms it; sticky_value_fn picks what to freeze at that
+    # moment (defaults to rep_fn's own result); sticky_bypass_fn drops the
+    # hold and lets rep_fn's own live result through; sticky_seconds
+    # bounds how long it can hold. There is deliberately no hook for
+    # computing a live value differently from rep_fn -- see issue #358.
+    sticky_fn: Callable[[dict], bool] | None = None
+    sticky_value_fn: Callable[[dict], Any] | None = None
+    sticky_bypass_fn: Callable[[dict], bool] | None = None
+    sticky_seconds: float = 300.0
 
 
 @dataclass(frozen=True, kw_only=True)
@@ -78,6 +90,10 @@ class SelectDesc(SamsungEntityDescription):
     # snapshot (not just this entity's own href) and returns raw device
     # option values; see select.py's LocalThingsSelect._raw_options().
     options_field: str | None = None  # resource field that contains the live options list
+    # Optional device-specific fallback for values absent from the translation
+    # catalog. Receives (raw_value, canonical_resources); select.py applies it
+    # identically to the current state and every option.
+    display_fn: DisplayFn = None
     write_fn: WriteFn = None
 
 
@@ -102,10 +118,9 @@ class NumberDesc(SamsungEntityDescription):
     native_min: float | None = None
     native_max: float | None = None
     step: float | None = None
-    # Override native_min/native_max/step from the live rep, when set --
+    # Override native_min/max/step from the live rep, when set -- same
-    # same "static default, live override" shape as unit_fn, for resources
+    # "static default, live override" shape as unit_fn, for resources whose
-    # whose sane bounds depend on a per-device value (e.g. a temperature
+    # bounds depend on a per-device value (e.g. Celsius vs. Fahrenheit).
-    # setpoint reported in Celsius on one device, Fahrenheit on another).
     native_min_fn: Callable[[dict], float] | None = None
     native_max_fn: Callable[[dict], float] | None = None
     step_fn: Callable[[dict], float] | None = None
@@ -120,27 +135,23 @@ class TimeDesc(SamsungEntityDescription):
 
 @dataclass(frozen=True, kw_only=True)
 class ClimateDesc(SamsungEntityDescription):
-    # A composite entity: it binds one *primary* resource (its href) but the
+    # Composite entity: binds one primary resource (its href) but the
-    # climate platform reads sibling resources (power, temperature, wind) from
+    # climate platform reads sibling resources from the coordinator
-    # the coordinator snapshot and writes to several of them. write_fn takes a
+    # snapshot and writes to several of them. write_fn takes a (kind,
-    # (kind, value) payload from the platform and returns the (path_segs, body)
+    # value) payload and returns the (path_segs, body) for that sub-write.
-    # for that one sub-write, so a single desc drives multi-resource writes.
     write_fn: WriteFn = None
 
 
 @dataclass(frozen=True, kw_only=True)
 class FanDesc(SamsungEntityDescription):
     # Composite fan entity: reads power from /power/0 and speed/support data
-    # from its bound href.  Payloads are (kind, value), like ClimateDesc.
+    # from its bound href. Payloads are (kind, value), like ClimateDesc.
     write_fn: WriteFn = None
 
 
 @dataclass(frozen=True, kw_only=True)
 class WaterHeaterDesc(SamsungEntityDescription):
-    # Composite water_heater entity: binds one primary resource (its href,
+    # Composite water_heater entity, same (kind, value) -> (path_segs,
-    # typically an operation-mode resource) but the water_heater platform
-    # reads sibling resources (power, temperature) from the coordinator
-    # snapshot and writes to several of them. Same (kind, value) -> (path_segs,
     # body) write_fn shape as ClimateDesc/FanDesc.
     write_fn: WriteFn = None
 

custom_components/localthings/registry/identity.py

@@ -13,6 +13,12 @@ class DeviceIdentity:
     model: str
     name: str
     serial: str | None
+    # /oic/d's `di` and /oic/p's `pi` -- OCF's own device and platform
+    # UUIDs. Promoted out of `raw` into named fields because
+    # resolve_device_key mints permanent registry keys from them; see its
+    # docstring for why `di` leads.
+    device_id: str | None = None
+    platform_id: str | None = None
     device_types: tuple[str, ...] = ()
     raw: dict[str, dict | list] = field(default_factory=dict)
 
@@ -22,24 +28,19 @@ def is_placeholder_serial(serial: str) -> bool:
 
     The ARTIK051_DONGLE_REF firmware family reports the literal string
     'Nothing(SVC)' for every unit -- non-empty, so a plain `if not serial`
-    check doesn't catch it, and the resolved serial feeds both the HA
+    check doesn't catch it, and two such units on the same install silently
-    device-registry identifier and every entity's unique_id (entity.py), so
+    collide, dropping the second one's entities (issue #83).
-    two such units on the same install silently collide and the second one's
-    entities get dropped (issue #83).
 
-    Issue #189: the DA_WM_A51_20_COMMON (ARTIK051) laundry board family
+    Issue #189: the DA_WM_A51_20_COMMON (ARTIK051) laundry family reports a
-    reports a flash-unset sentinel instead -- every character the same
+    flash-unset sentinel instead -- every character the same repeated hex
-    repeated hex digit (a washer and a dryer, two different physical units,
+    digit -- which the 'nothing' check doesn't catch either, aborting the
-    both reported the literal serialNum 'FFFFFFFFFFFFFFF') -- which the
+    second unit's config flow as already configured.
-    'nothing' check above doesn't catch either, so the second unit's config
-    flow aborted as already configured.
 
-    Lives here, rather than being duplicated in config_flow.py and
+    Lives here rather than duplicated in config_flow.py/coordinator.py: the
-    coordinator.py as it once was, because the config flow now resolves the
+    config flow resolves the serial once and persists it for the
-    serial once and persists it on the entry for the coordinator to seed its
+    coordinator to seed its registry keys from (issue #236), so two copies
-    registry keys from (issue #236). Two copies of this rule meant the two
+    of this rule could let the two sides disagree and orphan a registry
-    sides could disagree about what a device's identity is -- and a
+    entry.
-    disagreement is exactly what orphans a registry entry.
     """
     s = serial.strip()
     if s.lower().startswith("nothing"):
@@ -62,18 +63,72 @@ def resolve_serial(raw_serial: str | None, host: str) -> str:
     return s
 
 
+def is_usable_device_id(value: str | None) -> bool:
+    """True for an OCF `di`/`pi` that actually identifies one unit.
+
+    Rejects OCF's nil UUID, which firmware that never had one assigned
+    reports on every unit of the family -- the #189 failure mode on a new
+    field, and one `is_placeholder_serial`'s repeated-digit rule misses
+    because the dashes make more than one distinct character. Past that the
+    same known-junk rules apply: a board flashed with 'Nothing(SVC)' in one
+    identity field is not one to trust in another.
+    """
+    s = (value or "").strip()
+    if not s:
+        return False
+    if not set(s) - {"0", "-"}:
+        return False
+    return not is_placeholder_serial(s)
+
+
+def ocf_device_key(identity: DeviceIdentity | None) -> str | None:
+    """The OCF-derived half of resolve_device_key's chain, or None when the
+    device reported no usable UUID.
+
+    Split out because "no UUID" and "this UUID" are different answers to a
+    caller holding an existing key: the coordinator must never demote an
+    entry off its UUID just because one poll couldn't read /oic/d.
+    Normalized so firmware that changes case between reads doesn't look
+    like a different appliance.
+    """
+    if identity is None:
+        return None
+    for candidate in (identity.device_id, identity.platform_id):
+        if candidate is not None and is_usable_device_id(candidate):
+            return candidate.strip().lower()
+    return None
+
+
+def resolve_device_key(identity: DeviceIdentity | None, raw_serial: str | None, host: str) -> str:
+    """The identity to mint this device's permanent registry keys from.
+
+    Tried in order: /oic/d's `di`, /oic/p's `pi`, the serialNum, the host.
+
+    `di` leads because it is what the protocol already uses to address this
+    endpoint: if it were wrong or shared, OCF discovery and the DTLS
+    association would not work at all. serialNum is a vendor-populated
+    string nothing depends on, which is why three firmware families have
+    shipped it unusable -- 'Nothing(SVC)' (#83), a flash-unset sentinel
+    (#189), and a well-formed serial duplicated across every unit (#381).
+
+    `pi` is only the fallback despite the spec calling it immutable: it is
+    *platform*-scoped, so a board hosting several logical OCF devices
+    shares one across all of them. `di` is device-scoped, the granularity
+    of a config entry. The serial and host stay below both so a board
+    answering neither resource lands where it always did.
+    """
+    return ocf_device_key(identity) or resolve_serial(raw_serial, host)
+
+
 def resolve_model(model_num: str, identity: DeviceIdentity | None) -> str:
     """The model string to name and register a device under.
 
-    `model_num` is /information/vs/0's x.com.samsung.da.modelNum, which many
+    `model_num` is /information/vs/0's modelNum, which many boards report
-    boards report as `<model>|<board>` -- only the part before the pipe is the
+    as `<model>|<board>` -- only the part before the pipe is recognizable.
-    model a user would recognize. A board that reports no modelNum at all
+    A board reporting no modelNum falls back to /oic/p's mnmo. Shared with
-    falls back to /oic/p's mnmo, which read_identity already parsed.
+    resolve_serial's motivation: two copies of this split rule could let
-
+    the config flow and the coordinator's post-poll recompute disagree, and
-    Shared with resolve_serial's motivation: the config flow resolves this
+    a device renaming itself after the first poll is the visible symptom.
-    once and persists it on the entry, and the coordinator recomputes it after
-    the first poll. Two copies of the split rule would let those two disagree,
-    and a device that renames itself on the first poll is the visible symptom.
     """
     if model_num:
         return model_num.split("|", 1)[0]
@@ -81,13 +136,11 @@ def resolve_model(model_num: str, identity: DeviceIdentity | None) -> str:
 
 
 def device_display_name(device_type_name: str | None, model: str) -> str:
-    """The HA device name for a resolved device type + model.
+    """The HA device name for a resolved device type + model. Shared by the
-
+    config flow and the coordinator's post-discovery rebuild, so the name a
-    Shared by the config flow (which builds the entry's stored identity) and
+    device is first registered under matches what discovery produces later
-    the coordinator's post-discovery rebuild, so the name a device is first
+    -- otherwise every setup would rename the device once the first poll
-    registered under is the same string discovery would produce later --
+    landed."""
-    otherwise every setup would rename the device once the first poll landed.
-    """
     device_type = device_type_name.replace("_", " ").title() if device_type_name else "Appliance"
     return f"Samsung {device_type} ({model})" if model else f"Samsung {device_type}"
 
@@ -120,15 +173,13 @@ def _get_links(sess, path) -> list:
 def _device_types(d: dict) -> tuple[str, ...]:
     """/oic/d's `rt` -- the device's own OCF device-type declaration.
 
-    In OCF this is the one standardized "what am I" field: alongside the
+    The one standardized "what am I" field in OCF: alongside the generic
-    generic 'oic.wk.d' it carries a concrete type such as 'oic.d.airconditioner'
+    'oic.wk.d' it carries a concrete type like 'oic.d.airconditioner' or a
-    or a SmartThings 'x.com.st.d.*' equivalent. `registry/by_type/resolve()`
+    SmartThings 'x.com.st.d.*' equivalent. `registry/by_type/resolve()`
-    now consults this first, ahead of board-part-number parsing, via
+    consults this first, via `for_device_by_oic_type`, but only a minority
-    `for_device_by_oic_type` and its `_OIC_TYPE_TO_KEY` table -- but only a
+    of dumps populate it, so the modelNum/description path stays
-    minority of dumps populate it, so the modelNum/description path stays
+    load-bearing. Kept whole in diagnostics (see `raw` below) so issue
-    load-bearing for everything else. It's also kept whole in diagnostics
+    reports keep surfacing types the table doesn't know about yet.
-    (see `raw` below) so incoming issue reports keep surfacing types that
-    table doesn't know about yet.
     """
     rt = d.get("rt")
     if isinstance(rt, str):
@@ -142,26 +193,24 @@ def read_identity(sess, serial: str | None) -> DeviceIdentity:
     p = _get(sess, ["oic", "p"])
     d = _get(sess, ["oic", "d"])
     # /oic/res is OCF's baseline resource-discovery endpoint: a unicast
-    # RETRIEVE on it returns every Resource/Collection href this endpoint
+    # RETRIEVE returns every Resource/Collection href this endpoint hosts,
-    # hosts, not just the one /device/0 seed path the coordinator polls.
+    # not just /device/0. Relevant for the "Composite Device" model (issue
-    # Relevant for the OCF "Composite Device" model (issue #177: a single
+    # #177: one physical device exposing more than one logical subdevice,
-    # physical device -- one IP, one /oic/p -- exposing more than one logical
+    # each its own Collection). registry.subdevices.enumerate_subdevices
-    # subdevice, each as its own Collection resource, same rt shape as our own
+    # reads this to find a board's `/device/<n>` siblings -- that probing
-    # /device/0). This is what registry.subdevices.enumerate_subdevices reads
+    # used to run right here on every _connect_session/reconnect and moved
-    # to find a board's `/device/<n>` siblings (Pattern A -- the reporter's
+    # to that module so it only runs once, at first discovery.
-    # ARTIK051_DONGLE_FAC_18K) -- that probing, plus the /device/1 and
-    # /device/2 speculative fallback it used to run right here on every
-    # _connect_session (including every reconnect), moved to that module so
-    # it only runs once, at first discovery, instead of on every reconnect.
     res = _get_links(sess, ["oic", "res"])
     return DeviceIdentity(
         manufacturer=p.get("mnmn") or "Samsung",
         model=p.get("mnmo") or "",
         name=d.get("n") or "",
         serial=serial,
+        device_id=d.get("di") if isinstance(d.get("di"), str) else None,
+        platform_id=p.get("pi") if isinstance(p.get("pi"), str) else None,
         device_types=_device_types(d),
-        # Kept whole rather than field-by-field: these resources are outside
+        # Kept whole rather than field-by-field: outside the /device/0 dump
-        # the /device/0 dump diagnostics already captures, and we don't yet
+        # diagnostics already captures, and we don't yet know which fields
-        # know which of their fields will turn out to identify a device type.
+        # will turn out to identify a device type.
         raw={"/oic/p": p, "/oic/d": d, "/oic/res": res},
     )

custom_components/localthings/registry/redact.py

@@ -30,20 +30,18 @@ _SENSITIVE_SUBSTRINGS = (
     "secret",
 )
 
-# Matched whole, not as substrings. OCF's /oic/d and /oic/p identify the unit
+# Matched whole, not as substrings: these are bare one/two-letter keys too
-# with bare one- and two-letter keys that the rules above cannot see, being
+# short for the substring rules above ('n' is a substring of very nearly
-# far too short to match on -- 'di' alone is a substring of 'condition',
+# everything). 'n' is /oic/d's free-text device name, which the owner sets
-# 'display', 'dispenser' and plenty of other ordinary appliance fields:
+# from the SmartThings app and can carry a person's name -- the device-type
+# signal we actually want from that resource is `rt`, which is not redacted.
 #
-#   'di' -- device UUID, 'pi' -- platform UUID. As identifying as the serial
+# /oic/d's `di` and /oic/p's `pi` are deliberately not redacted: they're
-#           number above.
+# randomly-assigned per-unit UUIDs rather than account data, and they are
-#   'n'  -- /oic/d's device name. Free text the owner can set from the
+# what registry keys are minted from (issue #381), so blanking them hides
-#           SmartThings app, so it may well carry a person's name. Nothing
+# the identity every entity in a report is named after -- which is exactly
-#           in the /device/0 dump has ever exposed it; it only became
+# what made #381's first diagnostics download unable to answer it.
-#           reachable when diagnostics started reporting /oic/d, and the
+_SENSITIVE_EXACT = frozenset({"n"})
-#           device-type signal we actually want from that resource is `rt`,
-#           which is not redacted.
-_SENSITIVE_EXACT = frozenset({"di", "pi", "n"})
 
 
 def _is_sensitive_key(key: str) -> bool:

custom_components/localthings/registry/subdevices.py

@@ -1,96 +1,43 @@
-"""Subdevice ("composite device") support for one physical connection exposing
+"""Subdevice ("composite device") support for one physical connection
-more than one logical indoor subdevice -- issue #177.
+exposing more than one logical indoor subdevice -- issue #177.
 
-Two reporters, two different board families, two genuinely different
+Three discovery patterns, unified by the same shape: a logical subdevice is
-mechanisms for exposing a second indoor subdevice over one IP / one DTLS
+a seed collection path to poll, plus an href transform between the
-session (see DESIGN-177.md section 1 for the full evidence trail; the two
+canonical href the registry knows (e.g. `/mode/vs/0`) and the actual
-diagnostics dumps this was built against come from the Pattern A and
+on-the-wire href.
-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
+- **Pattern A -- indexed siblings** (`ARTIK051_DONGLE_FAC_18K`). `/oic/res`
-board). `/oic/res` lists three complete parallel resource sets whose
+  lists parallel resource sets by trailing index (`/mode/vs/0`,
-trailing path segment is the index (`/mode/vs/0`, `/mode/vs/1`,
+  `/mode/vs/1`, ...); each sibling has its own `/device/<n>` Collection.
-`/mode/vs/2`, ... on both OCF-standard and vendor hrefs), and `/device/0`'s
+- **Pattern B -- UUID-prefixed tree** (`TP2X_FAC_BORA_21K`). `/oic/res`
-batch carries only the index-0 hrefs -- the sibling subdevices are
+  hides the tree; `/subdevices/vs/0`'s `subdeviceIdList` gives the UUID.
-reachable only via their own `/device/<n>` collection.
+  `GET /<uuid>/device/0` is tried first; when it comes back empty (issue
+  #205 -- not even the reference board always exposes it), this falls back
+  to probing every href the master answered this cycle individually under
+  the UUID prefix (see `Subdevice.flat_hrefs`).
+- **Pattern C -- UUID prefix via `/oic/res` only** (`AWM-WW-AID-26-ONEBODY`
+  washer+dryer combo, issue #241). No `subdeviceIdList`, `/device/<n>`
+  404s; the sibling's UUID only appears as a link prefix in `/oic/res`
+  (e.g. the `x.com.samsung.da.multidevice` link) -- treated as Pattern B's
+  transform with the UUID sourced from there instead.
 
-Pattern B -- UUID-prefixed tree (`TP2X_FAC_BORA_21K`, that reporter's board).
+A non-empty seed batch is necessary but not sufficient for a candidate to
-`/oic/res` hides the whole appliance tree; `/device/0`'s batch instead
+be a real second subdevice: an unused SmartThings slot (e.g. the Pattern A
-carries `x.com.samsung.da.subdeviceIdList` on `/subdevices/vs/0`, and that
+reporter's own `/device/2`) answers the same shape with constant/echoed
-same UUID appears as a literal href prefix in `/oic/res`
+reps and no live state. Gating on resource shape would need per-family
-(`/<uuid>/file/list/vs/0`, ...). What's actually been confirmed live on
+domain knowledge, so `discover_partitioned` instead gates at the *entity*
-that reporter's unit is narrower than early issue #177 writeups suggested: a
+layer: a candidate is only materialized if it produces at least one live,
-single individual `GET /<uuid>/information/vs/0` was read by hand through
+non-`None`, primary (no `entity_category`), non-meter bound entity. The
-the debug panel and came back carrying a different model/serial than the
+meter exclusion (issue #214) covers a second failure mode: an unused slot
-master (`TP2X_FAC_BORA_RAC_21K`, the wall-mounted subdevice, vs. the
+reporting a populated whole-appliance energy counter, which is the
-master's `TP2X_FAC_BORA_21K`, the floor subdevice) -- real evidence a
+appliance's own bookkeeping, not evidence of a second indoor unit -- see
-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`.
-
-Pattern C -- UUID prefix advertised only via `/oic/res`
-(`AWM-WW-AID-26-ONEBODY` washer+dryer combo, issue #241). The board answers
-`numofsubdevice='2'` on `/multidevice/vs/0` but has no `/subdevices/vs/0`
-(no `subdeviceIdList`) and 4.04s `/device/1`/`/device/2`; the washer
-subdevice's UUID appears nowhere except as the path prefix of the
-`x.com.samsung.da.multidevice` link in `/oic/res`, and
-`GET /<uuid>/device/0` answers the washer's own full Collection batch
-(model `..._WF80H` vs. the master's `..._DV80H27H`) -- Pattern B's
-transform with the UUID sourced from the link prefix instead of
-`subdeviceIdList`.
-
-All of these are "the same thing wearing different clothes": a logical subdevice is a
-seed collection path to poll, plus an href transform between the canonical
-href the registry knows (`/mode/vs/0`) and the actual on-the-wire href. The
-detection signals don't overlap on either captured board (the Pattern A
-reporter's has no `/subdevices/vs/0` at all; the Pattern B reporter's has
-no `/device/1`), so no disambiguation logic is needed --
-`enumerate_subdevices` checks both and materializes any candidate whose
-seed answers with a non-empty batch.
-
-A non-empty seed batch is necessary but not sufficient for the *candidate*
-to actually be a live second subdevice, though: the Pattern A reporter's
-own board also has a `/device/2` -- a third, unused SmartThings slot --
-that answers with the exact same 14-href shape as the real `/device/1`
-sibling, populated with three constant/echoed/shape-only reps (a region
-code identical to every other subdevice's, an /information rep echoing the
-*same* model string as subdevice 1, and a /temperatures items[] entry with
-an id/description but no current/desired/minimum/maximum reading) and
-nothing resembling live climate state. Gating on *resource* shape/hrefs
-turned out to be the wrong layer -- it would need per-family domain
-knowledge (which hrefs mean "in use" for a washer's second drum, a
-fridge's second compartment, ...) baked into a registry field before any
-of those families could use this module at all. `discover_partitioned`
-instead gates at the *entity* layer, after discovery+flattening: a
-candidate is only kept if it produced at least one *primary* (no
-`entity_category`), non-meter bound entity whose flattened value isn't
-`None` -- e.g. the Pattern A reporter's /device/2 does flatten to an
-`alarm_code` value, but that entity is diagnostic-category and derived from
-an empty /alarms/vs/2, so it doesn't count. This reuses the same
-primary/config/diagnostic taxonomy every registry already declares (see the
-adding-device-support skill's entity-taxonomy section) instead of adding a
-second, parallel domain-knowledge mechanism.
-
-The meter carve-out is issue #214, and it's the same "an unused slot still
-answers *something*" problem one layer further in: that reporter's
-single-split ARTIK051_KRAC_18K has a /device/1 whose operational reps are
-all empty {} -- the /device/2 shape above -- but which also reports a
-populated /energy/consumption/vs/1, a whole-appliance lifetime kWh counter
-that materialized the slot as a phantom second air conditioner. See
 `_has_live_primary_entity`.
 """
 
 from __future__ import annotations
 
 import re
+import time
 from collections.abc import Callable, Sequence
 from dataclasses import dataclass
 
@@ -102,18 +49,15 @@ from .by_type._base import DeviceRegistry
 _INDEXED_HREF_RE = re.compile(r"^/device/(\d+)$")
 
 # A UUID as the first path segment of an /oic/res link href -- Pattern C's
-# discovery signal (issue #241): a subdevice tree whose UUID is advertised
+# discovery signal (issue #241).
-# nowhere except as this prefix (no subdeviceIdList, no /device/<n>).
 _UUID_PREFIX_RE = re.compile(r"^/([0-9a-fA-F]{8}(?:-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12})/")
 
 # Speculative /device/<n> siblings probed when /oic/res doesn't reveal a
-# second logical subdevice's Collection on this board (moved here from
+# second subdevice's Collection (moved here from identity.py, issue #177,
-# identity.py, issue #177 -- see enumerate_subdevices' docstring for why: the
+# since the old read_identity fired these on every _connect_session
-# old read_identity fired these two extra RETRIEVEs on *every* _connect_session,
+# including reconnects, when enumeration only needs to run once). A plain
-# including every reconnect, for information enumeration only needs once).
+# tolerated-404 RETRIEVE, not the kind of guess the write-contract
-# Same bound as before: a plain, tolerated-404 RETRIEVE, not the kind of
+# 'don't guess' rule is about. Widen only if a board needs more siblings.
-# 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)
 
 
@@ -122,22 +66,20 @@ class Subdevice:
     """One logical indoor subdevice reachable over a single physical
     connection.
 
-    `kind='main'` is the subdevice this config entry actually connects to and
+    `kind='main'` is the subdevice this config entry actually connects to
-    always exists (see MAIN below) -- its `to_actual`/`to_canonical` are the
+    and always exists (see MAIN below) -- its `to_actual`/`to_canonical`
-    identity transform, so every existing single-subdevice device keeps
+    are the identity transform, so a single-subdevice device behaves
-    behaving exactly as it did before this module existed. `'indexed'`/
+    exactly as before this module existed. `'indexed'`/`'prefixed'` are
-    `'prefixed'` are Pattern A/B above; `key` is the trailing index string
+    Pattern A/B above; `key` is the trailing index string ('1', '2', ...)
-    ('1', '2', ...) or the full subdevice UUID, and `seed_path` is the
+    or the full subdevice UUID, and `seed_path` is the Collection href (as
-    Collection href (as path segments) whose batch response
+    path segments) whose batch enumerates/refreshes that subdevice.
-    enumerates/refreshes that subdevice.
 
-    `flat_hrefs` is non-empty only for a 'prefixed' subdevice that doesn't
+    `flat_hrefs` is non-empty only for a 'prefixed' subdevice with no
-    expose its own Collection at `seed_path` (issue #205 -- not even
+    Collection at `seed_path` (issue #205). When set, `seed_path` is
-    TP2X_FAC_BORA_21K, the board this pattern was built against, always
+    meaningless (left as `()`) and this subdevice's state comes from
-    does). When set, `seed_path` is meaningless (left as `()`) and this
+    GETting each of these canonical hrefs individually under its prefix
-    subdevice's state comes from GETting each of these canonical hrefs
+    instead -- see enumerate_subdevices' fallback and
-    individually under its prefix instead of one Collection batch -- see
+    coordinator._poll_subdevice_seed.
-    enumerate_subdevices' fallback and coordinator._poll_subdevice_seed.
     """
 
     kind: str  # 'main' | 'indexed' | 'prefixed'
@@ -150,13 +92,11 @@ class Subdevice:
         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 --
+            # Only the index-0 trailing segment is ours to rewrite -- not a
-            # deliberately not a "replace any trailing digit" rule, which
+            # "replace any trailing digit" rule, which would misread a
-            # would misread a genuine multi-instance resource (the fridge's
+            # genuine multi-instance resource (e.g. the fridge's
-            # pattern-cap hrefs, e.g. '/door/vs/1') as a subdevice's. No
+            # '/door/vs/1') as a subdevice's. No registry declares a
-            # registry declares a non-zero trailing index today and no
+            # non-zero trailing index today.
-            # 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
@@ -179,25 +119,24 @@ class Subdevice:
         return actual
 
     def owns(self, actual: str) -> bool:
-        """True if `actual` belongs to this subdevice's namespace. MAIN never
+        """True if `actual` belongs to this subdevice's namespace. MAIN
-        "owns" anything by this definition -- it gets whatever's left after
+        never "owns" anything by this definition -- it gets whatever's
-        every other subdevice's hrefs are excluded (see canonical_view)."""
+        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
+        """Prefix guaranteeing a unique entity key/unique_id (see
-        adapter._key). '' for MAIN -- the master's flattened state
+        adapter._key). '' for MAIN, so the master's flattened state keys
-        keys must stay byte-identical to every device this integration
+        stay byte-identical to every device shipped before issue #177. The
-        shipped before issue #177, so no golden file changes. The full
+        full subdevice UUID is used verbatim (non-alphanumerics stripped)
-        subdevice UUID is used verbatim (non-alphanumerics stripped, not
+        rather than an enumeration-order ordinal, since it's device-reported
-        truncated or replaced with an ordinal) because it's device-reported
+        and stable across reconnects; it never appears in a user-visible
-        and stable across reconnects/restarts, unlike an ordinal assigned by
+        string, since HA derives entity_id from device+entity name, not
-        enumeration order -- and it never appears in a user-visible string
+        unique_id.
-        (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}_"
@@ -219,16 +158,15 @@ def canonical_view(
     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
+    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`
+    other subdevices in `subdevices` -- otherwise a sibling's own
-    would leak into the master's view under the same canonical key
+    `/mode/vs/1` would leak into the master's view under the canonical key
-    ('/mode/vs/0') that the master's actual `/mode/vs/0` also maps to,
+    ('/mode/vs/0') the master's own resource also maps to. For an
-    silently mixing two subdevices' state together. For an indexed/prefixed
+    indexed/prefixed subdevice it's the reverse: only the hrefs that
-    subdevice it's the reverse: only the hrefs that subdevice owns, rewritten
+    subdevice owns, rewritten back through `to_canonical`.
-    back through `to_canonical`.
 
-    `subdevices` may or may not include MAIN itself -- MAIN.owns() is always
+    `subdevices` may or may not include MAIN itself -- MAIN.owns() is
-    False, so including it is harmless.
+    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)}
@@ -245,11 +183,9 @@ def normalize_seed_batch(subdevice: Subdevice, batch: dict[str, dict]) -> dict[s
     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
+    href in its own `/device/<n>` batch. A prefixed subdevice's batch
-    reporter's dump). A prefixed subdevice's batch entries may or may not
+    entries may or may not already carry the `/<id>` prefix (unconfirmed),
-    already carry the `/<id>` prefix (unconfirmed which -- the Pattern B
+    so it's added when missing.
-    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
@@ -265,9 +201,8 @@ def _iter_oic_res_hrefs(oic_res):
 
     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
+    handled here. Tolerant of a flat link-list too, and of anything else by
-    rules it out, and _get_links' own posture already treats any list-shaped
+    yielding nothing.
-    body as possible) and of anything else by yielding nothing.
     """
     for entry in oic_res or []:
         if not isinstance(entry, dict):
@@ -287,13 +222,12 @@ def _seed_href(path_segs: tuple[str, ...]) -> str:
     return "/" + "/".join(path_segs)
 
 
-def _get_raw(sess, path_segs: tuple[str, ...]):
+def _get_raw(sess, path_segs: tuple[str, ...], timeout: float = 10.0):
     """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
+    shared tolerated-absence posture for both callers below."""
-    only in which body shape they accept."""
     try:
-        code, pl = sess.get(list(path_segs), timeout=10.0)
+        code, pl = sess.get(list(path_segs), timeout=timeout)
         if code == 0x45 and pl:
             return cbor2.loads(pl)
     except Exception:
@@ -301,21 +235,29 @@ def _get_raw(sess, path_segs: tuple[str, ...]):
     return None
 
 
-def _get_batch(sess, path_segs: tuple[str, ...]) -> dict[str, dict]:
+def _get_batch(
+    sess,
+    path_segs: tuple[str, ...],
+    timeout: float = 10.0,
+) -> 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)
+    body = _get_raw(sess, path_segs, timeout)
     return parse_device0_batch(body) if isinstance(body, list) else {}
 
 
-def _get_property(sess, path_segs: tuple[str, ...]) -> dict:
+def _get_property(
+    sess,
+    path_segs: tuple[str, ...],
+    timeout: float = 10.0,
+) -> 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)
+    body = _get_raw(sess, path_segs, timeout)
     return body if isinstance(body, dict) else {}
 
 
@@ -324,40 +266,69 @@ def enumerate_subdevices(
     resources: dict[str, dict],
     oic_res_links,
     probe_log: Callable[[str, bool], None] | None = None,
+    *,
+    preferred_hrefs: Sequence[str] = (),
+    time_budget: float | None = None,
+    collection_timeout: float = 10.0,
+    property_timeout: float = 10.0,
 ) -> 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
+    session lock -- every GET here is a plain RETRIEVE. Returns the
-    'don't guess' rule doesn't apply to reading an extra resource to find
+    *candidate* subdevices and the resources already fetched while probing
-    out whether it's there). Returns the *candidate* subdevices and the resources
+    them (normalized to real hrefs), so the coordinator's first discovery
-    already fetched while probing them (already normalized to real hrefs),
+    poll doesn't need to re-poll them.
-    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
+    `probe_log(seed_href, found)` fires for every seed attempted, whether
-    not it answered -- so diagnostics (see diagnostics.py's subdevice_probes)
+    or not it answered, so diagnostics can tell "checked, nothing there"
-    can tell "checked, nothing there" apart from "never checked", the same
+    apart from "never checked".
-    posture the speculative-probe code this replaces used to document in
+
-    identity.py.
+    `preferred_hrefs` only changes the order of the flat Property fallback;
+    it never filters the device's resource surface. When `time_budget` is
+    supplied, probes are bounded by one shared monotonic deadline and this
+    returns every candidate/resource confirmed before it. This makes first
+    setup finite even when firmware silently drops unknown paths instead of
+    returning 4.04.
 
     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
+    here -- this function can't tell a real sibling from an unused
-    SmartThings slot that merely answers the same shape (the Pattern A
+    SmartThings slot that answers the same shape; that requires
-    reporter's `/device/2`); that requires discovering+flattening the
+    discovering+flattening the candidate's own entities first, which is
-    candidate's own entities first, which is `discover_partitioned`'s job,
+    `discover_partitioned`'s job. See this module's docstring.
-    not this one's.
-    See this module's docstring.
     """
     subdevices: list[Subdevice] = []
     fetched: dict[str, dict] = {}
     # Case-insensitive -- the same UUID can reach here once from
     # subdeviceIdList and once from an /oic/res link prefix with different
-    # casing (Samsung's own fields disagree on this elsewhere too, e.g. the
+    # casing, and probing it twice would materialize the same physical
-    # redaction-prone subdeviceIdList handling below), and probing it twice
+    # subdevice as two Subdevice candidates.
-    # would materialize the same physical subdevice as two Subdevice
-    # candidates under two different keys.
     probed_ids: set[str] = set()
+    deadline = time.monotonic() + max(0.0, time_budget) if time_budget is not None else None
+    budget_exhausted = False
+
+    def _next_timeout(maximum: float) -> float | None:
+        """Clamp one probe to the remaining enumeration wall-clock budget."""
+        nonlocal budget_exhausted
+        if deadline is None:
+            return maximum
+        remaining = deadline - time.monotonic()
+        if remaining <= 0:
+            budget_exhausted = True
+            return None
+        return min(maximum, remaining)
+
+    def _flat_probe_hrefs():
+        """Preferred live-state hrefs first, then every remaining master href."""
+        seen = set()
+        for href in preferred_hrefs:
+            if href in resources and href not in seen:
+                seen.add(href)
+                yield href
+        for href in sorted(resources):
+            if href not in seen:
+                yield href
 
     def _probed(seed_href: str, batch: dict) -> None:
         if probe_log is not None:
@@ -372,44 +343,45 @@ def enumerate_subdevices(
             return
         probed_ids.add(sub_id.lower())
         seed = (sub_id, "device", "0")
-        batch = _get_batch(sess, seed)
+        timeout = _next_timeout(collection_timeout)
+        if timeout is None:
+            return
+        batch = _get_batch(sess, seed, timeout)
         _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)
             return
-        # Fallback (issue #205): TP2X_FAC_BORA_21K itself -- the board this
+        # Fallback (issue #205): even the reference TP2X_FAC_BORA_21K board
-        # pattern was built against -- turns out not to always expose its own
+        # doesn't always expose its own `/<uuid>/device/0` Collection. With
-        # `/<uuid>/device/0` Collection either, so "every prefixed subdevice
+        # no Collection to seed from and no per-UUID entry in /oic/res to
-        # 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
+        # this UUID's prefix, and keep whichever ones answer before the
-        # plain tolerated-404 RETRIEVE, same posture as every other probe in
+        # optional enumeration deadline. Each is a plain tolerated-404
-        # this function.
+        # RETRIEVE, same posture as every other probe in this function.
         #
-        # Known gap, not yet guarded against: a firmware that answers *any*
+        # Known gap: a firmware that echoes the master's own state back
-        # request under an unrecognized prefix (echoing the master's own
+        # under an unrecognized prefix, rather than 4.04ing, would pass
-        # state back rather than 4.04ing) would pass every one of these
+        # every probe here and could materialize a phantom duplicate. Every
-        # probes and, if the echoed state also clears discover_partitioned's
+        # board seen so far genuinely 4.04s on paths it doesn't own (issue
-        # liveness gate, materialize a phantom duplicate of the master
+        # #205's unit answered only 1 of 31 probes), so this hasn't been
-        # rather than a real sibling. Every board seen so far genuinely
+        # guarded against -- the fix would compare a candidate's confirmed
-        # 4.04s on paths it doesn't own (issue #205's own unit answered only
+        # reps against the master's own values for the same hrefs.
-        # 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):
+        for href in _flat_probe_hrefs():
             if not first:
                 sess.pace()
             first = False
+            timeout = _next_timeout(property_timeout)
+            if timeout is None:
+                break
             actual = f"/{sub_id}{href}"
-            rep = _get_property(sess, tuple(actual.strip("/").split("/")))
+            rep = _get_property(sess, tuple(actual.strip("/").split("/")), timeout)
             _probed(actual, rep)
             if rep:
                 flat_hrefs.append(href)
@@ -427,45 +399,44 @@ def enumerate_subdevices(
 
     # --- 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
+    # Tolerate anything but a list of strings -- this field is
-    # (it matches the 'deviceid' substring rule in redact.py) and the existing
+    # redaction-prone (matches redact.py's 'deviceid' rule) and a shipped
-    # airconditioner_fac_bora fixture carries the literal string
+    # fixture carries the literal string 'REDACTED' there. That must yield
-    # '**REDACTED**'/'REDACTED' there. That must yield zero subdevices, not a
+    # zero subdevices, not a crash -- issue #177 is additive and must never
-    # crash -- issue #177 is additive, it must never break an already-working
+    # break an already-working single-climate-entity device.
-    # single-climate-entity device.
     ids = raw_ids if isinstance(raw_ids, list) else []
     listed = sorted(i for i in ids if isinstance(i, str) and i)
     for sub_id in listed:
         _probe_prefixed(sub_id)
+        if budget_exhausted:
+            break
 
     # --- Pattern C: UUID prefix advertised only via /oic/res ----------------
-    # (AWM-WW-AID-26-ONEBODY washer+dryer combo, issue #241.) A third
+    # (AWM-WW-AID-26-ONEBODY washer+dryer combo, issue #241.) No
-    # multidevice shape: the board answers numofsubdevice='2' on
+    # /subdevices/vs/0 and /device/<n> 404s; the only trace of the sibling
-    # /multidevice/vs/0, but carries no /subdevices/vs/0 (no subdeviceIdList
+    # is a UUID-prefixed link in /oic/res (the x.com.samsung.da.multidevice
-    # -- Pattern B's signal) and 4.04s /device/1 and /device/2 (Pattern A's).
+    # link). Its own tree answers a full Collection at /<uuid>/device/0,
-    # The only trace of the sibling is a UUID-prefixed link in /oic/res
+    # exactly Pattern B's transform, so a UUID prefix attached to that
-    # itself: the x.com.samsung.da.multidevice link,
+    # resource type is treated as a candidate. Other UUID-prefixed links are
-    # '/<uuid>/multidevice/vs/0' on the reporting board. Its washer tree
+    # not evidence of a sibling: some single-unit AC boards advertise only
-    # answers a full Collection at /<uuid>/device/0, exactly Pattern B's
+    # per-prefix file-transfer resources, and probing those prefixes against
-    # transform -- so treat every UUID path prefix seen in /oic/res as a
+    # every master href needlessly burns the setup timeout budget.
-    # prefixed-subdevice candidate. Probing is the same tolerated-404
+    # _probe_prefixed's probed_ids
-    # RETRIEVE as everything else here, and discover_partitioned's
+    # guard (not a set difference against `listed`) is what keeps an id
-    # entity-level liveness gate still decides materialization, so a board
+    # already named by subdeviceIdList from being probed twice, since the
-    # that advertises a UUID link without a live sibling behind it
+    # two sources can disagree on case.
-    # contributes nothing. _probe_prefixed's probed_ids guard -- not a set
-    # difference against `listed` here -- is what keeps an id already named
-    # by subdeviceIdList from being probed and materialized a second time,
-    # since the two sources can disagree on that UUID's case.
     linked = sorted(
         {
             m.group(1)
             for link in _iter_oic_res_hrefs(oic_res_links)
             for m in [_UUID_PREFIX_RE.match(link.get("href", ""))]
-            if m
+            if m and "x.com.samsung.da.multidevice" in (link.get("rt") or ())
         }
     )
     for sub_id in linked:
         _probe_prefixed(sub_id)
+        if budget_exhausted:
+            break
 
     # --- Pattern A: indexed siblings (ARTIK051_DONGLE_FAC_18K) --------------
     indices = sorted(
@@ -477,14 +448,16 @@ def enumerate_subdevices(
         }
     )
     if not indices:
-        # A board that hides its whole tree from /oic/res (Pattern B's
+        # A board that hides its whole tree from /oic/res gives us nothing
-        # reporter board does this too, but it has no /device/<n> to find
+        # to enumerate from -- fall back to the bounded speculative probe
-        # regardless) gives us nothing to enumerate from -- fall back to the
+        # this replaces from identity.py.
-        # bounded speculative probe this replaces from identity.py.
         indices = list(_SPECULATIVE_DEVICE_INDICES)
     for n in indices:
+        timeout = _next_timeout(collection_timeout)
+        if timeout is None:
+            break
         seed = ("device", str(n))
-        batch = _get_batch(sess, seed)
+        batch = _get_batch(sess, seed, timeout)
         _probed(_seed_href(seed), batch)
         if not batch:
             continue
@@ -506,33 +479,33 @@ def enumerate_subdevices(
     # 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)
+    timeout = _next_timeout(property_timeout)
-    _probed(_seed_href(multidevice_seed), multidevice)
+    if timeout is not None:
-    if multidevice:
+        multidevice = _get_property(sess, multidevice_seed, timeout)
-        fetched["/multidevice/vs/0"] = multidevice
+        _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
+    """A candidate `enumerate_subdevices` found whose seed answered, but
-    `discover_partitioned`'s entity-level liveness gate rejected -- an
+    that `discover_partitioned`'s entity-level liveness gate rejected -- an
-    unused SmartThings slot (the Pattern A reporter's `/device/2`), not a
+    unused SmartThings slot, not a real second subdevice. Kept around so a
-    real second subdevice. Kept around (rather than silently dropped) so a
     caller can log/report what was skipped and why."""
 
     subdevice: Subdevice
     hrefs: tuple[str, ...]
 
 
-# Sensor kinds whose value is a running total the *appliance* keeps rather
+# Sensor kinds whose value is a running total the appliance keeps rather
 # than a reading of the subdevice's own hardware -- excluded from the
-# liveness gate below (issue #214). HA's own running-total state classes
+# liveness gate below (issue #214). HA's running-total state classes cover
-# cover most of them; the consumption device classes catch the rest, since a
+# most of them; the consumption device classes catch the rest (a descriptor
-# descriptor may deliberately declare no state_class (common.ENERGY_METER's
+# may deliberately declare no state_class, e.g. common.ENERGY_METER's
-# monthly totals reset at each billing boundary, so they aren't
+# monthly totals that reset at each billing boundary).
-# `total_increasing`).
 _METER_STATE_CLASSES = frozenset({"total", "total_increasing"})
 _METER_DEVICE_CLASSES = frozenset({"energy", "water", "gas"})
 
@@ -549,35 +522,26 @@ def _is_meter(desc) -> bool:
 
 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 --
+    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"
+    (`entity_category` unset) that isn't a cumulative meter (`_is_meter`).
-    tier (see the adding-device-support skill's entity-taxonomy section) --
-    that isn't a cumulative meter (`_is_meter`).
 
     This is the materialization gate itself (see this module's docstring).
-    Two exclusions, both for the same reason -- the question this answers is
+    Two exclusions, both because the question this answers is "is a
-    "is a physical subdevice installed at this slot?", and neither kind of
+    physical subdevice installed at this slot?", and neither kind of value
-    value can speak to it:
+    can speak to it:
 
-    - **Non-primary entities.** The Pattern A reporter's `/device/2` does
+    - **Non-primary entities.** An unused slot can still flatten to a
-      flatten to one non-`None` value (`alarm_code`), but that entity is
+      diagnostic-category value derived from an empty resource (e.g. a
-      `diagnostic`-category and derived from an empty `/alarms/vs/2` -- a
+      formatted `alarm_code` off an empty `/alarms/vs/2`) -- that proves
-      config/diagnostic entity reading "something" proves nothing about
+      nothing about whether hardware is there.
-      whether hardware is there.
+    - **Cumulative meters** (issue #214). An unused slot has been seen
-    - **Cumulative meters** (issue #214). An unused slot on the issue #214
+      reporting a populated whole-appliance `cumulativePower` while every
-      reporter's ARTIK051_KRAC_18K reports `/energy/consumption/vs/1` with a
+      operational rep on it is empty `{}`. A single-split AC has one
-      populated `cumulativePower` while every operational rep on it
+      compressor and one energy meter, so a whole-appliance total showing
-      (`/power/1`, `/mode/1`, `/mode/vs/1`, `/temperature/current/1`,
+      up under a second index is the appliance's own bookkeeping, not
-      `/temperature/desired/1`, `/airflow/1`, `/humidity/1`) is empty `{}` --
+      evidence of a second indoor unit. A genuinely installed subdevice
-      i.e. exactly the Pattern A `/device/2` shape plus a lifetime kWh
+      reports its own operational state too, and that is what still passes
-      counter. That counter got the slot materialized as a phantom second
+      this gate.
-      air conditioner. A single-split AC has one compressor and one energy
-      meter, so a whole-appliance total showing up under a second index is
-      the appliance's own bookkeeping, not evidence of a second indoor unit.
-      A genuinely installed subdevice reports its own operational state too
-      (the Pattern A reporter's real `/device/1` reports power, mode, both
-      temperatures and airflow), and that state is what still passes this
-      gate.
     """
     from .adapter import _key  # see discover_partitioned's deferred-import note
 
@@ -596,64 +560,53 @@ def discover_partitioned(
     tier_log: Callable[[str, str], None] | None = None,
     oic_device_types: Sequence[str] = (),
 ):
-    """Bind every href in `resources` (the merged, real-href snapshot -- main
+    """Bind every href in `resources` (the merged, real-href snapshot --
-    plus every enumerated subdevice's seed) to entities, partitioned by which
+    main plus every enumerated subdevice's seed) to entities, partitioned
-    subdevice owns it.
+    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
+    `/mode/vs/1` would land in `unbound_hrefs` too and raise a spurious
-    device's registry claims that literal href) and raise a spurious
+    coverage-gap repair. Then one pass per candidate subdevice over its own
-    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
+    `/information/vs/0` when it reports one, falling back to the master's
-    wall subdevice reports `TP2X_FAC_BORA_RAC_21K` -> the 'RAC' board token ->
+    registry otherwise -- a sibling that fails to answer its own identity
-    airconditioner), falling back to the master's registry otherwise --
+    resource is still treated as the same appliance type as the master.
-    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
+    Each candidate is discovered and flattened twice: once silently to
-    evaluate `_has_live_primary_entity` (this module's materialization
+    evaluate `_has_live_primary_entity`, and, only if that passes, a second
-    gate -- see its docstring and this module's own), and, only if that
+    time with `log`/`tier_log` wired so its coverage gaps and poll tiers
-    passes, a second time with `log`/`tier_log` wired so its coverage gaps
+    actually count. A candidate that fails the gate contributes nothing at
-    and poll tiers actually count. A candidate that fails the gate
+    all, as if it had never answered its seed.
-    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.
 
-    `oic_device_types` (from the master's own `/oic/d`, see
+    `oic_device_types` (from the master's own `/oic/d`) is passed only to
-    registry/identity.py) is passed only to the *master's* resolution --
+    the master's resolution -- subdevices resolve from their own
-    subdevices have no `/oic/d` of their own read today (they resolve from
+    `/information/vs/0` or fall back to the master's whole registry, and
-    their own `/information/vs/0` or fall back to the master's whole
+    blindly applying the master's OCF device type to every subdevice would
-    registry, as documented above), and blindly applying the master's OCF
+    be wrong the moment a composite appliance pairs two different device
-    device type to every subdevice's own model-based resolution would be
+    types under one connection.
-    wrong the moment a composite appliance ever pairs two genuinely
-    different device types under one connection.
 
     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
+    - `device_type_name`: the master's resolved device type (used for
-      logging/device naming; each subdevice's own resolved type only affects
+      logging/device naming; each subdevice's own resolved type only
-      which capabilities bind its hrefs, not this).
+      affects which capabilities bind its hrefs).
-    - `materialized`: the subset of `subdevices` that passed the gate, in the
+    - `materialized`: the subset of `subdevices` that passed the gate, in
-      same order -- what the caller should keep as its live subdevice roster
+      the same order -- what the caller should keep as its live subdevice
-      going forward (poll seeds, canonical_resources, device_info_for, ...).
+      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
+    # Deferred import: discovery.py imports Subdevice/MAIN from this module
-    # module scope, so importing discover() back here at module scope would
+    # at module scope, so importing discover() back here at module scope
-    # be a circular import. By the time this function actually runs both
+    # would be circular. By the time this function runs both modules are
-    # modules are fully loaded. adapter.py imports discovery.py, so the same
+    # fully loaded; adapter.py imports discovery.py, so the same applies to
-    # applies to flatten()/_key().
+    # flatten()/_key().
     from .adapter import flatten
     from .discovery import discover
 
-    # Same computation canonical_view does for MAIN (snapshot minus every
+    # Same computation canonical_view does for MAIN -- reuse it rather than
-    # other subdevice's owned hrefs) -- reuse it rather than re-deriving
+    # re-deriving owned_elsewhere here too.
-    # owned_elsewhere here too.
     main_view = canonical_view(MAIN, resources, subdevices)
 
     reg = resolve_registry(main_view, device_types=oic_device_types)

custom_components/localthings/rekey.py

@@ -0,0 +1,90 @@
+"""Move an entry's registry entries from one device key to another.
+
+The key (registry.identity.resolve_device_key) is permanent in three
+places, so changing it means rewriting the registries rather than storing
+a new value -- anything left behind is orphaned. Rewriting rather than
+recreating is what keeps an entity's entity_id, and with it its history,
+area and automations.
+
+Its own module because both callers need it: the v1 -> v2 migration in
+__init__.py and the coordinator's first-poll adoption (issue #381).
+"""
+
+from __future__ import annotations
+
+import logging
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import device_registry as dr
+from homeassistant.helpers import entity_registry as er
+
+from .const import DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+
+@callback
+def rekey_entry(hass: HomeAssistant, entry: ConfigEntry, old_key: str, new_key: str) -> None:
+    """Rewrite everything this entry registered under `old_key` to `new_key`.
+
+    All three permanent places move together: entity unique_ids
+    (f"{DOMAIN}_{key}_{state_key}"), device identifiers ((DOMAIN, key), plus
+    (DOMAIN, f"{key}_{subdevice}") per subdevice -- see device_info_for),
+    and the entry's own unique_id. Leaving that last one behind would let
+    the config flow's duplicate check wave through a re-add of this very
+    appliance.
+
+    Idempotent, so it is safe to attempt on every poll rather than tracking
+    whether it has run. Where both keys already exist the `old_key` copy is
+    the dead one, so it is removed rather than rewritten over the live entry.
+
+    Must run on the event loop; the registry helpers require it.
+    """
+    if old_key == new_key:
+        return
+
+    new_entry_unique_id = f"{DOMAIN}_{new_key}"
+    if entry.unique_id != new_entry_unique_id:
+        hass.config_entries.async_update_entry(entry, unique_id=new_entry_unique_id)
+
+    ent_reg = er.async_get(hass)
+    stale_prefix = f"{DOMAIN}_{old_key}_"
+    for entity in list(er.async_entries_for_config_entry(ent_reg, entry.entry_id)):
+        if not entity.unique_id.startswith(stale_prefix):
+            continue
+        new_unique_id = f"{DOMAIN}_{new_key}_{entity.unique_id[len(stale_prefix) :]}"
+        if ent_reg.async_get_entity_id(entity.domain, DOMAIN, new_unique_id):
+            _LOGGER.debug("removing orphaned entity %s", entity.entity_id)
+            ent_reg.async_remove(entity.entity_id)
+        else:
+            _LOGGER.debug("re-keying entity %s to %s", entity.entity_id, new_unique_id)
+            ent_reg.async_update_entity(entity.entity_id, new_unique_id=new_unique_id)
+
+    dev_reg = dr.async_get(hass)
+    for device in list(dr.async_entries_for_config_entry(dev_reg, entry.entry_id)):
+        stale = {
+            ident
+            for ident in device.identifiers
+            if ident[0] == DOMAIN and (ident[1] == old_key or ident[1].startswith(f"{old_key}_"))
+        }
+        if not stale:
+            continue
+        fresh = {(DOMAIN, f"{new_key}{ident[1][len(old_key) :]}") for ident in stale}
+        existing = dev_reg.async_get_device(identifiers=fresh)
+        if existing is not None and existing.id != device.id:
+            # Removing a device takes its entities with it. Anything still
+            # attached here was re-keyed rather than removed above -- the
+            # surviving copy, not a duplicate -- so move it onto the device
+            # it now belongs to before the removal destroys it too.
+            for entity in er.async_entries_for_device(
+                ent_reg, device.id, include_disabled_entities=True
+            ):
+                ent_reg.async_update_entity(entity.entity_id, device_id=existing.id)
+            _LOGGER.debug("removing orphaned device %s", device.id)
+            dev_reg.async_remove_device(device.id)
+        else:
+            _LOGGER.debug("re-keying device %s to %s", device.id, fresh)
+            dev_reg.async_update_device(
+                device.id, new_identifiers=(device.identifiers - stale) | fresh
+            )

custom_components/localthings/select.py

@@ -49,40 +49,39 @@ def _translation_state(value: str, known: frozenset[str]) -> str | None:
     return snake if snake in known else None
 
 
-def _display(value, translation_key: str | None):
+def _display(value, translation_key: str | None, fallback_fn=None):
     """Turn a raw device option/state value into what's shown in the UI.
 
-    `translation_key` is the entity's already-resolved key (SelectDesc.
+    `translation_key` is the entity's already-resolved key (it can itself
-    translation_key can itself be a callable -- see entities.py -- so
+    be a callable -- see entities.py -- so callers pass the resolved
-    callers pass the resolved value, e.g. self.translation_key, not
+    value, not the raw descriptor field).
-    the raw descriptor field).
 
     An entity with a translation_key looks its state up in the shipped
-    translation catalog, whose state keys are lowercase -- so those values
+    translation catalog, whose state keys are lowercase, and the device
-    must be lowercased exactly to match, and the device still expects
+    still expects that same raw casing back on write (mapped back via
-    that same raw casing back on write (callers map the displayed value
+    _raw_options()). Everything else has no catalog lookup, so there's no
-    back to raw via _raw_options()).
+    reason to destroy the device's own casing: only two cosmetic fixups
-
+    apply, title-casing a fully lowercase token ("voice") and spacing a
-    Everything else has no catalog lookup, so there's no reason to
+    PascalCase one ("ExtraHigh" -> "Extra High"); an already-friendly value
-    destroy the device's own casing. Only two cosmetic fixups apply: a
+    ("AI Wash") matches neither and passes through unchanged.
-    fully lowercase device-native token (e.g. "voice") is title-cased,
-    and a PascalCase token (e.g. "ExtraHigh") gets a space inserted at
-    the case boundary ("Extra High"). A value that's already
-    human-friendly (e.g. "AI Wash") matches neither pattern and passes
-    through unchanged.
     """
     if not isinstance(value, str):
         return value
-    if translation_key:
+    known = translated_states("select", translation_key) if translation_key else frozenset()
-        known = translated_states("select", translation_key)
+    if translated := _translation_state(value, known):
-        if not known:
+        return translated
-            # No state table for this key: either the entity isn't translated
+    if fallback_fn is not None and (fallback := fallback_fn(value)) is not None:
-            # at all, or its name is translated but its options deliberately
+        return fallback
-            # aren't (an unrecognized course table, say). Either way the
+    if translation_key and not known:
-            # opaque device value is the best thing to show.
+        # No state table for this key: either the entity isn't translated at
-            return value
+        # all, or its name is translated but its options deliberately aren't
-        if translated := _translation_state(value, known):
+        # (an unrecognized course table, say). Nothing named this value, so
-            return translated
+        # the raw device value is the best choice -- the cosmetic reshaping
+        # below would only mangle an opaque code, turning a course '0E' into
+        # '0 E'. Reached only when the fallback *declined* the value, not
+        # merely when none was supplied: cycle_select always supplies one now
+        # (it labels cloud programs) and returns None for everything else.
+        return value
     if value.islower():
         return value.replace("_", " ").title()
     return _CAMEL_BOUNDARY_RE.sub(" ", value)
@@ -93,18 +92,25 @@ class LocalThingsSelect(LocalThingsEntity, SelectEntity):
         super().__init__(coordinator, bound)
         desc = cast(SelectDesc, bound.desc)
         if not desc.options_field and not callable(desc.options):
-            self._attr_options = [_display(o, self.translation_key) for o in desc.options]
+            self._attr_options = [self._display_option(o) for o in desc.options]
+
+    def _display_option(self, value):
+        """Normalize both current state and options through one path."""
+        display_fn = cast(SelectDesc, self._bound.desc).display_fn
+        fallback_fn = (
+            (lambda raw: display_fn(raw, self._resources)) if display_fn is not None else None
+        )
+        return _display(value, self.translation_key, fallback_fn)
 
     def _raw_options(self) -> list[str]:
         desc = cast(SelectDesc, self._bound.desc)
         if callable(desc.options):
             # Per-device option list computed from the full resource
-            # snapshot (not just this entity's own href) -- e.g. a course
+            # snapshot -- e.g. a course list decoded from a sibling
-            # list decoded from a sibling resource. There is no static
+            # resource. No static fallback: when unpopulated, the callable
-            # fallback: when that resource isn't populated the callable
+            # returns [] and exists_fn suppresses the entity entirely. Uses
-            # returns [] and the entity's exists_fn suppresses it entirely.
+            # this subdevice's canonical view (issue #177), not the raw
-            # This entity's own subdevice's canonical view (issue #177), not
+            # snapshot -- see LocalThingsEntity._resources.
-            # 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 {}
@@ -115,17 +121,17 @@ class LocalThingsSelect(LocalThingsEntity, SelectEntity):
     def options(self) -> list[str]:
         desc = cast(SelectDesc, self._bound.desc)
         if desc.options_field or callable(desc.options):
-            return [_display(o, self.translation_key) for o in self._raw_options()]
+            return [self._display_option(o) for o in self._raw_options()]
         return self._attr_options
 
     @property
     def current_option(self):
         raw = (self.coordinator.data or {}).get(self._state_key)
-        return _display(raw, self.translation_key)
+        return self._display_option(raw)
 
     async def async_select_option(self, option: str) -> None:
         raw = next(
-            (o for o in self._raw_options() if _display(o, self.translation_key) == option),
+            (o for o in self._raw_options() if self._display_option(o) == option),
             option,
         )
         await self.coordinator.async_send_command(self._bound, raw)

custom_components/localthings/sensor.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import time
 from datetime import timedelta
 from typing import cast
 
@@ -48,9 +49,12 @@ class LocalThingsSensor(LocalThingsEntity, SensorEntity):
             SensorDeviceClass(desc.device_class) if desc.device_class else None
         )
         self._attr_state_class = SensorStateClass(desc.state_class) if desc.state_class else None
-        if desc.options:
+        # Always set, so the `options` property below can read it unguarded.
-            self._attr_options = list(desc.options)
+        self._attr_options = list(desc.options) if desc.options else None
         self._hysteresis_value = None
+        self._sticky_value = None
+        self._sticky_until: float | None = None
+        self._sticky_spent = False
 
     @property
     def native_unit_of_measurement(self):
@@ -59,14 +63,86 @@ class LocalThingsSensor(LocalThingsEntity, SensorEntity):
             return desc.unit_fn(self.coordinator.resource(self._bound.href))
         return self._attr_native_unit_of_measurement
 
+    @property
+    def options(self):
+        """Declared options, plus whatever this device is actually reporting.
+
+        HA raises for an enum state outside `options`, which would turn any
+        device value we don't have a translation for into a broken entity --
+        the opposite of this registry's rule that an unrecognized value
+        renders raw. Admitting the live value keeps it displayable; it just
+        shows untranslated (PR #341 review).
+        """
+        if self._attr_options is None:
+            return None
+        value = self.native_value
+        if not isinstance(value, str) or value in self._attr_options:
+            return self._attr_options
+        return [*self._attr_options, value]
+
     @property
     def native_value(self):
         raw = (self.coordinator.data or {}).get(self._state_key)
         desc = cast(SensorDesc, self._bound.desc)
+        if desc.sticky_fn is not None:
+            raw = self._apply_sticky(raw, desc)
         if not desc.hysteresis:
             return raw
         return self._apply_hysteresis(raw)
 
+    def _apply_sticky(self, raw, desc: SensorDesc):
+        """Freeze this entity at a value for up to `desc.sticky_seconds`
+        after `desc.sticky_fn` next stops matching this href's live rep
+        (issue #345 -- see operational.py's `_just_finished` for the
+        motivating case). Entity-instance state only, exactly like
+        `_hysteresis_value` above -- never written back to the coordinator
+        cache, so write_fn, diagnostics, and the observe-mode sweep
+        comparison keep seeing real device data throughout.
+
+        `sticky_fn`/`sticky_bypass_fn` read this href's live rep rather
+        than the already-computed `raw`, so they can key on fields rep_fn
+        has collapsed away -- but they never compute a value. `raw` and
+        the frozen `sticky_value` are the only things returned here, so a
+        held entity and a free-running one agree on what "live" means; a
+        hook that broke that rule caused issue #358.
+
+        At most one window per `sticky_bypass_fn` cycle: arming marks the
+        hold spent, and only the bypass clears that. So a `sticky_fn` that
+        keeps matching (firmware leaving the field stuck -- the quirk
+        `_completion_minutes` works around) can't extend the window, and
+        one flapping in and out can't restart it either, before or after
+        expiry. Expiry alone doesn't re-open the door: without something
+        the calibre of "a new cycle is actually running" in between, a
+        second Finish is the same Finish, and re-arming on it would strobe
+        the entity between held and live once per window -- exactly the
+        repeated announcements #345 and #358 are about.
+
+        `sticky_bypass_fn` drops the hold and returns `raw`, for when "not
+        sticky right now" is ambiguous between "went idle, honor the hold"
+        and "genuinely moved on to new data". It is both the early release
+        and the only re-arm, so it should demand positive evidence of that
+        move; when unsure, letting the window run out is the cheaper
+        mistake.
+        """
+        assert desc.sticky_fn is not None  # native_value only calls this when set
+        rep = self.coordinator.resource(self._bound.href)
+        now = time.monotonic()
+
+        if desc.sticky_fn(rep):
+            if not self._sticky_spent:
+                self._sticky_value = (
+                    desc.sticky_value_fn(rep) if desc.sticky_value_fn is not None else raw
+                )
+                self._sticky_until = now + desc.sticky_seconds
+                self._sticky_spent = True
+        elif desc.sticky_bypass_fn is not None and desc.sticky_bypass_fn(rep):
+            self._sticky_until = None
+            self._sticky_spent = False
+            return raw
+
+        holding = self._sticky_until is not None and now < self._sticky_until
+        return self._sticky_value if holding else raw
+
     def _apply_hysteresis(self, raw):
         """Hold the last value this entity actually reported until a new one
         differs by at least the configured threshold, regardless of how long
@@ -111,7 +187,7 @@ class LocalThingsConnectionModeSensor(CoordinatorEntity[LocalThingsCoordinator],
 
     def __init__(self, coordinator: LocalThingsCoordinator) -> None:
         super().__init__(coordinator)
-        self._attr_unique_id = f"{DOMAIN}_{coordinator.device_serial}_connection_mode"
+        self._attr_unique_id = f"{DOMAIN}_{coordinator.device_key}_connection_mode"
 
     @property
     def device_info(self) -> DeviceInfo:

custom_components/localthings/services.py

@@ -0,0 +1,229 @@
+"""Home Assistant services for direct OCF resource read/write access
+(issue #300): a raw-transport escape hatch for reverse-engineering a
+device's write contract -- an ordered multi-write sequence with settle
+delays and a delayed re-read, which the single-write options-flow debug
+panel can't express. Both sit on the same coordinator primitives the panel
+now calls too (config_flow.py), so there is exactly one code path that
+performs a raw write.
+
+Kept thin on purpose: session/lock ownership lives on the coordinator
+(coordinator.py). This module only resolves the service call's device
+target to a `(coordinator, subdevice)` pair, translates canonical hrefs
+through that subdevice, and shapes the response.
+"""
+
+from __future__ import annotations
+
+from typing import Any, cast
+
+import voluptuous as vol
+from homeassistant.core import HomeAssistant, ServiceCall, ServiceResponse, SupportsResponse
+from homeassistant.exceptions import ServiceValidationError
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers import device_registry as dr
+
+from .const import DOMAIN, SERVICE_READ_RESOURCE, SERVICE_WRITE_RESOURCE
+from .coordinator import LocalThingsCoordinator, normalize_href
+from .registry.subdevices import MAIN, Subdevice
+
+ATTR_HREF = "href"
+ATTR_PAYLOAD = "payload"
+ATTR_SETTLE = "settle"
+ATTR_WRITES = "writes"
+ATTR_VERIFY_AFTER = "verify_after"
+ATTR_HOLD_SESSION_LOCK = "hold_session_lock"
+ATTR_DEVICE_ID = "device_id"
+
+_WRITE_ITEM_SCHEMA = vol.Schema(
+    {
+        vol.Required(ATTR_HREF): str,
+        # Not `dict` here: a non-dict payload must fail the same way an
+        # empty one does -- coordinator.async_raw_write_sequence's
+        # ServiceValidationError -- not a raw schema vol.Invalid, so every
+        # caller sees one consistent error shape regardless of which rule
+        # a bad payload tripped.
+        vol.Required(ATTR_PAYLOAD): object,
+        vol.Optional(ATTR_SETTLE): vol.Coerce(float),
+    }
+)
+
+# Structural validation only (types, and unwrapping a bare dict into a
+# one-item list) -- the semantic checks (non-empty payload, non-root href,
+# the 1..10/settle/verify_after ranges) live on
+# LocalThingsCoordinator.async_raw_write_sequence, so every caller gets the
+# same ServiceValidationError + translation key regardless of whether it
+# reached the primitive through this service, the options-flow panel, or a
+# future caller.
+_WRITE_RESOURCE_SCHEMA = vol.Schema(
+    {
+        **cv.TARGET_SERVICE_FIELDS,
+        vol.Required(ATTR_WRITES): vol.All(cv.ensure_list, [_WRITE_ITEM_SCHEMA]),
+        vol.Optional(ATTR_VERIFY_AFTER): vol.Coerce(float),
+        vol.Optional(ATTR_HOLD_SESSION_LOCK): cv.boolean,
+    }
+)
+
+_READ_RESOURCE_SCHEMA = vol.Schema(
+    {
+        **cv.TARGET_SERVICE_FIELDS,
+        vol.Optional(ATTR_HREF): str,
+    }
+)
+
+
+def _resolve_target(
+    hass: HomeAssistant, call: ServiceCall
+) -> tuple[LocalThingsCoordinator, Subdevice, str]:
+    """The one `(coordinator, subdevice, device_id)` a service call's
+    device target names.
+
+    Deliberately strict about count, not just presence: the `target:
+    device:` selector in services.yaml still lets a user pick an area or
+    label in the picker, and the frontend expands that into a `device_id`
+    list before the call reaches here -- more than one entry means an
+    area/label fanned this out across several appliances, which a raw
+    debug write must never do silently (issue #300).
+    """
+    device_ids = cv.ensure_list(call.data.get(ATTR_DEVICE_ID) or [])
+    if len(device_ids) != 1:
+        raise ServiceValidationError(
+            translation_domain=DOMAIN,
+            translation_key="service_device_target_invalid",
+        )
+    device_id = device_ids[0]
+
+    dev_reg = dr.async_get(hass)
+    device = dev_reg.async_get(device_id)
+    if device is None:
+        raise ServiceValidationError(
+            translation_domain=DOMAIN,
+            translation_key="service_device_not_found",
+        )
+
+    for coordinator in hass.data.get(DOMAIN, {}).values():
+        if device.identifiers & coordinator.device_info.get("identifiers", set()):
+            return coordinator, MAIN, device_id
+        for sub in coordinator.subdevices:
+            if device.identifiers & coordinator.device_info_for(sub).get("identifiers", set()):
+                return coordinator, sub, device_id
+
+    raise ServiceValidationError(
+        translation_domain=DOMAIN,
+        translation_key="service_device_not_loaded",
+    )
+
+
+async def _async_write_resource(hass: HomeAssistant, call: ServiceCall) -> ServiceResponse:
+    coordinator, subdevice, device_id = _resolve_target(hass, call)
+    writes_in: list[dict[str, Any]] = call.data[ATTR_WRITES]
+
+    # Canonical -> actual translation happens here, not in the coordinator
+    # (issue #177), whose raw-write primitive has no notion of subdevices --
+    # identity transform for MAIN. Normalized first, or a trailing slash
+    # slips past to_actual onto the master (see coordinator.normalize_href).
+    canonicals = [normalize_href(w[ATTR_HREF]) for w in writes_in]
+    raw_writes = [
+        {
+            "href": subdevice.to_actual(canonical),
+            "payload": w.get(ATTR_PAYLOAD),
+            "settle": w.get(ATTR_SETTLE, 0.0),
+        }
+        for canonical, w in zip(canonicals, writes_in, strict=True)
+    ]
+    sequence = await coordinator.async_raw_write_sequence(
+        raw_writes,
+        verify_after=call.data.get(ATTR_VERIFY_AFTER, 0.0),
+        hold_session_lock=call.data.get(ATTR_HOLD_SESSION_LOCK, True),
+    )
+
+    results = [
+        {
+            "href": canonical,
+            "actual_href": result["href"],
+            "code": result["code"],
+            "raw_code": result["raw_code"],
+            "accepted": result["accepted"],
+            "before": result["before"],
+            "after": result["after"],
+            "changed": result["changed"],
+        }
+        for canonical, result in zip(canonicals, sequence["results"], strict=True)
+    ]
+    response: dict[str, Any] = {"device_id": device_id, "results": results}
+    if "verified" in sequence:
+        # Keyed off the same normalized canonicals the sequence was built
+        # from, so the lookup can't miss and return an actual href where the
+        # contract promises a canonical one.
+        canonical_by_actual = {subdevice.to_actual(c): c for c in canonicals}
+        response["verified"] = {
+            canonical_by_actual.get(actual_href, actual_href): verified
+            for actual_href, verified in sequence["verified"].items()
+        }
+    return response
+
+
+async def _async_read_resource(hass: HomeAssistant, call: ServiceCall) -> ServiceResponse:
+    coordinator, subdevice, _device_id = _resolve_target(hass, call)
+    href = call.data.get(ATTR_HREF)
+    if not href:
+        # No href -> the cached snapshot, not a live sweep of every known
+        # href: lets a user enumerate what exists without hammering the
+        # device (see this module's docstring and the coordinator's
+        # canonical_resources).
+        # device_resources, not canonical_resources: this response is what
+        # the appliance reported, without the fields this integration merges
+        # on for its own use (see coordinator.entity_resources).
+        snapshot: dict[str, Any] = {"resources": coordinator.device_resources(subdevice)}
+        return cast(ServiceResponse, snapshot)
+
+    # Same normalize-before-translate order as the write path above.
+    canonical = normalize_href(href)
+    actual_href = subdevice.to_actual(canonical)
+    code, rep, body = await coordinator.async_raw_read(actual_href)
+    read_result: dict[str, Any] = {
+        "href": canonical,
+        "actual_href": actual_href,
+        "code": f"{code >> 5}.{code & 0x1F:02d}",
+        "raw_code": code,
+        "rep": rep,
+    }
+    # `body` only when it isn't the Property map already in `rep` -- a
+    # Collection (`/device/0`, `/sec/devices`) answers a CBOR list, which
+    # `rep` can't carry and which used to vanish into an empty-looking
+    # 2.05 (issue #335). Omitted for the ordinary map case rather than
+    # duplicating every rep in every response.
+    if body is not None and not isinstance(body, dict):
+        read_result["body"] = body
+    return cast(ServiceResponse, read_result)
+
+
+def async_setup_services(hass: HomeAssistant) -> None:
+    """Register the write_resource/read_resource services (issue #300).
+
+    Called once from `async_setup`, not per config entry: services are
+    process-global, and `hass.services.async_register` on an
+    already-registered name just replaces the handler, so re-registering
+    on every entry setup would silently rebind to whichever entry loaded
+    last. `async_unload_entry` must never call the inverse of this.
+    """
+
+    async def _handle_write(call: ServiceCall) -> ServiceResponse:
+        return await _async_write_resource(hass, call)
+
+    async def _handle_read(call: ServiceCall) -> ServiceResponse:
+        return await _async_read_resource(hass, call)
+
+    hass.services.async_register(
+        DOMAIN,
+        SERVICE_WRITE_RESOURCE,
+        _handle_write,
+        schema=_WRITE_RESOURCE_SCHEMA,
+        supports_response=SupportsResponse.OPTIONAL,
+    )
+    hass.services.async_register(
+        DOMAIN,
+        SERVICE_READ_RESOURCE,
+        _handle_read,
+        schema=_READ_RESOURCE_SCHEMA,
+        supports_response=SupportsResponse.ONLY,
+    )

custom_components/localthings/services.yaml

@@ -0,0 +1,88 @@
+write_resource:
+  name: Write resource
+  description: >-
+    Send one or more raw partial-rep writes straight to a device's OCF
+    resources, in order, with an optional settle delay between steps and a
+    delayed re-read at the end -- for reverse-engineering a device's write
+    contract (issue #300), not day-to-day control. This bypasses the
+    remote-control-off block and every write_fn/validate_fn a normal entity
+    write goes through, and sends exactly the fields you give it verbatim:
+    it can misconfigure your appliance. Prefer a real entity, or the Debug
+    write panel in the integration's Configure menu, for anything this
+    integration already models.
+  fields:
+    device_id:
+      name: Device
+      description: The appliance to write to, or one of its subdevices.
+      required: true
+      selector:
+        device:
+          integration: localthings
+    writes:
+      name: Writes
+      description: >-
+        1-10 writes to perform in order. Each item needs href (the
+        canonical resource, e.g. /mode/vs/0) and payload (a non-empty
+        object sent verbatim as a partial-rep POST); settle is how many
+        seconds to wait after that write before starting the next one
+        (0-30, default 0).
+      required: true
+      example: >-
+        [{"href": "/mode/vs/0", "payload": {"x.com.samsung.da.modes":
+        ["Bake"]}, "settle": 3}]
+      selector:
+        object:
+    hold_session_lock:
+      name: Hold the session for the whole sequence
+      description: >-
+        Keep the device session for the entire sequence, settle delays
+        included, so nothing else -- a routine poll, another entity's write
+        -- can land between two steps and blur which write the appliance
+        was reacting to. On by default. Turning it off takes the session
+        per write and frees it across the waits, which lets entities keep
+        updating during a long sequence at the cost of that certainty.
+      required: false
+      default: true
+      selector:
+        boolean:
+    verify_after:
+      name: Verify after
+      description: >-
+        Seconds to wait after the whole sequence finishes before
+        re-reading every href touched, to see whether the values held or
+        were reverted by the board. 0 (default) skips verification.
+      required: false
+      default: 0
+      selector:
+        number:
+          min: 0
+          max: 60
+          step: 0.5
+          unit_of_measurement: seconds
+          mode: box
+
+read_resource:
+  name: Read resource
+  description: >-
+    Read a device's OCF resources directly, bypassing this integration's
+    entity model. Give an href for a live GET straight from the device --
+    deliberately not the cache, which can be up to a poll interval stale --
+    or omit it to get the cached snapshot of every resource this
+    integration currently tracks on that device.
+  fields:
+    device_id:
+      name: Device
+      description: The appliance to read from, or one of its subdevices.
+      required: true
+      selector:
+        device:
+          integration: localthings
+    href:
+      name: Resource href
+      description: >-
+        Canonical resource href to read (e.g. /mode/vs/0). Omit to get the
+        cached snapshot of every tracked resource instead of a live GET.
+      required: false
+      example: /mode/vs/0
+      selector:
+        text:

custom_components/localthings/translations/cs.json

@@ -108,6 +108,15 @@
       },
       "softener_low": {
         "name": "Málo aviváže"
+      },
+      "add_wash_available": {
+        "name": "AddWash povoleno"
+      },
+      "add_wash_indicator": {
+        "name": "AddWash připraveno"
+      },
+      "stick_ble_connected": {
+        "name": "Tyč připojena přes BLE"
       }
     },
     "button": {
@@ -117,6 +126,12 @@
       "diagnosis_start": {
         "name": "Spustit diagnostiku"
       },
+      "auto_clean_stop": {
+        "name": "Zastavit samočištění"
+      },
+      "filter_time_reset": {
+        "name": "Vynulovat počítadlo filtru"
+      },
       "pause": {
         "name": "Pozastavit"
       },
@@ -146,11 +161,13 @@
               "smart": "Chytrý",
               "speed": "Rychlý",
               "nano": "WindFree",
+              "sleep": "Spánek",
               "nanosleep": "WindFree spánek",
               "longwind": "Dlouhý vánek",
               "motionindirect": "Nepřímý vzduch při pohybu",
               "motiondirect": "Přímý vzduch při pohybu",
               "drycomfort": "Komfortní sušení",
+              "dlightcool": "d'light Cool",
               "2step": "2stupňový"
             }
           }
@@ -191,6 +208,9 @@
       "oven_setpoint": {
         "name": "Požadovaná teplota"
       },
+      "sensing_interval": {
+        "name": "Interval AI Purify"
+      },
       "setpoint": {
         "name": "Požadovaná teplota"
       },
@@ -214,6 +234,9 @@
       "air_filter_threshold": {
         "name": "Práh upozornění na filtr"
       },
+      "auto_door_timer": {
+        "name": "Časovač automatického otevírání dvířek"
+      },
       "beverage_zone_mode": {
         "name": "Režim zóny nápojů",
         "state": {
@@ -244,7 +267,11 @@
         "name": "Zvuk bzučáku",
         "state": {
           "off": "Vypnuto",
-          "on": "Zapnuto"
+          "on": "Zapnuto",
+          "volume_off": "Vypnuto",
+          "volume_low": "Nízká",
+          "volume_med": "Střední",
+          "volume_high": "Vysoká"
         }
       },
       "discharging_time": {
@@ -286,7 +313,16 @@
           "07": "Předoplach",
           "8d": "Hrnce a pánve",
           "8e": "Plast",
-          "8f": "Dětské potřeby"
+          "8f": "Dětské potřeby",
+          "82": "Automatický",
+          "8a": "Normální",
+          "a7": "Intenzivní",
+          "a8": "Expresní",
+          "8c": "Extra tichý",
+          "88": "Samočištění",
+          "85": "Jemné",
+          "0c": "Express",
+          "0d": "Samočištění"
         }
       },
       "dispense_type": {
@@ -301,6 +337,35 @@
           "4": "Alarm 4"
         }
       },
+      "dryer_cycle_table_00": {
+        "name": "Cyklus",
+        "state": {
+          "01": "Normální",
+          "9c": "Intenzivní",
+          "a5": "Ložní prádlo",
+          "9e": "Nežehlivé prádlo",
+          "9b": "Parní dezinfekce+",
+          "27": "Osvěžení",
+          "a0": "Provětrání",
+          "a4": "Časové sušení",
+          "a6": "Rychlé sušení",
+          "a3": "Sportovní oblečení",
+          "a2": "Jemné prádlo",
+          "9a": "Bavlna",
+          "ca": "Provětrání",
+          "db": "Super Speed",
+          "99": "Smíšená náplň",
+          "93": "Žehlení",
+          "b5": "Vlna",
+          "d7": "Outdoor péče",
+          "96": "Studený vzduch",
+          "97": "Teplý vzduch",
+          "7f": "Časové sušení",
+          "98": "Rychlé sušení 35",
+          "eb": "Jemné prádlo",
+          "b6": "Syntetika"
+        }
+      },
       "dryer_cycle_table_03": {
         "name": "Cyklus",
         "state": {
@@ -328,7 +393,27 @@
           "4c": "Osvěžení vzduchem",
           "51": "Eko bavlna",
           "53": "AI sušení+",
-          "4e": "Automatické sušení"
+          "4e": "Automatické sušení",
+          "26": "Provětrání",
+          "2a": "Hygienické sušení+",
+          "02": "AI sušení",
+          "03": "Super Speed",
+          "05": "Ložní prádlo",
+          "07": "Jemné prádlo",
+          "09": "Košile",
+          "0b": "Péče o prošívané bundy",
+          "0c": "Outdoor impregnace",
+          "0e": "Ručníky",
+          "0f": "Vlna",
+          "11": "Studený vzduch",
+          "28": "Vnitřní dezinfekce horkým vzduchem",
+          "37": "Halenky",
+          "38": "Žehlení",
+          "39": "Odvlhčování místnosti",
+          "3a": "Hygienické sušení",
+          "3b": "Ložní prádlo/Odstranění prachu",
+          "3c": "Sportovní oblečení",
+          "3d": "Džíny"
         }
       },
       "favorite_capacity": {
@@ -450,9 +535,11 @@
           "kimchi_storage_crunfch": "Křupavé kimči",
           "kimchi_storage_buy": "Kupované kimči",
           "storage_fridge_normal": "Chlazení",
+          "storage_fridge": "Chlazení",
           "storage_fridge_cold": "Chlazení, silné",
           "storage_fridge_warm": "Chlazení, slabé",
           "storage_freezer_normal": "Mražení",
+          "storage_freezer": "Mražení",
           "storage_freezer_cold": "Mražení, silné",
           "storage_freezer_warm": "Mražení, slabé",
           "kimchi_ripe_low_temp": "Zrání kimči, nízká teplota",
@@ -465,7 +552,8 @@
           "storage_fresh_cereal": "Obiloviny",
           "storage_fridge_drink": "Nápoje",
           "storage_fresh_wine": "Víno",
-          "storage_fresh_potato_banana": "Brambory a banány"
+          "storage_fresh_potato_banana": "Brambory a banány",
+          "newmode_kimchi_0000": "Nový režim"
         }
       },
       "pantry_zone_mode": {
@@ -476,6 +564,16 @@
           "fdr_drinks": "Nápoje"
         }
       },
+      "winecellar_pantry_zone_mode": {
+        "name": "Režim spíže",
+        "state": {
+          "processed_meat": "Zpracované maso",
+          "cheese": "Sýr",
+          "nuts": "Ořechy",
+          "fruit": "Ovoce",
+          "wine": "Víno"
+        }
+      },
       "range_burner_power_level": {
         "name": "Výkon hořáku {number}",
         "state": {
@@ -494,6 +592,14 @@
       "rinse_cycles": {
         "name": "Počet máchání"
       },
+      "sensing_mode": {
+        "name": "Akce AI Purify",
+        "state": {
+          "off": "Pouze měření",
+          "airpurify": "Automatické čištění",
+          "alarm": "Dostat upozornění"
+        }
+      },
       "softener_concentration": {
         "name": "Koncentrace aviváže",
         "state": {
@@ -519,6 +625,9 @@
           "mute": "Ztlumeno"
         }
       },
+      "energy_saving_mode": {
+        "name": "Režim úspory energie"
+      },
       "air_purifier_sound_mode": {
         "name": "Zvukový režim",
         "state": {
@@ -555,12 +664,51 @@
           "extra_hot": "Extra horká"
         }
       },
+      "washer_cycle_table_00": {
+        "name": "Cyklus",
+        "state": {
+          "01": "Normální",
+          "70": "Intenzivní",
+          "55": "Bílé prádlo",
+          "71": "Ložní prádlo",
+          "72": "Dezinfekce",
+          "77": "Nežehlivé prádlo",
+          "57": "Samočištění+",
+          "73": "Máchání + odstřeďování",
+          "74": "Sportovní oblečení",
+          "75": "Jemné prádlo",
+          "78": "Rychlé praní"
+        }
+      },
       "washer_cycle_table_02": {
         "name": "Cyklus",
         "state": {
           "01": "Normální",
+          "02": "Extra intenzivní",
+          "03": "Super Eco",
           "04": "Rychlé praní",
+          "05": "Vlna/Spodní prádlo",
+          "06": "Ložní prádlo",
+          "07": "Outdoor",
+          "08": "Máchání+odstřeďování",
+          "09": "Čištění bubnu",
+          "0a": "Ručníky",
+          "0b": "Praní varem",
+          "0c": "Dětské potřeby",
+          "0d": "Pouze odstřeďování",
+          "0e": "Zataženo",
+          "0f": "Čisté praní",
+          "10": "Sušicí odstřeďování",
+          "11": "Letní ložní prádlo",
+          "12": "Bavlna",
+          "13": "Černá bavlna",
+          "14": "Jemné spodní prádlo",
+          "15": "Sportovní oblečení",
+          "16": "Halenky",
           "17": "Stažený program",
+          "18": "Soft Bubble",
+          "19": "AI praní",
+          "1a": "Košile",
           "1b": "Bavlna",
           "1c": "Eco 40-60",
           "1d": "Super rychlé",
@@ -570,7 +718,7 @@
           "21": "Barevné prádlo",
           "22": "Vlna",
           "23": "Outdoor",
-          "24": "Ručníky",
+          "24": "Ložní prádlo",
           "25": "Syntetika",
           "26": "Jemné prádlo",
           "27": "Máchání+odstřeďování",
@@ -583,8 +731,9 @@
           "2f": "Sportovní oblečení",
           "30": "Zataženo",
           "32": "Košile",
-          "33": "Ložní prádlo",
+          "33": "Ručníky",
           "34": "Smíšené",
+          "35": "Eko bavlna",
           "36": "Praní+sušení",
           "37": "Sušení vzduchem",
           "38": "Sušení bavlny",
@@ -599,14 +748,34 @@
           "60": "Samočištění+",
           "65": "Barevné prádlo",
           "66": "Džíny",
+          "69": "AI praní",
+          "6a": "Vlna",
+          "6b": "Džíny",
+          "6c": "Halenky",
+          "6d": "Jemné prádlo",
+          "6e": "Sportovní oblečení",
+          "6f": "Ložní prádlo",
+          "70": "Ručníky",
+          "71": "Rychlé praní",
+          "72": "Košile",
+          "73": "Dezinfekce",
+          "74": "Čištění bubnu",
+          "75": "Outdoor",
+          "76": "Dětské potřeby",
+          "77": "Bavlna",
+          "78": "Máchání + odstřeďování",
+          "79": "Pouze odstřeďování",
           "7c": "Bílé prádlo",
           "7d": "Ložní prádlo/nepromokavé",
           "7e": "Samočištění",
           "7f": "Vlna/jemné",
           "86": "Hloubkové praní",
           "87": "Stažený program",
+          "88": "Péče o domácí mazlíčky",
           "8f": "Intenzivní studená",
-          "96": "Méně mikrovláken"
+          "96": "Méně mikrovláken",
+          "a0": "15min rychlé praní",
+          "b0": "Smíšená náplň"
         }
       },
       "washer_dry_level": {
@@ -646,6 +815,38 @@
       },
       "freezer_temperature_setpoint": {
         "name": "Teplota mrazicí zóny"
+      },
+      "edge_lighting_mode": {
+        "name": "Režim okrajového osvětlení",
+        "state": {
+          "smart": "Chytrý",
+          "high": "Vysoký",
+          "low": "Nízký"
+        }
+      },
+      "edge_lighting_color": {
+        "name": "Barva okrajového osvětlení",
+        "state": {
+          "3000k": "3000 K",
+          "4000k": "4000 K",
+          "6500k": "6500 K"
+        }
+      },
+      "indicator_light_mode": {
+        "name": "Režim kontrolky",
+        "state": {
+          "smart": "Chytrý",
+          "high": "Vysoký",
+          "low": "Nízký"
+        }
+      },
+      "ventilation_mode": {
+        "name": "Režim",
+        "state": {
+          "purification": "Čištění",
+          "ventilation": "Větrání",
+          "smartventilation": "Chytré větrání"
+        }
       }
     },
     "sensor": {
@@ -661,6 +862,9 @@
       "air_filter_usage_hours": {
         "name": "Hodiny využití filtru"
       },
+      "deodor_filter_usage": {
+        "name": "Využití filtru"
+      },
       "air_quality_standard": {
         "name": "Norma kvality vzduchu"
       },
@@ -734,6 +938,12 @@
       "stick_status": {
         "name": "Stav tyče"
       },
+      "stick_operation_mode": {
+        "name": "Provozní režim tyče"
+      },
+      "stick_cleaning_status": {
+        "name": "Stav čištění tyče"
+      },
       "uvc_operation_time": {
         "name": "Doba provozu UV-C"
       },
@@ -768,6 +978,12 @@
           "indirect": "Nepřímý"
         }
       },
+      "energy_saving_state": {
+        "name": "Stav úspory energie"
+      },
+      "energy_saving_operating_status": {
+        "name": "Provozní stav úspory energie"
+      },
       "current_temp_c": {
         "name": "Teplota"
       },
@@ -775,10 +991,16 @@
         "name": "Teplota"
       },
       "diagnosis": {
-        "name": "Diagnostika"
+        "name": "Diagnostika",
+        "state": {
+          "ready": "Připraveno"
+        }
       },
       "diagnosis_status": {
-        "name": "Stav diagnostiky"
+        "name": "Stav diagnostiky",
+        "state": {
+          "ready": "Připraveno"
+        }
       },
       "drum_clean_cycles_remaining": {
         "name": "Čištění bubnu za"
@@ -793,7 +1015,10 @@
         "name": "Doba sušení"
       },
       "dryer_type": {
-        "name": "Typ sušičky"
+        "name": "Typ sušičky",
+        "state": {
+          "electricity": "Elektřina"
+        }
       },
       "dust": {
         "name": "Prach"
@@ -922,7 +1147,23 @@
         "name": "Teplota sondy"
       },
       "progress": {
-        "name": "Průběh"
+        "name": "Průběh",
+        "state": {
+          "idle": "Nečinný",
+          "weightsensing": "Detekce náplně",
+          "wash": "Praní",
+          "rinse": "Máchání",
+          "spin": "Odstřeďování",
+          "finish": "Dokončeno",
+          "steaming": "Napařování",
+          "airwashing": "Osvěžení vzduchem",
+          "drying": "Sušení",
+          "dryingwithdooropen": "Větrání",
+          "cooling": "Chlazení",
+          "predrain": "Vypouštění",
+          "prewash": "Předpírka",
+          "sanitizing": "Dezinfekce"
+        }
       },
       "progress_percentage": {
         "name": "Průběh v procentech"
@@ -1021,6 +1262,9 @@
       "absence_power_saving_active": {
         "name": "Úspora energie při nepřítomnosti aktivní"
       },
+      "absence_clean": {
+        "name": "Čištění při nepřítomnosti"
+      },
       "motion_detect_wind_active": {
         "name": "Vyhýbání se proudu vzduchu při pohybu aktivní"
       },
@@ -1030,6 +1274,12 @@
       "display": {
         "name": "Displej"
       },
+      "periodic_air_sensing": {
+        "name": "AI Purify"
+      },
+      "periodic_sensing_skip_status": {
+        "name": "Přeskočení měření AI Purify"
+      },
       "pet_filter_activation": {
         "name": "Aktivace filtru pro domácí mazlíčky"
       },
@@ -1048,6 +1298,12 @@
       "auto_door_opener": {
         "name": "Automatické otevírání dvířek"
       },
+      "auto_door_sound_control": {
+        "name": "Zvuk automatického otevírání dvířek"
+      },
+      "auto_door_voice_control": {
+        "name": "Hlasové ovládání automatického otevírání dvířek"
+      },
       "auto_release_dry": {
         "name": "Automatické uvolnění při sušení"
       },
@@ -1114,6 +1370,18 @@
       "intensive": {
         "name": "Intenzivní"
       },
+      "add_wash_alarm": {
+        "name": "Alarm AddWash"
+      },
+      "add_wash_alarm_rinse": {
+        "name": "AddWash při máchání"
+      },
+      "add_wash_alarm_final_rinse": {
+        "name": "AddWash při posledním máchání"
+      },
+      "add_wash_alarm_spin": {
+        "name": "AddWash při odstřeďování"
+      },
       "lamp": {
         "name": "Lampa"
       },
@@ -1179,6 +1447,18 @@
       },
       "ventilation_alarm": {
         "name": "Alarm větrání"
+      },
+      "edge_lighting": {
+        "name": "Okrajové osvětlení"
+      },
+      "indicator_light": {
+        "name": "Kontrolka"
+      },
+      "windfree": {
+        "name": "Režim Wind-Free"
+      },
+      "windsleep": {
+        "name": "Noční režim"
       }
     },
     "time": {
@@ -1199,6 +1479,12 @@
       },
       "night_start": {
         "name": "Začátek nočního osvětlení"
+      },
+      "sensing_skip_end": {
+        "name": "Konec přeskočení měření AI Purify"
+      },
+      "sensing_skip_start": {
+        "name": "Začátek přeskočení měření AI Purify"
       }
     },
     "water_heater": {
@@ -1261,17 +1547,25 @@
         "title": "Možnosti LocalThings",
         "menu_options": {
           "settings": "Nastavení zápisu pro dálkové ovládání",
+          "cloud_courses": "Stažené cykly",
+          "forget_learned_modes": "Zapomenout zapamatované režimy",
           "debug_write": "Ladění: zápis do prostředku"
         }
       },
       "settings": {
         "title": "Nastavení zápisu pro dálkové ovládání",
-        "description": "Některá zařízení přijímají určité zápisy (např. výchozí dávkování pracího prostředku/aviváže v pračce) i když hlásí vypnuté dálkové ovládání. LocalThings ve výchozím nastavení blokuje každý zápis srozumitelnou chybou, kdykoli zařízení hlásí vypnuté dálkové ovládání, místo aby jej zařízení tiše odmítlo. Povolte toto pouze tehdy, pokud jste ověřili, že zápisy na tomto zařízení skutečně fungují i s vypnutým dálkovým ovládáním – jinak tuto srozumitelnou chybu vyměníte za tiché selhání.",
+        "description": "Některá zařízení přijímají určité zápisy (např. výchozí dávkování pracího prostředku/aviváže v pračce) i když hlásí vypnuté dálkové ovládání. LocalThings ve výchozím nastavení blokuje každý zápis srozumitelnou chybou, kdykoli zařízení hlásí vypnuté dálkové ovládání, místo aby jej zařízení tiše odmítlo. Povolte toto pouze tehdy, pokud jste ověřili, že zápisy na tomto zařízení skutečně fungují i s vypnutým dálkovým ovládáním – jinak tuto srozumitelnou chybu vyměníte za tiché selhání.\n\nNěkterá zařízení hlásí režim, který nikdy neuvedou mezi podporovanými – například klimatizace běžící v režimu Quiet, která nabízí pouze Off/Sleep/Speed. LocalThings si každý takový režim zapamatuje a dál jej nabízí, takže zůstane volitelný, jakmile v něm zařízení alespoň jednou bylo. Vypnutím této volby se budou nabízet pouze režimy, které zařízení samo uvádí; k vymazání již zapamatovaných použijte „Zapomenout zapamatované režimy“ v předchozí nabídce. Zařízení pro praní se staženými cykly z cloudu zde dostane připomenutí, jakmile nahlásí cyklus, který Home Assistant zatím nemůže nabídnout -- některá zařízení jej nahlásí, i když jste obrazovku „Stažené cykly“ v aplikaci SmartThings sami nikdy neotevřeli. Vypněte tuto možnost, chcete-li připomenutí zastavit a skrýt už pojmenované stažené cykly ze seznamu cyklů; nic z toho, co je již nastaveno, se neztratí, a po opětovném zapnutí se to hned znovu objeví.",
         "data": {
           "bypass_remote_control_lock": "Povolit zápis i když je dálkové ovládání hlášeno jako vypnuté",
-          "finish_time_hysteresis_minutes": "Odhadovaný konec -- minimální změna (minuty)"
+          "finish_time_hysteresis_minutes": "Odhadovaný konec -- minimální změna (minuty)",
+          "learn_device_modes": "Pamatovat si režimy, které zařízení hlásí, ale neuvádí jako podporované",
+          "cloud_courses_enabled": "Nabízet stažené cykly"
         }
       },
+      "forget_learned_modes": {
+        "title": "Zapomenout zapamatované režimy",
+        "description": "Aktuálně zapamatováno: {codes}\n\nJde o režimy, ve kterých se toto zařízení samo hlásilo, aniž by je uvádělo mezi podporovanými; jsou uchovány, aby zůstaly volitelné. Zapomenutí je řešením, pokud se některý ukázal jako chybný – cokoli, co zařízení skutečně znovu nahlásí, si systém opět zapamatuje, pokud zároveň nevypnete volbu „Pamatovat si režimy, které zařízení hlásí, ale neuvádí jako podporované“ v nastavení."
+      },
       "debug_write": {
         "title": "Ladění: zápis do prostředku",
         "description": "Nástroj pro pokročilé uživatele k odhalení chování zápisu specifického pro dané zařízení. Vyberte prostředek (href), do kterého chcete zapisovat, nebo zadejte vlastní, který není uveden v seznamu. Toto obchází blokování při vypnutém dálkovém ovládání a odesílá přesně ta pole, která zadáte -- může to špatně nakonfigurovat váš spotřebič, používejte tedy záměrně.",
@@ -1293,20 +1587,63 @@
           "debug_write": "Zapsat do dalšího prostředku",
           "finish": "Dokončit"
         }
+      },
+      "cloud_manual": {
+        "title": "Stažené cykly",
+        "description": "Toto zařízení hlásí {total} stažených cyklů; {found} jich bylo dosud zjištěno.\n\nNastavení staženého cyklu jsou viditelná pouze tehdy, když je daný cyklus právě načtený, a zařízení nikdy nehlásí jejich názvy. Chcete-li doplnit chybějící ({pending}): v aplikaci SmartThings (ne na samotném zařízení) otevřete toto zařízení a klepněte na „Stažené cykly“ -- samostatný řádek odlišný od „Cyklus“, níže na obrazovce, a ten, na kterém zde záleží. Poté postupně projděte jednotlivé stažené programy, u každého se na pár sekund zastavte, aby jej LocalThings zaznamenal, a vraťte se sem.\n\nKaždému z nich zadejte název, který chcete vidět v Home Assistant. Necháte-li název prázdný, daný cyklus zůstane mimo seznam cyklů. Názvy musí být jedinečné.\n\nStažený program je program na tomto zařízení, který spouští stažený cyklus. Rozpoznává se automaticky, ale před použitím jej zde potvrďte: výběrem staženého cyklu se do zařízení zapíše tento kód programu.",
+        "data": {
+          "download_course": "Kód programu „Stažený program“"
+        }
+      },
+      "cloud_courses": {
+        "title": "Stažené cykly",
+        "description": "Průvodce nastavením vás provede: v aplikaci SmartThings (ne na samotném zařízení) otevřete toto zařízení a klepněte na „Stažené cykly“ -- samostatný řádek odlišný od „Cyklus“, níže na obrazovce, a ten, na kterém zde záleží. Vyberte tam cyklus, vraťte se sem a jakmile je nalezen, pojmenujte ho – jeden po druhém.\n\nÚprava názvů zobrazí vše dosud nalezené najednou – použijte ji později k přejmenování nebo opravě. Pojmenování funguje v obou případech, ale pojmenovaný cyklus se nabízí jako vybratelný cyklus jen tehdy, když je v nastavení zařízení zapnuto „Nabízet stažené cykly“.",
+        "menu_options": {
+          "cloud_guided": "Průvodce nastavením",
+          "cloud_manual": "Upravit názvy"
+        }
+      },
+      "cloud_wait": {
+        "title": "Stažené cykly"
+      },
+      "cloud_name": {
+        "title": "Pojmenujte tento cyklus",
+        "description": "Pozice „Stažené cykly“ zařízení nyní obsahuje nový cyklus (pozice {slot}) a hlásí zbývající čas {remaining}.\n\nZadejte název, který chcete vidět v Home Assistant, a poté na obrazovce „Stažené cykly“ v aplikaci SmartThings vyberte další cyklus, který ještě není označen jako „Stažený“. Necháte-li pole prázdné, tento cyklus zůstane mimo seznam.\n\nDosud pojmenováno ({named} z {total}): {named_list}\n\nNázvy musí být jedinečné. Toto okno můžete kdykoli zavřít – názvy se ukládají průběžně.",
+        "data": {
+          "name": "Název",
+          "download_course": "Kód programu „Stažený program“"
+        }
+      },
+      "cloud_timeout": {
+        "title": "Nebyl vybrán žádný cyklus",
+        "description": "Na zařízení se nic nezměnilo. Ujistěte se, že jste v aplikaci SmartThings klepli na „Stažené cykly“ -- samostatný řádek odlišný od „Cyklus“, níže na obrazovce -- a vybrali cyklus, který ještě nebyl označen jako „Stažený“, a poté klepli na Hotovo.\n\nDosud pojmenováno ({named} z {total}): {named_list}\n\nVše dosud pojmenované je již uloženo.",
+        "menu_options": {
+          "cloud_guided": "Počkat znovu",
+          "cloud_finish": "Dokončit"
+        }
       }
     },
     "error": {
       "empty_payload": "Zadejte alespoň jedno pole k zápisu.",
-      "write_failed": "Zápis se nezdařil. Podrobnosti najdete v protokolech Home Assistant."
+      "write_failed": "Zápis se nezdařil. Podrobnosti najdete v protokolech Home Assistant.",
+      "cloud_course_name_duplicate": "Dva cykly mají stejný název. Názvy musí být jedinečné.",
+      "cloud_course_unknown_course": "Tento program zařízení nenabízí. Vyberte jej ze seznamu."
     },
     "abort": {
       "not_loaded": "Toto zařízení ještě není připojeno. Zkuste to znovu, až se načte."
+    },
+    "progress": {
+      "cloud_wait": "V aplikaci SmartThings (ne na samotném zařízení) otevřete toto zařízení a klepněte na „Stažené cykly“ -- samostatný řádek odlišný od „Cyklus“, níže na obrazovce, který uvádí pouze cykly rozpoznatelné tímto způsobem. Vyberte cyklus, který ještě není označen jako „Stažený“, a klepněte na Hotovo.\n\nZařízení nemusí být poblíž ani spuštěné -- stačí, když je zapnuté a připojené.\n\nDosud pojmenováno ({named} z {total}): {named_list}\n\nToto okno můžete kdykoli zavřít – názvy se ukládají průběžně."
     }
   },
   "issues": {
     "device_gap": {
       "title": "Neúplné pokrytí funkcí pro {device_name}",
       "description": "Toto zařízení nemá úplné pokrytí funkcí. Buď nebyl rozpoznán jeho typ spotřebiče, nebo některé jím poskytované prostředky ještě nejsou namodelovány. Bude i nadále fungovat se vším, co je již podporováno. Podporu můžete pomoci rozšířit tak, že přejdete do Nastavení > Zařízení a služby > {device_name} > nabídka (vpravo nahoře) > Stáhnout diagnostiku a poté ji vložíte do odkazované šablony issue."
+    },
+    "cloud_courses_undiscovered": {
+      "title": "Stažené cykly nejsou nastaveny pro {device_name}",
+      "description": "{device_name} má {pending} z {total} stažených cyklů, které Home Assistant zatím nemůže nabídnout. Stažený cyklus lze použít až poté, co byl na zařízení zjištěn načtený -- na obrazovce „Stažené cykly“ v aplikaci SmartThings, ne na obrazovce „Cyklus“ -- a co jste mu dali název.\n\nChcete-li je nastavit, přejděte do Nastavení > Zařízení a služby > LocalThings > {device_name} > Konfigurovat > Stažené cykly a postupujte podle pokynů.\n\nStažené cykly nepoužíváte? Přejděte místo toho do Konfigurovat > Nastavení zařízení a vypněte „Nabízet stažené cykly“, čímž toto připomenutí natrvalo umlčíte."
     }
   },
   "exceptions": {
@@ -1327,6 +1664,30 @@
     },
     "intensive_unavailable_for_cycle": {
       "message": "Intenzivní není u vybraného cyklu k dispozici."
+    },
+    "command_failed": {
+      "message": "Příkaz pro {href} selhal i po opětovném připojení: {error}"
+    },
+    "debug_read_failed": {
+      "message": "Čtení z {href} selhalo: {error}"
+    },
+    "debug_too_many_writes": {
+      "message": "Zadejte 1 až 10 zápisů."
+    },
+    "debug_settle_out_of_range": {
+      "message": "Hodnota settle musí být mezi 0 a 30 sekundami."
+    },
+    "debug_verify_after_out_of_range": {
+      "message": "Hodnota verify_after musí být mezi 0 a 60 sekundami."
+    },
+    "service_device_target_invalid": {
+      "message": "Tato služba vyžaduje přesně jedno cílové zařízení."
+    },
+    "service_device_not_found": {
+      "message": "Pro tento cíl nebylo nalezeno žádné odpovídající zařízení."
+    },
+    "service_device_not_loaded": {
+      "message": "Toto zařízení ještě není připojeno. Zkuste to znovu, až se načte."
     }
   }
 }

custom_components/localthings/translations/en.json

@@ -108,6 +108,15 @@
       },
       "softener_low": {
         "name": "Softener low"
+      },
+      "add_wash_available": {
+        "name": "AddWash allowed"
+      },
+      "add_wash_indicator": {
+        "name": "AddWash ready"
+      },
+      "stick_ble_connected": {
+        "name": "Stick BLE connected"
       }
     },
     "button": {
@@ -117,6 +126,12 @@
       "diagnosis_start": {
         "name": "Start diagnosis"
       },
+      "auto_clean_stop": {
+        "name": "Stop auto clean"
+      },
+      "filter_time_reset": {
+        "name": "Reset filter time"
+      },
       "pause": {
         "name": "Pause"
       },
@@ -146,11 +161,13 @@
               "smart": "Smart",
               "speed": "Speed",
               "nano": "WindFree",
+              "sleep": "Sleep",
               "nanosleep": "WindFree sleep",
               "longwind": "Long wind",
               "motionindirect": "Motion indirect",
               "motiondirect": "Motion direct",
               "drycomfort": "Dry comfort",
+              "dlightcool": "d'light Cool",
               "2step": "2-Step"
             }
           }
@@ -191,6 +208,9 @@
       "oven_setpoint": {
         "name": "Setpoint"
       },
+      "sensing_interval": {
+        "name": "AI Purify interval"
+      },
       "setpoint": {
         "name": "Setpoint"
       },
@@ -214,6 +234,9 @@
       "air_filter_threshold": {
         "name": "Filter alarm threshold"
       },
+      "auto_door_timer": {
+        "name": "Auto door open timer"
+      },
       "beverage_zone_mode": {
         "name": "Beverage zone mode",
         "state": {
@@ -244,7 +267,11 @@
         "name": "Buzzer sound",
         "state": {
           "off": "Off",
-          "on": "On"
+          "on": "On",
+          "volume_off": "Off",
+          "volume_low": "Low",
+          "volume_med": "Medium",
+          "volume_high": "High"
         }
       },
       "discharging_time": {
@@ -285,8 +312,17 @@
           "0e": "AI Wash",
           "07": "Pre blast",
           "8d": "Pots and pans",
+          "85": "Delicate",
+          "0c": "Express",
+          "0d": "Self clean",
           "8e": "Plastic",
-          "8f": "Baby Care"
+          "8f": "Baby Care",
+          "82": "Auto",
+          "8a": "Normal",
+          "a7": "Heavy",
+          "a8": "Express",
+          "8c": "Extra Silence",
+          "88": "Self Clean"
         }
       },
       "dispense_type": {
@@ -301,6 +337,35 @@
           "4": "Alarm 4"
         }
       },
+      "dryer_cycle_table_00": {
+        "name": "Cycle",
+        "state": {
+          "01": "Normal",
+          "9c": "Heavy Duty",
+          "a5": "Bedding",
+          "9e": "Perm Press",
+          "9b": "Steam Sanitize+",
+          "27": "Refresh",
+          "a0": "Air Fluff",
+          "a4": "Time Dry",
+          "a6": "Quick Dry",
+          "a3": "Active Wear",
+          "a2": "Delicates",
+          "9a": "Cotton",
+          "ca": "Air Wash",
+          "db": "Super Speed",
+          "99": "Mixed Load",
+          "93": "Iron Dry",
+          "b5": "Wool",
+          "d7": "Outdoor Care",
+          "96": "Cool Air",
+          "97": "Warm Air",
+          "7f": "Time Dry",
+          "98": "Quick Dry 35",
+          "eb": "Delicates",
+          "b6": "Synthetics"
+        }
+      },
       "dryer_cycle_table_03": {
         "name": "Cycle",
         "state": {
@@ -316,8 +381,10 @@
           "23": "Quick Dry 35'",
           "24": "Cool air",
           "25": "Warm air",
+          "26": "Air wash",
           "27": "Time dry",
           "29": "AI Dry",
+          "2a": "Hygiene Care+",
           "1a": "Wool",
           "1b": "Bedding",
           "1c": "Shirts",
@@ -328,7 +395,25 @@
           "4c": "Air Refresh",
           "51": "Eco Cotton",
           "53": "AI Dry+",
-          "4e": "Self Dry"
+          "4e": "Self Dry",
+          "02": "AI Dry",
+          "03": "Super Speed",
+          "05": "Bedding",
+          "07": "Delicates",
+          "09": "Shirts",
+          "0b": "Padding Care",
+          "0c": "Outdoor Water-Repellent Care",
+          "0e": "Towels",
+          "0f": "Wool",
+          "11": "Cool air",
+          "28": "Interior Hot Air Sanitize",
+          "37": "Blouses",
+          "38": "Iron dry",
+          "39": "Room Dehumidify",
+          "3a": "Hygiene Care",
+          "3b": "Bedding/Dust Off",
+          "3c": "Activewear",
+          "3d": "Denim"
         }
       },
       "favorite_capacity": {
@@ -452,9 +537,11 @@
           "storage_fridge_normal": "Fridge",
           "storage_fridge_cold": "Fridge, strong",
           "storage_fridge_warm": "Fridge, weak",
+          "storage_fridge": "Fridge",
           "storage_freezer_normal": "Freezer",
           "storage_freezer_cold": "Freezer, strong",
           "storage_freezer_warm": "Freezer, weak",
+          "storage_freezer": "Freezer",
           "kimchi_ripe_low_temp": "Kimchi ripening, low temperature",
           "kimchi_ripe_normal_temp": "Kimchi ripening, room temperature",
           "kimchi_ripe_kkakdugi": "Kkakdugi ripening",
@@ -465,7 +552,8 @@
           "storage_fresh_cereal": "Grains",
           "storage_fridge_drink": "Beverages",
           "storage_fresh_wine": "Wine",
-          "storage_fresh_potato_banana": "Potato & banana"
+          "storage_fresh_potato_banana": "Potato & banana",
+          "newmode_kimchi_0000": "New mode"
         }
       },
       "pantry_zone_mode": {
@@ -476,6 +564,16 @@
           "fdr_drinks": "Drinks"
         }
       },
+      "winecellar_pantry_zone_mode": {
+        "name": "Pantry zone mode",
+        "state": {
+          "processed_meat": "Processed meat",
+          "cheese": "Cheese",
+          "nuts": "Nuts",
+          "fruit": "Fruit",
+          "wine": "Wine"
+        }
+      },
       "range_burner_power_level": {
         "name": "Burner {number} power level",
         "state": {
@@ -494,6 +592,14 @@
       "rinse_cycles": {
         "name": "Rinse cycles"
       },
+      "sensing_mode": {
+        "name": "AI Purify action",
+        "state": {
+          "off": "Sensing only",
+          "airpurify": "Auto clean",
+          "alarm": "Get notified"
+        }
+      },
       "softener_concentration": {
         "name": "Softener concentration",
         "state": {
@@ -519,6 +625,9 @@
           "mute": "Mute"
         }
       },
+      "energy_saving_mode": {
+        "name": "Energy saving mode"
+      },
       "air_purifier_sound_mode": {
         "name": "Sound mode",
         "state": {
@@ -555,12 +664,51 @@
           "extra_hot": "Extra hot"
         }
       },
+      "washer_cycle_table_00": {
+        "name": "Cycle",
+        "state": {
+          "01": "Normal",
+          "70": "Heavy Duty",
+          "55": "Whites",
+          "71": "Bedding",
+          "72": "Sanitize",
+          "77": "Perm Press",
+          "57": "Self Clean+",
+          "73": "Rinse + Spin",
+          "74": "Active Wear",
+          "75": "Delicates",
+          "78": "Quick Wash"
+        }
+      },
       "washer_cycle_table_02": {
         "name": "Cycle",
         "state": {
           "01": "Normal",
+          "02": "Extra Heavy Duty",
+          "03": "Super Eco Wash",
           "04": "Quick Wash",
+          "05": "Wool/Lingerie",
+          "06": "Bedding",
+          "07": "Outdoor",
+          "08": "Rinse+Spin",
+          "09": "Drum Clean",
+          "0a": "Towels",
+          "0b": "Boil Wash",
+          "0c": "Baby Care",
+          "0d": "Spin Only",
+          "0e": "Cloudy Day",
+          "0f": "Pure Wash",
+          "10": "Spin Dry",
+          "11": "Summer Bedding",
+          "12": "Cottons",
+          "13": "Black Cottons",
+          "14": "Delicate Underwear",
+          "15": "Activewear",
+          "16": "Blouses",
           "17": "Downloaded",
+          "18": "Soft Bubble",
+          "19": "AI Wash",
+          "1a": "Shirts",
           "1b": "Cotton",
           "1c": "Eco 40-60",
           "1d": "Super Speed",
@@ -570,7 +718,7 @@
           "21": "Colors",
           "22": "Wool",
           "23": "Outdoor",
-          "24": "Towels",
+          "24": "Bedding",
           "25": "Synthetics",
           "26": "Delicates",
           "27": "Rinse+Spin",
@@ -583,8 +731,9 @@
           "2f": "Activewear",
           "30": "Cloudy Day",
           "32": "Shirts",
-          "33": "Bedding",
+          "33": "Towels",
           "34": "Mixed",
+          "35": "E Cotton",
           "36": "Wash+Dry",
           "37": "Air Wash",
           "38": "Cotton Dry",
@@ -599,14 +748,34 @@
           "60": "Self Clean+",
           "65": "Colors",
           "66": "Denim",
+          "69": "AI Wash",
+          "6a": "Wool",
+          "6b": "Denim",
+          "6c": "Blouses",
+          "6d": "Delicates",
+          "6e": "Active Wear",
+          "6f": "Bedding",
+          "70": "Towels",
+          "71": "Quick Wash",
+          "72": "Shirts",
+          "73": "Sanitize",
+          "74": "Drum Clean",
+          "75": "Outdoor",
+          "76": "Baby Care",
+          "77": "Cottons",
+          "78": "Rinse + Spin",
+          "79": "Spin Only",
           "7c": "Whites",
           "7d": "Bedding/Waterproof",
           "7e": "Self-Clean",
           "7f": "Wool/Delicate",
           "86": "Deep Wash",
           "87": "Download",
+          "88": "Pet Care",
           "8f": "Intense Cold",
-          "96": "Less Microfiber"
+          "96": "Less Microfiber",
+          "a0": "15' Quick Wash",
+          "b0": "Mixed Load"
         }
       },
       "washer_dry_level": {
@@ -646,6 +815,38 @@
       },
       "freezer_temperature_setpoint": {
         "name": "Freezer temperature"
+      },
+      "edge_lighting_mode": {
+        "name": "Edge lighting mode",
+        "state": {
+          "smart": "Smart",
+          "high": "High",
+          "low": "Low"
+        }
+      },
+      "edge_lighting_color": {
+        "name": "Edge lighting color",
+        "state": {
+          "3000k": "3000 K",
+          "4000k": "4000 K",
+          "6500k": "6500 K"
+        }
+      },
+      "indicator_light_mode": {
+        "name": "Indicator light mode",
+        "state": {
+          "smart": "Smart",
+          "high": "High",
+          "low": "Low"
+        }
+      },
+      "ventilation_mode": {
+        "name": "Mode",
+        "state": {
+          "purification": "Purification",
+          "ventilation": "Ventilation",
+          "smartventilation": "Smart Ventilation"
+        }
       }
     },
     "sensor": {
@@ -661,6 +862,9 @@
       "air_filter_usage_hours": {
         "name": "Filter usage hours"
       },
+      "deodor_filter_usage": {
+        "name": "Filter usage"
+      },
       "air_quality_standard": {
         "name": "Air quality standard"
       },
@@ -734,6 +938,12 @@
       "stick_status": {
         "name": "Stick status"
       },
+      "stick_operation_mode": {
+        "name": "Stick operation mode"
+      },
+      "stick_cleaning_status": {
+        "name": "Stick cleaning status"
+      },
       "uvc_operation_time": {
         "name": "UV-C operation time"
       },
@@ -768,6 +978,12 @@
           "indirect": "Indirect"
         }
       },
+      "energy_saving_state": {
+        "name": "Energy saving state"
+      },
+      "energy_saving_operating_status": {
+        "name": "Energy saving operating status"
+      },
       "current_temp_c": {
         "name": "Temperature"
       },
@@ -775,10 +991,16 @@
         "name": "Temperature"
       },
       "diagnosis": {
-        "name": "Diagnosis"
+        "name": "Diagnosis",
+        "state": {
+          "ready": "Ready"
+        }
       },
       "diagnosis_status": {
-        "name": "Diagnosis status"
+        "name": "Diagnosis status",
+        "state": {
+          "ready": "Ready"
+        }
       },
       "drum_clean_cycles_remaining": {
         "name": "Drum clean due in"
@@ -793,7 +1015,10 @@
         "name": "Dry time"
       },
       "dryer_type": {
-        "name": "Dryer type"
+        "name": "Dryer type",
+        "state": {
+          "electricity": "Electricity"
+        }
       },
       "dust": {
         "name": "Dust"
@@ -922,7 +1147,23 @@
         "name": "Probe temperature"
       },
       "progress": {
-        "name": "Progress"
+        "name": "Progress",
+        "state": {
+          "idle": "Idle",
+          "weightsensing": "Weight sensing",
+          "wash": "Washing",
+          "rinse": "Rinsing",
+          "spin": "Spinning",
+          "finish": "Finished",
+          "steaming": "Steaming",
+          "airwashing": "Air washing",
+          "drying": "Drying",
+          "dryingwithdooropen": "Venting",
+          "cooling": "Cooling",
+          "predrain": "Pre-drain",
+          "prewash": "Pre-wash",
+          "sanitizing": "Sanitizing"
+        }
       },
       "progress_percentage": {
         "name": "Progress percent"
@@ -1021,6 +1262,9 @@
       "absence_power_saving_active": {
         "name": "Absence power saving active"
       },
+      "absence_clean": {
+        "name": "Absence clean"
+      },
       "motion_detect_wind_active": {
         "name": "Motion-detect wind avoidance active"
       },
@@ -1030,6 +1274,12 @@
       "display": {
         "name": "Display"
       },
+      "periodic_air_sensing": {
+        "name": "AI Purify"
+      },
+      "periodic_sensing_skip_status": {
+        "name": "AI Purify sensing skip"
+      },
       "pet_filter_activation": {
         "name": "Pet filter activation"
       },
@@ -1048,6 +1298,12 @@
       "auto_door_opener": {
         "name": "Auto door opener"
       },
+      "auto_door_sound_control": {
+        "name": "Auto door sound"
+      },
+      "auto_door_voice_control": {
+        "name": "Auto door voice control"
+      },
       "auto_release_dry": {
         "name": "Auto release dry"
       },
@@ -1114,6 +1370,18 @@
       "intensive": {
         "name": "Intensive"
       },
+      "add_wash_alarm": {
+        "name": "AddWash alarm"
+      },
+      "add_wash_alarm_rinse": {
+        "name": "AddWash rinse"
+      },
+      "add_wash_alarm_final_rinse": {
+        "name": "AddWash final rinse"
+      },
+      "add_wash_alarm_spin": {
+        "name": "AddWash spin"
+      },
       "lamp": {
         "name": "Lamp"
       },
@@ -1179,6 +1447,18 @@
       },
       "ventilation_alarm": {
         "name": "Ventilation alarm"
+      },
+      "edge_lighting": {
+        "name": "Edge lighting"
+      },
+      "indicator_light": {
+        "name": "Indicator light"
+      },
+      "windfree": {
+        "name": "Wind-Free mode"
+      },
+      "windsleep": {
+        "name": "Sleep mode"
       }
     },
     "time": {
@@ -1199,6 +1479,12 @@
       },
       "night_start": {
         "name": "Night light start"
+      },
+      "sensing_skip_end": {
+        "name": "AI Purify sensing skip end"
+      },
+      "sensing_skip_start": {
+        "name": "AI Purify sensing skip start"
       }
     },
     "water_heater": {
@@ -1261,17 +1547,25 @@
         "title": "LocalThings options",
         "menu_options": {
           "settings": "Device settings",
+          "cloud_courses": "Download cycles",
+          "forget_learned_modes": "Forget remembered modes",
           "debug_write": "Debug: write to a resource"
         }
       },
       "settings": {
         "title": "Device settings",
-        "description": "Some devices accept certain writes (e.g. default detergent/softener dosing on a washer) even while reporting remote control off. By default, LocalThings blocks every write with a clear error whenever a device reports remote control off, rather than letting the device silently reject it. Only enable this if you've confirmed writes actually work on this device with remote control off -- otherwise you'll trade that clear error for a silent failure.\n\nEstimated finish time is recomputed from the device's remaining-time estimate on every poll, which can drift or get revised by a minute or two between updates. Raise the minimum-change value below to hold the sensor at its last reported value until the estimate moves by at least that many minutes, cutting down on history/logbook noise. Set it to 0 to report every computed change.",
+        "description": "Some devices accept certain writes (e.g. default detergent/softener dosing on a washer) even while reporting remote control off. By default, LocalThings blocks every write with a clear error whenever a device reports remote control off, rather than letting the device silently reject it. Only enable this if you've confirmed writes actually work on this device with remote control off -- otherwise you'll trade that clear error for a silent failure.\n\nEstimated finish time is recomputed from the device's remaining-time estimate on every poll, which can drift or get revised by a minute or two between updates. Raise the minimum-change value below to hold the sensor at its last reported value until the estimate moves by at least that many minutes, cutting down on history/logbook noise. Set it to 0 to report every computed change.\n\nSome models report a mode they never list as supported -- an air conditioner sitting in Quiet that only offers Off/Sleep/Speed, for instance. LocalThings remembers any such mode it sees and keeps offering it, so it stays selectable once the device has been in it at least once. Turn this off to offer only what the device advertises; use \"Forget remembered modes\" on the previous screen to clear what has already been remembered.\n\nA laundry device with cloud-downloaded cycles gets a reminder here once it's reported one Home Assistant can't offer yet -- some devices report one even if you've never opened the SmartThings app's \"Download cycles\" screen yourself. Turn this off to stop that reminder and hide any already-named downloaded cycles from the cycle list; nothing already set up is lost, and turning it back on brings it right back.",
         "data": {
           "bypass_remote_control_lock": "Allow writes even when remote control is reported off",
-          "finish_time_hysteresis_minutes": "Estimated finish -- minimum change (minutes)"
+          "finish_time_hysteresis_minutes": "Estimated finish -- minimum change (minutes)",
+          "learn_device_modes": "Remember modes the device reports but doesn't advertise",
+          "cloud_courses_enabled": "Offer downloaded cycles"
         }
       },
+      "forget_learned_modes": {
+        "title": "Forget remembered modes",
+        "description": "Currently remembered: {codes}\n\nThese are modes this device reported itself in without listing them as supported, kept so they stay selectable. Forgetting them is the fix if one turned out to be bogus -- anything the device genuinely reports again will simply be remembered again, unless you also turn off \"Remember modes the device reports but doesn't advertise\" in Device settings."
+      },
       "debug_write": {
         "title": "Debug: write to a resource",
         "description": "Power-user tool for pinning down device-specific write behavior. Pick the resource (href) you want to write to, or type a custom one that isn't listed. This bypasses the remote-control-off block and sends exactly the fields you provide -- it can misconfigure your appliance, so use it deliberately.",
@@ -1293,20 +1587,63 @@
           "debug_write": "Write another resource",
           "finish": "Finish"
         }
+      },
+      "cloud_manual": {
+        "title": "Download cycles",
+        "description": "This appliance reports {total} downloaded cycle(s); {found} have been seen so far.\n\nA downloaded cycle's settings are only visible while that cycle is loaded, and the appliance never reports their names. To add the missing ones ({pending}): in the SmartThings app (not on the appliance itself), open this appliance and tap \"Download cycles\" -- a separate row from \"Cycle\", further down the screen, and the one that matters here. Step through each downloaded program in turn, pausing a few seconds on each so LocalThings can see it, then come back here.\n\nGive each one the name you want to see in Home Assistant. Leave a name blank to keep that cycle out of the cycle list. Names must be unique.\n\nThe Download cycle is the course on this appliance that runs a downloaded program. It is detected automatically, but confirm it here before use: selecting a downloaded cycle writes this course code to the appliance.",
+        "data": {
+          "download_course": "Download cycle course code"
+        }
+      },
+      "cloud_courses": {
+        "title": "Download cycles",
+        "description": "Guided setup walks you through it: in the SmartThings app (not on the appliance itself), open this appliance and tap \"Download cycles\" -- a separate row from \"Cycle\", further down the screen, and the one that matters here. Pick a cycle there, then come back and name it as it's found, one at a time.\n\nEdit names shows everything found so far at once — use it to rename or correct something later. Naming works either way, but a named cycle is only offered as a selectable cycle while \"Offer downloaded cycles\" is on in Device settings.",
+        "menu_options": {
+          "cloud_guided": "Guided setup",
+          "cloud_manual": "Edit names"
+        }
+      },
+      "cloud_wait": {
+        "title": "Download cycles"
+      },
+      "cloud_name": {
+        "title": "Name this cycle",
+        "description": "The appliance's \"Download cycles\" slot now holds a new cycle (slot {slot}) and reports {remaining} remaining.\n\nGive it the name you want to see in Home Assistant, then in the SmartThings app's \"Download cycles\" screen pick the next one that isn't already marked \"Downloaded\". Leave it blank to keep this cycle out of the list.\n\nNamed so far ({named} of {total}): {named_list}\n\nNames must be unique. You can close this dialog whenever you like — names are saved as you go.",
+        "data": {
+          "name": "Name",
+          "download_course": "Download cycle course code"
+        }
+      },
+      "cloud_timeout": {
+        "title": "No cycle selected",
+        "description": "Nothing changed on the appliance. Make sure you tapped \"Download cycles\" in the SmartThings app -- a separate row from \"Cycle\", further down the screen -- and picked one that wasn't already marked \"Downloaded\", then tapped Done.\n\nNamed so far ({named} of {total}): {named_list}\n\nEverything named so far is already saved.",
+        "menu_options": {
+          "cloud_guided": "Wait again",
+          "cloud_finish": "Finish"
+        }
       }
     },
     "error": {
       "empty_payload": "Enter at least one field to write.",
-      "write_failed": "The write failed. Check the Home Assistant logs for details."
+      "write_failed": "The write failed. Check the Home Assistant logs for details.",
+      "cloud_course_name_duplicate": "Two cycles have the same name. Names must be unique.",
+      "cloud_course_unknown_course": "That course isn't one this appliance offers. Pick one from the list."
     },
     "abort": {
       "not_loaded": "This device isn't connected yet. Try again once it has loaded."
+    },
+    "progress": {
+      "cloud_wait": "In the SmartThings app (not on the appliance itself), open this appliance and tap \"Download cycles\" -- a separate row from \"Cycle\", further down the screen, that lists only the cycles this can detect. Pick one that isn't already marked \"Downloaded\", then tap Done.\n\nThe appliance doesn't need to be nearby or running the cycle -- just powered on and connected.\n\nNamed so far ({named} of {total}): {named_list}\n\nYou can close this dialog at any time — names are saved as you go."
     }
   },
   "issues": {
     "device_gap": {
       "title": "Incomplete capability coverage for {device_name}",
       "description": "This device is missing full capability coverage. Either its appliance type wasn't recognized, or some of the resources it exposes aren't modeled yet. It'll keep working with whatever is already supported. You can help expand support by going to Settings > Devices & Services > {device_name} > the menu (top right) > Download diagnostics, then filing it with the linked issue template."
+    },
+    "cloud_courses_undiscovered": {
+      "title": "Downloaded cycles not set up for {device_name}",
+      "description": "{device_name} has {pending} of {total} downloaded cycle(s) that Home Assistant can't offer yet. A downloaded cycle can only be used once the appliance has been seen with it loaded -- in the SmartThings app's \"Download cycles\" screen, not the \"Cycle\" one -- and you've given it a name.\n\nTo set them up, go to Settings > Devices & Services > LocalThings > {device_name} > Configure > Download cycles and follow the instructions there.\n\nDon't use downloaded cycles? Go to Configure > Device settings instead and turn off \"Offer downloaded cycles\" to silence this reminder for good."
     }
   },
   "exceptions": {
@@ -1327,6 +1664,30 @@
     },
     "intensive_unavailable_for_cycle": {
       "message": "Intensive isn't available on the selected cycle."
+    },
+    "command_failed": {
+      "message": "The command to {href} failed even after reconnecting: {error}"
+    },
+    "debug_read_failed": {
+      "message": "The read from {href} failed: {error}"
+    },
+    "debug_too_many_writes": {
+      "message": "Provide between 1 and 10 writes."
+    },
+    "debug_settle_out_of_range": {
+      "message": "settle must be between 0 and 30 seconds."
+    },
+    "debug_verify_after_out_of_range": {
+      "message": "verify_after must be between 0 and 60 seconds."
+    },
+    "service_device_target_invalid": {
+      "message": "This service requires exactly one target device."
+    },
+    "service_device_not_found": {
+      "message": "No matching device was found for that target."
+    },
+    "service_device_not_loaded": {
+      "message": "This device isn't connected yet. Try again once it has loaded."
     }
   }
 }

custom_components/localthings/translations/es.json

@@ -53,17 +53,25 @@
         "title": "Opciones de LocalThings",
         "menu_options": {
           "settings": "Ajustes del dispositivo",
+          "cloud_courses": "Ciclos descargados",
+          "forget_learned_modes": "Olvidar los modos recordados",
           "debug_write": "Depuración: escribir en un recurso"
         }
       },
       "settings": {
         "title": "Ajustes del dispositivo",
-        "description": "Algunos dispositivos aceptan ciertas escrituras (p. ej. la dosificación por defecto de detergente/suavizante en una lavadora) incluso cuando informan de control remoto desactivado. Por defecto, LocalThings bloquea cada escritura con un error claro cuando un dispositivo informa de control remoto desactivado, en lugar de dejar que el dispositivo la rechace en silencio. Solo actívalo si has confirmado que las escrituras funcionan de verdad en este dispositivo con el control remoto desactivado; si no, cambiarás ese error claro por un fallo silencioso.\n\nLa hora estimada de finalización se recalcula a partir de la estimación de tiempo restante del dispositivo en cada sondeo, que puede variar o revisarse uno o dos minutos entre actualizaciones. Sube el valor de cambio mínimo siguiente para mantener el sensor en su último valor notificado hasta que la estimación varíe al menos esa cantidad de minutos, reduciendo el ruido en el historial/registro de actividad. Ponlo a 0 para notificar cada cambio calculado.",
+        "description": "Algunos dispositivos aceptan ciertas escrituras (p. ej. la dosificación por defecto de detergente/suavizante en una lavadora) incluso cuando informan de control remoto desactivado. Por defecto, LocalThings bloquea cada escritura con un error claro cuando un dispositivo informa de control remoto desactivado, en lugar de dejar que el dispositivo la rechace en silencio. Solo actívalo si has confirmado que las escrituras funcionan de verdad en este dispositivo con el control remoto desactivado; si no, cambiarás ese error claro por un fallo silencioso.\n\nLa hora estimada de finalización se recalcula a partir de la estimación de tiempo restante del dispositivo en cada sondeo, que puede variar o revisarse uno o dos minutos entre actualizaciones. Sube el valor de cambio mínimo siguiente para mantener el sensor en su último valor notificado hasta que la estimación varíe al menos esa cantidad de minutos, reduciendo el ruido en el historial/registro de actividad. Ponlo a 0 para notificar cada cambio calculado.\n\nAlgunos modelos notifican un modo que nunca incluyen entre los admitidos: por ejemplo, un aire acondicionado en modo Quiet que solo ofrece Off/Sleep/Speed. LocalThings recuerda cualquier modo así que detecte y lo sigue ofreciendo, de modo que quede seleccionable en cuanto el dispositivo haya estado en él al menos una vez. Desactívalo para ofrecer solo lo que el dispositivo anuncia; usa «Olvidar los modos recordados» en la pantalla anterior para borrar lo ya recordado. Un dispositivo de lavandería con ciclos descargados de la nube recibe aquí un aviso en cuanto informa de uno que Home Assistant aún no puede ofrecer -- algunos dispositivos informan de uno incluso si nunca has abierto tú mismo la pantalla \"Descarga de Programas\" de la app SmartThings. Desactiva esto para detener ese aviso y ocultar los ciclos descargados ya nombrados de la lista de ciclos; no se pierde nada de lo ya configurado, y al volver a activarlo reaparece de inmediato.",
         "data": {
           "bypass_remote_control_lock": "Permitir escrituras incluso cuando el control remoto se notifica como desactivado",
-          "finish_time_hysteresis_minutes": "Finalización estimada -- cambio mínimo (minutos)"
+          "finish_time_hysteresis_minutes": "Finalización estimada -- cambio mínimo (minutos)",
+          "learn_device_modes": "Recordar los modos que el dispositivo notifica pero no anuncia",
+          "cloud_courses_enabled": "Ofrecer ciclos descargados"
         }
       },
+      "forget_learned_modes": {
+        "title": "Olvidar los modos recordados",
+        "description": "Recordados actualmente: {codes}\n\nSon modos en los que este dispositivo se notificó a sí mismo sin incluirlos entre los admitidos; se conservan para que sigan siendo seleccionables. Olvidarlos es la solución si alguno resultó ser erróneo: cualquier modo que el dispositivo vuelva a notificar de verdad se recordará otra vez, salvo que además desactives «Recordar los modos que el dispositivo notifica pero no anuncia» en los ajustes del dispositivo."
+      },
       "debug_write": {
         "title": "Depuración: escribir en un recurso",
         "description": "Herramienta para usuarios avanzados para precisar el comportamiento de escritura específico del dispositivo. Elige el recurso (href) sobre el que quieres escribir, o escribe uno personalizado que no esté en la lista. Esto omite el bloqueo de control remoto desactivado y envía exactamente los campos que proporciones; puede desconfigurar tu electrodoméstico, así que úsalo deliberadamente.",
@@ -85,20 +93,63 @@
           "debug_write": "Escribir otro recurso",
           "finish": "Finalizar"
         }
+      },
+      "cloud_manual": {
+        "title": "Ciclos descargados",
+        "description": "Este dispositivo informa de {total} ciclos descargados; se han detectado {found} hasta ahora.\n\nLos ajustes de un ciclo descargado solo son visibles mientras ese ciclo está cargado, y el dispositivo nunca informa de sus nombres. Para añadir los que faltan ({pending}): en la app SmartThings (no en el dispositivo), abre este dispositivo y toca \"Descarga de Programas\" -- una fila aparte de \"Ciclo\", más abajo en la pantalla, y la que importa aquí. Ve pasando por cada programa descargado uno a uno, deteniéndote unos segundos en cada uno para que LocalThings pueda detectarlo, y vuelve aquí.\n\nDa a cada uno el nombre que quieras ver en Home Assistant. Deja un nombre en blanco para mantener ese ciclo fuera de la lista de ciclos. Los nombres deben ser únicos.\n\nDescarga de Programas es el programa de este dispositivo que ejecuta un ciclo descargado. Se detecta automáticamente, pero confírmalo aquí antes de usarlo: seleccionar un ciclo descargado escribe este código de programa en el dispositivo.",
+        "data": {
+          "download_course": "Código de programa de Descarga de Programas"
+        }
+      },
+      "cloud_courses": {
+        "title": "Ciclos descargados",
+        "description": "La configuración guiada te acompaña: en la app SmartThings (no en el dispositivo), abre este dispositivo y toca \"Descarga de Programas\" -- una fila aparte de \"Ciclo\", más abajo en la pantalla, y la que importa aquí. Elige un ciclo allí, vuelve aquí y ponle nombre en cuanto se detecte, uno por uno.\n\nEditar nombres muestra todo lo encontrado hasta ahora de una vez — úsalo más adelante para renombrar o corregir algo. Nombrar funciona en cualquier caso, pero un ciclo con nombre solo se ofrece como ciclo seleccionable mientras \"Ofrecer ciclos descargados\" esté activado en los ajustes del dispositivo.",
+        "menu_options": {
+          "cloud_guided": "Configuración guiada",
+          "cloud_manual": "Editar nombres"
+        }
+      },
+      "cloud_wait": {
+        "title": "Ciclos descargados"
+      },
+      "cloud_name": {
+        "title": "Nombra este ciclo",
+        "description": "La ranura \"Descarga de Programas\" del dispositivo ahora tiene un ciclo nuevo (ranura {slot}) e informa de {remaining} restantes.\n\nDale el nombre que quieras ver en Home Assistant y luego, en la pantalla \"Descarga de Programas\" de la app SmartThings, elige el siguiente que no esté ya marcado como \"Descargado\". Déjalo en blanco para mantener este ciclo fuera de la lista.\n\nNombrados hasta ahora ({named} de {total}): {named_list}\n\nLos nombres deben ser únicos. Puedes cerrar este cuadro de diálogo cuando quieras — los nombres se guardan sobre la marcha.",
+        "data": {
+          "name": "Nombre",
+          "download_course": "Código de programa de Descarga de Programas"
+        }
+      },
+      "cloud_timeout": {
+        "title": "No se seleccionó ningún ciclo",
+        "description": "No ha cambiado nada en el dispositivo. Asegúrate de haber tocado \"Descarga de Programas\" en la app SmartThings -- una fila aparte de \"Ciclo\", más abajo en la pantalla -- y de haber elegido uno que no estuviera ya marcado como \"Descargado\", y luego tocado Hecho.\n\nNombrados hasta ahora ({named} de {total}): {named_list}\n\nTodo lo nombrado hasta ahora ya está guardado.",
+        "menu_options": {
+          "cloud_guided": "Esperar de nuevo",
+          "cloud_finish": "Finalizar"
+        }
       }
     },
     "error": {
       "empty_payload": "Introduce al menos un campo para escribir.",
-      "write_failed": "La escritura falló. Consulta los registros de Home Assistant para más detalles."
+      "write_failed": "La escritura falló. Consulta los registros de Home Assistant para más detalles.",
+      "cloud_course_name_duplicate": "Dos ciclos tienen el mismo nombre. Los nombres deben ser únicos.",
+      "cloud_course_unknown_course": "Ese programa no es uno que ofrezca este dispositivo. Elige uno de la lista."
     },
     "abort": {
       "not_loaded": "Este dispositivo aún no está conectado. Inténtalo de nuevo cuando se haya cargado."
+    },
+    "progress": {
+      "cloud_wait": "En la app SmartThings (no en el dispositivo), abre este dispositivo y toca \"Descarga de Programas\" -- una fila aparte de \"Ciclo\", más abajo en la pantalla, que solo lista los ciclos que se pueden detectar así. Elige uno que no esté ya marcado como \"Descargado\" y toca Hecho.\n\nEl dispositivo no necesita estar cerca ni ejecutando el ciclo -- solo encendido y conectado.\n\nNombrados hasta ahora ({named} de {total}): {named_list}\n\nPuedes cerrar este cuadro de diálogo en cualquier momento — los nombres se guardan sobre la marcha."
     }
   },
   "issues": {
     "device_gap": {
       "title": "Cobertura de capacidades incompleta para {device_name}",
       "description": "A este dispositivo le falta cobertura completa de capacidades. O su tipo de electrodoméstico no fue reconocido, o algunos de los recursos que expone aún no están modelados. Seguirá funcionando con lo que ya está soportado. Puedes ayudar a ampliar el soporte yendo a Ajustes > Dispositivos y servicios > {device_name} > el menú (arriba a la derecha) > Descargar diagnósticos, y reportándolo con la plantilla de incidencia enlazada."
+    },
+    "cloud_courses_undiscovered": {
+      "title": "Ciclos descargados sin configurar para {device_name}",
+      "description": "{device_name} tiene {pending} de {total} ciclos descargados que Home Assistant todavía no puede ofrecer. Un ciclo descargado solo se puede usar una vez que el dispositivo se ha visto con él cargado -- en la pantalla \"Descarga de Programas\" de la app SmartThings, no en la de \"Ciclo\" -- y le has dado un nombre.\n\nPara configurarlos, ve a Ajustes > Dispositivos y servicios > LocalThings > {device_name} > Configurar > Ciclos descargados y sigue las instrucciones que aparecen allí.\n\n¿No usas ciclos descargados? Ve a Configurar > Ajustes del dispositivo y desactiva \"Ofrecer ciclos descargados\" para silenciar este aviso definitivamente."
     }
   },
   "exceptions": {
@@ -119,6 +170,30 @@
     },
     "intensive_unavailable_for_cycle": {
       "message": "El modo intensivo no está disponible en el ciclo seleccionado."
+    },
+    "command_failed": {
+      "message": "El comando para {href} falló incluso después de reconectar: {error}"
+    },
+    "debug_read_failed": {
+      "message": "La lectura desde {href} falló: {error}"
+    },
+    "debug_too_many_writes": {
+      "message": "Proporciona entre 1 y 10 escrituras."
+    },
+    "debug_settle_out_of_range": {
+      "message": "settle debe estar entre 0 y 30 segundos."
+    },
+    "debug_verify_after_out_of_range": {
+      "message": "verify_after debe estar entre 0 y 60 segundos."
+    },
+    "service_device_target_invalid": {
+      "message": "Este servicio requiere exactamente un dispositivo de destino."
+    },
+    "service_device_not_found": {
+      "message": "No se encontró ningún dispositivo coincidente para ese destino."
+    },
+    "service_device_not_loaded": {
+      "message": "Este dispositivo aún no está conectado. Vuelve a intentarlo cuando se haya cargado."
     }
   },
   "entity": {
@@ -228,8 +303,17 @@
       "softener_low": {
         "name": "Poco suavizante"
       },
+      "add_wash_available": {
+        "name": "AddWash permitido"
+      },
+      "add_wash_indicator": {
+        "name": "AddWash disponible"
+      },
       "auto_clean_running": {
         "name": "Limpieza automática en curso"
+      },
+      "stick_ble_connected": {
+        "name": "Aspiradora conectada por BLE"
       }
     },
     "button": {
@@ -239,6 +323,12 @@
       "diagnosis_start": {
         "name": "Iniciar diagnóstico"
       },
+      "auto_clean_stop": {
+        "name": "Detener la autolimpieza"
+      },
+      "filter_time_reset": {
+        "name": "Restablecer el contador del filtro"
+      },
       "pause": {
         "name": "Pausar"
       },
@@ -268,11 +358,13 @@
               "smart": "Inteligente",
               "speed": "Rápido",
               "nano": "WindFree",
+              "sleep": "Sueño",
               "nanosleep": "WindFree sueño",
               "longwind": "Viento prolongado",
               "motionindirect": "Indirecto al movimiento",
               "motiondirect": "Directo al movimiento",
               "drycomfort": "Confort seco",
+              "dlightcool": "d'light Cool",
               "2step": "2 pasos"
             }
           }
@@ -313,6 +405,9 @@
       "oven_setpoint": {
         "name": "Punto de ajuste"
       },
+      "sensing_interval": {
+        "name": "Intervalo de AI Purify"
+      },
       "setpoint": {
         "name": "Punto de ajuste"
       },
@@ -336,6 +431,9 @@
       "air_filter_threshold": {
         "name": "Umbral de alarma del filtro"
       },
+      "auto_door_timer": {
+        "name": "Temporizador de apertura automática de puerta"
+      },
       "beverage_zone_mode": {
         "name": "Modo de zona de bebidas",
         "state": {
@@ -366,7 +464,11 @@
         "name": "Volumen",
         "state": {
           "off": "Apagado",
-          "on": "Encendido"
+          "on": "Encendido",
+          "volume_off": "Apagado",
+          "volume_low": "Bajo",
+          "volume_med": "Medio",
+          "volume_high": "Alto"
         }
       },
       "discharging_time": {
@@ -408,7 +510,16 @@
           "07": "Prelavado intenso",
           "8d": "Ollas y sartenes",
           "8e": "Plástico",
-          "8f": "Cuidado del bebé"
+          "8f": "Cuidado del bebé",
+          "82": "Automático",
+          "8a": "Normal",
+          "a7": "Intenso",
+          "a8": "Express",
+          "8c": "Extra silencioso",
+          "88": "Autolimpieza",
+          "85": "Delicado",
+          "0c": "Express",
+          "0d": "Autolimpieza"
         }
       },
       "dispense_type": {
@@ -423,6 +534,35 @@
           "4": "Alarma 4"
         }
       },
+      "dryer_cycle_table_00": {
+        "name": "Ciclo",
+        "state": {
+          "01": "Normal",
+          "9c": "Servicio intensivo",
+          "a5": "Ropa de cama",
+          "9e": "Planchado fácil",
+          "9b": "Desinfección por vapor+",
+          "27": "Renovar",
+          "a0": "Aireación",
+          "a4": "Secado por tiempo",
+          "a6": "Secado rápido",
+          "a3": "Ropa deportiva",
+          "a2": "Delicados",
+          "9a": "Algodón",
+          "ca": "Aireación",
+          "db": "Súper velocidad",
+          "99": "Carga mixta",
+          "93": "Planchado fácil",
+          "b5": "Lana",
+          "d7": "Cuidado para exterior",
+          "96": "Aire frío",
+          "97": "Aire caliente",
+          "7f": "Secado por tiempo",
+          "98": "Secado rápido 35",
+          "eb": "Delicados",
+          "b6": "Sintéticos"
+        }
+      },
       "dryer_cycle_table_03": {
         "name": "Ciclo",
         "state": {
@@ -450,7 +590,27 @@
           "4c": "Renovación de aire",
           "51": "Eco algodón",
           "53": "Secado IA+",
-          "4e": "Autosecado"
+          "4e": "Autosecado",
+          "26": "Aireación",
+          "2a": "Cuidado higiénico+",
+          "02": "Secado IA",
+          "03": "Súper velocidad",
+          "05": "Ropa de cama",
+          "07": "Delicados",
+          "09": "Camisas",
+          "0b": "Cuidado de acolchados",
+          "0c": "Cuidado hidrófugo para exterior",
+          "0e": "Toallas",
+          "0f": "Lana",
+          "11": "Aire frío",
+          "28": "Desinfección interior con aire caliente",
+          "37": "Blusas",
+          "38": "Planchado fácil",
+          "39": "Deshumidificación de habitación",
+          "3a": "Cuidado higiénico",
+          "3b": "Ropa de cama/Antipolvo",
+          "3c": "Ropa deportiva",
+          "3d": "Denim"
         }
       },
       "favorite_capacity": {
@@ -572,9 +732,11 @@
           "kimchi_storage_crunfch": "Kimchi crujiente",
           "kimchi_storage_buy": "Kimchi comprado",
           "storage_fridge_normal": "Frigorífico",
+          "storage_fridge": "Frigorífico",
           "storage_fridge_cold": "Frigorífico, fuerte",
           "storage_fridge_warm": "Frigorífico, suave",
           "storage_freezer_normal": "Congelador",
+          "storage_freezer": "Congelador",
           "storage_freezer_cold": "Congelador, fuerte",
           "storage_freezer_warm": "Congelador, suave",
           "kimchi_ripe_low_temp": "Maduración kimchi, baja temperatura",
@@ -587,7 +749,8 @@
           "storage_fresh_cereal": "Cereales",
           "storage_fridge_drink": "Bebidas",
           "storage_fresh_wine": "Vino",
-          "storage_fresh_potato_banana": "Patata y plátano"
+          "storage_fresh_potato_banana": "Patata y plátano",
+          "newmode_kimchi_0000": "Modo nuevo"
         }
       },
       "pantry_zone_mode": {
@@ -598,6 +761,16 @@
           "fdr_drinks": "Bebidas"
         }
       },
+      "winecellar_pantry_zone_mode": {
+        "name": "Modo de zona de despensa",
+        "state": {
+          "processed_meat": "Embutidos",
+          "cheese": "Queso",
+          "nuts": "Frutos secos",
+          "fruit": "Fruta",
+          "wine": "Vino"
+        }
+      },
       "range_burner_power_level": {
         "name": "Nivel de potencia del fuego {number}",
         "state": {
@@ -616,6 +789,14 @@
       "rinse_cycles": {
         "name": "Aclarados"
       },
+      "sensing_mode": {
+        "name": "Acción de AI Purify",
+        "state": {
+          "off": "Solo medición",
+          "airpurify": "Limpieza automática",
+          "alarm": "Recibir notificación"
+        }
+      },
       "softener_concentration": {
         "name": "Concentración del suavizante",
         "state": {
@@ -641,6 +822,9 @@
           "mute": "Silencio"
         }
       },
+      "energy_saving_mode": {
+        "name": "Modo de ahorro de energía"
+      },
       "air_purifier_sound_mode": {
         "name": "Modo de sonido",
         "state": {
@@ -677,12 +861,51 @@
           "extra_hot": "Muy caliente"
         }
       },
+      "washer_cycle_table_00": {
+        "name": "Ciclo",
+        "state": {
+          "01": "Normal",
+          "70": "Servicio intensivo",
+          "55": "Blancos",
+          "71": "Ropa de cama",
+          "72": "Desinfección",
+          "77": "Planchado fácil",
+          "57": "Autolimpieza+",
+          "73": "Aclarar + Centrifugar",
+          "74": "Ropa deportiva",
+          "75": "Delicados",
+          "78": "Lavado rápido"
+        }
+      },
       "washer_cycle_table_02": {
         "name": "Ciclo",
         "state": {
           "01": "Normal",
+          "02": "Servicio Extra Intensivo",
+          "03": "Super Eco",
           "04": "Lavado rápido",
+          "05": "Lana/Lencería",
+          "06": "Ropa de cama",
+          "07": "Exterior",
+          "08": "Aclarar + Centrifugar",
+          "09": "Limpieza de Tambor",
+          "0a": "Toallas",
+          "0b": "Lavado a ebullición",
+          "0c": "Cuidado del bebé",
+          "0d": "Solo centrifugar",
+          "0e": "Día nublado",
+          "0f": "Lavado puro",
+          "10": "Secado-centrifugado",
+          "11": "Ropa de cama de verano",
+          "12": "Algodón",
+          "13": "Algodón negro",
+          "14": "Ropa interior delicada",
+          "15": "Ropa deportiva",
+          "16": "Blusas",
           "17": "Descargado",
+          "18": "Burbuja suave",
+          "19": "Lavado IA",
+          "1a": "Camisas",
           "1b": "Algodón",
           "1c": "Eco 40-60",
           "1d": "Súper velocidad",
@@ -692,7 +915,7 @@
           "21": "Color",
           "22": "Lana",
           "23": "Exterior",
-          "24": "Toallas",
+          "24": "Ropa de cama",
           "25": "Sintéticos",
           "26": "Delicados",
           "27": "Aclarar + Centrifugar",
@@ -705,8 +928,9 @@
           "2f": "Ropa deportiva",
           "30": "Día nublado",
           "32": "Camisas",
-          "33": "Ropa de cama",
+          "33": "Toallas",
           "34": "Mezcla",
+          "35": "Algodón E",
           "36": "Lavado + Secado",
           "37": "Lavado con aire",
           "38": "Secado de algodón",
@@ -721,14 +945,34 @@
           "60": "Autolimpieza+",
           "65": "Color",
           "66": "Denim",
+          "69": "Lavado IA",
+          "6a": "Lana",
+          "6b": "Denim",
+          "6c": "Blusas",
+          "6d": "Delicados",
+          "6e": "Ropa deportiva",
+          "6f": "Ropa de cama",
+          "70": "Toallas",
+          "71": "Lavado rápido",
+          "72": "Camisas",
+          "73": "Desinfección",
+          "74": "Limpieza de Tambor",
+          "75": "Exterior",
+          "76": "Cuidado del bebé",
+          "77": "Algodón",
+          "78": "Aclarar + Centrifugar",
+          "79": "Solo centrifugar",
           "7c": "Blancos",
           "7d": "Ropa de cama / Impermeable",
           "7e": "Autolimpieza",
           "7f": "Lana / Delicados",
           "86": "Lavado profundo",
           "87": "Descarga de Programas",
+          "88": "Cuidado de mascotas",
           "8f": "Lavado en frío",
-          "96": "Menos microfibras"
+          "96": "Menos microfibras",
+          "a0": "Lavado rápido 15'",
+          "b0": "Carga mixta"
         }
       },
       "washer_dry_level": {
@@ -768,6 +1012,38 @@
       },
       "freezer_temperature_setpoint": {
         "name": "Temperatura del congelador"
+      },
+      "edge_lighting_mode": {
+        "name": "Modo de iluminación perimetral",
+        "state": {
+          "smart": "Inteligente",
+          "high": "Alto",
+          "low": "Bajo"
+        }
+      },
+      "edge_lighting_color": {
+        "name": "Color de iluminación perimetral",
+        "state": {
+          "3000k": "3000 K",
+          "4000k": "4000 K",
+          "6500k": "6500 K"
+        }
+      },
+      "indicator_light_mode": {
+        "name": "Modo de luz indicadora",
+        "state": {
+          "smart": "Inteligente",
+          "high": "Alto",
+          "low": "Bajo"
+        }
+      },
+      "ventilation_mode": {
+        "name": "Modo",
+        "state": {
+          "purification": "Purificación",
+          "ventilation": "Ventilación",
+          "smartventilation": "Ventilación inteligente"
+        }
       }
     },
     "sensor": {
@@ -780,6 +1056,9 @@
       "air_filter_usage_hours": {
         "name": "Horas de uso del filtro"
       },
+      "deodor_filter_usage": {
+        "name": "Uso del filtro"
+      },
       "air_quality_standard": {
         "name": "Estándar de calidad del aire"
       },
@@ -853,6 +1132,12 @@
       "stick_status": {
         "name": "Estado de la aspiradora"
       },
+      "stick_operation_mode": {
+        "name": "Modo de funcionamiento de la aspiradora"
+      },
+      "stick_cleaning_status": {
+        "name": "Estado de limpieza de la aspiradora"
+      },
       "uvc_operation_time": {
         "name": "Tiempo de funcionamiento UV-C"
       },
@@ -887,6 +1172,12 @@
           "indirect": "Indirecto"
         }
       },
+      "energy_saving_state": {
+        "name": "Estado de ahorro de energía"
+      },
+      "energy_saving_operating_status": {
+        "name": "Estado de funcionamiento del ahorro de energía"
+      },
       "current_temp_c": {
         "name": "Temperatura"
       },
@@ -894,10 +1185,16 @@
         "name": "Temperatura"
       },
       "diagnosis": {
-        "name": "Diagnóstico"
+        "name": "Diagnóstico",
+        "state": {
+          "ready": "Listo"
+        }
       },
       "diagnosis_status": {
-        "name": "Estado del diagnóstico"
+        "name": "Estado del diagnóstico",
+        "state": {
+          "ready": "Listo"
+        }
       },
       "drum_clean_cycles_remaining": {
         "name": "Limpieza de tambor en"
@@ -912,7 +1209,10 @@
         "name": "Tiempo de secado"
       },
       "dryer_type": {
-        "name": "Tipo de secadora"
+        "name": "Tipo de secadora",
+        "state": {
+          "electricity": "Electricidad"
+        }
       },
       "dust": {
         "name": "Polvo"
@@ -1041,7 +1341,23 @@
         "name": "Temperatura de la sonda"
       },
       "progress": {
-        "name": "Progreso"
+        "name": "Progreso",
+        "state": {
+          "idle": "Inactiva",
+          "weightsensing": "Detección de carga",
+          "wash": "Lavado",
+          "rinse": "Aclarado",
+          "spin": "Centrifugado",
+          "finish": "Finalizado",
+          "steaming": "Vaporización",
+          "airwashing": "Lavado con aire",
+          "drying": "Secado",
+          "dryingwithdooropen": "Ventilación",
+          "cooling": "Enfriamiento",
+          "predrain": "Drenaje previo",
+          "prewash": "Prelavado",
+          "sanitizing": "Desinfección"
+        }
       },
       "progress_percentage": {
         "name": "Porcentaje de progreso"
@@ -1143,6 +1459,9 @@
       "absence_power_saving_active": {
         "name": "Ahorro por ausencia activo"
       },
+      "absence_clean": {
+        "name": "Limpieza por ausencia"
+      },
       "motion_detect_wind_active": {
         "name": "Evitación de viento por detección de movimiento activa"
       },
@@ -1152,6 +1471,12 @@
       "display": {
         "name": "Pantalla"
       },
+      "periodic_air_sensing": {
+        "name": "AI Purify"
+      },
+      "periodic_sensing_skip_status": {
+        "name": "Omisión de medición de AI Purify"
+      },
       "pet_filter_activation": {
         "name": "Activación de filtro para mascotas"
       },
@@ -1170,6 +1495,12 @@
       "auto_door_opener": {
         "name": "Apertura automática de puerta"
       },
+      "auto_door_sound_control": {
+        "name": "Sonido de apertura automática de puerta"
+      },
+      "auto_door_voice_control": {
+        "name": "Control por voz de apertura automática de puerta"
+      },
       "auto_release_dry": {
         "name": "Liberación automática de secado"
       },
@@ -1236,6 +1567,18 @@
       "intensive": {
         "name": "Intensivo"
       },
+      "add_wash_alarm": {
+        "name": "Aviso AddWash"
+      },
+      "add_wash_alarm_rinse": {
+        "name": "AddWash en aclarado"
+      },
+      "add_wash_alarm_final_rinse": {
+        "name": "AddWash en último aclarado"
+      },
+      "add_wash_alarm_spin": {
+        "name": "AddWash en centrifugado"
+      },
       "lamp": {
         "name": "Lámpara"
       },
@@ -1301,6 +1644,18 @@
       },
       "ventilation_alarm": {
         "name": "Alarma de ventilación"
+      },
+      "edge_lighting": {
+        "name": "Iluminación perimetral"
+      },
+      "indicator_light": {
+        "name": "Luz indicadora"
+      },
+      "windfree": {
+        "name": "Modo Wind-Free"
+      },
+      "windsleep": {
+        "name": "Modo nocturno"
       }
     },
     "time": {
@@ -1321,6 +1676,12 @@
       },
       "night_start": {
         "name": "Inicio de la luz nocturna"
+      },
+      "sensing_skip_end": {
+        "name": "Fin de la omisión de medición de AI Purify"
+      },
+      "sensing_skip_start": {
+        "name": "Inicio de la omisión de medición de AI Purify"
       }
     },
     "water_heater": {

custom_components/localthings/translations/it.json

@@ -108,6 +108,15 @@
       },
       "softener_low": {
         "name": "Aggiungi ammorbidente"
+      },
+      "add_wash_available": {
+        "name": "AddWash consentito"
+      },
+      "add_wash_indicator": {
+        "name": "AddWash disponibile"
+      },
+      "stick_ble_connected": {
+        "name": "Scopa elettrica connessa via BLE"
       }
     },
     "button": {
@@ -117,6 +126,12 @@
       "diagnosis_start": {
         "name": "Avvia diagnosi"
       },
+      "auto_clean_stop": {
+        "name": "Arresta autopulizia"
+      },
+      "filter_time_reset": {
+        "name": "Azzera il contatore del filtro"
+      },
       "pause": {
         "name": "Pausa"
       },
@@ -146,11 +161,13 @@
               "smart": "Smart",
               "speed": "Veloce",
               "nano": "WindFree",
+              "sleep": "Sonno",
               "nanosleep": "WindFree sonno",
               "longwind": "Vento prolungato",
               "motionindirect": "Indiretto al movimento",
               "motiondirect": "Diretto al movimento",
               "drycomfort": "Comfort asciugatura",
+              "dlightcool": "d'light Cool",
               "2step": "2 fasi"
             }
           }
@@ -191,6 +208,9 @@
       "oven_setpoint": {
         "name": "Valore impostato"
       },
+      "sensing_interval": {
+        "name": "Intervallo AI Purify"
+      },
       "setpoint": {
         "name": "Valore impostato"
       },
@@ -214,6 +234,9 @@
       "air_filter_threshold": {
         "name": "Soglia allarme filtro"
       },
+      "auto_door_timer": {
+        "name": "Timer apertura automatica sportello"
+      },
       "beverage_zone_mode": {
         "name": "Modalità zona bevande",
         "state": {
@@ -244,7 +267,11 @@
         "name": "Suono cicalino",
         "state": {
           "off": "Spento",
-          "on": "Acceso"
+          "on": "Acceso",
+          "volume_off": "Spento",
+          "volume_low": "Basso",
+          "volume_med": "Medio",
+          "volume_high": "Alto"
         }
       },
       "discharging_time": {
@@ -286,7 +313,16 @@
           "07": "Prelavaggio intenso",
           "8d": "Pentole e padelle",
           "8e": "Plastica",
-          "8f": "Bambini"
+          "8f": "Bambini",
+          "82": "Automatico",
+          "8a": "Normale",
+          "a7": "Intenso",
+          "a8": "Express",
+          "8c": "Extra silenzioso",
+          "88": "Autopulizia",
+          "85": "Delicato",
+          "0c": "Express",
+          "0d": "Autopulizia"
         }
       },
       "dispense_type": {
@@ -301,6 +337,35 @@
           "4": "Allarme 4"
         }
       },
+      "dryer_cycle_table_00": {
+        "name": "Ciclo",
+        "state": {
+          "01": "Normale",
+          "9c": "Intenso",
+          "a5": "Biancheria da letto",
+          "9e": "Pronto da stirare",
+          "9b": "Igienizzante a vapore+",
+          "27": "Rinfresca",
+          "a0": "Arieggiatura",
+          "a4": "Asciugatura a tempo",
+          "a6": "Asciugatura rapida",
+          "a3": "Abbigliamento sportivo",
+          "a2": "Delicati",
+          "9a": "Cotone",
+          "ca": "Arieggiatura",
+          "db": "Super Speed",
+          "99": "Carico misto",
+          "93": "Pronto da stirare",
+          "b5": "Lana",
+          "d7": "Cura outdoor",
+          "96": "Aria fredda",
+          "97": "Aria calda",
+          "7f": "Asciugatura a tempo",
+          "98": "Asciugatura rapida 35",
+          "eb": "Delicati",
+          "b6": "Sintetici"
+        }
+      },
       "dryer_cycle_table_03": {
         "name": "Ciclo",
         "state": {
@@ -328,7 +393,27 @@
           "4c": "Rinfresca",
           "51": "Eco cotone",
           "53": "Asciugatura AI+",
-          "4e": "Autoasciugatura"
+          "4e": "Autoasciugatura",
+          "26": "Arieggiatura",
+          "2a": "Cura igienica+",
+          "02": "Asciugatura AI",
+          "03": "Super Speed",
+          "05": "Biancheria da letto",
+          "07": "Delicati",
+          "09": "Camicie",
+          "0b": "Cura piumini",
+          "0c": "Cura idrorepellente outdoor",
+          "0e": "Asciugamani",
+          "0f": "Lana",
+          "11": "Aria fredda",
+          "28": "Sanificazione interna ad aria calda",
+          "37": "Camicette",
+          "38": "Pronto da stirare",
+          "39": "Deumidificazione ambiente",
+          "3a": "Cura igienica",
+          "3b": "Biancheria da letto/Antipolvere",
+          "3c": "Abbigliamento sportivo",
+          "3d": "Jeans"
         }
       },
       "favorite_capacity": {
@@ -450,9 +535,11 @@
           "kimchi_storage_crunfch": "Kimchi croccante",
           "kimchi_storage_buy": "Kimchi acquistato",
           "storage_fridge_normal": "Frigorifero",
+          "storage_fridge": "Frigorifero",
           "storage_fridge_cold": "Frigorifero, forte",
           "storage_fridge_warm": "Frigorifero, debole",
           "storage_freezer_normal": "Congelatore",
+          "storage_freezer": "Congelatore",
           "storage_freezer_cold": "Congelatore, forte",
           "storage_freezer_warm": "Congelatore, debole",
           "kimchi_ripe_low_temp": "Maturazione kimchi, bassa temperatura",
@@ -465,7 +552,8 @@
           "storage_fresh_cereal": "Cereali",
           "storage_fridge_drink": "Bevande",
           "storage_fresh_wine": "Vino",
-          "storage_fresh_potato_banana": "Patate e banane"
+          "storage_fresh_potato_banana": "Patate e banane",
+          "newmode_kimchi_0000": "Nuova modalità"
         }
       },
       "pantry_zone_mode": {
@@ -476,6 +564,16 @@
           "fdr_drinks": "Bevande"
         }
       },
+      "winecellar_pantry_zone_mode": {
+        "name": "Modalità zona dispensa",
+        "state": {
+          "processed_meat": "Salumi",
+          "cheese": "Formaggio",
+          "nuts": "Frutta secca",
+          "fruit": "Frutta",
+          "wine": "Vino"
+        }
+      },
       "range_burner_power_level": {
         "name": "Livello potenza fornello {number}",
         "state": {
@@ -494,6 +592,14 @@
       "rinse_cycles": {
         "name": "Risciacquo"
       },
+      "sensing_mode": {
+        "name": "Azione AI Purify",
+        "state": {
+          "off": "Solo rilevamento",
+          "airpurify": "Pulizia automatica",
+          "alarm": "Ricevi notifica"
+        }
+      },
       "softener_concentration": {
         "name": "Concentrazione ammorbidente",
         "state": {
@@ -519,6 +625,9 @@
           "mute": "Muto"
         }
       },
+      "energy_saving_mode": {
+        "name": "Modalità risparmio energetico"
+      },
       "air_purifier_sound_mode": {
         "name": "Modalità audio",
         "state": {
@@ -555,22 +664,61 @@
           "extra_hot": "Extra caldo"
         }
       },
+      "washer_cycle_table_00": {
+        "name": "Ciclo",
+        "state": {
+          "01": "Normale",
+          "70": "Intenso",
+          "55": "Bianchi",
+          "71": "Biancheria da letto",
+          "72": "Igienizzante",
+          "77": "Pronto da stirare",
+          "57": "Self Clean+",
+          "73": "Risciacquo+Centrifuga",
+          "74": "Abbigliamento sportivo",
+          "75": "Delicati",
+          "78": "Lavaggio rapido"
+        }
+      },
       "washer_cycle_table_02": {
         "name": "Ciclo",
         "state": {
           "01": "Normale",
+          "02": "Extra Intenso",
+          "03": "Super Eco",
           "04": "Lavaggio rapido",
+          "05": "Lana/Lingerie",
+          "06": "Biancheria da letto",
+          "07": "Capi outdoor",
+          "08": "Risciacquo+Centrifuga",
+          "09": "Pulizia cestello",
+          "0a": "Asciugamani",
+          "0b": "Lavaggio a ebollizione",
+          "0c": "Bambini",
+          "0d": "Solo centrifuga",
+          "0e": "Giornata nuvolosa",
+          "0f": "Lavaggio puro",
+          "10": "Asciugatura centrifuga",
+          "11": "Biancheria da letto estiva",
+          "12": "Cotone",
+          "13": "Cotone nero",
+          "14": "Biancheria intima delicata",
+          "15": "Abbigliamento sportivo",
+          "16": "Camicette",
           "17": "Scaricato",
+          "18": "Soft Bubble",
+          "19": "Lavaggio AI",
+          "1a": "Camicie",
           "1b": "Cotone",
           "1c": "Eco 40-60",
           "1d": "Super Speed",
           "1e": "Rapido 15'",
-          "1f": "Intenseo a freddo",
+          "1f": "Intenso a freddo",
           "20": "Vapore igienizzante",
           "21": "Colorati",
           "22": "Lana",
           "23": "Capi outdoor",
-          "24": "Asciugamani",
+          "24": "Biancheria da letto",
           "25": "Sintetici",
           "26": "Delicati",
           "27": "Risciacquo+Centrifuga",
@@ -583,8 +731,9 @@
           "2f": "Abbigliamento sportivo",
           "30": "Giornata nuvolosa",
           "32": "Camicie",
-          "33": "Biancheria da letto",
+          "33": "Asciugamani",
           "34": "Misti",
+          "35": "Cotone E",
           "36": "Lavaggio+Asciugatura",
           "37": "Lavaggio ad aria",
           "38": "Asciugatura cotone",
@@ -599,14 +748,34 @@
           "60": "Self Clean+",
           "65": "Colorati",
           "66": "Jeans",
+          "69": "Lavaggio AI",
+          "6a": "Lana",
+          "6b": "Jeans",
+          "6c": "Camicette",
+          "6d": "Delicati",
+          "6e": "Abbigliamento sportivo",
+          "6f": "Biancheria da letto",
+          "70": "Asciugamani",
+          "71": "Lavaggio rapido",
+          "72": "Camicie",
+          "73": "Igienizzante",
+          "74": "Pulizia cestello",
+          "75": "Capi outdoor",
+          "76": "Bambini",
+          "77": "Cotone",
+          "78": "Risciacquo+Centrifuga",
+          "79": "Solo centrifuga",
           "7c": "Bianchi",
           "7d": "Biancheria da letto/Impermeabile",
           "7e": "Pulizia cestello",
           "7f": "Lana/Delicati",
           "86": "Lavaggio profondo",
           "87": "Scaricato",
+          "88": "Cura animali",
           "8f": "Intenso a freddo",
-          "96": "Riduci microfibre"
+          "96": "Riduci microfibre",
+          "a0": "Rapido 15'",
+          "b0": "Carico misto"
         }
       },
       "washer_dry_level": {
@@ -646,6 +815,38 @@
       },
       "freezer_temperature_setpoint": {
         "name": "Temperatura freezer"
+      },
+      "edge_lighting_mode": {
+        "name": "Modalità illuminazione perimetrale",
+        "state": {
+          "smart": "Smart",
+          "high": "Alta",
+          "low": "Bassa"
+        }
+      },
+      "edge_lighting_color": {
+        "name": "Colore illuminazione perimetrale",
+        "state": {
+          "3000k": "3000 K",
+          "4000k": "4000 K",
+          "6500k": "6500 K"
+        }
+      },
+      "indicator_light_mode": {
+        "name": "Modalità spia luminosa",
+        "state": {
+          "smart": "Smart",
+          "high": "Alta",
+          "low": "Bassa"
+        }
+      },
+      "ventilation_mode": {
+        "name": "Modalità",
+        "state": {
+          "purification": "Purificazione",
+          "ventilation": "Ventilazione",
+          "smartventilation": "Ventilazione intelligente"
+        }
       }
     },
     "sensor": {
@@ -661,6 +862,9 @@
       "air_filter_usage_hours": {
         "name": "Ore di utilizzo filtro"
       },
+      "deodor_filter_usage": {
+        "name": "Utilizzo filtro"
+      },
       "air_quality_standard": {
         "name": "Standard qualità aria"
       },
@@ -734,6 +938,12 @@
       "stick_status": {
         "name": "Stato scopa elettrica"
       },
+      "stick_operation_mode": {
+        "name": "Modalità operativa scopa elettrica"
+      },
+      "stick_cleaning_status": {
+        "name": "Stato pulizia scopa elettrica"
+      },
       "uvc_operation_time": {
         "name": "Tempo funzionamento UV-C"
       },
@@ -768,6 +978,12 @@
           "indirect": "Indiretto"
         }
       },
+      "energy_saving_state": {
+        "name": "Stato risparmio energetico"
+      },
+      "energy_saving_operating_status": {
+        "name": "Stato di funzionamento del risparmio energetico"
+      },
       "current_temp_c": {
         "name": "Temperatura"
       },
@@ -775,10 +991,16 @@
         "name": "Temperatura"
       },
       "diagnosis": {
-        "name": "Diagnosi"
+        "name": "Diagnosi",
+        "state": {
+          "ready": "Pronto"
+        }
       },
       "diagnosis_status": {
-        "name": "Stato diagnosi"
+        "name": "Stato diagnosi",
+        "state": {
+          "ready": "Pronto"
+        }
       },
       "drum_clean_cycles_remaining": {
         "name": "Pulizia cestello fra"
@@ -793,7 +1015,10 @@
         "name": "Tempo di asciugatura"
       },
       "dryer_type": {
-        "name": "Tipo di asciugatrice"
+        "name": "Tipo di asciugatrice",
+        "state": {
+          "electricity": "Elettricità"
+        }
       },
       "dust": {
         "name": "Polvere"
@@ -922,7 +1147,23 @@
         "name": "Temperatura sonda"
       },
       "progress": {
-        "name": "Avanzamento"
+        "name": "Avanzamento",
+        "state": {
+          "idle": "Inattivo",
+          "weightsensing": "Rilevamento del carico",
+          "wash": "Lavaggio",
+          "rinse": "Risciacquo",
+          "spin": "Centrifuga",
+          "finish": "Completato",
+          "steaming": "Vapore",
+          "airwashing": "Lavaggio ad aria",
+          "drying": "Asciugatura",
+          "dryingwithdooropen": "Ventilazione",
+          "cooling": "Raffreddamento",
+          "predrain": "Scarico preliminare",
+          "prewash": "Prelavaggio",
+          "sanitizing": "Igienizzazione"
+        }
       },
       "progress_percentage": {
         "name": "Avanzamento percentuale"
@@ -1021,6 +1262,9 @@
       "absence_power_saving_active": {
         "name": "Risparmio energetico in assenza attivo"
       },
+      "absence_clean": {
+        "name": "Pulizia in assenza"
+      },
       "motion_detect_wind_active": {
         "name": "Elusione flusso d'aria a rilevamento movimento attiva"
       },
@@ -1030,6 +1274,12 @@
       "display": {
         "name": "Display"
       },
+      "periodic_air_sensing": {
+        "name": "AI Purify"
+      },
+      "periodic_sensing_skip_status": {
+        "name": "Esclusione rilevamento AI Purify"
+      },
       "pet_filter_activation": {
         "name": "Attivazione filtro animali"
       },
@@ -1048,6 +1298,12 @@
       "auto_door_opener": {
         "name": "Apertura automatica sportello"
       },
+      "auto_door_sound_control": {
+        "name": "Suono apertura automatica sportello"
+      },
+      "auto_door_voice_control": {
+        "name": "Controllo vocale apertura automatica sportello"
+      },
       "auto_release_dry": {
         "name": "Apertura automatica per asciugatura"
       },
@@ -1114,6 +1370,18 @@
       "intensive": {
         "name": "Intensivo"
       },
+      "add_wash_alarm": {
+        "name": "Avviso AddWash"
+      },
+      "add_wash_alarm_rinse": {
+        "name": "AddWash al risciacquo"
+      },
+      "add_wash_alarm_final_rinse": {
+        "name": "AddWash all'ultimo risciacquo"
+      },
+      "add_wash_alarm_spin": {
+        "name": "AddWash alla centrifuga"
+      },
       "lamp": {
         "name": "Lampada"
       },
@@ -1179,6 +1447,18 @@
       },
       "ventilation_alarm": {
         "name": "Allarme ventilazione"
+      },
+      "edge_lighting": {
+        "name": "Illuminazione perimetrale"
+      },
+      "indicator_light": {
+        "name": "Spia luminosa"
+      },
+      "windfree": {
+        "name": "Modalità Wind-Free"
+      },
+      "windsleep": {
+        "name": "Modalità notte"
       }
     },
     "time": {
@@ -1199,6 +1479,12 @@
       },
       "night_start": {
         "name": "Inizio luce notturna"
+      },
+      "sensing_skip_end": {
+        "name": "Fine esclusione rilevamento AI Purify"
+      },
+      "sensing_skip_start": {
+        "name": "Inizio esclusione rilevamento AI Purify"
       }
     },
     "water_heater": {
@@ -1261,17 +1547,25 @@
         "title": "Opzioni LocalThings",
         "menu_options": {
           "settings": "Impostazioni dispositivo",
+          "cloud_courses": "Cicli scaricati",
+          "forget_learned_modes": "Dimentica le modalità memorizzate",
           "debug_write": "Debug: scrivi su una risorsa"
         }
       },
       "settings": {
         "title": "Impostazioni dispositivo",
-        "description": "Alcuni dispositivi accettano determinate scritture (ad esempio, il dosaggio predefinito di detersivo/ammorbidente su una lavatrice) anche quando segnalano che il controllo remoto è disattivato. Per impostazione predefinita, LocalThings blocca ogni scrittura con un errore chiaro ogni volta che un dispositivo segnala che il controllo remoto è disattivato, invece di consentire al dispositivo di rifiutarla silenziosamente. Abilitare questa opzione solo se si è verificato che le scritture funzionano effettivamente su questo dispositivo con il controllo remoto disattivato; in caso contrario, si sostituirà l'errore chiaro con un errore silenzioso.\n\nIl tempo di fine stimato viene ricalcolato dalla stima del tempo rimanente del dispositivo a ogni interrogazione, che può variare o essere rivista di uno o due minuti tra un aggiornamento e l'altro. Aumentare il valore di variazione minima riportato di seguito per mantenere il sensore al suo ultimo valore segnalato finché la stima non si sposta di almeno quel numero di minuti, riducendo il rumore nella cronologia/registro. Impostarlo su 0 per segnalare ogni variazione calcolata.",
+        "description": "Alcuni dispositivi accettano determinate scritture (ad esempio, il dosaggio predefinito di detersivo/ammorbidente su una lavatrice) anche quando segnalano che il controllo remoto è disattivato. Per impostazione predefinita, LocalThings blocca ogni scrittura con un errore chiaro ogni volta che un dispositivo segnala che il controllo remoto è disattivato, invece di consentire al dispositivo di rifiutarla silenziosamente. Abilitare questa opzione solo se si è verificato che le scritture funzionano effettivamente su questo dispositivo con il controllo remoto disattivato; in caso contrario, si sostituirà l'errore chiaro con un errore silenzioso.\n\nIl tempo di fine stimato viene ricalcolato dalla stima del tempo rimanente del dispositivo a ogni interrogazione, che può variare o essere rivista di uno o due minuti tra un aggiornamento e l'altro. Aumentare il valore di variazione minima riportato di seguito per mantenere il sensore al suo ultimo valore segnalato finché la stima non si sposta di almeno quel numero di minuti, riducendo il rumore nella cronologia/registro. Impostarlo su 0 per segnalare ogni variazione calcolata.\n\nAlcuni modelli segnalano una modalità che non elencano mai tra quelle supportate: ad esempio un condizionatore in modalità Quiet che offre solo Off/Sleep/Speed. LocalThings memorizza ogni modalità di questo tipo che rileva e continua a proporla, così resta selezionabile una volta che il dispositivo vi è stato almeno una volta. Disattivare questa opzione per proporre solo ciò che il dispositivo dichiara; usare «Dimentica le modalità memorizzate» nella schermata precedente per cancellare quanto già memorizzato. Un dispositivo per il bucato con cicli scaricati dal cloud riceve qui un promemoria non appena ne segnala uno che Home Assistant non può ancora offrire -- alcuni dispositivi ne segnalano uno anche se non è mai stata aperta la schermata \"Cicli scaricati\" dell'app SmartThings. Disattivarlo per interrompere il promemoria e nascondere dall'elenco dei cicli quelli scaricati già nominati; nulla di quanto già configurato va perso, e riattivandolo riappare subito.",
         "data": {
           "bypass_remote_control_lock": "Consenti la scrittura anche quando il controllo remoto risulta disattivato.",
-          "finish_time_hysteresis_minutes": "Tempo finale stimato - variazione minima (minuti)"
+          "finish_time_hysteresis_minutes": "Tempo finale stimato - variazione minima (minuti)",
+          "learn_device_modes": "Memorizza le modalità che il dispositivo segnala ma non dichiara supportate",
+          "cloud_courses_enabled": "Offri cicli scaricati"
         }
       },
+      "forget_learned_modes": {
+        "title": "Dimentica le modalità memorizzate",
+        "description": "Attualmente memorizzate: {codes}\n\nSono modalità in cui questo dispositivo si è dichiarato senza elencarle tra quelle supportate; vengono conservate perché restino selezionabili. Dimenticarle è la soluzione se una si è rivelata errata: qualsiasi modalità che il dispositivo segnali davvero di nuovo verrà memorizzata un'altra volta, a meno che non si disattivi anche «Memorizza le modalità che il dispositivo segnala ma non dichiara supportate» nelle impostazioni del dispositivo."
+      },
       "debug_write": {
         "title": "Debug: scrivi su una risorsa",
         "description": "Strumento avanzato per definire con precisione il comportamento di scrittura specifico del dispositivo. Seleziona la risorsa (href) su cui desideri scrivere oppure digitane una personalizzata non presente nell'elenco. Questo bypassa il blocco di disattivazione del controllo remoto e invia esattamente i campi specificati; tuttavia, potrebbe causare una configurazione errata del dispositivo, quindi utilizzalo con cautela.",
@@ -1293,20 +1587,63 @@
           "debug_write": "Scrivi un'altra risorsa",
           "finish": "Fine"
         }
+      },
+      "cloud_manual": {
+        "title": "Cicli scaricati",
+        "description": "Questo dispositivo segnala {total} cicli scaricati; finora ne sono stati rilevati {found}.\n\nLe impostazioni di un ciclo scaricato sono visibili solo mentre quel ciclo è caricato, e il dispositivo non ne segnala mai il nome. Per aggiungere quelli mancanti ({pending}): nell'app SmartThings (non sul dispositivo), aprire questo dispositivo e toccare \"Cicli scaricati\" -- una riga separata da \"Ciclo\", più in basso nella schermata, ed è quella che conta qui. Scorrere ciascun programma scaricato uno alla volta, sostando qualche secondo su ognuno perché LocalThings possa rilevarlo, e tornare qui.\n\nAssegnare a ciascuno il nome che si desidera vedere in Home Assistant. Lasciare un nome vuoto per escludere quel ciclo dall'elenco dei cicli. I nomi devono essere univoci.\n\nIl ciclo Scaricato è il programma su questo dispositivo che esegue un programma scaricato. Viene rilevato automaticamente, ma confermarlo qui prima dell'uso: selezionare un ciclo scaricato scrive questo codice di programma sul dispositivo.",
+        "data": {
+          "download_course": "Codice programma del ciclo Scaricato"
+        }
+      },
+      "cloud_courses": {
+        "title": "Cicli scaricati",
+        "description": "La configurazione guidata accompagna l'utente: nell'app SmartThings (non sul dispositivo), aprire questo dispositivo e toccare \"Cicli scaricati\" -- una riga separata da \"Ciclo\", più in basso nella schermata, ed è quella che conta qui. Scegliere un ciclo lì, poi tornare qui e assegnargli un nome non appena viene rilevato, uno alla volta.\n\nModifica nomi mostra tutto ciò che è stato trovato finora in una sola volta — usarla in seguito per rinominare o correggere qualcosa. Assegnare un nome funziona comunque, ma un ciclo con nome viene offerto come ciclo selezionabile solo quando \"Offri cicli scaricati\" è attivo nelle impostazioni del dispositivo.",
+        "menu_options": {
+          "cloud_guided": "Configurazione guidata",
+          "cloud_manual": "Modifica nomi"
+        }
+      },
+      "cloud_wait": {
+        "title": "Cicli scaricati"
+      },
+      "cloud_name": {
+        "title": "Assegna un nome a questo ciclo",
+        "description": "Lo slot \"Cicli scaricati\" del dispositivo ora contiene un nuovo ciclo (slot {slot}) e segnala {remaining} rimanenti.\n\nAssegnargli il nome che si desidera vedere in Home Assistant, quindi nella schermata \"Cicli scaricati\" dell'app SmartThings scegliere il successivo non ancora contrassegnato come \"Scaricato\". Lasciare vuoto per escludere questo ciclo dall'elenco.\n\nAssegnati finora ({named} di {total}): {named_list}\n\nI nomi devono essere univoci. È possibile chiudere questa finestra in qualsiasi momento — i nomi vengono salvati man mano.",
+        "data": {
+          "name": "Nome",
+          "download_course": "Codice programma del ciclo Scaricato"
+        }
+      },
+      "cloud_timeout": {
+        "title": "Nessun ciclo selezionato",
+        "description": "Non è cambiato nulla sul dispositivo. Assicurarsi di aver toccato \"Cicli scaricati\" nell'app SmartThings -- una riga separata da \"Ciclo\", più in basso nella schermata -- e di aver scelto un ciclo non ancora contrassegnato come \"Scaricato\", quindi di aver toccato Fine.\n\nAssegnati finora ({named} di {total}): {named_list}\n\nTutto ciò che è stato assegnato finora è già salvato.",
+        "menu_options": {
+          "cloud_guided": "Attendi di nuovo",
+          "cloud_finish": "Fine"
+        }
       }
     },
     "error": {
       "empty_payload": "Inserisci almeno un campo da scrivere.",
-      "write_failed": "Operazione di scrittura non riuscita. Controlla i registri di Home Assistant per i dettagli."
+      "write_failed": "Operazione di scrittura non riuscita. Controlla i registri di Home Assistant per i dettagli.",
+      "cloud_course_name_duplicate": "Due cicli hanno lo stesso nome. I nomi devono essere univoci.",
+      "cloud_course_unknown_course": "Quel programma non è tra quelli offerti da questo dispositivo. Selezionarne uno dall'elenco."
     },
     "abort": {
       "not_loaded": "Questo dispositivo non è ancora connesso. Riprova dopo il caricamento."
+    },
+    "progress": {
+      "cloud_wait": "Nell'app SmartThings (non sul dispositivo), aprire questo dispositivo e toccare \"Cicli scaricati\" -- una riga separata da \"Ciclo\", più in basso nella schermata, che elenca solo i cicli rilevabili in questo modo. Scegliere uno non ancora contrassegnato come \"Scaricato\", quindi toccare Fine.\n\nIl dispositivo non deve essere nelle vicinanze né in esecuzione -- deve solo essere acceso e connesso.\n\nAssegnati finora ({named} di {total}): {named_list}\n\nÈ possibile chiudere questa finestra in qualsiasi momento — i nomi vengono salvati man mano."
     }
   },
   "issues": {
     "device_gap": {
       "title": "Copertura delle funzionalità incompleta per {device_name}",
       "description": "Questo dispositivo non è completamente supportato. Il tipo di dispositivo non è stato riconosciuto oppure alcune delle risorse che espone non sono ancora state modellate. Continuerò a funzionare con le funzionalità già supportate. Puoi contribuire ad ampliare il supporto andando su Impostazioni > Dispositivi e servizi > {device_name} > il menu (in alto a destra) > Scarica diagnostica, quindi inviando una segnalazione tramite il modulo di segnalazione collegato."
+    },
+    "cloud_courses_undiscovered": {
+      "title": "Cicli scaricati non configurati per {device_name}",
+      "description": "{device_name} ha {pending} cicli scaricati su {total} che Home Assistant non può ancora offrire. Un ciclo scaricato può essere usato solo dopo che il dispositivo è stato rilevato con quel ciclo caricato -- nella schermata \"Cicli scaricati\" dell'app SmartThings, non in quella \"Ciclo\" -- ed è stato assegnato un nome.\n\nPer configurarli, andare su Impostazioni > Dispositivi e servizi > LocalThings > {device_name} > Configura > Cicli scaricati e seguire le istruzioni presenti lì.\n\nNon si usano cicli scaricati? Andare invece su Configura > Impostazioni dispositivo e disattivare \"Offri cicli scaricati\" per silenziare questo promemoria definitivamente."
     }
   },
   "exceptions": {
@@ -1327,6 +1664,30 @@
     },
     "intensive_unavailable_for_cycle": {
       "message": "Intensivo non è disponibile per il ciclo selezionato."
+    },
+    "command_failed": {
+      "message": "Il comando per {href} è fallito anche dopo la riconnessione: {error}"
+    },
+    "debug_read_failed": {
+      "message": "La lettura da {href} è fallita: {error}"
+    },
+    "debug_too_many_writes": {
+      "message": "Specificare da 1 a 10 scritture."
+    },
+    "debug_settle_out_of_range": {
+      "message": "settle deve essere compreso tra 0 e 30 secondi."
+    },
+    "debug_verify_after_out_of_range": {
+      "message": "verify_after deve essere compreso tra 0 e 60 secondi."
+    },
+    "service_device_target_invalid": {
+      "message": "Questo servizio richiede esattamente un dispositivo di destinazione."
+    },
+    "service_device_not_found": {
+      "message": "Nessun dispositivo corrispondente trovato per quella destinazione."
+    },
+    "service_device_not_loaded": {
+      "message": "Questo dispositivo non è ancora connesso. Riprova una volta caricato."
     }
   }
 }

custom_components/localthings/translations/nl.json

@@ -108,6 +108,15 @@
       },
       "softener_low": {
         "name": "Wasverzachter bijna op"
+      },
+      "add_wash_available": {
+        "name": "AddWash toegestaan"
+      },
+      "add_wash_indicator": {
+        "name": "AddWash beschikbaar"
+      },
+      "stick_ble_connected": {
+        "name": "Steel via BLE verbonden"
       }
     },
     "button": {
@@ -117,6 +126,12 @@
       "diagnosis_start": {
         "name": "Diagnose starten"
       },
+      "auto_clean_stop": {
+        "name": "Zelfreiniging stoppen"
+      },
+      "filter_time_reset": {
+        "name": "Filterteller op nul zetten"
+      },
       "pause": {
         "name": "Pauzeren"
       },
@@ -146,11 +161,13 @@
               "smart": "Slim",
               "speed": "Snel",
               "nano": "WindFree",
+              "sleep": "Slaap",
               "nanosleep": "WindFree-slaap",
               "longwind": "Lange wind",
               "motionindirect": "Beweging indirect",
               "motiondirect": "Beweging direct",
               "drycomfort": "Droog comfort",
+              "dlightcool": "d'light Cool",
               "2step": "2-Step"
             }
           }
@@ -191,6 +208,9 @@
       "oven_setpoint": {
         "name": "Instelpunt"
       },
+      "sensing_interval": {
+        "name": "AI Purify-interval"
+      },
       "setpoint": {
         "name": "Instelpunt"
       },
@@ -214,6 +234,9 @@
       "air_filter_threshold": {
         "name": "Filteralarmdrempel"
       },
+      "auto_door_timer": {
+        "name": "Timer automatische deuropener"
+      },
       "beverage_zone_mode": {
         "name": "Modus drankenzone",
         "state": {
@@ -244,7 +267,11 @@
         "name": "Zoemergeluid",
         "state": {
           "off": "Uit",
-          "on": "Aan"
+          "on": "Aan",
+          "volume_off": "Uit",
+          "volume_low": "Laag",
+          "volume_med": "Gemiddeld",
+          "volume_high": "Hoog"
         }
       },
       "discharging_time": {
@@ -286,7 +313,16 @@
           "07": "Voorspoelen",
           "8d": "Potten en pannen",
           "8e": "Kunststof",
-          "8f": "Babyverzorging"
+          "8f": "Babyverzorging",
+          "82": "Auto",
+          "8a": "Normaal",
+          "a7": "Intensief",
+          "a8": "Express",
+          "8c": "Extra stil",
+          "88": "Zelfreiniging",
+          "85": "Delicaat",
+          "0c": "Express",
+          "0d": "Zelfreiniging"
         }
       },
       "dispense_type": {
@@ -301,6 +337,35 @@
           "4": "Alarm 4"
         }
       },
+      "dryer_cycle_table_00": {
+        "name": "Programma",
+        "state": {
+          "01": "Normaal",
+          "9c": "Intensief",
+          "a5": "Beddengoed",
+          "9e": "Strijkvrij",
+          "9b": "Stoomhygiëne+",
+          "27": "Opfrissen",
+          "a0": "Luchtdrogen",
+          "a4": "Tijdprogramma",
+          "a6": "Snel drogen",
+          "a3": "Sportkleding",
+          "a2": "Fijne was",
+          "9a": "Katoen",
+          "ca": "Luchtverfrissing",
+          "db": "Super Speed",
+          "99": "Gemengde was",
+          "93": "Strijkdroog",
+          "b5": "Wol",
+          "d7": "Outdoorverzorging",
+          "96": "Koude lucht",
+          "97": "Warme lucht",
+          "7f": "Tijdprogramma",
+          "98": "Snel drogen 35",
+          "eb": "Fijne was",
+          "b6": "Synthetisch"
+        }
+      },
       "dryer_cycle_table_03": {
         "name": "Programma",
         "state": {
@@ -328,7 +393,27 @@
           "4c": "Opfrissen",
           "51": "Eco katoen",
           "53": "AI drogen+",
-          "4e": "Zelf drogen"
+          "4e": "Zelf drogen",
+          "26": "Luchtverfrissing",
+          "2a": "Hygiënische verzorging+",
+          "02": "AI drogen",
+          "03": "Super Speed",
+          "05": "Beddengoed",
+          "07": "Fijne was",
+          "09": "Overhemden",
+          "0b": "Paddingverzorging",
+          "0c": "Waterafstotende outdoorverzorging",
+          "0e": "Handdoeken",
+          "0f": "Wol",
+          "11": "Koude lucht",
+          "28": "Interne desinfectie met hete lucht",
+          "37": "Blouses",
+          "38": "Strijkdroog",
+          "39": "Ruimte ontvochtigen",
+          "3a": "Hygiënisch drogen",
+          "3b": "Beddengoed/Stof verwijderen",
+          "3c": "Sportkleding",
+          "3d": "Spijkergoed"
         }
       },
       "favorite_capacity": {
@@ -450,9 +535,11 @@
           "kimchi_storage_crunfch": "Knapperige kimchi",
           "kimchi_storage_buy": "Gekochte kimchi",
           "storage_fridge_normal": "Koelkast",
+          "storage_fridge": "Koelkast",
           "storage_fridge_cold": "Koelkast, sterk",
           "storage_fridge_warm": "Koelkast, zwak",
           "storage_freezer_normal": "Vriezer",
+          "storage_freezer": "Vriezer",
           "storage_freezer_cold": "Vriezer, sterk",
           "storage_freezer_warm": "Vriezer, zwak",
           "kimchi_ripe_low_temp": "Kimchi rijpen, lage temperatuur",
@@ -465,7 +552,8 @@
           "storage_fresh_cereal": "Granen",
           "storage_fridge_drink": "Dranken",
           "storage_fresh_wine": "Wijn",
-          "storage_fresh_potato_banana": "Aardappelen en bananen"
+          "storage_fresh_potato_banana": "Aardappelen en bananen",
+          "newmode_kimchi_0000": "Nieuwe modus"
         }
       },
       "pantry_zone_mode": {
@@ -476,6 +564,16 @@
           "fdr_drinks": "Dranken"
         }
       },
+      "winecellar_pantry_zone_mode": {
+        "name": "Modus voorraadzone",
+        "state": {
+          "processed_meat": "Vleeswaren",
+          "cheese": "Kaas",
+          "nuts": "Noten",
+          "fruit": "Fruit",
+          "wine": "Wijn"
+        }
+      },
       "range_burner_power_level": {
         "name": "Vermogensniveau brander {number}",
         "state": {
@@ -494,6 +592,14 @@
       "rinse_cycles": {
         "name": "Spoelcycli"
       },
+      "sensing_mode": {
+        "name": "AI Purify-actie",
+        "state": {
+          "off": "Alleen meten",
+          "airpurify": "Automatisch reinigen",
+          "alarm": "Melding ontvangen"
+        }
+      },
       "softener_concentration": {
         "name": "Concentratie wasverzachter",
         "state": {
@@ -519,6 +625,9 @@
           "mute": "Stil"
         }
       },
+      "energy_saving_mode": {
+        "name": "Energiebesparingsmodus"
+      },
       "air_purifier_sound_mode": {
         "name": "Geluidsmodus",
         "state": {
@@ -555,12 +664,51 @@
           "extra_hot": "Extra heet"
         }
       },
+      "washer_cycle_table_00": {
+        "name": "Programma",
+        "state": {
+          "01": "Normaal",
+          "70": "Intensief",
+          "55": "Witte was",
+          "71": "Beddengoed",
+          "72": "Hygiëne",
+          "77": "Strijkvrij",
+          "57": "Self Clean+",
+          "73": "Spoelen + centrifugeren",
+          "74": "Sportkleding",
+          "75": "Fijne was",
+          "78": "Snelle was"
+        }
+      },
       "washer_cycle_table_02": {
         "name": "Programma",
         "state": {
           "01": "Normaal",
+          "02": "Extra intensief",
+          "03": "Super Eco",
           "04": "Snelle was",
+          "05": "Wol/Lingerie",
+          "06": "Beddengoed",
+          "07": "Outdoor",
+          "08": "Spoelen+centrifugeren",
+          "09": "Trommel reinigen",
+          "0a": "Handdoeken",
+          "0b": "Kookwas",
+          "0c": "Babyverzorging",
+          "0d": "Alleen centrifugeren",
+          "0e": "Bewolkte dag",
+          "0f": "Zuivere was",
+          "10": "Droogcentrifugeren",
+          "11": "Zomer beddengoed",
+          "12": "Katoen",
+          "13": "Zwart katoen",
+          "14": "Fijn ondergoed",
+          "15": "Sportkleding",
+          "16": "Blouses",
           "17": "Gedownload",
+          "18": "Soft Bubble",
+          "19": "AI Wash",
+          "1a": "Overhemden",
           "1b": "Katoen",
           "1c": "Eco 40-60",
           "1d": "Super Speed",
@@ -570,7 +718,7 @@
           "21": "Bonte was",
           "22": "Wol",
           "23": "Outdoor",
-          "24": "Handdoeken",
+          "24": "Beddengoed",
           "25": "Synthetisch",
           "26": "Fijne was",
           "27": "Spoelen+centrifugeren",
@@ -583,8 +731,9 @@
           "2f": "Sportkleding",
           "30": "Bewolkte dag",
           "32": "Overhemden",
-          "33": "Beddengoed",
+          "33": "Handdoeken",
           "34": "Gemengd",
+          "35": "Eco katoen",
           "36": "Wassen+drogen",
           "37": "Air Wash",
           "38": "Katoen drogen",
@@ -599,14 +748,34 @@
           "60": "Self Clean+",
           "65": "Bonte was",
           "66": "Spijkergoed",
+          "69": "AI wassen",
+          "6a": "Wol",
+          "6b": "Spijkergoed",
+          "6c": "Blouses",
+          "6d": "Fijne was",
+          "6e": "Sportkleding",
+          "6f": "Beddengoed",
+          "70": "Handdoeken",
+          "71": "Snelle was",
+          "72": "Overhemden",
+          "73": "Hygiëne",
+          "74": "Trommel reinigen",
+          "75": "Outdoor",
+          "76": "Babyverzorging",
+          "77": "Katoen",
+          "78": "Spoelen + centrifugeren",
+          "79": "Alleen centrifugeren",
           "7c": "Witte was",
           "7d": "Beddengoed/waterdicht",
           "7e": "Self Clean",
           "7f": "Wol/fijne was",
           "86": "Diep wassen",
           "87": "Gedownload",
+          "88": "Huisdierverzorging",
           "8f": "Intensief koud",
-          "96": "Minder microvezels"
+          "96": "Minder microvezels",
+          "a0": "15' Snelle was",
+          "b0": "Gemengde was"
         }
       },
       "washer_dry_level": {
@@ -646,6 +815,38 @@
       },
       "freezer_temperature_setpoint": {
         "name": "Temperatuur vriesgedeelte"
+      },
+      "edge_lighting_mode": {
+        "name": "Randverlichtingsmodus",
+        "state": {
+          "smart": "Slim",
+          "high": "Hoog",
+          "low": "Laag"
+        }
+      },
+      "edge_lighting_color": {
+        "name": "Randverlichtingskleur",
+        "state": {
+          "3000k": "3000 K",
+          "4000k": "4000 K",
+          "6500k": "6500 K"
+        }
+      },
+      "indicator_light_mode": {
+        "name": "Indicatorlampjemodus",
+        "state": {
+          "smart": "Slim",
+          "high": "Hoog",
+          "low": "Laag"
+        }
+      },
+      "ventilation_mode": {
+        "name": "Modus",
+        "state": {
+          "purification": "Zuivering",
+          "ventilation": "Ventilatie",
+          "smartventilation": "Slimme ventilatie"
+        }
       }
     },
     "sensor": {
@@ -661,6 +862,9 @@
       "air_filter_usage_hours": {
         "name": "Filterverbruik (uren)"
       },
+      "deodor_filter_usage": {
+        "name": "Filterverbruik"
+      },
       "air_quality_standard": {
         "name": "Luchtkwaliteitsnorm"
       },
@@ -734,6 +938,12 @@
       "stick_status": {
         "name": "Status steel"
       },
+      "stick_operation_mode": {
+        "name": "Bedieningsmodus steel"
+      },
+      "stick_cleaning_status": {
+        "name": "Schoonmaakstatus steel"
+      },
       "uvc_operation_time": {
         "name": "UV-C-bedrijfstijd"
       },
@@ -768,6 +978,12 @@
           "indirect": "Indirect"
         }
       },
+      "energy_saving_state": {
+        "name": "Energiebesparing status"
+      },
+      "energy_saving_operating_status": {
+        "name": "Bedrijfsstatus energiebesparing"
+      },
       "current_temp_c": {
         "name": "Temperatuur"
       },
@@ -775,10 +991,16 @@
         "name": "Temperatuur"
       },
       "diagnosis": {
-        "name": "Diagnose"
+        "name": "Diagnose",
+        "state": {
+          "ready": "Gereed"
+        }
       },
       "diagnosis_status": {
-        "name": "Diagnosestatus"
+        "name": "Diagnosestatus",
+        "state": {
+          "ready": "Gereed"
+        }
       },
       "drum_clean_cycles_remaining": {
         "name": "Trommelreiniging over"
@@ -793,7 +1015,10 @@
         "name": "Droogtijd"
       },
       "dryer_type": {
-        "name": "Type droger"
+        "name": "Type droger",
+        "state": {
+          "electricity": "Elektriciteit"
+        }
       },
       "dust": {
         "name": "Stof"
@@ -922,7 +1147,23 @@
         "name": "Sondetemperatuur"
       },
       "progress": {
-        "name": "Voortgang"
+        "name": "Voortgang",
+        "state": {
+          "idle": "Inactief",
+          "weightsensing": "Beladingsdetectie",
+          "wash": "Wassen",
+          "rinse": "Spoelen",
+          "spin": "Centrifugeren",
+          "finish": "Voltooid",
+          "steaming": "Stomen",
+          "airwashing": "Luchtreiniging",
+          "drying": "Drogen",
+          "dryingwithdooropen": "Ventileren",
+          "cooling": "Koelen",
+          "predrain": "Vooraf afpompen",
+          "prewash": "Voorwas",
+          "sanitizing": "Ontsmetten"
+        }
       },
       "progress_percentage": {
         "name": "Voortgangspercentage"
@@ -1021,6 +1262,9 @@
       "absence_power_saving_active": {
         "name": "Energiebesparing bij afwezigheid actief"
       },
+      "absence_clean": {
+        "name": "Reiniging bij afwezigheid"
+      },
       "motion_detect_wind_active": {
         "name": "Bewegingsdetectie luchtstroomvermijding actief"
       },
@@ -1030,6 +1274,12 @@
       "display": {
         "name": "Display"
       },
+      "periodic_air_sensing": {
+        "name": "AI Purify"
+      },
+      "periodic_sensing_skip_status": {
+        "name": "AI Purify meting overslaan"
+      },
       "pet_filter_activation": {
         "name": "Huisdierfilter actief"
       },
@@ -1048,6 +1298,12 @@
       "auto_door_opener": {
         "name": "Automatische deuropener"
       },
+      "auto_door_sound_control": {
+        "name": "Geluid automatische deuropener"
+      },
+      "auto_door_voice_control": {
+        "name": "Spraakbediening automatische deuropener"
+      },
       "auto_release_dry": {
         "name": "Auto Release Dry"
       },
@@ -1114,6 +1370,18 @@
       "intensive": {
         "name": "Intensief"
       },
+      "add_wash_alarm": {
+        "name": "AddWash-melding"
+      },
+      "add_wash_alarm_rinse": {
+        "name": "AddWash bij spoelen"
+      },
+      "add_wash_alarm_final_rinse": {
+        "name": "AddWash laatste spoeling"
+      },
+      "add_wash_alarm_spin": {
+        "name": "AddWash centrifugeren"
+      },
       "lamp": {
         "name": "Lamp"
       },
@@ -1179,6 +1447,18 @@
       },
       "ventilation_alarm": {
         "name": "Ventilatiealarm"
+      },
+      "edge_lighting": {
+        "name": "Randverlichting"
+      },
+      "indicator_light": {
+        "name": "Indicatorlampje"
+      },
+      "windfree": {
+        "name": "Wind-Free modus"
+      },
+      "windsleep": {
+        "name": "Slaapmodus"
       }
     },
     "time": {
@@ -1199,6 +1479,12 @@
       },
       "night_start": {
         "name": "Start nachtverlichting"
+      },
+      "sensing_skip_end": {
+        "name": "Einde AI Purify meting overslaan"
+      },
+      "sensing_skip_start": {
+        "name": "Start AI Purify meting overslaan"
       }
     },
     "water_heater": {
@@ -1261,17 +1547,25 @@
         "title": "LocalThings-opties",
         "menu_options": {
           "settings": "Apparaatinstellingen",
+          "cloud_courses": "Gedownloade programma's",
+          "forget_learned_modes": "Onthouden modi vergeten",
           "debug_write": "Foutopsporing: naar een resource schrijven"
         }
       },
       "settings": {
         "title": "Apparaatinstellingen",
-        "description": "Sommige apparaten accepteren bepaalde schrijfbewerkingen (bijvoorbeeld de standaarddosering van wasmiddel of wasverzachter op een wasmachine), ook als ze melden dat de afstandsbediening is uitgeschakeld. LocalThings blokkeert standaard elke schrijfbewerking met een duidelijke foutmelding wanneer een apparaat meldt dat de afstandsbediening is uitgeschakeld, in plaats van het apparaat de opdracht stilzwijgend te laten weigeren. Schakel deze optie alleen in als je hebt bevestigd dat schrijfbewerkingen op dit apparaat echt werken wanneer de afstandsbediening is uitgeschakeld. Anders verruil je de duidelijke foutmelding voor een stille mislukking.\n\nDe geschatte eindtijd wordt bij elke poll opnieuw berekend op basis van de resterende tijd die het apparaat opgeeft, wat kan afwijken of met een minuut of wat worden bijgesteld tussen updates. Verhoog de minimale wijziging hieronder om de sensor op zijn laatst gerapporteerde waarde te houden totdat de schatting met minstens dat aantal minuten verandert, wat de ruis in geschiedenis/logboek vermindert. Zet op 0 om elke berekende wijziging te rapporteren.",
+        "description": "Sommige apparaten accepteren bepaalde schrijfbewerkingen (bijvoorbeeld de standaarddosering van wasmiddel of wasverzachter op een wasmachine), ook als ze melden dat de afstandsbediening is uitgeschakeld. LocalThings blokkeert standaard elke schrijfbewerking met een duidelijke foutmelding wanneer een apparaat meldt dat de afstandsbediening is uitgeschakeld, in plaats van het apparaat de opdracht stilzwijgend te laten weigeren. Schakel deze optie alleen in als je hebt bevestigd dat schrijfbewerkingen op dit apparaat echt werken wanneer de afstandsbediening is uitgeschakeld. Anders verruil je de duidelijke foutmelding voor een stille mislukking.\n\nDe geschatte eindtijd wordt bij elke poll opnieuw berekend op basis van de resterende tijd die het apparaat opgeeft, wat kan afwijken of met een minuut of wat worden bijgesteld tussen updates. Verhoog de minimale wijziging hieronder om de sensor op zijn laatst gerapporteerde waarde te houden totdat de schatting met minstens dat aantal minuten verandert, wat de ruis in geschiedenis/logboek vermindert. Zet op 0 om elke berekende wijziging te rapporteren.\n\nSommige modellen melden een modus die ze nooit als ondersteund opgeven: bijvoorbeeld een airco die in Quiet staat maar alleen Off/Sleep/Speed aanbiedt. LocalThings onthoudt elke zo waargenomen modus en blijft die aanbieden, zodat hij selecteerbaar blijft zodra het apparaat er minstens één keer in heeft gestaan. Schakel dit uit om alleen aan te bieden wat het apparaat opgeeft; gebruik \"Onthouden modi vergeten\" in het vorige scherm om te wissen wat al is onthouden. Een wasapparaat met uit de cloud gedownloade programma's krijgt hier een herinnering zodra het er een meldt die Home Assistant nog niet kan aanbieden -- sommige apparaten melden er een, ook als je het scherm \"Gedownloade programma's\" in de SmartThings-app zelf nooit hebt geopend. Zet dit uit om die herinnering te stoppen en al benoemde gedownloade programma's uit de programmalijst te verbergen; niets van wat al is ingesteld gaat verloren, en bij opnieuw inschakelen verschijnt het meteen weer.",
         "data": {
           "bypass_remote_control_lock": "Schrijfbewerkingen toestaan wanneer afstandsbediening als uitgeschakeld wordt gemeld",
-          "finish_time_hysteresis_minutes": "Geschatte eindtijd -- minimale wijziging (minuten)"
+          "finish_time_hysteresis_minutes": "Geschatte eindtijd -- minimale wijziging (minuten)",
+          "learn_device_modes": "Modi onthouden die het apparaat meldt maar niet als ondersteund opgeeft",
+          "cloud_courses_enabled": "Gedownloade programma's aanbieden"
         }
       },
+      "forget_learned_modes": {
+        "title": "Onthouden modi vergeten",
+        "description": "Nu onthouden: {codes}\n\nDit zijn modi waarin dit apparaat zichzelf meldde zonder ze als ondersteund op te geven; ze worden bewaard zodat ze selecteerbaar blijven. Vergeten is de oplossing als er een onterecht tussen staat: alles wat het apparaat echt opnieuw meldt, wordt gewoon opnieuw onthouden, tenzij je ook \"Modi onthouden die het apparaat meldt maar niet als ondersteund opgeeft\" bij Apparaatinstellingen uitzet."
+      },
       "debug_write": {
         "title": "Foutopsporing: naar een resource schrijven",
         "description": "Geavanceerd hulpmiddel om apparaatspecifiek schrijfgedrag te onderzoeken. Kies de resource (href) waarnaar je wilt schrijven, of voer een aangepaste resource in die niet in de lijst staat. Hiermee wordt de blokkering bij een uitgeschakelde afstandsbediening omzeild en worden precies de opgegeven velden verzonden. Dit kan de configuratie van je apparaat verstoren, dus gebruik het bewust.",
@@ -1293,20 +1587,63 @@
           "debug_write": "Naar een andere resource schrijven",
           "finish": "Voltooien"
         }
+      },
+      "cloud_manual": {
+        "title": "Gedownloade programma's",
+        "description": "Dit apparaat meldt {total} gedownloade programma's; {found} daarvan zijn tot nu toe gezien.\n\nDe instellingen van een gedownload programma zijn alleen zichtbaar zolang dat programma geladen is, en het apparaat meldt nooit de naam ervan. Om de ontbrekende ({pending}) toe te voegen: open in de SmartThings-app (niet op het apparaat zelf) dit apparaat en tik op \"Gedownloade programma's\" -- een aparte regel, los van \"Programma\", verderop op het scherm, en degene die hier telt. Doorloop dan elk gedownload programma na elkaar, pauzeer bij elk een paar seconden zodat LocalThings het kan zien, en kom hierna terug.\n\nGeef elk programma de naam die je in Home Assistant wilt zien. Laat een naam leeg om dat programma buiten de programmalijst te houden. Namen moeten uniek zijn.\n\nHet programma \"Gedownload\" is het programma op dit apparaat dat een gedownload programma uitvoert. Het wordt automatisch gedetecteerd, maar bevestig dit hier voor gebruik: als je een gedownload programma selecteert, wordt deze programmacode naar het apparaat geschreven.",
+        "data": {
+          "download_course": "Programmacode van \"Gedownload\""
+        }
+      },
+      "cloud_courses": {
+        "title": "Gedownloade programma's",
+        "description": "Begeleide installatie loodst je stap voor stap: open in de SmartThings-app (niet op het apparaat zelf) dit apparaat en tik op \"Gedownloade programma's\" -- een aparte regel, los van \"Programma\", verderop op het scherm, en degene die hier telt. Kies daar een programma, kom terug en geef het een naam zodra het gevonden is, één voor één.\n\nNamen bewerken toont in één keer alles wat tot nu toe is gevonden — gebruik dit later om iets te hernoemen of te corrigeren. Namen geven werkt sowieso, maar een benoemd programma wordt alleen als selecteerbaar programma aangeboden zolang \"Gedownloade programma's aanbieden\" aan staat in de apparaatinstellingen.",
+        "menu_options": {
+          "cloud_guided": "Begeleide installatie",
+          "cloud_manual": "Namen bewerken"
+        }
+      },
+      "cloud_wait": {
+        "title": "Gedownloade programma's"
+      },
+      "cloud_name": {
+        "title": "Geef dit programma een naam",
+        "description": "Het vak \"Gedownloade programma's\" van het apparaat bevat nu een nieuw programma (slot {slot}) en meldt nog {remaining} resterend.\n\nGeef het de naam die je in Home Assistant wilt zien en kies daarna in het scherm \"Gedownloade programma's\" van de SmartThings-app het volgende programma dat nog niet als \"Gedownload\" is gemarkeerd. Laat het veld leeg om dit programma buiten de lijst te houden.\n\nTot nu toe benoemd ({named} van {total}): {named_list}\n\nNamen moeten uniek zijn. Je kunt dit venster op elk moment sluiten — namen worden onderweg opgeslagen.",
+        "data": {
+          "name": "Naam",
+          "download_course": "Programmacode van \"Gedownload\""
+        }
+      },
+      "cloud_timeout": {
+        "title": "Geen programma geselecteerd",
+        "description": "Er is niets veranderd op het apparaat. Zorg dat je in de SmartThings-app op \"Gedownloade programma's\" hebt getikt -- een aparte regel, los van \"Programma\", verderop op het scherm -- en een programma hebt gekozen dat nog niet als \"Gedownload\" was gemarkeerd, en daarna op Klaar hebt getikt.\n\nTot nu toe benoemd ({named} van {total}): {named_list}\n\nAlles wat tot nu toe benoemd is, is al opgeslagen.",
+        "menu_options": {
+          "cloud_guided": "Opnieuw wachten",
+          "cloud_finish": "Voltooien"
+        }
       }
     },
     "error": {
       "empty_payload": "Voer ten minste één veld in om te schrijven.",
-      "write_failed": "De schrijfbewerking is mislukt. Raadpleeg de Home Assistant-logboeken voor meer informatie."
+      "write_failed": "De schrijfbewerking is mislukt. Raadpleeg de Home Assistant-logboeken voor meer informatie.",
+      "cloud_course_name_duplicate": "Twee programma's hebben dezelfde naam. Namen moeten uniek zijn.",
+      "cloud_course_unknown_course": "Dat programma biedt dit apparaat niet aan. Kies er een uit de lijst."
     },
     "abort": {
       "not_loaded": "Dit apparaat is nog niet verbonden. Probeer het opnieuw zodra het is geladen."
+    },
+    "progress": {
+      "cloud_wait": "Open in de SmartThings-app (niet op het apparaat zelf) dit apparaat en tik op \"Gedownloade programma's\" -- een aparte regel, los van \"Programma\", verderop op het scherm, die alleen de programma's toont die op deze manier te herkennen zijn. Kies er een die nog niet als \"Gedownload\" is gemarkeerd en tik op Klaar.\n\nHet apparaat hoeft niet in de buurt te zijn of het programma uit te voeren -- het moet alleen aan staan en verbonden zijn.\n\nTot nu toe benoemd ({named} van {total}): {named_list}\n\nJe kunt dit venster op elk moment sluiten — namen worden onderweg opgeslagen."
     }
   },
   "issues": {
     "device_gap": {
       "title": "Onvolledige ondersteuning van mogelijkheden voor {device_name}",
       "description": "Niet alle mogelijkheden van dit apparaat worden ondersteund. Het apparaattype is niet herkend of sommige beschikbare resources zijn nog niet gemodelleerd. Het apparaat blijft werken met de mogelijkheden die al worden ondersteund. Je kunt helpen de ondersteuning uit te breiden: ga naar Instellingen > Apparaten & diensten > {device_name} > het menu (rechtsboven) > Diagnostische gegevens downloaden en voeg het bestand daarna bij via de gekoppelde issue-template."
+    },
+    "cloud_courses_undiscovered": {
+      "title": "Gedownloade programma's niet ingesteld voor {device_name}",
+      "description": "{device_name} heeft {pending} van de {total} gedownloade programma's die Home Assistant nog niet kan aanbieden. Een gedownload programma kan pas worden gebruikt zodra het apparaat ermee geladen is gezien -- in het scherm \"Gedownloade programma's\" van de SmartThings-app, niet in \"Programma\" -- en je het een naam hebt gegeven.\n\nGa om ze in te stellen naar Instellingen > Apparaten & diensten > LocalThings > {device_name} > Configureren > Gedownloade programma's en volg de instructies daar.\n\nGebruik je geen gedownloade programma's? Ga dan naar Configureren > Apparaatinstellingen en zet \"Gedownloade programma's aanbieden\" uit om deze herinnering voorgoed te stoppen."
     }
   },
   "exceptions": {
@@ -1327,6 +1664,30 @@
     },
     "intensive_unavailable_for_cycle": {
       "message": "Intensief is niet beschikbaar voor het geselecteerde programma."
+    },
+    "command_failed": {
+      "message": "Het commando naar {href} is ook na opnieuw verbinden mislukt: {error}"
+    },
+    "debug_read_failed": {
+      "message": "Het lezen van {href} is mislukt: {error}"
+    },
+    "debug_too_many_writes": {
+      "message": "Geef tussen de 1 en 10 schrijfacties op."
+    },
+    "debug_settle_out_of_range": {
+      "message": "settle moet tussen 0 en 30 seconden liggen."
+    },
+    "debug_verify_after_out_of_range": {
+      "message": "verify_after moet tussen 0 en 60 seconden liggen."
+    },
+    "service_device_target_invalid": {
+      "message": "Deze service vereist precies één doelapparaat."
+    },
+    "service_device_not_found": {
+      "message": "Er is geen bijpassend apparaat gevonden voor dat doel."
+    },
+    "service_device_not_loaded": {
+      "message": "Dit apparaat is nog niet verbonden. Probeer het opnieuw zodra het is geladen."
     }
   }
 }

custom_components/localthings/water_heater.py

@@ -1,38 +1,29 @@
 """Water heater platform for Local Things.
 
 Second composite entity in this integration (see climate.py's module
-docstring for the general pattern this follows): a single HA water_heater
+docstring for the general pattern): a single HA water_heater card for a
-card for a Samsung EHS heat pump's domestic hot water (DHW) loop. It binds
+Samsung EHS heat pump's domestic hot water (DHW) loop. It binds the primary
-the primary `WaterHeaterDesc` (the `/mode/dhw/vs/0` capability, DHW.entities
+`WaterHeaterDesc` (the `/mode/dhw/vs/0` capability, DHW.entities in
-in registry/capabilities/ehs.py) so the registry still tracks it, and reads
+registry/capabilities/ehs.py) and reads the sibling `/power/dhw/vs/0` and
-the sibling `/power/dhw/vs/0` and `/temperatures/dhw/vs/0` resources straight
+`/temperatures/dhw/vs/0` resources straight from the coordinator snapshot,
-from the coordinator snapshot -- the same cross-resource read climate.py uses
+the same cross-resource read climate.py uses.
-for the AC's power/temperature/wind siblings.
 
-Writes go through `coordinator.async_send_command(bound, (kind, value))`:
+Writes go through `coordinator.async_send_command`: DHW's `write_fn`
-DHW's `write_fn` (ehs._dhw_write) maps each `(kind, value)` payload to the
+(ehs._dhw_write) maps each `(kind, value)` payload to the right
-right `(path_segs, body)`, and `async_send_command` POSTs to those path_segs
+`(path_segs, body)`, applying the optimistic value/settle guard to that
-and applies the optimistic value/settle guard to that same href -- not the
+resource's own href rather than the bound `/mode/dhw/vs/0` href.
-bound `/mode/dhw/vs/0` href -- so one descriptor drives writes to, and gets
-fresh state back for, power, mode and temperature alike.
 
 Operation-mode vocabulary: the DHW loop's four device modes (Eco/Std/Force/
-Power) map onto HA's own standard water_heater states -- the same mapping
+Power) map onto HA's own standard water_heater states, the same mapping
-Home Assistant's core `smartthings` integration uses for this exact Samsung
+HA core's `smartthings` integration uses for this exact Samsung capability
-capability over the cloud API (`samsungce.ehsThermostat` /
+(`samsungce.ehsThermostat`), just title-cased to match this OCF resource's
-`airConditionerMode`: eco/std/force/power -> STATE_ECO/STATE_HEAT_PUMP/
+spelling. Reusing HA's standard states means no state translation catalog
-STATE_HIGH_DEMAND/STATE_PERFORMANCE), just title-cased to match this OCF
+entry is needed for them.
-resource's own code spelling. Reusing HA's standard states means no *state*
-translation catalog entry is needed for them (see the entity_component
-fallback in homeassistant.components.water_heater.strings.json).
 
-Naming is a separate question from that, and the answer here differs from
+Naming differs from climate.py's: the AC *is* the device, so its card takes
-climate.py's: the AC *is* the device, so its climate card takes the bare
+the bare device name. An EHS unit has two loops, and DHW isn't "the
-device name (`_attr_name = None`). An EHS unit has two loops, and the DHW
+device" (siblings are named "Zone Mode"/"Zone Target Temperature"), so this
-one is not "the device" -- its siblings are named "Zone Mode"/"Zone Target
+entity is named through the catalog via `translation_key='dhw'`
-Temperature", so a card labelled just "EHS" would misrepresent which loop
-it drives. This entity is named through the catalog like every other
-descriptor here, via the DHW descriptor's `translation_key='dhw'`
 (entity.water_heater.dhw.name -> "Hot water").
 """
 
@@ -73,8 +64,7 @@ _LOGGER = logging.getLogger(__name__)
 _MODES_FIELD = "x.com.samsung.da.modes"
 _SUPPORTED_FIELD = "x.com.samsung.da.supportedModes"
 
-# Device mode <-> HA water_heater operation state -- see the module
+# Device mode <-> HA water_heater operation state -- see module docstring.
-# docstring above for the SmartThings-cloud precedent this mirrors.
 _DEVICE_TO_STATE: dict[str, str] = {
     "Eco": STATE_ECO,
     "Std": STATE_HEAT_PUMP,
@@ -83,12 +73,10 @@ _DEVICE_TO_STATE: dict[str, str] = {
 }
 _STATE_TO_DEVICE = {v: k for k, v in _DEVICE_TO_STATE.items()}
 
-# Read-side lookup, case-folded. climate.py resolves write codes from the
+# Read-side lookup, case-folded: this map is bijective (unlike climate.py's
-# unit's own supportedModes because two spellings there mean one HA value
+# 'Wind'/'Fan' -> FAN_ONLY), so the write side uses _STATE_TO_DEVICE
-# ('Wind'/'Fan' -> FAN_ONLY); this map is bijective, so the write side can
+# directly; only the read side needs to absorb a board spelling the same
-# use _STATE_TO_DEVICE directly. Only the read side is exposed to a board
+# code differently ('eco'/'ECO').
-# spelling the same code differently ('eco'/'ECO'), and case is the one
-# variation worth absorbing rather than warning about.
 _DEVICE_TO_STATE_CI = {k.lower(): v for k, v in _DEVICE_TO_STATE.items()}
 
 
@@ -132,21 +120,18 @@ class LocalThingsWaterHeater(LocalThingsEntity, WaterHeaterEntity):
     def __init__(self, coordinator: LocalThingsCoordinator, bound) -> None:
         super().__init__(coordinator, bound)
         # No _attr_name here: unlike climate.py's AC, this is one loop of a
-        # two-loop device and takes a catalog name ("Hot water") through the
+        # two-loop device and takes a catalog name through translation_key.
-        # descriptor's translation_key -- see the module docstring.
         self._attr_supported_features = (
             WaterHeaterEntityFeature.TARGET_TEMPERATURE
             | WaterHeaterEntityFeature.OPERATION_MODE
             | WaterHeaterEntityFeature.ON_OFF
         )
-        # Raw device codes already logged by _warn_unmapped -- these
+        # Raw device codes already logged by _warn_unmapped -- read on every
-        # properties are read on every coordinator refresh, so an un-deduped
+        # refresh, so un-deduped would spam the log for an unrecognized code.
-        # warning would spam the log for any unit reporting a genuinely
-        # unrecognized code.
         self._warned_unmapped: set[str] = set()
 
     def _rep(self, href: str) -> dict:
-        """`href` is one of this module's canonical HREF_* constants --
+        """`href` is one of this module's canonical HREF_* constants,
         translated through this bound entity's own subdevice (issue #177),
         same as climate.py's identical helper."""
         return self.coordinator.resource(self._bound.subdevice.to_actual(href)) or {}
@@ -188,14 +173,10 @@ class LocalThingsWaterHeater(LocalThingsEntity, WaterHeaterEntity):
         return _num(self._rep(TEMPERATURE_HREF).get("x.com.samsung.da.desired"))
 
     def _range(self) -> list | None:
-        """The device's own (minimum, maximum) pair, or None.
+        """The device's own (minimum, maximum) pair, or None. Both ends
-
+        together or neither -- same rule as climate._range(); a board
-        Both ends together or neither, deliberately -- same rule as
+        reporting only minimum would otherwise pair it with HA's own
-        climate._range(). A board reporting minimum but not maximum would
+        default maximum, silently wrong."""
-        otherwise pair a device minimum (40) with HA's own default maximum
-        (140 °F), which looks plausible and is silently wrong on a unit
-        that really allows 62.
-        """
         rep = self._rep(TEMPERATURE_HREF)
         lo = _num(rep.get("x.com.samsung.da.minimum"))
         hi = _num(rep.get("x.com.samsung.da.maximum"))
@@ -213,8 +194,7 @@ class LocalThingsWaterHeater(LocalThingsEntity, WaterHeaterEntity):
 
     @property
     def target_temperature_step(self) -> float:
-        # `is None`, not `or` -- see issue #160: `or` collapses a genuine 0
+        # `is None`, not `or` -- `or` would collapse a genuine 0 (issue #160).
-        # into the fallback.
         step = _num(self._rep(TEMPERATURE_HREF).get("x.com.samsung.da.increment"))
         return 0.5 if step is None else step
 
@@ -245,13 +225,11 @@ class LocalThingsWaterHeater(LocalThingsEntity, WaterHeaterEntity):
     # -- writes ---------------------------------------------------------------
 
     async def async_set_temperature(self, **kwargs) -> None:
-        # HA's water_heater.set_temperature service takes an optional
+        # HA's water_heater.set_temperature service can carry an optional
-        # operation_mode and forwards it here (SET_TEMPERATURE_SCHEMA), same
+        # operation_mode; honor it, setting the mode first (which also
-        # as climate.set_temperature does with hvac_mode. Honour it, and set
+        # powers the loop on) so a dashboard "boost to 55" button that
-        # it first -- that also powers the loop on when it was off -- so a
+        # carries a mode actually changes mode, not just the setpoint. Same
-        # dashboard "boost to 55" button that carries a mode actually changes
+        # fix as climate.async_set_temperature.
-        # mode, instead of only moving the setpoint. Same fix as the AC's
-        # (see climate.async_set_temperature).
         operation_mode = kwargs.get("operation_mode")
         if operation_mode is not None:
             await self.async_set_operation_mode(operation_mode)

docs/investigations/ac-filter-reset.md

@@ -0,0 +1,169 @@
+# AC filter-time counter reset: solved
+
+`registry/capabilities/airconditioner.py`'s `filter_time` sensor
+(`FilterTime_<N>` option token, tenths of an hour) has a reset entity now
+(`filter_time_reset`, issue-tracked as PR #289): a single-token options write
+of `FilterCleanAlarm_Clear` to `/mode/vs/0`, the same merge every other
+setting on that href uses. Measured on an ARTIK051_KRAC_18K: `FilterTime_95`
+(9h30m) → `FilterTime_0`, still zero on a fresh DTLS session and every poll
+after; none of the other 17 tokens moved and the `/alarms/vs/0` entries
+stayed `Deleted`.
+
+The rest of this file is kept as-is: the failed attempts below are still the
+best record of what *doesn't* work on this generation, and the reasoning
+that follows them explains why the reset looked cloud-only for as long as it
+did — a genuine trap worth knowing about before the next reset-adjacent
+mystery on this board family.
+
+Scope: all of the above applies to boards that carry the counter as a
+`FilterTime_<N>` option token on `/mode/vs/0`. Not every AC does. See
+"Boards with no `FilterTime` token" at the end for an `ARTIK051_PRAC_20K`
+that keeps the counter in its own resource, rejects both the token and a
+direct write, and has no local reset at all.
+
+## What the reset actually is
+
+A **command**, not a value write. Samsung's cloud models it as capability
+`custom.dustFilter`, command `resetDustFilter`, no arguments (implemented in
+several SmartThings HA forks; not in the core integration) — that command
+name is real, but see below for why POSTing it directly went nowhere.
+
+## Tried, all against a live unit, all failed (before the token above was found)
+
+- `FilterTime_0` via the single-token options merge that works for every
+  other setting on this href — accepted with no error, then discarded. Tried
+  on two units in opposite power states to rule out the obvious confound:
+  5595 → back to 5595 after 69s (powered off, alarm active), 1925 → back to
+  1925 after 65s (actively cooling).
+- A full `options[]` read-modify-write with `FilterTime_0` substituted,
+  instead of the single-token merge — zero fields changed anywhere.
+- A write to `/consumable/vs/0`, the board's own filter resource
+  (`items[{name: FilterProgress, state: N}]`) — discarded. `/oic/res`
+  declares that resource `oic.if.s` (read-only), which fits.
+- `/actions/vs/0` (`x.com.samsung.da.actions`, `oic.if.a`) is the obvious
+  local command channel but publishes no schema: GET returns `{}` on
+  baseline and on `oic.if.a`, and five POSTs probing the shape (empty map,
+  empty string, empty array, invalid value, items shape) all returned 4.00
+  with an empty body — no echo of accepted field names, unlike the laundry
+  firmware's `"Control fail, <...>"`. Guessed action names were deliberately
+  not enumerated against a live appliance: an unknown vocabulary on a
+  channel called "actions" can hold a factory reset next to the one we want.
+- `/hass/state/vs/0` and `/hass/command/vs/0` (advertised in `/oic/res`, and
+  `/opt/data/hass.db` exists in `/file/list`) → 4.04 on every interface, so
+  unimplemented scaffolding on this firmware.
+- `/file/transfer/vs/0` serves only `/mnt/usage.db`; selecting another path
+  returns 4.05/4.00, so the firmware can't be pulled that way to read the
+  action vocabulary out of it.
+- `/rm/micomdata/vs/0` (channel toward the MICOM board the physical panel
+  talks to) stays empty even after successfully enabling remote management.
+
+## What the failures are not
+
+Not a transport, permission, or cert problem: a control write of `rmState`
+on `/rm/state/vs/0` was accepted (2.04 Changed, value held, restored
+afterwards), and `FilterAlarmTime_` is written through the very same options
+merge and kept. Writes work; this one value just isn't driven that way.
+
+## The token, and why the dead ends below missed it
+
+`FilterCleanAlarm_Clear` is not derived from anything in this file's earlier
+attempts — how it was originally identified isn't recorded here. What is
+recorded is why the standard technique (diff the appliance's reported state
+before/after triggering the action in Samsung's app) couldn't have found it
+on its own: the token is a trigger, never stored and never echoed back in
+`x.com.samsung.da.options`, so a before/after diff of stored state shows
+only the *effects* (counter zeroing, alarm clearing) and never the token
+that caused them.
+
+## Dead ends tried before the token was known (kept for the next unrelated mystery)
+
+- The `/actions/vs/0` action vocabulary from an independent source (a
+  firmware image, or a capture of what the cloud sends the device).
+- The IR path — the physical remote has a filter reset (Options → Filter
+  Reset → SET), and IRremoteESP8266 decodes this AC family, though issue
+  #1277's dump doesn't include that button.
+
+## Evidence for the counter's direction and scale
+
+Confirmed counting *up* (running time since last reset, not remaining time):
+token 1710 matched the Samsung app's "171 hours 0 minutes" for the same
+filter (pins the tenths-of-an-hour scale); seen rising while the unit ran
+(171.0 → 171.5); and across two units on one site the `/alarms/vs/0` filter
+alarm tracks the counter in the right direction — live (`FilterAlarm`,
+`Created`) at `FilterTime_5595`, still the `FilterAlarm_OFF`/`Deleted`
+placeholder at `FilterTime_1915`, matching the app's own 500-hour threshold
+behavior. `FilterAlarmTime_` in the same options blob is that threshold (500
+on every unit on record).
+
+The entity key stays `filter_time` rather than `filter_time_elapsed`:
+renaming it would change every existing unit's `entity_id`/`unique_id` for a
+wording improvement only.
+
+## Boards with no `FilterTime` token (`ARTIK051_PRAC_20K`)
+
+Negative result, measured 2026-08-11 on integration v0.21.0 / HA 2026.8.1,
+against one head of a three-head multi-split (`OptionCode_35880`,
+`ExtendOptionCode_199181`). **There is no local reset on this board**, by
+either route. Reset appears to be panel-only.
+
+This generation does not put the counter in `/mode/vs/0` at all. Its
+options blob carries no `FilterTime`, no `FilterAlarmTime` and no
+`FilterCleanAlarm`:
+
+```json
+["Sleep_0", "ArtificialWorking_Off", "ComfortAICooling_Off",
+ "AiTempChanged_Off", "AiTemp_240", "OutdoorTemp_77", "CoolCapa_25",
+ "WarmCapa_32", "Light_Off", "Volume_100", "OptionCode_35880",
+ "ExtendOptionCode_199181", "RacInfo_None", "UpdateAllow_NotAllowed",
+ "DurationOn_0", "WelcomeCoolingState_Off"]
+```
+
+The counter lives in its own resource instead, as a **percentage** of a
+500-hour interval rather than tenths of an hour —
+`/filter/airdustfilter/vs/0`:
+
+```json
+{
+  "x.com.samsung.da.filterUsage": "96",
+  "x.com.samsung.da.filterUsageResolution": "1",
+  "x.com.samsung.da.filterDesiredUsage": "500",
+  "x.com.samsung.da.filterStatus": "normal",
+  "x.com.samsung.da.filterCapacity": "500",
+  "x.com.samsung.da.filterCapacityUnit": "Hour",
+  "x.com.samsung.da.filterResetType": ["replaceable", "washable"]
+}
+```
+
+Three attempts, all against a live unit deliberately put in `fan_only`
+first — writes to a powered-off head on this board are dropped silently
+with no error, which would otherwise be indistinguishable from a rejected
+write:
+
+| Target | Payload | Result |
+|---|---|---|
+| `/mode/vs/0` | `{"x.com.samsung.da.options": ["FilterCleanAlarm_Clear"]}` | 4.00, options blob byte-identical |
+| `/filter/airdustfilter/vs/0` | `{"x.com.samsung.da.filterUsage": "0"}` | 4.00 |
+| `/filter/airdustfilter/vs/0` | `{"x.com.samsung.da.filterUsage": 0}` (integer) | 5.00 |
+
+`filterUsage` stayed at `96` throughout, verified by a live re-read after
+each write rather than by the integration's optimistic state.
+
+The last two rows are the informative pair. They differ only in JSON type
+and return *different* codes, which rules out both boring explanations: an
+unresolved href or an unrecognised field name would fail identically. The
+board parses the field, faults on the wrong type, and still refuses the
+value when typed as the string its own rep uses. The resource is
+**read-only**, not mis-addressed.
+
+One trap worth stating plainly: `filterResetType:
+["replaceable","washable"]` describes what the filter *is*, not a reset
+command that exists. It reads like a hint that a reset write is available
+somewhere. It is not.
+
+Since the integration cannot perform the reset here, it can still observe
+it. The counter only climbs in normal use, so a downward crossing is
+unambiguous: a `numeric_state` trigger with `below: 10` on
+`sensor.<name>_filter_usage`, stamping an `input_datetime`, keeps an
+honest "last cleaned" date without pretending a reset entity exists. The
+blind spot is a reset performed while HA is down or the entry is
+unloaded — no state transition, so that stamp has to be set by hand.

docs/investigations/composite-subdevice-hrefs.md

@@ -0,0 +1,184 @@
+# Composite AC subdevices: where else a sibling's hrefs could live
+
+Open question behind issue #335 (`ARTIK051_FAC_BORA_19K`, a 2-in-1 floor +
+wall AC): the board reports a sibling in `/subdevices/vs/0`'s
+`subdeviceIdList`, but every seed `registry/subdevices.enumerate_subdevices`
+tries comes back 4.04, so `subdevices` and `subdevices_skipped` are both
+empty and the wall unit never becomes an entity.
+
+This file records what that actually rules out (less than it looks like),
+why, and which hrefs are worth reading next.
+
+## `/oic/res` does not enumerate the resource tree on modern firmware
+
+This is the finding that reopens the question. Across every fixture that
+carries a captured `/oic/res`:
+
+| board | links | `sec:true` | lists `/device/0`? |
+| --- | --- | --- | --- |
+| `ARTIK051_DONGLE_FAC_18K` | 91 | 78 | yes |
+| `TP2X_FAC_BORA_21K` (2-in-1) | 17 | 6 | no |
+| `TP2X_FAC_BORA_21K` (#205 flat) | 17 | 6 | no |
+| `TP1X_DA_KS_RANGE_0101X` | 10 | 6 | no |
+| `AWM-WW-AID-26-ONEBODY` | 15 | 9 | no |
+| `ARTIK051_FAC_BORA_19K` (#335) | 18 | 6 | no |
+
+The `ARTIK051_DONGLE_FAC_18K` board — the one Pattern A was built against —
+is the outlier, not the model. Everywhere else `/oic/res` lists the
+onboarding surface and nothing else: `/oic/d`, `/oic/p`, the security and
+EasySetup/WiFiConf/CoapCloudConf/DevConf resources, file transfer, and the
+`sec/*` pair. On issue #335's board the six `sec:true` links are exactly
+doxm, pstat and the four setup URIs; every other listed link is `sec:false`.
+The entire secure operational tree — `/device/0` included, which
+demonstrably answers, since the dump comes from it — is absent.
+
+Two consequences, both load-bearing:
+
+1. **Nothing is learned from an href's absence in `/oic/res`.** On the range
+   board (issue #324) `/oic/res` lists ten onboarding links and no
+   `/device/0`, yet `/device/1` answers a full indexed dual-cavity sibling.
+   It was found only by `_SPECULATIVE_DEVICE_INDICES`, never by enumeration
+   of the links.
+2. **Pattern A's `/oic/res` index scan is dead weight on these boards.** It
+   contributes nothing anywhere except the dongle board, so in practice
+   indexed siblings are found by the speculative `/device/1`, `/device/2`
+   probe alone.
+
+## What issue #335 has actually ruled out
+
+All 26 probes in the report returned false. Twenty-three of them are the
+issue #205 flat fallback walking the master's own href list under the
+sibling's UUID prefix, plus `/<uuid>/device/0`, `/device/1`, `/device/2`
+and `/multidevice/vs/0`. Four more were read by hand from the issue thread
+(`/<uuid>/information/vs/{1,2}`, `/<uuid>/device/{1,2}`), all 4.04.
+
+So what is ruled out is: the UUID-prefixed namespace (Pattern B/C), and the
+indexed **Collection** (`/device/<n>`). What has never been read on this
+board — or on any `FAC_BORA` board — is **a bare indexed leaf**:
+`/mode/vs/1`, `/temperatures/vs/1`, and friends. Every indexed href ever
+probed by this project arrived via a `/device/<n>` batch; none was ever
+GETed directly.
+
+That gap matters because the "leaves exist, their Collection does not" shape
+is already confirmed on this exact product family, just in the other
+namespace: issue #205's `TP2X_FAC_BORA_21K` answers
+`/<uuid>/information/vs/0` while `/<uuid>/device/0` comes back empty. A
+board that mounts sibling leaves without mounting a sibling Collection is
+the documented BORA behavior, so `/device/1`'s 4.04 is evidence about the
+Collection and not about `/mode/vs/1`.
+
+## What the OCF spec says about composite devices
+
+The Core/Device specifications model this as a *Composite Device*: one
+Platform representing the whole appliance, `/oic/d` carrying the Device
+Types of every constituent Device, and — the relevant part — a **Collection
+per distinct Device in the composition**, each Collection's `rt` including
+the Device Type it represents.
+
+Issue #335's `/oic/d` reports `["oic.wk.d", "oic.d.airconditioner"]`, which
+is consistent with a two-indoor-unit composite (both constituents are air
+conditioners, so the type appears once) and equally consistent with a single
+unit. It does not discriminate.
+
+The Collection half does suggest something untried. `x.com.samsung.devcol`
+is Samsung's Collection type, carried by `/device/0` — and on the dongle
+board `/oic/res` advertises a second resource with the same
+`["x.com.samsung.devcol", "oic.wk.col"]` pair: **`/sec/devices`**. A
+collection of devices, sitting alongside `/device/0`, never read by this
+project or by any issue thread. If the composite enumeration is exposed
+anywhere as a first-class resource, that is the shape it would take.
+
+## Results of the second probe round
+
+The reporter ran these live. Three answers, all informative.
+
+**Indexed leaves do not exist.** `/information/vs/1`, `/power/vs/1`,
+`/mode/vs/1` → 4.04. Pattern A is ruled out on this board properly now:
+not just the `/device/1` Collection, but the leaf namespace it would have
+carried.
+
+**The UUID prefix routes, and is empty of operational resources.** The
+control pair settles it:
+
+    /c24e25e9-.../file/list/vs/0  → 2.05, two items
+    /file/list/vs/0              → 2.05, the same two items
+    (/opt/data/energy.db, /opt/data/hass.db)
+
+So the sibling's prefix is a live, routed namespace — the 23 flat-fallback
+4.04s under it are the firmware answering "no such resource", not a dead
+prefix swallowing everything. Pattern B/C is ruled out on this board on
+positive evidence rather than on absence. That the two listings are
+identical is expected either way: one board, one flash, one filesystem.
+
+**`/sec/devices` exists — and this project could not see what's in it.**
+It answered `2.05` with `rep: {}`, which reads as "the resource is there and
+has nothing in it". It is not. `coordinator._raw_read_blocking` decoded the
+CBOR body and then kept it *only if it was a Property map*:
+
+```python
+if isinstance(body, dict):
+    rep = body
+```
+
+A Collection answers a **list** — the `[devcol rep, {href, rep}, ...]` batch
+`parse_device0_batch` reads. `/device/0` itself would have rendered exactly
+the same accepted-but-empty `2.05 {}` through `read_resource`. Fixed: the
+read path now returns the decoded body alongside `rep`, and the service
+response carries it as `body` whenever it isn't the map already in `rep`.
+
+`/sec/devices` therefore remains the one open lead, and needs one re-read on
+a build carrying that fix.
+
+## Still worth reading
+
+**1 — `/sec/devices`, again.** Same `x.com.samsung.devcol` + `oic.wk.col`
+pair as `/device/0`, so its body should be a batch naming its members. If a
+composite enumeration is exposed anywhere, it is here.
+
+**2 — the file-transfer pair.** `/oic/res` advertises
+`/c24e25e9-.../file/transfer/vs/0` alongside the master's, and the prefix is
+now known to route. Issue #301 documents the shape: a baseline GET returns
+one item, `x.com.samsung.name` plus `x.com.samsung.blob`, no write needed to
+see whatever it currently serves. If the prefixed endpoint serves *different
+bytes* than the master's, that is the first hard local evidence the wall
+unit exists as a data producer, and `/opt/data/energy.db` would be where its
+runtime history lives.
+
+    /file/transfer/vs/0
+    /c24e25e9-55dd-ba18-d567-000000000001/file/transfer/vs/0
+
+Mind the blob: #301 measured 2172 B on a `KRAC_18K`, and a raw `bytes` value
+in a service response is not guaranteed to survive rendering in Developer
+Tools. Ask for `x.com.samsung.name` and whether a blob field appears, not
+for the blob pasted into a comment.
+
+## Dead ends, so they aren't re-tried
+
+- `/hass/state/vs/0`, `/hass/command/vs/0` — advertised in `/oic/res` on
+  every board here, and indexed per subdevice on the dongle board
+  (`/hass/state/vs/{0,1,2}`), which makes them look like a subdevice-aware
+  state channel. They are not: 4.04 on every interface on
+  `ARTIK051_KRAC_18K` (see `ac-filter-reset.md`). Cheap enough to retry once
+  on #335's newer build, but expect nothing.
+- `/multidevice/vs/0` — probed, 4.04. Absent on this board; only the dongle
+  family exposes it.
+- `/actions/vs/0` — GET returns `{}` on baseline and `oic.if.a`; publishes
+  no schema (`ac-filter-reset.md`).
+
+## Where this lands if `/sec/devices` is empty too
+
+Then the sibling is named in `subdeviceIdList` for the cloud's benefit and
+has no local operational surface at all on this firmware — every namespace
+it could occupy has now been read directly, and the UUID one was confirmed
+routable first, so the negatives mean what they say. That closes issue #335
+as a firmware limitation rather than leaving it open against a probe
+strategy that was never actually exercised.
+
+Worth keeping in view for the enumeration code either way: both remaining
+patterns hinge on a Collection, and this board answers neither `/device/1`
+nor a prefixed `/device/0`. An indexed flat-probe fallback — the mirror of
+issue #205's prefixed one, gated on a board that claims a sibling but
+materialized nothing — would have cost 8 round trips here and returned the
+same 4.04s the reporter got by hand. It is worth building only if some
+other board turns out to serve indexed leaves without their Collection;
+this one does not.

docs/investigations/download-cycle.md

@@ -0,0 +1,279 @@
+# Laundry cloud "Download" cycles: solved, with one dead end
+
+`registry/capabilities/laundry.py`'s cycle select offers a washer's
+downloaded ("Download" / "Downloaded") programs alongside its ordinary
+courses now, driven by the store in `cloudcourse.py` (issue #342). This file
+records the byte-level work behind it, including a decode that fit one
+device perfectly and collapsed on the second — the reason nothing in the
+shipped code interprets a program payload at all.
+
+Four devices in the corpus carry these tokens (a survey of every laundry
+diagnostics dump attached to an issue turned up 14 devices; the other 10 have
+no cloud tokens at all, so this is a minority feature):
+
+| dump | model | slots advertised | payloads seen | blob width |
+| --- | --- | --- | --- | --- |
+| `washer_ww5000c_cloud` | WW5000C `_B06C`, `DA_WM_TP1_21_COMMON`, Table_02 | 9 | 2 | 20 bytes |
+| `washer_wa55a7700av` | WA55A7700AV, `DA_WM_TP1_21_COMMON`, Table_02 | 2 | 1 | 16 bytes |
+| `dishwasher_dw5000c_cloud` | DW5000C, `DA_DW_TP1_21_COMMON` | 4 (but see below) | **0** | — |
+| (not fixtured) | WW5000C `_B048`, issues #259/#343, Table_02 | 9 | 1 | 20 bytes |
+
+Three things follow immediately from that table:
+
+- **`CloudExtraCourse_` does not mean the same thing on every family.** On
+  the DW5000C all four of its bytes (`8E 8D 8F 02`) are course codes in that
+  dishwasher's *own* course list, three already translated (Plastic, Pots and
+  pans, Baby Care). There it tags which ordinary courses came from the cloud;
+  they select with a plain `Course_` write and need no payload — consistent
+  with it carrying no payload token at all. It also has a
+  `DownloadCourseList_8F` token the washers lack.
+  On both washers the slots share **zero** overlap with the course list and a
+  payload is required. Subtracting the course list is what tells the two
+  apart (`cloudcourse.cloud_slots`), so the feature engages on the washers
+  and correctly does nothing on the dishwasher.
+- **A device can advertise a slot it has never loaded.** True on the washers
+  too — nothing about a program is learnable until its owner runs it, which
+  is what the Repairs issue exists to explain.
+- **Both WW5000C units advertise the byte-identical slot list**
+  (`0A5C286B2D0C55301A`, same nine slots in the same order) despite different
+  firmware builds. Either the set is a factory/regional default rather than
+  something each owner curates, or the two dumps share an owner — unresolved,
+  but worth knowing before assuming a user picked their own programs.
+
+## The three tokens
+
+All on `/course/vs/0`'s `x.com.samsung.da.options` array, same
+prefix-match/replace merge as every other token there.
+
+- `CloudExtraCourse_<slot><slot>…` — the device's own list of downloaded
+  program slots, one byte each. The cloud counterpart of `EditCourseList_`.
+- `CloudCourse_<blob>` — the persisted default program.
+- `OneTimeCloudCourse_<blob>` — a this-run-only override.
+
+### `CloudExtraCourse_` is an enumeration, and byte 2 of a blob is its slot
+
+The WW5000C reports `CloudExtraCourse_0A5C286B2D0C55301A` — nine bytes for
+its nine downloaded programs. Byte 2 of each of the nine blobs its owner
+captured is exactly one of those nine, no repeats, sets equal:
+
+```
+        blob                                       byte2  program
+        00 21 55 04 49 28 4D 13 4A A0 4C 00 …       55    Sports
+        00 20 28 04 49 00 4D 00 4A B8 4C 00 …       28    Spin only
+        00 02 5C 04 49 28 4D 13 4A B0 4C 00 …       5C    Outdoor
+        00 1F 6B 04 49 28 4D 13 4A A0 4C 00 …       6B    Jeans
+        00 2E 2D 04 49 30 4D 12 4A A0 4C 00 …       2D    Super quiet
+        00 2F 0C 04 49 58 4D 14 4A B8 4C 00 …       0C    Baby care intensive
+        00 0D 30 04 49 30 4D 12 4A B8 4C 00 …       30    Cloudy heaven
+        00 30 1A 04 49 28 4D 12 4A A0 4C 00 …       1A    Shirts
+        00 04 0A 04 49 40 4D 13 4A B8 4C 00 …       0A    Towels
+
+CloudExtraCourse_  0A 5C 28 6B 2D 0C 55 30 1A
+```
+
+Confirmed independently on the WA55A7700AV: `CloudExtraCourse_5958`, and its
+`CloudCourse` blob `00 1C 59 05 …` has byte 2 = `59`. Its
+`OneTimeCloudCourse` is `FF FF 01 …` — byte 2 = `01`, which is *not* an
+advertised slot, and the `FFFF` prefix marks it as "nothing loaded" rather
+than naming a program. That sentinel is why `cloudcourse.is_loaded` exists.
+
+This is what makes "3 of 9 discovered" answerable, and it is why no catalog
+of program ids is hardcoded anywhere: the appliance already knows which
+programs it has.
+
+## Writing: the two-token rule
+
+Confirmed on hardware by the issue #342 reporter. Writing
+`OneTimeCloudCourse_<blob>` alone while some other course is selected is
+accepted at the protocol level (no error) and then silently ignored by the
+machine. It takes effect only when the same write also switches `Course_` to
+the Download course — which is what `laundry._cloud_cycle_write` does, and
+the only two-token options write in the codebase:
+
+```yaml
+x.com.samsung.da.options:
+  - Course_87
+  - OneTimeCloudCourse_001F6B0449284D134AA04C0035F004F005F0AC00
+```
+
+`CloudCourse_` was separately confirmed writable on its own: set while on
+Download it changes the running program; set from another course it becomes
+what gets preselected the next time Download is chosen. The integration
+doesn't write it today — a "default download cycle" control is a possible
+follow-up, deliberately left out of the first pass.
+
+### There is no single "Download" course code
+
+The WW5000C's Download is `Course_87`; the WA55A7700AV's is `17`
+("Downloaded" in `washer_cycle_table_02`). **Same course table, different
+code.** Any per-table lookup of "the Download code" would have been wrong on
+one of the only two devices available to check it against, which is why the
+code is learned by observation and confirmed by the user in the options flow
+instead of tabled.
+
+The observation signal is "whatever `Course_` reads at the moment a
+non-sentinel `OneTimeCloudCourse_` *appears or changes*" — a transition that
+was actually watched, not a state. Tokens in this array are replaced by
+prefix and never evicted, so a payload merely sitting there says nothing
+about when it got there; on the first rep after a restart it is equally
+consistent with "just loaded" and "left over from last week". Believing it
+would propose whatever ordinary course the appliance happens to be sitting
+on, and accepting that prefill starts a real wash cycle. Even a genuine
+transition is only ever a *candidate*, confirmed by the user before use.
+
+Both dumps in the corpus taken while off the Download course
+(`washer_wa55a7700av` on `Course_01`, the `_B048` washer on `Course_1C`)
+show the appliance clearing its one-time token to the `FFFF` sentinel, so
+the saved default persists but the one-shot does not. That makes the stale
+case unlikely on these boards — which is a reason to expect it to behave,
+not a reason to depend on it.
+
+## The dead end: bytes 5/7/9 do not decode portably
+
+With the nine WW5000C programs and their app-reported settings side by side,
+three of the varying bytes fit perfectly:
+
+| byte | meaning | formula | fit |
+| --- | --- | --- | --- |
+| 5 | wash temperature | `(b - 0x10) / 0.8` °C, `0x00` = n/a | 9/9 |
+| 7 | rinse count | `b - 0x10`, `0x00` = off | 9/9 |
+| 9 | spin level | `(b - 0x90) / 8` | 9/9 |
+
+Nine for nine, including the internally consistent case: "Spin only" is the
+only program with `0x00` in *both* byte 5 and byte 7, matching a cycle that
+skips washing entirely while still reporting a spin level.
+
+It does not survive the second device. Against the WA55A7700AV's
+`CloudCourse` blob `00 1C 59 05 49 16 4D 11 4A 22 4C 20 37 F0 AC 22`:
+
+- temperature: `(0x16 - 0x10) / 0.8` = **7.5 °C**
+- spin: `(0x22 - 0x90) / 8` = **negative**
+- rinse: `0x11 - 0x10` = 1 — the only plausible one
+
+### What *does* survive is the grammar
+
+The two boards' payloads are different lengths (20 vs 16 bytes) but not a
+different format — same header, same leading fields, two fewer optional
+trailing ones:
+
+```
+WW5000C  00 | 2155 | 04 | 49:28  4D:13  4A:A0  4C:00 | 35:F0  04:F0  05:F0 | AC:00
+WA55     00 | 1C59 | 05 | 49:16  4D:11  4A:22  4C:20 | 37:F0               | AC:22
+```
+
+- `00`, then the 2-byte program id, then one byte (`04` vs `05`) — identical
+  layout on both.
+- Then a tag/value stream whose **first four tags are the same, in the same
+  order, at the same offsets**: `49`, `4D`, `4A`, `4C`. These are exactly the
+  four whose values vary per program.
+- Then a fixed tail, terminated on both by an `AC:<value>` pair. The entire
+  width difference is two trailing pairs the WA55 doesn't carry.
+
+The tail is not program data. Across all nine WW5000C programs bytes 12–19
+are byte-identical — every trailing pair carries value `F0` except the `AC`
+terminator, and `35` vs `37` looks like a board or profile marker rather than
+a field. (It is not a field count either: the board with the *higher* leading
+byte has *fewer* pairs.)
+
+### Byte 3 is not part of a program's identity
+
+Worth its own heading, because it is the single strongest argument against
+ever shipping a table of payloads. The second WW5000C (issues #259/#343,
+firmware `_B048`) has its saved `CloudCourse` set to the same program as the
+first one's "Towels" capture — and the two payloads differ at exactly one
+byte:
+
+```
+_B06C  "Towels"      00 04 0A 04 49 40 4D 13 4A B8 4C 00 35 F0 04 F0 05 F0 AC 00
+_B048  CloudCourse   00 04 0A 06 49 40 4D 13 4A B8 4C 00 35 F0 04 F0 05 F0 AC 00
+                              ^^
+```
+
+Same program id, same slot, same values on all four varying tags, same tail.
+Only byte 3 moves, `04` → `06`. So it is neither a per-board constant (both
+are WW5000C) nor a property of the program (identical in every other
+respect) — most likely a download revision or sequence counter.
+
+A hardcoded catalog keyed on program id would therefore have shipped one
+unit's byte 3 to the other unit. Whether the appliance would reject that, or
+accept it and do something unintended, is untested and does not need to be:
+every payload is learned from the device it will be replayed to.
+
+### Sentinels
+
+The `FFFF` "nothing loaded" payload takes its board's own width (16 bytes on
+the WA55, 20 on the WW5000C `_B048`) and always carries byte 3 = `00`. Its
+byte 2 is *not* reliably meaningful: it equals the currently selected course
+on the WA55 (`01`, on `Course_01`) and does not on the `_B048` (`1B`, on
+`Course_1C`). Nothing keys off it — a sentinel is rejected on its `FFFF`
+prefix, and its byte 2 is not an advertised slot in either dump anyway.
+
+So the payload is tag/value, not fixed offsets — but knowing the grammar
+doesn't recover the values. The same four tags carry non-overlapping ranges
+between the two boards:
+
+| tag | WW5000C (9 programs) | WA55 |
+| --- | --- | --- |
+| `49` | `00, 28, 30, 40, 58` | `16` |
+| `4D` | `00, 12, 13, 14` | `11` |
+| `4A` | `A0, B0, B8` | `22` |
+| `4C` | `00` (all nine) | `20` |
+
+Same field, board-specific encoding. Decoding it properly needs a third
+device; one device's fit is a coincidence-shaped hypothesis, not a format.
+
+**A trap for whoever picks this up:** the WA55's `/washer/vs/0` reads
+Warm / High / 1, which looks like it could confirm a decode of that unit's
+`CloudCourse`. It can't — that appliance is sitting on `Course_01` (Normal),
+not on its cloud course, so those values describe the local cycle it has
+selected, not the saved cloud program. A cross-check like this is only
+evidence when the machine is actually loaded with the program being decoded.
+
+So the shipped code never interprets a payload: a blob is recorded whole and
+replayed byte-for-byte, exactly as the device reported it, and never
+decomposed or rebuilt. The read-only "loaded program's temperature/spin"
+sensors this decode would have enabled were dropped for the same reason.
+
+## What is deliberately not done
+
+- **No hardcoded program catalog.** Blobs are cloud-assigned per
+  account/region. One owner's captured payload is not evidence about anyone
+  else's appliance, and a table of them would offer options that write
+  another household's wash settings.
+- **No invented names.** The appliance reports an opaque slot id and nothing
+  else. Names come from the user in the options flow, the same rule that
+  stops an unrecognized local course code from getting a made-up English
+  label (PR #251 review).
+- **No blob synthesis.** Even with the byte 5/7/9 decode in hand, nothing
+  builds a payload from parts — the device was never tested with one, and a
+  fabricated blob is an untested write to a wash cycle.
+
+## Open questions for the next dump
+
+1. Does `OneTimeCloudCourse_` clear itself when a cycle finishes, or when the
+   course changes? Behavior suggests the appliance falls back to
+   `CloudCourse_` when Download is re-entered, but the token's own lifecycle
+   is unconfirmed. `laundry.cloud_current` is written to be correct either
+   way.
+2. What does byte 1 mean? It is distinct per program and *sometimes*
+   coincides with a plausible local course code for that program (`2E` Baby
+   Care for "Baby care intensive", `30` Cloudy Day for "Cloudy heaven") and
+   sometimes doesn't (`21` Colors for "Sports"). Probably a base-course
+   reference; not reliable enough to use.
+3. What does byte 3 count? It moves between two units holding the identical
+   program (`04` vs `06`) and is `00` on every sentinel. A revision or
+   download counter is the obvious guess; a dump taken before and after
+   re-downloading the same program would confirm it.
+4. **The value encoding is still open, and a third *washer* won't
+   necessarily settle it.** The survey found one, but its saved program is a
+   duplicate of one already captured, so it adds no new tag values. What is
+   actually needed is a dump from a board whose `/washer/vs/0` speaks in
+   named levels (Cold/Warm/Hot, Low/High) *while that unit is sitting on a
+   downloaded program* — then the payload's `49`/`4A` values can be read
+   against settings that describe the same program. The WA55 is such a
+   board but was captured on a local course, which is why it can't be used
+   (see the trap above).
+5. The DW5000C's four slots (`8E 8D 8F 02`) are in the same numeric range as
+   dishwasher course codes (its selected course is `86`), unlike the
+   washers' slots. One payload from that machine would show whether slot ids
+   are drawn from the course-code space on some boards.

docs/investigations/offline-setup.md

@@ -0,0 +1,213 @@
+# Loading a config entry while the appliance is offline
+
+Issue #295 asks for faster recovery when a powered-off appliance comes back,
+instead of waiting out HA's `ConfigEntryNotReady` backoff. PR #303 tried to
+get there by catching the first-refresh failure in `async_setup_entry` and
+loading the entry anyway.
+
+That doesn't work here, and the reason is worth writing down: this
+integration has no static entity list. Every entity comes from discovery,
+and discovery only happens inside a successful poll.
+
+(The issue's "up to 15 minutes" is out of date, incidentally. Current HA
+retries on `2 ** min(tries, 4) * 5` seconds — capped at 80s, not 900. The
+backoff was never the worst part; a device card reading "Retrying setup" with
+no entities behind it is.)
+
+## What PR #303 produces today
+
+Measured on the PR's branch — set up with `_poll_once` raising, then advance
+the clock four summary intervals:
+
+| | |
+| --- | --- |
+| entry state | `LOADED` |
+| `coordinator.bound` | 0 |
+| entities in the state machine | 0 |
+| registry entries | 1 (the disabled connection-mode sensor) |
+| coordinator listeners | 0 |
+| `_unsub_refresh` | `None` |
+| poll attempts over the next 4 intervals | **0** |
+
+The entry loads and then never polls again. `DataUpdateCoordinator._async_refresh`
+reschedules only `if not auth_failed and self._listeners and not
+self.hass.is_stopping`; with no bound entities the only unconditional entity
+is `LocalThingsConnectionModeSensor`, which is
+`entity_registry_enabled_default = False` and so never added and never
+subscribes. Nothing reloads the entry either. The device comes back online to
+an entry that is permanently empty until a manual reload — strictly worse
+than the backoff it replaces, which did recover on its own within 15 minutes.
+
+## Why entities can't just be created offline
+
+Four independent gates, all of which need live device data:
+
+1. `bound` is only ever assigned in `_run_discovery` (`coordinator.py:1081`),
+   which runs on a poll's `resources` dict.
+2. All ten platforms enumerate `coordinator.bound` exactly once, at forward
+   time (`sensor.py:34` and siblings). Nothing adds entities later — the
+   invariant is already documented at `coordinator.py:1283-1286`.
+3. `_is_included` (`entity.py:39`) returns False whenever `last_resources`
+   has no rep for the href. Even a fully reconstructed `bound` filters to
+   nothing while `StateCache` is empty.
+4. `LocalThingsEntity` is a bare `CoordinatorEntity` with no `available`
+   override, no `RestoreEntity`, and no `Store` anywhere in the component. An
+   entity that did exist offline would be `unavailable` with no state.
+
+The issue cites ESPHome, Shelly, LIFX and WLED as precedent for setup that
+never fails. Those integrations can do it because each one has a *persisted
+device description* to build entities from — ESPHome keeps its entity list in
+`.storage`, Shelly caches device info. The pattern is portable; the mechanism
+underneath it is the part PR #303 is missing.
+
+## How the implemented version works
+
+Three pieces, plus a gating rule.
+
+### 1. A persisted discovery snapshot
+
+After each successful first cycle, `_save_snapshot` banks exactly the
+`resources` dict that cycle handed `_run_discovery`, along with the
+pre-narrowing subdevice candidate list and the `DeviceIdentity` read from
+`/oic/*`.
+
+Storing the poll input rather than a rendered entity list is the decision
+that keeps this honest. `BoundEntity` holds live
+`Capability`/`SamsungEntityDescription` objects and isn't serializable, so
+the alternative was a parallel format plus a re-resolution path — a second
+implementation of discovery that could drift from the real one. Replaying the
+input through `_run_discovery` means the same code, the same registry
+resolution, and no second source of truth.
+
+Three things ride along because `_run_discovery` reads them off `self`
+rather than out of `resources`, and getting them wrong would silently resolve
+a *different* registry offline than online — which reconciliation below would
+then see as a real change and reload on every restart:
+
+- `_identity.device_types` routes `resolve_registry`.
+- `self.subdevices` is the candidate list `discover_partitioned` narrows;
+  replaying against the already-narrowed list finds no siblings at all.
+- `_identity.manufacturer`/`model` feed `device_info`.
+
+It lives in `.storage` (`Store`, keyed on entry_id) rather than on the config
+entry: it's device state, not configuration, and runs to tens of kilobytes.
+`async_remove_entry` deletes it with the entry.
+
+The write is awaited, not `async_delay_save`d. A deferred write outlives
+whatever queued it: it lands after `async_remove_entry` has deleted the file
+and recreates it orphaned, and a reload scheduled by the reconcile below
+would read the pre-reload snapshot back off disk. It runs once per entry
+load, so there's nothing worth deferring. A write that fails is logged and
+swallowed — a board reporting something the JSON encoder rejects must not
+break polling.
+
+### 2. Reconcile on reconnect
+
+The snapshot is a claim about a device we haven't talked to yet. When the
+first live poll lands, `_reconcile_rehydrated` compares the live entity set
+against the rehydrated one — as `(subdevice key, _key(bound))` pairs, which
+is the unique_id identity — and calls `async_schedule_reload` if they differ.
+
+Gate 2 above is why this has to be a reload rather than an in-place fixup.
+It's what makes the feature safe against a firmware update, a sibling
+subdevice that starts answering, or a different appliance at the same IP.
+
+### 3. Keep polling with no listeners
+
+`async_setup_entry` holds one listener for the entry's lifetime:
+
+```python
+entry.async_on_unload(coordinator.async_add_listener(lambda: None))
+```
+
+Registered *before* the first refresh, so scheduling survives a refresh that
+fails. This alone fixes the measured "never polls again" bug, and covers a
+rehydrated set whose entities are all registry-disabled. Removing the last
+listener unschedules the timer, and HA runs `async_on_unload` callbacks when
+setup raises, so the setup-retry path doesn't leak a polling coordinator.
+
+### Gating rule: only load offline when there's a snapshot
+
+An entry that has never successfully polled has nothing to restore and keeps
+raising `ConfigEntryNotReady`. This is what answers the objection in the PR
+thread — with a snapshot we *do* have metadata to build a device from, and
+without one HA's backoff is still the right behavior. It also leaves room for
+the #168-style flows that need to interact with the device during setup: a
+device that never completed setup still blocks.
+
+It also means `async_remove_config_entry_device` is no longer reachable with
+an empty `coordinator.subdevices`, so an offline load can't offer to delete a
+real-but-unreachable subdevice.
+
+### The coverage-gap Repair stays live-only
+
+`_run_discovery(..., from_snapshot=True)` skips `_update_coverage_gap_issue`.
+The Repair points the user at a diagnostics download, which is empty until
+the appliance answers, and a device name that drifts between the snapshot and
+the live poll would churn the issue for no reason.
+
+Not a de-duplication measure — HA already handles that. `async_create_issue`
+is keyed on `(domain, issue_id)`, `dataclasses.replace` in
+`async_get_or_create` leaves `dismissed_version` alone, and the registry
+reloads non-persistent issues with their dismissal intact, so one row per
+entry survives restarts and an "Ignore" sticks.
+
+### What a cycle costs while the appliance stays dark (issue #269)
+
+An appliance switched off at the wall isn't a one-cycle blip: it fails the
+same way every 30s for hours, and both halves of that failure were being paid
+twice.
+
+`_poll_once` opens the session itself when there isn't one, so a switched-off
+appliance fails *in the handshake* — 12s (`DtlsCoapSession.HANDSHAKE_TIMEOUT_S`)
+with nothing to show for it. The poll path then treated that like any other
+poll failure and ran its reconnect: close the session, pause
+`_RECONNECT_PAUSE_S`, poll again. There is no session to close and no
+association for the device to clean up, so the "reconnect" was the identical
+handshake five seconds later — 29s of the 30s interval spent proving the
+appliance is off, twice over, and the same again on every `SETUP_RETRY`
+attempt for an entry with no snapshot to load from. `_handshake_failed` marks
+that case in `_poll_once` so the poll path can skip the retry; a session that
+opened and *then* broke still reconnects within the cycle.
+
+The log was the half the reporters actually saw: `poll failed after
+reconnect` at ERROR every cycle, plus a `reconnect_is_frequent` WARNING once
+three piled up, for a state this integration is specifically built to sit
+through. Issue #269's reporter read that repetition as the integration having
+failed. It's one ERROR per outage now, DEBUG for the cycles after it, and one
+INFO when the device answers again — HA's own coordinator already logs the
+transition into and out of a failed update.
+
+## What this still won't do
+
+Entities will be present and `unavailable` — not showing their last values.
+Gate 4 means last-known values require either `RestoreEntity` per platform or
+persisting `StateCache`, and both mean asserting state the integration cannot
+verify: a washer unplugged for a week would read "Running". HA's convention
+is that unreachable means unavailable, and the recorder keeps the history
+either way, so long-term statistics and history graphs are unaffected by this
+choice.
+
+Worth being explicit about, because it is the gap between what PR #303
+promises in the thread ("load their previously recorded states") and what any
+correct version can deliver.
+
+## Rejected: zeroconf
+
+The issue's other suggestion — wire zeroconf so the device's own boot
+announcement triggers a retry, which is the genuinely idiomatic HA answer —
+is a non-starter as things stand: there is no `zeroconf` or `dhcp` key in
+`manifest.json` and the config flow is user-driven only, so HA has no
+discovery signal for this integration to hang a retry on. It would first need
+a confirmed mDNS service on the appliance. Worth revisiting if one turns up;
+it would make recovery near-instant instead of within one poll interval.
+
+## Rejected: the cheap version
+
+Keeping `ConfigEntryNotReady` and adding a probe that calls
+`async_schedule_reload` on first success would have fixed the recovery *time*
+in about twenty lines, with no persistence and no reconcile. It was rejected
+because it leaves the device reading as broken for as long as the appliance
+is off, which is the half of issue #295 that actually bites — an appliance
+switched off at the wall is offline for days, not seconds, and a whole
+integration that looks failed for that entire window is the complaint.

requirements-dev.txt

@@ -6,7 +6,7 @@ pytest-homeassistant-custom-component>=0.13.316
 
 # Integration runtime deps, needed to import the component under test
 # (also declared in custom_components/localthings/manifest.json).
-smartthings-local>=0.1.2
+smartthings-local>=0.1.8
 cbor2>=5.4.6
 pyOpenSSL>=23.0
 cryptography>=41.0

tests/conftest.py

@@ -70,7 +70,7 @@ class FakeCoapSession:
         pass
 
 
-def _discover_full(resources: dict[str, dict], oic_res, seeds: dict[str, list]):
+def _discover_full(resources: dict[str, dict], oic_res, seeds: dict[str, list], device_types=()):
     """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
@@ -78,6 +78,12 @@ def _discover_full(resources: dict[str, dict], oic_res, seeds: dict[str, list]):
     it. See the adding-device-support skill's section 2 for the plain
     (non-subdevice) equivalent this extends.
 
+    `device_types` is the master's own /oic/d `rt` (see
+    discover_partitioned's `oic_device_types` param) -- only needed for a
+    board with no /information/vs/0 at all to route from (issue #324's
+    range, whose modelNum-based fallback has nothing to read), so it
+    defaults to () for every fixture that resolves by board token instead.
+
     Returns `(bound, materialized, skipped, full_resources, device_type_name)`:
     - `bound`: every BoundEntity, main + every materialized subdevice.
     - `materialized`/`skipped`: Subdevice / SkippedSubdevice lists straight from
@@ -101,6 +107,7 @@ def _discover_full(resources: dict[str, dict], oic_res, seeds: dict[str, list]):
         candidates,
         resolve,
         CAPABILITIES,
+        oic_device_types=device_types,
     )
     return bound, materialized, skipped, full_resources, device_type_name
 

tests/fixtures/dishwasher_dw5000c_cloud_device.json

@@ -0,0 +1,297 @@
+{
+  "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.periodicnotisubscription": "true"
+      }
+    },
+    {
+      "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": "DishA_Disable",
+            "x.com.samsung.da.triggeredTime": "2022-07-28T13:45:57",
+            "x.com.samsung.da.state": "Deleted"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/diagnosis/vs/0",
+      "rep": {
+        "x.com.samsung.da.diagnosisStart": "Ready"
+      }
+    },
+    {
+      "href": "/energy/consumption/vs/0",
+      "rep": {
+        "x.com.samsung.da.cumulativeSavedPower": "0"
+      }
+    },
+    {
+      "href": "/energy/consumption/0",
+      "rep": {}
+    },
+    {
+      "href": "/course/vs/0",
+      "rep": {
+        "x.com.samsung.da.supportedModes": [
+          "HOMECARE_WIZARD_V2"
+        ],
+        "x.com.samsung.da.options": [
+          "DeviceType_0812",
+          "UpdateAllow_NotAllowed",
+          "CourseDefaultTimeSet_008B008E009A006D003C000A006600A50059009D",
+          "CourseDefaultTempSet_3C41363F41413737373700003C3C464649493C3C",
+          "CourseDefaultFahrenheitSet_8C95819195958383838300008C8C9E9EA3A38C8C",
+          "Course_86",
+          "DetergentOnce_0",
+          "DetergentLeft_0",
+          "DetergentBase_0",
+          "DetergentAlarm_Off",
+          "DetergentType_0",
+          "DetergentTotal_0",
+          "ProgressTimeSet_420622820456B20384",
+          "SendToDevice_Off",
+          "GMT_F2",
+          "SavingModeCondition_01010207828485868E8D020300",
+          "SavingMode_Off",
+          "DownloadCourseList_8F",
+          "StormWashZone_Off",
+          "AutoDoorRelease_On",
+          "Sound_On",
+          "WaterLevelSet_050404050302010205010400",
+          "CloudExtraCourse_8E8D8F02",
+          "EnergyLevelSet_050403050202010305040300",
+          "UsagesDB_ok",
+          "EnergyKW_396",
+          "DrumCleanLog_Empty",
+          "TimeSync_NotSupported"
+        ],
+        "x.com.samsung.da.supportedOptions": [
+          "482830CB002C002D00283830CB002C002D00284830CB002C002D00285830CB000C000D00086830CB002C002D002908308B000C000D0008E830CB000C000D0008D830CB002C002D0028F8308B000C000D00002830CB002C002D002"
+        ]
+      }
+    },
+    {
+      "href": "/power/vs/0",
+      "rep": {
+        "x.com.samsung.da.power": "On"
+      }
+    },
+    {
+      "href": "/power/0",
+      "rep": {
+        "value": true
+      }
+    },
+    {
+      "href": "/kidslock/vs/0",
+      "rep": {
+        "x.com.samsung.da.kidsLock": "Ready"
+      }
+    },
+    {
+      "href": "/kidslock/0",
+      "rep": {
+        "value": false
+      }
+    },
+    {
+      "href": "/operational/state/vs/0",
+      "rep": {
+        "x.com.samsung.da.state": "Run",
+        "x.com.samsung.da.remainingTime": "00:44:00",
+        "x.com.samsung.da.progressPercentage": "28",
+        "x.com.samsung.da.delayStartTime": "00:00:00",
+        "x.com.samsung.da.progress": "Wash",
+        "x.com.samsung.da.supportedProgress": [
+          "None",
+          "Predrain",
+          "Wash",
+          "Rinse",
+          "Drying",
+          "Finish"
+        ]
+      }
+    },
+    {
+      "href": "/operational/state/0",
+      "rep": {
+        "currentMachineState": "**REDACTED**",
+        "machineStates": "**REDACTED**",
+        "jobStates": [
+          "None",
+          "Predrain",
+          "Wash",
+          "Rinse",
+          "Drying",
+          "Finish"
+        ],
+        "currentJobState": "Wash",
+        "remainingTime": "00:44:00",
+        "progressPercentage": "28"
+      }
+    },
+    {
+      "href": "/information/vs/0",
+      "rep": {
+        "x.com.samsung.da.modelNum": "DA_DW_TP1_21_COMMON|30010741|40000200001711004981000000200000",
+        "x.com.samsung.da.description": "DA_DW_TP1_21_COMMON_DW5000C/DD92-0010741_0001",
+        "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": "WD0",
+        "x.com.samsung.da.diagMinVersion": "1.0",
+        "x.com.samsung.da.items": [
+          {
+            "x.com.samsung.da.id": "0",
+            "x.com.samsung.da.description": "DA_DW_TP1_21_COMMON|30010741|40000200001711004981000000200000",
+            "x.com.samsung.da.type": "Software",
+            "x.com.samsung.da.number": "00081A230213(A214)",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          },
+          {
+            "x.com.samsung.da.id": "1",
+            "x.com.samsung.da.description": "Firmware_1_DB_30010741230602142FFFFFFFFFFFFFFFFFFFFFFFFFFE(081230010741FFFFFFFF_30000000)(FileDown:0)(Type:0)",
+            "x.com.samsung.da.type": "Firmware",
+            "x.com.samsung.da.number": "23060214,FFFFFFFF",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/file/information/vs/0",
+      "rep": {
+        "x.com.samsung.timeoffset": "+00:00"
+      }
+    },
+    {
+      "href": "/wm/editcourse/vs/0",
+      "rep": {}
+    },
+    {
+      "href": "/wm/setinfo/vs/0",
+      "rep": {
+        "x.com.samsung.da.isModelSettingWithoutSC": "false",
+        "x.com.samsung.da.isModelSettingPowerOnOff": "false"
+      }
+    },
+    {
+      "href": "/dishwasher/vs/0",
+      "rep": {
+        "x.com.samsung.da.highTemperatureDry": "Off",
+        "x.com.samsung.da.sanitize": "Off",
+        "x.com.samsung.da.selectedZone": "ON_ON",
+        "x.com.samsung.da.rinseLevel": "0",
+        "x.com.samsung.da.supportedSelectedZone": [
+          "OFF_ON",
+          "ON_ON"
+        ],
+        "x.com.samsung.da.supportedSanitize": [
+          "Off",
+          "On"
+        ],
+        "x.com.samsung.da.supportedHighTemperatureDry": [
+          "Off",
+          "On"
+        ],
+        "x.com.samsung.da.supportedRinseLevel": [
+          "0",
+          "1",
+          "2",
+          "3",
+          "4",
+          "5",
+          "6"
+        ]
+      }
+    },
+    {
+      "href": "/otninformation/vs/0",
+      "rep": {
+        "x.com.samsung.da.target": "Micom",
+        "x.com.samsung.da.newVersionAvailable": "false"
+      }
+    },
+    {
+      "href": "/remotectrl/vs/0",
+      "rep": {
+        "x.com.samsung.da.remoteControlEnabled": "true"
+      }
+    },
+    {
+      "href": "/remotectrl/0",
+      "rep": {
+        "value": true
+      }
+    },
+    {
+      "href": "/configuration/vs/0",
+      "rep": {
+        "x.com.samsung.da.region": "0000000000",
+        "x.com.samsung.da.countryCode": "CA"
+      }
+    },
+    {
+      "href": "/filter/waterfilter/vs/0",
+      "rep": {}
+    },
+    {
+      "href": "/drlc/0",
+      "rep": {
+        "DRLevel": 0,
+        "start": "0000-00-00T00:00:00Z",
+        "duration": 0,
+        "override": false
+      }
+    },
+    {
+      "href": "/drlc/vs/0",
+      "rep": {
+        "x.com.samsung.da.drlcLevel": "0",
+        "x.com.samsung.da.durationminutes": "0",
+        "x.com.samsung.da.start": "0000-00-00T00:00:00Z",
+        "x.com.samsung.da.override": "Off",
+        "x.com.samsung.da.realSaving": "Off"
+      }
+    },
+    {
+      "href": "/water/consumption/vs/0",
+      "rep": {
+        "x.com.samsung.da.cumulativeWater": "2662000"
+      }
+    },
+    {
+      "href": "/wm/submode/vs/0",
+      "rep": {
+        "setTemperatureUnit": "F"
+      }
+    }
+  ]
+}

tests/fixtures/dryer_dv6800n_device.json

@@ -0,0 +1,244 @@
+{
+  "device0": [
+    {
+      "rt": [
+        "x.com.samsung.devcol",
+        "oic.wk.col"
+      ],
+      "if": [
+        "oic.if.baseline",
+        "oic.if.ll",
+        "oic.if.b"
+      ]
+    },
+    {
+      "href": "/alarms/vs/0",
+      "rep": {}
+    },
+    {
+      "href": "/configuration/vs/0",
+      "rep": {
+        "x.com.samsung.da.region": "0000000000",
+        "x.com.samsung.da.countryCode": "US\u0001"
+      }
+    },
+    {
+      "href": "/course/vs/0",
+      "rep": {
+        "x.com.samsung.da.supportedModes": [
+          "HOMECARE_WIZARD_V2"
+        ],
+        "x.com.samsung.da.options": [
+          "DeviceType_0165",
+          "UpdateAllow_NotAllowed",
+          "Course_9A",
+          "MixedLoadBell_Disable",
+          "MixedLoadBellNoti_Nothing",
+          "LaundryOutTime_0",
+          "SeamlessControl_Disable",
+          "KidsLockBypass_On",
+          "DetergentOnce_0",
+          "DetergentLeft_0",
+          "DetergentBase_0",
+          "DetergentAlarm_Off",
+          "DetergentType_0",
+          "DetergentTotal_0",
+          "SpecialFunction_4",
+          "AvailableDelayTime_188",
+          "LaundryPlannerUserSetTime_0",
+          "ProgressTimeSet_B22D00B4003C",
+          "WrinklePreventRunning_Off",
+          "EnergyLevelSet_050502050503020304010204030203",
+          "MostUsed_9AD20EE000",
+          "MixedLoadBellSet_02FFFF02FFFFFFFFFFFFFFFFFF02",
+          "UsagesDB_ok",
+          "EnergyKW_396",
+          "TimeSync_NotSupported"
+        ],
+        "x.com.samsung.da.supportedOptions": [
+          "29AD20EE000CAD10EE000DBD204E00099D20EE00093D102E000B5D102E000D7D204E000A5D204E00096D000E10E97D000E10E7FD000E33E98D000E000EBD204E000B6D20EE000"
+        ]
+      }
+    },
+    {
+      "href": "/cycleinterface/vs/0",
+      "rep": {}
+    },
+    {
+      "href": "/diagnosis/vs/0",
+      "rep": {
+        "x.com.samsung.da.diagnosisStart": "Ready"
+      }
+    },
+    {
+      "href": "/energy/consumption/0",
+      "rep": {}
+    },
+    {
+      "href": "/energy/consumption/vs/0",
+      "rep": {
+        "x.com.samsung.da.instantaneousPowerUnit": "W",
+        "x.com.samsung.da.instantaneousPower": "-500",
+        "x.com.samsung.da.cumulativePower": "692600",
+        "x.com.samsung.da.cumulativeUnit": "Wh",
+        "x.com.samsung.da.cumulativeDate": "1786964400",
+        "x.com.samsung.da.cumulativeDateUTC": "1786960800"
+      }
+    },
+    {
+      "href": "/file/information/vs/0",
+      "rep": {
+        "x.com.samsung.timeoffset": "+01:00"
+      }
+    },
+    {
+      "href": "/information/vs/0",
+      "rep": {
+        "x.com.samsung.da.modelNum": "DA_WM_A51_20_COMMON|20221341|30010102001211000103000000000000",
+        "x.com.samsung.da.description": "DA_WM_A51_20_COMMON_DV6800N/DC92-01967B_0404",
+        "x.com.samsung.da.serialNum": "**REDACTED**",
+        "x.com.samsung.da.otnDUID": "**REDACTED**",
+        "x.com.samsung.da.items": [
+          {
+            "x.com.samsung.da.id": "0",
+            "x.com.samsung.da.description": "DA_WM_A51_20_COMMON|20221341|30010102001211000103000000000000",
+            "x.com.samsung.da.type": "Software",
+            "x.com.samsung.da.number": "02198A230708(E257)",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          },
+          {
+            "x.com.samsung.da.id": "1",
+            "x.com.samsung.da.description": "DA_WM_A51_20_COMMON",
+            "x.com.samsung.da.type": "Firmware",
+            "x.com.samsung.da.number": "17111305,17122616",
+            "x.com.samsung.da.newVersionAvailable": "0"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/kidslock/0",
+      "rep": {
+        "value": false
+      }
+    },
+    {
+      "href": "/kidslock/vs/0",
+      "rep": {
+        "x.com.samsung.da.kidsLock": "Ready"
+      }
+    },
+    {
+      "href": "/operational/state/0",
+      "rep": {
+        "currentMachineState": "**REDACTED**",
+        "machineStates": "**REDACTED**",
+        "jobStates": [
+          "None",
+          "Drying",
+          "Cooling",
+          "Finish"
+        ],
+        "currentJobState": "None",
+        "remainingTime": "03:08:00",
+        "progressPercentage": "1"
+      }
+    },
+    {
+      "href": "/operational/state/vs/0",
+      "rep": {
+        "x.com.samsung.da.state": "Ready",
+        "x.com.samsung.da.remainingTime": "03:08:00",
+        "x.com.samsung.da.progressPercentage": "1",
+        "x.com.samsung.da.progress": "None",
+        "x.com.samsung.da.delayEndTime": "00:00:00",
+        "x.com.samsung.da.supportedProgress": [
+          "None",
+          "Drying",
+          "Cooling",
+          "Finish"
+        ]
+      }
+    },
+    {
+      "href": "/power/0",
+      "rep": {
+        "value": false
+      }
+    },
+    {
+      "href": "/power/vs/0",
+      "rep": {
+        "x.com.samsung.da.power": "Off"
+      }
+    },
+    {
+      "href": "/realtimenotiforclient/vs/0",
+      "rep": {
+        "x.com.samsung.da.timeforshortnoti": "0",
+        "x.com.samsung.da.periodicnotisubscription": "true"
+      }
+    },
+    {
+      "href": "/remotectrl/0",
+      "rep": {
+        "value": false
+      }
+    },
+    {
+      "href": "/remotectrl/vs/0",
+      "rep": {
+        "x.com.samsung.da.remoteControlEnabled": "false"
+      }
+    },
+    {
+      "href": "/setting/vs/0",
+      "rep": {}
+    },
+    {
+      "href": "/st/dryercourse/vs/0",
+      "rep": {
+        "x.com.samsung.da.st.dryerMode": "Table_00_Course_9A",
+        "x.com.samsung.da.st.courseTable": "Table_00"
+      }
+    },
+    {
+      "href": "/washer/vs/0",
+      "rep": {
+        "x.com.samsung.da.wrinklePrevent": "Off",
+        "x.com.samsung.da.dryLevel": "2",
+        "x.com.samsung.da.supportedDryLevel": [
+          "None",
+          "1",
+          "2",
+          "3"
+        ],
+        "x.com.samsung.da.dryTime": "00:00:00",
+        "x.com.samsung.da.supportedDryTime": [
+          "00:00:00",
+          "00:30:00",
+          "01:00:00",
+          "01:30:00",
+          "02:00:00",
+          "02:30:00"
+        ],
+        "x.com.samsung.da.dryerType": "Electricity"
+      }
+    },
+    {
+      "href": "/wm/editcourse/vs/0",
+      "rep": {}
+    },
+    {
+      "href": "/wm/jobbeginingstatus/vs/0",
+      "rep": {}
+    },
+    {
+      "href": "/wm/setinfo/vs/0",
+      "rep": {
+        "x.com.samsung.da.isModelSettingWithoutSC": "false",
+        "x.com.samsung.da.isModelSettingPowerOnOff": "false"
+      }
+    }
+  ]
+}

tests/fixtures/gas_cooktop_tp2x_ks_device.json

@@ -0,0 +1,138 @@
+{
+  "device0": [
+    {
+      "rt": [
+        "x.com.samsung.devcol",
+        "oic.wk.col"
+      ],
+      "if": [
+        "oic.if.baseline",
+        "oic.if.ll",
+        "oic.if.b"
+      ]
+    },
+    {
+      "href": "/alarms/vs/0",
+      "rep": {
+        "rt": [
+          "x.com.samsung.da.alarms"
+        ],
+        "if": [
+          "oic.if.baseline",
+          "oic.if.a"
+        ],
+        "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": "CT_E",
+            "x.com.samsung.da.triggeredTime": "2026-08-06T14:24:02"
+          }
+        ]
+      }
+    },
+    {
+      "href": "/bluetooth/hood/status/vs/0",
+      "rep": {
+        "connectionState": "disconnected",
+        "micomModelId": "",
+        "firmwareVersion": "",
+        "power": "off",
+        "fanSpeed": 0,
+        "lampState": "off",
+        "timer": {},
+        "rt": [
+          "bluetoothHoodStatus"
+        ],
+        "if": [
+          "oic.if.baseline",
+          "oic.if.s"
+        ]
+      }
+    },
+    {
+      "href": "/configuration/vs/0",
+      "rep": {}
+    },
+    {
+      "href": "/connected/vs/0",
+      "rep": {
+        "x.com.samsung.da.connected": "On",
+        "rt": [
+          "x.com.samsung.da.connected"
+        ],
+        "if": [
+          "oic.if.baseline",
+          "oic.if.a"
+        ]
+      }
+    },
+    {
+      "href": "/kidslock/vs/0",
+      "rep": {
+        "x.com.samsung.da.kidsLock": "Ready"
+      }
+    },
+    {
+      "href": "/mode/vs/0",
+      "rep": {
+        "x.com.samsung.da.options": [
+          "DeviceType_NV8000T-/KO0",
+          "Pause_Off",
+          "SyncFlex_Off",
+          "FlexCoil_0",
+          "MainTimerCurrent_0",
+          "MainTimerSet_0",
+          "MainTimerState_Ready",
+          "IndependentTimerCheck_Enable",
+          "OperationState0_Ready",
+          "HotSurface0_Normal",
+          "PowerLevel0_0",
+          "OperationState1_Ready",
+          "HotSurface1_Normal",
+          "PowerLevel1_0",
+          "OperationState2_Ready",
+          "HotSurface2_Normal",
+          "PowerLevel2_0",
+          "OperationState3_Ready",
+          "HotSurface3_Normal",
+          "PowerLevel3_0",
+          "OperationState4_Ready",
+          "HotSurface4_Normal",
+          "PowerLevel4_0",
+          "OperationState5_Ready",
+          "HotSurface5_Normal",
+          "PowerLevel5_0"
+        ],
+        "rt": [
+          "x.com.samsung.da.mode"
+        ],
+        "if": [
+          "oic.if.baseline",
+          "oic.if.a"
+        ]
+      }
+    },
+    {
+      "href": "/otninformation/vs/0",
+      "rep": {
+        "x.com.samsung.da.target": "",
+        "x.com.samsung.da.newVersionAvailable": "false"
+      }
+    },
+    {
+      "href": "/power/vs/0",
+      "rep": {
+        "x.com.samsung.da.power": "Off",
+        "rt": [
+          "x.com.samsung.da.operation"
+        ],
+        "if": [
+          "oic.if.baseline",
+          "oic.if.a"
+        ]
+      }
+    }
+  ]
+}

tests/fixtures/golden/air_purifier_avt_ww.json

@@ -1,5 +1,6 @@
 {
   "state_keys": [
+    "air_sensing_state",
     "alarm_code",
     "clean_level",
     "device_active",
@@ -10,9 +11,17 @@
     "firmware_update",
     "hepa_filter_status",
     "hepa_filter_usage",
+    "last_air_sensing_level",
+    "last_air_sensing_time",
     "mute_once",
     "odor",
+    "periodic_air_sensing",
+    "periodic_sensing_skip_status",
     "power_switch",
+    "sensing_interval",
+    "sensing_mode",
+    "sensing_skip_end",
+    "sensing_skip_start",
     "super_fine_dust",
     "wind_strength_fan"
   ]

tests/fixtures/golden/air_purifier_tp1x_da_ac_air.json

@@ -1,5 +1,6 @@
 {
   "state_keys": [
+    "air_sensing_state",
     "alarm_code",
     "child_lock",
     "clean_level",
@@ -14,11 +15,18 @@
     "firmware_update",
     "hepa_filter_status",
     "hepa_filter_usage",
+    "last_air_sensing_level",
+    "last_air_sensing_time",
     "mute_once",
     "odor",
     "panel_status",
+    "periodic_air_sensing",
+    "periodic_sensing_skip_status",
     "pet_filter_activation",
     "power_switch",
+    "sensing_mode",
+    "sensing_skip_end",
+    "sensing_skip_start",
     "sound_mode",
     "sound_output",
     "sound_volume",

tests/fixtures/golden/air_purifier_vtww.json

@@ -1,5 +1,6 @@
 {
   "state_keys": [
+    "air_sensing_state",
     "alarm_code",
     "clean_level",
     "device_active",
@@ -9,8 +10,16 @@
     "firmware_update",
     "hepa_filter_status",
     "hepa_filter_usage",
+    "last_air_sensing_level",
+    "last_air_sensing_time",
     "odor",
+    "periodic_air_sensing",
+    "periodic_sensing_skip_status",
     "power_switch",
+    "sensing_interval",
+    "sensing_mode",
+    "sensing_skip_end",
+    "sensing_skip_start",
     "super_fine_dust",
     "wind_strength_fan"
   ]

tests/fixtures/golden/airconditioner.json

@@ -20,6 +20,7 @@
     "fine_dust",
     "humidity",
     "odor",
+    "outdoor_temperature",
     "power_watts",
     "super_fine_dust",
     "tropical_night_mode"

tests/fixtures/golden/airconditioner_ailp_fac.json

@@ -0,0 +1,40 @@
+{
+  "state_keys": [
+    "absence_clean",
+    "ai_energy_level",
+    "air_filter_status",
+    "air_filter_threshold",
+    "air_filter_usage",
+    "air_filter_usage_hours",
+    "air_purify",
+    "alarm_code",
+    "auto_clean",
+    "auto_clean_progress",
+    "auto_clean_running",
+    "beep",
+    "climate",
+    "current_temperature_c",
+    "display",
+    "energy_kwh",
+    "energy_saved_kwh",
+    "energy_saving_mode",
+    "energy_saving_operating_status",
+    "energy_saving_state",
+    "firmware_update",
+    "humidity",
+    "mute_once",
+    "odor_controller_active",
+    "odor_controller_progress",
+    "outdoor_temperature",
+    "power_energy_kwh",
+    "power_watts",
+    "selfcheck_error",
+    "selfcheck_result",
+    "selfcheck_status",
+    "sound_mode",
+    "sound_output",
+    "tropical_night_mode",
+    "uv_led",
+    "ventilation_alarm"
+  ]
+}

tests/fixtures/golden/airconditioner_ara_ww_tp1_22.json

@@ -18,6 +18,7 @@
     "mute_once",
     "odor_controller_active",
     "odor_controller_progress",
+    "outdoor_temperature",
     "power_watts",
     "tropical_night_mode"
   ]

tests/fixtures/golden/airconditioner_artik051_dongle_fac_18k.json

@@ -2,6 +2,7 @@
   "state_keys": [
     "alarm_code",
     "auto_clean_legacy",
+    "auto_clean_progress_legacy",
     "beep",
     "clean_level",
     "climate",
@@ -18,6 +19,7 @@
     "super_fine_dust",
     "subdevice1_alarm_code",
     "subdevice1_auto_clean_legacy",
+    "subdevice1_auto_clean_progress_legacy",
     "subdevice1_beep",
     "subdevice1_climate",
     "subdevice1_current_temperature_c",

tests/fixtures/golden/airconditioner_artik051_krac_18k.json

@@ -3,6 +3,7 @@
     "air_monitoring",
     "alarm_code",
     "auto_clean_legacy",
+    "auto_clean_progress_legacy",
     "beep",
     "climate",
     "current_temperature_c",

tests/fixtures/golden/airconditioner_artik051_krac_18k_slot.json

@@ -3,6 +3,7 @@
     "air_monitoring",
     "alarm_code",
     "auto_clean_legacy",
+    "auto_clean_progress_legacy",
     "beep",
     "climate",
     "current_temperature_c",

tests/fixtures/golden/airconditioner_artik051_krac_energy.json

@@ -3,6 +3,7 @@
     "air_monitoring",
     "alarm_code",
     "auto_clean_legacy",
+    "auto_clean_progress_legacy",
     "beep",
     "climate",
     "current_temperature_c",

tests/fixtures/golden/airconditioner_cac.json

@@ -1,5 +1,6 @@
 {
   "state_keys": [
+    "absence_clean",
     "absence_power_saving_active",
     "absence_power_saving_mode",
     "air_filter_pm1_status",
@@ -9,6 +10,7 @@
     "air_filter_usage",
     "air_filter_usage_hours",
     "air_purify",
+    "air_sensing_state",
     "alarm_code",
     "auto_clean",
     "auto_clean_progress",
@@ -17,20 +19,37 @@
     "climate",
     "current_temperature_c",
     "dust",
+    "edge_lighting",
+    "edge_lighting_color",
+    "edge_lighting_mode",
     "energy_kwh",
     "energy_saved_kwh",
     "fine_dust",
     "firmware_update",
     "humidity",
+    "indicator_light",
+    "indicator_light_mode",
+    "last_air_sensing_level",
+    "last_air_sensing_time",
     "motion_detect_wind_active",
     "motion_detect_wind_mode",
     "mute_once",
     "odor_controller_active",
     "odor_controller_progress",
+    "outdoor_temperature",
+    "periodic_air_sensing",
+    "periodic_sensing_skip_status",
     "power_watts",
     "selfcheck_error",
     "selfcheck_result",
     "selfcheck_status",
+    "sensing_interval",
+    "sensing_mode",
+    "sensing_skip_end",
+    "sensing_skip_start",
+    "sound_mode",
+    "sound_output",
+    "sound_volume",
     "super_fine_dust",
     "tropical_night_mode",
     "uv_led"

tests/fixtures/golden/airconditioner_caww_tp2.json

@@ -17,6 +17,7 @@
     "firmware_update",
     "humidity",
     "mute_once",
+    "outdoor_temperature",
     "power_watts",
     "tropical_night_mode"
   ]

tests/fixtures/golden/airconditioner_tp1x_da_ac_rac_01011.json

@@ -5,6 +5,7 @@
     "air_filter_usage",
     "air_filter_usage_hours",
     "air_purify",
+    "air_sensing_state",
     "alarm_code",
     "auto_clean",
     "auto_clean_progress",
@@ -19,10 +20,19 @@
     "fine_dust",
     "firmware_update",
     "humidity",
+    "last_air_sensing_level",
+    "last_air_sensing_time",
     "mute_once",
+    "outdoor_temperature",
+    "periodic_air_sensing",
+    "periodic_sensing_skip_status",
     "selfcheck_error",
     "selfcheck_result",
     "selfcheck_status",
+    "sensing_interval",
+    "sensing_mode",
+    "sensing_skip_end",
+    "sensing_skip_start",
     "super_fine_dust",
     "tropical_night_mode"
   ]

tests/fixtures/golden/airconditioner_tp1x_rac.json

@@ -19,6 +19,7 @@
     "energy_saved_kwh",
     "firmware_update",
     "mute_once",
+    "outdoor_temperature",
     "selfcheck_error",
     "selfcheck_result",
     "selfcheck_status",

tests/fixtures/golden/airconditioner_tp1x_rac_01001.json

@@ -18,6 +18,7 @@
     "mute_once",
     "odor_controller_active",
     "odor_controller_progress",
+    "outdoor_temperature",
     "power_watts",
     "tropical_night_mode"
   ]

tests/fixtures/golden/airconditioner_tp1x_rac_coolonly.json

@@ -16,6 +16,7 @@
     "firmware_update",
     "humidity",
     "mute_once",
+    "outdoor_temperature",
     "power_watts",
     "tropical_night_mode"
   ]

tests/fixtures/golden/airconditioner_tp1x_rac_odor_controller.json

@@ -20,6 +20,7 @@
     "mute_once",
     "odor_controller_active",
     "odor_controller_progress",
+    "outdoor_temperature",
     "selfcheck_error",
     "selfcheck_result",
     "selfcheck_status",

tests/fixtures/golden/airconditioner_tp2x_rac_20k.json

@@ -15,6 +15,7 @@
     "firmware_update",
     "humidity",
     "mute_once",
+    "outdoor_temperature",
     "power_watts",
     "tropical_night_mode"
   ]

tests/fixtures/golden/airconditioner_windfree.json

@@ -19,6 +19,7 @@
     "fine_dust",
     "humidity",
     "odor",
+    "outdoor_temperature",
     "power_watts",
     "super_fine_dust",
     "tropical_night_mode"

tests/fixtures/golden/airconditioner_window_ac.json

@@ -16,6 +16,7 @@
     "firmware_update",
     "humidity",
     "mute_once",
+    "outdoor_temperature",
     "power_watts",
     "selfcheck_error",
     "selfcheck_result",

tests/fixtures/golden/dishwasher.json

@@ -8,6 +8,7 @@
     "cycle_active",
     "delay_start_hours",
     "diagnosis_status",
+    "drum_clean_cycles_remaining",
     "energy_kwh",
     "energy_saved_kwh",
     "finish_time",
@@ -40,6 +41,7 @@
     "samsung_dishwasher_delay_start_hours",
     "samsung_dishwasher_diagnosis_start",
     "samsung_dishwasher_diagnosis_status",
+    "samsung_dishwasher_drum_clean_cycles_remaining",
     "samsung_dishwasher_energy_kwh",
     "samsung_dishwasher_energy_saved_kwh",
     "samsung_dishwasher_finish_time",

tests/fixtures/golden/dishwasher_dw5000c_cloud.json

@@ -0,0 +1,26 @@
+{
+  "state_keys": [
+    "alarm_code",
+    "auto_release_dry",
+    "child_lock",
+    "completion_minutes",
+    "cycle",
+    "cycle_active",
+    "delay_start_hours",
+    "diagnosis_status",
+    "energy_saved_kwh",
+    "filter_status",
+    "filter_usage",
+    "finish_time",
+    "firmware_update",
+    "heated_dry",
+    "machine_state",
+    "power_switch",
+    "progress",
+    "progress_percentage",
+    "remote_control",
+    "sanitize",
+    "storm_wash",
+    "water_liters"
+  ]
+}

tests/fixtures/golden/dryer_dv6800n.json

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

tests/fixtures/golden/gas_cooktop_tp2x_ks.json

@@ -0,0 +1,24 @@
+{
+  "state_keys": [
+    "alarm_code",
+    "any_burner_active",
+    "burner_0_state",
+    "burner_1_state",
+    "burner_2_state",
+    "burner_3_state",
+    "burner_4_state",
+    "burner_5_state",
+    "child_lock",
+    "cloud_connected",
+    "firmware_update",
+    "main_timer_current",
+    "main_timer_state",
+    "paired_hood_connected",
+    "paired_hood_fan_speed",
+    "paired_hood_firmware",
+    "paired_hood_light",
+    "paired_hood_model",
+    "paired_hood_power",
+    "power_state"
+  ]
+}

tests/fixtures/golden/induction_cooktop_nv9000d.json

@@ -0,0 +1,23 @@
+{
+  "state_keys": [
+    "alarm_code",
+    "burner_0_hot_surface",
+    "burner_0_pan_detected",
+    "burner_0_power_level",
+    "burner_0_state",
+    "burner_1_hot_surface",
+    "burner_1_pan_detected",
+    "burner_1_power_level",
+    "burner_1_state",
+    "burner_2_hot_surface",
+    "burner_2_pan_detected",
+    "burner_2_power_level",
+    "burner_2_state",
+    "cooktop_child_lock",
+    "cooktop_power",
+    "cooktop_safety_shutoff_enabled",
+    "cooktop_state",
+    "energy_kwh",
+    "firmware_update"
+  ]
+}

tests/fixtures/golden/oven_tp2x_ks_walloven.json

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

tests/fixtures/golden/range_tp1x_da_ks_range_0101x.json

@@ -0,0 +1,39 @@
+{
+  "state_keys": [
+    "alarm_code",
+    "child_lock",
+    "cloud_connected",
+    "cook_time",
+    "cooktop_on_alert",
+    "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",
+    "subdevice1_cloud_connected",
+    "subdevice1_cook_time",
+    "subdevice1_current_temp_c",
+    "subdevice1_cycle_active",
+    "subdevice1_finish_time",
+    "subdevice1_machine_state",
+    "subdevice1_operation_time_minutes",
+    "subdevice1_oven_mode",
+    "subdevice1_oven_setpoint",
+    "subdevice1_oven_state",
+    "subdevice1_progress_percentage",
+    "subdevice1_sound",
+    "warming_center_state"
+  ]
+}

tests/fixtures/golden/refrigerator_tp1x_ref_21k_airfilter.json

@@ -0,0 +1,36 @@
+{
+  "state_keys": [
+    "ai_energy_level",
+    "air_filter_status",
+    "air_filter_usage",
+    "alarm_code",
+    "auto_door_opener",
+    "brightness_level",
+    "cabinet_light_dim",
+    "cabinet_light_switch",
+    "cooler_setpoint",
+    "cooler_temperature",
+    "day_brightness",
+    "door_alert",
+    "door_cooler_open",
+    "door_freezer_open",
+    "energy_kwh",
+    "energy_saved_kwh",
+    "firmware_update",
+    "freezer_setpoint",
+    "freezer_temperature",
+    "fridge_sound",
+    "ice_night_mode",
+    "icemaker_one_enabled",
+    "icemaker_one_making_status",
+    "night_end",
+    "night_start",
+    "power_energy_kwh",
+    "power_watts",
+    "rapid_freezing",
+    "rapid_fridge",
+    "selfcheck_error",
+    "selfcheck_result",
+    "selfcheck_status"
+  ]
+}

tests/fixtures/golden/refrigerator_tp1x_ref_21k_autodoor.json

@@ -0,0 +1,24 @@
+{
+  "state_keys": [
+    "ai_energy_level",
+    "alarm_code",
+    "auto_door_opener",
+    "auto_door_timer",
+    "auto_door_voice_control",
+    "defrost_active",
+    "door_onedoorfreezer_open",
+    "energy_kwh",
+    "energy_saved_kwh",
+    "firmware_update",
+    "freezer_setpoint",
+    "freezer_temperature",
+    "fridge_sound",
+    "power_energy_kwh",
+    "power_watts",
+    "rapid_freezing",
+    "rapid_fridge",
+    "selfcheck_error",
+    "selfcheck_result",
+    "selfcheck_status"
+  ]
+}

tests/fixtures/golden/refrigerator_tp1x_ref_21k_kimchi.json

@@ -0,0 +1,22 @@
+{
+  "state_keys": [
+    "alarm_code",
+    "auto_door_opener",
+    "auto_door_timer",
+    "auto_door_voice_control",
+    "door_onedoorkimchi_open",
+    "energy_kwh",
+    "energy_saved_kwh",
+    "firmware_update",
+    "fridge_sound",
+    "onedoor_mode",
+    "onedoor_rack_count",
+    "onedoor_ripening_remaining",
+    "onedoor_ripening_status",
+    "power_energy_kwh",
+    "power_watts",
+    "selfcheck_error",
+    "selfcheck_result",
+    "selfcheck_status"
+  ]
+}