refactor(sim): move the simulator harness into tests/common

The simulator lived in src/ as a std-gated `pub mod sim` so it could reach pub(crate) internals, putting ~1.1k lines of test harness in the shipping crate. Move it to tests/common/sim, where it drives only rmk's public API:

- Vial/Rynk now go through the public `run_session` over in-memory pipes (the rynk_link pattern), so host/via and host/rynk revert to base — the pub(crate) seams are gone.
- A std-gated #[doc(hidden)] `rmk::test_exports` wraps the few internal signals the harness still needs (flash/connection/keycode). std is dev-only, so the firmware API is unchanged.
- src/test_support.rs regains its own block_on (src unit tests can't reach the test crate); check_sim_tests.sh skips the harness itself.

Whole feature matrix passes (scripts/test_all.sh).

Author: HaoboGu

rmk/src/host/rynk/mod.rs

@@ -51,7 +51,7 @@ pub struct RynkService<'a> {
     lock_config: LockConfig,
 }
 
-pub(crate) struct RynkSession<'a> {
+struct RynkSession<'a> {
     locker: HostLock<'a>,
     topics: topics::TopicSubscribers,
 }
@@ -90,23 +90,9 @@ impl<'a> RynkService<'a> {
         }
     }
 
-    /// Build a fresh per-connection session (authorization gate + topic
-    /// subscriptions). Each transport calls this once at connect.
-    pub(crate) fn new_session(&self) -> RynkSession<'a> {
-        RynkSession {
-            locker: HostLock::new(
-                self.lock_config.unlock_keys,
-                self.ctx.keymap,
-                self.lock_config.insecure,
-                RYNK_UNLOCK_WINDOW,
-            ),
-            topics: topics::TopicSubscribers::new(),
-        }
-    }
-
     /// Process one inbound message in place and replace its payload with a
     /// response envelope. `cmd` and `seq` remain unchanged.
-    pub(crate) async fn dispatch(&self, session: &RynkSession<'_>, msg: &mut RynkMessage<'_>) {
+    async fn dispatch(&self, session: &RynkSession<'_>, msg: &mut RynkMessage<'_>) {
         let cmd = msg.header().cmd;
 
         if self.requires_unlock(cmd) && !session.locker.is_unlocked() {
@@ -183,7 +169,15 @@ impl<'a> RynkService<'a> {
     ///
     /// Owns frame reassembly/dispatch; transport setup and reconnect stay outside.
     pub async fn run_session<R: Read, T: Write>(&self, rx: &mut R, tx: &mut T) {
-        let mut session = self.new_session();
+        let mut session = RynkSession {
+            locker: HostLock::new(
+                self.lock_config.unlock_keys,
+                self.ctx.keymap,
+                self.lock_config.insecure,
+                RYNK_UNLOCK_WINDOW,
+            ),
+            topics: topics::TopicSubscribers::new(),
+        };
         let mut buf = [0u8; RYNK_BUFFER_SIZE];
 
         loop {

rmk/src/host/via/mod.rs

@@ -37,7 +37,7 @@ impl<'a> VialService<'a> {
         }
     }
 
-    pub(crate) async fn process_via_packet(&self, report: &mut ViaReport) {
+    async fn process_via_packet(&self, report: &mut ViaReport) {
         let command_id = report.output_data[0];
 
         // Caller pre-fills `input_data` from `output_data`, so individual arms

rmk/src/lib.rs

@@ -107,12 +107,54 @@ pub mod usb;
 #[cfg(feature = "watchdog")]
 pub mod watchdog;
 
+// Test-only re-exports of crate internals the simulator harness (in
+// `tests/common/sim`) drives. Gated on the dev-only `std` feature, so none of
+// this is part of the shipping firmware API.
 #[cfg(feature = "std")]
 #[doc(hidden)]
-pub mod sim;
+pub mod test_exports {
+    //! Thin accessors for the few `pub(crate)` internals the simulator harness
+    //! (in `tests/common/sim`) drives. Wrappers rather than `pub use` — the
+    //! latter can't widen `pub(crate)` visibility. Std-gated, so none of this is
+    //! compiled into firmware.
+
+    pub const COMBO_MAX_LENGTH: usize = crate::COMBO_MAX_LENGTH;
+    pub const MACRO_SPACE_SIZE: usize = crate::MACRO_SPACE_SIZE;
+
+    #[cfg(feature = "vial")]
+    pub fn to_via_keycode(action: rmk_types::action::KeyAction) -> u16 {
+        crate::host::via::keycode_convert::to_via_keycode(action)
+    }
+
+    #[cfg(all(feature = "_no_usb", feature = "_ble"))]
+    pub fn set_ble_state(state: rmk_types::ble::BleState) {
+        crate::state::set_ble_state(state);
+    }
+
+    #[cfg(any(not(feature = "_no_usb"), feature = "_ble"))]
+    pub fn reset_connection_status() {
+        crate::state::CONNECTION_STATUS.lock(|c| c.set(rmk_types::connection::ConnectionStatus::default()));
+    }
+
+    #[cfg(feature = "storage")]
+    pub fn clear_flash_channel() {
+        crate::channel::FLASH_CHANNEL.clear();
+    }
+
+    #[cfg(feature = "storage")]
+    pub fn reset_flash_operation() {
+        crate::storage::FLASH_OPERATION_FINISHED.reset();
+    }
+
+    #[cfg(feature = "storage")]
+    pub async fn flash_operation_finished() -> bool {
+        crate::storage::FLASH_OPERATION_FINISHED.wait().await
+    }
+}
 
-// Makes the shared simulator executor available to `#[cfg(test)]` modules
-// while preserving the nextest process guard.
+// Self-contained `block_on` over embassy-time's mock clock for `#[cfg(test)]`
+// modules under `src/` (the simulator harness lives in the separate test crate,
+// out of their reach). Also runs the nextest process guard.
 #[cfg(test)]
 pub(crate) mod test_support;
 

rmk/src/test_support.rs

@@ -1,8 +1,23 @@
+//! Test-only `block_on` that drives `embassy-time`'s mock clock.
+//!
+//! Mirrors the executor in `tests/common/sim/executor.rs`. Lives under `src/`
+//! because `#[cfg(test)] mod tests` blocks inside library files cannot import
+//! from the `tests/` directory (that's a separate compilation target).
+//!
+//! Use as a drop-in replacement for `embassy_futures::block_on`:
+//!
+//! ```ignore
+//! use crate::test_support::test_block_on as block_on;
+//! ```
+
 use core::future::Future;
+use core::task::{Context, Poll, RawWaker, RawWakerVTable, Waker};
+
+use embassy_time::{Duration, MockDriver};
 
 // `embassy-time`'s MockDriver is a process-global singleton, so running the
 // suite under plain `cargo test` lets tests race on it and hang at the 60 s
-// virtual-time kill switch. Abort at test-binary startup with a pointer
+// virtual-time kill switch below. Abort at test-binary startup with a pointer
 // to the right runner instead of making the user wait for that timeout.
 #[ctor::ctor(unsafe)]
 fn require_nextest() {
@@ -20,6 +35,40 @@ fn require_nextest() {
     }
 }
 
-pub(crate) fn test_block_on<F: Future>(future: F) -> F::Output {
-    crate::sim::test_block_on(future)
+const STEP: Duration = Duration::from_micros(100);
+const MAX_ITERS: usize = 60_000_000; // 60 s of virtual time
+
+pub(crate) fn test_block_on<F: Future>(fut: F) -> F::Output {
+    MockDriver::get().reset();
+
+    let waker = noop_waker();
+    let mut cx = Context::from_waker(&waker);
+
+    let mut fut = Box::pin(fut);
+    for _ in 0..MAX_ITERS {
+        if let Poll::Ready(out) = fut.as_mut().poll(&mut cx) {
+            return out;
+        }
+        MockDriver::get().advance(STEP);
+    }
+    panic!(
+        "test_block_on: future did not resolve within {} iterations ({} s of virtual time)",
+        MAX_ITERS,
+        (MAX_ITERS as u64 * STEP.as_micros()) / 1_000_000,
+    );
+}
+
+fn noop_waker() -> Waker {
+    // Safety: every vtable function is a true no-op; no state is ever
+    // dereferenced through the data pointer.
+    unsafe { Waker::from_raw(RAW) }
 }
+
+const RAW: RawWaker = RawWaker::new(core::ptr::null(), &VTABLE);
+
+const VTABLE: RawWakerVTable = RawWakerVTable::new(
+    |_| RAW, // clone
+    |_| {},  // wake
+    |_| {},  // wake_by_ref
+    |_| {},  // drop
+);

rmk/tests/common/mod.rs

@@ -3,6 +3,8 @@ pub mod morse;
 pub mod rynk_hid_link;
 #[cfg(feature = "rynk")]
 pub mod rynk_link;
+pub mod sim;
+
 use core::future::Future;
 
 use rmk::types::action::KeyAction;
@@ -40,7 +42,7 @@ pub fn init_log() {
 }
 
 pub fn test_block_on<F: Future>(future: F) -> F::Output {
-    rmk::sim::test_block_on(future)
+    sim::test_block_on(future)
 }
 
 pub const KC_LCTRL: u8 = 1 << 0;

rmk/tests/common/morse.rs

@@ -1,9 +1,10 @@
-use rmk::sim::{KeymapOverride, SimKeyboardSetup};
 use rmk::types::action::{Action, KeyAction};
 use rmk::types::keycode::{HidKeyCode, KeyCode};
 use rmk::types::modifier::ModifierCombination;
 use rmk::{k, lt, mt, td};
 
+use crate::common::sim::{KeymapOverride, SimKeyboardSetup};
+
 pub const SIMPLE_MORSE_KEY_OVERRIDES: [KeymapOverride; 10] = [
     KeymapOverride::new(0, 0, 0, k!(A)),
     KeymapOverride::new(0, 0, 1, mt!(B, ModifierCombination::LSHIFT)),