flowevent 1.2__tar.gz → 1.2.1__tar.gz

{flowevent-1.2 → flowevent-1.2.1}/CHANGELOG.md

@@ -4,6 +4,26 @@ All notable changes to this project are documented in this file.
 
 ## [Unreleased]
 
+## [v1.2.1] - 2026-11-02
+
+### Changed
+
+- Isolate sync and async subscriber matching in focused bus helpers while
+  keeping their cancellation and replay behavior separate.
+- Share finite timeout validation and replay-history window selection across
+  both buses without merging their independent delivery paths.
+- Count a publication only after a configured history append succeeds, and
+  reject non-string engine channel names instead of coercing them.
+- Skip repeated event-loop lookups on stream reads after the owning consumer
+  task has been established.
+- Run Twine metadata checks in strict mode in CI.
+
+### Fixed
+
+- Claim engine-created channels for their owning engine, preserve finite
+  subscription deliveries when cancellation or executor submission fails, and
+  coordinate concurrent synchronous subscription cancellation retries.
+
 ## [v1.2] - 2026-11-02
 
 ### Added

{flowevent-1.2/flowevent.egg-info → flowevent-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flowevent
-Version: 1.2
+Version: 1.2.1
 Summary: EventFlow: synchronous and asynchronous event delivery for Python.
 Author-email: TahsinCr <Tahsincr@outlook.com>
 License-Expression: MIT
@@ -30,7 +30,7 @@ Requires-Dist: pyright<2,>=1.1.400; extra == "dev"
 Requires-Dist: ruff<1,>=0.12; extra == "dev"
 Dynamic: license-file
 
-[![Version: v1.2][version-shield]](https://github.com/TahsinCr/python-eventflow/blob/main/CHANGELOG.md)
+[![Version: v1.2.1][version-shield]](https://github.com/TahsinCr/python-eventflow/blob/main/CHANGELOG.md)
 [![Python 3.10+][python-shield]](https://www.python.org/downloads/)
 [![MIT License][license-shield]](https://github.com/TahsinCr/python-eventflow/blob/main/LICENSE)
 
@@ -146,7 +146,7 @@ The installed package exposes its version through `eventflow.__version__`:
 ~~~python
 from eventflow import __version__
 
-print(__version__)  # 1.2
+print(__version__)  # 1.2.1
 ~~~
 
 <a id="first-event"></a>
@@ -327,10 +327,11 @@ directly. The bus attempts delivery to the selected handlers, then raises an
 a `PublishResult`. The `bus.stats` property provides cumulative
 `published`, `delivered`, and `failed` counts.
 
-These counters are not a per-publish invariant. `published` is incremented
-before callbacks run; `delivered` and `failed` are finalized afterward. An
-in-flight or cancelled async publish can leave them different. `failed` counts
-collected errors from handlers, filters, and actions, not only failed handlers.
+These counters are not a per-publish invariant. `published` advances after
+history recording succeeds (or is skipped when history is disabled) and before
+callbacks run; `delivered` and `failed` are finalized afterward. An in-flight
+or cancelled async publish can leave them different. `failed` counts collected
+errors from handlers, filters, and actions, not only failed handlers.
 
 To catch grouped failures with the same import on Python 3.10 and newer, import
 `ExceptionGroup` from `eventflow.compatibility`. On Python 3.11 and newer, that
@@ -607,10 +608,11 @@ with EventEngine(history=50) as engine:
     print(result.delivered)
 ~~~
 
-Channel names are stripped and lowercased, so `" Orders "` and `"orders"`
-refer to the same channel. `engine.channel(name)` returns a channel, creating
-it when necessary. Use `engine.add(name, bus)` to register a bus with custom
-settings. `remove(name)` closes one channel; `stop()` closes every channel.
+Channel names must be strings and are stripped and lowercased, so `" Orders "`
+and `"orders"` refer to the same channel. `engine.channel(name)` returns a
+channel, creating it when necessary. Use `engine.add(name, bus)` to register a
+bus with custom settings. `remove(name)` closes one channel; `stop()` closes
+every channel.
 An engine can own a bus instance under only one channel name at a time. A
 successful `add()` claims that bus for the engine; another engine cannot claim
 the same instance and receives `ValueError`. Removing or stopping the owner
@@ -1166,6 +1168,6 @@ Copyright © 2026 TahsinCr. EventFlow is licensed under the MIT License.
 See [LICENSE](https://github.com/TahsinCr/python-eventflow/blob/main/LICENSE) and
 [CHANGELOG](https://github.com/TahsinCr/python-eventflow/blob/main/CHANGELOG.md).
 
-[version-shield]: https://img.shields.io/badge/version-v1.2-b7a3e3.svg?style=for-the-badge
+[version-shield]: https://img.shields.io/badge/version-v1.2.1-b7a3e3.svg?style=for-the-badge
 [python-shield]: https://img.shields.io/badge/Python-3.10%2B-3776AB.svg?style=for-the-badge&logo=python&logoColor=white
 [license-shield]: https://img.shields.io/badge/license-MIT-blue.svg?style=for-the-badge

{flowevent-1.2 → flowevent-1.2.1}/README-TR.md

@@ -1,4 +1,4 @@
-[![Sürüm: v1.2][version-shield]](https://github.com/TahsinCr/python-eventflow/blob/main/CHANGELOG.md)
+[![Sürüm: v1.2.1][version-shield]](https://github.com/TahsinCr/python-eventflow/blob/main/CHANGELOG.md)
 [![Python 3.10+][python-shield]](https://www.python.org/downloads/)
 [![MIT Lisansı][license-shield]](https://github.com/TahsinCr/python-eventflow/blob/main/LICENSE)
 
@@ -118,7 +118,7 @@ Kurulu paketin sürüm numarasına `eventflow.__version__` üzerinden erişebili
 ~~~python
 from eventflow import __version__
 
-print(__version__)  # 1.2
+print(__version__)  # 1.2.1
 ~~~
 
 <a id="first-event"></a>
@@ -304,11 +304,12 @@ denedikten sonra toplanan hatalar için `ExceptionGroup` yükseltir; o yayın
 çağrısı `PublishResult` döndürmez. `bus.stats` toplam `published`,
 `delivered` ve `failed` sayaçlarını verir.
 
-Bu sayaçlar her yayın için değişmez bir eşitlik oluşturmaz. `published` callback'ler
-çalışmadan önce artar; `delivered` ve `failed` işlem sonunda güncellenir. Devam
-eden veya iptal edilen async yayınlarda değerler farklı kalabilir. `failed`,
-yalnızca başarısız handler'ları değil; handler, filtre ve action hatası
-kayıtlarını sayar.
+Bu sayaçlar her yayın için değişmez bir eşitlik oluşturmaz. `published`, history
+kaydı başarılı olduktan (history kapalıysa bu adım atlandıktan) sonra ve
+callback'ler çalışmadan önce artar; `delivered` ve `failed` işlem sonunda
+güncellenir. Devam eden veya iptal edilen async yayınlarda değerler farklı
+kalabilir. `failed`, yalnızca başarısız handler'ları değil; handler, filtre ve
+action hatası kayıtlarını sayar.
 
 Python 3.10 ve üzerindeki sürümlerde aynı import ile gruplandırılmış hataları
 yakalamak için `ExceptionGroup` sınıfını `eventflow.compatibility` modülünden
@@ -590,8 +591,8 @@ with EventEngine(history=50) as engine:
     print(result.delivered)
 ~~~
 
-Kanal adlarının başındaki ve sonundaki boşluklar silinir, harfler küçültülür.
-Bu nedenle `" Orders "` ve `"orders"` aynı kanala gider.
+Kanal adları string olmalı; başındaki ve sonundaki boşluklar silinir, harfler
+küçültülür. Bu nedenle `" Orders "` ve `"orders"` aynı kanala gider.
 `engine.channel(name)` kanalı döndürür veya oluşturur.
 `engine.add(name, bus)` özel ayarlı bus kaydeder. `remove(name)` bir kanalı
 kapatıp kaldırır; `stop()` tüm kanalları kapatır. Engine ayrıca `running` ve
@@ -1160,6 +1161,6 @@ Copyright © 2026 TahsinCr. EventFlow, MIT Lisansı ile lisanslanmıştır.
 [CHANGELOG](https://github.com/TahsinCr/python-eventflow/blob/main/CHANGELOG.md)
 dosyalarına bakın.
 
-[version-shield]: https://img.shields.io/badge/version-v1.2-b7a3e3.svg?style=for-the-badge
+[version-shield]: https://img.shields.io/badge/version-v1.2.1-b7a3e3.svg?style=for-the-badge
 [python-shield]: https://img.shields.io/badge/Python-3.10%2B-3776AB.svg?style=for-the-badge&logo=python&logoColor=white
 [license-shield]: https://img.shields.io/badge/license-MIT-blue.svg?style=for-the-badge

{flowevent-1.2 → flowevent-1.2.1}/README.md

@@ -1,4 +1,4 @@
-[![Version: v1.2][version-shield]](https://github.com/TahsinCr/python-eventflow/blob/main/CHANGELOG.md)
+[![Version: v1.2.1][version-shield]](https://github.com/TahsinCr/python-eventflow/blob/main/CHANGELOG.md)
 [![Python 3.10+][python-shield]](https://www.python.org/downloads/)
 [![MIT License][license-shield]](https://github.com/TahsinCr/python-eventflow/blob/main/LICENSE)
 
@@ -114,7 +114,7 @@ The installed package exposes its version through `eventflow.__version__`:
 ~~~python
 from eventflow import __version__
 
-print(__version__)  # 1.2
+print(__version__)  # 1.2.1
 ~~~
 
 <a id="first-event"></a>
@@ -295,10 +295,11 @@ directly. The bus attempts delivery to the selected handlers, then raises an
 a `PublishResult`. The `bus.stats` property provides cumulative
 `published`, `delivered`, and `failed` counts.
 
-These counters are not a per-publish invariant. `published` is incremented
-before callbacks run; `delivered` and `failed` are finalized afterward. An
-in-flight or cancelled async publish can leave them different. `failed` counts
-collected errors from handlers, filters, and actions, not only failed handlers.
+These counters are not a per-publish invariant. `published` advances after
+history recording succeeds (or is skipped when history is disabled) and before
+callbacks run; `delivered` and `failed` are finalized afterward. An in-flight
+or cancelled async publish can leave them different. `failed` counts collected
+errors from handlers, filters, and actions, not only failed handlers.
 
 To catch grouped failures with the same import on Python 3.10 and newer, import
 `ExceptionGroup` from `eventflow.compatibility`. On Python 3.11 and newer, that
@@ -575,10 +576,11 @@ with EventEngine(history=50) as engine:
     print(result.delivered)
 ~~~
 
-Channel names are stripped and lowercased, so `" Orders "` and `"orders"`
-refer to the same channel. `engine.channel(name)` returns a channel, creating
-it when necessary. Use `engine.add(name, bus)` to register a bus with custom
-settings. `remove(name)` closes one channel; `stop()` closes every channel.
+Channel names must be strings and are stripped and lowercased, so `" Orders "`
+and `"orders"` refer to the same channel. `engine.channel(name)` returns a
+channel, creating it when necessary. Use `engine.add(name, bus)` to register a
+bus with custom settings. `remove(name)` closes one channel; `stop()` closes
+every channel.
 An engine can own a bus instance under only one channel name at a time. A
 successful `add()` claims that bus for the engine; another engine cannot claim
 the same instance and receives `ValueError`. Removing or stopping the owner
@@ -1134,6 +1136,6 @@ Copyright © 2026 TahsinCr. EventFlow is licensed under the MIT License.
 See [LICENSE](https://github.com/TahsinCr/python-eventflow/blob/main/LICENSE) and
 [CHANGELOG](https://github.com/TahsinCr/python-eventflow/blob/main/CHANGELOG.md).
 
-[version-shield]: https://img.shields.io/badge/version-v1.2-b7a3e3.svg?style=for-the-badge
+[version-shield]: https://img.shields.io/badge/version-v1.2.1-b7a3e3.svg?style=for-the-badge
 [python-shield]: https://img.shields.io/badge/Python-3.10%2B-3776AB.svg?style=for-the-badge&logo=python&logoColor=white
 [license-shield]: https://img.shields.io/badge/license-MIT-blue.svg?style=for-the-badge

{flowevent-1.2 → flowevent-1.2.1}/eventflow/__init__.py

@@ -3,7 +3,7 @@
 from importlib import import_module
 from typing import TYPE_CHECKING, Any
 
-__version__ = "1.2"
+__version__ = "1.2.1"
 
 from .actions import (
     AsyncEventBusActions,

{flowevent-1.2 → flowevent-1.2.1}/eventflow/async_event_bus.py

@@ -14,9 +14,8 @@ from .base import (
     BaseEventBus,
     normalize_replay_capacity,
     validate_nonnegative_count,
-    validate_nonnegative_timeout,
     validate_positive_capacity,
-    validate_positive_timeout,
+    _validate_timeout,
 )
 from .contracts import DeliveryMode, ErrorPolicy, EventBusStats, PublishResult
 from .compatibility import ExceptionGroup
@@ -51,6 +50,10 @@ class _AsyncSubscriber(Generic[T]):
         self.remaining -= 1
         return True, self.remaining == 0
 
+    def restore_claim(self) -> None:
+        if self.remaining is not None:
+            self.remaining += 1
+
     def buffer_if_replaying(self, event: T) -> bool:
         if not self.replaying:
             return False
@@ -178,13 +181,11 @@ class AsyncEventBus(BaseEventBus[T]):
         async with self._lock:
             self._ensure_open()
             history = self._history
-            if replay and history is not None:
-                if event_filter is None and event_type is None and predicate is None:
-                    replay_snapshot = history.query(limit=replay)
-                else:
-                    replay_snapshot = history.query()
-            else:
-                replay_snapshot = ()
+            replay_snapshot = self._query_replay(
+                history,
+                replay,
+                any(option is not None for option in (event_filter, event_type, predicate)),
+            )
             subscription, subscriber = self._subscribe_locked(
                 callback,
                 normalized_filter,
@@ -278,33 +279,18 @@ class AsyncEventBus(BaseEventBus[T]):
         async with self._lock:
             self._ensure_open()
             subscribers = tuple(self._subscribers.values())
-            self._published += 1
             self._record(event)
+            self._published += 1
 
-        matched: list[_AsyncSubscriber[T]] = []
         errors: list[Exception] = []
         if self._actions.on_before is not None:
             try:
                 await self._actions.on_before(event)
             except Exception as exc:
                 errors.append(exc)
-        for subscriber in subscribers:
-            if not subscriber.subscription.active:
-                continue
-            try:
-                matches = subscriber.event_filter.matches(event)
-            except Exception as exc:
-                errors.append(exc)
-                continue
-            if matches:
-                try:
-                    if subscriber.buffer_if_replaying(event):
-                        continue
-                except BufferError as exc:
-                    await subscriber.subscription.cancel()
-                    errors.append(exc)
-                    continue
-                matched.append(subscriber)
+
+        matched, matching_errors = await self._match_subscribers(subscribers, event)
+        errors.extend(matching_errors)
 
         delivered = 0
         if self._delivery_mode is DeliveryMode.SEQUENTIAL:
@@ -353,6 +339,32 @@ class AsyncEventBus(BaseEventBus[T]):
             raise ExceptionGroup("Async event delivery failed", errors)
         return result
 
+    async def _match_subscribers(
+        self,
+        subscribers: tuple[_AsyncSubscriber[T], ...],
+        event: T,
+    ) -> tuple[list[_AsyncSubscriber[T]], list[Exception]]:
+        matched: list[_AsyncSubscriber[T]] = []
+        errors: list[Exception] = []
+        for subscriber in subscribers:
+            if not subscriber.subscription.active:
+                continue
+            try:
+                matches = subscriber.event_filter.matches(event)
+            except Exception as exc:
+                errors.append(exc)
+                continue
+            if matches:
+                try:
+                    if subscriber.buffer_if_replaying(event):
+                        continue
+                except BufferError as exc:
+                    await subscriber.subscription.cancel()
+                    errors.append(exc)
+                    continue
+                matched.append(subscriber)
+        return matched, errors
+
     @staticmethod
     def _collect_concurrent_outcomes(
         outcomes: list[tuple[bool, Exception | None] | BaseException],
@@ -452,7 +464,11 @@ class AsyncEventBus(BaseEventBus[T]):
         if not claimed:
             return False, None
         if final:
-            await subscriber.subscription._consume()
+            try:
+                await subscriber.subscription._consume()
+            except BaseException:
+                subscriber.restore_claim()
+                raise
         try:
             await subscriber.callback(event)
         except Exception as exc:
@@ -470,7 +486,7 @@ class AsyncEventBus(BaseEventBus[T]):
         """Publish the same event periodically until cancelled or completed."""
 
         self._bind_loop()
-        interval = validate_positive_timeout(interval, name="Event publish interval")
+        interval = _validate_timeout(interval, name="Event publish interval")
         if times is not None and (
             isinstance(times, bool) or not isinstance(times, int) or times <= 0
         ):
@@ -536,7 +552,11 @@ class AsyncEventBus(BaseEventBus[T]):
     ) -> T | None:
         loop = self._bind_loop()
         if timeout is not None:
-            timeout = validate_nonnegative_timeout(timeout, name="Event wait timeout")
+            timeout = _validate_timeout(
+                timeout,
+                name="Event wait timeout",
+                allow_zero=True,
+            )
         normalized_filter = coerce_event_filter(
             event_filter,
             event_type=event_type,

{flowevent-1.2 → flowevent-1.2.1}/eventflow/base.py

@@ -33,17 +33,20 @@ def normalize_replay_capacity(value: int) -> int:
     return validate_positive_capacity(value, name="Replay buffer limit")
 
 
-def validate_positive_timeout(value: float, *, name: str) -> float:
-    """Validate and normalize a finite timeout value."""
-
-    if (
-        isinstance(value, bool)
-        or not isinstance(value, (int, float))
-        or not math.isfinite(value)
-        or value <= 0
-    ):
-        raise ValueError(f"{name} must be positive and finite")
-    return float(value)
+def _validate_timeout(value: float, *, name: str, allow_zero: bool = False) -> float:
+    qualifier = "non-negative" if allow_zero else "positive"
+    message = f"{name} must be {qualifier} and finite"
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        raise ValueError(message)
+    try:
+        timeout = float(value)
+    except OverflowError as exc:
+        if allow_zero:
+            raise ValueError(message) from exc
+        raise ValueError(message) from None
+    if not math.isfinite(timeout) or timeout < 0 or (timeout == 0 and not allow_zero):
+        raise ValueError(message)
+    return timeout
 
 
 def validate_nonnegative_count(value: int, *, name: str) -> int:
@@ -54,20 +57,6 @@ def validate_nonnegative_count(value: int, *, name: str) -> int:
     return value
 
 
-def validate_nonnegative_timeout(value: float, *, name: str) -> float:
-    """Validate and normalize a finite timeout that may be zero."""
-
-    if isinstance(value, bool) or not isinstance(value, (int, float)):
-        raise ValueError(f"{name} must be non-negative and finite")
-    try:
-        normalized = float(value)
-    except OverflowError as exc:
-        raise ValueError(f"{name} must be non-negative and finite") from exc
-    if not math.isfinite(normalized) or normalized < 0:
-        raise ValueError(f"{name} must be non-negative and finite")
-    return normalized
-
-
 class BaseEventBus(Generic[T], ABC):
     def __init__(
         self,
@@ -125,6 +114,18 @@ class BaseEventBus(Generic[T], ABC):
         if self._history is not None:
             self._history.append(event)
 
+    @staticmethod
+    def _query_replay(
+        history: EventHistory[T] | None,
+        replay: int,
+        has_filter: bool,
+    ) -> tuple[T, ...]:
+        if not replay or history is None:
+            return ()
+        if has_filter:
+            return history.query()
+        return history.query(limit=replay)
+
     @staticmethod
     def _delivery_limit(*, once: bool, times: int | None) -> int | None:
         if times is not None:

{flowevent-1.2 → flowevent-1.2.1}/eventflow/contracts.py

@@ -35,6 +35,8 @@ class PublishResult:
 
 @dataclass(frozen=True, slots=True)
 class EventBusStats:
+    """Aggregate counts; published follows successful configured history recording."""
+
     published: int = 0
     delivered: int = 0
     failed: int = 0

{flowevent-1.2 → flowevent-1.2.1}/eventflow/engine.py

@@ -24,7 +24,9 @@ from .subscription import AsyncSubscription, Subscription
 
 
 def _channel_name(name: str) -> str:
-    normalized = str(name).strip().lower()
+    if not isinstance(name, str):
+        raise TypeError("Event channel name must be a string")
+    normalized = name.strip().lower()
     if not normalized:
         raise ValueError("Event channel name cannot be empty")
     return normalized
@@ -95,6 +97,7 @@ class EventEngine:
                     executor=self._executor,
                     actions=self._actions,
                 )
+                bus._claim_engine_ownership(self)
                 self._channels[name] = bus
             self._running = True
             return bus
@@ -313,6 +316,7 @@ class AsyncEventEngine:
                     max_concurrency=self._max_concurrency,
                     actions=self._actions,
                 )
+                bus._claim_engine_ownership(self)
                 self._channels[name] = bus
             self._running = True
             return bus

{flowevent-1.2 → flowevent-1.2.1}/eventflow/event_bus.py

@@ -17,9 +17,8 @@ from .base import (
     BaseEventBus,
     normalize_replay_capacity,
     validate_nonnegative_count,
-    validate_nonnegative_timeout,
     validate_positive_capacity,
-    validate_positive_timeout,
+    _validate_timeout,
 )
 from .contracts import ErrorPolicy, EventBusStats, PublishResult
 from .compatibility import ExceptionGroup
@@ -73,6 +72,11 @@ class _Subscriber(Generic[T]):
             self.remaining -= 1
             return True, self.remaining == 0
 
+    def restore_claim(self) -> None:
+        with self.lock:
+            if self.remaining is not None:
+                self.remaining += 1
+
     def buffer_if_replaying(self, event: T) -> bool:
         with self.lock:
             if not self.replaying:
@@ -116,10 +120,7 @@ class EventBus(BaseEventBus[T]):
             max_schedules,
             name="Maximum periodic schedules",
         )
-        shutdown_timeout = validate_positive_timeout(
-            shutdown_timeout,
-            name="Shutdown timeout",
-        )
+        shutdown_timeout = _validate_timeout(shutdown_timeout, name="Shutdown timeout")
         direct_actions = (on_before, on_after, on_error, on_timeout)
         if actions is not None and any(action is not None for action in direct_actions):
             raise ValueError("Use actions or direct on_* callbacks, not both")
@@ -193,13 +194,11 @@ class EventBus(BaseEventBus[T]):
             history = self._history
             subscription_id = self._next_id
             self._next_id += 1
-            if replay and history is not None:
-                if event_filter is None and event_type is None and predicate is None:
-                    replay_snapshot = history.query(limit=replay)
-                else:
-                    replay_snapshot = history.query()
-            else:
-                replay_snapshot = ()
+            replay_snapshot = self._query_replay(
+                history,
+                replay,
+                any(option is not None for option in (event_filter, event_type, predicate)),
+            )
 
             def cancel() -> None:
                 with self._lock:
@@ -277,33 +276,18 @@ class EventBus(BaseEventBus[T]):
         with self._lock:
             self._ensure_open()
             subscribers = tuple(self._subscribers.values())
-            self._published += 1
             self._record(event)
+            self._published += 1
 
-        matched: list[_Subscriber[T]] = []
         errors: list[Exception] = []
         if self._actions.on_before is not None:
             try:
                 synchronous_result(self._actions.on_before(event))
             except Exception as exc:
                 errors.append(exc)
-        for subscriber in subscribers:
-            if not subscriber.subscription.active:
-                continue
-            try:
-                matches = subscriber.event_filter.matches(event)
-            except Exception as exc:
-                errors.append(exc)
-                continue
-            if matches:
-                try:
-                    if subscriber.buffer_if_replaying(event):
-                        continue
-                except BufferError as exc:
-                    subscriber.subscription.cancel()
-                    errors.append(exc)
-                    continue
-                matched.append(subscriber)
+
+        matched, matching_errors = self._match_subscribers(subscribers, event)
+        errors.extend(matching_errors)
 
         delivered = 0
         active_executors = getattr(_executor_context, "active", frozenset())
@@ -320,17 +304,20 @@ class EventBus(BaseEventBus[T]):
                 claimed, final = subscriber.claim()
                 if not claimed:
                     continue
-                if final:
-                    subscriber.subscription._consume()
                 try:
                     future = self._executor.submit(
                         self._invoke_executor_callback,
-                        subscriber.callback,
+                        subscriber,
                         event,
                         active_executors,
+                        final,
                     )
                 except Exception as exc:
+                    subscriber.restore_claim()
                     errors.append(exc)
+                except BaseException:
+                    subscriber.restore_claim()
+                    raise
                 else:
                     futures.append((subscriber, future))
             for _subscriber, future in futures:
@@ -368,12 +355,45 @@ class EventBus(BaseEventBus[T]):
             raise ExceptionGroup("Event delivery failed", errors)
         return result
 
+    def _match_subscribers(
+        self,
+        subscribers: tuple[_Subscriber[T], ...],
+        event: T,
+    ) -> tuple[list[_Subscriber[T]], list[Exception]]:
+        matched: list[_Subscriber[T]] = []
+        errors: list[Exception] = []
+        for subscriber in subscribers:
+            if not subscriber.subscription.active:
+                continue
+            try:
+                matches = subscriber.event_filter.matches(event)
+            except Exception as exc:
+                errors.append(exc)
+                continue
+            if matches:
+                try:
+                    if subscriber.buffer_if_replaying(event):
+                        continue
+                except BufferError as exc:
+                    subscriber.subscription.cancel()
+                    errors.append(exc)
+                    continue
+                matched.append(subscriber)
+        return matched, errors
+
     def _invoke_executor_callback(
         self,
-        callback: Callable[[T], None],
+        subscriber: _Subscriber[T],
         event: T,
         inherited_executors: frozenset[int],
+        final: bool,
     ) -> None:
+        if final:
+            try:
+                subscriber.subscription._consume()
+            except BaseException:
+                subscriber.restore_claim()
+                raise
         previous = getattr(_executor_context, "active", None)
         active = set(inherited_executors)
         if previous is not None:
@@ -382,7 +402,7 @@ class EventBus(BaseEventBus[T]):
             active.add(id(self._executor))
         _executor_context.active = frozenset(active)
         try:
-            _invoke_sync_callback(callback, event)
+            _invoke_sync_callback(subscriber.callback, event)
         finally:
             if previous is None:
                 del _executor_context.active
@@ -414,7 +434,11 @@ class EventBus(BaseEventBus[T]):
         if not claimed:
             return False, None
         if final:
-            subscriber.subscription._consume()
+            try:
+                subscriber.subscription._consume()
+            except BaseException:
+                subscriber.restore_claim()
+                raise
         try:
             _invoke_sync_callback(subscriber.callback, event)
         except Exception as exc:
@@ -431,7 +455,7 @@ class EventBus(BaseEventBus[T]):
     ) -> Subscription:
         """Publish the same event periodically until cancelled or completed."""
 
-        interval = validate_positive_timeout(interval, name="Event publish interval")
+        interval = _validate_timeout(interval, name="Event publish interval")
         if times is not None and (
             isinstance(times, bool) or not isinstance(times, int) or times <= 0
         ):
@@ -499,7 +523,11 @@ class EventBus(BaseEventBus[T]):
         timeout: float | None = None,
     ) -> T | None:
         if timeout is not None:
-            timeout = validate_nonnegative_timeout(timeout, name="Event wait timeout")
+            timeout = _validate_timeout(
+                timeout,
+                name="Event wait timeout",
+                allow_zero=True,
+            )
         normalized_filter = coerce_event_filter(
             event_filter,
             event_type=event_type,