rustuya-local 0.1.0.dev1__tar.gz → 0.1.0.dev3__tar.gz

{rustuya_local-0.1.0.dev1 → rustuya_local-0.1.0.dev3}/CHANGELOG.md

@@ -8,6 +8,29 @@ stable release.
 
 ## [Unreleased]
 
+## [0.1.0.dev3] — 2026-10-11
+
+### Changed
+- Require tuya2ildevice 0.4.0.dev4 in the package and Home Assistant integration.
+- Load bundled official rules from `rules/builtin/`, exclude the manifest from rule layers, and apply user files after official rules regardless of filename.
+- Fetch the complete official pack into `rules/builtin/` inside the overrides directory and watch it for live reloads.
+- Retire unedited files owned by the old flat override pack while preserving user edits.
+- Include the official rule layers and manifest in the manager drop-in archive.
+
+## [0.1.0.dev2] — 2026-10-11
+
+### Fixed
+- Serialize device setting saves and override reloads so simultaneous commands preserve every device's settings,
+  including when a save is cancelled during file work.
+- Release a Hub's native rule pack on service shutdown, failed construction, and failed rule replacement; retain
+  shared packs until their last owner releases them.
+- Remove Runner reconnect callbacks and subscriptions on shutdown or failed startup, and await background cleanup.
+- Retry transient override-loading failures and read watched device files off the event loop.
+
+### Changed
+- Share atomic file replacement across settings, converter files and the override pack, using unique temporary files.
+- Refresh the roadmap and document the cover motion-source selector and position-source settings.
+
 ## [0.1.0.dev1] — 2026-10-11
 
 ### Changed

{rustuya_local-0.1.0.dev1 → rustuya_local-0.1.0.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: rustuya-local
-Version: 0.1.0.dev1
+Version: 0.1.0.dev3
 Summary: Local Tuya control: rustuya-bridge -> tuya2ildevice -> IL (ildevice). HA-independent core.
 Project-URL: Homepage, https://github.com/3735943886/rustuya-local
 Project-URL: Repository, https://github.com/3735943886/rustuya-local
@@ -10,7 +10,7 @@ License-File: LICENSE
 Requires-Python: >=3.13
 Requires-Dist: paho-mqtt>=2.0
 Requires-Dist: pyrustuyabridge>=0.4
-Requires-Dist: tuya2ildevice>=0.4.0.dev3
+Requires-Dist: tuya2ildevice>=0.4.0.dev4
 Provides-Extra: fullstack
 Requires-Dist: tuyamock; extra == 'fullstack'
 Provides-Extra: manager
@@ -103,28 +103,34 @@ config; integration: `<config>/rustuya_converters`; manager plugin: its data dir
 - Converters are JSON programs under `converters.declarative`; Python code plugins are not loaded.
 
 See tuya2ildevice's README ("User overrides") for the format. A curated set ships in tuya2ildevice, and fixes published
-between its releases (its [override pack](https://github.com/3735943886/tuya2ildevice/tree/master/rules/pack)) are copied
-into the directory at start and daily, as `00_pack_*` files that your own files refine. Turn that off with `"pack":
-false` (daemon), the Rustuya panel's *Options* (integration), or the plugin tab. The pack only replaces or removes the files it
+between its releases (its [override pack](https://github.com/3735943886/tuya2ildevice/tree/master/rules/builtin)) are copied
+into `rules/builtin/` inside the overrides directory at start and daily. These include `00-default.json`; your own
+files are applied after all official rules. The bundled defaults update with tuya2ildevice, even when pack sync is off.
+Turn online updates off with `"pack": false` (daemon), the Rustuya panel's *Options* (integration), or the plugin tab. The pack only replaces or removes the files it
 put there, and leaves a file alone once you edit it.
 
 ### Cover settings
 
-A curtain or blind whose position runs the other way, or that never shows *opening* / *closing*, is fixed from its
-own configuration switches, not a file. Each appears only where it changes something:
+A curtain or blind whose position runs the other way, or whose *opening* / *closing* state is wrong, can be fixed
+from its own configuration switches and motion-source selector. Each appears only where it changes something:
 
-| switch | shown when the cover has | turn it on when |
+| setting | shown when the cover has | use it when |
 |---|---|---|
 | *Invert current position* | a position it reports | fully opened, it shows 0% |
 | *Invert target position* | a target position, separate from the reported one | *Open* closes it |
 | *Invert control* | an open / close command and no target position | *Open* closes it |
-| *Infer motion* (on by default) | a reported position and a target or a command | off: when *opening* / *closing* is wrong |
+| *Use target as current position* | distinct reported and target position sources | the target DP should supply the displayed position |
+| *Motion state source* | a position or control DP, with no custom converter owning the motion state | choose `inferred` for motion inference, `control` for control reports, or `none` to disable motion generation; `control` requires a control DP |
+| *Invert reported motion* | the `control` motion source | the reported *opening* and *closing* meanings are reversed |
 
-With one position data point for both, *Invert current position* turns both. A switch changes nothing on the device:
+With one position data point for both, *Invert current position* turns both. Motion defaults to `inferred` when
+device settings are enabled, unless an override selects another source. A setting changes nothing on the device:
 the setting is saved as the device's block in `zz_settings.json` in the converters directory and applied at once, so it
 survives a restart and can be edited there too. Without a converters directory (a daemon with no
 `custom_converters`) the switches are not offered; `"options": {"device_settings": false}` turns them off.
-A block with the same `cover` keys in your own file or the pack sets a model's starting point; the switches win.
+A block with the same `cover` keys in your own file or the pack sets a model's starting point; the saved settings win.
+Older `cover.infer_motion` and `converters.cover_motion` blocks are upgraded on loading to `cover.state_source`
+(`inferred`, or `none` for `infer_motion: false`) and `cover.settle`; see [migration notes](docs/MIGRATING.md).
 
 In Home Assistant the files can be edited from a sidebar panel: the integration's *Configure* → *Add the Rustuya
 panel to the sidebar* adds it and links to it. The panel is for administrators. It fetches the device list from Tuya Cloud, shows the

{rustuya_local-0.1.0.dev1 → rustuya_local-0.1.0.dev3}/README.md

@@ -77,28 +77,34 @@ config; integration: `<config>/rustuya_converters`; manager plugin: its data dir
 - Converters are JSON programs under `converters.declarative`; Python code plugins are not loaded.
 
 See tuya2ildevice's README ("User overrides") for the format. A curated set ships in tuya2ildevice, and fixes published
-between its releases (its [override pack](https://github.com/3735943886/tuya2ildevice/tree/master/rules/pack)) are copied
-into the directory at start and daily, as `00_pack_*` files that your own files refine. Turn that off with `"pack":
-false` (daemon), the Rustuya panel's *Options* (integration), or the plugin tab. The pack only replaces or removes the files it
+between its releases (its [override pack](https://github.com/3735943886/tuya2ildevice/tree/master/rules/builtin)) are copied
+into `rules/builtin/` inside the overrides directory at start and daily. These include `00-default.json`; your own
+files are applied after all official rules. The bundled defaults update with tuya2ildevice, even when pack sync is off.
+Turn online updates off with `"pack": false` (daemon), the Rustuya panel's *Options* (integration), or the plugin tab. The pack only replaces or removes the files it
 put there, and leaves a file alone once you edit it.
 
 ### Cover settings
 
-A curtain or blind whose position runs the other way, or that never shows *opening* / *closing*, is fixed from its
-own configuration switches, not a file. Each appears only where it changes something:
+A curtain or blind whose position runs the other way, or whose *opening* / *closing* state is wrong, can be fixed
+from its own configuration switches and motion-source selector. Each appears only where it changes something:
 
-| switch | shown when the cover has | turn it on when |
+| setting | shown when the cover has | use it when |
 |---|---|---|
 | *Invert current position* | a position it reports | fully opened, it shows 0% |
 | *Invert target position* | a target position, separate from the reported one | *Open* closes it |
 | *Invert control* | an open / close command and no target position | *Open* closes it |
-| *Infer motion* (on by default) | a reported position and a target or a command | off: when *opening* / *closing* is wrong |
+| *Use target as current position* | distinct reported and target position sources | the target DP should supply the displayed position |
+| *Motion state source* | a position or control DP, with no custom converter owning the motion state | choose `inferred` for motion inference, `control` for control reports, or `none` to disable motion generation; `control` requires a control DP |
+| *Invert reported motion* | the `control` motion source | the reported *opening* and *closing* meanings are reversed |
 
-With one position data point for both, *Invert current position* turns both. A switch changes nothing on the device:
+With one position data point for both, *Invert current position* turns both. Motion defaults to `inferred` when
+device settings are enabled, unless an override selects another source. A setting changes nothing on the device:
 the setting is saved as the device's block in `zz_settings.json` in the converters directory and applied at once, so it
 survives a restart and can be edited there too. Without a converters directory (a daemon with no
 `custom_converters`) the switches are not offered; `"options": {"device_settings": false}` turns them off.
-A block with the same `cover` keys in your own file or the pack sets a model's starting point; the switches win.
+A block with the same `cover` keys in your own file or the pack sets a model's starting point; the saved settings win.
+Older `cover.infer_motion` and `converters.cover_motion` blocks are upgraded on loading to `cover.state_source`
+(`inferred`, or `none` for `infer_motion: false`) and `cover.settle`; see [migration notes](docs/MIGRATING.md).
 
 In Home Assistant the files can be edited from a sidebar panel: the integration's *Configure* → *Add the Rustuya
 panel to the sidebar* adds it and links to it. The panel is for administrators. It fetches the device list from Tuya Cloud, shows the

{rustuya_local-0.1.0.dev1 → rustuya_local-0.1.0.dev3}/custom_components/rustuya/manifest.json

@@ -9,12 +9,12 @@
   "iot_class": "local_push",
   "issue_tracker": "https://github.com/3735943886/rustuya-local/issues",
   "requirements": [
-    "tuya2ildevice>=0.4.0.dev3",
+    "tuya2ildevice>=0.4.0.dev4",
     "paho-mqtt>=2.0",
     "rustuya-manager>=0.2.2",
     "pyrustuyabridge>=0.4",
-    "rustuya-local>=0.1.0.dev1"
+    "rustuya-local>=0.1.0.dev3"
   ],
   "single_config_entry": true,
-  "version": "0.1.0.dev1"
+  "version": "0.1.0.dev3"
 }

{rustuya_local-0.1.0.dev1 → rustuya_local-0.1.0.dev3}/custom_components/rustuya/www/rustuya-panel.js

@@ -3,7 +3,7 @@
 // <config>/rustuya_converters and the override pack (the rustuya-manager plugin tab's file API).
 //
 // Home Assistant sets `hass`, `narrow` and `panel` on the element; every call goes through hass.callApi, which carries
-// the user's token. The views are for administrators only (converters run code in Home Assistant's process).
+// the user's token. The views are for administrators only (rule files change how devices are driven).
 
 const ORIGIN = { pack: "origin_pack", pack_edited: "origin_pack_edited" };      // I18N keys
 const PACK_CHANGES = ["added", "updated", "removed", "kept"];                    // a pack sync's lists, in this order

{rustuya_local-0.1.0.dev1 → rustuya_local-0.1.0.dev3}/docs/MIGRATING.md

@@ -69,8 +69,8 @@ rustuya-manager plugin. It is retired. Its replacement is two pieces:
    - `converters.cover_motion` and a cover's `infer_motion` are read as the cover's `state_source` (`inferred`, or
      `none` for `infer_motion: false`), and a `cover_motion` `settle` as the cover's `settle`; its other keys are
      dropped with a warning. `zz_settings.json` is rewritten in the new form the next time a setting is saved.
-   - Leave the old pack (`00_default.json`, `00_curtain.py`, `.rustuya_pack.json`) out. Fixes arrive as `00_pack_*`
-     files by themselves.
+   - Leave the old pack (`00_default.json`, `00_curtain.py`, `.rustuya_pack.json`) out. Official rules ship with tuya2ildevice; online updates arrive under
+     `rules/builtin/` automatically. User files are applied after all official rules.
 
    Changes to the directory are picked up while running, no restart needed.
 

{rustuya_local-0.1.0.dev1 → rustuya_local-0.1.0.dev3}/docs/ROADMAP.md

@@ -1,6 +1,16 @@
-# 남은 일 (2026-09-28 기준)
+# 남은 일 (2026-10-11 갱신)
 
-재설계(REDESIGN.md 9장)는 끝났다. 현재 배포: tuya2ildevice 0.3.16, rustuya-local 0.0.45(PyPI, HACS, 매니저 카탈로그 drop-in), rustuya-manager 0.2.1, pyrustuyabridge 0.4.0(PyPI).
+현재 작업 트리는 `rustuya-local 0.1.0.dev2`이며 `tuya2ildevice>=0.4.0.dev3`, `pyrustuyabridge>=0.4`를 요구한다.
+HA 통합과 매니저 플러그인 테스트는 `rustuya-manager>=0.2.2`를 사용한다. 변환은 Sans-I/O Rust 드라이버가 맡고,
+기기 레지스트리·IL MQTT 어댑터·전송·타이머·규칙 파일 로딩은 `rustuya_local.host`로 옮겼다.
+버전별 변경은 [CHANGELOG.md](../CHANGELOG.md)에 기록한다. 이 문서는 실제 배포 서버의 최신 상태를 확인하는 자료가 아니다.
+
+2026-10-11 코드 검토 후 동시 설정 저장을 직렬화하고, Hub 규칙 팩과 Runner 재연결 콜백의 종료 처리를 보강했다.
+파일 원자적 교체와 비동기 작업 종료 처리를 공통화했고, 기기 목록 감시의 파일 읽기를 이벤트 루프 밖으로 옮겼다.
+실기기 검증은 아래 M2에 기록된 범위이며, 이번 코드·자동 테스트 검증으로 완료 처리하지 않는다.
+
+아래 마일스톤의 완료 항목은 2026-09-28까지의 이력이다. 당시 배포 기준은 tuya2ildevice 0.3.16,
+rustuya-local 0.0.45, rustuya-manager 0.2.1, pyrustuyabridge 0.4.0이었다.
 rustuya-homeassistant 는 폐기 안내만 푸시했다(아카이브 안 함). 2026-09-27 에 저장소 이름을 rustuya-homeassistant 로 바꿨다가 같은 날
 되돌렸다(HA 전용이 아니고 이름이 여러 개면 헷갈림): 저장소·PyPI·import·CLI·플러그인 id 모두 `rustuya-local`.
 아래는 그 뒤에 남은 것을 마일스톤 순서로 정리한 것이다. 저장소 표기: **T** tuya2ildevice, **L** rustuya-local, **H** il-ha,

{rustuya_local-0.1.0.dev1 → rustuya_local-0.1.0.dev3}/pyproject.toml

@@ -4,12 +4,12 @@ build-backend = "hatchling.build"
 
 [project]
 name = "rustuya-local"
-version = "0.1.0.dev1"
+version = "0.1.0.dev3"
 description = "Local Tuya control: rustuya-bridge -> tuya2ildevice -> IL (ildevice). HA-independent core."
 readme = "README.md"
 requires-python = ">=3.13"
 license = "MIT"
-dependencies = ["tuya2ildevice>=0.4.0.dev3", "pyrustuyabridge>=0.4", "paho-mqtt>=2.0"]
+dependencies = ["tuya2ildevice>=0.4.0.dev4", "pyrustuyabridge>=0.4", "paho-mqtt>=2.0"]
 # rustuya-manager (custom_components/rustuya's config flow) is optional at the package level (the HA manifest
 # pulls it in); declared here too so the venv used for this repo's tests has it. pyrustuyabridge is a base dependency
 # now (not just for the embedded bridge): rustuya-local's own bridge_client uses it to interpret rustuya-bridge's

rustuya_local-0.1.0.dev3/release-notes.md

@@ -0,0 +1,6 @@
+### Changed
+- Require tuya2ildevice 0.4.0.dev4 in the package and Home Assistant integration.
+- Load bundled official rules from `rules/builtin/`, exclude the manifest from rule layers, and apply user files after official rules regardless of filename.
+- Fetch the complete official pack into `rules/builtin/` inside the overrides directory and watch it for live reloads.
+- Retire unedited files owned by the old flat override pack while preserving user edits.
+- Include the official rule layers and manifest in the manager drop-in archive.

{rustuya_local-0.1.0.dev1 → rustuya_local-0.1.0.dev3}/scripts/build_dropin.py

@@ -58,7 +58,10 @@ def _members() -> list[tuple[str, Path]]:
             members = dict(out)
             members.setdefault(f"{prefix}/{native.name}", native)
             for layer in rule_files(rule_paths()[:1]):          # the rule layers a wheel bundles, nothing else
-                members.setdefault(f"{prefix}/rules/{layer.name}", layer)
+                members.setdefault(f"{prefix}/rules/builtin/{layer.name}", layer)
+            manifest = rule_paths()[0] / 'manifest.json'
+            if manifest.is_file():
+                members.setdefault(f"{prefix}/rules/builtin/manifest.json", manifest)
             out = list(members.items())
     return sorted(out)
 

rustuya_local-0.1.0.dev3/src/rustuya_local/async_tools.py

@@ -0,0 +1,24 @@
+"""Small lifecycle helpers for background tasks and file work."""
+
+import asyncio
+import contextlib
+from collections.abc import Callable
+
+
+async def cancel_task(task: asyncio.Task | None) -> None:
+    """Cancel an owned task and wait until its cleanup has finished."""
+    if task is not None:
+        task.cancel()
+        with contextlib.suppress(asyncio.CancelledError):
+            await task
+
+
+async def run_in_thread[**P, T](function: Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> T:
+    """Finish file work before propagating cancellation; cancelling cannot stop its thread."""
+    task = asyncio.create_task(asyncio.to_thread(function, *args, **kwargs))
+    try:
+        return await asyncio.shield(task)
+    except asyncio.CancelledError:
+        # Do not release a caller's lock or close its resources while the worker still uses them.
+        await asyncio.gather(task, return_exceptions=True)
+        raise

rustuya_local-0.1.0.dev3/src/rustuya_local/files.py

@@ -0,0 +1,18 @@
+"""Atomic replacement shared by settings, converter files and the override pack."""
+
+import os
+import tempfile
+from pathlib import Path
+
+
+def atomic_write(path: Path, data: str | bytes) -> None:
+    """Replace a file using a unique sibling temporary file; preserve it if writing fails."""
+    payload = data.encode("utf-8") if isinstance(data, str) else data
+    fd, name = tempfile.mkstemp(dir=path.parent, prefix=f".{path.name}.")
+    temporary = Path(name)
+    try:
+        with os.fdopen(fd, "wb") as stream:
+            stream.write(payload)
+        os.replace(temporary, path)
+    finally:
+        temporary.unlink(missing_ok=True)

{rustuya_local-0.1.0.dev1 → rustuya_local-0.1.0.dev3}/src/rustuya_local/host/devices.py

@@ -7,13 +7,25 @@ from __future__ import annotations
 import asyncio
 import json
 import logging
+from dataclasses import dataclass
 from pathlib import Path
+from typing import Protocol
 
-from .runner import Runner
+from ..async_tools import cancel_task, run_in_thread
 
 _LOGGER = logging.getLogger(__name__)
 
 
+class DeviceRegistry(Protocol):
+    def sync_devices(self, records: list[dict]) -> object: ...
+
+
+@dataclass(frozen=True)
+class _DeviceUpdate:
+    stamp: tuple[int, int] | None
+    records: list[dict] | None
+
+
 def parse_devices(raw: str | bytes) -> tuple[list[dict], list[str]]:
     """(usable records, ids skipped). The file is a list of records or a dict of them; a record without an `id` or a
     `category` cannot be turned into an IL device (there is nothing to classify it by)."""
@@ -43,7 +55,7 @@ class DeviceWatcher:
     """Follow the device file: a new record is added to the runner, a changed one replaced, a removed one removed.
     A file that cannot be read or parsed right now (half written by something else) leaves things as they are."""
 
-    def __init__(self, path: str | Path, runner: Runner, interval: float = 5.0) -> None:
+    def __init__(self, path: str | Path, runner: DeviceRegistry, interval: float = 5.0) -> None:
         self.path = Path(path)
         self.runner = runner
         self.interval = interval
@@ -51,13 +63,13 @@ class DeviceWatcher:
         self._task: asyncio.Task | None = None
 
     def start(self) -> None:
-        self._stamp = self._stat()
-        self._task = asyncio.ensure_future(self._loop())
+        if self._task is None:
+            self._stamp = self._stat()
+            self._task = asyncio.create_task(self._loop())
 
     async def stop(self) -> None:
-        if self._task:
-            self._task.cancel()
-            self._task = None
+        task, self._task = self._task, None
+        await cancel_task(task)
 
     def _stat(self) -> tuple[int, int] | None:
         try:
@@ -68,20 +80,31 @@ class DeviceWatcher:
 
     def check(self) -> bool:
         """Sync once if the file changed since the last look; True if it did."""
+        return self._apply(self._read_changes())
+
+    def _read_changes(self) -> _DeviceUpdate | None:
         stamp = self._stat()
         if stamp is None or stamp == self._stamp:
-            return False
-        self._stamp = stamp
+            return None
         try:
             records = load_devices(self.path)
         except (OSError, ValueError):
             _LOGGER.warning("could not read %s; keeping the devices as they are", self.path)
-            self._stamp = None                      # look again next time
-            return True
-        self.runner.sync_devices(records)
+            return _DeviceUpdate(None, None)        # look again next time
+        return _DeviceUpdate(stamp, records)
+
+    def _apply(self, update: _DeviceUpdate | None) -> bool:
+        if update is None:
+            return False
+        if update.records is not None:
+            self.runner.sync_devices(update.records)
+        self._stamp = update.stamp
         return True
 
     async def _loop(self) -> None:
         while True:
             await asyncio.sleep(self.interval)
-            self.check()
+            try:
+                self._apply(await run_in_thread(self._read_changes))
+            except Exception:
+                _LOGGER.exception("could not sync devices from %s; will retry", self.path)

{rustuya_local-0.1.0.dev1 → rustuya_local-0.1.0.dev3}/src/rustuya_local/host/hub.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import time
+import weakref
 from collections import Counter
 from collections.abc import Sequence
 from typing import Any
@@ -27,6 +28,12 @@ from .rules import upgrade_overrides
 _pack_users: Counter[str] = Counter()
 
 
+def _acquire(rules: dict) -> str:
+    rules_id = register_rules(rules)
+    _pack_users[rules_id] += 1
+    return rules_id
+
+
 def _release(rules_id: str) -> None:
     _pack_users[rules_id] -= 1
     if _pack_users[rules_id] <= 0:
@@ -42,16 +49,27 @@ class Hub:
         self.il = il or IlTopics()
         self._kw = {**driver_kwargs, 'rules': rules if rules is not None else default_rules()}
         self._kw['overrides'] = upgrade_overrides(self._kw.get('overrides'))
-        self._rules_id = register_rules(self._kw['rules'])
-        _pack_users[self._rules_id] += 1
         for device in devices:
             self._check_id(device['id'])
         self._devices = {d['id']: d for d in devices}
-        self.drivers = {i: self._create(d, self._kw) for i, d in self._devices.items()}
+        self.drivers: dict[str, TuyaDriver] = {}
+        self._rules_id = _acquire(self._kw['rules'])
+        self._release_rules = weakref.finalize(self, _release, self._rules_id)
+        try:
+            self.drivers = {i: TuyaDriver(d, **self._kw) for i, d in self._devices.items()}
+        except BaseException:
+            self.close()
+            raise
 
-    @staticmethod
-    def _create(device, options):
-        return TuyaDriver(device, **options)
+    def close(self) -> None:
+        """Release this Hub's drivers and rule pack once; stop() only publishes presence."""
+        self.drivers.clear()
+        self._devices.clear()
+        self._release_rules()
+
+    def _check_open(self) -> None:
+        if not self._release_rules.alive:
+            raise RuntimeError('Hub is closed')
 
     @property
     def records(self) -> dict[str, dict]:
@@ -87,8 +105,9 @@ class Hub:
 
     def set_device(self, device: dict, seed: Sequence[Connected | Disconnected | Message] = (),
                    now: float | None = None) -> list:
+        self._check_open()
         self._check_id(device['id'])
-        new = self._create(device, self._kw)
+        new = TuyaDriver(device, **self._kw)
         old = self.drivers.get(device['id'])
         if not seed and old is not None and old.linked:
             seed = [Connected()]
@@ -110,19 +129,27 @@ class Hub:
                 *self.il.clear(device_id, old.descriptor['props'], descriptor=True)]
 
     def reload(self, overrides: dict | None, *, rules: dict | None = None, now: float | None = None) -> list:
+        self._check_open()
         options = {**self._kw, 'overrides': upgrade_overrides(overrides)}
-        rules_id = self._rules_id
         if rules is not None:
             options['rules'] = rules
-            rules_id = register_rules(rules)
+        rules_id = _acquire(options['rules'])
         try:
-            fresh = {i: self._create(d, options) for i, d in self._devices.items()}
-        except Exception:
-            if not _pack_users[rules_id]:           # refused: a pack nobody took is not kept
-                unregister_rules(rules_id)
+            fresh = {i: TuyaDriver(d, **options) for i, d in self._devices.items()}
+            actions, replacements = self._replacements(fresh, options['rules'], time.time() if now is None else now)
+        except BaseException:
+            _release(rules_id)
             raise
+        self.drivers.update(replacements)
+        self._kw = options
+        self._release_rules()
+        self._rules_id = rules_id
+        self._release_rules = weakref.finalize(self, _release, rules_id)
+        return actions
+
+    def _replacements(self, fresh: dict[str, TuyaDriver], rules: dict,
+                      now: float) -> tuple[list, dict[str, TuyaDriver]]:
         actions = []
-        now = time.time() if now is None else now
         replacements = {}
         for device_id, new in fresh.items():
             old = self.drivers[device_id]
@@ -131,17 +158,11 @@ class Hub:
             seed = [Connected()] if old.linked else []
             if old.synced:
                 seed.append(Message('state', old.dps))
-            actions.extend(self._adopt(old, new, seed, now, rules=options['rules']))
+            actions.extend(self._adopt(old, new, seed, now, rules=rules))
             if old.linked and not old.synced:
                 actions.append(BridgeCommand(device_id, 'get'))
             replacements[device_id] = new
-        self.drivers.update(replacements)
-        self._kw = options
-        if rules_id != self._rules_id:              # every driver was replaced: none uses the old pack now
-            _pack_users[rules_id] += 1
-            _release(self._rules_id)
-            self._rules_id = rules_id
-        return actions
+        return actions, replacements
 
     def subscriptions(self) -> list[Subscribe]:
         return [Subscribe(IL, self.il.set_subscription())]
@@ -150,6 +171,7 @@ class Hub:
         return Publish(IL, self.il.presence, 'online' if online else 'offline', True)
 
     def start(self, now: float | None = None) -> list:
+        self._check_open()
         now = time.time() if now is None else now
         actions = [self.presence(True)]
         for device_id, driver in self.drivers.items():