VectorCraft: An open-source, vector art tool written by scratch in pure Rust
Pen tablets: a pen's eraser end selects the Eraser on Windows
dotCooCoodbc446329f7a
diff --git a/apps/vectorcraft/Cargo.toml b/apps/vectorcraft/Cargo.tomlindex d68db8162..0b7883f31 100644--- a/apps/vectorcraft/Cargo.toml+++ b/apps/vectorcraft/Cargo.toml@@ -53,9 +53,10 @@ winsafe = { version = "0.0.29", default-features = false, features = ["user"], o# DirectWrite's system font collection (src/system_fonts.rs): fonts that font services such as# Adobe Fonts load in place (#579). MIT OR Apache-2.0, already in the build through accesskit.# Win32_UI_WindowsAndMessaging has `MSG` and `WM_POINTERDOWN`, which src/windows_stylus.rs uses to-# read a pen's barrel button from its pointer messages.+# read a pen's barrel button from its pointer messages. Win32_UI_Input_Pointer has+# `GetPointerPenInfo`, which it uses to read the pen's pressure and which end of the pen is down.[target.'cfg(all(windows, not(target_vendor = "win7")))'.dependencies]-windows = { version = "0.62", features = ["Win32_Graphics_DirectWrite", "Win32_UI_WindowsAndMessaging"] }+windows = { version = "0.62", features = ["Win32_Graphics_DirectWrite", "Win32_UI_Input_Pointer", "Win32_UI_WindowsAndMessaging"] }[target.'cfg(target_os = "macos")'.dependencies]# The macOS menu bar (src/mac_menu.rs): Tauri's menu crate, AppKit menus behind a safe API (no GTKdiff --git a/apps/vectorcraft/src/main.rs b/apps/vectorcraft/src/main.rsindex d41c8bb72..73e02b79e 100644--- a/apps/vectorcraft/src/main.rs+++ b/apps/vectorcraft/src/main.rs@@ -614,6 +614,9 @@ fn services(parent: Parent, ui: egui::Context) -> Services {// macOS reads it from AppKit's events (#852).#[cfg(target_os = "macos")]stylus: mac_tablet::start(),+ // Windows reads it from the pen's pointer messages (`windows_stylus`).+ #[cfg(all(windows, not(target_vendor = "win7")))]+ stylus: Some(windows_stylus::start()),read: Some(Box::new(|p: &str| std::fs::read(p).map_err(|e| e.to_string()))),write: Some(Box::new(write_file)),exists: Some(Box::new(|p: &str| std::path::Path::new(p).exists())),@@ -974,9 +977,9 @@ fn main() -> std::process::ExitCode {}options};- // With Windows Ink, winit reports a pen as a touch and drops its barrel button; the message- // hook notes each pointer contact and whether it starts with the barrel button held- // (`windows_stylus`).+ // With Windows Ink, winit reports a pen as a touch and drops its barrel button and which end+ // is down; the message hook notes each pointer contact and whether it starts with the barrel+ // button held, and writes the pen's end into the pen feed (`windows_stylus`).#[cfg(all(windows, not(target_vendor = "win7")))]let options = {use winit::platform::windows::EventLoopBuilderExtWindows as _;diff --git a/apps/vectorcraft/src/windows_stylus.rs b/apps/vectorcraft/src/windows_stylus.rsindex cf17976b5..814ba55fe 100644--- a/apps/vectorcraft/src/windows_stylus.rs+++ b/apps/vectorcraft/src/windows_stylus.rs@@ -5,30 +5,74 @@//! second-button flag ("analogous to a mouse right button down",//! <https://learn.microsoft.com/en-us/windows/win32/inputmsg/wm-pointerdown>): [`msg_hook`] notes//! it, and [`raw_input_hook`] makes the primary button of that contact the secondary one.+//!+//! winit also drops which end of the pen is down. For each pointer message of a pen, [`msg_hook`]+//! reads the pen's `POINTER_PEN_INFO` and writes its pressure and end into the canvas's pen feed+//! ([`start`]): `PEN_FLAG_INVERTED` ("The pen is inverted") or `PEN_FLAG_ERASER` ("The eraser+//! button is pressed") is the eraser end+//! (<https://learn.microsoft.com/en-us/windows/win32/inputmsg/pen-flags-constants>). Pointer+//! messages also come while the pen hovers, so turning the pen over selects the Eraser tool before+//! it touches. A message of another pointer, a pen leaving detection range or the window, or a+//! mouse message that Windows did not make from a pen or a touch+//! (<https://learn.microsoft.com/en-us/windows/win32/tablet/system-events-and-mouse-messages>)+//! clears the feed.#![cfg_attr(not(all(windows, not(target_vendor = "win7"))), allow(dead_code))]use std::cell::RefCell;+use std::sync::OnceLock;use egui::{Event, Modifiers, PointerButton, Pos2, TouchId, TouchPhase};+use vectorcraft_ui_egui::stylus::{PenSample, StylusFeed};/// `POINTER_MESSAGE_FLAG_SECONDBUTTON` (`winuser.h`): in the high word of a pointer message's/// `wParam`, a pen in contact with its barrel button pressed.const POINTER_MESSAGE_FLAG_SECONDBUTTON: usize = 0x0020;+/// `POINTER_MESSAGE_FLAG_INRANGE` (`winuser.h`): not set on the message of a pointer that has left+/// detection range.+const POINTER_MESSAGE_FLAG_INRANGE: usize = 0x0002;/// At most this many pointer contacts wait for their touch event.const MAX_PENDING: usize = 16;+/// `PEN_FLAG_INVERTED` and `PEN_FLAG_ERASER` (`winuser.h`), in `POINTER_PEN_INFO::penFlags`.+const PEN_FLAG_INVERTED: u32 = 0x0002;+const PEN_FLAG_ERASER: u32 = 0x0004;+/// `PEN_MASK_PRESSURE` (`winuser.h`), in `POINTER_PEN_INFO::penMask`: the pen reports pressure.+const PEN_MASK_PRESSURE: u32 = 0x0001;+/// `MI_WP_SIGNATURE` and `SIGNATURE_MASK`: the extra information of a mouse message that Windows+/// made from a pen or a touch.+const MI_WP_SIGNATURE: u32 = 0xFF51_5700;+const SIGNATURE_MASK: u32 = 0xFFFF_FF00;+/// `WM_MOUSEFIRST` to `WM_MOUSELAST` (`winuser.h`).+const MOUSE_MESSAGES: std::ops::RangeInclusive<u32> = 0x0200..=0x020E;+/// `WM_POINTERUPDATE`, `WM_POINTERDOWN`, `WM_POINTERUP`, `WM_POINTERENTER` and `WM_POINTERLEAVE`+/// (`winuser.h`).+const WM_POINTERUPDATE: u32 = 0x0245;+const WM_POINTERDOWN: u32 = 0x0246;+const WM_POINTERUP: u32 = 0x0247;+const WM_POINTERENTER: u32 = 0x0249;+const WM_POINTERLEAVE: u32 = 0x024A;thread_local! {static STROKES: RefCell<BarrelStrokes> = RefCell::new(BarrelStrokes::default());}+/// The pen feed [`msg_hook`] writes, once [`start`] has made it.+static FEED: OnceLock<StylusFeed> = OnceLock::new();++/// The canvas's pen feed, which [`msg_hook`] writes on the UI thread before winit handles each+/// message, so a press never waits for it.+pub fn start() -> StylusFeed {+ FEED.get_or_init(StylusFeed::on_ui_thread).clone()+}+/// winit's message hook (`EventLoopBuilderExtWindows::with_msg_hook`), which winit calls for each/// message it takes from the thread's queue, before dispatching it: notes each pointer contact's id-/// and whether the barrel button was held.+/// and whether the barrel button was held, and writes the pen's pressure and end into the feed./// It never consumes the message.#[cfg(all(windows, not(target_vendor = "win7")))]#[allow(unsafe_code)]pub fn msg_hook(msg: *const std::ffi::c_void) -> bool {- use windows::Win32::UI::WindowsAndMessaging::{MSG, WM_POINTERDOWN};+ use windows::Win32::UI::Input::Pointer::{GetPointerPenInfo, POINTER_FLAG_INCONTACT, POINTER_PEN_INFO};+ use windows::Win32::UI::WindowsAndMessaging::{GetMessageExtraInfo, MSG};// SAFETY: winit passes the `MSG` that `PeekMessageW` has just filled, which lives for this// call; `as_ref` gives `None` for a null pointer.let Some(msg) = (unsafe { msg.cast::<MSG>().as_ref() }) else {@@ -41,9 +85,63 @@ pub fn msg_hook(msg: *const std::ffi::c_void) -> bool {}});}+ let Some(feed) = FEED.get() else {+ return false;+ };+ let read_pen = || {+ let mut info = POINTER_PEN_INFO::default();+ // SAFETY: `info` is a `POINTER_PEN_INFO` that lives for the call. The call fails for a+ // pointer that is not a pen.+ unsafe { GetPointerPenInfo((msg.wParam.0 & 0xffff) as u32, &mut info) }.ok()?;+ let in_contact = info.pointerInfo.pointerFlags.0 & POINTER_FLAG_INCONTACT.0 != 0;+ Some(pen_sample(info.pressure, info.penMask, info.penFlags, in_contact))+ };+ // SAFETY: `GetMessageExtraInfo` reads the extra information of the thread's last message.+ let from_mouse = || is_mouse(unsafe { GetMessageExtraInfo() }.0 as u32);+ if let Some(sample) = feed_update(msg.message, msg.wParam.0, read_pen, from_mouse) {+ feed.set_sample(sample);+ }false}+/// What a pen whose `POINTER_PEN_INFO` holds `pressure` (0..1024), `pen_mask` and `pen_flags`+/// reports: the pressure as winit gives it to a touch, 0 while it hovers, a full press for a pen+/// in contact that reports none; and the eraser end while it is inverted or its eraser button is+/// pressed.+fn pen_sample(pressure: u32, pen_mask: u32, pen_flags: u32, in_contact: bool) -> PenSample {+ let pressure = match pressure {+ 1..=1024 if pen_mask & PEN_MASK_PRESSURE != 0 => pressure as f32 / 1024.0,+ _ if in_contact => 1.0,+ _ => 0.0,+ };+ PenSample { pressure, eraser: pen_flags & (PEN_FLAG_INVERTED | PEN_FLAG_ERASER) != 0 }+}++/// Whether a mouse message with this extra information (`GetMessageExtraInfo`) comes from a mouse,+/// not from a pen or a touch.+fn is_mouse(extra_info: u32) -> bool {+ extra_info & SIGNATURE_MASK != MI_WP_SIGNATURE+}++/// What the feed is set to for a message with this `wParam`: `Some(Some(sample))` for a pointer+/// message of a pen in range (`read_pen`), `Some(None)` for a pointer message of another pointer,+/// a pointer leaving detection range or the window, or a mouse message from a mouse+/// (`from_mouse`), and `None` to leave it as it is.+fn feed_update(+ message: u32,+ wparam: usize,+ read_pen: impl FnOnce() -> Option<PenSample>,+ from_mouse: impl FnOnce() -> bool,+) -> Option<Option<PenSample>> {+ match message {+ WM_POINTERENTER | WM_POINTERUPDATE | WM_POINTERDOWN | WM_POINTERUP if (wparam >> 16) & POINTER_MESSAGE_FLAG_INRANGE == 0 => Some(None),+ WM_POINTERENTER | WM_POINTERUPDATE | WM_POINTERDOWN | WM_POINTERUP => Some(read_pen()),+ WM_POINTERLEAVE => Some(None),+ m if MOUSE_MESSAGES.contains(&m) && from_mouse() => Some(None),+ _ => None,+ }+}+/// Before egui reads a frame's input: the primary button of a contact that started with the/// barrel button held becomes the secondary button.pub fn raw_input_hook(raw: &mut egui::RawInput) {@@ -287,6 +385,59 @@ mod tests {assert_eq!(buttons(&rewrite(&mut strokes, &events)), [PRIMARY_DOWN]);}+ /// `PEN_FLAG_BARREL` (`winuser.h`).+ const PEN_FLAG_BARREL: u32 = 0x0001;++ #[test]+ fn an_inverted_pen_or_its_eraser_button_is_the_eraser_end() {+ let eraser = |flags| pen_sample(512, PEN_MASK_PRESSURE, flags, true).eraser;+ assert!(!eraser(0), "the tip");+ assert!(!eraser(PEN_FLAG_BARREL), "the barrel button");+ assert!(eraser(PEN_FLAG_INVERTED), "turned over");+ assert!(eraser(PEN_FLAG_ERASER), "the eraser button");+ assert!(eraser(PEN_FLAG_INVERTED | PEN_FLAG_ERASER));+ assert!(eraser(PEN_FLAG_INVERTED | PEN_FLAG_BARREL));+ }++ #[test]+ fn a_pens_pressure_is_the_one_winit_gives_its_touch() {+ assert_eq!(pen_sample(512, PEN_MASK_PRESSURE, 0, true).pressure, 0.5);+ assert_eq!(pen_sample(1024, PEN_MASK_PRESSURE, 0, true).pressure, 1.0);+ assert_eq!(pen_sample(0, PEN_MASK_PRESSURE, PEN_FLAG_INVERTED, false), PenSample { pressure: 0.0, eraser: true }, "hovering");+ assert_eq!(pen_sample(0, 0, 0, true).pressure, 1.0, "a pen in contact that reports no pressure presses fully");+ assert_eq!(pen_sample(300, 0, 0, true).pressure, 1.0, "a pressure without the pressure mask is not one");+ assert_eq!(pen_sample(0, PEN_MASK_PRESSURE, 0, true).pressure, 1.0, "as winit, which gives no force for 0");+ assert_eq!(pen_sample(2000, PEN_MASK_PRESSURE, 0, false).pressure, 0.0);+ }++ #[test]+ fn mouse_messages_from_a_pen_or_a_touch_are_told_apart() {+ assert!(is_mouse(0), "a mouse");+ assert!(!is_mouse(0xFF51_5701), "a pen");+ assert!(!is_mouse(0xFF51_5780), "a touch");+ assert!(is_mouse(0xFF51_5600));+ }++ #[test]+ fn pen_messages_set_the_feed_and_other_pointers_clear_it() {+ let pen = PenSample { pressure: 0.0, eraser: true };+ // `POINTER_MESSAGE_FLAG_INRANGE` in the high word of `wParam`, pointer 7 in the low word.+ let in_range = (POINTER_MESSAGE_FLAG_INRANGE << 16) | 7;+ let no_mouse = || -> bool { panic!("a pointer message is not a mouse message") };+ let no_pen = || -> Option<PenSample> { panic!("no pen to read") };+ for m in [WM_POINTERENTER, WM_POINTERUPDATE, WM_POINTERDOWN, WM_POINTERUP] {+ assert_eq!(feed_update(m, in_range, || Some(pen), no_mouse), Some(Some(pen)), "{m:#x}");+ assert_eq!(feed_update(m, in_range, || None, no_mouse), Some(None), "a touch: {m:#x}");+ assert_eq!(feed_update(m, 7, no_pen, no_mouse), Some(None), "out of range: {m:#x}");+ }+ assert_eq!(feed_update(WM_POINTERLEAVE, in_range, no_pen, no_mouse), Some(None));+ // WM_MOUSEMOVE and WM_LBUTTONDOWN.+ assert_eq!(feed_update(0x0200, 0, no_pen, || true), Some(None), "a mouse moved");+ assert_eq!(feed_update(0x0201, 0, no_pen, || false), None, "made from a pen");+ // WM_KEYDOWN.+ assert_eq!(feed_update(0x0100, 0, no_pen, || -> bool { panic!("not a mouse message") }), None);+ }+#[test]fn contacts_whose_touch_never_arrives_are_bounded() {let mut strokes = BarrelStrokes::default();diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rsindex 440eb11ea..93d1366a6 100644--- a/crates/ui-egui/src/lib.rs+++ b/crates/ui-egui/src/lib.rs@@ -332,7 +332,7 @@ pub struct Services {/// pointer visible next to the tool glyph ([`cursors::hide_system_pointer`], #2450).pub no_cursor_theme: bool,/// The pen pressure and pen end the host reads from the system itself (desktop Linux under- /// X11 and XWayland). The canvas uses the pressure when a frame's events carry no touch force,+ /// X11 and XWayland, macOS and Windows). The canvas uses the pressure when a frame's events carry no touch force,/// and the end to switch to the Eraser tool and back. Without it, pen pressure comes from/// touch events only ([`stylus`]).pub stylus: Option<stylus::StylusFeed>,diff --git a/crates/ui-egui/src/stylus.rs b/crates/ui-egui/src/stylus.rsindex f45251b15..f2f65b226 100644--- a/crates/ui-egui/src/stylus.rs+++ b/crates/ui-egui/src/stylus.rs@@ -6,8 +6,10 @@//! from XInput2 on a connection of its own and writes it into a [`StylusFeed`]//! ([`crate::Services::stylus`]). On macOS, where winit reports none either, the app reads each//! event's pressure from AppKit before the window handles it, and also keeps it for that event's-//! pointer move ([`StylusFeed::set_move`]), so the moves of a fast stroke each get their own. The-//! canvas uses the feed when a frame's events carry no touch force.+//! pointer move ([`StylusFeed::set_move`]), so the moves of a fast stroke each get their own. On+//! Windows, where winit drops which end of the pen is down, the app reads the pressure and the end+//! from each pointer message of a pen before winit handles it. The canvas uses the feed when a+//! frame's events carry no touch force.//!//! The feed also says which end of the pen moved. Turning the pen to its eraser end selects the//! Eraser tool, and turning it back to the tip selects the tool used beforediff --git a/docs/gaps.md b/docs/gaps.mdindex 48ec6b817..658571250 100644--- a/docs/gaps.md+++ b/docs/gaps.md@@ -443,9 +443,10 @@ from G14 and the budget run of G15: **~170–270 h** one agent, ~50–80 h wall- **Done:** pen pressure on macOS (#852), read from AppKit's tablet events before the window gets them, eachmove of a stroke with its own pressure, and the pen's eraser end there selecting the Eraser tool, as on Linux- under X11 and XWayland; not yet tried on a Mac with a tablet.+ under X11 and XWayland; not yet tried on a Mac with a tablet. The pen's eraser end on Windows with Windows Ink,+ read from the pen's pointer messages; not yet tried with a pen.- **Missing:** pen pressure on native Wayland (#491, #764) — winit 0.30 reports none there; tilt, bearing and- barrel rotation for brushes (6D Art Pen, #372); the eraser end on Windows, native Wayland and the web.+ barrel rotation for brushes (6D Art Pen, #372); the eraser end on native Wayland and the web.- **Estimate:** 4–10 h, partly waiting on winit 0.31; needs pen hardware to verify.## G5 Brushes, symbols and librariesdiff --git a/docs/hardware-parity.md b/docs/hardware-parity.mdindex 7e8ab2ff4..e92d95233 100644--- a/docs/hardware-parity.md+++ b/docs/hardware-parity.md@@ -12,7 +12,7 @@ documentation (GPU Performance, touch workspace, pen pressure pages); ours from**~35% (estimated), 25–45 h.** VectorCraft rasterizes the canvas on the CPU (multithreaded `vello_cpu`) and usesthe GPU only to composite, so any GPU that can show a window works, at the cost of GPU-accelerated previewon huge documents. VectorCraft reads pen pressure on Windows, on the web, on macOS, and on Linux under X11 and XWayland, and it-reads the pen's eraser end on macOS and on Linux under X11 and XWayland.+reads the pen's eraser end on Windows, on macOS and on Linux under X11 and XWayland.| Feature | Illustrator | VectorCraft macOS | Windows | Linux | Web | Status / hours ||---|---|---|---|---|---|---|@@ -22,7 +22,7 @@ reads the pen's eraser end on macOS and on Linux under X11 and XWayland.| Restart on another GPU when the first fails to present | — | yes (#502, #964) | yes | yes | restart on lost device (#369) | done || Pen pressure | yes (Wacom, Windows Ink, macOS tablet events) | yes, read from AppKit's tablet events before the window gets them (winit reports none), each move of a stroke with its own pressure, mouse event coalescing off (#852; not yet tried on a Mac) | yes (pointer force via `WM_POINTER`) | under X11 and XWayland (Preferences › Performance › Linux Display Server, #1151, #2028), read from XInput2 raw events (#764); **no** on native Wayland, where winit reports none and the pen may not reach the window (#491) | browser pointer events, with coalesced events; Apple Pencil on iPad (hover, palm rejection: fingers navigate after a pen contact until reload) | partial: 2–4 h for Wayland (winit 0.31), plus a check on a Mac || Pen tilt, bearing, barrel rotation (6D Art Pen) | yes, drives brushes | no | no | no | no | missing: 4–8 h after the input layer (#372) |-| Pen eraser end | yes | the eraser end (AppKit's tablet proximity events) selects the Eraser tool and the tip brings back the tool used before, as on Linux (#852; not yet tried on a Mac) | no | under X11 and XWayland, the eraser end selects the Eraser tool and the tip brings back the tool used before (#764); **no** on native Wayland | no | partial |+| Pen eraser end | yes | the eraser end (AppKit's tablet proximity events) selects the Eraser tool and the tip brings back the tool used before, as on Linux (#852; not yet tried on a Mac) | with Windows Ink, an inverted pen or its eraser button (`PEN_FLAG_INVERTED`, `PEN_FLAG_ERASER` in the pen's pointer messages) selects the Eraser tool and the tip brings back the tool used before, as on Linux (not yet tried with a pen) | under X11 and XWayland, the eraser end selects the Eraser tool and the tip brings back the tool used before (#764); **no** on native Wayland | no | partial || Touch gestures (pinch zoom, two-finger pan, rotate view, Touch workspace) | yes (Windows touch, Surface) | trackpad pinch, scroll and rotate | pinch, pan; two-finger tap undo, three-finger redo (#585) | same where winit reports touch | eframe until the first pen contact, then Pointer Events (pen and fingers told apart); long press opens the context menu | partial: touch workspace and touch-screen rotation missing, 3–5 h || Trackpad (smooth scroll, pinch) | yes | yes | precision touchpads | yes | yes | done || HiDPI / Retina, per-monitor scale | yes | yes | yes | yes | yes | done; a window dragged between monitors of different scale can still grow on Windows (#1459, open); the custom title bar's window on Windows stays truly borderless so the pointer lines up with what is drawn (#1791, #1758; awaiting the reporter's confirmation) |diff --git a/docs/target-app-parity.md b/docs/target-app-parity.mdindex 457857325..52f937406 100644--- a/docs/target-app-parity.md+++ b/docs/target-app-parity.md@@ -996,6 +996,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur- **Linux pen pressure (part of #764):** when the window is on X11, XWayland included, the desktop app reads a drawing tablet's pen pressure from XInput2 raw events on a second X connection, and the Paintbrush's pressure-sensitive brushes and the Liquify tools' Use Pressure Pen get it.- **Linux pen eraser end (part of #764):** when the window is on X11, XWayland included, turning a drawing tablet's pen to its eraser end selects the Eraser tool, and turning it back to the tip selects the tool used before, unless another tool was chosen meanwhile. A turn during a press takes effect after the release, and a turn made while the pointer is over another window takes effect when it comes back over VectorCraft's window.- **Pen barrel button on Windows:** with Windows Ink, a pen that touches down with its barrel button held acts as the right mouse button until it lifts, so a tap opens the canvas context menu; on Linux the barrel button is the right button (#3659). A touch with the tip alone is the left button, with pressure, as before.+- **Pen eraser end on Windows:** with Windows Ink, turning a pen over, or holding its eraser button, selects the Eraser tool, and the tip selects the tool used before, as on Linux and macOS; the switch comes while the pen hovers, so the eraser end erases from its first touch.- **Control transport:** idle sockets expire after 5 minutes, partial lines after an absolute 30 seconds from their first byte, and reply writes after 60 seconds (#1726). Real TCP regressions cover stalled peers and slot recovery; command execution has its separate existing timeout. MCP limits: 16 MiB lines, 64-message batches, 256-step `command_batch` with 8 MiB of kept results and 256 MiB control replies (#1764, fixes #1727). MCP requires the JSON-RPC 2.0 envelope and matches control replies by id, and an app refusal without an id reports the app's reason (#1768, fixes #1728). The MCP server reconnects to the app before a call when the connection was closed or holds stray bytes, after an app restart or an idle expiry (#1739).- **MCP vertical type:** `add_text {vertical: true}` forwards to `text.create` or `text.createInPath`. Regression coverage checks point type, rectangular area type, type in a path and type on a path with true, false and omitted direction. This exposes an existing engine option; it does not change glyph orientation, CJK composition or the type/automation scores.- **Malformed MCP replies:** invalid JSON from the app drops the connection, reports that the operation may have completed and leaves the next call to reconnect; it never replays the edit (#1761). TCP regressions cover malformed and uncorrelated replies, connection closure and a subsequent inspection. Envelope regressions also verify zero backend calls and unchanged initialization state for invalid versions.