Increase coverage

.mise/config.coverage.toml

@@ -47,6 +47,29 @@ coreutils rm -rf target/debug target/release
 # `--sh` is the current flag (the old `--export-prefix` alias is deprecated). This sets the rustc wrapper +
 # LLVM_PROFILE_FILE + profile dir so nextest and the regens instrument into one profile set that `report` merges.
 eval "$(cargo llvm-cov show-env --sh)"
+# nextest SIGKILLs the spawned et-ws-pyo3-runner (services/ws-pyo3-runner/tests/modules.rs) after each exchange.
+# LLVM flushes a process's counters only at exit, so a SIGKILLed process contributes nothing: the runner's async
+# run/drive/worker paths reported 0% while its in-process initialize() was covered. Continuous mode (%c) memory-maps
+# the counter file so increments persist live and survive the kill. %c is incompatible with the merge-pool (%Nm)
+# specifier show-env emits, so use a per-process (%p) continuous file in the same profile dir -- `cargo llvm-cov
+# report` globs every *.profraw there regardless of name. On Linux continuous mode additionally needs relocatable
+# counters (`-Cllvm-args=-runtime-counter-relocation`). The wrapper flags env is CARGO_ENCODED_RUSTFLAGS format
+# (ASCII unit separator 0x1f between flags), not space-separated -- a space append glues the llvm-arg onto the
+# last existing flag and rustc rejects `--cfg=coverage_nightly -Cllvm-args=...` as one invalid --cfg value.
+cov_dir="$(coreutils dirname "$LLVM_PROFILE_FILE")"
+export LLVM_PROFILE_FILE="$cov_dir/core-cont-%p%c.profraw"
+if [ "$(coreutils uname -s)" = "Linux" ]; then
+  reloc="-Cllvm-args=-runtime-counter-relocation"
+  flags="${__CARGO_LLVM_COV_RUSTC_WRAPPER_RUSTFLAGS:-}"
+  # Append the reloc flag with a TOML-injected unit separator (ASCII 31).
+  # Bash dollar-quote hex is not a valid TOML escape, so the separator has to be introduced by the
+  # TOML parser into the task body rather than written as a shell escape.
+  if [ -n "$flags" ]; then
+    export __CARGO_LLVM_COV_RUSTC_WRAPPER_RUSTFLAGS="${flags}\u001f${reloc}"
+  else
+    export __CARGO_LLVM_COV_RUSTC_WRAPPER_RUSTFLAGS="${reloc}"
+  fi
+fi
 # The --features flags compile each runner's coverage code, off by default so non-coverage builds omit it.
 # et-ws-web-runner/coverage adds the browser-module capture (shims + the __et_capture_coverage PUT);
 # et-ws-wasi-runner/coverage adds the guest `/cov` preopen. ET_TEST_COVERAGE (set by the coverage job) still

config/otelcol-hostmetrics.yaml

@@ -2,6 +2,13 @@
 # Scrapes host resource usage and ships it to the local OpenObserve (o2) over OTLP/HTTP -- the same OTLP-to-o2
 # path the ws-server uses.
 receivers:
+  # GPU (NVIDIA) is not collected here.
+  # Use the dedicated `o2-nvidia` / `o2-nvidia-native` mise tasks (native nvidia_gpu_exporter + prometheus
+  # scrape). DCGM remains available if you prefer in-collector GPU metrics: it needs `--gpus all` on the docker
+  # run and a DCGM-capable host; uncomment this receiver and add `dcgm` to the metrics pipeline receivers below
+  # to enable it.
+  # dcgm:
+  #   collection_interval: 10s
   hostmetrics:
     # Read the host's /proc and /sys rather than the collector container's own.
     # `/hostfs` is the host root the task bind-mounts read-only.
@@ -15,13 +22,6 @@ receivers:
       filesystem: {}
       network: {}
       paging: {}
-  # GPU (NVIDIA) is not collected here.
-  # Use the dedicated `o2-nvidia` / `o2-nvidia-native` mise tasks (native nvidia_gpu_exporter + prometheus
-  # scrape). DCGM remains available if you prefer in-collector GPU metrics: it needs `--gpus all` on the docker
-  # run and a DCGM-capable host; uncomment this receiver and add `dcgm` to the metrics pipeline receivers below
-  # to enable it.
-  # dcgm:
-  #   collection_interval: 10s
 
 extensions:
   # o2 ingests OTLP over HTTP with HTTP Basic auth; the credentials come from config/o2.env (passed via --env-file).

config/ryl.yaml

@@ -3,6 +3,9 @@
 extends: default
 
 rules:
+  # A misindented comment reads as attached to the wrong block, so treat it as an error, not a warning.
+  comments-indentation:
+    level: error
   # dprint (the YAML formatter) writes one space before an inline `#`.
   # yamllint defaults to two. Defer to dprint so the two can't fight.
   comments:

libs/path/tests/find.rs

@@ -1,9 +1,20 @@
 #![cfg(test)]
 
-use et_path::find_project_root;
+use et_path::{find_project_root, find_project_root_from_manifest};
 use fs_err as fs;
 use tempfile::tempdir;
 
+#[test]
+fn manifest_dir_resolves_to_an_existing_root() {
+    // cargo sets `CARGO_MANIFEST_DIR` in the test process env, so the helper reads this crate's
+    // directory and walks up to the workspace root (which carries project-root markers).
+    let root = find_project_root_from_manifest();
+    assert!(
+        root.is_dir(),
+        "resolved project root {root:?} should be an existing directory"
+    );
+}
+
 #[test]
 fn finds_marker_in_an_ancestor() {
     let root = tempdir().unwrap();

libs/web/src/lib.rs

@@ -6,6 +6,14 @@ pub use self::error::{JsCastExt, JsFunctionExt, JsPromiseExt, JsResultExt};
 
 pub const SENSOR_PERMISSION_GRANTED: &str = "granted";
 
+/// Discard `value`, marking a `Result` (or other `#[must_use]`) as intentionally ignored.
+///
+/// The workspace denies `let_underscore*` and `unused_results`, and `DeepSource`'s RS-E1021 flags `drop()` on a
+/// non-`Drop` type (e.g. `Result`), so neither `let _ = expr` nor `drop(expr)` is available for discarding one.
+/// Passing the value here consumes it -- satisfying `must_use` / `unused_results` -- via neither. Intended for
+/// best-effort JS DOM calls in `()`-returning closures and event handlers where the error is deliberately dropped.
+pub fn ignore<T>(_value: T) {}
+
 /// Return this module's raw minicov coverage buffer (a `.profraw`), or empty on failure.
 ///
 /// Present only in the `coverage` build. `wasm-bindgen` collects this export into every dependent browser

services/ws-modules/audio1/src/lib.rs

@@ -77,7 +77,7 @@ thread_local! {
 
 #[wasm_bindgen(start)]
 pub fn init() {
-    drop(tracing_wasm::try_set_as_global_default());
+    et_web::ignore(tracing_wasm::try_set_as_global_default());
     info!("audio-capture module initialized");
 }
 
@@ -126,7 +126,7 @@ pub async fn run() -> Result<(), JsValue> {
         let stop_callback = Closure::once_into_js(move || {
             if is_running() {
                 log("workflow finished automatically after 5 seconds");
-                drop(stop());
+                et_web::ignore(stop());
             }
         });
         let window = web_sys::window().ok_or_else(|| JsValue::from_str("No window available"))?;
@@ -139,7 +139,7 @@ pub async fn run() -> Result<(), JsValue> {
 
     if let Err(error) = &outcome {
         let message = describe_js_error(error);
-        drop(set_module_status(&format!("audio-capture: error\n{message}")));
+        et_web::ignore(set_module_status(&format!("audio-capture: error\n{message}")));
         log(&format!("error: {message}"));
     }
 
@@ -204,13 +204,13 @@ async fn sleep_ms(duration_ms: i32) -> Result<(), JsValue> {
     let window = web_sys::window().ok_or_else(|| JsValue::from_str("No window available"))?;
     let promise = Promise::new(&mut |resolve, reject| {
         let callback = Closure::once_into_js(move || {
-            drop(resolve.call0(&JsValue::NULL));
+            et_web::ignore(resolve.call0(&JsValue::NULL));
         });
 
         if let Err(error) =
             window.set_timeout_with_callback_and_timeout_and_arguments_0(callback.unchecked_ref(), duration_ms)
         {
-            drop(reject.call1(&JsValue::NULL, &error));
+            et_web::ignore(reject.call1(&JsValue::NULL, &error));
         }
     });
     JsFuture::from(promise).await.map(|_| ())

services/ws-modules/bluetooth/src/lib.rs

@@ -96,7 +96,7 @@ impl BluetoothAccess {
 
 #[wasm_bindgen(start)]
 pub fn init() {
-    drop(tracing_wasm::try_set_as_global_default());
+    et_web::ignore(tracing_wasm::try_set_as_global_default());
     info!("bluetooth module initialized");
 }
 
@@ -146,7 +146,7 @@ pub async fn run() -> Result<(), JsValue> {
 
     if let Err(error) = &outcome {
         let message = describe_js_error(error);
-        drop(set_module_status(&format!("bluetooth: error\n{message}")));
+        et_web::ignore(set_module_status(&format!("bluetooth: error\n{message}")));
         log(&format!("error: {message}"));
     }
 
@@ -197,13 +197,13 @@ async fn sleep_ms(duration_ms: i32) -> Result<(), JsValue> {
     let window = web_sys::window().ok_or_else(|| JsValue::from_str("No window available"))?;
     let promise = Promise::new(&mut |resolve, reject| {
         let callback = Closure::once_into_js(move || {
-            drop(resolve.call0(&JsValue::NULL));
+            et_web::ignore(resolve.call0(&JsValue::NULL));
         });
 
         if let Err(error) =
             window.set_timeout_with_callback_and_timeout_and_arguments_0(callback.unchecked_ref(), duration_ms)
         {
-            drop(reject.call1(&JsValue::NULL, &error));
+            et_web::ignore(reject.call1(&JsValue::NULL, &error));
         }
     });
     JsFuture::from(promise).await.map(|_| ())

services/ws-modules/comm1/src/lib.rs

@@ -133,7 +133,7 @@ fn handle_incoming_message(
                 "comm1: received {scope:?} message {message_id} from {from_agent_id} at {server_received_at}: {summary}"
             );
             web_sys::console::log_1(&JsValue::from_str(&line));
-            drop(set_module_status(&line));
+            let _status = set_module_status(&line);
         }
         ServerMessage::MessageStatus {
             message_id,
@@ -142,12 +142,12 @@ fn handle_incoming_message(
         } => {
             let line = format!("comm1: message status update {message_id:?} {status:?}: {detail}");
             web_sys::console::log_1(&JsValue::from_str(&line));
-            drop(set_module_status(&line));
+            let _status = set_module_status(&line);
         }
         ServerMessage::Invalid { message_id, detail } => {
             let line = format!("comm1: invalid server response {message_id:?}: {detail}");
             web_sys::console::warn_1(&JsValue::from_str(&line));
-            drop(set_module_status(&line));
+            let _status = set_module_status(&line);
         }
         ServerMessage::ConnectAck { .. }
         | ServerMessage::Response { .. }
@@ -192,13 +192,13 @@ async fn sleep_ms(duration_ms: i32) -> Result<(), JsValue> {
     let window = web_sys::window().ok_or_else(|| JsValue::from_str("No window available"))?;
     let promise = Promise::new(&mut |resolve, reject| {
         let callback = Closure::once_into_js(move || {
-            drop(resolve.call0(&JsValue::NULL));
+            let _resolved = resolve.call0(&JsValue::NULL);
         });
 
         if let Err(error) =
             window.set_timeout_with_callback_and_timeout_and_arguments_0(callback.unchecked_ref(), duration_ms)
         {
-            drop(reject.call1(&JsValue::NULL, &error));
+            let _rejected = reject.call1(&JsValue::NULL, &error);
         }
     });
     JsFuture::from(promise).await.map(|_| ())

services/ws-modules/data1/src/lib.rs

@@ -36,7 +36,7 @@ pub async fn run() -> Result<(), JsValue> {
         let Some(data) = value.as_string() else {
             return;
         };
-        drop(serde_json::from_str::<ServerMessage>(&data));
+        et_web::ignore(serde_json::from_str::<ServerMessage>(&data));
     }) as Box<dyn FnMut(JsValue)>);
 
     client.set_on_message(on_message.as_ref().clone());
@@ -134,7 +134,7 @@ async fn sleep_ms(duration_ms: i32) -> Result<(), JsValue> {
     let window = web_sys::window().ok_or_else(|| JsValue::from_str("No window available"))?;
     let promise = Promise::new(&mut |resolve, _reject| {
         let callback = Closure::once_into_js(move || {
-            drop(resolve.call0(&JsValue::NULL));
+            et_web::ignore(resolve.call0(&JsValue::NULL));
         });
         let _id: Result<i32, JsValue> =
             window.set_timeout_with_callback_and_timeout_and_arguments_0(callback.unchecked_ref(), duration_ms);

services/ws-modules/geolocation/src/lib.rs

@@ -44,28 +44,28 @@ impl GeolocationReading {
         let promise = js_sys::Promise::new(&mut |resolve, reject| {
             let reject_for_callback = reject.clone();
             let success_box: Box<dyn FnOnce(JsValue)> = Box::new(move |position: JsValue| {
-                drop(resolve.call1(&JsValue::NULL, &position));
+                et_web::ignore(resolve.call1(&JsValue::NULL, &position));
             });
             let success = Closure::once(success_box);
 
             let failure_box: Box<dyn FnOnce(JsValue)> = Box::new(move |error: JsValue| {
-                drop(reject_for_callback.call1(&JsValue::NULL, &error));
+                et_web::ignore(reject_for_callback.call1(&JsValue::NULL, &error));
             });
             let failure = Closure::once(failure_box);
 
             match js_sys::Reflect::get(&geolocation, &JsValue::from_str("getCurrentPosition"))
                 .and_then(|value| value.into_function("navigator.geolocation.getCurrentPosition"))
             {
                 Ok(get_current_position) => {
-                    drop(get_current_position.call3(
+                    et_web::ignore(get_current_position.call3(
                         &geolocation,
                         success.as_ref().unchecked_ref(),
                         failure.as_ref().unchecked_ref(),
                         &options,
                     ));
                 }
                 Err(err) => {
-                    drop(reject.call1(&JsValue::NULL, &err));
+                    et_web::ignore(reject.call1(&JsValue::NULL, &err));
                 }
             }
 
@@ -116,7 +116,7 @@ impl GeolocationReading {
 
 #[wasm_bindgen(start)]
 pub fn init() {
-    drop(tracing_wasm::try_set_as_global_default());
+    et_web::ignore(tracing_wasm::try_set_as_global_default());
     info!("geolocation module initialized");
 }
 
@@ -170,7 +170,7 @@ pub async fn run() -> Result<(), JsValue> {
 
     if let Err(error) = &outcome {
         let message = describe_js_error(error);
-        drop(set_module_status(&format!("geolocation: error\n{message}")));
+        et_web::ignore(set_module_status(&format!("geolocation: error\n{message}")));
         log(&format!("error: {message}"));
     }
 
@@ -221,13 +221,13 @@ async fn sleep_ms(duration_ms: i32) -> Result<(), JsValue> {
     let window = web_sys::window().ok_or_else(|| JsValue::from_str("No window available"))?;
     let promise = Promise::new(&mut |resolve, reject| {
         let callback = Closure::once_into_js(move || {
-            drop(resolve.call0(&JsValue::NULL));
+            et_web::ignore(resolve.call0(&JsValue::NULL));
         });
 
         if let Err(error) =
             window.set_timeout_with_callback_and_timeout_and_arguments_0(callback.unchecked_ref(), duration_ms)
         {
-            drop(reject.call1(&JsValue::NULL, &error));
+            et_web::ignore(reject.call1(&JsValue::NULL, &error));
         }
     });
     JsFuture::from(promise).await.map(|_| ())

services/ws-modules/graphics-info/src/lib.rs

@@ -674,7 +674,7 @@ fn string_or_unknown(value: String) -> String {
 
 #[wasm_bindgen(start)]
 pub fn init() {
-    drop(tracing_wasm::try_set_as_global_default());
+    et_web::ignore(tracing_wasm::try_set_as_global_default());
     info!("graphics-info module initialized");
 }
 
@@ -800,7 +800,7 @@ pub async fn run() -> Result<(), JsValue> {
 
     if let Err(error) = &outcome {
         let message = describe_js_error(error);
-        drop(set_module_status(&format!("graphics-info: error\n{message}")));
+        et_web::ignore(set_module_status(&format!("graphics-info: error\n{message}")));
         log(&format!("error: {message}"));
     }
 
@@ -851,13 +851,13 @@ async fn sleep_ms(duration_ms: i32) -> Result<(), JsValue> {
     let window = web_sys::window().ok_or_else(|| JsValue::from_str("No window available"))?;
     let promise = Promise::new(&mut |resolve, reject| {
         let callback = Closure::once_into_js(move || {
-            drop(resolve.call0(&JsValue::NULL));
+            et_web::ignore(resolve.call0(&JsValue::NULL));
         });
 
         if let Err(error) =
             window.set_timeout_with_callback_and_timeout_and_arguments_0(callback.unchecked_ref(), duration_ms)
         {
-            drop(reject.call1(&JsValue::NULL, &error));
+            et_web::ignore(reject.call1(&JsValue::NULL, &error));
         }
     });
     JsFuture::from(promise).await.map(|_| ())

services/ws-modules/har1/src/lib.rs

@@ -332,7 +332,7 @@ impl DeviceSensors {
 
 #[wasm_bindgen(start)]
 pub fn init() {
-    drop(tracing_wasm::try_set_as_global_default());
+    et_web::ignore(tracing_wasm::try_set_as_global_default());
     info!("har1 workflow module initialized");
 }
 
@@ -371,7 +371,7 @@ pub async fn run() -> Result<(), JsValue> {
 
     if let Err(error) = &outcome {
         let message = describe_js_error(error);
-        drop(set_har_status(&format!("har1: error\n{message}")));
+        et_web::ignore(set_har_status(&format!("har1: error\n{message}")));
         log(&format!("error: {message}"));
     }
 
@@ -874,13 +874,13 @@ async fn sleep_ms(duration_ms: i32) -> Result<(), JsValue> {
     let window = web_sys::window().ok_or_else(|| JsValue::from_str("No window available"))?;
     let promise = Promise::new(&mut |resolve, reject| {
         let callback = Closure::once_into_js(move || {
-            drop(resolve.call0(&JsValue::NULL));
+            et_web::ignore(resolve.call0(&JsValue::NULL));
         });
 
         if let Err(error) =
             window.set_timeout_with_callback_and_timeout_and_arguments_0(callback.unchecked_ref(), duration_ms)
         {
-            drop(reject.call1(&JsValue::NULL, &error));
+            et_web::ignore(reject.call1(&JsValue::NULL, &error));
         }
     });
     JsFuture::from(promise).await.map(|_| ())