diff --git a/.rustfmt.toml b/.rustfmt.toml
new file mode 100644
index 00000000..56abb065
--- /dev/null
+++ b/.rustfmt.toml
@@ -0,0 +1 @@
+max_width = 80 # This matches the maximum line length used in Dart
diff --git a/README.md b/README.md
index cd5c0fbf..6dd3d226 100644
--- a/README.md
+++ b/README.md
@@ -10,7 +10,7 @@
 
 ![Preview](https://github.com/cunarist/rinf/assets/66480156/5c9a7fb6-e566-4c4e-bd77-d72c1c064d6c)
 
-Rinf is a production-ready framework for creating beautiful and performant cross-platform apps using Flutter and Rust with batteries fully included. Simply add this framework to your app project, and you're all set to write Flutter and Rust together!
+Rinf is a framework for creating beautiful and performant cross-platform apps using Flutter and Rust with batteries fully included. Simply add this framework to your app project, and you're all set to write Flutter and Rust together!
 
 ## 🎮 Demo
 
diff --git a/documentation/docs/state-management.md b/documentation/docs/state-management.md
index 718efbfc..cc644189 100644
--- a/documentation/docs/state-management.md
+++ b/documentation/docs/state-management.md
@@ -16,7 +16,7 @@ Several crates on `crates.io` provide building blocks for implementing the actor
 
 Here’s a basic example using the [`actix`](https://github.com/actix/actix) crate, a popular choice for the actor model:
 
-```rust
+```rust title="Rust"
 use actix::prelude::*;
 
 // this is our Message
diff --git a/documentation/docs/stylesheets/extra.css b/documentation/docs/stylesheets/extra.css
new file mode 100644
index 00000000..f6430a3e
--- /dev/null
+++ b/documentation/docs/stylesheets/extra.css
@@ -0,0 +1,13 @@
+html {
+  overflow-y: scroll;
+}
+
+.md-header {
+  background-color: transparent !important;
+  position: relative;
+  box-shadow: none;
+}
+
+.md-search {
+  padding: 4px;
+}
diff --git a/documentation/mkdocs.yml b/documentation/mkdocs.yml
index be803c04..9329f121 100644
--- a/documentation/mkdocs.yml
+++ b/documentation/mkdocs.yml
@@ -9,7 +9,7 @@ theme:
   palette:
     # Palette toggle for light mode
     - media: "(prefers-color-scheme: light)"
-      primary: grey
+      primary: white
       scheme: default
       toggle:
         icon: material/brightness-7
@@ -21,7 +21,6 @@ theme:
         icon: material/brightness-4
   features:
     - navigation.instant
-    - navigation.top
     - navigation.tracking
     - navigation.path
     - navigation.footer
@@ -59,4 +58,7 @@ extra:
     - icon: fontawesome/brands/twitter
       link: https://twitter.com/cunarist
 
+extra_css:
+  - stylesheets/extra.css
+
 copyright: Copyright © 2024 Cunarist
diff --git a/documentation/overrides/home.html b/documentation/overrides/home.html
index d597b887..4035ad35 100644
--- a/documentation/overrides/home.html
+++ b/documentation/overrides/home.html
@@ -1,8 +1,14 @@
-{% extends "main.html" %}
+{% extends "base.html" %}
 <!-- END OF BLOCK -->
 
 {% block tabs %}
 <style>
+  [data-md-color-scheme="default"] {
+    --md-default-bg-color: #ffffff;
+  }
+  [data-md-color-scheme="slate"] {
+    --md-default-bg-color: #141414;
+  }
   .outermost {
     padding: 0px 24px 0px;
     text-align: center;
@@ -35,7 +41,7 @@
     box-shadow: 0px 8px 24px rgba(0, 0, 0, 0.4);
     margin-bottom: 24px;
     width: 400px;
-    max-width: 50svw !important;
+    max-width: 72svw !important;
     outline: 1px solid rgba(122, 122, 122, 1);
     outline-offset: -1px;
     filter: grayscale();
@@ -49,24 +55,31 @@
   .spacing {
     height: 40px;
   }
+  .description-text {
+    padding: 0px 40px;
+  }
   .guide-box {
     max-width: min(36em, 80svw);
-    min-width: 14em;
+    min-width: 18em;
     margin: 0em auto 0em;
-    padding: 8px;
+    padding: 16px;
     text-align: left;
     flex: 1;
   }
   .repeated-box {
-    max-width: 14em;
-    min-width: 14em;
+    width: 14em;
+    height: 28em;
     margin: 8px;
     padding: 24px;
     text-align: left;
     background-color: rgba(127, 127, 127, 0.08);
     border-radius: 4px;
-    height: 30em;
-    flex: 1;
+  }
+  @media (max-width: 40em) {
+    .repeated-box {
+      width: 100%;
+      height: fit-content;
+    }
   }
   .lang-icon {
     margin-top: 30px;
@@ -94,18 +107,23 @@
 <div class="md-grid md-typeset outermost">
   <div class="front-panel">
     <div class="spacing"></div>
-    <div class="centered">
-      <img
-        src="assets/preview.webp"
-        loop
-        class="preview-image"
-        draggable="false"
-      />
+    <div>
+      <a
+        href="https://rinf-demo.cunarist.com"
+        target="_blank"
+        title="Visit demo"
+      >
+        <img
+          src="assets/preview.webp"
+          loop
+          class="preview-image"
+          draggable="false"
+        />
+      </a>
     </div>
-    <div class="centered">
-      <p class="semi-transparent">
-        Production-ready framework for creating beautiful and performant
-        cross-platform apps
+    <div>
+      <p class="semi-transparent description-text">
+        Build beautiful and performant cross-platform apps
       </p>
       <p class="web-title">Rinf</p>
       <p class="semi-transparent"><strong>RUST IN FLUTTER</strong></p>
@@ -113,22 +131,7 @@
     <div class="spacing"></div>
   </div>
   <div class="spacing"></div>
-  <div class="centered">
-    <h2>Quick Start</h2>
-    <div class="spacing"></div>
-    <a href="{{ page.next_page.url | url }}" class="md-button fixed-button">
-      Read the Docs
-    </a>
-    <a
-      href="https://rinf-demo.cunarist.com"
-      class="md-button fixed-button"
-      target="_blank"
-    >
-      Visit demo
-    </a>
-  </div>
-  <div class="spacing"></div>
-  <div class="centered">
+  <div>
     <h2>The Combination</h2>
     <div class="columns">
       <div class="guide-box">
@@ -184,7 +187,7 @@ <h3>Rust for Performance</h3>
     </div>
   </div>
   <div class="spacing"></div>
-  <div class="centered">
+  <div>
     <h2>Platform Support</h2>
     <div class="guide-box">
       <p>
@@ -207,7 +210,7 @@ <h2>Platform Support</h2>
     </div>
   </div>
   <div class="spacing"></div>
-  <div class="centered">
+  <div>
     <h2>Benefits</h2>
     <div class="columns">
       <div class="repeated-box">
@@ -274,6 +277,7 @@ <h3>Reliable</h3>
       </div>
     </div>
   </div>
+  <div class="spacing"></div>
 </div>
 {% endblock %}
 <!-- END OF BLOCK -->
diff --git a/documentation/pyproject.toml b/documentation/pyproject.toml
index d9808d90..c88c8967 100644
--- a/documentation/pyproject.toml
+++ b/documentation/pyproject.toml
@@ -3,8 +3,8 @@ package-mode = false
 
 [tool.poetry.dependencies]
 python = "^3.10"
-mkdocs = "^1.5.2"
-mkdocs-material = "^9.1.21"
-mkdocs-awesome-pages-plugin = "^2.9.1"
-mkdocs-glightbox = "^0.3.4"
-mkdocs-git-revision-date-localized-plugin = "^1.2.2"
+mkdocs = "^1.6.1"
+mkdocs-material = "^9.5.34"
+mkdocs-awesome-pages-plugin = "^2.9.3"
+mkdocs-glightbox = "^0.4.0"
+mkdocs-git-revision-date-localized-plugin = "^1.2.9"
diff --git a/flutter_package/README.md b/flutter_package/README.md
index cd5c0fbf..6dd3d226 100644
--- a/flutter_package/README.md
+++ b/flutter_package/README.md
@@ -10,7 +10,7 @@
 
 ![Preview](https://github.com/cunarist/rinf/assets/66480156/5c9a7fb6-e566-4c4e-bd77-d72c1c064d6c)
 
-Rinf is a production-ready framework for creating beautiful and performant cross-platform apps using Flutter and Rust with batteries fully included. Simply add this framework to your app project, and you're all set to write Flutter and Rust together!
+Rinf is a framework for creating beautiful and performant cross-platform apps using Flutter and Rust with batteries fully included. Simply add this framework to your app project, and you're all set to write Flutter and Rust together!
 
 ## 🎮 Demo
 
diff --git a/flutter_package/bin/src/message.dart b/flutter_package/bin/src/message.dart
index 553c5c2f..475df2dc 100644
--- a/flutter_package/bin/src/message.dart
+++ b/flutter_package/bin/src/message.dart
@@ -290,8 +290,7 @@ import 'package:rinf/rinf.dart';
 use prost::Message;
 use rinf::{
     debug_print, send_rust_signal, signal_channel,
-    DartSignal, RinfError, SignalReceiver,
-    SignalSender,
+    DartSignal, SignalReceiver, SignalSender,
 };
 use std::sync::LazyLock;
 
@@ -422,29 +421,21 @@ impl ${normalizePascal(messageName)} {
 #![allow(unused_imports)]
 #![allow(unused_mut)]
 
+use super::*;
 use prost::Message;
-use rinf::{debug_print, signal_channel, DartSignal, RinfError};
+use rinf::{DartSignal, RinfError};
 use std::collections::HashMap;
-use std::error::Error;
-use std::sync::OnceLock;
+use std::sync::LazyLock;
 
 type Handler = dyn Fn(&[u8], &[u8]) -> Result<(), RinfError> + Send + Sync;
 type DartSignalHandlers = HashMap<i32, Box<Handler>>;
-static DART_SIGNAL_HANDLERS: OnceLock<DartSignalHandlers> = OnceLock::new();
-
-pub fn assign_dart_signal(
-    message_id: i32,
-    message_bytes: &[u8],
-    binary: &[u8]
-) -> Result<(), RinfError> {    
-    let hash_map = DART_SIGNAL_HANDLERS.get_or_init(|| {
-        let mut new_hash_map: DartSignalHandlers = HashMap::new();
+static DART_SIGNAL_HANDLERS: LazyLock<DartSignalHandlers> = LazyLock::new(|| {
+    let mut hash_map: DartSignalHandlers = HashMap::new();
 ''';
   for (final entry in markedMessagesAll.entries) {
     final subpath = entry.key;
     final files = entry.value;
     for (final entry in files.entries) {
-      final filename = entry.key;
       final markedMessages = entry.value;
       for (final markedMessage in markedMessages) {
         final markType = markedMessage.markType;
@@ -455,13 +446,12 @@ pub fn assign_dart_signal(
           var modulePath = subpath.replaceAll('/', '::');
           modulePath = modulePath == '::' ? '' : modulePath;
           rustReceiveScript += '''
-new_hash_map.insert(
+hash_map.insert(
     ${markedMessage.id},
     Box::new(|message_bytes: &[u8], binary: &[u8]| {
-        use super::$modulePath$filename::*;
         let message =
             ${normalizePascal(messageName)}::decode(message_bytes)
-            .map_err(|_| RinfError::DecodeMessage)?;
+            .map_err(|_| RinfError::CannotDecodeMessage)?;
         let dart_signal = DartSignal {
             message,
             binary: binary.to_vec(),
@@ -476,10 +466,15 @@ new_hash_map.insert(
     }
   }
   rustReceiveScript += '''
-        new_hash_map
-    });
+    hash_map
+});
 
-    let signal_handler = match hash_map.get(&message_id) {
+pub fn assign_dart_signal(
+    message_id: i32,
+    message_bytes: &[u8],
+    binary: &[u8]
+) -> Result<(), RinfError> {
+    let signal_handler = match DART_SIGNAL_HANDLERS.get(&message_id) {
         Some(inner) => inner,
         None => return Err(RinfError::NoSignalHandler),
     };
diff --git a/flutter_package/example/native/hub/src/common.rs b/flutter_package/example/native/hub/src/common.rs
index 44f453a4..3115f963 100644
--- a/flutter_package/example/native/hub/src/common.rs
+++ b/flutter_package/example/native/hub/src/common.rs
@@ -1,7 +1,7 @@
 use std::error::Error;
 
-/// Using this `Result` type alias allows
-/// handling any error type that implements the `Error` trait.
-/// This approach eliminates the need
-/// to depend on external crates for error handling.
+/// This `Result` type alias allows handling any error type
+/// that implements the `Error` trait.
+/// In practice, it is recommended to use custom solutions
+/// or crates dedicated to error handling.
 pub type Result<T> = std::result::Result<T, Box<dyn Error + Send + Sync>>;
diff --git a/flutter_package/example/native/hub/src/lib.rs b/flutter_package/example/native/hub/src/lib.rs
index d2b44ae5..1a04f3d6 100644
--- a/flutter_package/example/native/hub/src/lib.rs
+++ b/flutter_package/example/native/hub/src/lib.rs
@@ -5,7 +5,6 @@ mod common;
 mod messages;
 mod sample_functions;
 
-use common::*;
 use tokio_with_wasm::alias as tokio;
 
 rinf::write_interface!();
@@ -16,16 +15,12 @@ rinf::write_interface!();
 // If you really need to use blocking code,
 // use `tokio::task::spawn_blocking`.
 #[tokio::main(flavor = "current_thread")]
-async fn main() -> Result<()> {
+async fn main() {
     // Spawn the concurrent tasks.
     tokio::spawn(sample_functions::tell_numbers());
     tokio::spawn(sample_functions::stream_fractal());
     tokio::spawn(sample_functions::run_debug_tests());
 
-    // Get the shutdown receiver from Rinf.
-    // This receiver will await a signal from Dart shutdown.
-    let shutdown_receiver = rinf::get_shutdown_receiver()?;
-    shutdown_receiver.await;
-
-    Ok(())
+    // Keep the main function running until Dart shutdown.
+    rinf::dart_shutdown().await;
 }
diff --git a/flutter_package/example/native/hub/src/sample_functions.rs b/flutter_package/example/native/hub/src/sample_functions.rs
index 3165ae02..0b96af27 100644
--- a/flutter_package/example/native/hub/src/sample_functions.rs
+++ b/flutter_package/example/native/hub/src/sample_functions.rs
@@ -1,4 +1,4 @@
-//! This crate is written for Rinf demonstrations.
+//! This module is written for Rinf demonstrations.
 
 use crate::common::*;
 use crate::messages::*;
@@ -8,9 +8,9 @@ use std::time::Duration;
 
 // Using the `cfg` macro enables conditional statement.
 #[cfg(debug_assertions)]
-static IS_DEBUG_MODE: bool = true;
+const IS_DEBUG_MODE: bool = true;
 #[cfg(not(debug_assertions))]
-static IS_DEBUG_MODE: bool = false;
+const IS_DEBUG_MODE: bool = false;
 
 // Business logic for the counter widget.
 pub async fn tell_numbers() {
@@ -193,7 +193,10 @@ pub async fn run_debug_tests() -> Result<()> {
                     prime_count += 1;
                 }
             }
-            format!("There are {prime_count} primes from {count_from} to {count_to}.")
+            format!(
+                "There are {} primes from {} to {}.",
+                prime_count, count_from, count_to,
+            )
         });
         join_handles.push(join_handle);
     }
diff --git a/flutter_package/example/native/sample_crate/src/fractal.rs b/flutter_package/example/native/sample_crate/src/fractal.rs
index af555c97..12ad1423 100644
--- a/flutter_package/example/native/sample_crate/src/fractal.rs
+++ b/flutter_package/example/native/sample_crate/src/fractal.rs
@@ -33,7 +33,13 @@ pub fn draw_fractal_image(scale: f64) -> Result<Vec<u8>, ExampleError> {
     }
 }
 
-fn render(buffer: &mut [u8], height: u32, point_x: f64, point_y: f64, scale: f64) {
+fn render(
+    buffer: &mut [u8],
+    height: u32,
+    point_x: f64,
+    point_y: f64,
+    scale: f64,
+) {
     for y in 0..height {
         let (line, line_number) = render_line(y, point_x, point_y, scale);
         write_line(buffer, &line, line_number);
@@ -42,20 +48,30 @@ fn render(buffer: &mut [u8], height: u32, point_x: f64, point_y: f64, scale: f64
 
 fn write_line(buffer: &mut [u8], line: &[u8], line_number: u32) {
     for i in 0..WIDTH {
-        buffer[(((line_number * WIDTH) + i) * 3) as usize] = line[(i * 3) as usize];
-        buffer[((((line_number * WIDTH) + i) * 3) + 1) as usize] = line[((i * 3) + 1) as usize];
-        buffer[((((line_number * WIDTH) + i) * 3) + 2) as usize] = line[((i * 3) + 2) as usize];
+        buffer[(((line_number * WIDTH) + i) * 3) as usize] =
+            line[(i * 3) as usize];
+        buffer[((((line_number * WIDTH) + i) * 3) + 1) as usize] =
+            line[((i * 3) + 1) as usize];
+        buffer[((((line_number * WIDTH) + i) * 3) + 2) as usize] =
+            line[((i * 3) + 2) as usize];
     }
 }
 
-fn render_line(line_number: u32, px: f64, py: f64, scale: f64) -> (Vec<u8>, u32) {
+fn render_line(
+    line_number: u32,
+    px: f64,
+    py: f64,
+    scale: f64,
+) -> (Vec<u8>, u32) {
     let line_size = WIDTH * 3;
     let mut line: Vec<u8> = vec![0; line_size as usize];
 
     for x in 0..WIDTH {
         // Calculate the offset from the center for x and y
-        let center_offset_x = (x as f64 - WIDTH as f64 / 2.0) / (WIDTH as f64 / 2.0);
-        let center_offset_y = (line_number as f64 - HEIGHT as f64 / 2.0) / (HEIGHT as f64 / 2.0);
+        let center_offset_x =
+            (x as f64 - WIDTH as f64 / 2.0) / (WIDTH as f64 / 2.0);
+        let center_offset_y =
+            (line_number as f64 - HEIGHT as f64 / 2.0) / (HEIGHT as f64 / 2.0);
 
         let (nx, ny) = (
             SIZE * center_offset_x * scale + px,
diff --git a/flutter_package/example/native/sample_crate/src/lib.rs b/flutter_package/example/native/sample_crate/src/lib.rs
index 43135346..dd1af987 100644
--- a/flutter_package/example/native/sample_crate/src/lib.rs
+++ b/flutter_package/example/native/sample_crate/src/lib.rs
@@ -10,7 +10,8 @@ pub use fractal::draw_fractal_image;
 // `machineid_rs` only supports desktop platforms.
 #[cfg(any(target_os = "windows", target_os = "macos", target_os = "linux"))]
 pub fn get_hardward_id() -> Result<String, ExampleError> {
-    let mut builder = machineid_rs::IdBuilder::new(machineid_rs::Encryption::MD5);
+    let mut builder =
+        machineid_rs::IdBuilder::new(machineid_rs::Encryption::MD5);
     builder
         .add_component(machineid_rs::HWIDComponent::SystemID)
         .add_component(machineid_rs::HWIDComponent::CPUCores);
@@ -19,7 +20,11 @@ pub fn get_hardward_id() -> Result<String, ExampleError> {
         .map_err(|error| ExampleError(error.into()))?;
     Ok(hwid)
 }
-#[cfg(not(any(target_os = "windows", target_os = "macos", target_os = "linux")))]
+#[cfg(not(any(
+    target_os = "windows",
+    target_os = "macos",
+    target_os = "linux"
+)))]
 pub fn get_hardward_id() -> Result<String, ExampleError> {
     Ok(String::from("UNSUPPORTED"))
 }
diff --git a/flutter_package/template/native/hub/src/common.rs b/flutter_package/template/native/hub/src/common.rs
deleted file mode 100644
index 44f453a4..00000000
--- a/flutter_package/template/native/hub/src/common.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-use std::error::Error;
-
-/// Using this `Result` type alias allows
-/// handling any error type that implements the `Error` trait.
-/// This approach eliminates the need
-/// to depend on external crates for error handling.
-pub type Result<T> = std::result::Result<T, Box<dyn Error + Send + Sync>>;
diff --git a/flutter_package/template/native/hub/src/lib.rs b/flutter_package/template/native/hub/src/lib.rs
index 4c2a559a..cd3729a2 100644
--- a/flutter_package/template/native/hub/src/lib.rs
+++ b/flutter_package/template/native/hub/src/lib.rs
@@ -1,11 +1,9 @@
 //! This `hub` crate is the
 //! entry point of the Rust logic.
 
-mod common;
 mod messages;
+mod sample_functions;
 
-use crate::common::*;
-use crate::messages::*;
 // use tokio_with_wasm::alias as tokio; // Uncomment this line to target the web.
 
 rinf::write_interface!();
@@ -16,26 +14,10 @@ rinf::write_interface!();
 // If you really need to use blocking code,
 // use `tokio::task::spawn_blocking`.
 #[tokio::main(flavor = "current_thread")]
-async fn main() -> Result<()> {
+async fn main() {
     // Spawn the concurrent tasks.
-    tokio::spawn(communicate());
+    tokio::spawn(sample_functions::communicate());
 
-    // Get the shutdown receiver from Rinf.
-    // This receiver will await a signal from Dart shutdown.
-    let shutdown_receiver = rinf::get_shutdown_receiver()?;
-    shutdown_receiver.await;
-
-    Ok(())
-}
-
-async fn communicate() {
-    // Send signals to Dart like below.
-    SmallNumber { number: 7 }.send_signal_to_dart();
-
-    // Get receivers that listen to Dart signals like below.
-    let receiver = SmallText::get_dart_signal_receiver();
-    while let Some(dart_signal) = receiver.recv().await {
-        let message: SmallText = dart_signal.message;
-        rinf::debug_print!("{message:?}");
-    }
+    // Keep the main function running until Dart shutdown.
+    rinf::dart_shutdown().await;
 }
diff --git a/flutter_package/template/native/hub/src/sample_functions.rs b/flutter_package/template/native/hub/src/sample_functions.rs
new file mode 100644
index 00000000..3ec6b5fb
--- /dev/null
+++ b/flutter_package/template/native/hub/src/sample_functions.rs
@@ -0,0 +1,15 @@
+//! This module is written for Rinf demonstrations.
+
+use crate::messages::*;
+
+pub async fn communicate() {
+    // Send signals to Dart like below.
+    SmallNumber { number: 7 }.send_signal_to_dart();
+
+    // Get receivers that listen to Dart signals like below.
+    let receiver = SmallText::get_dart_signal_receiver();
+    while let Some(dart_signal) = receiver.recv().await {
+        let message: SmallText = dart_signal.message;
+        rinf::debug_print!("{message:?}");
+    }
+}
diff --git a/rust_crate/Cargo.toml b/rust_crate/Cargo.toml
index 607a1c22..588afcb2 100644
--- a/rust_crate/Cargo.toml
+++ b/rust_crate/Cargo.toml
@@ -16,14 +16,18 @@ bevy = ["bevy_ecs"]
 bevy_ecs = { version = "0.14", optional = true }
 
 [target.'cfg(not(target_family = "wasm"))'.dependencies]
+allo-isolate = "0.1.25"
 os-thread-local = "0.1.3"
-backtrace = { version = "0.3.69", optional = true }
 protoc-prebuilt = "0.3.0"
 home = "0.5.9"
 which = "6.0.0"
-allo-isolate = "0.1.25"
+backtrace = { version = "0.3.69", optional = true }
 
 [target.'cfg(target_family = "wasm")'.dependencies]
 js-sys = "0.3.70"
 wasm-bindgen = "0.2.93"
 wasm-bindgen-futures = "0.4.43"
+
+[lints.clippy]
+unwrap_used = "deny"
+expect_used = "deny"
diff --git a/rust_crate/README.md b/rust_crate/README.md
index cd5c0fbf..6dd3d226 100644
--- a/rust_crate/README.md
+++ b/rust_crate/README.md
@@ -10,7 +10,7 @@
 
 ![Preview](https://github.com/cunarist/rinf/assets/66480156/5c9a7fb6-e566-4c4e-bd77-d72c1c064d6c)
 
-Rinf is a production-ready framework for creating beautiful and performant cross-platform apps using Flutter and Rust with batteries fully included. Simply add this framework to your app project, and you're all set to write Flutter and Rust together!
+Rinf is a framework for creating beautiful and performant cross-platform apps using Flutter and Rust with batteries fully included. Simply add this framework to your app project, and you're all set to write Flutter and Rust together!
 
 ## 🎮 Demo
 
diff --git a/rust_crate/src/channel.rs b/rust_crate/src/channel.rs
index 3c049b90..a71c6d2b 100644
--- a/rust_crate/src/channel.rs
+++ b/rust_crate/src/channel.rs
@@ -8,7 +8,6 @@ use std::task::{Context, Poll, Waker};
 /// It is clonable, and multiple senders can be created to send messages into
 /// the same queue. Each message is sent to a receiver, but only the currently
 /// active receiver can receive messages.
-#[derive(Clone)]
 pub struct SignalSender<T> {
     inner: Arc<Mutex<SignalChannel<T>>>,
 }
@@ -36,15 +35,15 @@ impl<T> SignalSender<T> {
     /// message, it will be woken up. This method does not fail if the mutex
     /// is poisoned but simply ignores the failure.
     pub fn send(&self, msg: T) {
-        let mut inner = match self.inner.lock() {
+        let mut guard = match self.inner.lock() {
             Ok(inner) => inner,
-            Err(_) => return, // Do not consider poisoned mutex
+            Err(poisoned) => poisoned.into_inner(),
         };
 
         // Enqueue the message
-        inner.queue.push_back(msg);
+        guard.queue.push_back(msg);
         // Wake up the previous receiver making it receive `None`, if any
-        if let Some(waker) = inner.waker.take() {
+        if let Some(waker) = guard.waker.take() {
             waker.wake();
         }
     }
@@ -70,13 +69,16 @@ impl<T> Clone for SignalReceiver<T> {
     /// original receiver will no longer receive messages after this clone.
     /// This ensures only the most recent receiver can access the message queue.
     fn clone(&self) -> Self {
-        let mut inner = self.inner.lock().unwrap();
+        let mut guard = match self.inner.lock() {
+            Ok(inner) => inner,
+            Err(poisoned) => poisoned.into_inner(),
+        };
         let new_receiver = SignalReceiver {
             inner: self.inner.clone(),
-            id: inner.active_receiver_id + 1, // Increment ID for new receiver
+            id: guard.active_receiver_id + 1, // Increment ID for new receiver
         };
-        inner.active_receiver_id = new_receiver.id;
-        if let Some(waker) = inner.waker.take() {
+        guard.active_receiver_id = new_receiver.id;
+        if let Some(waker) = guard.waker.take() {
             waker.wake();
         }
         new_receiver
@@ -99,26 +101,27 @@ impl<T> Future for RecvFuture<T> {
     /// a message is sent. If this receiver is not the active receiver, it will
     /// return `None`.
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let mut inner = match self.inner.lock() {
+        let mut guard = match self.inner.lock() {
             Ok(inner) => inner,
-            Err(_) => return Poll::Ready(None), // Return None on poisoned mutex
+            Err(poisoned) => poisoned.into_inner(),
         };
 
         // Only allow the current active receiver to receive messages
-        if inner.active_receiver_id == self.receiver_id {
-            if let Some(msg) = inner.queue.pop_front() {
+        if guard.active_receiver_id == self.receiver_id {
+            if let Some(msg) = guard.queue.pop_front() {
                 // Check if more messages are in the queue
-                if !inner.queue.is_empty() {
+                if !guard.queue.is_empty() {
                     // If so, wake the current task immediately
                     cx.waker().wake_by_ref();
                 }
                 Poll::Ready(Some(msg))
             } else {
-                inner.waker = Some(cx.waker().clone());
+                guard.waker = Some(cx.waker().clone());
                 Poll::Pending
             }
         } else {
-            Poll::Ready(None) // Return None if this receiver is not the current active one
+            // Return None if this receiver is not the current active one
+            Poll::Ready(None)
         }
     }
 }
@@ -127,11 +130,14 @@ impl<T> Future for RecvFuture<T> {
 /// used to send messages, and the receiver can be used to receive them
 /// asynchronously. Only one receiver is active at a time, and new receivers
 /// are created by cloning the original receiver.
+#[doc(hidden)]
 pub fn signal_channel<T>() -> (SignalSender<T>, SignalReceiver<T>) {
+    let start_receiver_id = 0;
+
     let channel = Arc::new(Mutex::new(SignalChannel {
         queue: VecDeque::new(),
         waker: None,
-        active_receiver_id: 0, // Start with receiver ID 0
+        active_receiver_id: start_receiver_id,
     }));
 
     let sender = SignalSender {
@@ -139,7 +145,7 @@ pub fn signal_channel<T>() -> (SignalSender<T>, SignalReceiver<T>) {
     };
     let receiver = SignalReceiver {
         inner: channel,
-        id: 0,
+        id: start_receiver_id,
     };
     (sender, receiver)
 }
diff --git a/rust_crate/src/error.rs b/rust_crate/src/error.rs
index ea528f57..489c8f86 100644
--- a/rust_crate/src/error.rs
+++ b/rust_crate/src/error.rs
@@ -3,30 +3,18 @@ use std::fmt;
 
 #[derive(Debug)]
 pub enum RinfError {
-    LockDartIsolate,
     NoDartIsolate,
-    LockShutdownReceiver,
-    NoShutdownReceiver,
-    DecodeMessage,
+    CannotDecodeMessage,
     NoSignalHandler,
 }
 
 impl fmt::Display for RinfError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            RinfError::LockDartIsolate => {
-                write!(f, "Could not acquire the Dart isolate lock.")
-            }
             RinfError::NoDartIsolate => {
                 write!(f, "Dart isolate for Rust signals was not created.")
             }
-            RinfError::LockShutdownReceiver => {
-                write!(f, "Could not acquire the shutdown receiver lock.")
-            }
-            RinfError::NoShutdownReceiver => {
-                write!(f, "Shutdown receiver was not created.")
-            }
-            RinfError::DecodeMessage => {
+            RinfError::CannotDecodeMessage => {
                 write!(f, "Could not decode the message.")
             }
             RinfError::NoSignalHandler => {
diff --git a/rust_crate/src/interface.rs b/rust_crate/src/interface.rs
index 4e6be5d6..19234c7b 100644
--- a/rust_crate/src/interface.rs
+++ b/rust_crate/src/interface.rs
@@ -25,6 +25,7 @@ pub struct DartSignal<T> {
 /// Even in a single-threaded (current-thread) runtime,
 /// the `Runtime` object itself might be moved between threads,
 /// along with all the tasks it manages.
+#[doc(hidden)]
 #[cfg(not(target_family = "wasm"))]
 pub fn start_rust_logic<F, T>(main_fn: F) -> Result<(), RinfError>
 where
@@ -45,6 +46,7 @@ where
 }
 
 /// Send a signal to Dart.
+#[doc(hidden)]
 pub fn send_rust_signal(
     message_id: i32,
     message_bytes: Vec<u8>,
diff --git a/rust_crate/src/interface_os.rs b/rust_crate/src/interface_os.rs
index 48f6f563..141b925c 100644
--- a/rust_crate/src/interface_os.rs
+++ b/rust_crate/src/interface_os.rs
@@ -1,9 +1,9 @@
 use crate::error::RinfError;
-use crate::shutdown::{create_shutdown_channel, SHUTDOWN_SENDER};
+use crate::shutdown::SHUTDOWN_EVENTS;
 use allo_isolate::{IntoDart, Isolate, ZeroCopyBuffer};
 use os_thread_local::ThreadLocal;
-use std::cell::RefCell;
 use std::sync::Mutex;
+use std::sync::OnceLock;
 use std::thread;
 
 static DART_ISOLATE: Mutex<Option<Isolate>> = Mutex::new(None);
@@ -13,20 +13,35 @@ pub extern "C" fn prepare_isolate_extern(port: i64) {
     let dart_isolate = Isolate::new(port);
     let mut guard = match DART_ISOLATE.lock() {
         Ok(inner) => inner,
-        Err(_) => {
-            let error = RinfError::LockDartIsolate;
-            println!("{error}");
-            return;
-        }
+        Err(poisoned) => poisoned.into_inner(),
     };
     guard.replace(dart_isolate);
 }
 
+// We use `os_thread_local` so that when the program fails
+// and the main thread exits unexpectedly,
+// the whole Rust async runtime shuts down accordingly.
+// Without this solution,
+// zombie threads inside the Rust async runtime might outlive the app.
+// This `ThreadLocal` is intended to be used only on the main thread,
+type ShutdownDropperLock = OnceLock<ThreadLocal<ShutdownDropper>>;
+static SHUTDOWN_DROPPER: ShutdownDropperLock = OnceLock::new();
+
+/// Notifies Rust that Dart thread has exited when dropped.
+pub struct ShutdownDropper;
+
+impl Drop for ShutdownDropper {
+    fn drop(&mut self) {
+        SHUTDOWN_EVENTS.dart_stopped.set();
+        SHUTDOWN_EVENTS.rust_stopped.wait();
+    }
+}
+
 pub fn start_rust_logic_real<F, T>(main_fn: F) -> Result<(), RinfError>
 where
     F: Fn() -> T + Send + 'static,
 {
-    // Enable backtrace output for panics.
+    // Enable console output for panics.
     #[cfg(debug_assertions)]
     {
         #[cfg(not(feature = "backtrace"))]
@@ -39,20 +54,40 @@ where
         {
             std::panic::set_hook(Box::new(|panic_info| {
                 let backtrace = backtrace::Backtrace::new();
-                crate::debug_print!("A panic occurred in Rust.\n{panic_info}\n{backtrace:?}");
+                crate::debug_print!(
+                    "A panic occurred in Rust.\n{panic_info}\n{backtrace:?}"
+                );
             }));
         }
     }
 
-    // Prepare the channel that will help notify async runtime to shutdown
-    // after the main Dart thread has gone.
-    let shutdown_reporter = create_shutdown_channel()?;
+    // Prepare the shutdown dropper that will notify the Rust async runtime
+    // after Dart thread has exited.
+    // This code assumes that this is the main thread.
+    let thread_local = ThreadLocal::new(|| ShutdownDropper);
+    let _ = SHUTDOWN_DROPPER.set(thread_local);
 
-    // Run the async runtime.
+    // Spawn a new thread to run the async runtime.
     thread::spawn(move || {
+        // Notify that Dart has stopped
+        // to terminate the previous Rust async runtime threads.
+        // After Dart's hot restart or reopening the app,
+        // Previous Rust async runtime can be still running.
+        SHUTDOWN_EVENTS.dart_stopped.set();
+
+        // Clear shutdown events to prepare for a fresh start.
+        SHUTDOWN_EVENTS.dart_stopped.clear();
+        SHUTDOWN_EVENTS.rust_stopped.clear();
+
+        // Execute the long-running function that will block the thread
+        // for the entire lifecycle of the app.
+        // This function runs the async Rust runtime.
         main_fn();
-        // After the runtime is closed, tell the main thread to stop waiting.
-        drop(shutdown_reporter);
+
+        // After the Rust async runtime is closed,
+        // notify the main Dart thread to stop blocking
+        // and allow the application to exit.
+        SHUTDOWN_EVENTS.rust_stopped.set();
     });
 
     Ok(())
@@ -60,14 +95,7 @@ where
 
 #[no_mangle]
 pub extern "C" fn stop_rust_logic_extern() {
-    let sender_lock = SHUTDOWN_SENDER.get_or_init(move || ThreadLocal::new(|| RefCell::new(None)));
-    let sender_option = sender_lock.with(|cell| cell.take());
-    if let Some(shutdown_sender) = sender_option {
-        // Dropping the sender tells the async runtime to stop running.
-        // Also, it blocks the main thread until
-        // it gets the report that async runtime is dropped.
-        drop(shutdown_sender);
-    }
+    SHUTDOWN_EVENTS.dart_stopped.set();
 }
 
 pub fn send_rust_signal_real(
@@ -77,9 +105,10 @@ pub fn send_rust_signal_real(
 ) -> Result<(), RinfError> {
     // When `DART_ISOLATE` is not initialized, just return the error.
     // This can happen when running test code in Rust.
-    let guard = DART_ISOLATE
-        .lock()
-        .map_err(|_| RinfError::LockDartIsolate)?;
+    let guard = match DART_ISOLATE.lock() {
+        Ok(inner) => inner,
+        Err(poisoned) => poisoned.into_inner(),
+    };
     let dart_isolate = guard.as_ref().ok_or(RinfError::NoDartIsolate)?;
 
     // If a `Vec<u8>` is empty, we can't just simply send it to Dart
diff --git a/rust_crate/src/interface_web.rs b/rust_crate/src/interface_web.rs
index af29fc5c..22b9fd69 100644
--- a/rust_crate/src/interface_web.rs
+++ b/rust_crate/src/interface_web.rs
@@ -1,5 +1,4 @@
 use crate::error::RinfError;
-use crate::shutdown::create_shutdown_channel;
 use js_sys::Uint8Array;
 use wasm_bindgen::prelude::*;
 
@@ -15,9 +14,6 @@ where
         }));
     }
 
-    // Prepare the channel to match the behavior of native platforms.
-    let _ = create_shutdown_channel();
-
     // Run the main function.
     main_fn();
 
@@ -27,7 +23,11 @@ where
 #[wasm_bindgen]
 extern "C" {
     #[wasm_bindgen(js_namespace = rinf)]
-    pub fn send_rust_signal_extern(resource: i32, message_bytes: Uint8Array, binary: Uint8Array);
+    pub fn send_rust_signal_extern(
+        resource: i32,
+        message_bytes: Uint8Array,
+        binary: Uint8Array,
+    );
 }
 
 pub fn send_rust_signal_real(
diff --git a/rust_crate/src/lib.rs b/rust_crate/src/lib.rs
index 059c6325..dc8debfe 100644
--- a/rust_crate/src/lib.rs
+++ b/rust_crate/src/lib.rs
@@ -12,4 +12,4 @@ mod interface_web;
 pub use channel::{signal_channel, SignalReceiver, SignalSender};
 pub use error::RinfError;
 pub use interface::{send_rust_signal, start_rust_logic, DartSignal};
-pub use shutdown::get_shutdown_receiver;
+pub use shutdown::dart_shutdown;
diff --git a/rust_crate/src/macros.rs b/rust_crate/src/macros.rs
index 51bca9a0..47d9a56c 100644
--- a/rust_crate/src/macros.rs
+++ b/rust_crate/src/macros.rs
@@ -33,9 +33,11 @@ macro_rules! write_interface {
             binary_size: usize,
         ) {
             use std::slice::from_raw_parts;
-            let message_bytes = unsafe { from_raw_parts(message_pointer, message_size) };
+            let message_bytes =
+                unsafe { from_raw_parts(message_pointer, message_size) };
             let binary = unsafe { from_raw_parts(binary_pointer, binary_size) };
-            let result = messages::assign_dart_signal(message_id, message_bytes, binary);
+            let result =
+                messages::assign_dart_signal(message_id, message_bytes, binary);
             if let Err(error) = result {
                 rinf::debug_print!("{error}");
             }
@@ -43,10 +45,15 @@ macro_rules! write_interface {
 
         #[cfg(target_family = "wasm")]
         #[wasm_bindgen::prelude::wasm_bindgen]
-        pub fn send_dart_signal_extern(message_id: i32, message_bytes: &[u8], binary: &[u8]) {
+        pub fn send_dart_signal_extern(
+            message_id: i32,
+            message_bytes: &[u8],
+            binary: &[u8],
+        ) {
             let message_bytes = message_bytes;
             let binary = binary;
-            let result = messages::assign_dart_signal(message_id, message_bytes, binary);
+            let result =
+                messages::assign_dart_signal(message_id, message_bytes, binary);
             if let Err(error) = result {
                 rinf::debug_print!("{error}");
             }
diff --git a/rust_crate/src/main.rs b/rust_crate/src/main.rs
index 108cef1e..4c6347e8 100644
--- a/rust_crate/src/main.rs
+++ b/rust_crate/src/main.rs
@@ -1,5 +1,5 @@
 #[cfg(not(target_family = "wasm"))]
-fn main() -> Result<(), Box<dyn std::error::Error>> {
+fn main() -> Result<(), String> {
     use std::env;
     use std::fs;
     use std::path;
@@ -15,10 +15,12 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             .to_path_buf()
     } else {
         // Install Protobuf compiler and get the path.
-        let home_path =
-            home::home_dir().ok_or("Could not get home directory for `protoc` installation.")?;
+        let home_path = home::home_dir()
+            .ok_or("Could not get home directory for `protoc` installation.")?;
         let out_path = home_path.join(".local").join("bin");
-        fs::create_dir_all(&out_path)?;
+        fs::create_dir_all(&out_path).map_err(|_| {
+            "Could not create the folder for `protoc` installation."
+        })?;
         env::set_var(
             "OUT_DIR",
             out_path
@@ -41,14 +43,19 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     // Find the path where Dart executables are located.
     #[cfg(target_family = "windows")]
-    let pub_cache_bin_path = path::PathBuf::from(env::var("LOCALAPPDATA")?)
-        .join("Pub")
-        .join("Cache")
-        .join("bin");
+    let pub_cache_bin_path = path::PathBuf::from(
+        env::var("LOCALAPPDATA")
+            .map_err(|_| "Could not get `LOCALAPPDATA` path.")?,
+    )
+    .join("Pub")
+    .join("Cache")
+    .join("bin");
     #[cfg(target_family = "unix")]
-    let pub_cache_bin_path = path::PathBuf::from(env::var("HOME")?)
-        .join(".pub-cache")
-        .join("bin");
+    let pub_cache_bin_path = path::PathBuf::from(
+        env::var("HOME").map_err(|_| "Could get find `HOME` path.")?,
+    )
+    .join(".pub-cache")
+    .join("bin");
 
     // Add some folders to PATH for various commands to work correctly.
     let mut path_var = match env::var_os("PATH") {
@@ -57,23 +64,28 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     };
     path_var.push(protoc_path);
     path_var.push(pub_cache_bin_path);
-    env::set_var("PATH", env::join_paths(path_var)?);
+    env::set_var(
+        "PATH",
+        env::join_paths(path_var)
+            .map_err(|_| "Could not push required values to `PATH`.")?,
+    );
 
     // Get command-line arguments excluding the program name.
     let dart_command_args: Vec<String> = env::args().skip(1).collect();
 
     // Run the Dart script.
-    let dart_path = which::which("dart")?;
+    let dart_path = which::which("dart")
+        .map_err(|_| "Could not find where Dart is located.")?;
     let mut command = process::Command::new(dart_path);
     command.args(["run", "rinf"]);
     command.args(&dart_command_args);
-    command.status()?;
+    command.status().map_err(|_| "Rinf command has failed.")?;
 
     Ok(())
 }
 
 #[cfg(target_family = "wasm")]
-fn main() -> Result<(), Box<dyn std::error::Error>> {
+fn main() -> Result<(), String> {
     // Dummy function to make the linter happy.
     Ok(())
 }
diff --git a/rust_crate/src/shutdown.rs b/rust_crate/src/shutdown.rs
index 7d6bad05..c946c38d 100644
--- a/rust_crate/src/shutdown.rs
+++ b/rust_crate/src/shutdown.rs
@@ -1,148 +1,205 @@
-use crate::error::RinfError;
-use os_thread_local::ThreadLocal;
-use std::cell::RefCell;
 use std::future::Future;
 use std::pin::Pin;
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{Arc, Condvar, Mutex, OnceLock};
+use std::sync::{Arc, LazyLock, Mutex};
 use std::task::{Context, Poll, Waker};
 
-// We use `os_thread_local` so that when the program fails
-// and the main thread exits unexpectedly,
-// the whole async runtime can shut down as well
-// by receiving a signal via the shutdown channel.
-// Without this solution,
-// zombie threads inside the async runtime might outlive the app.
-// This `ThreadLocal` is intended to be used only on the main thread.
-type ShutdownSenderLock = OnceLock<ThreadLocal<RefCell<Option<ShutdownSender>>>>;
-pub static SHUTDOWN_SENDER: ShutdownSenderLock = OnceLock::new();
-
-type ShutdownReceiverLock = Mutex<Option<ShutdownReceiver>>;
-pub static SHUTDOWN_RECEIVER: ShutdownReceiverLock = Mutex::new(None);
+// Thread-blocking operations are possible
+// only on non-web platforms.
+#[cfg(not(target_family = "wasm"))]
+use std::sync::Condvar;
+
+type ShutdownEventsLock = LazyLock<ShutdownEvents>;
+pub static SHUTDOWN_EVENTS: ShutdownEventsLock =
+    LazyLock::new(|| ShutdownEvents {
+        dart_stopped: Event::new(),
+        #[cfg(not(target_family = "wasm"))]
+        rust_stopped: Event::new(),
+    });
+
+/// A collection of shutdown events
+/// expected to occur one by one on app close.
+pub struct ShutdownEvents {
+    pub dart_stopped: Event,
+    #[cfg(not(target_family = "wasm"))]
+    pub rust_stopped: Event,
+}
 
 /// Retrieves the shutdown receiver that listens for
 /// the Dart runtime's closure.
 /// Awaiting this receiver in the async main Rust function
 /// is necessary to prevent the async runtime in Rust from
 /// finishing immediately.
-pub fn get_shutdown_receiver() -> Result<ShutdownReceiver, RinfError> {
-    let mut reciver_lock = SHUTDOWN_RECEIVER
-        .lock()
-        .map_err(|_| RinfError::LockShutdownReceiver)?;
-    reciver_lock.take().ok_or(RinfError::NoShutdownReceiver)
+pub async fn dart_shutdown() {
+    SHUTDOWN_EVENTS.dart_stopped.wait_async().await;
 }
 
-pub fn create_shutdown_channel() -> Result<ShutdownReporter, RinfError> {
-    let (shutdown_sender, shutdown_receiver, shutdown_reporter) = shutdown_channel();
-
-    let sender_lock = SHUTDOWN_SENDER.get_or_init(move || ThreadLocal::new(|| RefCell::new(None)));
-    sender_lock.with(|cell| cell.replace(Some(shutdown_sender)));
+/// Synchronization primitive that allows
+/// threads or async tasks to wait until a condition is met.
+pub struct Event {
+    inner: Arc<Mutex<EventInner>>,
+    #[cfg(not(target_family = "wasm"))]
+    condvar: Arc<Condvar>,
+}
 
-    let mut reciver_lock = SHUTDOWN_RECEIVER
-        .lock()
-        .map_err(|_| RinfError::LockShutdownReceiver)?;
-    reciver_lock.replace(shutdown_receiver);
+impl Event {
+    /// Creates a new `Event` with the initial flag state.
+    pub fn new() -> Self {
+        Event {
+            inner: Arc::new(Mutex::new(EventInner::new())),
+            #[cfg(not(target_family = "wasm"))]
+            condvar: Arc::new(Condvar::new()),
+        }
+    }
 
-    Ok(shutdown_reporter)
+    /// Creates a future that will be resolved
+    /// when the flag is set to `true`.
+    pub fn wait_async(&self) -> EventFuture {
+        let guard = match self.inner.lock() {
+            Ok(inner) => inner,
+            Err(poisoned) => poisoned.into_inner(),
+        };
+        EventFuture {
+            started_session: guard.session,
+            inner: self.inner.clone(),
+        }
+    }
 }
 
-type ChannelTuple = (ShutdownSender, ShutdownReceiver, ShutdownReporter);
-fn shutdown_channel() -> ChannelTuple {
-    let should_shutdown = Arc::new(AtomicBool::new(false));
-    let waker = Arc::new(Mutex::new(None));
-    let did_shutdown = Arc::new(Mutex::new(false));
-    let is_done = Arc::new(Condvar::new());
-
-    let sender = ShutdownSender {
-        should_shutdown: should_shutdown.clone(),
-        waker: waker.clone(),
-        did_shutdown: did_shutdown.clone(),
-        is_done: is_done.clone(),
-    };
-    let receiver = ShutdownReceiver {
-        should_shutdown,
-        waker,
-    };
-    let reporter = ShutdownReporter {
-        did_shutdown,
-        is_done,
-    };
-
-    (sender, receiver, reporter)
+#[cfg(not(target_family = "wasm"))]
+impl Event {
+    /// Sets the flag to `true` and notifies all waiting threads.
+    /// This will wake up any threads or async tasks.
+    pub fn set(&self) {
+        let mut guard = match self.inner.lock() {
+            Ok(inner) => inner,
+            Err(poisoned) => poisoned.into_inner(),
+        };
+        guard.flag = true; // Set the flag
+        guard.session += 1; // Increment the session count
+
+        // Wake all threads and async tasks when the event is set
+        self.condvar.notify_all();
+        for waker in guard.wakers.drain(..) {
+            waker.wake();
+        }
+    }
+
+    /// Clears the flag, setting it to `false`.
+    /// This does not affect any waiting threads,
+    /// but subsequent calls to `wait` will
+    /// block until the flag is set again.
+    pub fn clear(&self) {
+        let mut guard = match self.inner.lock() {
+            Ok(inner) => inner,
+            Err(poisoned) => poisoned.into_inner(),
+        };
+        guard.flag = false; // Clear the flag
+    }
+
+    /// Blocks the current thread until the flag is set to `true`.
+    /// If the flag is already set,
+    /// this method will return immediately.
+    /// Otherwise, it will block until `set` is called by another thread.
+    pub fn wait(&self) {
+        let event_blocking =
+            EventBlocking::new(self.inner.clone(), self.condvar.clone());
+        event_blocking.wait();
+    }
 }
 
-pub struct ShutdownSender {
-    should_shutdown: Arc<AtomicBool>,
-    waker: Arc<Mutex<Option<Waker>>>,
-    did_shutdown: Arc<Mutex<bool>>,
-    is_done: Arc<Condvar>,
+/// Internal state for the `Event` synchronization primitive.
+struct EventInner {
+    flag: bool,         // Current flag state
+    session: usize,     // Session count to detect changes
+    wakers: Vec<Waker>, // List of wakers to be notified
 }
 
-impl Drop for ShutdownSender {
-    fn drop(&mut self) {
-        self.should_shutdown.store(true, Ordering::SeqCst);
-        if let Ok(mut guard) = self.waker.lock() {
-            if let Some(waker) = guard.take() {
-                waker.wake();
-            }
-        }
-        while let Ok(guard) = self.did_shutdown.lock() {
-            if *guard {
-                break;
-            } else {
-                let _unused = self.is_done.wait(guard);
-            }
+impl EventInner {
+    fn new() -> Self {
+        EventInner {
+            flag: false,
+            session: 0,
+            wakers: Vec::new(),
         }
     }
 }
 
-pub struct ShutdownReceiver {
-    should_shutdown: Arc<AtomicBool>,
-    waker: Arc<Mutex<Option<Waker>>>,
+/// Struct to handle waiting with session tracking.
+#[cfg(not(target_family = "wasm"))]
+struct EventBlocking {
+    inner: Arc<Mutex<EventInner>>,
+    condvar: Arc<Condvar>,
+    started_session: usize,
 }
 
-impl Future for ShutdownReceiver {
-    type Output = ();
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        if !self.should_shutdown.load(Ordering::SeqCst) {
-            if let Ok(mut guard) = self.waker.lock() {
-                guard.replace(cx.waker().clone());
+#[cfg(not(target_family = "wasm"))]
+impl EventBlocking {
+    fn new(inner: Arc<Mutex<EventInner>>, condvar: Arc<Condvar>) -> Self {
+        let guard = match inner.lock() {
+            Ok(inner) => inner,
+            Err(poisoned) => poisoned.into_inner(),
+        };
+        EventBlocking {
+            inner: inner.clone(),
+            condvar,
+            started_session: guard.session,
+        }
+    }
+
+    pub fn wait(&self) {
+        // Lock the inner state and wait on the condition variable
+        let mut guard = match self.inner.lock() {
+            Ok(inner) => inner,
+            Err(poisoned) => poisoned.into_inner(),
+        };
+        loop {
+            // Check if the condition is met
+            if guard.flag || guard.session != self.started_session {
+                break;
             }
-            Poll::Pending
-        } else {
-            Poll::Ready(())
+            // Wait on the condition variable and reassign the guard
+            guard = match self.condvar.wait(guard) {
+                Ok(inner) => inner,
+                Err(poisoned) => poisoned.into_inner(),
+            };
         }
     }
 }
 
-pub struct ShutdownReporter {
-    did_shutdown: Arc<Mutex<bool>>,
-    is_done: Arc<Condvar>,
+/// Future that resolves when the `Event` flag is set to `true`.
+pub struct EventFuture {
+    started_session: usize,
+    inner: Arc<Mutex<EventInner>>, // Use the combined inner state
 }
 
-impl Drop for ShutdownReporter {
-    fn drop(&mut self) {
-        if let Ok(mut guard) = self.did_shutdown.lock() {
-            *guard = true;
-        }
-        self.is_done.notify_all();
-    }
-}
+impl Future for EventFuture {
+    type Output = ();
 
-// `os_thread_local` is only available on native platforms,
-// Let's simply mimic `ThreadLocal` on the web.
-#[cfg(target_family = "wasm")]
-mod os_thread_local {
-    pub struct ThreadLocal<T> {
-        inner: T,
-    }
-    unsafe impl<T> Sync for ThreadLocal<T> {}
-    impl<T> ThreadLocal<T> {
-        pub fn new<F: Fn() -> T>(inner: F) -> ThreadLocal<T> {
-            ThreadLocal { inner: inner() }
-        }
-        pub fn with<R, F: FnOnce(&T) -> R>(&self, f: F) {
-            f(&self.inner);
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let mut guard = match self.inner.lock() {
+            Ok(inner) => inner,
+            Err(poisoned) => poisoned.into_inner(),
+        };
+
+        // Check if the flag is set or if the session count has changed.
+        // If the flag is true or the session count is different
+        // because a new event session has started, stop polling.
+        if guard.flag || guard.session != self.started_session {
+            Poll::Ready(())
+        } else {
+            // Check if the current waker is already in the list of wakers.
+            // If the waker is unique (not already in the list),
+            // add it to the list.
+            let waker = cx.waker();
+            if !guard
+                .wakers
+                .iter()
+                .any(|existing_waker| existing_waker.will_wake(waker))
+            {
+                guard.wakers.push(waker.clone());
+            }
+
+            Poll::Pending
         }
     }
 }