flowproof 0.23.4__tar.gz → 0.23.6__tar.gz

{flowproof-0.23.4 → flowproof-0.23.6}/Cargo.lock

@@ -930,7 +930,7 @@ dependencies = [
 
 [[package]]
 name = "flowproof-adapters"
-version = "0.23.4"
+version = "0.23.6"
 dependencies = [
  "anyhow",
  "flowproof-driver",
@@ -949,7 +949,7 @@ dependencies = [
 
 [[package]]
 name = "flowproof-agent"
-version = "0.23.4"
+version = "0.23.6"
 dependencies = [
  "chrono",
  "flowproof-driver",
@@ -967,7 +967,7 @@ dependencies = [
 
 [[package]]
 name = "flowproof-cli"
-version = "0.23.4"
+version = "0.23.6"
 dependencies = [
  "ab_glyph",
  "chrono",
@@ -992,7 +992,7 @@ dependencies = [
 
 [[package]]
 name = "flowproof-driver"
-version = "0.23.4"
+version = "0.23.6"
 dependencies = [
  "calamine",
  "flowproof-trace",
@@ -1008,7 +1008,7 @@ dependencies = [
 
 [[package]]
 name = "flowproof-python"
-version = "0.23.4"
+version = "0.23.6"
 dependencies = [
  "flowproof-agent",
  "flowproof-cli",
@@ -1020,7 +1020,7 @@ dependencies = [
 
 [[package]]
 name = "flowproof-replay"
-version = "0.23.4"
+version = "0.23.6"
 dependencies = [
  "chrono",
  "flowproof-agent",
@@ -1034,7 +1034,7 @@ dependencies = [
 
 [[package]]
 name = "flowproof-trace"
-version = "0.23.4"
+version = "0.23.6"
 dependencies = [
  "jsonschema",
  "regex",

{flowproof-0.23.4 → flowproof-0.23.6}/Cargo.toml

@@ -22,7 +22,7 @@ members = ["crates/flowproof-driver", "crates/flowproof-trace", "crates/flowproo
 exclude = ["spike/windows-containment"]
 
 [workspace.package]
-version = "0.23.4"
+version = "0.23.6"
 edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/automators-com/flowproof"

{flowproof-0.23.4 → flowproof-0.23.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flowproof
-Version: 0.23.4
+Version: 0.23.6
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3

{flowproof-0.23.4 → flowproof-0.23.6}/crates/flowproof-adapters/src/web.rs

@@ -459,10 +459,23 @@ const FRAME_ACT: &str = r#"function(FRAME, CSS, ID, TEXT, OP, ARG){
       + '.urMnu, .lsPOMNContainer, [id^="ARIA_"], [id*="SAPGUI"]'
     );
   }
+  // The classic value-help ("F4") popup's own filter input is a document-
+  // level match for isSapWebGui() too (it renders inside the same WebGUI
+  // frame), but it does NOT commit on blur like an ordinary screen field -
+  // it commits on an explicit Go/search button click, which the recorded
+  // flow already does as its own separate step. Confirmed live: typing a
+  // value then tabbing out of one of these (the sap_webgui path's blur+
+  // verify dance) left the field empty rather than reformatted, failing a
+  // spec that never asked for a Tab here at all. `NSH`-prefixed ids and
+  // `SHLP`/search-help markers are SAP's own standard naming for this popup
+  // across systems, not something specific to one client's screens.
+  function isValueHelpPopupField(){
+    return !!el.closest('[id^="NSH"], [id*="SHLP"], [id*="F4Help"], [class*="shlp"]');
+  }
   if (OP === 'kind'){
     var nativeInput = el.tagName === 'INPUT' || el.tagName === 'TEXTAREA';
     return (nativeInput ? 'native_input' : 'other') + ':'
-      + (isSapWebGui() ? 'sap_webgui' : 'generic');
+      + (isSapWebGui() && !isValueHelpPopupField() ? 'sap_webgui' : 'generic');
   }
   if (OP === 'value'){
     var value = ('value' in el)
@@ -2078,27 +2091,38 @@ impl WebAppDriver {
         ))
     }
 
-    /// Run an element operation with ONE retry on a CDP transport fault:
-    /// re-resolve the element (its object id may be gone with the dead
-    /// connection) and try again before failing the step.
+    // These probes run before dispatching any input. A control without a
+    // box during a redraw is not ready; let the bounded actionability wait
+    // re-resolve it, without retrying a click or masking transport errors.
+    fn composed_readiness(&mut self, target: &UiaSelector) -> Result<Option<String>, DriverError> {
+        match flowproof_driver::composed_actionability_gate(self, target) {
+            Err(DriverError::Browser(message))
+                if message.contains("box model of [")
+                    && message.contains("Could not compute box model") =>
+            {
+                Ok(Some(
+                    "not rendered (target has no box during redraw)".into(),
+                ))
+            }
+            result => result,
+        }
+    }
+
+    /// Run an element operation with the shared transport-fault retry
+    /// policy (see [`retry_on_transport_fault`]): re-resolve the element
+    /// (its object id may be gone with the dead connection) and try again
+    /// before failing the step.
     fn with_element<T>(
         &self,
         locator: &WebLocator,
         context: &str,
         op: impl Fn(&headless_chrome::Element<'_>) -> Result<T, anyhow::Error>,
     ) -> Result<T, DriverError> {
-        let mut retried = false;
-        loop {
-            let element = self.find(locator)?;
-            match op(&element) {
-                Ok(value) => return Ok(value),
-                Err(e) if !retried && is_transport_fault(&e.to_string()) => {
-                    retried = true;
-                    std::thread::sleep(Duration::from_millis(300));
-                }
-                Err(e) => return Err(web_err(context, e)),
-            }
-        }
+        retry_on_transport_fault(|| {
+            let element = self.find(locator).map_err(|e| e.to_string())?;
+            op(&element).map_err(|e| e.to_string())
+        })
+        .map_err(|e| web_err(context, e))
     }
 }
 
@@ -2120,30 +2144,63 @@ fn is_transport_fault(message: &str) -> bool {
         || m.contains("unable to make method calls")
 }
 
-/// Retry a fallible operation exactly once if its first failure looks like
-/// a transient CDP transport fault - the same one-shot recovery
-/// `with_element` already gives element-scoped calls (re-finding the
-/// element and retrying its own op inline), generalized here for a call
-/// that talks to the tab directly and has nothing to re-resolve. Pure
-/// control flow, no CDP calls of its own, so it is unit-testable with a
-/// mock closure rather than only provable against a real, flaky browser.
-fn retry_once_on_transport_fault<T>(
+/// Attempts allowed beyond the first for a transport-faulting operation.
+/// Was 1 (a single fixed ~300ms retry) until issue #608: a clean live
+/// re-verification of `medium-02-change-info-record-readonly.flow.yaml`
+/// still hit "underlying connection is closed" 3 of 6 runs, including
+/// `frame_act` failing *twice in a row* even though it already had that one
+/// retry - proof a single ~300ms retry does not reliably bridge a real CDP
+/// outage.
+const TRANSPORT_FAULT_RETRIES: u32 = 3;
+
+/// Backoff base: the wait before retry N is `N * TRANSPORT_FAULT_BACKOFF`
+/// (300ms, 600ms, 900ms), so the delay grows instead of hammering a
+/// connection that needs a moment to recover.
+const TRANSPORT_FAULT_BACKOFF: Duration = Duration::from_millis(300);
+
+/// Retry a fallible operation on a transient CDP transport fault, backing
+/// off a little more between each attempt - the same recovery
+/// `with_element` gives element-scoped calls (re-finding the element and
+/// retrying its own op), generalized here for a call that talks to the tab
+/// directly and has nothing to re-resolve. Pure control flow, no CDP calls
+/// of its own, so it is unit-testable with a mock closure rather than only
+/// provable against a real, flaky browser.
+fn retry_on_transport_fault<T>(
     mut attempt: impl FnMut() -> Result<T, String>,
 ) -> Result<T, String> {
-    match attempt() {
-        Ok(value) => Ok(value),
-        Err(e) if is_transport_fault(&e) => {
-            std::thread::sleep(Duration::from_millis(300));
-            attempt()
+    retry_on_transport_fault_with(TRANSPORT_FAULT_RETRIES, &mut attempt, |backoff| {
+        std::thread::sleep(backoff)
+    })
+}
+
+/// The retry loop itself, with the attempt budget and the sleep both
+/// injectable: production always calls it via [`retry_on_transport_fault`]
+/// with the real constants and a real sleep; tests inject a smaller budget
+/// and a no-op sleep so the backoff schedule is provable without paying
+/// seconds of real wall-clock time per test.
+fn retry_on_transport_fault_with<T>(
+    max_retries: u32,
+    attempt: &mut impl FnMut() -> Result<T, String>,
+    mut sleep: impl FnMut(Duration),
+) -> Result<T, String> {
+    let mut retries = 0;
+    loop {
+        match attempt() {
+            Ok(value) => return Ok(value),
+            Err(e) if retries < max_retries && is_transport_fault(&e) => {
+                retries += 1;
+                sleep(TRANSPORT_FAULT_BACKOFF * retries);
+            }
+            Err(e) => return Err(e),
         }
-        Err(e) => Err(e),
     }
 }
 
 #[cfg(test)]
 mod transport_retry_tests {
-    use super::retry_once_on_transport_fault;
-    use std::cell::Cell;
+    use super::{retry_on_transport_fault, retry_on_transport_fault_with};
+    use std::cell::{Cell, RefCell};
+    use std::time::Duration;
 
     /// docs/fiori-reliability/FINDINGS.md:
     /// medium-02-change-info-record-readonly.flow.yaml failed live with
@@ -2154,7 +2211,7 @@ mod transport_retry_tests {
     #[test]
     fn a_transport_fault_recovers_on_the_second_attempt() {
         let calls = Cell::new(0);
-        let result = retry_once_on_transport_fault(|| {
+        let result = retry_on_transport_fault(|| {
             calls.set(calls.get() + 1);
             if calls.get() == 1 {
                 Err("Unable to make method calls because underlying connection is closed".into())
@@ -2163,21 +2220,51 @@ mod transport_retry_tests {
             }
         });
         assert_eq!(result, Ok("recovered"));
-        assert_eq!(calls.get(), 2, "must retry exactly once, not loop");
+        assert_eq!(calls.get(), 2);
     }
 
+    /// issue #608: a live run saw `frame_act` fail twice in a row on the
+    /// same connection-closed fault even though it already had one retry -
+    /// this proves the policy now survives that exact shape of failure by
+    /// recovering on the third attempt (second retry).
     #[test]
-    fn a_transport_fault_that_never_clears_still_fails_after_one_retry() {
+    fn a_transport_fault_recovers_on_the_third_attempt() {
         let calls = Cell::new(0);
-        let result: Result<(), String> = retry_once_on_transport_fault(|| {
-            calls.set(calls.get() + 1);
-            Err("the event waited for never came".into())
-        });
+        let result = retry_on_transport_fault_with(
+            3,
+            &mut || {
+                calls.set(calls.get() + 1);
+                if calls.get() < 3 {
+                    Err(
+                        "Unable to make method calls because underlying connection is closed"
+                            .into(),
+                    )
+                } else {
+                    Ok("recovered")
+                }
+            },
+            |_| {},
+        );
+        assert_eq!(result, Ok("recovered"));
+        assert_eq!(calls.get(), 3, "must survive two consecutive faults");
+    }
+
+    #[test]
+    fn a_transport_fault_that_never_clears_still_fails_after_all_retries() {
+        let calls = Cell::new(0);
+        let result: Result<(), String> = retry_on_transport_fault_with(
+            3,
+            &mut || {
+                calls.set(calls.get() + 1);
+                Err("the event waited for never came".into())
+            },
+            |_| {},
+        );
         assert_eq!(result, Err("the event waited for never came".to_string()));
         assert_eq!(
             calls.get(),
-            2,
-            "one retry, then give up - not an infinite loop"
+            4,
+            "one first attempt plus three retries, then give up - not an infinite loop"
         );
     }
 
@@ -2187,13 +2274,34 @@ mod transport_retry_tests {
     #[test]
     fn a_non_transport_error_is_never_retried() {
         let calls = Cell::new(0);
-        let result: Result<(), String> = retry_once_on_transport_fault(|| {
+        let result: Result<(), String> = retry_on_transport_fault(|| {
             calls.set(calls.get() + 1);
             Err("element not found".into())
         });
         assert_eq!(result, Err("element not found".to_string()));
         assert_eq!(calls.get(), 1, "a non-transport error must not be retried");
     }
+
+    /// The wait between attempts grows (300ms, 600ms, 900ms) instead of
+    /// staying fixed - issue #608's "and/or backoff that scales" direction.
+    #[test]
+    fn backoff_grows_with_each_retry() {
+        let waits = RefCell::new(Vec::new());
+        let result: Result<(), String> = retry_on_transport_fault_with(
+            3,
+            &mut || Err("connection is closed".into()),
+            |backoff| waits.borrow_mut().push(backoff),
+        );
+        assert!(result.is_err());
+        assert_eq!(
+            waits.into_inner(),
+            vec![
+                Duration::from_millis(300),
+                Duration::from_millis(600),
+                Duration::from_millis(900),
+            ]
+        );
+    }
 }
 
 /// How a [`UiaSelector`] resolves on a page: a CSS selector or a text
@@ -2473,8 +2581,10 @@ impl WebAppDriver {
         // this talks to the tab directly, with no element to re-resolve, so
         // it never went through with_element's retry either - one transient
         // CDP hiccup here (this is the exact call `type_text`'s framed path
-        // uses for every field inside an iframe) killed the whole flow.
-        let status = retry_once_on_transport_fault(|| {
+        // uses for every field inside an iframe) killed the whole flow. A
+        // single retry was also not enough on its own (issue #608) - this
+        // is the call site that failed twice in a row live.
+        let status = retry_on_transport_fault(|| {
             self.tab()
                 .map_err(|e| e.to_string())?
                 .evaluate(&call, false)
@@ -3366,7 +3476,7 @@ impl AppDriver for WebAppDriver {
             })
             .flatten();
         let Some(resolver) = resolver else {
-            return flowproof_driver::composed_actionability_gate(self, target);
+            return self.composed_readiness(target);
         };
         let gate_js = format!(
             "(async el => {{
@@ -3402,7 +3512,7 @@ impl AppDriver for WebAppDriver {
             .map_err(|e| web_err(&format!("actionability of [{target}]"), e))?;
         let verdict = value.value.and_then(|v| v.as_str().map(str::to_string));
         Ok(match verdict.as_deref() {
-            Some("sap_grid") => return flowproof_driver::composed_actionability_gate(self, target),
+            Some("sap_grid") => return self.composed_readiness(target),
             Some("ok") => None,
             Some("disabled") => Some("disabled".into()),
             Some("unstable") => Some("unstable (still moving/animating)".into()),
@@ -3454,6 +3564,36 @@ impl AppDriver for WebAppDriver {
 
     fn element_visible(&mut self, selector: &UiaSelector) -> Result<Option<bool>, DriverError> {
         let locator = Self::locator(selector)?;
+        // A dialog can disappear between element_exists and this probe.
+        // Resolve and read in one page operation: absence is a visibility
+        // answer, while browser/transport failures must still propagate.
+        if selector.frame.is_none() {
+            if let Some(resolver) = Self::js_resolver(&locator) {
+                let expression = format!(
+                    "((element) => {{
+                        if (!element) return false;
+                        if (typeof element.checkVisibility === 'function' &&
+                            !element.checkVisibility({{
+                                contentVisibilityAuto: true,
+                                opacityProperty: true,
+                                visibilityProperty: true
+                            }})) return false;
+                        return element.getClientRects().length > 0;
+                    }})({resolver})"
+                );
+                let value = self
+                    .tab()?
+                    .evaluate(&expression, false)
+                    .map_err(|e| web_err(&format!("reading visibility of [{selector}]"), e))?;
+                return value
+                    .value
+                    .and_then(|v| v.as_bool())
+                    .map(Some)
+                    .ok_or_else(|| {
+                        DriverError::Browser("visibility probe did not return a boolean".into())
+                    });
+            }
+        }
         let value = self.with_element(
             &locator,
             &format!("reading visibility of [{selector}]"),
@@ -4165,14 +4305,14 @@ impl AppDriver for WebAppDriver {
             id = js(&query.inner_id),
             text = js(&query.inner_text),
         );
-        // ONE retry on a transport fault, same recovery `with_element` gives
+        // Retry on a transport fault, same recovery `with_element` gives
         // element-scoped calls (see medium-02-change-info-record-readonly's
         // real "probing an iframe: ... underlying connection is closed"
         // failure in docs/fiori-reliability/FINDINGS.md): this call talks to
         // the tab directly, with no element to re-resolve, so it never went
         // through that retry at all - any transient CDP hiccup here killed
         // the whole flow on the first blip, with zero chance to recover.
-        let status = retry_once_on_transport_fault(|| {
+        let status = retry_on_transport_fault(|| {
             self.tab()
                 .map_err(|e| e.to_string())?
                 .evaluate(&call, false)
@@ -4287,15 +4427,38 @@ impl AppDriver for WebAppDriver {
                     // back the accepted value before passing.
                     self.press_key("A", &[KeyMod::Ctrl])?;
                     self.press_key("Backspace", &[])?;
-                    self.tab()?
-                        .type_str(text)
-                        .map_err(|e| web_err("typing into the framed SAP field", e))?;
+                    // Talks to the tab directly, same gap frame_act had before
+                    // its own retry: confirmed live, a dropped CDP event here
+                    // failed the whole flow on a field that would have typed
+                    // fine a moment later.
+                    retry_on_transport_fault(|| {
+                        self.tab()
+                            .map_err(|e| e.to_string())?
+                            .type_str(text)
+                            .map_err(|e| e.to_string())
+                    })
+                    .map_err(|e| web_err("typing into the framed SAP field", e))?;
                     self.press_key("Tab", &[])?;
-                    std::thread::sleep(Duration::from_millis(300));
-                    let accepted = self.frame_value(&query)?;
+                    // Some SAP WebGUI fields (a material number checked
+                    // against the current plant/org, for instance) validate
+                    // against the backend on commit, and read back empty for
+                    // a moment while that round trip is in flight - not
+                    // reverted, just not settled yet. A single fixed sleep
+                    // caught that transitional empty state and failed a
+                    // field that would have read back correctly moments
+                    // later (confirmed live). Poll instead of sampling once.
+                    let deadline = std::time::Instant::now() + Duration::from_secs(2);
+                    let accepted = loop {
+                        let value = self.frame_value(&query)?;
+                        if value == text || std::time::Instant::now() >= deadline {
+                            break value;
+                        }
+                        std::thread::sleep(Duration::from_millis(200));
+                    };
                     if accepted != text {
                         return Err(DriverError::Browser(format!(
-                            "the field inside iframe '{}' accepted a different value after commit",
+                            "the field inside iframe '{}' accepted a different value after \
+                             commit: typed {text:?}, field now reads {accepted:?}",
                             query.frame
                         )));
                     }
@@ -4305,9 +4468,13 @@ impl AppDriver for WebAppDriver {
                     // it - the same click -> select -> keystrokes contract the
                     // top-level path below uses, not an append.
                     self.frame_act(&query, "select_all", serde_json::Value::Null)?;
-                    self.tab()?
-                        .type_str(text)
-                        .map_err(|e| web_err("typing into the framed field", e))?;
+                    retry_on_transport_fault(|| {
+                        self.tab()
+                            .map_err(|e| e.to_string())?
+                            .type_str(text)
+                            .map_err(|e| e.to_string())
+                    })
+                    .map_err(|e| web_err("typing into the framed field", e))?;
                     // An Escape here was tried to dismiss the value-help popup
                     // real keystrokes can trigger on classic SAP GUI screens
                     // (confirmed live), but Escape on these fields REVERTS to
@@ -4697,9 +4864,20 @@ impl AppDriver for WebAppDriver {
             "Space" | "Spacebar" => " ",
             _ => key,
         };
-        self.tab()?
-            .press_key_with_modifiers(browser_key, (!mods.is_empty()).then_some(mods.as_slice()))
-            .map_err(|e| web_err(&format!("pressing key '{key}'"), e))?;
+        // Same direct-tab gap type_text's framed path had: no element to
+        // re-resolve, so with_element's retry never covered it either -
+        // confirmed live, a dropped CDP event on a bare keypress (Tab to
+        // commit a field, Ctrl+A to select) failed the whole flow.
+        retry_on_transport_fault(|| {
+            self.tab()
+                .map_err(|e| e.to_string())?
+                .press_key_with_modifiers(
+                    browser_key,
+                    (!mods.is_empty()).then_some(mods.as_slice()),
+                )
+                .map_err(|e| e.to_string())
+        })
+        .map_err(|e| web_err(&format!("pressing key '{key}'"), e))?;
         Ok(())
     }
 

flowproof-0.23.6/crates/flowproof-adapters/tests/visibility_detach_e2e.rs

@@ -0,0 +1,77 @@
+//! Visibility must tolerate a dialog disappearing after the existence probe.
+use flowproof_driver::{AppDriver, ScopeQuery, UiaSelector};
+
+#[test]
+fn removed_element_is_not_visible_without_swallowing_browser_errors() {
+    if std::env::var("FLOWPROOF_E2E").as_deref() != Ok("1") {
+        return;
+    }
+    let _guard = flowproof_adapters::SharedBrowserGuard::new();
+    let html = "<html><body><div id='dialog'>Receipt checked</div><div id='hidden' style='display:none'>Hidden</div><button id='close' onclick=\"document.getElementById('dialog').remove()\">Close</button><div id='scope'>Scope<button id='payment' style='display:none'>Payment</button></div><button id='reveal' onclick=\"document.getElementById('payment').style.display='block'\">Reveal</button></body></html>";
+    let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("fixture listener");
+    let port = listener.local_addr().expect("fixture address").port();
+    std::thread::spawn(move || {
+        use std::io::{Read, Write};
+        for mut stream in listener.incoming().flatten() {
+            let mut request = [0; 2048];
+            let _ = stream.read(&mut request);
+            let _ = write!(stream, "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}", html.len(), html);
+        }
+    });
+    let mut driver = flowproof_adapters::WebAppDriver::new().expect("Chrome launches");
+    driver
+        .launch(
+            &format!("http://127.0.0.1:{port}"),
+            "",
+            std::time::Duration::from_secs(30),
+        )
+        .expect("fixture loads");
+    let scoped = UiaSelector {
+        scope: Some(ScopeQuery {
+            container: "css:#scope".into(),
+            anchor: "Scope".into(),
+            inner_css: Some("#payment".into()),
+            ..Default::default()
+        }),
+        ..Default::default()
+    };
+    assert!(driver
+        .actionability_gate(&scoped)
+        .expect("hidden target waits")
+        .is_some());
+    driver
+        .invoke(&UiaSelector::css("#reveal"))
+        .expect("reveal target");
+    assert!(driver
+        .actionability_gate(&scoped)
+        .expect("visible target ready")
+        .is_none());
+    let dialog = UiaSelector::css("#dialog");
+    assert!(driver.element_exists(&dialog).expect("dialog existence"));
+    assert_eq!(
+        driver.element_visible(&dialog).expect("visible dialog"),
+        Some(true)
+    );
+    assert_eq!(
+        driver
+            .element_visible(&UiaSelector::css("#hidden"))
+            .expect("hidden element visibility"),
+        Some(false)
+    );
+    driver
+        .invoke(&UiaSelector::css("#close"))
+        .expect("close dialog");
+    assert_eq!(
+        driver
+            .element_visible(&dialog)
+            .expect("removed element visibility"),
+        Some(false)
+    );
+    assert_eq!(
+        driver
+            .element_visible(&UiaSelector::css("#never-present"))
+            .expect("absent element visibility"),
+        Some(false)
+    );
+    assert!(driver.element_visible(&UiaSelector::css("[")).is_err());
+}

{flowproof-0.23.4 → flowproof-0.23.6}/crates/flowproof-agent/src/author.rs

@@ -65,7 +65,7 @@ when it already holds a value the step does not contradict.
 submit button behind mandatory fields - include the actions that supply it, then the \
 action that reaches the goal.
 - Respond with ONLY JSON, no prose, no code fences.
-- The JSON action is one of: \"click\", \"click_at\", \"drag\", \"type_text\", \
+- The JSON action is one of: \"click\", \"double_click\", \"click_at\", \"drag\", \"type_text\", \
 \"assert_text\", \"capture_text\", \"capture_count\", \"type_captured\", \
 \"select_option\", \"select_options\", \"scroll\", \"scroll_into_view\", \"press_key\", \"rule_step\", or \
 \"capture_ambiguity\".
@@ -745,14 +745,23 @@ fn ground_one(
         )));
     };
     match authored.action.as_str() {
-        "click" => {
+        "click" | "double_click" => {
             if !scene_token_is_actionable(scene, token) {
                 return Err("click target is readable but not actionable".into());
             }
-            Ok(vec![ResolvedAction::Press {
-                target,
-                label: scene_label(scene, token).unwrap_or_default(),
-                dialog: None,
+            let label = scene_label(scene, token).unwrap_or_default();
+            Ok(vec![if authored.action == "double_click" {
+                ResolvedAction::DoubleClick {
+                    target,
+                    label,
+                    dialog: None,
+                }
+            } else {
+                ResolvedAction::Press {
+                    target,
+                    label,
+                    dialog: None,
+                }
             }])
         }
         "click_at" => {
@@ -2248,6 +2257,15 @@ mod tests {
     #[test]
     fn human_language_primitives_ground_without_rules_in_the_input() {
         let cases = [
+            (
+                "Double-click task 1 to activate its editor",
+                r#"{"action":"double_click","target":"css:#task-1"}"#,
+                ResolvedAction::DoubleClick {
+                    target: Target::css("#task-1"),
+                    label: "task 1".into(),
+                    dialog: None,
+                },
+            ),
             (
                 "Drag task 1 into the todo drop area",
                 r#"{"action":"drag","target":"css:#task-1","onto":"css:#todo"}"#,

{flowproof-0.23.4 → flowproof-0.23.6}/crates/flowproof-cli/Cargo.toml

@@ -20,8 +20,10 @@ chrono = { workspace = true }
 clap = { workspace = true }
 # Cross-platform Ctrl-C handling for the long-lived `capture` listener, so a
 # deliberate interrupt exits 0 cleanly on Windows and Unix alike. Light: no
-# async runtime, just a signal handler.
-ctrlc = "3"
+# async runtime, just a signal handler. `termination` additionally catches
+# SIGTERM/SIGHUP on Unix (a plain `kill` or a CI timeout, not just Ctrl-C) -
+# see `run_cli`'s shared-browser signal handler.
+ctrlc = { version = "3", features = ["termination"] }
 # `flowproof config`'s platform config directory (plans/001-credential-config.md,
 # "Where the file lives"): a single-purpose lookup, no multi-app namespacing
 # to justify `directories`' extra structure.