SOLIDWORKS Bridge

@@ -6,7 +6,7 @@ user-invocable: true  Parent skill: **solidworks-bridge** -Every line below is marked **[measured]** (seen on a real machine, 2026-10-02) or+Every line below is marked **[measured]** (seen on a real machine, 2026-10-02 to 2026-10-12) or **[unmeasured]** (not seen yet — treat as a guess and read the window first).  ## When the window appears@@ -26,6 +26,11 @@ Every line below is marked **[measured]** (seen on a real machine, 2026-10-02) o   desktop shortcut created from the Platform"). Started through its platform   shortcut (`swx_start {app:"visualize"}`, 2026-10-05) while the 3DEXPERIENCE   Launcher already held the session, it raised no login at all.+- [measured] After a week away (2026-10-12) the platform session had lapsed.+  Starting Visualize through its shortcut started `SWXDesktopUpdate.exe` (from+  `%TEMP%\SWXDesktopUpdate\`) the same second, and THAT showed the sign-in;+  Visualize itself did not start until the sign-in was done. Any app start can+  be parked behind it.  ## Finding the window @@ -34,8 +39,51 @@ Every line below is marked **[measured]** (seen on a real machine, 2026-10-02) o   Systèmes", owned by SWXDesktopLauncher.exe. - [measured] Visualize shows the same web page in a WinForms window: title   "Login - 3DEXPERIENCE ID - Dassault Systemes", 968x968.-- Find it by a title containing "3DEXPERIENCE ID". `swx_status` reports-  `waitingOn: "userSignIn"` and `signInWindow` while the launcher's window is up.+- [measured] A THIRD host: `SWXDesktopUpdate.exe`, the platform updater. Title+  just "3DEXPERIENCE" (no "ID", no "Login"), class+  `WindowsForms10.Window.8.app.0.30495d1_r6_ad1`, UIA automationId+  `SWXDesktopUpdateForm`. Same web page ("Welcome to the 3DEXPERIENCE platform",+  "Email or username", "Continue"), and no cookie banner, only a "Manage+  cookies" link at the bottom right.+- FIND IT BY CONTENT, not by title. A window that contains an Edit "Email or+  username" (page 1) or an Edit "Password" (page 2) is a 3DEXPERIENCE ID login,+  whatever its title, class or owner. The two titles above are only shortcuts.+  `swx_status` reports `waitingOn: "userSignIn"` and+  `signInWindow {hwnd, title, ownerImage, host, recognizedBy}` (host is+  `solidworks`, `visualize` or `desktopUpdate`) while any of them is up.++## When the tree shows only the frame++- [measured] On the SWXDesktopUpdate host, `desktop_ui_tree` returned 14 nodes+  (Window, MenuBar, Minimize/Maximize/Close), even with maxNodes 600 and depth+  40, and even after a `desktop_ui_from_point` wake. The page is not in it.+- [measured] `desktop_find_control {hwnd, ...}` DOES reach the page. Page 1:+  `{automationId:"username"}` or `{role:"Edit", name:"Email or username"}` gives+  the Edit (settable:true); `{role:"Button", name:"Continue"}` gives the button+  (invokable:true).+- [measured] Page 2: Edit `username` (prefilled); Edit `password` whose NAME is+  "Password " plus an icon glyph, so `{role:"Edit", name:"Password "}` does NOT+  match it and `{automationId:"password"}` does; Text "Password" (its label);+  Text "Remember me" (no CheckBox found by name); Button "Log in"; Button+  "Back".+- [measured] `{role:"Edit"}` with no name matched "Address and search bar"+  (view_1012), a control somewhere else entirely. Never query a role alone.+  Look up by automation id first, then role and exact name, then role and+  name-contains, and check the match's role and id or name before using it.+- [measured] `desktop_ui_set {hwnd, automationId:"username", text}` WORKS on this+  host (ValuePattern accepted), unlike the Visualize host. But the first set+  left the user name followed by a stray "s". Set "" first, then the value.+  That fixed it.+- [measured] `desktop_find_control`'s reply carries NO `value`, and the tree has+  no page, so on this host the user name cannot be read back. `swx_sign_in`+  says `readBack: "unreadable"` in its steps rather than claiming a match.+- [measured] `desktop_ui_click {hwnd, name:"Continue"}` (background Invoke)+  moved to page 2.+- [unmeasured] Whether "Remember me" can be read once clicked here. The bridge+  clicks the label (only while the user is idle, with the window in front) and+  reports `rememberTicked: null`.+- [unmeasured] What this host shows after "Log in": a wrong password or a+  second step. Read it; never retry.  ## The flow @@ -116,7 +164,10 @@ wiki page, a log line or a chat message.  `swx_sign_in` is the path: it does every step above, in order, and fails closed with a reason when it cannot. For a login window the bridge's own launch did not-raise (SOLIDWORKS Visualize's, or one already up), pass `userAuthorized:true` —-only on the user's say-so — and `window:"visualize"` or `"solidworks"` (or the-window handle) when more than one is open; the reply names the process that-owns the window.+raise (SOLIDWORKS Visualize's, the platform updater's, or one already up), pass+`userAuthorized:true` (only on the user's say-so) and `window:"visualize"`,+`"solidworks"`, `"desktopUpdate"` or the window handle when more than one is+open; the reply names the process that owns the window. A window handle the+user names is checked by its content and never refused because a census missed+it. If it has neither field, the reply is `sign_in_window_not_a_login` with+what was found.

@@ -152,6 +152,11 @@ pub struct Element {     /// Screen centre — ab's own `rect.centerX/centerY` when it gives them     /// (MEASURED 2026-10-02: click there, in screen px).     pub center: Option<(i64, i64)>,+    /// LOCATED BY `desktop_find_control`, not read from the tree (0.9.23): the+    /// SWXDesktopUpdate-hosted login's tree holds only the frame (measured+    /// 2026-10-12, 14 nodes), so its controls are found one by one by name /+    /// automation id. Such an element is targeted by its automation id.+    pub by_find: bool, }  impl Element {@@ -160,11 +165,16 @@ impl Element {     pub fn offscreen(&self) -> bool {         self.center.map(|(x, y)| x < -1000 || y < -1000).unwrap_or(false)     }+    /// Off-screen, or a zero-size rectangle (a hidden input a find can still+    /// match). Never a page's field.+    pub fn hidden(&self) -> bool {+        self.offscreen() || self.rect.map(|[_, _, w, h]| w <= 0 || h <= 0).unwrap_or(false)+    } }  impl Element {     pub fn to_json(&self) -> Value {-        json!({+        let mut v = json!({             "controlType": self.control_type,             "name": self.name,             "automationId": self.automation_id,@@ -173,7 +183,11 @@ impl Element {             "enabled": self.enabled,             "invokable": self.invokable,             "settable": self.settable,-        })+        });+        if self.by_find {+            v["locatedBy"] = json!("desktop_find_control");+        }+        v     }     fn is(&self, t: &str) -> bool {         self.control_type == t@@ -195,6 +209,41 @@ fn str_of(m: &serde_json::Map<String, Value>, keys: &[&str]) -> String {     keys.iter().find_map(|k| m.get(*k).and_then(|v| v.as_str())).unwrap_or("").to_string() } +/// One element from one ab node (a tree node or a find_control match) — its+/// SHAPE, never its value.+fn element_of(m: &serde_json::Map<String, Value>) -> Option<Element> {+    let ty = str_of(m, &["controlType", "control_type", "role", "type", "localizedControlType"]);+    if ty.is_empty() || !(m.contains_key("name") || m.contains_key("automationId") || m.contains_key("automation_id")) {+        return None;+    }+    let mut e = Element {+        control_type: norm_type(&ty),+        name: str_of(m, &["name"]),+        automation_id: str_of(m, &["automationId", "automation_id", "id"]),+        is_password: m.get("isPassword").or_else(|| m.get("is_password")).and_then(|x| x.as_bool()),+        toggle_state: m+            .get("toggleState")+            .or_else(|| m.get("toggle_state"))+            .or_else(|| m.get("checked"))+            .map(|x| x.as_str().map(String::from).unwrap_or_else(|| x.to_string())),+        enabled: m.get("isEnabled").or_else(|| m.get("enabled")).and_then(|x| x.as_bool()),+        invokable: m.get("invokable").and_then(|x| x.as_bool()),+        settable: m.get("settable").and_then(|x| x.as_bool()),+        rect: m.get("rect").and_then(rect_xywh),+        center: m.get("rect").and_then(rect_center),+        by_find: false,+    };+    // THE PASSWORD FIELD (MEASURED 2026-10-02: ab's nodes carry no+    // `isPassword` key): an explicit password flag, OR an edit whose name /+    // automation id says password.+    if e.control_type == "edit" && e.is_password.is_none() {+        let flag = m.get("password").and_then(|x| x.as_bool());+        let named = looks_like_password(&e.name) || looks_like_password(&e.automation_id);+        e.is_password = Some(flag == Some(true) || named);+    }+    Some(e)+}+ /// Every element in ab's tree reply, depth first. Lenient about the reply's /// shape (it has not been measured) and STRICT about what is copied: type, /// name, automation id, IsPassword, toggle state, enabled — never a value.@@ -203,34 +252,8 @@ pub fn parse_inventory(reply: &Value) -> Vec<Element> {         match v {             Value::Array(a) => a.iter().for_each(|x| walk(x, out)),             Value::Object(m) => {-                let ty = str_of(m, &["controlType", "control_type", "role", "type", "localizedControlType"]);-                if !ty.is_empty() && (m.contains_key("name") || m.contains_key("automationId") || m.contains_key("automation_id")) {-                    out.push(Element {-                        control_type: norm_type(&ty),-                        name: str_of(m, &["name"]),-                        automation_id: str_of(m, &["automationId", "automation_id", "id"]),-                        is_password: m.get("isPassword").or_else(|| m.get("is_password")).and_then(|x| x.as_bool()),-                        toggle_state: m-                            .get("toggleState")-                            .or_else(|| m.get("toggle_state"))-                            .or_else(|| m.get("checked"))-                            .map(|x| x.as_str().map(String::from).unwrap_or_else(|| x.to_string())),-                        enabled: m.get("isEnabled").or_else(|| m.get("enabled")).and_then(|x| x.as_bool()),-                        invokable: m.get("invokable").and_then(|x| x.as_bool()),-                        settable: m.get("settable").and_then(|x| x.as_bool()),-                        rect: m.get("rect").and_then(rect_xywh),-                        center: m.get("rect").and_then(rect_center),-                    });-                    // THE PASSWORD FIELD (MEASURED 2026-10-02: ab's nodes carry no-                    // `isPassword` key): an explicit password flag, OR an edit-                    // whose name / automation id says password.-                    if let Some(last) = out.last_mut() {-                        if last.control_type == "edit" && last.is_password.is_none() {-                            let flag = m.get("password").and_then(|x| x.as_bool());-                            let named = looks_like_password(&last.name) || looks_like_password(&last.automation_id);-                            last.is_password = Some(flag == Some(true) || named);-                        }-                    }+                if let Some(e) = element_of(m) {+                    out.push(e);                 }                 for (k, x) in m {                     if matches!(k.as_str(), "children" | "elements" | "nodes" | "tree" | "root" | "items" | "controls") {@@ -368,6 +391,284 @@ pub fn inventory_json(inv: &[Element]) -> Value {     json!(inv.iter().map(|e| e.to_json()).collect::<Vec<_>>()) } +// ── the page the tree does not show: desktop_find_control (0.9.23) ──────────+//+// MEASURED 2026-10-12 on adom_drew2: a THIRD login host — a window titled just+// "3DEXPERIENCE", class `WindowsForms10.Window.8.app.0.30495d1_r6_ad1`, UIA+// automationId `SWXDesktopUpdateForm`, owned by `SWXDesktopUpdate.exe` running+// from %TEMP%\SWXDesktopUpdate\ (started the moment the platform shortcut was+// invoked). Its content is the same 3DEXPERIENCE ID sign-in, but+// `desktop_ui_tree` returns only the frame (14 nodes: Window, MenuBar,+// Minimize/Maximize/Close) even at maxNodes 600 / depth 40 and after a+// `desktop_ui_from_point` wake. `desktop_find_control` DOES reach the page:+//   page 1: Edit automationId "username" (name "Email or username",+//           settable:true), Button "Continue" (invokable);+//   page 2: Edit "username" (prefilled), Edit automationId "password" whose+//           NAME is "Password " + a private-use icon glyph (an exact-name query+//           does NOT match it; `{automationId:"password"}` does), Text+//           "Password", Text "Remember me" (no CheckBox found by name),+//           Button "Log in", Button "Back".+//   `{role:"Edit"}` with no name matched "Address and search bar" (view_1012)+//   somewhere else entirely — so a query NEVER goes out with a role alone.+// So a control is located by automation id first, then by role + exact name,+// then by role + name-contains, and a match is accepted only if its role and+// its id or (cleaned) name say it is the control asked for.++/// One control to look for: its role, its automation id (if known), its name.+pub struct Want {+    pub role: &'static str,+    pub automation_id: Option<&'static str>,+    pub name: &'static str,+}++const PAGE_WANTS: &[Want] = &[+    Want { role: "Edit", automation_id: Some("username"), name: "Email or username" },+    Want { role: "Edit", automation_id: Some("password"), name: "Password" },+    Want { role: "Button", automation_id: None, name: "Continue" },+    Want { role: "Button", automation_id: None, name: "Log in" },+    Want { role: "Button", automation_id: None, name: "Back" },+    Want { role: "CheckBox", automation_id: None, name: "Remember me" },+    Want { role: "Text", automation_id: None, name: "Remember me" },+    Want { role: "Button", automation_id: None, name: "Accept All" },+    Want { role: "Button", automation_id: None, name: "Manage my preferences" },+];++/// Lower case, letters/digits/spaces only, trimmed — "Password \u{e9a0}" and+/// "Remember me…" compare as "password" and "remember me".+fn clean(s: &str) -> String {+    let t: String = s.chars().filter(|c| c.is_ascii_alphanumeric() || *c == ' ').collect::<String>().to_lowercase();+    t.split_whitespace().collect::<Vec<_>>().join(" ")+}++/// Every element-like object anywhere in a find_control reply.+fn found_elements(reply: &Value) -> Vec<Element> {+    fn walk(v: &Value, out: &mut Vec<Element>) {+        match v {+            Value::Array(a) => a.iter().for_each(|x| walk(x, out)),+            Value::Object(m) => {+                if let Some(e) = element_of(m) {+                    out.push(e);+                }+                m.values().for_each(|x| walk(x, out));+            }+            _ => {}+        }+    }+    let mut out = Vec::new();+    if !ab_ok(reply) {+        return out;+    }+    let top = unwrap_ab(reply);+    if top.get("found").and_then(|f| f.as_bool()) == Some(false) {+        return out;+    }+    walk(&top, &mut out);+    out+}++/// Is `e` the control `w` asks for?+fn is_wanted(e: &Element, w: &Want) -> bool {+    if e.control_type != norm_type(w.role) {+        return false;+    }+    if let Some(id) = w.automation_id {+        if e.automation_id.eq_ignore_ascii_case(id) {+            return true;+        }+    }+    let (n, want) = (clean(&e.name), clean(w.name));+    !want.is_empty() && (n == want || n.starts_with(&want))+}++/// LOCATE ONE CONTROL by `desktop_find_control`: automation id, then role ++/// name, then role + name-contains. Never a role alone. Each attempt is+/// returned (the query and what came back), for the reply.+pub fn find_one(hwnd: i64, w: &Want) -> (Option<Element>, Vec<Value>) {+    let mut queries: Vec<Value> = Vec::new();+    if let Some(id) = w.automation_id {+        queries.push(json!({"hwnd": hwnd, "automationId": id}));+    }+    queries.push(json!({"hwnd": hwnd, "role": w.role, "name": w.name}));+    queries.push(json!({"hwnd": hwnd, "role": w.role, "contains": w.name}));+    let mut tried = Vec::new();+    for q in queries {+        let r = crate::caller::ad_callback("desktop_find_control", q.clone(), Duration::from_secs(20));+        let hit = found_elements(&r).into_iter().find(|e| is_wanted(e, w));+        let mut q_report = q.clone();+        if let Value::Object(m) = &mut q_report {+            m.remove("hwnd");+        }+        tried.push(json!({"query": q_report, "matched": hit.as_ref().map(|e| e.to_json())}));+        if let Some(mut e) = hit {+            e.by_find = true;+            if e.control_type == "edit" && w.automation_id == Some("password") {+                e.is_password = Some(true);+            }+            return (Some(e), tried);+        }+    }+    (None, tried)+}++/// The page, control by control. Off-screen edits (a hidden input) are not+/// the page's fields.+pub fn read_by_find(hwnd: i64) -> (Vec<Element>, Value) {+    let mut els: Vec<Element> = Vec::new();+    let mut report = serde_json::Map::new();+    for w in PAGE_WANTS {+        let (hit, _tried) = find_one(hwnd, w);+        let key = format!("{} \"{}\"", w.role, w.name);+        match hit {+            Some(e) if !(e.control_type == "edit" && e.hidden()) => {+                report.insert(key, json!({"found": true, "name": e.name, "automationId": e.automation_id,+                                          "center": e.center.map(|(x, y)| json!([x, y])), "settable": e.settable, "invokable": e.invokable}));+                if !els.iter().any(|x| x.control_type == e.control_type && x.name == e.name && x.automation_id == e.automation_id) {+                    els.push(e);+                }+            }+            _ => {+                report.insert(key, json!({"found": false}));+            }+        }+    }+    (els, Value::Object(report))+}++/// IS THIS WINDOW A 3DEXPERIENCE ID LOGIN, BY ITS CONTENT? An Edit+/// "Email or username" (page 1) or "Password" (page 2) found in it. Some(1|2)+/// = the page; None = neither field. Needs ab.+pub fn probe_login(hwnd: i64) -> Option<u8> {+    if !crate::caller::ab_available() {+        return None;+    }+    let (pw, _) = find_one(hwnd, &PAGE_WANTS[1]);+    if pw.filter(|e| !e.hidden()).is_some() {+        return Some(2);+    }+    let (user, _) = find_one(hwnd, &PAGE_WANTS[0]);+    user.filter(|e| !e.hidden()).map(|_| 1)+}++static PROBES: std::sync::Mutex<Option<std::collections::HashMap<i64, (std::time::Instant, Option<u8>)>>> = std::sync::Mutex::new(None);++fn probe_ttl() -> Duration {+    Duration::from_millis(std::env::var("SWX_SIGN_IN_PROBE_TTL_MS").ok().and_then(|v| v.trim().parse().ok()).unwrap_or(3000))+}++/// `probe_login`, remembered for a few seconds per window (a census runs on+/// every swx_status and every launch poll).+pub fn probe_login_cached(hwnd: i64) -> Option<u8> {+    if let Some((at, v)) = PROBES.lock().unwrap_or_else(|e| e.into_inner()).as_ref().and_then(|m| m.get(&hwnd).cloned()) {+        if at.elapsed() < probe_ttl() {+            return v;+        }+    }+    let v = probe_login(hwnd);+    PROBES.lock().unwrap_or_else(|e| e.into_inner()).get_or_insert_with(Default::default).insert(hwnd, (std::time::Instant::now(), v));+    v+}++/// The platform's updater, which hosts the third login (measured 2026-10-12).+pub const DESKTOP_UPDATE_IMAGE: &str = "SWXDesktopUpdate.exe";++/// Worth a content probe? Visible, titled, and not a window the probe would be+/// wasted on: SOLIDWORKS's own (its login is hosted by the launcher) and+/// Visualize's main window (its dialogs are classified by their words).+pub fn probe_eligible(image: &str, w: &crate::launchos::WindowInfo) -> bool {+    w.visible+        && !w.title.trim().is_empty()+        && !image.eq_ignore_ascii_case("SLDWORKS.exe")+        && !SHELLS.iter().any(|s| image.eq_ignore_ascii_case(s))+        && !w.class_name.to_ascii_lowercase().starts_with("hwndwrapper[sldworksvisualize.exe;")+}++/// Is this window a login: by its class / title (the fast path) or by its+/// CONTENT? `Some("titleOrClass" | "content")`.+pub fn window_is_login(image: &str, w: &crate::launchos::WindowInfo) -> Option<(&'static str, Option<u8>)> {+    if !w.visible {+        return None;+    }+    if crate::launch::is_sign_in_window(&w.class_name, &w.title) {+        return Some(("titleOrClass", None));+    }+    if probe_eligible(image, w) {+        if let Some(page) = probe_login_cached(w.hwnd) {+            return Some(("content", Some(page)));+        }+    }+    None+}++/// A login window hosted by SWXDesktopUpdate.exe, anywhere on the machine —+/// the platform's own sign-in, which parks every app start behind it.+pub fn desktop_update_login(os: &dyn crate::launchos::LaunchOs) -> Option<(i64, String)> {+    let census = os.processes().ok()?;+    for p in census.iter().filter(|p| p.image.eq_ignore_ascii_case(DESKTOP_UPDATE_IMAGE)) {+        if let Ok(ws) = os.windows_of_pid(p.pid) {+            if let Some(w) = ws.iter().find(|w| window_is_login(&p.image, w).is_some()) {+                return Some((w.hwnd, w.title.clone()));+            }+        }+    }+    None+}++/// The tree holds no page for this window (remembered so the next read skips+/// the wakes that never help on this host).+static TREE_BLIND: std::sync::Mutex<Vec<i64>> = std::sync::Mutex::new(Vec::new());++/// A page, read: from the tree when the tree shows it, otherwise control by+/// control through desktop_find_control.+pub struct Page {+    pub elements: Vec<Element>,+    pub source: &'static str,+    pub wake: Value,+    pub found: Value,+}++impl Page {+    pub fn report(&self) -> Value {+        json!({"source": self.source, "wake": self.wake, "findControl": self.found})+    }+}++/// READ THE LOGIN PAGE — the tree first; when the tree has no text field (the+/// SWXDesktopUpdate host, measured), `desktop_find_control` by name.+pub fn read_page(hwnd: i64) -> Result<Page, String> {+    let blind = TREE_BLIND.lock().unwrap_or_else(|e| e.into_inner()).contains(&hwnd);+    let tree: Result<(Vec<Element>, Value), String> = if blind {+        if !crate::caller::ab_available() {+            Err("ab's direct API is not available to this bridge (it was not spawned by Adom Bridge)".into())+        } else {+            read_once(hwnd).map(|(e, n, _)| (e, json!({"nodeCounts": [n], "wakes": 0, "treeBlind": true})))+        }+    } else {+        inventory(hwnd).map(|r| (r.elements.clone(), r.wake_json()))+    };+    if let Ok((els, wake)) = &tree {+        if els.iter().any(|e| e.is("edit")) || has_marker(els, SECOND_STEP).is_some() || has_marker(els, REJECTED).is_some() {+            return Ok(Page { elements: els.clone(), source: "tree", wake: wake.clone(), found: Value::Null });+        }+    }+    if !crate::caller::ab_available() {+        return tree.map(|(e, w)| Page { elements: e, source: "tree", wake: w, found: Value::Null });+    }+    let (found, report) = read_by_find(hwnd);+    if found.iter().any(|e| e.is("edit")) {+        let mut b = TREE_BLIND.lock().unwrap_or_else(|e| e.into_inner());+        if !b.contains(&hwnd) {+            b.push(hwnd);+        }+        let wake = tree.as_ref().map(|(_, w)| w.clone()).unwrap_or(Value::Null);+        return Ok(Page { elements: found, source: "desktop_find_control", wake, found: report });+    }+    match tree {+        Ok((e, w)) => Ok(Page { elements: e, source: "tree", wake: w, found: report }),+        Err(e) if !found.is_empty() => Ok(Page { elements: found, source: "desktop_find_control", wake: json!({"treeError": e}), found: report }),+        Err(e) => Err(e),+    }+}+ // ── what the window is asking ───────────────────────────────────────────────  const SECOND_STEP: &[&str] = &[@@ -491,6 +792,17 @@ pub fn recognize(inv: &[Element]) -> (Reading, Option<Form>) { /// with no name answers "control found but has NO InvokePattern"). The /// automation id is sent too, as a reported field — never relied on. fn target(e: &Element, role: &str) -> Value {+    // LOCATED BY find_control (0.9.23): by automation id when it has one —+    // MEASURED 2026-10-12: `desktop_ui_set {hwnd, automationId:"username",+    // text}` works on the SWXDesktopUpdate host, and the password edit's NAME+    // ("Password " + an icon glyph) does not match an exact-name query.+    if e.by_find && !e.automation_id.is_empty() {+        return json!({"automationId": e.automation_id});+    }+    if e.by_find {+        let _ = role;+        return json!({"name": e.name});+    }     json!({         "name": e.name,         "contains": e.name,@@ -711,13 +1023,29 @@ pub struct LoginWindow {     pub owner_image: String,     /// Owned by a process of THIS bridge's launch chain.     pub ours: bool,+    /// How it was recognised: "titleOrClass" (the fast path) or "content" (an+    /// Edit "Email or username" / "Password" found in it — 0.9.23).+    pub found_by: &'static str,+    /// The page a content probe saw (1 = user name, 2 = password).+    pub page: Option<u8>, }  impl LoginWindow {+    pub fn host(&self) -> &'static str {+        if self.owner_image.eq_ignore_ascii_case("SLDWORKSVisualize.exe") {+            "visualize"+        } else if self.owner_image.eq_ignore_ascii_case(DESKTOP_UPDATE_IMAGE) {+            "desktopUpdate"+        } else if self.owner_image.is_empty() {+            "unknown"+        } else {+            "solidworks"+        }+    }     pub fn to_json(&self) -> Value {         json!({"hwnd": self.hwnd, "title": self.title, "ownerPid": self.owner_pid,                "ownerImage": self.owner_image, "ownedByThisBridgesLaunch": self.ours,-               "host": if self.owner_image.eq_ignore_ascii_case("SLDWORKSVisualize.exe") { "visualize" } else { "solidworks" }})+               "host": self.host(), "recognizedBy": self.found_by, "page": self.page})     } } @@ -736,6 +1064,18 @@ pub fn login_windows(os: &dyn crate::launchos::LaunchOs, all: bool) -> Result<Ve     for p in &ours {         candidates.push((*p, image_of(*p), true));     }+    // THE PLATFORM UPDATER (0.9.23): SWXDesktopUpdate.exe starts the moment a+    // platform shortcut is invoked (measured 2026-10-12) and is not a child the+    // chain census links. One started at or after THIS bridge's invoke, while+    // its launch is in flight, is that launch's.+    if let (Some(a), Ok(c)) = (crate::launch::attempt().filter(|a| !a.finished), &census) {+        for p in c.iter().filter(|p| p.image.eq_ignore_ascii_case(DESKTOP_UPDATE_IMAGE)) {+            let since_invoke = p.created_at.map(|t| t + 2 >= a.invoked_at).unwrap_or(false);+            if since_invoke && !candidates.iter().any(|(q, _, _)| *q == p.pid) {+                candidates.push((p.pid, p.image.clone(), true));+            }+        }+    }     if all {         match &census {             Ok(c) => {@@ -754,9 +1094,12 @@ pub fn login_windows(os: &dyn crate::launchos::LaunchOs, all: bool) -> Result<Ve     for (pid, image, is_ours) in candidates {         if let Ok(ws) = os.windows_of_pid(pid) {             read_any = true;-            for w in ws.iter().filter(|w| w.visible && crate::launch::is_sign_in_window(&w.class_name, &w.title)) {-                if !out.iter().any(|o| o.hwnd == w.hwnd) {-                    out.push(LoginWindow { hwnd: w.hwnd, title: w.title.clone(), owner_pid: pid, owner_image: image.clone(), ours: is_ours });+            for w in ws.iter() {+                if out.iter().any(|o| o.hwnd == w.hwnd) {+                    continue;+                }+                if let Some((how, page)) = window_is_login(&image, w) {+                    out.push(LoginWindow { hwnd: w.hwnd, title: w.title.clone(), owner_pid: pid, owner_image: image.clone(), ours: is_ours, found_by: how, page });                 }             }         }@@ -772,9 +1115,54 @@ pub fn login_windows(os: &dyn crate::launchos::LaunchOs, all: bool) -> Result<Ve  /// Is that login window still up? `None` = cannot tell. fn still_up(os: &dyn crate::launchos::LaunchOs, lw: &LoginWindow) -> Option<bool> {+    if lw.owner_pid == 0 {+        // A window the census does not hold (named by the caller): ab's list.+        return crate::abwin::list_windows(Duration::from_secs(10))+            .ok()+            .map(|ws| ws.iter().any(|w| w.get("hwnd").and_then(|h| h.as_i64()) == Some(lw.hwnd)));+    }     os.windows_of_pid(lw.owner_pid).ok().map(|ws| ws.iter().any(|w| w.hwnd == lw.hwnd && w.visible)) } +/// THE WINDOW THE CALLER NAMED, when no census holds it as a login (0.9.23).+/// MEASURED 2026-10-12: `swx_sign_in {userAuthorized:true, window:857684}`+/// was refused "no 3DEXPERIENCE ID login window matching the request" while+/// that window WAS the sign-in (SWXDesktopUpdate.exe, title "3DEXPERIENCE").+/// A named window is judged by its CONTENT; refused only when neither field is+/// in it, with what was found.+fn named_window(os: &dyn crate::launchos::LaunchOs, hwnd: i64) -> Result<LoginWindow, Value> {+    let (found, report) = read_by_find(hwnd);+    let user = found.iter().any(|e| e.is("edit") && is_wanted(e, &PAGE_WANTS[0]));+    let pass = found.iter().any(|e| e.is("edit") && is_wanted(e, &PAGE_WANTS[1]));+    // Who owns it, if the census can say.+    let mut owner: Option<(u32, String, String)> = None;+    if let Ok(c) = os.processes() {+        for p in &c {+            if let Ok(ws) = os.windows_of_pid(p.pid) {+                if let Some(w) = ws.iter().find(|w| w.hwnd == hwnd) {+                    owner = Some((p.pid, p.image.clone(), w.title.clone()));+                    break;+                }+            }+        }+    }+    let title = owner.as_ref().map(|o| o.2.clone()).or_else(|| {+        crate::abwin::list_windows(Duration::from_secs(10)).ok().and_then(|ws| {+            ws.iter().find(|w| w.get("hwnd").and_then(|h| h.as_i64()) == Some(hwnd)).and_then(|w| w.get("title").and_then(|t| t.as_str()).map(String::from))+        })+    });+    if !user && !pass {+        return Err(err(+            "sign_in_window_not_a_login",+            format!("window {hwnd} shows neither an \"Email or username\" nor a \"Password\" field"),+            "Nothing was typed. `found` lists every control looked for and what desktop_find_control answered.",+            json!({"hwnd": hwnd, "title": title, "found": report}),+        ));+    }+    let (pid, image) = owner.map(|o| (o.0, o.1)).unwrap_or((0, String::new()));+    Ok(LoginWindow { hwnd, title: title.unwrap_or_default(), owner_pid: pid, owner_image: image, ours: false, found_by: "content", page: Some(if pass { 2 } else { 1 }) })+}+ fn sign_in_inner(reason: &str, opts: &Opts) -> Value {     let os = crate::launchos::os();     let user_confirmed_new_password = opts.user_confirmed_new_password;@@ -787,18 +1175,34 @@ fn sign_in_inner(reason: &str, opts: &Opts) -> Value {     if !opts.user_authorized && attempt.is_none() {         return err("sign_in_not_waiting", "no launch by this bridge is recorded", "swx_start begins one; swx_sign_in answers only the sign-in window of a launch this bridge started — or, with userAuthorized:true (the user's say-so), any 3DEXPERIENCE ID login window on this machine.", json!({}));     }+    let named_hwnd = opts.window.as_deref().and_then(|w| w.trim().parse::<i64>().ok()).filter(|_| opts.user_authorized);     let found = match login_windows(os.as_ref(), opts.user_authorized) {         Ok(f) => f,+        // A window the CALLER NAMED is judged by its content, not refused+        // because a census could not be taken (0.9.23).+        Err(_) if named_hwnd.is_some() => Vec::new(),         Err(e) => return err("sign_in_not_waiting", format!("the login windows could not be read: {e}"), "Nothing was typed anywhere.", json!({})),     };     let pool: Vec<LoginWindow> = if opts.user_authorized { found } else { found.into_iter().filter(|w| w.ours).collect() };     let picked: Vec<LoginWindow> = match opts.window.as_deref().map(|w| w.trim().to_lowercase()) {         None => pool.clone(),         Some(w) if w == "visualize" => pool.iter().filter(|l| l.owner_image.eq_ignore_ascii_case("SLDWORKSVisualize.exe")).cloned().collect(),-        Some(w) if w == "solidworks" => pool.iter().filter(|l| !l.owner_image.eq_ignore_ascii_case("SLDWORKSVisualize.exe")).cloned().collect(),+        Some(w) if w == "solidworks" => pool.iter().filter(|l| l.host() == "solidworks").cloned().collect(),+        Some(w) if w == "desktopupdate" => pool.iter().filter(|l| l.host() == "desktopUpdate").cloned().collect(),         Some(w) => match w.parse::<i64>() {-            Ok(h) => pool.iter().filter(|l| l.hwnd == h).cloned().collect(),-            Err(_) => return err("sign_in_bad_window", format!("window {w:?} is not \"visualize\", \"solidworks\" or an hwnd"), "Pass window:\"visualize\", \"solidworks\" or a window handle.", json!({})),+            Ok(h) => {+                let hit: Vec<LoginWindow> = pool.iter().filter(|l| l.hwnd == h).cloned().collect();+                if hit.is_empty() && opts.user_authorized {+                    // NAMED BY THE CALLER: never refused on census grounds.+                    match named_window(os.as_ref(), h) {+                        Ok(lw) => vec![lw],+                        Err(e) => return e,+                    }+                } else {+                    hit+                }+            }+            Err(_) => return err("sign_in_bad_window", format!("window {w:?} is not \"visualize\", \"solidworks\", \"desktopUpdate\" or an hwnd"), "Pass window:\"visualize\", \"solidworks\", \"desktopUpdate\" or a window handle.", json!({})),         },     };     let listed = json!(pool.iter().map(|l| l.to_json()).collect::<Vec<_>>());@@ -833,14 +1237,17 @@ fn sign_in_inner(reason: &str, opts: &Opts) -> Value {         );     }     // 1. THE INVENTORY, captured every time (woken first if the page is lazy).-    let read = match inventory(hwnd) {+    //    When the tree holds only the frame (the SWXDesktopUpdate host,+    //    measured 2026-10-12), the page is located control by control.+    let read = match read_page(hwnd) {         Ok(r) => r,         Err(e) => return err("sign_in_inventory_unreadable", e, "Nothing was typed. The user can sign in by hand.", json!({"hwnd": hwnd})),     };     crate::launch::note_sign_in_inventory(inventory_json(&read.elements));-    crate::launch::note_sign_in_wake(read.wake_json());+    crate::launch::note_sign_in_wake(read.wake.clone());     let inv_j = inventory_json(&read.elements);-    let wake_1 = read.wake_json();+    let wake_1 = read.wake.clone();+    let located_1 = read.report();     let banner = cookie_banner(&read.elements);     let (reading, form) = recognize(&read.elements);     let form = match (reading, form) {@@ -851,7 +1258,7 @@ fn sign_in_inner(reason: &str, opts: &Opts) -> Value {         }         (r, _) => {             let why = match r { Reading::Unrecognized(w) | Reading::Rejected(w) => w, _ => "unrecognized".into() };-            return err("sign_in_window_unrecognized", format!("the sign-in window does not look like the form this bridge fills: {why}"), "Nothing was typed. The inventory is attached so the form can be recognized next time; the user can sign in by hand.", json!({"inventory": inv_j, "wake": wake_1, "cookieBanner": banner}));+            return err("sign_in_window_unrecognized", format!("the sign-in window does not look like the form this bridge fills: {why}"), "Nothing was typed. The inventory is attached so the form can be recognized next time; the user can sign in by hand.", json!({"inventory": inv_j, "wake": wake_1, "located": located_1, "cookieBanner": banner, "window": window_j}));         }     };     // 2. THE SECRET, locally — ONCE for the whole sign-in, however many pages it@@ -878,7 +1285,7 @@ fn sign_in_inner(reason: &str, opts: &Opts) -> Value {     };     let needles = secret.needles();     let mut steps: Vec<Value> = Vec::new();-    let mut pages: Vec<Value> = vec![json!({"page": 1, "inventory": inv_j, "wake": wake_1, "cookieBanner": banner})];+    let mut pages: Vec<Value> = vec![json!({"page": 1, "inventory": inv_j, "wake": wake_1, "located": located_1, "cookieBanner": banner})];     let mut remember_ticked = Value::Null;     // 3. PAGE ONE (and, on a one-page form, the whole sign-in).     if let Err(fe) = fill_page(hwnd, &read.elements, &form, &secret, &mut steps, &mut remember_ticked) {@@ -899,12 +1306,12 @@ fn sign_in_inner(reason: &str, opts: &Opts) -> Value {             if still_up(os.as_ref(), &lw) == Some(false) {                 break; // the window closed after the user name alone             }-            if let Ok(r2) = inventory(hwnd) {+            if let Ok(r2) = read_page(hwnd) {                 last = r2.elements.clone();                 match recognize(&r2.elements) {                     (Reading::Form, Some(f2)) if f2.password.is_some() => {-                        pages.push(json!({"page": 2, "inventory": inventory_json(&r2.elements), "wake": r2.wake_json(),-                                          "cookieBanner": cookie_banner(&r2.elements)}));+                        pages.push(json!({"page": 2, "inventory": inventory_json(&r2.elements), "wake": r2.wake.clone(),+                                          "located": r2.report(), "cookieBanner": cookie_banner(&r2.elements)}));                         crate::launch::note_sign_in_inventory(inventory_json(&r2.elements));                         page2_els = r2.elements.clone();                         page2 = Some(f2);@@ -974,7 +1381,7 @@ fn sign_in_inner(reason: &str, opts: &Opts) -> Value {         }     }     // STILL UP: read it again and say what it is asking.-    let after = inventory(hwnd).map(|r| r.elements).unwrap_or_default();+    let after = read_page(hwnd).map(|r| r.elements).unwrap_or_default();     let after_j = inventory_json(&after);     let out = if let Some(m) = has_marker(&after, REJECTED) {         crate::launch::note_sign_in_rejected();@@ -1008,6 +1415,15 @@ fn fill_page(hwnd: i64, page: &[Element], form: &Form, secret: &Secret, steps: &     }     if let Some(rm) = &form.remember {         *remember_ticked = tick_remember(hwnd, page, rm);+    } else if form.password.is_some() {+        // THE SWXDesktopUpdate HOST (MEASURED 2026-10-12): page 2 shows a Text+        // "Remember me" and no CheckBox could be found by name. The label is+        // clicked (as on the Visualize host) only while the user is idle and the+        // login window is in front; its state is NOT readable, so+        // `rememberTicked` stays null and the step says what was done.+        if let Some(label) = page.iter().find(|e| e.by_find && e.is("text") && clean(&e.name).starts_with("remember me") && e.center.is_some() && !e.offscreen()) {+            steps.push(click_remember_label(hwnd, label));+        }     }     let r = crate::caller::ad_callback("desktop_ui_click", merge(target(&form.submit, "button"), json!({"hwnd": hwnd, "reason": FILL_REASON})), AB_TIMEOUT);     steps.push(json!({"step": format!("press \"{}\"", form.submit.name), "ok": ab_ok(&r), "via": "uiaInvoke"}));@@ -1071,6 +1487,25 @@ fn tick_remember(hwnd: i64, page: &[Element], rm: &Element) -> Value {     json!({"ticked": ab_ok(&r) && is_on(after.as_deref()), "via": "labelClick", "label": label.name, "toggleStateAfter": after}) } +/// A real click on the "Remember me" label, guarded like every real input.+fn click_remember_label(hwnd: i64, label: &Element) -> Value {+    if let Err(why) = user_idle() {+        return json!({"step": "remember me (label)", "ok": false, "why": format!("skipped: {why}"), "state": "unreadable"});+    }+    let _ = crate::caller::ad_callback("desktop_raise_window", json!({"hwnd": hwnd, "reason": FILL_REASON}), AB_TIMEOUT);+    let settle = std::time::Instant::now() + Duration::from_millis(1500);+    while login_in_front(hwnd).is_err() && std::time::Instant::now() < settle {+        std::thread::sleep(Duration::from_millis(100));+    }+    if let Err(why) = login_in_front(hwnd) {+        return json!({"step": "remember me (label)", "ok": false, "why": format!("skipped: {why}"), "state": "unreadable"});+    }+    let (x, y) = label.center.unwrap_or_default();+    let r = crate::caller::ad_callback("desktop_click", json!({"x": x, "y": y, "hwnd": hwnd, "reason": FILL_REASON}), AB_TIMEOUT);+    json!({"step": "remember me (label)", "ok": ab_ok(&r), "via": "labelClick", "label": label.name,+           "state": "unreadable — no CheckBox was found on this host, so whether it is ticked cannot be read"})+}+ pub(crate) enum FillErr {     /// The user is typing (or the idle time cannot be read): no keystroke sent.     NeedsIdle(String),@@ -1129,7 +1564,24 @@ fn field_value(hwnd: i64, el: &Element) -> Option<String> {             _ => None,         }     }-    walk(&unwrap_ab(&r), el)+    if let Some(v) = walk(&unwrap_ab(&r), el) {+        return Some(v);+    }+    if !el.by_find {+        return None;+    }+    // Located by find_control: its reply's `value`, IF ab ever carries one+    // (measured 2026-10-12: it does not).+    let q = if el.automation_id.is_empty() { json!({"hwnd": hwnd, "role": "Edit", "name": el.name}) } else { json!({"hwnd": hwnd, "automationId": el.automation_id}) };+    let r = crate::caller::ad_callback("desktop_find_control", q, AB_TIMEOUT);+    fn val(v: &Value) -> Option<String> {+        match v {+            Value::Array(a) => a.iter().find_map(val),+            Value::Object(m) => m.get("value").and_then(|x| x.as_str()).map(String::from).or_else(|| m.values().find_map(val)),+            _ => None,+        }+    }+    if ab_ok(&r) { val(&unwrap_ab(&r)) } else { None } }  /// Where a field is NOW: its centre (ab's own), whether a cookie-banner@@ -1141,6 +1593,21 @@ struct Spot { }  fn locate(hwnd: i64, el: &Element) -> Option<Spot> {+    if el.by_find {+        // Fresh geometry by find_control; the banner's buttons too.+        let q = if el.automation_id.is_empty() { json!({"hwnd": hwnd, "role": "Edit", "name": el.name}) } else { json!({"hwnd": hwnd, "automationId": el.automation_id}) };+        let r = crate::caller::ad_callback("desktop_find_control", q, AB_TIMEOUT);+        let field = found_elements(&r).into_iter().find(|e| e.is("edit") && (e.automation_id == el.automation_id || e.name == el.name))?;+        let center = field.center?;+        let covered = match field.rect {+            Some(fr) => ["Accept All", "Manage my preferences"].iter().any(|n| {+                let (b, _) = find_one(hwnd, &Want { role: "Button", automation_id: None, name: n });+                b.and_then(|b| b.rect).map(|br| overlaps(fr, br)).unwrap_or(false)+            }),+            None => false,+        };+        return Some(Spot { center, covered, render_widget: None });+    }     let r = crate::caller::ad_callback("desktop_ui_tree", json!({"hwnd": hwnd, "maxDepth": 30, "maxNodes": 400}), AB_TIMEOUT);     if !ab_ok(&r) {         return None;@@ -1177,6 +1644,76 @@ fn locate(hwnd: i64, el: &Element) -> Option<Spot> {     Some(Spot { center, covered, render_widget: widget(&unwrap_ab(&r)) }) } +/// CLEAR, THEN SET, a find_control-located field (0.9.23). MEASURED+/// 2026-10-12 on the SWXDesktopUpdate host: the first `desktop_ui_set` of the+/// user name left the name plus a stray trailing "s" (a leftover keystroke+/// or SetValue inserting, origin unknown); setting "" first and then the value+/// fixed it. So: set "", read back (when readable) that it is empty, set the+/// value, read the user name back (when readable). `desktop_find_control`'s+/// reply carries NO `value` (measured), and this host's tree holds no page, so+/// the read-back is usually UNREADABLE there — said in the step, never+/// assumed. The password is never read back. `Ok(false)` = no ValuePattern+/// (fall back to keystrokes).+fn set_cleared(hwnd: i64, el: &Element, typed: &str, read_back: bool, label: &str, steps: &mut Vec<Value>) -> Result<bool, FillErr> {+    let set = |text: &str| {+        crate::caller::ad_callback(+            "desktop_ui_set",+            merge(target(el, "edit"), json!({"hwnd": hwnd, "text": text, "sensitive": true, "reason": FILL_REASON})),+            AB_TIMEOUT,+        )+    };+    let r = set("");+    if !ab_ok(&r) {+        let why = ab_error(&r);+        if why.to_lowercase().contains("no valuepattern") {+            return Ok(false);+        }+        steps.push(json!({"step": format!("{label}: clear"), "ok": false, "via": "uiaValuePattern"}));+        return Err(FillErr::Failed { step: format!("{label} (UIA clear)"), why, observed: None, may_be_banner: true });+    }+    let cleared = field_value(hwnd, el);+    if read_back {+        if let Some(v) = cleared.as_deref().filter(|v| !v.is_empty()) {+            return Err(FillErr::Failed {+                step: format!("{label}: clear"),+                why: "the field was set to empty but still holds text".into(),+                observed: Some(json!({"fieldText": v, "length": v.chars().count()})),+                may_be_banner: false,+            });+        }+    }+    let r = set(typed);+    if !ab_ok(&r) {+        steps.push(json!({"step": label, "ok": false, "via": "uiaValuePattern", "cleared": true}));+        return Err(FillErr::Failed { step: format!("{label} (UIA set)"), why: ab_error(&r), observed: None, may_be_banner: true });+    }+    if !read_back {+        steps.push(json!({"step": label, "ok": true, "via": "uiaValuePattern", "cleared": true, "readBack": "notReadPassword"}));+        return Ok(true);+    }+    let got = field_value(hwnd, el);+    match got {+        Some(g) if g == typed => {+            steps.push(json!({"step": label, "ok": true, "via": "uiaValuePattern", "cleared": true, "readBack": "matched"}));+            Ok(true)+        }+        Some(g) => {+            steps.push(json!({"step": label, "ok": false, "via": "uiaValuePattern", "cleared": true, "readBack": "mismatch"}));+            Err(FillErr::Failed {+                step: format!("{label}: read-back"),+                why: "the user-name field does not hold what was set".into(),+                observed: Some(json!({"fieldText": g, "length": g.chars().count()})),+                may_be_banner: false,+            })+        }+        None => {+            steps.push(json!({"step": label, "ok": true, "via": "uiaValuePattern", "cleared": true,+                              "readBack": "unreadable (desktop_find_control carries no value; the tree holds no page on this host)"}));+            Ok(true)+        }+    }+}+ /// FILL ONE FIELD. First the background UIA ValuePattern set; MEASURED /// 2026-10-02 the 3DEXPERIENCE ID page refuses it ("control found but has NO /// ValuePattern … try a foregrounded desktop_type") even on an edit the tree@@ -1194,6 +1731,12 @@ fn locate(hwnd: i64, el: &Element) -> Option<Spot> { fn fill_field(hwnd: i64, el: &Element, text: &[u8], read_back: bool, steps: &mut Vec<Value>) -> Result<(), FillErr> {     let label = if read_back { "user name" } else { "password" };     let typed = String::from_utf8_lossy(text).to_string();+    if el.by_find {+        match set_cleared(hwnd, el, &typed, read_back, label, steps)? {+            true => return Ok(()),+            false => {} // no ValuePattern: real keystrokes, below+        }+    } else {     let r = crate::caller::ad_callback(         "desktop_ui_set",         merge(target(el, "edit"), json!({"hwnd": hwnd, "text": typed, "sensitive": true, "reason": FILL_REASON})),@@ -1209,6 +1752,7 @@ fn fill_field(hwnd: i64, el: &Element, text: &[u8], read_back: bool, steps: &mut         steps.push(json!({"step": label, "ok": false, "via": "uiaValuePattern"}));         return Err(FillErr::Failed { step: format!("{label} (UIA set)"), why, observed: None, may_be_banner: true });     }+    }     // ── REAL KEYSTROKES ──────────────────────────────────────────────────────     user_idle().map_err(FillErr::NeedsIdle)?;     // FRESH GEOMETRY (MEASURED 2026-10-02: moving the window re-laid the page@@ -1277,6 +1821,10 @@ fn fill_field(hwnd: i64, el: &Element, text: &[u8], read_back: bool, steps: &mut             std::thread::sleep(Duration::from_millis(150));             got = field_value(hwnd, el);         }+        if got.is_none() && el.by_find {+            steps.push(json!({"step": label, "ok": true, "via": "keystrokes", "readBack": "unreadable (desktop_find_control carries no value; the tree holds no page on this host)"}));+            return Ok(());+        }         if got.as_deref() != Some(typed.as_str()) {             steps.push(json!({"step": label, "ok": false, "via": "keystrokes", "readBack": "mismatch"}));             return Err(FillErr::Failed {

@@ -3017,7 +3017,7 @@ pub const CATALOG: &[(&str, &str, &str)] = &[     ("swx_close_all_safely", "exec", "save EVERY open document into a recovery folder, then close it — nothing closes before it is on disk; needs only a reason"),     ("swx_shutdown", "exec", "close_all_safely, then quit SOLIDWORKS; idempotent, and the quit is skipped unless the session really emptied"),     ("swx_recover_list", "read", "what previous sweeps preserved, and where — newest first"),-    ("swx_sign_in", "exec", "sign in to 3DEXPERIENCE for a launch this bridge started (or, with userAuthorized:true, any 3DEXPERIENCE ID login window, e.g. Visualize's; window picks one), from the user's local vault (the password never leaves the laptop or reaches a reply); fails closed and never retries a rejected password"),+    ("swx_sign_in", "exec", "sign in to 3DEXPERIENCE for a launch this bridge started (or, with userAuthorized:true, any 3DEXPERIENCE ID login window, e.g. Visualize's or the platform updater's, recognized by its content; window:visualize|solidworks|desktopUpdate|<hwnd> picks one, and a named hwnd is probed by content, never refused on census grounds), from the user's local vault (the password never leaves the laptop or reaches a reply); fails closed and never retries a rejected password"),     ("swx_user_presence", "read", "is the user working in this SOLIDWORKS? foreground + last input + documents the bridge did not open (the guard every quit and sweep passes)"),     ("swx_kill", "process", "force-kill SOLIDWORKS (reason + confirm; discards unsaved work)"),     ("swx_window_info", "read", "SOLIDWORKS' windows and its main hwnd (read-only, nothing raised)"),@@ -3422,37 +3422,60 @@ fn dispatch_after_gate(ctx: &Ctx, command: &str, args: &Value) -> Value {         }     }     // BLOCKED ON THE USER'S SIGN-IN (0.9.12): said plainly, with the window.+    // 0.9.23: `signInWindow` is an OBJECT {hwnd, title, ownerImage, host, …},+    // and ANY 3DEXPERIENCE ID login on the machine counts — by class/title or by+    // CONTENT (measured 2026-10-12: the SWXDesktopUpdate-hosted login, titled+    // just "3DEXPERIENCE", was up while swx_status said waitingOn:null).     if command == "swx_start" || command == "swx_status" {-        if let Some(a) = crate::launch::attempt() {-            // From a LIVE census whenever the record names the sign-in stage —-            // the monitor that first saw the window may have died with an older-            // bridge process (0.9.13).-            let live = if a.stage.name() == "helperSignIn" {-                match crate::launch::sign_in_now(crate::launchos::os().as_ref()) {-                    Some(Some((_, t))) => Some(t),-                    _ => None,+        let os = crate::launchos::os();+        let attempt = crate::launch::attempt();+        // From a LIVE census whenever the record names the sign-in stage —+        // the monitor that first saw the window may have died with an older+        // bridge process (0.9.13).+        let live = match &attempt {+            Some(a) if a.stage.name() == "helperSignIn" => match crate::launch::sign_in_now(os.as_ref()) {+                Some(Some((h, t))) => Some((Some(h), t)),+                _ => None,+            },+            _ => None,+        };+        let recorded = attempt.as_ref().and_then(|a| a.sign_in_window.clone().filter(|_| !a.finished)).map(|t| (None, t));+        let machine = crate::signin::login_windows(os.as_ref(), true).unwrap_or_default();+        let ours_title = live.or(recorded);+        let window: Option<Value> = match &ours_title {+            Some((h, t)) => Some(+                machine+                    .iter()+                    .find(|l| Some(l.hwnd) == *h || (h.is_none() && l.title == *t))+                    .map(|l| l.to_json())+                    .unwrap_or_else(|| json!({"hwnd": h, "title": t, "ownerImage": Value::Null, "host": Value::Null})),+            ),+            None => machine.iter().find(|l| l.ours).or_else(|| machine.first()).map(|l| l.to_json()),+        };+        if let Some(w) = window {+            if let Value::Object(m) = &mut out {+                if let Some(a) = attempt.as_ref().filter(|_| ours_title.is_some()) {+                    m.insert("signInInventory".into(), a.sign_in_inventory.clone().unwrap_or(Value::Null));+                    m.insert("signInMode".into(), json!(if a.sign_in_auto { "auto" } else { "wait" }));                 }-            } else {-                None-            };-            let title = live.or_else(|| a.sign_in_window.clone().filter(|_| !a.finished));-            if let Some(m) = out.as_object_mut().filter(|_| title.is_some()) {-                m.insert("signInInventory".into(), a.sign_in_inventory.clone().unwrap_or(Value::Null));-                m.insert("signInMode".into(), json!(if a.sign_in_auto { "auto" } else { "wait" }));-            }-            if let Some(title) = title {-                if let Value::Object(m) = &mut out {-                    m.insert("waitingOn".into(), json!("userSignIn"));-                    m.insert("signInWindow".into(), json!(title));-                    m.insert(-                        "_signInHint".into(),-                        json!("SOLIDWORKS is waiting for the user to sign in to 3DEXPERIENCE in the \-                               window named here. Only the user can answer it; the launch's deadlines \-                               are paused and nothing is killed. Tell the user, or — if they have a \-                               3DEXPERIENCE login saved in their local vault — call swx_sign_in \-                               {reason}. Then poll swx_status."),-                    );+                m.insert("waitingOn".into(), json!("userSignIn"));+                m.insert("signInWindow".into(), w);+                if machine.len() > 1 {+                    m.insert("loginWindows".into(), json!(machine.iter().map(|l| l.to_json()).collect::<Vec<_>>()));+                }+                // swx_start must not say "launching" while the start is parked+                // behind a login (0.9.23).+                if command == "swx_start" && m.get("stage").and_then(|v| v.as_str()) == Some("launching") {+                    m.insert("stage".into(), json!("waitingOn"));                 }+                m.insert(+                    "_signInHint".into(),+                    json!("A 3DEXPERIENCE sign-in window is waiting for the user (signInWindow). Only the user \+                           can answer it; a launch's deadlines are paused and nothing is killed. Tell the user, \+                           or — if they have a 3DEXPERIENCE login saved in their local vault — call swx_sign_in \+                           {reason} (a launch this bridge started) or swx_sign_in {reason, userAuthorized:true, \+                           window:<signInWindow.hwnd>} on the user's say-so. Then poll swx_status."),+                );             }         }     }

@@ -102,7 +102,11 @@ fn wait_for_sign_in_stage(b: &Bridge) -> Value {     let deadline = Instant::now() + Duration::from_secs(10);     loop {         let st = b.call("swx_status", json!({}));-        if st["waitingOn"] == "userSignIn" || Instant::now() > deadline {+        // 0.9.23: `waitingOn` comes from a machine-wide census the moment the+        // window is up; the LAUNCH has reached the sign-in when it reports it+        // as its own (`signInMode`).+        // ...and its inventory is read off the monitor thread: wait for it too.+        if (st["waitingOn"] == "userSignIn" && st["signInMode"].is_string() && !st["signInInventory"].is_null()) || Instant::now() > deadline {             return st;         }         std::thread::sleep(Duration::from_millis(150));@@ -361,7 +365,7 @@ fn a_respawned_bridge_still_sees_the_sign_in_and_reconciles_after_it() {     check!(         b,         "after a respawn mid-launch, waitingOn and the window come from a LIVE census",-        st["waitingOn"] == "userSignIn" && st["signInWindow"].as_str().unwrap_or("").contains("3DEXPERIENCE ID"),+        st["waitingOn"] == "userSignIn" && st["signInWindow"]["title"].as_str().unwrap_or("").contains("3DEXPERIENCE ID") && st["signInWindow"]["hwnd"].is_number(),         s(&st)     );     // The user signs in by hand; SOLIDWORKS comes up and COM attaches.@@ -1089,3 +1093,210 @@ fn a_cookie_banner_over_the_field_is_never_clicked_through() {         s(&r)     ); }++// ── 0.9.23: the THIRD host — SWXDesktopUpdate.exe, found by CONTENT ─────────+//+// MEASURED 2026-10-12: title "3DEXPERIENCE" (no "ID", no "login"), class+// WindowsForms10.Window.8.app.0.30495d1_r6_ad1, owned by SWXDesktopUpdate.exe+// (from %TEMP%). desktop_ui_tree returns only the frame (14 nodes);+// desktop_find_control reaches the page by name / automation id.++const UPDATE_HWND: i64 = 857684;+const UPDATE_CLASS: &str = "WindowsForms10.Window.8.app.0.30495d1_r6_ad1";++fn update_machine(tag: &str) -> Machine {+    let m = Machine::new(tag);+    std::fs::write(m.dir.join("preexisting.json"), json!([{"pid": 61000, "image": "SWXDesktopUpdate.exe", "ageSeconds": 30}]).to_string()).unwrap();+    std::fs::write(+        m.dir.join("sign-in.json"),+        json!({"hwnd": UPDATE_HWND, "ownerPid": 61000, "className": UPDATE_CLASS, "title": "3DEXPERIENCE"}).to_string(),+    )+    .unwrap();+    m+}++/// The measured tree: the frame only, even after a wake.+fn frame_tree() -> Value {+    json!({"success": true, "status": "ok", "hwnd": UPDATE_HWND, "maxNodes": 600, "nodeCount": 14, "truncated": false,+           "window": {"title": "3DEXPERIENCE", "rect": {"x": 828, "y": 273, "w": 1316, "h": 1076}},+           "root": {"role": "Window", "name": "3DEXPERIENCE", "automationId": "SWXDesktopUpdateForm", "invokable": false, "settable": false, "children": [+               {"role": "TitleBar", "name": "", "automationId": "", "children": [+                   {"role": "MenuBar", "name": "System Menu Bar", "automationId": ""},+                   {"role": "Button", "name": "Minimize", "automationId": "", "invokable": true},+                   {"role": "Button", "name": "Maximize", "automationId": "", "invokable": true},+                   {"role": "Button", "name": "Close", "automationId": "", "invokable": true}+               ]},+               {"role": "Pane", "name": "", "automationId": ""}+           ]}})+}++fn ctl(role: &str, name: &str, aid: &str, cx: i64, cy: i64, settable: bool, invokable: bool) -> Value {+    json!({"success": true, "data": {"found": true, "control": {"role": role, "name": name, "automationId": aid,+           "invokable": invokable, "settable": settable,+           "rect": {"x": cx - 200, "y": cy - 20, "w": 400, "h": 40, "centerX": cx, "centerY": cy}}}})+}++fn not_found() -> Value {+    json!({"success": false, "error": "no control matched"})+}++const FIND: &str = "desktop_find_control";++/// Page one, as measured: the user-name edit (by automation id or exact+/// name), Continue. A query with a role ALONE answers the measured wrong match.+fn update_page_one(ab: &common::AbStub) {+    ab.clear_rules(FIND);+    let user = ctl("Edit", "Email or username", "username", 1486, 844, true, false);+    ab.when(FIND, json!({"automationId": "username"}), user.clone());+    ab.when(FIND, json!({"role": "Edit", "name": "Email or username"}), user);+    ab.when(FIND, json!({"role": "Button", "name": "Continue"}), ctl("Button", "Continue", "", 1486, 940, false, true));+    ab.when(FIND, json!({"name": "Manage cookies"}), ctl("Hyperlink", "Manage cookies", "", 2034, 1264, false, true));+    ab.set_response(FIND, not_found());+}++/// Page two, as measured: the password edit's NAME carries an icon glyph, so+/// only `{automationId:"password"}` finds it; "Remember me" is a Text.+fn update_page_two(ab: &common::AbStub) {+    ab.clear_rules(FIND);+    let user = ctl("Edit", "Email or username", "username", 1486, 727, true, false);+    ab.when(FIND, json!({"automationId": "username"}), user.clone());+    ab.when(FIND, json!({"role": "Edit", "name": "Email or username"}), user);+    ab.when(FIND, json!({"automationId": "password"}), ctl("Edit", "Password \u{e9a0}", "password", 1486, 856, true, false));+    ab.when(FIND, json!({"role": "Text", "name": "Remember me"}), ctl("Text", "Remember me", "", 1255, 923, false, false));+    ab.when(FIND, json!({"role": "Button", "name": "Log in"}), ctl("Button", "Log in", "", 1486, 1006, false, true));+    ab.when(FIND, json!({"role": "Button", "name": "Back"}), ctl("Button", "Back", "", 1486, 1093, false, true));+    ab.set_response(FIND, not_found());+}++fn update_ab() -> common::AbStub {+    let ab = ab_for(frame_tree(), vault_ok());+    ab.set_response("desktop_raise_window", json!({"success": true}));+    ab.set_response("desktop_click", json!({"success": true}));+    update_page_one(&ab);+    ab+}++/// Continue → page two; Log in → the window closes.+fn drive_update(m: &Machine, ab: &common::AbStub) {+    let deadline = Instant::now() + Duration::from_secs(25);+    let mut state = 0;+    while Instant::now() < deadline {+        let clicks = ab.calls_to("desktop_ui_click");+        let clicked = |n: &str| clicks.iter().any(|c| c["args"]["name"] == n);+        match state {+            0 if clicked("Continue") => {+                update_page_two(ab);+                state = 1;+            }+            1 if clicked("Log in") => {+                let _ = std::fs::remove_file(m.dir.join("sign-in.json"));+                return;+            }+            _ => {}+        }+        std::thread::sleep(Duration::from_millis(15));+    }+}++#[test]+fn the_desktop_update_login_is_found_by_its_content_and_signed_in() {+    assert!(+        !swx_bridge::launch::is_sign_in_window(UPDATE_CLASS, "3DEXPERIENCE"),+        "the fast path does NOT know this window (its title is just \"3DEXPERIENCE\") — content must"+    );+    assert!(swx_bridge::launchos::WATCHED_IMAGES.contains(&"SWXDesktopUpdate.exe"), "the census must see the updater");+    let m = update_machine("signin-update");+    std::fs::write(m.dir.join("foreground.json"), json!({"hwnd": UPDATE_HWND, "pid": 61000, "title": "3DEXPERIENCE", "className": UPDATE_CLASS}).to_string()).unwrap();+    let ab = update_ab();+    let b = m.boot(TempDir::new("signin-update-scratch"), &ab, &[("SWX_SIGN_IN_WAKE_MS", "20"), ("SWX_SIGN_IN_VERIFY_SECS", "8")]);+    let st = b.call("swx_status", json!({}));+    check!(+        b,+        "swx_status: waitingOn userSignIn, signInWindow {hwnd, title, ownerImage, host:desktopUpdate}, recognized by content",+        st["waitingOn"] == "userSignIn" && st["signInWindow"]["hwnd"] == UPDATE_HWND && st["signInWindow"]["title"] == "3DEXPERIENCE"+            && st["signInWindow"]["ownerImage"] == "SWXDesktopUpdate.exe" && st["signInWindow"]["host"] == "desktopUpdate"+            && st["signInWindow"]["recognizedBy"] == "content",+        s(&st)+    );+    let r = std::thread::scope(|sc| {+        sc.spawn(|| drive_update(&m, &ab));+        b.call("swx_sign_in", json!({"reason": "Drew: sign me in", "userAuthorized": true, "window": UPDATE_HWND}))+    });+    check!(+        b,+        "signed in over both pages, located by desktop_find_control, verified by the window closing",+        r["signedIn"] == true && r["twoPage"] == true && r["window"]["host"] == "desktopUpdate" && !m.sign_in_up()+            && r["pages"][0]["located"]["source"] == "desktop_find_control" && r["pages"][1]["located"]["source"] == "desktop_find_control",+        s(&r)+    );+    let sets = ab.calls_to("desktop_ui_set");+    let set = |i: usize| (sets.get(i).map(|c| c["args"]["automationId"].clone()), sets.get(i).map(|c| c["args"]["text"].clone()));+    check!(+        b,+        "CLEAR THEN SET, by automation id: username \"\" then the user name; password \"\" then the password",+        sets.len() == 4+            && set(0) == (Some(json!("username")), Some(json!(""))) && set(1) == (Some(json!("username")), Some(json!(USER)))+            && set(2) == (Some(json!("password")), Some(json!(""))) && set(3) == (Some(json!("password")), Some(json!(PW))),+        format!("{sets:?}")+    );+    check!(+        b,+        "no find_control query ever went out with a role alone (measured: it matched the browser's address bar)",+        ab.calls_to(FIND).iter().all(|c| c["args"].get("name").is_some() || c["args"].get("contains").is_some() || c["args"].get("automationId").is_some()),+        format!("{:?}", ab.calls_to(FIND))+    );+    check!(+        b,+        "Remember me: the label was clicked, its state is unreadable, rememberTicked is null",+        r["rememberTicked"].is_null()+            && ab.calls_to("desktop_click").iter().any(|c| c["args"]["x"] == 1255 && c["args"]["y"] == 923),+        s(&r["steps"])+    );+    let all = everything_but_the_fill(&b, &ab, &[st, r]);+    check!(b, "the password appears nowhere", !all.contains(PW), String::new());+}++#[test]+fn a_named_window_is_judged_by_its_content_never_refused_on_census_grounds() {+    // The window is NOT in any census (no sign-in.json): only ab sees it.+    let m = Machine::new("signin-named");+    let _ = std::fs::remove_file(m.dir.join("sign-in.json"));+    let ab = update_ab();+    ab.set_response("pup_credential_reveal", json!({"success": false, "error": "no credential stored for that host", "errorCode": "not_found"}));+    ab.set_response("pup_credentials", json!({"success": true, "data": {"credentials": []}}));+    let b = m.boot(TempDir::new("signin-named-scratch"), &ab, &[("SWX_SIGN_IN_WAKE_MS", "20")]);+    let r = b.call("swx_sign_in", json!({"reason": "Drew: sign me in", "userAuthorized": true, "window": UPDATE_HWND}));+    check!(+        b,+        "a named hwnd with the user-name field is TAKEN (it gets as far as the vault), not refused sign_in_not_waiting",+        r["errorCode"] != "sign_in_not_waiting" && r["errorCode"] != "sign_in_window_not_a_login"+            && ab.calls_to(FIND).iter().any(|c| c["args"]["hwnd"] == UPDATE_HWND),+        s(&r)+    );+    ab.clear_rules(FIND);+    let r = b.call("swx_sign_in", json!({"reason": "Drew: sign me in", "userAuthorized": true, "window": 4242}));+    check!(+        b,+        "a named hwnd with neither field: sign_in_window_not_a_login, with what WAS looked for and found; nothing typed",+        r["errorCode"] == "sign_in_window_not_a_login" && r["found"]["Edit \"Email or username\""]["found"] == false+            && r["found"]["Edit \"Password\""]["found"] == false && ab.calls_to("desktop_ui_set").is_empty(),+        s(&r)+    );+}++#[test]+fn a_launch_parked_behind_the_updater_login_says_so() {+    // SOLIDWORKS: the launch pauses (never killed) and swx_status names the updater's login.+    let m = update_machine("signin-update-launch");+    let ab = update_ab();+    let b = m.boot(TempDir::new("signin-update-launch-scratch"), &ab, &[("SWX_SIGN_IN_WAKE_MS", "20")]);+    let r = b.call("swx_start", json!({"waitSeconds": 0, "reason": "start"}));+    let st = wait_for_sign_in_stage(&b);+    check!(+        b,+        "swx_start / swx_status: waitingOn userSignIn with the updater's window; the launch reached its sign-in stage",+        st["waitingOn"] == "userSignIn" && st["signInWindow"]["host"] == "desktopUpdate" && st["signInMode"] == "wait"+            && r["stage"] != "launching",+        format!("{}\n{}", s(&r), s(&st))+    );+}