fix(operations): bound handler lifetimes

req: operations/003

examples/kanban/tests/browser_e2e.rs

@@ -2196,6 +2196,83 @@ async fn adversarial_wire_inputs_are_rejected_before_partial_application() -> We
     result.and(quit)
 }
 
+#[tokio::test]
+async fn ordinary_browser_request_exposes_deadline_and_cancels_on_pagehide() -> WebDriverResult<()>
+{
+    // test req: operations/003
+    let app_port = available_port();
+    let app_addr = format!("127.0.0.1:{app_port}");
+    let mut app_command = Command::new(env!("CARGO_BIN_EXE_hemx-kanban-example"));
+    app_command.env("HEMX_KANBAN_ADDR", &app_addr);
+    let _app = TestProcess::start(app_command, "hemx-kanban", &app_addr, STARTUP_TIMEOUT)
+        .expect("start hemx-kanban");
+
+    let webdriver_port = available_port();
+    let webdriver_addr = format!("127.0.0.1:{webdriver_port}");
+    let mut webdriver = Command::new("geckodriver");
+    webdriver.arg("--port").arg(webdriver_port.to_string());
+    let _webdriver = TestProcess::start(webdriver, "geckodriver", &webdriver_addr, STARTUP_TIMEOUT)
+        .expect("start ready geckodriver");
+    let mut caps = DesiredCapabilities::firefox();
+    caps.set_headless()?;
+    let driver = WebDriver::new(&format!("http://{webdriver_addr}"), caps).await?;
+
+    let result = async {
+        driver.goto(&format!("http://{app_addr}/")).await?;
+        wait_until(
+            &driver,
+            "return document.querySelector('[data-hemx-root]')?.getAttribute('data-hemx-request-timeout-ms') === '10000'",
+        )
+        .await?;
+        let proof = driver
+            .execute_async(
+                r#"
+                const done = arguments[arguments.length - 1];
+                (async () => {
+                  const root = document.querySelector('[data-hemx-root]');
+                  const form = root.querySelector('form');
+                  form.querySelector('[name=title]').value = 'cancel me';
+                  let started = false;
+                  let abortDetail;
+                  window.fetch = (_url, init) => new Promise((_resolve, reject) => {
+                    started = true;
+                    init.signal.addEventListener('abort', () => {
+                      abortDetail = { name: init.signal.reason.name, message: init.signal.reason.message };
+                      reject(init.signal.reason);
+                    }, { once: true });
+                  });
+                  form.dispatchEvent(new Event('submit', { bubbles: true, cancelable: true }));
+                  while (!started) await new Promise((resolve) => setTimeout(resolve, 1));
+                  window.dispatchEvent(new PageTransitionEvent('pagehide'));
+                  while (!abortDetail || form.hasAttribute('data-hemx-pending')) {
+                    await new Promise((resolve) => setTimeout(resolve, 1));
+                  }
+                  done({
+                    abortDetail,
+                    timeoutMs: root.getAttribute('data-hemx-request-timeout-ms'),
+                    pending: form.hasAttribute('data-hemx-pending'),
+                  });
+                })().catch((error) => done({ error: String(error), stack: error?.stack }));
+                "#,
+                Vec::new(),
+            )
+            .await?
+            .json()
+            .clone();
+        assert!(proof["error"].is_null(), "ordinary cancellation failed: {proof}");
+        assert_eq!(proof["timeoutMs"], "10000");
+        assert_eq!(proof["abortDetail"]["name"], "AbortError");
+        assert!(proof["abortDetail"]["message"]
+            .as_str()
+            .is_some_and(|message| message.contains("cancelled because page is hidden")));
+        assert_eq!(proof["pending"], false);
+        Ok(())
+    }
+    .await;
+    let quit = driver.quit().await;
+    result.and(quit)
+}
+
 #[tokio::test]
 async fn acknowledgement_stream_bounds_reconnect_buffering_heartbeat_and_cancellation(
 ) -> WebDriverResult<()> {