diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index 9b10f53..e0537f2 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -19,12 +19,12 @@ jobs: - uses: actions/checkout@v4 with: repository: Flowduino/ESPressio-Timing - ref: 2.2.2 + ref: 2.2.3 path: ESPressio_Timing - uses: actions/checkout@v4 with: repository: Flowduino/ESPressio-Units - ref: 0.2.1 + ref: 0.2.2 path: ESPressio-Units - name: Configure run: cmake -S ESPressio-Event/tests -B build @@ -47,18 +47,23 @@ jobs: - uses: actions/checkout@v4 with: repository: Flowduino/ESPressio-Units - ref: 0.2.1 + ref: 0.2.2 path: project/dependencies/ESPressio-Units - uses: actions/checkout@v4 with: repository: Flowduino/ESPressio-Timing - ref: 2.2.2 + ref: 2.2.3 path: project/dependencies/ESPressio-Timing - uses: actions/checkout@v4 with: repository: Flowduino/ESPressio-Threads - ref: 3.1.2 + ref: 3.1.3 path: project/dependencies/ESPressio-Threads + - uses: actions/checkout@v4 + with: + repository: Flowduino/ESPressio-Serializable + ref: 0.10.1 + path: project/dependencies/ESPressio-Serializable - uses: actions/checkout@v4 with: repository: Flowduino/ESPressio-Security @@ -77,7 +82,7 @@ jobs: - uses: actions/checkout@v4 with: repository: Flowduino/ESPressio-ESP-Now - ref: 0.5.0 + ref: 0.5.1 path: project/dependencies/ESPressio-ESP-Now - uses: actions/setup-python@v5 with: @@ -109,11 +114,13 @@ jobs: ../dependencies/ESPressio-Units ../dependencies/ESPressio-Timing ../dependencies/ESPressio-Threads + ../dependencies/ESPressio-Serializable ../ESPressio-Event EOF cat > project/compile/src/main.cpp <<'EOF' #include #include + #include #include #include #include @@ -123,5 +130,5 @@ jobs: void setup() {} void loop() {} EOF - - name: Compile ESP32 optional bridges + - name: Compile ESP32 Event Transport and optional bridges run: pio run -d project/compile diff --git a/CHANGELOG.md b/CHANGELOG.md index ca49fda..bb2b15a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,19 @@ # Changelog +## 5.8.1 — 2026-08-20 + +### Changed +- Raised the required ESPressio Threads baseline from 3.1.2 to 3.1.3. +- Raised the required ESPressio Timing baseline from 2.2.2 to 2.2.3. +- Raised the optional ESPressio Serializable baseline from 0.10.0 to 0.10.1 for Serializable Events, runtime construction and Event Transport integrations. +- Preserved the required ESPressio Observable baseline at `>=3.0.1 <4.0.0`. +- Updated package and ESP-IDF component metadata for Event 5.8.1. +- Documented the reciprocal optional Event/ESP-Now dependency as an architectural exception: the preferred long-term resolution is to relocate `ESPNowTransportEventBridge` downstream into ESP-Now's Event integration (or a dedicated integration package), keeping Event transport-neutral. + +### Compatibility +- No Event, EventThread, listener, Observer, Event Transport, routing, bridge or wire-format API changes are introduced by this dependency-maintenance release. +- Security, Command, Sockets, ESP-Now and Serializable remain opt-in where applicable. + ## 5.8.0 — 2026-08-20 ### Added diff --git a/ESPRESSIO_DEPENDENCY_CHART.md b/ESPRESSIO_DEPENDENCY_CHART.md index 76f7e56..1696337 100644 --- a/ESPRESSIO_DEPENDENCY_CHART.md +++ b/ESPRESSIO_DEPENDENCY_CHART.md @@ -1,335 +1,137 @@ -# ESPressio Dependency Chart +# ESPressio Dependency Chart — Event 5.8.1 ![ESPressio Library Dependency Chart](ESPRESSIO_DEPENDENCY_CHART.png) -## Purpose - -This document describes the dependency relationships between the current ESPressio libraries and the validated release baselines used by the 2026-08-20 dependency-refresh generation. - -The chart is hierarchical: libraries with no **required** ESPressio dependencies are positioned at the top, while libraries that build on progressively more of the ESPressio ecosystem appear lower in the hierarchy. - -### Relationship notation - -- **Solid arrow** — a required ESPressio library dependency. -- **Dashed arrow** — an opt-in relationship. The dependency is required only when the consuming application selects the associated feature, integration, type, or header. -- Arrows point from the **dependent library** to the **library it consumes**. - -Optional integrations are intentionally kept out of the normal/core include path wherever possible so that a project does not acquire unrelated ESPressio dependencies simply by consuming a library. - ---- - -## ESPressio Units 0.2.1 - -**Required ESPressio dependencies: none.** - -ESPressio Units is a foundational library providing strongly typed physical quantities and unit representations. - -### Units → Serializable — opt-in - -Ordinary Unit headers do not require ESPressio Serializable. Serializable counterparts are supplied through separate `*_Serializable.hpp` headers and the `ESPressio_SerializableUnits.hpp` batch header. +## Required dependencies ```text -ordinary Unit type - -> ESPressio Units only - -Serializable Unit type - -> ESPressio Units - -> ESPressio Serializable +ESPressio Event 5.8.1 + -> ESPressio Threads >= 3.1.3 < 4.0.0 + -> ESPressio Timing >= 2.2.3 < 3.0.0 + -> ESPressio Observable >= 3.0.1 < 4.0.0 ``` ---- - -## ESPressio Observable 3.0.1 - -**Required ESPressio dependencies: none.** - -Observable is the foundational synchronous observation/notification mechanism. Version 3.0.1 adds the zero-Observer fast path used by higher-frequency consumers without changing the public Observer contract. - -It is directly consumed by: - -- ESPressio Timing; -- ESPressio Threads; -- ESPressio Event. - ---- - -## ESPressio Serializable 0.10.0 - -**Required ESPressio dependencies: none.** - -Serializable is the foundational serialization framework. Version 0.10.0 adds direct ESPB v2 binary serialization/deserialization while preserving the existing archive/tree APIs and wire representation. - -Current opt-in relationships include: - -- ESPressio Units → Serializable for Serializable Unit variants; -- ESPressio Event → Serializable for Serializable Events, runtime Serializable Event construction, and Event Transport; -- ESPressio Serial → Serializable for EventConsole/EventMonitor integrations that consume Serializable payload facilities. - ---- - -## ESPressio Timing 2.2.2 - -**Required ESPressio dependencies:** - -- ESPressio Units `>=0.2.1 <1.0.0`; -- ESPressio Observable `>=3.0.1 <4.0.0`. - -### Timing → Units — required - -Timing uses ESPressio Units for its strongly typed time representations. - -### Timing → Observable — required - -Timing exposes logical clock and synchronization lifecycle notifications through ESPressio Observable. The 2.2.2 patch explicitly raises the Observable floor to 3.0.1. - -Timing itself does not directly require Serializable. Serializable Unit time representations remain selected by the consuming application through the Units integration. - ---- - -## ESPressio Threads 3.1.2 - -**Required ESPressio dependencies:** - -- ESPressio Timing `>=2.2.2 <3.0.0`; -- ESPressio Observable `>=3.0.1 <4.0.0`. - -### Threads → Timing — required - -Threads uses Timing for PrecisionThread time-related execution and scheduling infrastructure. - -### Threads → Observable — required - -Threads uses Observable for synchronous Thread and singleton-infrastructure lifecycle notifications. - -The 3.1.2 patch raises both dependency floors to the refreshed upstream patch generation. - ---- - -## ESPressio Event 5.7.1 - -**Required ESPressio dependencies:** - -- ESPressio Threads `>=3.1.2 <4.0.0`; -- ESPressio Timing `>=2.2.2 <3.0.0`; -- ESPressio Observable `>=3.0.1 <4.0.0`. - -### Event → Threads — required - -Event uses ESPressio Threads for asynchronous Event processing and execution infrastructure. - -### Event → Timing — required - -Event uses Timing for Event lifecycle timing and the optional System Clock Event Bridge. - -### Event → Observable — required - -Observable is used directly by Event and by the Observer/Event bridge architecture. - -### Event → Serializable — opt-in - -Ordinary local Event usage does not require Serializable. - -Serializable Event support, runtime Serializable Event construction and Event Transport use ESPressio Serializable 0.10.0 or newer within the current 0.x integration line. Event 5.7 uses the 0.10.0 direct ESPB v2 binary path for normal same-schema transport while retaining the archive path for migration/compatibility cases. +The transitive required chain is: ```text -ordinary local Event - -> no Serializable requirement - -Serializable / remotely transported Event - -> ESPressio Serializable +Event 5.8.1 + -> Threads 3.1.3 + -> Timing 2.2.3 + -> Units 0.2.2 + -> Observable 3.0.1 + -> Timing 2.2.3 + -> Units 0.2.2 + -> Observable 3.0.1 + -> Observable 3.0.1 ``` ---- - -## ESPressio ESP-Now 0.2.3 - -**Required ESPressio dependencies:** - -- ESPressio Timing `>=2.2.2 <3.0.0`. - -### ESP-Now → Timing — required - -ESP-Now provides ESP-NOW-based distributed System Clock synchronization and submits transport-specific observations to ESPressio Timing. +## Optional Serializable integration -### ESP-Now → Event — opt-in +Ordinary local Event use does not require Serializable. Serializable Events, +runtime Serializable Event construction, and Event Transport require: -`ESPNowEventTransport` implements the ESPressio Event transport abstraction. The validated 0.2.3 integration baseline is ESPressio Event 5.7.1 within the 5.x line. - -Applications using ESP-Now only for communication and/or System Clock synchronization do not acquire Event or Serializable dependencies. - ---- - -## ESPressio Sockets 0.2.3 - -**Required ESPressio dependencies: none.** - -The core Sockets library deliberately has no mandatory ESPressio dependency. - -### Sockets → Event — opt-in - -UDP, TCP, TLS, WebSocket and MQTT Event Transport adapters implement the ESPressio Event transport abstraction. The validated 0.2.3 baseline is Event 5.7.1 within the 5.x line. - -### Sockets → Timing — opt-in - -Socket/SNTP System Clock synchronization implementations consume ESPressio Timing. The validated 0.2.3 baseline is Timing 2.2.2 within the 2.x line. - ---- - -## ESPressio Serial 0.3.3 +```text +ESPressio Serializable >= 0.10.1 < 1.0.0 +``` -**Required ESPressio dependencies: none.** +Serializable 0.10.1 preserves the ESPB v2 wire representation while adding +bounded/allocation-free inspection facilities. Event's transport wire format is +unchanged by this dependency refresh. -The core Serial, Console, logging and diagnostic foundations deliberately remain usable without mandatory ESPressio dependencies. +## Optional Observer-to-Event bridges -Optional integrations are independently selected: +Event 5.8.x provides opt-in bridges for Observable contracts from: -- System Clock Monitor → Timing `>=2.2.2 <3.0.0`; -- Thread Monitor → Threads `>=3.1.2 <4.0.0`; -- Event Monitor/EventConsole → Event `>=5.7.1 <6.0.0`; -- Serializable payload/JSON facilities used by Event tooling → Serializable `>=0.10.0` within the compatible 0.x integration line. +```text +Security >= 0.2.0 < 1.0.0 +Command >= 0.3.0 < 1.0.0 +Sockets >= 0.5.0 < 1.0.0 +ESP-Now >= 0.5.0 < 1.0.0 +``` ---- +These integrations must remain optional. Security, Command, Sockets and ESP-Now +do not become mandatory Event dependencies merely because bridge headers exist. -## Required-dependency hierarchy +## Current coordinated ecosystem ```text FOUNDATIONAL -├── ESPressio Units 0.2.1 -├── ESPressio Observable 3.0.1 -├── ESPressio Serializable 0.10.0 -├── ESPressio Sockets 0.2.3 -└── ESPressio Serial 0.3.3 +├── Observable 3.0.1 +├── Serializable 0.10.1 +├── Units 0.2.2 +├── Security 0.2.0 +└── Command 0.3.0 RUNTIME -└── ESPressio Timing 2.2.2 - ├── Units >=0.2.1 <1.0.0 - └── Observable >=3.0.1 <4.0.0 - -EXECUTION / COMMUNICATION -├── ESPressio Threads 3.1.2 -│ ├── Timing >=2.2.2 <3.0.0 -│ └── Observable >=3.0.1 <4.0.0 -│ -└── ESPressio ESP-Now 0.2.3 - └── Timing >=2.2.2 <3.0.0 - -EVENT INFRASTRUCTURE -└── ESPressio Event 5.7.1 - ├── Threads >=3.1.2 <4.0.0 - ├── Timing >=2.2.2 <3.0.0 - └── Observable >=3.0.1 <4.0.0 -``` - -## Opt-in cross-cutting relationships +└── Timing 2.2.3 -```text -Units - - - -> Serializable - Serializable Unit variants +EXECUTION +└── Threads 3.1.3 -Event - - - -> Serializable - Serializable Events / runtime construction / Event Transport - -ESP-Now - - - -> Event - ESP-NOW Event Transport - -Sockets - - - -> Event - socket Event Transports - -Sockets - - - -> Timing - socket/SNTP clock synchronization - -Serial - - - -> Timing - System Clock Monitor - - - -> Threads - Thread Monitor - - - -> Event - Event Monitor / EventConsole - - - -> Serializable - Event payload representation / JSON composition -``` +TRANSPORT / INTEGRATION +├── Sockets 0.5.0 +└── ESP-Now 0.5.1 ---- +EVENT +└── Event 5.8.1 -## Dependency-refresh release order +DIAGNOSTICS / OPERATOR +└── Serial 0.5.1 +``` -When only dependency baselines change, downstream patch releases must consume the already-bumped upstream patch release rather than the pre-refresh version. +## Circular-dependency audit -For the 2026-08-20 cascade the release order is: +There is one currently known reciprocal optional relationship: ```text -Observable 3.0.1 already released -Serializable 0.10.0 already released - | - v -Timing 2.2.2 - | - v -Threads 3.1.2 - | - v -Event 5.7.1 - | - +--> ESP-Now 0.2.3 - +--> Sockets 0.2.3 - +--> Serial 0.3.3 -``` - -This ensures every downstream release advertises the newest upstream patch generation that existed when that downstream release was validated. - ---- +ESP-Now - - -> Event + ESPNowEventTransport -## Architectural principle +Event - - -> ESP-Now + ESPNowTransportEventBridge +``` -The dependency graph follows a general ESPressio design rule: +Although neither edge is mandatory, this violates the desired dependency rule: +integration dependencies should cascade downstream and must not point back into +a consumer that already depends on the abstraction. -> A foundational library should expose the synchronous or transport-neutral abstraction it owns; higher-level integration libraries should opt into that abstraction rather than forcing the foundational library to depend upward. +### Preferred resolution -Examples include: +Event should remain the upstream, transport-neutral abstraction. The +ESP-Now-specific Observer-to-Event bridge should move downstream: ```text -Timing - exposes Observer notifications - Event - optionally bridges those notifications into Events + ^ + | + | optional + | +ESP-Now Event integration + ├── ESPNowEventTransport + └── ESPNowTransportEventBridge ``` -```text -Timing - exposes transport-neutral clock synchronization - -ESP-Now / Sockets - provide concrete synchronization transports -``` +A dedicated integration package would also be valid if keeping both libraries +completely unaware of one another is preferable. -```text -Event - exposes transport-neutral Event Transport +Until that relocation occurs, Event 5.8.1 does not add or strengthen any new +Event -> ESP-Now package-level dependency. The existing bridge remains available +for compatibility only. -ESP-Now / Sockets - provide concrete Event transports -``` +## Dependency-direction rule -```text -Units - provides ordinary Unit types +> A library should expose the abstraction it owns. Integration code that adds a +> new dependency belongs downstream of that abstraction. -Units + Serializable - optionally provides Serializable Unit variants -``` +Examples: ```text -Serial - provides dependency-free core console/logging facilities +Timing owns clock discipline + -> ESP-Now / Sockets provide concrete synchronization transports -Serial + selected ESPressio integrations - adds monitors and runtime Event tooling only when requested -``` +Event owns Event semantics and transport abstraction + -> ESP-Now / Sockets provide concrete Event transports -This keeps the individual libraries independently useful while allowing progressively richer ESPressio compositions without imposing unnecessary dependencies on applications that do not use those integrations. +Observable libraries own synchronous lifecycle contracts + -> Event can bridge them only when doing so does not create a reverse edge +``` diff --git a/README.md b/README.md index 1ae5d16..73da903 100644 --- a/README.md +++ b/README.md @@ -10,49 +10,43 @@ queues, listener/observer registration, priority dispatch, high-resolution Event timing, optional Observer-to-Event bridges, and optional transport-neutral Serializable Event routing. -## Latest Stable Version +## Current Version — 5.8.1 -The latest stable version is **5.7.1**. +ESPressio Event **5.8.1** is a dependency-maintenance patch over 5.8.0. It retains the expanded Observable-to-Event bridge surface while refreshing the validated upstream dependency baselines. -For release-by-release history, see [CHANGELOG.md](CHANGELOG.md). - -## Current Development Version — 5.8.0 - -The `feature/observable-callback-coverage` branch targets **5.8.0** and extends Event's existing opt-in Observer-to-Event bridge architecture to the new lifecycle observer contracts introduced across the ESPressio platform. - -The new bridge families are: +Current dependency model: ```text -ESPressio Security >= 0.2.0 < 1.0.0 - TransportSecurityEventBridge +Required + ESPressio Threads >= 3.1.3 < 4.0.0 + ESPressio Timing >= 2.2.3 < 3.0.0 + ESPressio Observable >= 3.0.1 < 4.0.0 -ESPressio Command >= 0.3.0 < 1.0.0 - CommandRegistryEventBridge +Optional Serializable Event / Event Transport + ESPressio Serializable >= 0.10.1 < 1.0.0 -ESPressio Sockets >= 0.5.0 < 1.0.0 - SocketWorkerEventBridge - SocketSecuritySessionEventBridge - -ESPressio ESP-Now >= 0.5.0 < 1.0.0 - ESPNowTransportEventBridge +Optional observer bridge sources + ESPressio Security >= 0.2.0 < 1.0.0 + ESPressio Command >= 0.3.0 < 1.0.0 + ESPressio Sockets >= 0.5.0 < 1.0.0 + ESPressio ESP-Now >= 0.5.0 < 1.0.0 ``` -These are **optional integrations**. The mandatory Event dependency graph remains Threads 3.x, Observable 3.x, and Timing 2.x; Security, Command, Sockets, and ESP-Now are required only when their corresponding bridge headers are selected. +Security and Command remain valid one-way bridge dependencies: those libraries expose synchronous Observable contracts and do not depend back upon Event. -The dependency direction remains intentionally one-way: +The dependency audit for 5.8.1 identifies two reciprocal optional relationships that should not be strengthened: ```text -Security / Command / Sockets / ESP-Now - expose synchronous Observable contracts +Sockets -> Event concrete socket Event transports +Event -> Sockets SocketWorkerEventBridge / SocketSecuritySessionEventBridge -Event 5.8 - optionally consumes those contracts - and emits asynchronous Events +ESP-Now -> Event ESPNowEventTransport +Event -> ESP-Now ESPNowTransportEventBridge ``` -The originating libraries therefore do not acquire an ESPressio Event dependency. Socket worker Events are also kept separate from Socket Security Session Events so observing ordinary socket worker lifecycle does not implicitly require ESPressio Security. +For 5.8.x compatibility the existing bridge headers remain available. The preferred future architecture moves the Sockets-specific and ESP-Now-specific bridges downstream into their respective optional Event integrations, or into dedicated integration packages, leaving ESPressio Event transport-neutral. -The complete stable 5.7.1 documentation below remains intact. +For release-by-release history, see [CHANGELOG.md](CHANGELOG.md). ## Compatibility @@ -201,7 +195,6 @@ See: examples/RuntimeSerializableEvents/RuntimeSerializableEvents.ino ``` - ## License ESPressio and its component libraries are licensed under the **Apache @@ -242,28 +235,50 @@ library: ``` ini lib_deps = - flowduino/ESPressio-Event@^5.7.1 + flowduino/ESPressio-Event@^5.8.1 ``` The mandatory dependency graph is: ``` text -ESPressio Event 5.7.1 +ESPressio Event 5.8.1 | - +-- ESPressio Threads >= 3.1.2 < 4.0.0 + +-- ESPressio Threads >= 3.1.3 < 4.0.0 | +-- ESPressio Observable >= 3.0.1 < 4.0.0 | - +-- ESPressio Timing >= 2.2.2 < 3.0.0 + +-- ESPressio Timing >= 2.2.3 < 3.0.0 ``` -The 5.8.0 development branch retains the same mandatory graph. Security, Command, Sockets, and ESP-Now remain optional bridge dependencies only. - -ESPressio Units is available through the Timing dependency stack. +ESPressio Units 0.2.2 is carried by the Timing dependency stack. **ESPressio Serializable is not a mandatory Event dependency.** It is required only when an application explicitly opts into Serializable -Events or Event Transport. +Events, runtime Serializable Event construction, or Event Transport. The +validated current baseline is: + +```text +ESPressio Serializable >= 0.10.1 < 1.0.0 +``` + +Security, Command, Sockets and ESP-Now remain optional bridge dependencies only. Event 5.8.1 introduces no new mandatory dependency on any of them. + +### Dependency direction and transport-specific bridges + +The general ESPressio rule is that dependency edges cascade downstream. Event owns transport-neutral Event semantics and `IEventTransport`; concrete transport libraries may consume Event to implement transports. A transport-specific Observer-to-Event bridge should therefore live downstream with that transport integration rather than make Event depend back upon the concrete transport. + +The current 5.8.x bridge API is retained for compatibility, but the preferred future locations are: + +```text +Sockets Event integration + SocketWorkerEventBridge + SocketSecuritySessionEventBridge + +ESP-Now Event integration + ESPNowTransportEventBridge +``` + +Generic bridges for genuinely upstream libraries such as Timing, Threads, Command and Security remain appropriate within Event because those libraries do not depend back on Event. ------------------------------------------------------------------------ @@ -377,7 +392,7 @@ directly: the originating libraries expose synchronous Observer notifications, while ESPressio Event can optionally convert those notifications into asynchronous Events. -Event 5.8 extends exactly the same model to Security, Command, Sockets, and ESP-Now; it does not move ownership of those lifecycle semantics into Event. +Event 5.8 extends the same model to Security, Command, Sockets, and ESP-Now. The 5.8.1 dependency audit additionally distinguishes valid one-way bridges from transport-specific bridges that should ultimately move downstream to avoid reciprocal optional dependency edges. ------------------------------------------------------------------------ @@ -1076,8 +1091,8 @@ Serializable explicitly: ``` ini lib_deps = - flowduino/ESPressio-Event@^5.7.1 - flowduino/ESPressio-Serializable@^0.10.0 + flowduino/ESPressio-Event@^5.8.1 + flowduino/ESPressio-Serializable@^0.10.1 ``` ## `SerializableEvent` @@ -1169,10 +1184,10 @@ does not require ESPressio Serializable. ESPressio Event can optionally convert synchronous Observer notifications from other ESPressio libraries into asynchronous Events. -The important dependency direction is: +For genuinely upstream libraries, the dependency direction is: ``` text -Timing / Threads / Security / Command / Sockets / ESP-Now +Timing / Threads / Security / Command expose synchronous Observer APIs Event @@ -1182,6 +1197,8 @@ Event The originating libraries therefore do not need to depend upward on Event. +Sockets and ESP-Now are special cases in 5.8.x because each already optionally consumes Event to implement concrete Event transports. Their existing bridges remain available for compatibility, but should move downstream in a future integration relocation. + ## System Clock Event Bridge Timing 2.2 System Clock Observer notifications can be bridged using: @@ -1265,7 +1282,7 @@ Bridge batch headers are: The ordinary bridges do not require ESPressio Serializable. -## Security Event Bridge (5.8.0 development) +## Security Event Bridge `TransportSecurityEventBridge` observes one selected `Security::TransportSecurity` instance and emits asynchronous Events for configuration changes, session establishment/reset, replay-protection resets, and security failures. @@ -1278,13 +1295,13 @@ bridge.Initialize(security); The bridge is instance-oriented because `TransportSecurity` is application-owned state rather than a process singleton. -## Command Registry Event Bridge (5.8.0 development) +## Command Registry Event Bridge `CommandRegistryEventBridge` converts command registration/unregistration lifecycle notifications from the process-wide `CommandRegistry` into Events. It deliberately does not convert normal Command execution callbacks or middleware into a competing Event execution mechanism. -## Socket Event Bridges (5.8.0 development) +## Socket Event Bridges -Socket lifecycle is split according to dependency ownership: +For 5.8.x compatibility, socket lifecycle bridges remain split according to dependency ownership: ``` text SocketWorkerEventBridge @@ -1296,13 +1313,15 @@ SocketSecuritySessionEventBridge -> requires Sockets + Security ``` -This separation prevents ordinary Socket worker observation from acquiring an unnecessary Security dependency. +Because Sockets also implements concrete Event transports, these bridge implementations should ultimately move downstream into Sockets' optional Event integration to eliminate the reciprocal optional dependency edge. -## ESP-Now Transport Event Bridge (5.8.0 development) +## ESP-Now Transport Event Bridge `ESPNowTransportEventBridge` converts the ESP-NOW transport's initialization, shutdown, peer lifecycle, and send-result observer notifications into asynchronous Events while leaving protocol receive delivery with the existing ESP-NOW handler mechanism. -All new 5.8 bridges remain dormant until explicitly initialized. +Because ESP-Now also implements `ESPNowEventTransport`, this bridge should ultimately move downstream into ESP-Now's optional Event integration to eliminate the reciprocal optional dependency edge. + +All 5.8 bridge families remain dormant until explicitly initialized. ------------------------------------------------------------------------ @@ -1459,9 +1478,7 @@ payload length ``` The payload uses the ESPressio Serializable **ESPB v2 binary wire format**. -Event 5.7 uses Serializable's direct binary path for the normal same-schema -transport case, while retaining the existing `BinaryArchive` path as a -compatibility and schema-migration fallback. +Event 5.8.1 validates against Serializable 0.10.1 while preserving the existing wire representation and direct binary transport path, with the archive path retained for compatibility/schema-migration cases. ## EventTransportManager observation @@ -1471,7 +1488,6 @@ inbound/outbound diagnostics. ------------------------------------------------------------------------ - ## Event Transport Transaction Observation Version 5.5 adds a unified, transport-neutral observation surface for complete Event Transport transaction activity. @@ -1699,4 +1715,4 @@ TransportMessageID HopCount ``` -This is a compatibility fix only; Event dispatch behaviour and public Event Transport semantics are unchanged. +This is a compatibility fix only; Event dispatch behaviour and public Event Transport semantics are unchanged. \ No newline at end of file diff --git a/component.mk b/component.mk index 8941fa7..5674c90 100644 --- a/component.mk +++ b/component.mk @@ -5,7 +5,7 @@ COMPONENT_REQUIRES := ESPressio_Threads ESPressio_Observable ESPressio_Timing CXXFLAGS += -DESPRESSIO_EVENT CXXFLAGS += -DESPRESSIO_EVENT_VERSION_MAJOR=5 CXXFLAGS += -DESPRESSIO_EVENT_VERSION_MINOR=8 -CXXFLAGS += -DESPRESSIO_EVENT_VERSION_PATCH=0 -CXXFLAGS += -DESPRESSIO_EVENT_VERSION_STRING=\"5.8.0\" +CXXFLAGS += -DESPRESSIO_EVENT_VERSION_PATCH=1 +CXXFLAGS += -DESPRESSIO_EVENT_VERSION_STRING=\"5.8.1\" CXXFLAGS += -std=gnu++17 diff --git a/library.json b/library.json index 3df4622..8ced8db 100644 --- a/library.json +++ b/library.json @@ -21,14 +21,14 @@ "type": "git", "url": "https://github.com/Flowduino/ESPressio-Event.git" }, - "version": "5.8.0", + "version": "5.8.1", "license": "Apache-2.0", "frameworks": "arduino", "platforms": "espressif32", "dependencies": [ { "name": "ESPressio-Threads", - "version": ">=3.1.2 <4.0.0", + "version": ">=3.1.3 <4.0.0", "url": "https://github.com/Flowduino/ESPressio-Threads.git", "platforms": "espressif32" }, @@ -41,7 +41,7 @@ { "owner": "flowduino", "name": "ESPressio-Timing", - "version": ">=2.2.2 <3.0.0" + "version": ">=2.2.3 <3.0.0" } ] } diff --git a/library.properties b/library.properties index 6263617..28088b0 100644 --- a/library.properties +++ b/library.properties @@ -1,5 +1,5 @@ name=Flowduino ESPressio-Event -version=5.8.0 +version=5.8.1 author=Simon J. Stuart maintainer=Flowduino.com sentence=Event-driven development library for ESP32 microcontrollers @@ -8,4 +8,4 @@ category=Communication url=https://github.com/Flowduino/ESPressio-Event architectures=esp32 includes=ESPressio_Event.hpp,ESPressio_EventThread.hpp,ESPressio_PrecisionEventThread.hpp -depends=ESPressio-Threads (>=3.1.2 && <4.0.0),Flowduino ESPressio-Observable (>=3.0.1 && <4.0.0),Flowduino ESPressio-Timing (>=2.2.2 && <3.0.0) +depends=ESPressio-Threads (>=3.1.3 && <4.0.0),Flowduino ESPressio-Observable (>=3.0.1 && <4.0.0),Flowduino ESPressio-Timing (>=2.2.3 && <3.0.0)