flowproof 0.2.2__tar.gz → 0.2.3__tar.gz

{flowproof-0.2.2 → flowproof-0.2.3}/Cargo.lock

@@ -722,7 +722,7 @@ dependencies = [
 
 [[package]]
 name = "flowproof-adapters"
-version = "0.2.2"
+version = "0.2.3"
 dependencies = [
  "anyhow",
  "flowproof-driver",
@@ -738,7 +738,7 @@ dependencies = [
 
 [[package]]
 name = "flowproof-agent"
-version = "0.2.2"
+version = "0.2.3"
 dependencies = [
  "chrono",
  "flowproof-driver",
@@ -753,7 +753,7 @@ dependencies = [
 
 [[package]]
 name = "flowproof-cli"
-version = "0.2.2"
+version = "0.2.3"
 dependencies = [
  "ab_glyph",
  "clap",
@@ -771,7 +771,7 @@ dependencies = [
 
 [[package]]
 name = "flowproof-driver"
-version = "0.2.2"
+version = "0.2.3"
 dependencies = [
  "image",
  "postgres",
@@ -785,7 +785,7 @@ dependencies = [
 
 [[package]]
 name = "flowproof-python"
-version = "0.2.2"
+version = "0.2.3"
 dependencies = [
  "flowproof-agent",
  "flowproof-cli",
@@ -797,12 +797,13 @@ dependencies = [
 
 [[package]]
 name = "flowproof-replay"
-version = "0.2.2"
+version = "0.2.3"
 dependencies = [
  "chrono",
  "flowproof-agent",
  "flowproof-driver",
  "flowproof-trace",
+ "image",
  "serde",
  "serde_json",
  "thiserror 2.0.18",
@@ -810,7 +811,7 @@ dependencies = [
 
 [[package]]
 name = "flowproof-trace"
-version = "0.2.2"
+version = "0.2.3"
 dependencies = [
  "jsonschema",
  "serde",

{flowproof-0.2.2 → flowproof-0.2.3}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/flowproof-driver", "crates/flowproof-trace", "crates/flowproof-replay", "crates/flowproof-agent", "crates/flowproof-adapters", "crates/flowproof-cli", "crates/flowproof-python"]
 
 [workspace.package]
-version = "0.2.2"
+version = "0.2.3"
 edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/automators-com/flowproof"

{flowproof-0.2.2 → flowproof-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flowproof
-Version: 0.2.2
+Version: 0.2.3
 Classifier: Development Status :: 2 - Pre-Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3

{flowproof-0.2.2 → flowproof-0.2.3}/crates/flowproof-adapters/src/web.rs

@@ -12,7 +12,7 @@ use std::time::Duration;
 use flowproof_driver::{AppDriver, DriverError, KeyMod, PixelRect, UiaSelector, WebSession};
 use headless_chrome::browser::tab::{ModifierKey, Tab};
 use headless_chrome::protocol::cdp::Target::CreateTarget;
-use headless_chrome::protocol::cdp::{Network, Page};
+use headless_chrome::protocol::cdp::{Emulation, Input, Network, Page};
 use headless_chrome::{Browser, LaunchOptions};
 
 use crate::AdapterError;
@@ -23,10 +23,13 @@ fn web_err(context: &str, err: impl std::fmt::Display) -> DriverError {
     DriverError::Uia(format!("web: {context}: {err}"))
 }
 
-/// Launch a fresh headless Chromium (`CHROME` env var overrides the binary).
-fn launch_browser() -> Result<Browser, AdapterError> {
+/// Launch a fresh headless Chromium (`CHROME` env var overrides the
+/// binary), optionally with extra command-line flags.
+fn launch_browser(extra_args: &[String]) -> Result<Browser, AdapterError> {
+    let os_args: Vec<std::ffi::OsString> = extra_args.iter().map(Into::into).collect();
     let mut options = LaunchOptions::default_builder();
     options.headless(true).sandbox(false);
+    options.args(os_args.iter().map(AsRef::as_ref).collect());
     if let Ok(path) = std::env::var("CHROME") {
         options.path(Some(path.into()));
     }
@@ -59,7 +62,7 @@ fn shared_browser() -> Result<Browser, AdapterError> {
             return Ok(browser.clone());
         }
     }
-    let browser = launch_browser()?;
+    let browser = launch_browser(&[])?;
     let keepalive = browser
         .new_tab()
         .map_err(|e| AdapterError::Web(format!("opening keep-alive tab: {e}")))?;
@@ -78,6 +81,49 @@ pub struct WebAppDriver {
     /// Session staged via [`AppDriver::stage_session`], applied by the next
     /// `launch` before the page loads.
     staged_session: Option<WebSession>,
+    /// Recent console/log lines from the page (bounded ring buffer),
+    /// filled by a CDP event listener registered at launch — read
+    /// retroactively when a step fails ([`AppDriver::debug_bundle`]).
+    console: std::sync::Arc<std::sync::Mutex<std::collections::VecDeque<String>>>,
+    /// Network mocks staged via [`AppDriver::stage_mocks`], installed by
+    /// the next `launch` before navigation (CDP Fetch interception).
+    staged_mocks: Vec<flowproof_driver::WebMock>,
+    /// Browser config staged via [`AppDriver::stage_browser`], applied by
+    /// the next `launch`: viewport/UA per-tab; extra flags swap in a
+    /// private browser (flags only apply at process start).
+    staged_browser: Option<flowproof_driver::WebBrowserConfig>,
+}
+
+/// Cap on retained console lines — enough context for a failure, bounded
+/// so a chatty app can't balloon the run bundle.
+const CONSOLE_TAIL_CAP: usize = 100;
+
+/// Standard base64 for CDP `Fetch.fulfillRequest` bodies — hand-rolled
+/// (~15 lines) rather than pulling a crate into the adapter for one call.
+fn base64_encode(data: &[u8]) -> String {
+    const ALPHABET: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    let mut out = String::with_capacity(data.len().div_ceil(3) * 4);
+    for chunk in data.chunks(3) {
+        let b = [
+            chunk[0],
+            *chunk.get(1).unwrap_or(&0),
+            *chunk.get(2).unwrap_or(&0),
+        ];
+        let n = (u32::from(b[0]) << 16) | (u32::from(b[1]) << 8) | u32::from(b[2]);
+        out.push(ALPHABET[(n >> 18) as usize & 63] as char);
+        out.push(ALPHABET[(n >> 12) as usize & 63] as char);
+        out.push(if chunk.len() > 1 {
+            ALPHABET[(n >> 6) as usize & 63] as char
+        } else {
+            '='
+        });
+        out.push(if chunk.len() > 2 {
+            ALPHABET[n as usize & 63] as char
+        } else {
+            '='
+        });
+    }
+    out
 }
 
 impl WebAppDriver {
@@ -86,10 +132,13 @@ impl WebAppDriver {
     pub fn new() -> Result<Self, AdapterError> {
         if std::env::var_os("FLOWPROOF_NO_SHARED_BROWSER").is_some() {
             return Ok(Self {
-                browser: launch_browser()?,
+                browser: launch_browser(&[])?,
                 context_id: None,
                 tab: None,
                 staged_session: None,
+                console: Default::default(),
+                staged_mocks: Vec::new(),
+                staged_browser: None,
             });
         }
         let browser = shared_browser()?;
@@ -102,6 +151,9 @@ impl WebAppDriver {
             context_id: Some(context_id),
             tab: None,
             staged_session: None,
+            console: Default::default(),
+            staged_mocks: Vec::new(),
+            staged_browser: None,
         })
     }
 
@@ -297,11 +349,25 @@ impl std::fmt::Display for WebLocator {
 /// tried in order: (1) exact match on the element's DIRECT text nodes (its
 /// own text, so a sibling avatar's initials can never fuse with a label
 /// into "ETE2E Test Runner's Team"); (2) exact match on the concatenated
-/// subtree text (covers labels wrapped in spans); (3) and (4) the same two
-/// as prefix matches (a leading match is accepted when the accessible name
-/// carries trailing detail — catalog cards, chips like `ID: …`).
-fn text_xpaths(text: &str) -> [String; 4] {
+/// subtree text (covers labels wrapped in spans); (3) `<label>` association
+/// by the label's exact text — both the wrapping form
+/// `<label>Name: <input/></label>` and `<label for>`/`id` pairing; (4) and
+/// (5) the own-text/subtree rungs as prefix matches (a leading match is
+/// accepted when the accessible name carries trailing detail — catalog
+/// cards, chips like `ID: …`); (6) label association as a prefix match
+/// (so `Name` finds the field labelled `Name:`); (7) and (8) ASCII
+/// case-insensitive fallbacks of the exact and prefix rungs — role names
+/// are case-insensitive in Playwright, and real pages disagree with specs
+/// about capitalization ("Close Account" vs "Close account"). A
+/// case-sensitive match always wins over a case-insensitive one.
+fn text_xpaths(text: &str) -> Vec<String> {
+    const UPPER: &str = "'ABCDEFGHIJKLMNOPQRSTUVWXYZ'";
+    const LOWER: &str = "'abcdefghijklmnopqrstuvwxyz'";
     let lit = xpath_literal(text);
+    let lower_lit = xpath_literal(&text.to_ascii_lowercase());
+    let ci = |expr: &str| format!("translate({expr}, {UPPER}, {LOWER})={lower_lit}");
+    let ci_prefix =
+        |expr: &str| format!("starts-with(translate({expr}, {UPPER}, {LOWER}), {lower_lit})");
     let build = |by_text: String, by_label: String, by_placeholder: String| {
         format!(
             "//*[self::button or self::a or self::summary or @role='button' or \
@@ -311,7 +377,20 @@ fn text_xpaths(text: &str) -> [String; 4] {
              //textarea[{by_placeholder} or {by_label}]"
         )
     };
-    [
+    // Fields addressed by their <label>: the wrapping form associates by
+    // containment, the `for` form by id. XPath 1.0 node-set comparison
+    // makes `@id = //label[…]/@for` "any label whose for equals this id".
+    let by_label_assoc = |label_text: String| {
+        ["input", "textarea", "select"]
+            .map(|tag| {
+                format!(
+                    "//label[{label_text}]//{tag} | \
+                     //{tag}[@id = //label[{label_text}]/@for]"
+                )
+            })
+            .join(" | ")
+    };
+    vec![
         build(
             format!("text()[normalize-space(.)={lit}]"),
             format!("@aria-label={lit}"),
@@ -322,6 +401,7 @@ fn text_xpaths(text: &str) -> [String; 4] {
             format!("@aria-label={lit}"),
             format!("@placeholder={lit}"),
         ),
+        by_label_assoc(format!("normalize-space()={lit}")),
         build(
             format!("text()[starts-with(normalize-space(.), {lit})]"),
             format!("starts-with(@aria-label, {lit})"),
@@ -332,6 +412,25 @@ fn text_xpaths(text: &str) -> [String; 4] {
             format!("starts-with(@aria-label, {lit})"),
             format!("starts-with(@placeholder, {lit})"),
         ),
+        by_label_assoc(format!("starts-with(normalize-space(), {lit})")),
+        format!(
+            "{} | {}",
+            build(
+                ci("normalize-space()"),
+                ci("@aria-label"),
+                ci("@placeholder"),
+            ),
+            by_label_assoc(ci("normalize-space()")),
+        ),
+        format!(
+            "{} | {}",
+            build(
+                ci_prefix("normalize-space()"),
+                ci_prefix("@aria-label"),
+                ci_prefix("@placeholder"),
+            ),
+            by_label_assoc(ci_prefix("normalize-space()")),
+        ),
     ]
 }
 
@@ -368,6 +467,17 @@ impl AppDriver for WebAppDriver {
         _window_name: &str,
         _timeout: Duration,
     ) -> Result<(), DriverError> {
+        let staged_browser = self.staged_browser.take();
+        // Extra Chrome flags only apply at process start: swap in a
+        // PRIVATE browser for this flow (a plain tab on it is already
+        // isolated), paying its cold start instead of sharing.
+        if let Some(config) = &staged_browser {
+            if !config.args.is_empty() {
+                self.browser =
+                    launch_browser(&config.args).map_err(|e| DriverError::Uia(e.to_string()))?;
+                self.context_id = None;
+            }
+        }
         // On the shared browser, open the tab INSIDE this flow's isolated
         // context so its cookies/storage never touch another flow's.
         let tab = match &self.context_id {
@@ -388,9 +498,146 @@ impl AppDriver for WebAppDriver {
             None => self.browser.new_tab(),
         }
         .map_err(|e| web_err("opening tab", e))?;
+        // Viewport/UA emulation BEFORE navigation, so the app boots into
+        // the emulated device (responsive breakpoints, UA sniffing). NOT
+        // best-effort: a flow recorded mobile must never run desktop.
+        if let Some(config) = &staged_browser {
+            if let Some(vp) = &config.viewport {
+                tab.call_method(Emulation::SetDeviceMetricsOverride {
+                    width: vp.width,
+                    height: vp.height,
+                    device_scale_factor: vp.device_scale_factor,
+                    mobile: vp.mobile,
+                    scale: None,
+                    screen_width: None,
+                    screen_height: None,
+                    position_x: None,
+                    position_y: None,
+                    dont_set_visible_size: None,
+                    screen_orientation: None,
+                    viewport: None,
+                    display_feature: None,
+                    device_posture: None,
+                })
+                .map_err(|e| web_err("emulating viewport", e))?;
+                if vp.touch {
+                    tab.call_method(Emulation::SetTouchEmulationEnabled {
+                        enabled: true,
+                        max_touch_points: Some(1),
+                    })
+                    .map_err(|e| web_err("emulating touch", e))?;
+                }
+            }
+            if let Some(ua) = &config.user_agent {
+                tab.set_user_agent(ua, None, None)
+                    .map_err(|e| web_err("overriding user agent", e))?;
+            }
+        }
         if let Some(session) = self.staged_session.take() {
             Self::apply_session(&tab, &session, command)?;
         }
+        // Network mocks: install interception BEFORE navigation so even the
+        // first document's subresources are answerable. Unlike the console
+        // listener this is NOT best-effort — a mock that silently failed to
+        // install would change what the flow tests.
+        if !self.staged_mocks.is_empty() {
+            let mocks = std::mem::take(&mut self.staged_mocks);
+            tab.enable_fetch(None, None)
+                .map_err(|e| web_err("enabling network interception", e))?;
+            tab.enable_request_interception(Arc::new(
+                move |_transport: Arc<headless_chrome::browser::transport::Transport>,
+                      _session: headless_chrome::browser::transport::SessionId,
+                      event: headless_chrome::protocol::cdp::Fetch::events::RequestPausedEvent| {
+                    use headless_chrome::browser::tab::RequestPausedDecision;
+                    use headless_chrome::protocol::cdp::Fetch;
+                    let url = &event.params.request.url;
+                    let method = event.params.request.method.to_ascii_uppercase();
+                    // Mocked responses must carry permissive CORS headers:
+                    // the page's origin differs from the mocked host, and a
+                    // fulfilled response is still subject to CORS — without
+                    // them the fetch rejects and the mock looks dead.
+                    let cors = |ct: Option<&str>| {
+                        let mut headers = vec![
+                            Fetch::HeaderEntry {
+                                name: "access-control-allow-origin".into(),
+                                value: "*".into(),
+                            },
+                            Fetch::HeaderEntry {
+                                name: "access-control-allow-methods".into(),
+                                value: "*".into(),
+                            },
+                            Fetch::HeaderEntry {
+                                name: "access-control-allow-headers".into(),
+                                value: "*".into(),
+                            },
+                        ];
+                        if let Some(ct) = ct {
+                            headers.push(Fetch::HeaderEntry {
+                                name: "content-type".into(),
+                                value: ct.to_string(),
+                            });
+                        }
+                        headers
+                    };
+                    let any_match = mocks.iter().any(|m| url.contains(&m.url_contains));
+                    // CORS preflight for a mocked URL: answer it ourselves —
+                    // the real host may not even exist.
+                    if method == "OPTIONS" && any_match {
+                        return RequestPausedDecision::Fulfill(Fetch::FulfillRequest {
+                            request_id: event.params.request_id.clone(),
+                            response_code: 204,
+                            response_headers: Some(cors(None)),
+                            binary_response_headers: None,
+                            body: None,
+                            response_phrase: None,
+                        });
+                    }
+                    let rule = mocks.iter().find(|m| {
+                        url.contains(&m.url_contains)
+                            && m.method.as_ref().is_none_or(|want| *want == method)
+                    });
+                    match rule {
+                        Some(m) => RequestPausedDecision::Fulfill(Fetch::FulfillRequest {
+                            request_id: event.params.request_id.clone(),
+                            response_code: u32::from(m.status),
+                            response_headers: Some(cors(Some(&m.content_type))),
+                            binary_response_headers: None,
+                            body: Some(base64_encode(&m.body)),
+                            response_phrase: None,
+                        }),
+                        None => RequestPausedDecision::Continue(None),
+                    }
+                },
+            ))
+            .map_err(|e| web_err("installing network mocks", e))?;
+        }
+        // Console tail: subscribe BEFORE navigation so boot-time errors are
+        // captured too. Best-effort — a page without console history still
+        // yields a DOM snapshot on failure.
+        if tab.enable_log().and_then(|t| t.enable_runtime()).is_ok() {
+            let buffer = self.console.clone();
+            let listener = move |event: &headless_chrome::protocol::cdp::types::Event| {
+                use headless_chrome::protocol::cdp::types::Event;
+                let line = match event {
+                    Event::LogEntryAdded(e) => Some(format!(
+                        "[{:?}] {}",
+                        e.params.entry.level, e.params.entry.text
+                    )),
+                    Event::RuntimeExceptionThrown(e) => {
+                        Some(format!("[exception] {}", e.params.exception_details.text))
+                    }
+                    _ => None,
+                };
+                if let Some(line) = line {
+                    let mut buf = buffer.lock().unwrap_or_else(|e| e.into_inner());
+                    if buf.len() >= CONSOLE_TAIL_CAP {
+                        buf.pop_front();
+                    }
+                    buf.push_back(line);
+                }
+            };
+            tab.add_event_listener(Arc::new(listener)).ok();
+        }
         tab.navigate_to(command)
             .map_err(|e| web_err(&format!("navigating to {command}"), e))?;
         tab.wait_until_navigated()
@@ -399,10 +646,47 @@ impl AppDriver for WebAppDriver {
         Ok(())
     }
 
+    fn debug_bundle(&mut self) -> Result<Option<flowproof_driver::DebugBundle>, DriverError> {
+        // Best-effort by contract: a half-captured bundle still beats none.
+        let dom_html = self
+            .tab()
+            .ok()
+            .and_then(|tab| {
+                tab.evaluate("document.documentElement.outerHTML", false)
+                    .ok()
+            })
+            .and_then(|v| v.value)
+            .and_then(|v| v.as_str().map(str::to_string));
+        let console = self
+            .console
+            .lock()
+            .unwrap_or_else(|e| e.into_inner())
+            .iter()
+            .cloned()
+            .collect();
+        Ok(Some(flowproof_driver::DebugBundle { dom_html, console }))
+    }
+
     fn surface_text(&mut self) -> Result<String, DriverError> {
+        // Visible text PLUS the accessible names of visible elements:
+        // icon-only buttons (a command palette, an account menu) exist on
+        // the page only as aria-labels, and `page shows` must see them.
         let value = self
             .tab()?
-            .evaluate("document.body ? document.body.innerText : ''", false)
+            .evaluate(
+                r#"(() => {
+                    const text = document.body ? document.body.innerText : '';
+                    const names = [];
+                    for (const el of document.querySelectorAll('[aria-label]')) {
+                        const r = el.getBoundingClientRect();
+                        if (r.width > 0 && r.height > 0) {
+                            names.push(el.getAttribute('aria-label'));
+                        }
+                    }
+                    return names.length ? text + '\n' + names.join('\n') : text;
+                })()"#,
+                false,
+            )
             .map_err(|e| web_err("reading page text", e))?;
         Ok(value
             .value
@@ -415,6 +699,19 @@ impl AppDriver for WebAppDriver {
         Ok(())
     }
 
+    fn stage_mocks(&mut self, rules: Vec<flowproof_driver::WebMock>) -> Result<(), DriverError> {
+        self.staged_mocks = rules;
+        Ok(())
+    }
+
+    fn stage_browser(
+        &mut self,
+        config: flowproof_driver::WebBrowserConfig,
+    ) -> Result<(), DriverError> {
+        self.staged_browser = Some(config);
+        Ok(())
+    }
+
     fn navigate(&mut self, url: &str) -> Result<(), DriverError> {
         let tab = self.tab()?;
         tab.navigate_to(url)
@@ -460,6 +757,31 @@ impl AppDriver for WebAppDriver {
         Ok(value.value.and_then(|v| v.as_bool()).unwrap_or(true))
     }
 
+    fn element_receives_events(
+        &mut self,
+        selector: &UiaSelector,
+    ) -> Result<Option<bool>, DriverError> {
+        let locator = Self::locator(selector)?;
+        let value =
+            self.with_element(&locator, &format!("hit-testing [{selector}]"), |element| {
+                // Playwright's obscured check: does elementFromPoint at the
+                // element's center resolve to it (or a relative)? A toast or
+                // modal backdrop on top makes the click land elsewhere.
+                element.call_js_fn(
+                    r#"function() {
+                        const r = this.getBoundingClientRect();
+                        if (r.width === 0 || r.height === 0) { return false; }
+                        const t = document.elementFromPoint(
+                            r.x + r.width / 2, r.y + r.height / 2);
+                        return !!(t && (t === this || this.contains(t) || t.contains(this)));
+                    }"#,
+                    vec![],
+                    false,
+                )
+            })?;
+        Ok(value.value.and_then(|v| v.as_bool()))
+    }
+
     fn invoke(&mut self, selector: &UiaSelector) -> Result<(), DriverError> {
         let locator = Self::locator(selector)?;
         self.with_element(&locator, &format!("clicking [{selector}]"), |element| {
@@ -467,6 +789,64 @@ impl AppDriver for WebAppDriver {
         })
     }
 
+    fn set_files(&mut self, selector: &UiaSelector, paths: &[String]) -> Result<(), DriverError> {
+        // Absolute paths: Chrome resolves DOM.setFileInputFiles against ITS
+        // working directory, not ours — canonicalize (which also fails
+        // loudly on a missing file, before the step "passes" emptily).
+        let mut absolute = Vec::with_capacity(paths.len());
+        for path in paths {
+            let canonical = std::fs::canonicalize(path)
+                .map_err(|e| web_err(&format!("upload file '{path}'"), e))?;
+            absolute.push(canonical.to_string_lossy().into_owned());
+        }
+        let locator = Self::locator(selector)?;
+        self.with_element(
+            &locator,
+            &format!("setting files on [{selector}]"),
+            |element| {
+                let refs: Vec<&str> = absolute.iter().map(String::as_str).collect();
+                element.set_input_files(&refs).map(|_| ())
+            },
+        )
+    }
+
+    fn context_click(&mut self, selector: &UiaSelector) -> Result<(), DriverError> {
+        let locator = Self::locator(selector)?;
+        let tab = self.tab()?.clone();
+        self.with_element(
+            &locator,
+            &format!("right-clicking [{selector}]"),
+            |element| {
+                element.scroll_into_view()?;
+                let point = element.get_midpoint()?;
+                for kind in [
+                    Input::DispatchMouseEventTypeOption::MousePressed,
+                    Input::DispatchMouseEventTypeOption::MouseReleased,
+                ] {
+                    tab.call_method(Input::DispatchMouseEvent {
+                        Type: kind,
+                        x: point.x,
+                        y: point.y,
+                        button: Some(Input::MouseButton::Right),
+                        click_count: Some(1),
+                        modifiers: None,
+                        timestamp: None,
+                        buttons: None,
+                        force: None,
+                        tangential_pressure: None,
+                        tilt_x: None,
+                        tilt_y: None,
+                        twist: None,
+                        delta_x: None,
+                        delta_y: None,
+                        pointer_Type: None,
+                    })?;
+                }
+                Ok(())
+            },
+        )
+    }
+
     fn read_text(&mut self, selector: &UiaSelector) -> Result<String, DriverError> {
         let locator = Self::locator(selector)?;
         // Inner text covers most elements; inputs expose their VALUE — the
@@ -680,3 +1060,49 @@ impl AppDriver for WebAppDriver {
         Ok(rects)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn text_xpath_ladder_orders_exact_label_prefix_then_case_insensitive() {
+        let rungs = super::text_xpaths("Close Account");
+        assert_eq!(rungs.len(), 8);
+        // Rung 1: exact own-text — unchanged from the original ladder.
+        assert!(rungs[0].contains("text()[normalize-space(.)='Close Account']"));
+        // Rung 3: label association — wrapping form and for/id pairing.
+        assert!(rungs[2].contains("//label[normalize-space()='Close Account']//input"));
+        assert!(rungs[2].contains("//input[@id = //label[normalize-space()='Close Account']/@for]"));
+        assert!(rungs[2].contains("//select"));
+        // Rung 6: label prefix — `Name` finds the field labelled `Name:`.
+        assert!(rungs[5].contains("starts-with(normalize-space(), 'Close Account')"));
+        // Rungs 7-8: case-insensitive fallbacks compare lowercased text.
+        assert!(rungs[6].contains("translate(normalize-space(), 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz')='close account'"));
+        assert!(rungs[6].contains("translate(@aria-label"));
+        assert!(rungs[7].contains("starts-with(translate(normalize-space()"));
+        // No case-sensitive rung mentions translate: exact always wins.
+        for rung in &rungs[..6] {
+            assert!(
+                !rung.contains("translate("),
+                "case-sensitive rung uses translate: {rung}"
+            );
+        }
+    }
+
+    #[test]
+    fn base64_matches_the_standard_alphabet_and_padding() {
+        // RFC 4648 vectors.
+        for (input, want) in [
+            (&b""[..], ""),
+            (b"f", "Zg=="),
+            (b"fo", "Zm8="),
+            (b"foo", "Zm9v"),
+            (b"foob", "Zm9vYg=="),
+            (b"fooba", "Zm9vYmE="),
+            (b"foobar", "Zm9vYmFy"),
+        ] {
+            assert_eq!(super::base64_encode(input), want);
+        }
+        // Binary-safe (high bytes map into +/ territory).
+        assert_eq!(super::base64_encode(&[0xfb, 0xff, 0xfe]), "+//+");
+    }
+}

{flowproof-0.2.2 → flowproof-0.2.3}/crates/flowproof-agent/src/lib.rs

@@ -15,7 +15,9 @@ pub mod spec;
 pub use clarify::{Clarification, ClarifyStage};
 pub use heal::{heal, heal_with_author, HealError, HealReport};
 pub use llm::{HttpModelClient, ModelClient};
-pub use recorder::{record, record_with_author, Author, RecordError, RecordSummary};
+pub use recorder::{
+    record, record_incremental, record_with_author, Author, RecordError, RecordSummary,
+};
 pub use spec::{FlowSpec, SpecStep, SuiteManifest};
 
 use std::env;