Release v0.6.38: avoid unnecessary RichEdit and cancel hidden history previews

CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.24)
-project(KSwitcher VERSION 0.6.27 LANGUAGES CXX RC)
+project(KSwitcher VERSION 0.6.38 LANGUAGES CXX RC)
 if(NOT WIN32)
   message(FATAL_ERROR "KSwitcher uses native Windows APIs")
 endif()
@@ -48,6 +48,7 @@ else()
 endif()
 add_executable(KSwitcherOcrTests tests/ocr.cpp src/screenshot_launcher.cpp src/screenshot_activation.cpp src/app.cpp src/screenshot_notifications.cpp src/screenshot.cpp src/configuration.cpp src/ui.cpp resources/app.rc)
 target_link_libraries(KSwitcherOcrTests PRIVATE kscore)
+add_dependencies(KSwitcherOcrTests KSwitcherScreenshot)
 if(MSVC)
   set_property(TARGET kscore KSwitcher KSwitcherConfig KSwitcherScreenshot KSwitcherTests KSwitcherScrollTests KSwitcherIntegration KSwitcherInputTests KSwitcherOcrTests PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
   target_compile_options(kscore PRIVATE /W4 /utf-8)
@@ -65,6 +66,26 @@ else()
   target_link_options(KSwitcherOcrTests PRIVATE -static -static-libgcc -static-libstdc++)
 endif()
 enable_testing()
+add_executable(KSwitcherImageCaptureTests tests/image_capture.cpp)
+target_link_libraries(KSwitcherImageCaptureTests PRIVATE kscore)
+add_dependencies(KSwitcherImageCaptureTests KSwitcherScreenshot)
+if(MSVC)
+  target_compile_options(KSwitcherImageCaptureTests PRIVATE /utf-8)
+  set_property(TARGET KSwitcherImageCaptureTests PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+else()
+  target_link_options(KSwitcherImageCaptureTests PRIVATE -static -static-libgcc -static-libstdc++)
+endif()
+# Explicit interactive test: stop the resident first so its clipboard listener
+# does not capture the test fixtures. Like KSwitcherIntegration, not part of ctest.
+add_executable(KSwitcherDictionaryTests tests/dictionary.cpp)
+target_link_libraries(KSwitcherDictionaryTests PRIVATE kscore psapi)
+if(MSVC)
+  set_property(TARGET KSwitcherDictionaryTests PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+else()
+  target_link_options(KSwitcherDictionaryTests PRIVATE -static -static-libgcc -static-libstdc++)
+endif()
+add_test(NAME dictionary-regressions COMMAND KSwitcherDictionaryTests)
+set_tests_properties(dictionary-regressions PROPERTIES WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
 add_test(NAME sync-regressions COMMAND KSwitcherSyncTests)
 add_test(NAME native-regressions COMMAND KSwitcherTests)
 add_test(NAME scroll-regressions COMMAND KSwitcherScrollTests)

README.md

@@ -16,10 +16,15 @@ Run `build/KSwitcher.exe`, or extract `dist/KSwitcher-win-x64.zip` and run the e
 The build also refreshes the release copy in `build/release/`. Exit KSwitcher before rebuilding.
 The application lives in the notification area. Right-click its icon for Settings, Snippets and history.
 Double-click the tray icon to open Settings, the bold default menu item.
+Closing Settings with unsaved changes (including accepted auto-correction or OCR options)
+asks whether to save, discard changes, or keep editing. Unchanged settings close without a prompt.
+If saving fails, the window stays open with your edits intact.
 Menus support access keys: press the underlined letter while the menu is open (for example,
 S for Settings or X for Exit in the tray menu). In forms, press Alt+the underlined letter
-to activate a button, toggle a checkbox or focus a labeled field. Press Alt to reveal
+to activate a button, toggle a checkbox or focus a labeled field. Dialog underline visibility
-the underlines when Windows hides them. Shortcut-capture fields still record Alt combinations;
+still follows Windows preferences; press Alt in a dialog to reveal them.
+From v0.6.33, tray and history menus show access letters in the right-hand column.
+Press the menu letter without Alt: Alt dismisses an open menu. Shortcut-capture fields still record Alt combinations;
 press Tab to leave a shortcut field before using form access keys.
 Settings, the snippet editor and log viewer run on demand in **KSwitcher.Config.exe**, beside the main executable.
 Repeated launches activate the existing configurator; closing its last window exits that process.
@@ -170,7 +175,8 @@ for shapes.
 **Canvas zoom:** use **Ctrl++ / Ctrl+-** (including numpad keys) or **Ctrl+mouse wheel**.
 Each step changes the view by 25%; the wheel zooms around the cursor, keyboard shortcuts around
 the viewport center. **Ctrl+0** restores the initial fit. Drag with the **middle mouse button**
-to pan an enlarged image. Zoom ranges from 0.1× to 16× the initial fit; the status bar shows the
+to pan an enlarged image. Panning is limited to axes where the image exceeds the viewport;
+an image that fits stays centered. Zoom ranges from 0.1× to 16× the initial fit; the status bar shows the
 actual image scale. Zoom and pan do not change annotations, export resolution or undo history.
 The wheel without Ctrl still adjusts the object under the cursor.
 
@@ -186,6 +192,9 @@ Every shape has a round rotation handle above its outline. Drag it to rotate aro
 hold **Shift** for 15-degree steps. The handle works for toolbar shapes and recognized shapes,
 including triangles. Resize handles and attached connectors follow the rotation; Ctrl+Z/Ctrl+Y
 undo and redo it. The square handle still controls outline thickness.
+From v0.6.34, endpoint, shape-corner and number-radius handles show the four-direction move cursor.
+Thickness handles retain directional resize cursors; rotation retains the hand cursor. Dragging,
+snapping and shape constraints are unchanged.
 **Triangle (G)** is also available directly on the toolbar: drag to create a triangle.
 Both drawn and recognized triangles have three independent vertex handles instead of bounding-box
 resize handles. Drag any vertex to reshape the triangle while keeping the other two fixed, even
@@ -271,7 +280,11 @@ thumbnails and source labels aligned with the scaled fonts and spacing.
 - Clipboard snapshot/restoration with concurrent-copy, foreground and input-version checks.
   A silently dropped copy is retried up to three total attempts while the clipboard and input
   context remain unchanged. Temporary transaction contents are excluded from Windows clipboard
-  history and cloud synchronization. Paste is not blindly retried.
+  history and cloud synchronization. Paste is not blindly retried: with manual paste readback
+  enabled by Write log, a native Windows EDIT gets at most one retry when readback reports the
+  original and fresh native queries confirm that exactly the original range is still selected.
+  Other controls and unknown/changed selections are not retried. A verified failed paste clears
+  repeat-conversion state and does not switch the Windows layout.
 - Case cycling, Russian/Ukrainian transliteration, verified undo and repeated conversion.
 - Text snippets across layouts, multiline insertion and a verified `{cursor}` position;
   `{enter}` presses Enter after insertion and cursor placement (once per marker), before buffered typing resumes.
@@ -321,6 +334,10 @@ existing saved shortcuts are preserved. While KSwitcher runs, this binding opens
 
 History controls: Enter to paste, Shift+Enter for plain text, Ctrl+1…9 for quick paste,
 Ctrl+P to pin/unpin, Delete to delete, Ctrl+O for the full item, Escape to hide.
+
+**Clear history… / Alt+H** in the history window clears all saved entries after confirmation,
+including pinned entries and entries hidden by search. No is the default choice. The current
+Windows clipboard and future recording are unchanged. Settings also retains its Clear history action.
 For an image, **Edit image**, **Ctrl+O**, or **Edit image in screenshot editor**
 in the context menu opens the original image in the built-in screenshot editor.
 Annotate it there, then copy the result. Opening the editor leaves the
@@ -336,7 +353,14 @@ the executable's directory is not writable. Each clipboard payload is an encrypt
 only bounded previews/metadata stay in memory. Image data is loaded on demand and released when
 the history popup is hidden. Settings **Write log** (`writeLog`, enabled by default) controls all
 log writes. Disabling it also clears diagnostic context from memory; existing log files remain.
-Diagnostic stages stay in a memory buffer of at most 40 events for 30 seconds.
+Diagnostic stages stay in a memory buffer of at most 128 events for 30 seconds.
+Selection diagnostics include the expected text, each copied candidate before and after suffix
+recovery, paced Shift+Left progress or batch delivery counts, and clipboard sequence changes,
+retry counts and elapsed times. Focus, caret geometry and keyboard layout are recorded when
+Windows exposes them; selection offsets are available for native EDIT controls and explicitly
+marked unavailable for other editors. Input interruptions identify keyboard, mouse, settings
+or layout-refresh events during an operation. Failed selection verification includes the expected
+selection and actual copied text in the operation details, without implying that a paste occurred.
 Only problem operations write a structured summary to `kswitcher.log`, with their preceding
 context. Successful operations stay in that bounded memory buffer and are included only when
 a subsequent problem flushes it; they do not create separate rows. Flushed context is discarded. Ordinary application
@@ -404,6 +428,10 @@ reverse-proxy URL prefixes, MFA login flows and other providers are not implemen
 
 Enable synchronization and choose **Save / Sign in / Sync**. The dialog saves connection changes
 immediately; the main Settings window's Save/Cancel does not control this separate configuration.
+When synchronization is disabled, connection fields and sync actions are inactive. Check **Enable
+synchronization** to make them available. To disable an existing connection, uncheck it and click
+**Save**; this preserves the saved connection and password without starting a sync request.
+**Disconnect / forget password** remains available while synchronization is disabled.
 A blank password keeps the existing Windows credential for that server, login mount and username.
 The password is saved in Windows Credential Manager, not in settings exports, logs or the remote
 profile. HTTPS certificate validation is mandatory and redirects are refused. Login tokens are
@@ -414,11 +442,15 @@ saved credential. A request already sent to the server may still complete; its d
 will not be applied after the connection changes. Old credentials for other connection identities
 can be removed in Windows Credential Manager under `KSwitcher.Sync/`.
 
-First connection is deliberately explicit:
+On the first connection, **Save / Sign in / Sync** merges the existing profiles without
+requiring a whole-profile replacement. Independent entries (such as snippets, exclusions and
+replacement pairs) are combined. Different values for the same setting remain on their respective
+sides and appear in **Resolve individual conflicts...**; no value is guessed without a common history.
+Nonconflicting changes synchronize immediately, and unresolved conflicts survive subsequent syncs.
 
 - **Upload local** creates the remote profile or replaces it with this PC's saved shared settings.
 - **Download remote** replaces this PC's shared settings with the server profile.
-- If both profiles are identical, ordinary Sync can establish the baseline without a replacement.
+- If the server has no profile yet, choose **Upload local** to create it.
 - Unsaved edits in Settings are not synchronized. Close and reopen Settings after a download;
   the existing stale-editor check prevents an old Settings window overwriting downloaded changes.
 
@@ -453,8 +485,14 @@ Deleted server versions are not silently recreated.
 Hotkeys, snippets, application exclusions, layout order, conversion, screenshot and autocorrection
 preferences are shared. Startup/elevation, keep-awake, logging, history enablement/limits,
 Tesseract executable/engine selection, connection details and credentials stay local. Clipboard
-history, screenshots and dictionary files are never uploaded. Missing keyboard layouts block
+history, screenshots and dictionary files are never uploaded. Full synchronization identifies
-applying a remote profile until those Windows layouts are installed, preventing lost bindings.
+missing keyboard layouts by language (when Windows can identify it) and exact ID.
+Install the same layout variant, or select **Keep this PC's layouts and layout shortcuts (sync
+other settings)** and click **Save / Sign in / Sync**. This device-local option keeps the entire
+local layout cycle and its direct shortcuts unchanged while synchronizing the other shared settings.
+The server's layout cycle and direct shortcuts are preserved on automatic sync and explicit Upload;
+Download also keeps the local layout configuration. Later syncs cannot erase missing server layouts
+just because this PC does not have them installed. Uncheck the option to resume full layout sync.
 Settings are JSON inside OpenBao; this is not end-to-end encryption from the vault administrator.
 
 The last common profile (`sync-base.bin`) and the settings preceding the most recent downloaded
@@ -506,13 +544,40 @@ Alternatively open this directory as a CMake project in Visual Studio with the C
 and Windows SDK installed, or use CMake with a Windows GCC toolchain. CMake/MSVC is provided but the
 verified local build uses GCC/w64devkit.
 
-## Automatic layout correction (experimental)
+## Automatic correction (experimental)
 
-Enable **Automatically correct layout (experimental)** in Settings, then use **Auto-correction
+Enable **Automatic correction (experimental)** in Settings, then use **Auto-correction
 options…** to select dictionary languages and edit excluded applications or words to never correct.
 The feature is off by default. English and Ukrainian are selected initially; Russian is optional.
 Target layouts must also be enabled in the layout cycle.
 
+### Custom replacements and spelling typos
+
+Two optional modes in **Auto-correction options…** extend layout correction. Both are off by
+default and require the main **Automatic correction (experimental)** checkbox to be enabled.
+
+- **Use custom replacements**: enter one `typo=correction` pair per line, for example
+  `првиіт=привіт` or `helo=hello`. Entries are normalized to lowercase; duplicate source words
+  are rejected. Each side must contain 1–32 letters of the same supported language, without
+  spaces or punctuation. Explicit pairs take priority over dictionary recognition, including
+  already valid words, and do not require dictionary membership or satisfy the frequency limit.
+- **Correct spelling typos using dictionaries**: checks unknown words in the current language
+  after no layout correction is found. It accepts exactly one dictionary candidate reachable
+  by inserting, deleting or replacing one letter, or swapping two adjacent letters. Both input
+  and target must have at least four letters. Multiple candidates leave the input unchanged,
+  even if a frequency limit would exclude one of them. Personal dictionary words participate.
+  This is word-level spelling correction, not grammar or sentence-context correction.
+
+Both modes run after Space, preserve surrounding punctuation and an initial capital, and keep
+the current layout. The selected dictionary languages, enabled layout cycle, minimum input
+length, excluded applications, never-correct list, protected fields and Undo behavior apply.
+ALL CAPS, mixed-case identifiers, numbers, URLs and email addresses are skipped. A replacement
+is applied once, without chaining. Click **OK**, then **Save** in Settings; pairs and switches
+are included in settings export/import and synchronization. Undo restores the original word
+and suppresses its correction until restart.
+
+### Layout correction and shared options
+
 **Characters before a word** and **Characters after a word** configure punctuation to preserve around
 the corrected word. Enter characters directly, without spaces or separators; a comma or semicolon
 is itself a character. Defaults include parentheses, square/curly brackets, quotation marks and common
@@ -562,7 +627,12 @@ support automatic correction. Dictionary recognition is heuristic, not an unders
 subtitle vocabulary is incomplete, and uncommon names or jargon can need personal exceptions.
 
 No network service or language model is used. The three dictionary files occupy about 2.6 MB on disk;
-the English/Ukrainian lookup data uses less than 3 MiB of RAM and is loaded on first automatic check.
+the bundled EN/UK/RU lookup payload uses about 0.90 MiB of RAM. When automatic correction is enabled,
+selected dictionaries are loaded before typing and shared by the input predictor and worker.
+Words are stored in compact indexed blocks; all words and frequency ranks are retained, and editable
+UTF-8 dictionary files keep the same format. Custom dictionaries can use more memory.
+`build.ps1 -Test` checks every bundled word/rank and measures lookup speed; CMake exposes the same
+check as `dictionary-regressions`. The payload figure excludes the rest of the process and allocator overhead.
 Keep `dictionaries/` beside the executable when copying the app. These word lists derive from
 [FrequencyWords](https://github.com/hermitdave/FrequencyWords) and are separately licensed under
 CC BY-SA 4.0; attribution, pinned source revision and license are in `dictionaries/`.
@@ -633,3 +703,25 @@ Keep `v0.4.2` as the last legacy `vX.Y.Z` release. Publish full packages as
 legacy version tag: clients that have not installed the bridge would select it.
 Keep the compatibility bridge in the first 100 releases returned by Gitea while
 supporting old clients; their immutable update code only reads that page.
+
+### Editors that omit copied trailing spaces
+
+From v0.6.31, KSwitcher recovers trailing ordinary spaces omitted by Ctrl+C only when Windows accessibility proves the complete selection. The same focused control and range are rechecked before paste, and the result is read back even without Write log. Recent-text conversion, automatic correction, repeat conversion and Undo retain exact verification. Missing letters, tabs, line breaks and unavailable or ambiguous selections are not reconstructed. No setting or shortcut has changed.
+
+### Notification registration and Viber — v0.6.36
+
+Notification registration runs in KSwitcher.Screenshot.exe; keep all three executables together. Startup registration is asynchronous. Viber pastes allow 75 ms for clipboard notifications before Ctrl+V, retaining focus, ownership and selection checks. This mitigates an intermittent clipboard timing issue; it does not guarantee all Viber failures are resolved. UI Automation is unchanged.
+
+### Image history, OCR and duplicate fingerprints — v0.6.37
+
+Image clipboard capture and automatic/uncached manual history OCR run in short-lived KSwitcher.Screenshot.exe processes. Keep all three executables together. Original clipboard formats, image limits, privacy exclusions, Windows OCR, optional Tesseract and searchable encrypted OCR results are preserved. Background OCR is cancelled on shutdown or an OCR-profile change; late results do not recreate deleted entries.
+
+Consecutive duplicates use SHA-256 fingerprints inside the encrypted history index, including pixel fingerprints for equivalent image encodings. Older entries acquire fingerprints on first comparison without a bulk migration. Pins and OCR caches survive duplicate detection; non-consecutive copies still create separate entries. New text no longer loads the preceding image to rule out a duplicate. No shortcut, setting or default changed.
+
+Moving OCR isolates its temporary memory rather than reducing the combined processing peak. A controlled three-run comparison retained about 0.8 MiB less private RAM in the caller after recognition; combined peak RAM was about 55.6 MiB before and 56.6 MiB with the helper. Results depend on the image, OCR engine and system.
+
+### History previews and Escape — v0.6.38
+
+History initializes RichEdit only for HTML/RTF previews. Plain text keeps Unicode and line breaks without RTF conversion; empty history and image-only previews do not load RichEdit unnecessarily. Plain and formatted text previews share the existing bounded text-preview cache.
+
+Esc clears hidden rows/caches and cancels obsolete queued preview work, while retaining the selected/top entry for reopening. Already-needed RichEdit controls are cleared and reused. Clipboard contents, paste formatting, OCR, settings and shortcuts are unchanged. A local isolated comparison saved approximately 0.48–0.72 MiB private working set after Esc depending on content; this is not a fixed application footprint or a guarantee that all UI memory returns to the startup level.

Release/README.md

@@ -1,29 +1,22 @@
 # Latest Windows release
 
-## v0.6.27 — 2026-11-02
+## v0.6.38 — 2026-11-04
 
 ## Changes
-- Tray and clipboard context menus support underlined access keys. Press the letter while a menu is open (S for Settings, X for Exit).
+- Clipboard history loads RichEdit only when an HTML/RTF preview actually needs it. Empty history, plain text and image-only previews no longer initialize it unnecessarily.
-- Alt+letter activates buttons and checkboxes in Settings, Snippets, Logs, synchronization/conflict, OCR and dictionary dialogs. Selected field labels also move focus to their input.
+- Plain text previews retain Unicode and line breaks without converting the text to RTF. Plain and formatted preview payloads share the existing bounded text-preview cache.
-- Clipboard history supports Alt+letter for its actions and search while retaining Enter, Shift+Enter and Ctrl+digit shortcuts.
+- Esc still clears hidden history rows and preview caches while preserving the remembered selection/top item. Closing or replacing a search now cancels obsolete preview work before loading/decoding where possible, and discards completed stale results.
-- Press Alt to reveal Windows' hidden underlines. Shortcut capture still records Alt combinations; press Tab to leave the capture field before using form access keys. Captions and access keys currently use English letters.
+- A RichEdit control that was needed for formatted text is cleared and reused, not repeatedly destroyed/recreated. This avoids additional initialization on reopening. Settings, shortcuts, stored clipboard contents, formatting on paste and OCR behavior are unchanged.
 
 ## Validation
-91 sync/protocol/conflict checks, 423 native regressions, 513 input/UI checks (including Windows Alt+K dispatch and checkbox toggling), shared wheel handling, screenshot editor and PNG save regressions, notification registration, 48 updater checks and updater progress checks.
+Staged build and tests cover dictionary equivalence for 140,939 words, 105 sync checks, wheel batching, 315 native checks, 561 input checks, screenshot UI/PNG/notification registration, 48 updater checks and updater progress UI. Added checks for plain previews without RichEdit, retained HTML rendering, lazy control creation and cleanup through Esc. Isolated real-window tests also verified formatted previews after reopening.
 
-## Limitations
+A controlled local comparison measured 0.72 MiB less private working set after Esc for empty history, 0.66 MiB for plain text, 0.48 MiB for formatted text and 0.53 MiB for images. These are isolated test-process comparisons, not the application's total RAM or a guaranteed reduction on another computer. The reported 7 MiB plateau on a different laptop was not reproduced. No working-set trimming was used; closing the history window does not promise an exact return to startup memory.
-OpenBao synchronization is experimental and requires a reachable HTTPS server with a trusted certificate, KV v2 and a provisioned userpass account/policy. It does not provide account registration, MFA login, non-root namespaces or reverse-proxy URL prefixes. Ordered layout/language lists are resolved as whole settings. Deletion records are retained without expiry. Missing keyboard layouts block applying a profile. Download/Upload replace a whole profile and are intended for initial setup or deliberate recovery; use Resolve individual conflicts for normal conflicts. Existing browser-selection and clipboard/accessibility limitations remain unchanged.
 
-**Upgrade:** choose Update in the tray menu. Legacy v0.3.0–v0.4.1 clients first receive the v0.4.2 compatibility bridge, then the current full release. v0.2.3 and earlier require manual installation.
+## Upgrade
+Choose **Update** in the tray menu. Legacy v0.3.0–v0.4.1 clients first receive the v0.4.2 compatibility bridge, then the current full release. v0.2.3 and earlier require manual installation.
 For manual installation, exit KSwitcher, close screenshot editors and extract the entire ZIP into its installation folder. Keep personal `data/` and customized dictionaries.
 
-Download **KSwitcher-win-x64.zip** with **SHA256SUMS.txt**. The package contains all three executables, a release manifest, offline dictionaries, documentation and license notices. It contains no personal settings, passwords, server address, clipboard history, Tesseract installation or language models.
+Download **KSwitcher-win-x64.zip** with **SHA256SUMS.txt**. Keep all three executables together. The package contains no personal settings, credentials or clipboard history.
 
-Build and package:
+Publish stable `release-vX.Y.Z` tags matching the executable version. Keep `v0.4.2` as the last legacy tag.
-
-```powershell
-.\build.ps1 -Stage -Test
-.\package.ps1 -PublishRelease
-```
-
-Commit the archive, checksum and sources together. Publish both assets on a stable `release-vX.Y.Z` tag matching the executable version. Keep `v0.4.2` as the last legacy tag.

Release/SHA256SUMS.txt

@@ -1 +1 @@
-e6597d11fc388979e972c8572e2471a00dec6c3782414a22d396072508fe7329  KSwitcher-win-x64.zip
+f430767d440581018e6adb33c153fb332318fa1eee5a162ddf32690d0b5a3391  KSwitcher-win-x64.zip

build.ps1

@@ -37,10 +37,14 @@ try {
     if ($LASTEXITCODE) { throw 'Configurator link failed' }
     Copy-Item -LiteralPath $configPath -Destination build/release/KSwitcher.Config.exe -Force
     $screenshotPath = Join-Path (Split-Path $executablePath) 'KSwitcher.Screenshot.exe'
-    & $compiler -mwindows -municode -static -s '-Wl,--gc-sections' build/core.o build/platform.o build/ocr.o build/screenshot.o build/screenshot_notifications.o build/screenshot_activation.o build/screenshot_main.o build/screenshot-res.o @libs -o $screenshotPath
+    & $compiler -mwindows -municode -static -s '-Wl,--gc-sections' build/core.o build/platform.o build/storage.o build/ocr.o build/screenshot.o build/screenshot_notifications.o build/screenshot_activation.o build/screenshot_main.o build/screenshot-res.o @libs -o $screenshotPath
     if ($LASTEXITCODE) { throw 'Screenshot link failed' }
     Copy-Item -LiteralPath $screenshotPath -Destination build/release/KSwitcher.Screenshot.exe -Force
     if ($Test) {
+        & $compiler @common tests/dictionary.cpp build/core.o build/platform.o build/autocorrect.o @libs -lpsapi -static -s -o build/KSwitcherDictionaryTests.exe
+        if ($LASTEXITCODE) { throw 'Dictionary test build failed' }
+        & .\build\KSwitcherDictionaryTests.exe
+        if ($LASTEXITCODE) { throw 'Dictionary tests failed' }
         & $compiler @common tests/sync.cpp build/core.o build/platform.o build/storage.o build/sync.o build/ocr.o @libs -static -s -o build/KSwitcherSyncTests.exe
         if ($LASTEXITCODE) { throw 'Sync test build failed' }
         & .\build\KSwitcherSyncTests.exe
@@ -77,15 +81,21 @@ try {
         if ($LASTEXITCODE) { throw 'Updater progress UI tests failed' }
     }
     if ($Integration) {
+        $captureTest = Join-Path (Split-Path $executablePath) 'KSwitcherImageCaptureTests.exe'
+        & $compiler @common tests/image_capture.cpp build/core.o build/platform.o build/storage.o build/ocr.o @libs -static -s -o $captureTest
+        if ($LASTEXITCODE) { throw 'Image capture test build failed' }
+        & $captureTest
+        if ($LASTEXITCODE) { throw 'Image capture tests failed' }
         & $compiler @common tests/integration.cpp build/core.o build/platform.o build/autostart.o build/autocorrect.o build/storage.o build/sync.o build/ocr.o build/richtext.o build/update.o build/screenshot.o build/screenshot_launcher.o build/screenshot_activation.o build/screenshot_notifications.o build/app.o build/configuration.o build/ui.o build/screenshot-res.o @libs -static -s -o build/KSwitcherIntegration.exe
         if ($LASTEXITCODE) { throw 'Integration test build failed' }
         & .\build\KSwitcherIntegration.exe
         if ($LASTEXITCODE) { throw 'Integration tests failed' }
     }
     if ($Ocr) {
-        & $compiler @common tests/ocr.cpp build/core.o build/platform.o build/autostart.o build/autocorrect.o build/storage.o build/sync.o build/ocr.o build/richtext.o build/update.o build/screenshot.o build/screenshot_launcher.o build/screenshot_activation.o build/screenshot_notifications.o build/app.o build/configuration.o build/ui.o build/screenshot-res.o @libs -static -s -o build/KSwitcherOcrTests.exe
+        $ocrTest = Join-Path (Split-Path $executablePath) 'KSwitcherOcrTests.exe'
+        & $compiler @common tests/ocr.cpp build/core.o build/platform.o build/autostart.o build/autocorrect.o build/storage.o build/sync.o build/ocr.o build/richtext.o build/update.o build/screenshot.o build/screenshot_launcher.o build/screenshot_activation.o build/screenshot_notifications.o build/app.o build/configuration.o build/ui.o build/screenshot-res.o @libs -static -s -o $ocrTest
         if ($LASTEXITCODE) { throw 'OCR test build failed' }
-        & .\build\KSwitcherOcrTests.exe
+        & $ocrTest
         if ($LASTEXITCODE) { throw 'OCR tests failed' }
     }
     foreach ($folder in @('build/dictionaries','build/release/dictionaries','build/staged/dictionaries')) {

resources/app.rc

@@ -9,8 +9,8 @@ IDC_SCREENSHOT_PENCIL CURSOR "icons/lucide/pencil.cur"
 1 RT_MANIFEST "app.manifest"
 201 RCDATA "update.ps1"
 1 VERSIONINFO
- FILEVERSION 0,6,27,0
+ FILEVERSION 0,6,38,0
- PRODUCTVERSION 0,6,27,0
+ PRODUCTVERSION 0,6,38,0
  FILEOS VOS_NT_WINDOWS32
  FILETYPE VFT_APP
 BEGIN
@@ -20,7 +20,7 @@ BEGIN
   BEGIN
    VALUE "FileDescription", "KSwitcher — native keyboard and clipboard utility"
    VALUE "ProductName", "KSwitcher"
-   VALUE "FileVersion", "0.6.27"
+   VALUE "FileVersion", "0.6.38"
   END
  END
  BLOCK "VarFileInfo"

src/app.cpp

@@ -1,4 +1,5 @@
 #include "app.h"
+#include <utility>
 #include "../vendor/json.hpp"
 #include "../resources/resource.h"
 #include "ocr.h"
@@ -73,7 +74,11 @@ class Transaction
     Clip snapshot;
     DWORD expected{};
     bool captured{};
+    mutable bool invalidLogged{};
+    unsigned copyNumber{};
     std::wstring adopted;
+    std::unique_ptr<PasteProbe> selectionProof;
+    std::wstring provenSelection;
 
   public:
     Transaction(App &a, HWND t, uint64_t v) : app(a), target(t), version(v)
@@ -108,8 +113,18 @@ class Transaction
     }
     bool valid() const
     {
-        return target && IsWindow(target) && GetForegroundWindow() == target &&
+        auto foreground = GetForegroundWindow();
-               app.inputVersion.load() == version;
+        auto currentVersion = app.inputVersion.load();
+        bool ok = target && IsWindow(target) && foreground == target && currentVersion == version;
+        if (!ok && !invalidLogged)
+        {
+            invalidLogged = true;
+            diagnosticEvent(L"Context invalid: target=" + std::to_wstring((uintptr_t)target) +
+                L" alive=" + std::to_wstring(IsWindow(target)) + L" foreground=" +
+                std::to_wstring((uintptr_t)foreground) + L" expectedVersion=" + std::to_wstring(version) +
+                L" currentVersion=" + std::to_wstring(currentVersion));
+        }
+        return ok;
     }
     void check()
     {
@@ -144,10 +159,14 @@ class Transaction
     }
     std::wstring copy()
     {
+        const auto started = GetTickCount64();
+        const auto number = ++copyNumber;
         if (!valid())
             return {};
         write(textClip(L"\x2063KSwitcher-" + std::to_wstring(GetTickCount64())));
         DWORD before = expected;
+        diagnosticEvent(L"Copy begin number=" + std::to_wstring(number) + L" sentinelSequence=" +
+            std::to_wstring(before) + L" target=" + std::to_wstring((uintptr_t)target));
         if (!valid() || !chord(L'C', MOD_CONTROL))
         {
             diagnosticEvent(L"Copy failed: context changed or simulated Ctrl+C blocked");
@@ -166,6 +185,10 @@ class Transaction
             DWORD now = GetClipboardSequenceNumber();
             if (now != changed)
             {
+                diagnosticEvent(L"Copy sequence number=" + std::to_wstring(number) + L" from=" +
+                    std::to_wstring(changed) + L" to=" + std::to_wstring(now) + L" elapsedMs=" +
+                    std::to_wstring(GetTickCount64() - started) + L" owner=" +
+                    std::to_wstring((uintptr_t)GetClipboardOwner()));
                 changedAgain |= changed != before;
                 changed = now;
                 stable = GetTickCount64();
@@ -183,7 +206,8 @@ class Transaction
                     return {};
                 if (!chord(L'C', MOD_CONTROL))
                     return {};
-                diagnosticEvent(L"Copy retry: clipboard unchanged after Ctrl+C");
+                diagnosticEvent(L"Copy retry: clipboard unchanged after Ctrl+C number=" + std::to_wstring(number) +
+                    L" attempt=" + std::to_wstring(attempts + 1) + L" elapsedMs=" + std::to_wstring(GetTickCount64() - started));
                 ++attempts;
                 retryAt = GetTickCount64() + 250;
             }
@@ -191,6 +215,10 @@ class Transaction
         }
         if (changed == before || !valid())
         {
+            diagnosticEvent(L"Copy end number=" + std::to_wstring(number) + L" attempts=" +
+                std::to_wstring(attempts) + L" elapsedMs=" + std::to_wstring(GetTickCount64() - started) +
+                L" sequence=" + std::to_wstring(GetClipboardSequenceNumber()) + L" clipboardOpenBy=" +
+                std::to_wstring((uintptr_t)GetOpenClipboardWindow()));
             diagnosticEvent(changed == before ? L"Copy failed: clipboard timeout (2000 ms)" :
                                     L"Copy failed: context changed");
             return {};
@@ -201,6 +229,9 @@ class Transaction
         expected = changed;
         auto clip = readClipboard(app.window);
         auto text = clip.text();
+        diagnosticEvent(L"Copy result number=" + std::to_wstring(number) + L" attempts=" +
+            std::to_wstring(attempts) + L" elapsedMs=" + std::to_wstring(GetTickCount64() - started) +
+            L" text=" + diagnosticText(text));
         adopted = text;
         check();
         for (auto &f : clip.formats)
@@ -222,8 +253,27 @@ class Transaction
                 }
             }
         }
+        selectionProof.reset();
+        provenSelection.clear();
+        // Viber and some other editors omit trailing ASCII spaces from Ctrl+C.
+        // Recover only from a real selection, never from the recorded keys alone.
+        if (valid() && !text.empty() && text.size() < 8192 && text.back() != L' ')
+        {
+            auto proof = std::make_unique<PasteProbe>(true, target);
+            auto selected = proof->read(1, false);
+            if (selected && selected->size() > text.size() && selected->starts_with(text) &&
+                selected->find_first_not_of(L' ', text.size()) == std::wstring::npos && valid())
+            {
+                diagnosticEvent(L"Copy: trailing spaces verified via accessibility copied=" +
+                    diagnosticText(text) + L" selected=" + diagnosticText(*selected));
+                text = *selected;
+                provenSelection = text;
+                selectionProof = std::move(proof);
+            }
+        }
         return text;
     }
+    bool recoveredSelection() const { return selectionProof != nullptr; }
     bool select(size_t n)
     {
         return selectPrevious(n, [&] { return valid(); });
@@ -233,6 +283,27 @@ class Transaction
                            const std::function<bool(const std::wstring &)> &suffixMatches = {})
     {
         // WebView word boundaries are only candidates; exact verification is mandatory.
+        diagnosticEvent(L"Selection begin steps=" + std::to_wstring(count) + L" expected=" + diagnosticText(wordCandidate));
+        GUITHREADINFO gui{sizeof(gui)};
+        if (GetGUIThreadInfo(GetWindowThreadProcessId(target, nullptr), &gui))
+        {
+            wchar_t cls[128]{};
+            GetClassNameW(gui.hwndFocus, cls, 128);
+            std::wstring offsets = L"unavailable";
+            if (_wcsicmp(cls, L"Edit") == 0)
+            {
+                DWORD_PTR range{};
+                if (SendMessageTimeoutW(gui.hwndFocus, EM_GETSEL, 0, 0,
+                                       SMTO_ABORTIFHUNG | SMTO_BLOCK, 25, &range) && (DWORD)range != 0xffffffff)
+                    offsets = std::to_wstring(LOWORD(range)) + L"," + std::to_wstring(HIWORD(range));
+            }
+            diagnosticEvent(L"Selection editor class=" + std::wstring(cls) + L" focus=" +
+                std::to_wstring((uintptr_t)gui.hwndFocus) + L" caretWindow=" + std::to_wstring((uintptr_t)gui.hwndCaret) +
+                L" caretRect=" + std::to_wstring(gui.rcCaret.left) + L"," + std::to_wstring(gui.rcCaret.top) +
+                L"," + std::to_wstring(gui.rcCaret.right) + L"," + std::to_wstring(gui.rcCaret.bottom) +
+                L" layout=" + std::to_wstring((uintptr_t)windowLayout(target)) + L" selectionOffsets=" + offsets);
+        }
+        else diagnosticEvent(L"Selection editor: focus/caret/selection unavailable");
         if (needsSelectionDelay(target) && !wordCandidate.empty() &&
             std::all_of(wordCandidate.begin(), wordCandidate.end(),
                         [](wchar_t c) { return letter(c) || iswdigit(c); }))
@@ -241,6 +312,7 @@ class Transaction
                 return {};
             Sleep(25);
             auto text = copy();
+            diagnosticEvent(L"Selection word-boundary match=" + std::to_wstring(matches(text)) + L" copied=" + diagnosticText(text));
             if (valid() && matches(text))
             {
                 diagnosticEvent(L"Selection: verified word boundary");
@@ -251,6 +323,7 @@ class Transaction
             Sleep(25);
         }
         auto text = select(count) ? copy() : std::wstring{};
+        diagnosticEvent(L"Selection initial match=" + std::to_wstring(matches(text)) + L" copied=" + diagnosticText(text));
         // Chromium editors can apply only part of a burst of Shift+Left events.
         // Extend only a verified suffix; never replace a partial or unrelated range.
         if (valid() && !matches(text) && !text.empty() &&
@@ -263,18 +336,36 @@ class Transaction
             {
                 if (!valid() || !chord(VK_LEFT, MOD_SHIFT))
                     return {};
+                diagnosticEvent(L"Selection recovery Shift+Left sent=" + std::to_wstring(i + 1) + L" total=" + std::to_wstring(missing));
                 Sleep(25);
             }
             text = copy();
-            diagnosticEvent(L"Selection: suffix recovery match=" + std::to_wstring(matches(text)));
+            diagnosticEvent(L"Selection: suffix recovery match=" + std::to_wstring(matches(text)) + L" copied=" + diagnosticText(text));
         }
         return text;
     }
     bool paste(const Clip &clip)
     {
+        if (selectionProof)
+        {
+            auto selected = selectionProof->read(1, false);
+            if (!selected || *selected != provenSelection || !valid())
+            {
+                diagnosticEvent(L"Paste cancelled: recovered selection changed or unavailable");
+                return false;
+            }
+        }
         if (!valid())
             return false;
         write(clip);
+        // Viber's Qt editor observes clipboard changes asynchronously. Give it
+        // a chance to discard the data object from Ctrl+C before requesting paste.
+        // Recheck ownership and input below; never retry a possibly applied paste.
+        if (lower(processName(target)) == L"viber")
+        {
+            Sleep(75);
+            diagnosticEvent(L"Paste: Viber clipboard notification settling interval completed");
+        }
         for (int i = 0; i < 2; ++i)
         {
             check();
@@ -286,6 +377,32 @@ class Transaction
         Sleep(300);
         return true;
     }
+    bool nativeSelectionIs(const std::wstring &original) const
+    {
+        if (!valid()) return false;
+        GUITHREADINFO gui{sizeof(gui)};
+        if (!GetGUIThreadInfo(GetWindowThreadProcessId(target, nullptr), &gui) || !gui.hwndFocus) return false;
+        wchar_t cls[32]{};
+        GetClassNameW(gui.hwndFocus, cls, 32);
+        if (_wcsicmp(cls, L"Edit") != 0 ||
+            (GetWindowLongPtrW(gui.hwndFocus, GWL_STYLE) & (ES_PASSWORD | ES_READONLY))) return false;
+        auto query = [&](UINT message, WPARAM wp, LPARAM lp, DWORD_PTR &result)
+        {
+            return SendMessageTimeoutW(gui.hwndFocus, message, wp, lp,
+                                       SMTO_ABORTIFHUNG | SMTO_BLOCK, 100, &result) != 0;
+        };
+        DWORD_PTR range{}, length{}, copied{};
+        if (!query(EM_GETSEL, 0, 0, range) || (DWORD)range == 0xffffffff ||
+            size_t(HIWORD(range) - LOWORD(range)) != original.size() ||
+            !query(WM_GETTEXTLENGTH, 0, 0, length) || length > 65534 || HIWORD(range) > length) return false;
+        std::wstring content(length + 1, L'\0');
+        if (!query(WM_GETTEXT, content.size(), (LPARAM)content.data(), copied) || copied != length) return false;
+        DWORD_PTR after{};
+        GUITHREADINFO focused{sizeof(focused)};
+        return query(EM_GETSEL, 0, 0, after) && after == range && valid() &&
+               GetGUIThreadInfo(GetWindowThreadProcessId(target, nullptr), &focused) && focused.hwndFocus == gui.hwndFocus &&
+               content.substr(LOWORD(range), original.size()) == original;
+    }
 };
 } // namespace
 App::App(HINSTANCE h, bool test, const std::filesystem::path &dataRoot) : instance(h), smoke(test)
@@ -324,6 +441,7 @@ App::App(HINSTANCE h, bool test, const std::filesystem::path &dataRoot) : instan
 }
 App::~App()
 {
+    if (notificationRegistration) CloseHandle(notificationRegistration);
     if (syncWorker.joinable()) syncWorker.join();
     if (updateWorker.joinable())
         updateWorker.join();
@@ -418,7 +536,10 @@ void App::scheduleHistoryOcr(const Settings &config)
                         if (!entry.image || (entry.ocrState != 1 && entry.ocrProfile == profile)) continue;
                         try
                         {
-                            auto text = recognizeText(history->load(entry.id), config);
+                            auto text = history->recognizeImage(entry.id, config, [this, &profile] {
+                                std::lock_guard lock(jobsMutex);
+                                return stop || ocrProfile(historyOcrSettings) != profile;
+                            });
                             std::lock_guard lock(jobsMutex);
                             if (stop || ocrProfile(historyOcrSettings) != profile) continue;
                             if (history->saveOcr(entry.id, text, config))
@@ -532,8 +653,9 @@ void App::applySettings(const Settings &requested)
         run.reset();
         last.reset();
         ++inputVersion;
+        if (busy) diagnosticEvent(L"Input context changed: settings applied version=" + std::to_wstring(inputVersion.load()));
     }
-    // Clear on the worker so the next check reloads edits to dictionary files.
+    // Release the worker's old snapshot; the next check shares the freshly loaded predictor.
     enqueue([this] { autoCorrector.configure({}, {}); });
     scheduleHistoryOcr(s);
     nextSync = std::max(GetTickCount64() + 2000, syncRetryAfter);
@@ -560,6 +682,7 @@ void App::reloadLayouts()
         run.reset();
         last.reset();
         ++inputVersion;
+        if (busy) diagnosticEvent(L"Input context changed: layouts reloaded version=" + std::to_wstring(inputVersion.load()));
     }
     registerHotkeys(settings);
 }
@@ -589,9 +712,17 @@ void App::resetInput()
 {
     std::lock_guard lock(stateMutex);
     ++inputVersion;
+    if (busy) diagnosticEvent(L"Input context changed: reset version=" + std::to_wstring(inputVersion.load()));
     run.reset();
     last.reset();
 }
+void App::releaseIdleMemory(ULONGLONG now)
+{
+    expireDiagnostics(now);
+    std::lock_guard lock(stateMutex);
+    // Match the Undo eligibility deadline; never discard an available operation.
+    if (!busy && last && now - last->at > 120000) last.reset();
+}
 void App::clearLog(bool previous) { clearDiagnosticLog(previous); }
 void App::keyboard(const KBDLLHOOKSTRUCT &k, UINT mods)
 {
@@ -606,6 +737,9 @@ void App::keyboard(const KBDLLHOOKSTRUCT &k, UINT mods)
     if (isHotkey(vk, mods))
         return;
     ++inputVersion;
+    if (busy) diagnosticEvent(L"Input context changed: keyboard vk=" + std::to_wstring(vk) +
+        L" modifiers=" + std::to_wstring(mods) + L" injected=" + std::to_wstring((k.flags & LLKHF_INJECTED) != 0) +
+        L" version=" + std::to_wstring(inputVersion.load()));
     last.reset();
     HWND fg = GetForegroundWindow();
     HKL layout = windowLayout(fg);
@@ -839,8 +973,11 @@ LRESULT CALLBACK App::mouseProc(int code, WPARAM wp, LPARAM lp)
         // KSwitcher generates no mouse input. Remote clicks invalidate a typing
         // range just like local clicks, including while a transaction is pending.
         if (wp == WM_LBUTTONDOWN || wp == WM_RBUTTONDOWN || wp == WM_MBUTTONDOWN || wp == WM_MOUSEWHEEL)
+        {
+            if (current->busy) diagnosticEvent(L"Input context changed: mouse message=" + std::to_wstring(wp));
             current->resetInput();
         }
+    }
     return CallNextHookEx(nullptr, code, wp, lp);
 }
 void App::dispatch(int command)
@@ -1010,9 +1147,10 @@ void App::transform(int command, int snippet)
                                     !(command == 0 && reason == L"paste-sent-unverified")},
                                 {"elapsedMs", GetTickCount64() - start}, {"foregroundSame", GetForegroundWindow() == target},
                                 {"inputSame", app.inputVersion.load() == version}, {"original", bounded(text)},
-                                {"expected", bounded(result)}, {"actual", bounded(actual)},
+                                {"expected", bounded(verification == L"selection-mismatch" ? expected : result)}, {"actual", bounded(actual)},
-                                {"originalUnits", text.size()}, {"expectedUnits", result.size()}, {"actualUnits", actual.size()},
+                                {"selectionExpected", bounded(expected)},
-                                {"textTruncated", text.size() > 4096 || result.size() > 4096 || actual.size() > 4096}};
+                                {"originalUnits", text.size()}, {"expectedUnits", (verification == L"selection-mismatch" ? expected : result).size()}, {"actualUnits", actual.size()},
+                                {"textTruncated", text.size() > 4096 || result.size() > 4096 || actual.size() > 4096 || expected.size() > 4096}};
                             diagnosticOperation(record.dump(-1, ' ', true, DiagnosticJson::error_handler_t::replace));
                         }
                         catch (...) {} // Logging must never abort a completed input transaction.
@@ -1048,9 +1186,11 @@ void App::transform(int command, int snippet)
                     if (!config.autoCorrect || recent.window != target || recent.overflow ||
                         recent.keys.empty() || recent.keys.back() != L' ' || hint < 0)
                         return;
-                    autoCorrector.configure(std::filesystem::path(executable()).parent_path() /
+                    {
-                                                L"dictionaries",
+                        std::lock_guard lock(stateMutex);
-                                            config.autoLanguages);
+                        if (inputVersion.load() != version) return;
+                        autoCorrector.shareDictionaries(autoPredictor);
+                    }
                     std::wstring predicted;
                     for (wchar_t key : recent.keys)
                         predicted += key == L' ' ? L' ' : available[hint].at(physicalLayout().code(key));
@@ -1135,6 +1275,8 @@ void App::transform(int command, int snippet)
                     if (newlines(text) != newlines(previous->result))
                     {
                         reason = L"undo-verification-mismatch";
+                        actual = text;
+                        verification = L"selection-mismatch";
                         if (tx.valid())
                             chord(VK_RIGHT);
                         return;
@@ -1177,6 +1319,8 @@ void App::transform(int command, int snippet)
                         std::to_wstring(recent.keys.size()) + L" match=" + std::to_wstring(hint));
                     if (hint < 0)
                     {
+                        actual = text;
+                        verification = L"selection-mismatch";
                         reason = text.empty() ? L"recent-copy-empty" : L"recent-verification-mismatch";
                         if (tx.valid())
                             chord(VK_RIGHT);
@@ -1194,7 +1338,14 @@ void App::transform(int command, int snippet)
                                         { return newlines(candidate) == newlines(previous->result); });
                     if (newlines(text) != newlines(previous->result))
                     {
+                        actual = text;
+                        verification = L"selection-mismatch";
                         reason = L"previous-result-verification-mismatch";
+                        {
+                            std::lock_guard lock(stateMutex);
+                            last.reset();
+                            run.reset();
+                        }
                         if (tx.valid())
                             chord(VK_RIGHT);
                         return;
@@ -1242,13 +1393,30 @@ void App::transform(int command, int snippet)
                     }
                 }
                 bool sent = false;
-                PasteProbe probe(config.writeLog && manual && result != text, text);
+                const bool requireReadback = tx.recoveredSelection();
+                PasteProbe probe(((config.writeLog && manual) || requireReadback) && result != text, text, target);
+                if (requireReadback && result != text && probe.status != L"ready")
+                {
+                    reason = L"recovered-selection-unavailable";
+                    std::lock_guard lock(stateMutex);
+                    last.reset();
+                    run.reset();
+                    return;
+                }
                 diagnosticEvent(L"Conversion source=" + std::to_wstring(hint) + L" target=" + std::to_wstring(to) +
                     L" changed=" + std::to_wstring(result != text));
                 if (result != text)
                     sent = tx.paste(textClip(result));
                 else if (automatic && tx.valid())
                     chord(VK_RIGHT);
+                if (requireReadback && result != text && !sent)
+                {
+                    reason = L"recovered-selection-paste-cancelled";
+                    std::lock_guard lock(stateMutex);
+                    last.reset();
+                    run.reset();
+                    return;
+                }
                 if (sent || result == text)
                     autoSelected = false;
                 reason = result == text ? L"conversion-unchanged" :
@@ -1258,19 +1426,48 @@ void App::transform(int command, int snippet)
                     reason = L"Conversion unchanged";
                     verification = L"calculated-result-equals-original";
                 }
-                if (sent && manual && config.writeLog)
+                if (sent && ((manual && config.writeLog) || requireReadback))
                 {
                     verification = probe.status;
                     if (tx.valid())
                     {
                         auto observed = probe.read((int)caretSteps(result));
+                        // A native Edit may silently ignore Ctrl+V while the clipboard is busy.
+                        // Retry once only with fresh native proof that the exact original range
+                        // is still selected. Never retry an unknown or changed editor state.
+                        if (observed && newlines(*observed) == newlines(text) && tx.nativeSelectionIs(text))
+                        {
+                            diagnosticEvent(L"Paste retry: native Edit still selects the unchanged original");
+                            if (tx.paste(textClip(result)) && tx.valid())
+                                observed = probe.read((int)caretSteps(result));
+                            else
+                                observed.reset();
+                        }
                         verification = probe.status;
                         if (observed && tx.valid())
                         {
                             actual = *observed;
                             reason = conversionReadbackOutcome(newlines(actual), newlines(text), newlines(result));
+                            if (newlines(actual) != newlines(result))
+                            {
+                                std::lock_guard lock(stateMutex);
+                                last.reset();
+                                run.reset();
+                                diagnosticEvent(L"Paste rejected by readback: previous result cleared; layout not switched");
+                                return;
+                            }
+                        }
+                        else
+                        {
+                            reason = L"Paste not verified";
+                            if (requireReadback)
+                            {
+                                std::lock_guard lock(stateMutex);
+                                last.reset();
+                                run.reset();
+                                return;
+                            }
                         }
-                        else reason = L"Paste not verified";
                     }
                     else verification = L"context-changed-after-paste";
                 }
@@ -1391,6 +1588,17 @@ void App::captureHistory()
                 for (auto &name : config.excluded)
                     if (lower(name) == lower(app))
                         return;
+                if (IsClipboardFormatAvailable(CF_DIB) || IsClipboardFormatAvailable(CF_DIBV5) ||
+                    IsClipboardFormatAvailable(CF_BITMAP) ||
+                    IsClipboardFormatAvailable(RegisterClipboardFormatW(L"PNG")))
+                {
+                    if (history->captureImage(sequence, app, config))
+                    {
+                        scheduleHistoryOcr(config);
+                        PostMessageW(window, HistoryMessage, 0, 0);
+                    }
+                    return;
+                }
                 auto clip = readClipboard(window, (size_t)config.maxImageMiB * 1024 * 1024);
                 if (sequence != GetClipboardSequenceNumber())
                     return;
@@ -1428,7 +1636,9 @@ void App::recognizeEntry(std::wstring id)
             try
             {
                 auto cached = history->ocrText(id, ocrProfile(config));
-                auto text = cached ? *cached : recognizeText(history->load(id), config);
+                auto text = cached ? *cached : history->recognizeImage(id, config, [this] {
+                    std::lock_guard lock(jobsMutex); return stop;
+                });
                 if (!cached) history->saveOcr(id, text, config);
                 if (text.empty())
                 {
@@ -1479,6 +1689,7 @@ void App::trayMenu()
     GetCursorPos(&pt);
     pasteTarget = GetForegroundWindow();
     SetForegroundWindow(window);
+    showMenuAccessKeys(menu);
     int cmd = TrackPopupMenu(menu, TPM_RETURNCMD | TPM_RIGHTBUTTON, pt.x, pt.y, 0, window, nullptr);
     DestroyMenu(menu);
     PostMessageW(window, WM_NULL, 0, 0);
@@ -1707,6 +1918,15 @@ LRESULT CALLBACK App::windowProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
     case WM_TIMER:
         if (wp == 6)
         {
+            if (app->notificationRegistration && WaitForSingleObject(app->notificationRegistration, 0) == WAIT_OBJECT_0)
+            {
+                DWORD code = ERROR_GEN_FAILURE;
+                GetExitCodeProcess(app->notificationRegistration, &code);
+                if (code) log(L"Screenshot notification registration helper failed: " + std::to_wstring(code));
+                CloseHandle(app->notificationRegistration);
+                app->notificationRegistration = nullptr;
+            }
+            app->releaseIdleMemory(GetTickCount64());
             app->pollSync();
             return 0;
         }
@@ -1825,7 +2045,7 @@ int App::execute()
         log(std::wstring(L"Update completed; running version ") + AppVersion);
     if (startCommand)
         PostMessageW(window, WM_HOTKEY, startCommand, 0);
-    try { registerScreenshotNotifications(); }
+    try { notificationRegistration = startScreenshotNotificationRegistration(); }
     catch(const std::exception &e) { log(L"Screenshot notification registration: "+wide(e.what())); }
     auto screenshotActivation=startScreenshotActivationListener();
     MSG msg;

src/app.h

@@ -86,11 +86,13 @@ class App
 
   private:
     friend struct InputRegressionAccess;
+    void releaseIdleMemory(ULONGLONG now);
     HHOOK keyboardHook{}, mouseHook{};
     std::mutex jobsMutex;
     std::condition_variable jobsReady;
     std::deque<std::function<void()>> jobs;
     std::thread worker;
+    HANDLE notificationRegistration{};
     std::thread historySearchWorker;
     std::condition_variable historySearchReady;
     std::function<void()> pendingHistorySearch;

src/app_sync.inl

@@ -35,7 +35,10 @@ std::wstring App::syncCommand(int action, const std::vector<SyncChoice> &choices
                 auto base = action == 1 || action == 4 ? loadSyncBase(data, c) : Bytes{};
                 result = synchronize(*provider, base, sharedSyncSettings(snapshot),
                     action == 2 ? SyncAction::Download : action == 3 ? SyncAction::Upload : SyncAction::Automatic,
-                    [&](const Bytes &b) { restoreSyncSettings(b, snapshot, availableLayouts); }, choices);
+                    [&](const Bytes &b) { restoreSyncSettings(b, snapshot, availableLayouts, c.keepLocalLayouts); }, choices,
+                    c.keepLocalLayouts);
+                if (result.success && c.keepLocalLayouts)
+                    result.status += L" Partial sync: this PC's layouts and their shortcuts were kept; server layouts were preserved.";
             }
             catch (const nlohmann::json::exception &) { result.status = L"Invalid sync data or server response."; }
             catch (const std::exception &e) { result.status = wide(e.what()); }
@@ -43,7 +46,7 @@ std::wstring App::syncCommand(int action, const std::vector<SyncChoice> &choices
             syncDone.store(true);
         });
     }
-    catch (...) { syncRunning = false; throw; }
+    catch (...) { syncRunning = false; Bytes().swap(syncSnapshot); syncResult = {}; throw; }
     return syncStatus;
 }
 void App::pollSync()
@@ -54,25 +57,28 @@ void App::pollSync()
         {
             if (busy) return;
             syncWorker.join();
+            // Own completed payloads locally so every return/exception releases them.
+            auto result = std::exchange(syncResult, SyncResult{});
+            auto snapshot = std::exchange(syncSnapshot, Bytes{});
             syncRunning = false;
             syncDone = false;
-            syncStatus = syncResult.status;
+            syncStatus = result.status;
-            if (syncResult.success)
+            if (result.success)
             {
-                if (loadSyncConfig(data) != syncConnection || encodeSettings(settings) != syncSnapshot)
+                if (loadSyncConfig(data) != syncConnection || encodeSettings(settings) != snapshot)
                 {
                     syncStatus = L"Local settings or connection changed during sync. Checking again shortly.";
                     nextSync = GetTickCount64() + 2000;
                     return;
                 }
-                auto next = restoreSyncSettings(syncResult.settings, settings, layouts);
+                auto next = restoreSyncSettings(result.settings, settings, layouts, syncConnection.keepLocalLayouts);
-                if (encodeSettings(next) != syncSnapshot)
+                if (encodeSettings(next) != snapshot)
                 {
-                    atomicWrite(data / L"settings-before-sync.bin", protect(syncSnapshot));
+                    atomicWrite(data / L"settings-before-sync.bin", protect(snapshot));
                     applySettings(next);
                 }
-                saveSyncBase(data, syncConnection, syncResult.base.empty() ? syncResult.settings : syncResult.base);
+                saveSyncBase(data, syncConnection, result.base.empty() ? result.settings : result.base);
-                pendingSyncConflicts = syncResult.conflicts;
+                pendingSyncConflicts = std::move(result.conflicts);
                 conflictConnection = syncConnection;
                 SYSTEMTIME time{}; GetLocalTime(&time);
                 wchar_t stamp[32]{};
@@ -81,8 +87,8 @@ void App::pollSync()
             }
             // Back off after errors (including bad credentials) instead of repeatedly
             // hitting userpass lockout. The explicit Sync button remains available.
-            syncRetryAfter = syncResult.success ? 0 : GetTickCount64() + 15 * 60000;
+            syncRetryAfter = result.success ? 0 : GetTickCount64() + 15 * 60000;
-            nextSync = syncResult.success ? GetTickCount64() + SyncIntervalMs : syncRetryAfter;
+            nextSync = result.success ? GetTickCount64() + SyncIntervalMs : syncRetryAfter;
         }
         if (!syncRunning && GetTickCount64() >= nextSync)
         {

src/autocorrect.cpp

@@ -42,82 +42,160 @@ bool safeAutoWord(const std::wstring &word, int minimumLength)
     auto small = lower(word);
     return word == small || (word.substr(1) == small.substr(1) && word != upper(word));
 }
-std::string_view AutoCorrector::Dictionary::word(size_t index) const
+namespace {
+constexpr size_t DictionaryBlockWords = 32;
+}
+std::string_view AutoCorrector::Dictionary::word(size_t block) const
 {
-    auto start = offsets[index];
+    size_t start = offsets[block];
-    auto end = bytes.find('\t', start);
+    // Every block starts with a complete word (zero shared prefix).
-    return std::string_view(bytes).substr(start, end - start);
+    size_t length = static_cast<unsigned char>(bytes[start++]) & 15;
+    if (length == 15) length = static_cast<unsigned char>(bytes[start++]);
+    return std::string_view(bytes).substr(start, length);
 }
 AutoCorrector::Dictionary::Dictionary(const std::filesystem::path &path)
 {
-    auto raw = readFile(path, 2 * 1024 * 1024);
+    const auto raw = readFile(path, 2 * 1024 * 1024);
-    bytes.assign(raw.begin(), raw.end());
+    const std::string_view source(reinterpret_cast<const char *>(raw.data()), raw.size());
-    for (size_t start = 0; start < bytes.size();)
+    std::vector<uint32_t> lines;
+    lines.reserve(std::count(source.begin(), source.end(), '\n') + 1);
+    for (size_t start = 0; start < source.size();)
     {
-        auto end = bytes.find('\n', start);
+        auto end = source.find('\n', start);
-        if (end == bytes.npos)
+        if (end == source.npos) end = source.size();
-            end = bytes.size();
+        auto tab = source.find('\t', start);
-        auto tab = bytes.find('\t', start);
+        if (tab == source.npos || tab >= end || tab == start || tab - start > 160)
-        if (tab == bytes.npos || tab >= end || tab == start || tab - start > 160)
             throw std::runtime_error("Invalid auto-correction dictionary");
         int rank{};
-        auto rankEnd = end > tab + 1 && bytes[end - 1] == '\r' ? end - 1 : end;
+        auto rankEnd = end > tab + 1 && source[end - 1] == '\r' ? end - 1 : end;
-        auto parse = std::from_chars(bytes.data() + tab + 1, bytes.data() + rankEnd, rank);
+        auto parse = std::from_chars(source.data() + tab + 1, source.data() + rankEnd, rank);
-        if (parse.ec != std::errc() || parse.ptr != bytes.data() + rankEnd || rank <= 0)
+        if (parse.ec != std::errc() || parse.ptr != source.data() + rankEnd || rank <= 0)
             throw std::runtime_error("Invalid dictionary rank");
-        offsets.push_back((uint32_t)start);
+        lines.push_back(static_cast<uint32_t>(start));
         start = end + 1;
     }
-    if (offsets.empty())
+    if (lines.empty()) throw std::runtime_error("Empty auto-correction dictionary");
-        throw std::runtime_error("Empty auto-correction dictionary");
+    auto entry = [&](uint32_t offset) { return source.substr(offset, source.find('\t', offset) - offset); };
-    auto entry = [&](uint32_t offset) { return std::string_view(bytes).substr(offset, bytes.find('\t', offset) - offset); };
+    auto frequency = [&](uint32_t offset) {
-    auto frequency = [&](uint32_t offset)
-    {
         int rank{};
         auto start = offset + entry(offset).size() + 1;
-        std::from_chars(bytes.data() + start, bytes.data() + bytes.size(), rank);
+        std::from_chars(source.data() + start, source.data() + source.size(), rank);
         return rank;
     };
-    std::sort(offsets.begin(), offsets.end(), [&](uint32_t a, uint32_t b)
+    std::sort(lines.begin(), lines.end(), [&](uint32_t a, uint32_t b) {
-              { return entry(a) == entry(b) ? frequency(a) < frequency(b) : entry(a) < entry(b); });
+        return entry(a) == entry(b) ? frequency(a) < frequency(b) : entry(a) < entry(b);
-    offsets.erase(std::unique(offsets.begin(), offsets.end(), [&](uint32_t a, uint32_t b)
+    });
-                              { return entry(a) == entry(b); }), offsets.end());
+    lines.erase(std::unique(lines.begin(), lines.end(), [&](uint32_t a, uint32_t b) {
-    offsets.shrink_to_fit();
+        return entry(a) == entry(b);
-    bytes.shrink_to_fit();
+    }), lines.end());
+    offsets.reserve((lines.size() + DictionaryBlockWords - 1) / DictionaryBlockWords);
+    std::string_view previous;
+    // Allocate the packed payload exactly once. Geometric growth and a final
+    // shrink otherwise leave discarded buffers in the resident process heap.
+    size_t packedSize = 0;
+    for (size_t i = 0; i < lines.size(); ++i)
+    {
+        auto current = entry(lines[i]);
+        size_t prefix = 0;
+        if (i % DictionaryBlockWords != 0)
+            while (prefix < std::min(previous.size(), current.size()) && previous[prefix] == current[prefix]) ++prefix;
+        auto suffix = current.size() - prefix;
+        packedSize += 1 + (prefix >= 15) + (suffix >= 15) + suffix + 2;
+        auto rank = static_cast<uint32_t>(frequency(lines[i]));
+        if (rank >= 65535)
+            do { ++packedSize; rank >>= 7; } while (rank);
+        previous = current;
+    }
+    bytes.reserve(packedSize);
+    previous = {};
+    for (size_t i = 0; i < lines.size(); ++i)
+    {
+        auto current = entry(lines[i]);
+        size_t prefix = 0;
+        if (i % DictionaryBlockWords == 0)
+            offsets.push_back(static_cast<uint32_t>(bytes.size()));
+        else
+            while (prefix < std::min(previous.size(), current.size()) && previous[prefix] == current[prefix]) ++prefix;
+        size_t suffix = current.size() - prefix;
+        bytes.push_back(static_cast<char>((std::min(prefix, size_t(15)) << 4) | std::min(suffix, size_t(15))));
+        if (prefix >= 15) bytes.push_back(static_cast<char>(prefix));
+        if (suffix >= 15) bytes.push_back(static_cast<char>(suffix));
+        bytes.append(current.substr(prefix));
+        auto rank = static_cast<uint32_t>(frequency(lines[i]));
+        auto shortRank = std::min(rank, uint32_t(65535));
+        bytes.push_back(static_cast<char>(shortRank & 255));
+        bytes.push_back(static_cast<char>(shortRank >> 8));
+        if (rank >= 65535)
+            do {
+                auto next = rank & 127;
+                rank >>= 7;
+                bytes.push_back(static_cast<char>(next | (rank ? 128 : 0)));
+            } while (rank);
+        previous = current;
+    }
 }
 int AutoCorrector::Dictionary::rank(const std::wstring &text) const
 {
     auto key = utf8(lower(text));
     size_t begin = 0, end = offsets.size();
+    // Find the last block whose first word is <= the search key.
     while (begin < end)
     {
         auto mid = begin + (end - begin) / 2;
-        if (word(mid) < key)
+        if (word(mid) <= key) begin = mid + 1;
-            begin = mid + 1;
+        else end = mid;
-        else
+    }
-            end = mid;
+    if (!begin) return 0;
+    size_t block = begin - 1;
+    size_t at = offsets[block];
+    const size_t limit = begin < offsets.size() ? offsets[begin] : bytes.size();
+    char decoded[160]; // The loader validates lengths; lookup never allocates a decoded word.
+    while (at < limit)
+    {
+        auto lengths = static_cast<unsigned char>(bytes[at++]);
+        size_t prefix = lengths >> 4, suffix = lengths & 15;
+        if (prefix == 15) prefix = static_cast<unsigned char>(bytes[at++]);
+        if (suffix == 15) suffix = static_cast<unsigned char>(bytes[at++]);
+        memcpy(decoded + prefix, bytes.data() + at, suffix);
+        at += suffix;
+        uint32_t rank = static_cast<unsigned char>(bytes[at]) |
+                        (uint32_t(static_cast<unsigned char>(bytes[at + 1])) << 8);
+        at += 2;
+        if (rank == 65535) {
+            rank = 0;
+            uint32_t shift = 0;
+            unsigned char part;
+            do {
+                part = static_cast<unsigned char>(bytes[at++]);
+                rank |= uint32_t(part & 127) << shift;
+                shift += 7;
+            } while (part & 128);
+        }
+        auto compared = std::string_view(decoded, size_t(prefix) + suffix).compare(key);
+        if (compared == 0) return static_cast<int>(rank);
+        if (compared > 0) return 0;
     }
-    if (begin == offsets.size() || word(begin) != key)
     return 0;
-    auto start = offsets[begin] + word(begin).size() + 1;
-    int rank{};
-    std::from_chars(bytes.data() + start, bytes.data() + bytes.size(), rank);
-    return rank;
 }
 void AutoCorrector::configure(const std::filesystem::path &folder, const std::vector<std::wstring> &wanted)
 {
     if (languages == wanted)
         return;
-    std::map<std::wstring, Dictionary> next;
+    std::map<std::wstring, std::shared_ptr<const Dictionary>> next;
     for (auto &lang : wanted)
     {
         if (lang != L"en" && lang != L"uk" && lang != L"ru")
             throw std::runtime_error("Unsupported dictionary language");
-        next.emplace(lang, Dictionary(folder / (lang + L".txt")));
+        next.emplace(lang, std::make_shared<const Dictionary>(folder / (lang + L".txt")));
     }
     dictionaries = std::move(next);
     languages = wanted;
 }
+void AutoCorrector::shareDictionaries(const AutoCorrector &source)
+{
+    dictionaries = source.dictionaries;
+    languages = source.languages;
+}
 void AutoCorrector::reject(std::wstring word, const Settings &settings)
 {
     while (!word.empty() && openingDelimiter(word.front(), settings))
@@ -132,7 +210,7 @@ size_t AutoCorrector::memoryBytes() const
 {
     size_t bytes = 0;
     for (auto &[language, d] : dictionaries)
-        bytes += d.bytes.capacity() + d.offsets.capacity() * sizeof(uint32_t);
+        bytes += d->bytes.capacity() + d->offsets.capacity() * sizeof(uint32_t);
     return bytes;
 }
 std::optional<AutoSuggestion> AutoCorrector::suggest(const std::wstring &typed, int source,
@@ -164,6 +242,24 @@ std::optional<AutoSuggestion> AutoCorrector::suggest(const std::wstring &typed,
     auto sourceLanguage = layoutLanguage(layouts[source]);
     if (!dictionaries.contains(sourceLanguage))
         return {};
+    const std::wstring alphabet = sourceLanguage == L"en" ? L"abcdefghijklmnopqrstuvwxyz" :
+        sourceLanguage == L"uk" ? L"абвгґдеєжзиіїйклмнопрстуфхцчшщьюя" : L"абвгдеёжзийклмнопрстуфхцчшщъыьэюя";
+    auto small = lower(word);
+    bool sameLanguage = safeAutoWord(word, settings.autoMinLength) &&
+        small.find_first_not_of(alphabet) == small.npos &&
+        std::find(settings.cycle.begin(), settings.cycle.end(), layouts[source].id) != settings.cycle.end();
+    auto sameLayout = [&](std::wstring text)
+    {
+        if (word != small) text[0] = upper(text.substr(0, 1))[0];
+        return AutoSuggestion{source, source, prefix + text + suffix};
+    };
+    if (settings.autoReplace && sameLanguage)
+    {
+        auto replacement = settings.autoReplacements.find(small);
+        if (replacement != settings.autoReplacements.end() &&
+            replacement->second.find_first_not_of(alphabet) == small.npos)
+            return sameLayout(replacement->second);
+    }
     auto personal = [&](const std::wstring &language, const std::wstring &candidate)
     {
         auto found = settings.autoWords.find(language);
@@ -173,7 +269,7 @@ std::optional<AutoSuggestion> AutoCorrector::suggest(const std::wstring &typed,
     };
     // Valid words from either selected language are never changed.
     for (auto &[language, d] : dictionaries)
-        if (d.rank(word) || personal(language, word))
+        if (d->rank(word) || personal(language, word))
             return {};
     std::optional<AutoSuggestion> candidate;
     std::optional<std::wstring> matchedText;
@@ -193,7 +289,7 @@ std::optional<AutoSuggestion> AutoCorrector::suggest(const std::wstring &typed,
         auto converted = convert(word, layouts[source], layouts[i], true);
         if (converted == word || !safeAutoWord(converted, settings.autoMinLength))
             continue;
-        int rank = personal(dictionary->first, converted) ? 1 : dictionary->second.rank(converted);
+        int rank = personal(dictionary->first, converted) ? 1 : dictionary->second->rank(converted);
         if (!rank)
             continue;
         if (matchedText && *matchedText != converted)
@@ -203,7 +299,54 @@ std::optional<AutoSuggestion> AutoCorrector::suggest(const std::wstring &typed,
             (!candidate || priority(i) < priority(candidate->target)))
             candidate = AutoSuggestion{source, i, prefix + converted + suffix};
     }
+    if (candidate || matchedText || !settings.autoTypos || !sameLanguage || word.size() < 4)
         return candidate;
+    // Generate only single edits. Stop at a second distinct dictionary hit,
+    // including rare hits: frequency limits must never hide ambiguity.
+    std::wstring found;
+    int foundRank = 0;
+    std::set<std::wstring> personalTargets;
+    if (auto it = settings.autoWords.find(sourceLanguage); it != settings.autoWords.end())
+        for (const auto &text : it->second) personalTargets.insert(lower(text));
+    auto consider = [&](const std::wstring &text)
+    {
+        if (text == small || text == found || text.size() < 4 || text.size() > 32) return true;
+        int rank = personalTargets.contains(text) ? 1 : dictionaries.at(sourceLanguage)->rank(text);
+        if (!rank) return true;
+        if (!found.empty()) return false;
+        found = text;
+        foundRank = rank;
+        return true;
+    };
+    for (size_t i = 0; i < small.size(); ++i)
+    {
+        auto text = small;
+        text.erase(i, 1);
+        if (!consider(text)) return {};
+        if (i + 1 < small.size())
+        {
+            text = small;
+            std::swap(text[i], text[i + 1]);
+            if (!consider(text)) return {};
+        }
+        for (wchar_t c : alphabet)
+        {
+            text = small;
+            text[i] = c;
+            if (!consider(text)) return {};
+        }
+    }
+    if (small.size() < 32)
+        for (size_t i = 0; i <= small.size(); ++i)
+            for (wchar_t c : alphabet)
+            {
+                auto text = small;
+                text.insert(i, 1, c);
+                if (!consider(text)) return {};
+            }
+    if (!found.empty() && (settings.autoMaxRank == 0 || foundRank <= settings.autoMaxRank))
+        return sameLayout(found);
+    return {};
 }
 int matchAutoInput(const Run &run, const std::wstring &text, const std::vector<Layout> &layouts,
                    const Layout &physical, const Settings &settings)

src/autocorrect.h

@@ -1,6 +1,7 @@
 #pragma once
 #include "platform.h"
 #include <map>
+#include <memory>
 #include <set>
 #include <string_view>
 namespace ks
@@ -18,23 +19,30 @@ int matchAutoInput(const Run &, const std::wstring &, const std::vector<Layout>
 bool autoCorrectionAllowed(HWND, const Settings &);
 class AutoCorrector
 {
+    friend struct AutoCorrectorRegressionAccess;
     struct Dictionary
     {
+        // Front-coded UTF-8 words in independently searchable blocks of 32.
+        // Prefix/suffix lengths share a byte (15 escapes to a full byte length).
+        // Ranks use two bytes; 65535 escapes to a varint for larger custom ranks.
         std::string bytes;
         std::vector<uint32_t> offsets;
         std::string_view word(size_t) const;
         explicit Dictionary(const std::filesystem::path &);
         int rank(const std::wstring &) const;
     };
-    std::map<std::wstring, Dictionary> dictionaries;
+    std::map<std::wstring, std::shared_ptr<const Dictionary>> dictionaries;
     std::vector<std::wstring> languages;
     std::set<std::wstring> rejected;
 
   public:
     void configure(const std::filesystem::path &, const std::vector<std::wstring> &);
+    // Share immutable dictionary storage, keeping each consumer's undo rejections private.
+    void shareDictionaries(const AutoCorrector &);
     std::optional<AutoSuggestion> suggest(const std::wstring &, int source, const std::vector<Layout> &,
                                           const Settings &) const;
     void reject(std::wstring word, const Settings & = {});
+    // Referenced dictionary payload, including shared storage (do not sum across consumers).
     size_t memoryBytes() const;
 };
 } // namespace ks

src/core.h

@@ -54,6 +54,8 @@ struct Settings
     bool recent = true, switchLayout = true, history = true, autostart = false, awake = false;
     bool elevatedAutostart = false;
     bool autoCorrect = false;
+    bool autoReplace = false, autoTypos = false;
+    std::map<std::wstring, std::wstring> autoReplacements;
     bool writeLog = true;
     bool screenshotAutoOpenEditor = false;
     bool useTesseract = false;

src/diagnostics.h

@@ -37,7 +37,8 @@ inline std::vector<OperationLogRow> parseOperationLog(const std::wstring &conten
                     L"Operation: " + field("attempt") + L"\r\nResult: " + row.outcome +
                     L"\r\nVerification: " + field("verification") + L"\r\nElapsed: " +
                     std::to_wstring(j.value("elapsedMs", 0ULL)) + L" ms\r\n\r\nOriginal:\r\n" +
-                    field("original") + L"\r\n\r\nExpected result:\r\n" + field("expected") +
+                    field("original") + L"\r\n\r\nExpected selection:\r\n" + field("selectionExpected") +
+                    L"\r\n\r\nExpected result / verification target:\r\n" + field("expected") +
                     L"\r\n\r\nRead back:\r\n" + field("actual") + L"\r\n\r\nForeground unchanged: " +
                     (j.value("foregroundSame", false) ? L"yes" : L"no") + L"\r\nInput context unchanged: " +
                     (j.value("inputSame", false) ? L"yes" : L"no") + L"\r\nText truncated: " +

src/history_preview.h

@@ -4,14 +4,28 @@
 #include <string>
 
 namespace ks {
+inline constexpr size_t HistoryThumbnailBudget = 1024 * 1024;
+inline constexpr size_t HistoryRichTextBudget = 256 * 1024;
 // Keep the visible working set even in unusually tall windows. Never evict a
 // visible preview to admit another visible preview: that creates a paint loop.
+template<class T, class Weight>
+void trimHistoryPreviews(std::map<std::wstring,T> &cache,
+                         const std::set<std::wstring> &visible, size_t limit,
+                         size_t byteLimit, Weight weight)
+{
+    size_t bytes = 0;
+    for (const auto &[id, value] : cache) bytes += weight(value);
+    for(auto it=cache.begin(); (cache.size()>limit || bytes>byteLimit) && it!=cache.end();)
+        if(!visible.contains(it->first)) {
+            bytes -= weight(it->second);
+            it=cache.erase(it);
+        }
+        else ++it;
+}
 template<class T>
 void trimHistoryPreviews(std::map<std::wstring,T> &cache,
                          const std::set<std::wstring> &visible, size_t limit=32)
 {
-    for(auto it=cache.begin(); cache.size()>limit && it!=cache.end();)
+    trimHistoryPreviews(cache, visible, limit, 0, [](const T &) { return size_t{}; });
-        if(!visible.contains(it->first)) it=cache.erase(it);
-        else ++it;
 }
 }

src/ocr.cpp

@@ -123,13 +123,16 @@ struct OcrStatics : IInspectable
 Pixels decodeImage(const Clip &clip, UINT maxWidth, UINT maxHeight)
 {
     Bytes encoded;
+    const Bytes *input = &encoded;
     for (const auto &f : clip.formats)
         if (f.name == L"PNG")
         {
-            encoded = f.data;
+            input = &f.data;
             break;
         }
-    if (encoded.empty())
+    if (input->empty())
+    {
+        input = &encoded;
         for (const auto &f : clip.formats)
             if ((f.id == CF_DIB || f.id == CF_DIBV5) && f.data.size() >= 40)
             {
@@ -146,19 +149,21 @@ Pixels decodeImage(const Clip &clip, UINT maxWidth, UINT maxHeight)
                 file.bfType = 0x4d42;
                 file.bfSize = (DWORD)(sizeof(file) + f.data.size());
                 file.bfOffBits = (DWORD)offset;
-                encoded.resize(sizeof(file));
+                encoded.resize(sizeof(file) + f.data.size());
                 memcpy(encoded.data(), &file, sizeof(file));
-                encoded.insert(encoded.end(), f.data.begin(), f.data.end());
+                memcpy(encoded.data() + sizeof(file), f.data.data(), f.data.size());
                 break;
             }
-    if (encoded.empty())
+    }
+    if (input->empty())
         throw std::runtime_error("This clipboard item has no supported image");
     Com<IWICImagingFactory> wic;
     check(CoCreateInstance(CLSID_WICImagingFactory, nullptr, CLSCTX_INPROC_SERVER, IID_IWICImagingFactory,
                            (void **)wic.out()));
     Com<IWICStream> stream;
     check(wic->CreateStream(stream.out()));
-    check(stream->InitializeFromMemory(encoded.data(), (DWORD)encoded.size()));
+    // WIC decoding only reads the stream. The clip outlives every WIC object here.
+    check(stream->InitializeFromMemory(const_cast<BYTE *>(input->data()), (DWORD)input->size()));
     Com<IWICBitmapDecoder> decoder;
     check(wic->CreateDecoderFromStream(stream.p, nullptr, WICDecodeMetadataCacheOnLoad, decoder.out()));
     Com<IWICBitmapFrameDecode> frame;

src/paste_probe.h

@@ -13,7 +13,7 @@ class PasteProbe
 
   public:
     std::wstring status = L"not-requested";
-    PasteProbe(bool enabled, const std::wstring &original)
+    PasteProbe(bool enabled, HWND target)
     {
         if (!enabled)
             return;
@@ -25,6 +25,18 @@ class PasteProbe
         automation->put_TransactionTimeout(200);
         if (FAILED(automation->GetFocusedElement(&element)) || !element)
             return;
+        if (target)
+        {
+            DWORD process{};
+            GetWindowThreadProcessId(target, &process);
+            int focusedProcess{};
+            if (!process || FAILED(element->get_CurrentProcessId(&focusedProcess)) ||
+                process != static_cast<DWORD>(focusedProcess) || GetForegroundWindow() != target)
+            {
+                status = L"focused-control-changed";
+                return;
+            }
+        }
         BOOL password = TRUE;
         if (FAILED(element->get_CurrentIsPassword(&password)) || password)
         {
@@ -35,6 +47,11 @@ class PasteProbe
                                                 (void **)&pattern)) ||
             !pattern)
             return;
+    }
+    PasteProbe(bool enabled, const std::wstring &original, HWND target = nullptr)
+        : PasteProbe(enabled, target)
+    {
+        if (!pattern) return;
         auto selected = read(1, false);
         auto normalize = [](std::wstring value)
         {

src/platform.cpp

@@ -159,6 +159,31 @@ void showRequestedWindow(HWND window)
     if (!IsWindowVisible(window))
         ShowWindow(window, SW_SHOW);
 }
+void showMenuAccessKeys(HMENU menu)
+{
+    // Mouse-opened popups ignore the owner's keyboard-cue state.
+    // Preserve the mnemonic and expose it in the right-hand hint column.
+    for (int i = 0; i < GetMenuItemCount(menu); ++i)
+    {
+        if (auto child = GetSubMenu(menu, i)) showMenuAccessKeys(child);
+        int length = GetMenuStringW(menu, i, nullptr, 0, MF_BYPOSITION);
+        std::wstring text(length + 1, L'\0');
+        GetMenuStringW(menu, i, text.data(), (int)text.size(), MF_BYPOSITION);
+        text.resize(length);
+        if (text.find(L'\t') != text.npos) continue;
+        for (size_t p = 0; p + 1 < text.size(); ++p)
+        {
+            if (text[p] != L'&') continue;
+            if (text[p + 1] == L'&') { ++p; continue; }
+            text += L"\t" + upper(text.substr(p + 1, 1));
+            MENUITEMINFOW item{sizeof(item)};
+            item.fMask = MIIM_STRING;
+            item.dwTypeData = text.data();
+            SetMenuItemInfoW(menu, i, TRUE, &item);
+            break;
+        }
+    }
+}
 bool activateWindow(HWND window)
 {
     if (!IsWindow(window))
@@ -407,12 +432,16 @@ bool selectPrevious(size_t count, const std::function<bool()> &valid)
     // Shift+Left events can all use the same caret position and select only one
     // character. Give each change time to settle before sending the next one.
     const auto target = GetForegroundWindow();
+    diagnosticEvent(L"SelectPrevious requested=" + std::to_wstring(count) +
+        L" mode=" + (needsSelectionDelay(target) ? std::wstring(L"paced-25ms") : std::wstring(L"batch")));
     if (needsSelectionDelay(target))
     {
         for (size_t i = 0; i < count; ++i)
         {
             if (!valid() || GetForegroundWindow() != target || !chord(VK_LEFT, MOD_SHIFT))
                 return false;
+            if (i < 32 || i + 1 == count)
+                diagnosticEvent(L"SelectPrevious Shift+Left sent=" + std::to_wstring(i + 1));
             Sleep(25);
         }
         return valid() && GetForegroundWindow() == target;
@@ -434,7 +463,10 @@ bool selectPrevious(size_t count, const std::function<bool()> &valid)
             add(VK_LEFT, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP);
         }
         add(VK_SHIFT, KEYEVENTF_KEYUP);
-        if (SendInput((UINT)inputs.size(), inputs.data(), sizeof(INPUT)) != inputs.size())
+        auto sent = SendInput((UINT)inputs.size(), inputs.data(), sizeof(INPUT));
+        diagnosticEvent(L"SelectPrevious batch offset=" + std::to_wstring(offset) + L" eventsRequested=" +
+            std::to_wstring(inputs.size()) + L" eventsSent=" + std::to_wstring(sent));
+        if (sent != inputs.size())
             return false;
     }
     return valid();
@@ -572,10 +604,25 @@ std::recursive_mutex logGate;
 bool loggingEnabled = false;
 DiagnosticBuffer diagnosticBuffer;
 }
+size_t DiagnosticBuffer::expire(ULONGLONG now)
+{
+    size_t removed = 0;
+    while (!entries.empty() && now - entries.front().first > 30000)
+    {
+        entries.pop_front();
+        ++removed;
+    }
+    return removed;
+}
+void expireDiagnostics(ULONGLONG now)
+{
+    std::lock_guard lock(logGate);
+    diagnosticBuffer.expire(now);
+}
 std::wstring DiagnosticBuffer::record(const std::wstring &message, bool problem, ULONGLONG now)
 {
-    while (!entries.empty() && (entries.size() >= 40 || now - entries.front().first > 30000))
+    expire(now);
-        entries.pop_front();
+    while (entries.size() >= 128) entries.pop_front();
     entries.emplace_back(now, message);
     if (!problem)
         return {};

src/platform.h

@@ -38,6 +38,7 @@ HKL windowLayout(HWND);
 bool switchWindowLayout(HWND, HKL, const std::function<bool()> &valid);
 bool activateWindow(HWND);
 void showRequestedWindow(HWND);
+void showMenuAccessKeys(HMENU);
 bool ownsClipboard(HWND);
 bool webViewDescendant(DWORD owner, DWORD host,
                        const std::function<std::optional<std::pair<DWORD, std::wstring>>(DWORD)> &read);
@@ -71,10 +72,12 @@ class DiagnosticBuffer
 {
     std::deque<std::pair<ULONGLONG, std::wstring>> entries;
   public:
+    size_t expire(ULONGLONG now);
     std::wstring record(const std::wstring &message, bool problem, ULONGLONG now);
     void clear() { entries.clear(); }
 };
 void setLoggingEnabled(bool enabled);
+void expireDiagnostics(ULONGLONG now);
 void diagnosticEvent(const std::wstring &message, bool problem = false);
 void diagnosticOperation(const std::string &json);
 std::wstring readDiagnosticLog(bool previous);

src/richtext.cpp

@@ -252,7 +252,7 @@ DWORD CALLBACK readStream(DWORD_PTR cookie, LPBYTE buffer, LONG size, LONG *read
     return 0;
 }
 } // namespace
-std::string richPreview(const Clip &clip)
+std::string richPreview(const Clip &clip, bool plainFallback)
 {
     for (const auto &f : clip.formats)
         if (f.name == L"Rich Text Format" && f.data.size() <= 65536)
@@ -276,6 +276,7 @@ std::string richPreview(const Clip &clip)
             {
             }
         }
+    if (!plainFallback) return {};
     auto text = clip.text();
     if (text.size() > 4096)
         text.resize(4096);

src/richtext.h

@@ -2,7 +2,7 @@
 #include "platform.h"
 namespace ks
 {
-std::string richPreview(const Clip &);
+std::string richPreview(const Clip &, bool plainFallback = true);
 HWND createRichText(HWND parent, int id, bool visible);
 bool setRichText(HWND, const std::string &);
 } // namespace ks

src/screenshot.cpp

@@ -783,12 +783,13 @@ HCURSOR actionCursor(const Capture &c,std::pair<int,MarkPart> hit,bool inside)
     if(hit.second==MarkPart::Body || hit.second==MarkPart::Label) cursor=IDC_SIZEALL;
     else if(hit.second==MarkPart::Rotation) cursor=IDC_HAND;
     else if(hit.second>=MarkPart::Vertex0 && hit.second<=MarkPart::Vertex2) cursor=IDC_SIZEALL;
-    else if(hit.second==MarkPart::Radius) cursor=IDC_SIZEWE;
+    else if(hit.second==MarkPart::Start || hit.second==MarkPart::End || hit.second==MarkPart::Radius)
-    else if(hit.second==MarkPart::Start || hit.second==MarkPart::End || hit.second==MarkPart::Thickness) {
+        cursor=IDC_SIZEALL;
+    else if(hit.second==MarkPart::Thickness) {
         const auto &mark=c.marks[hit.first];
-        auto [from,to]=hit.second==MarkPart::Thickness?thicknessSegment(mark):std::pair{mark.from,mark.to};
+        auto [from,to]=thicknessSegment(mark);
         double angle=std::atan2(double(to.y-from.y),double(to.x-from.x));
-        if(hit.second==MarkPart::Thickness) angle+=3.141592653589793/2;
+        angle+=3.141592653589793/2;
         int axis=(int(std::lround(angle/(3.141592653589793/4)))+8)%4;
         const LPCWSTR cursors[]{IDC_SIZEWE,IDC_SIZENWSE,IDC_SIZENS,IDC_SIZENESW};
         cursor=cursors[axis];

src/screenshot_activation.cpp

@@ -50,6 +50,30 @@ void registerScreenshotNotifications()
     // Notify the shell that notification identity/activation registration changed.
     SHChangeNotify(SHCNE_ASSOCCHANGED,SHCNF_IDLIST,nullptr,nullptr);
 }
+HANDLE startScreenshotNotificationRegistration()
+{
+    auto path=std::filesystem::path(executable()).parent_path()/L"KSwitcher.Screenshot.exe";
+    auto command=L"\""+path.wstring()+L"\" --register-notifications";
+    STARTUPINFOW startup{sizeof(startup)};
+    startup.dwFlags=STARTF_USESHOWWINDOW; startup.wShowWindow=SW_HIDE;
+    PROCESS_INFORMATION process{};
+    if(!CreateProcessW(path.c_str(),command.data(),nullptr,nullptr,FALSE,CREATE_NO_WINDOW,
+                       nullptr,path.parent_path().c_str(),&startup,&process))
+        throw std::runtime_error(utf8(lastError(L"Cannot start notification registration helper")));
+    CloseHandle(process.hThread);
+    return process.hProcess;
+}
+void registerScreenshotNotificationsInHelper()
+{
+    auto process=startScreenshotNotificationRegistration();
+    auto wait=WaitForSingleObject(process,10000);
+    DWORD code=ERROR_GEN_FAILURE;
+    bool completed=wait==WAIT_OBJECT_0 && GetExitCodeProcess(process,&code);
+    CloseHandle(process);
+    if(!completed || code)
+        throw std::runtime_error(completed ? "Notification registration helper failed: "+std::to_string(code)
+                                          : "Notification registration helper did not complete within 10 seconds");
+}
 bool validScreenshotToken(const std::wstring &id)
 {
     if(id.size()!=36) return false;

src/screenshot_main.cpp

@@ -1,5 +1,6 @@
 #include "screenshot.h"
 #include "screenshot_notifications.h"
+#include "storage.h"
 #include <commctrl.h>
 #include <shellapi.h>
 #include <roapi.h>
@@ -49,6 +50,14 @@ int WINAPI wWinMain(HINSTANCE instance,HINSTANCE,PWSTR,int)
     std::wstring token;
     bool autoOpenEditor=false, writeLog=false;
     int argc{}; auto argv=CommandLineToArgvW(GetCommandLineW(),&argc);
+    if(argc==3 && (std::wstring(argv[1])==L"--capture-history" || std::wstring(argv[1])==L"--history-ocr")) {
+        bool ocr=std::wstring(argv[1])==L"--history-ocr";
+        std::filesystem::path request=argv[2]; LocalFree(argv);
+        auto initialized=CoInitializeEx(nullptr,COINIT_MULTITHREADED);
+        if(FAILED(initialized)) return 1;
+        int result=ocr ? ks::runHistoryOcr(request) : ks::runImageHistoryCapture(request);
+        CoUninitialize(); return result;
+    }
     if(argc>1 && std::wstring(argv[argc-1])==L"--write-log") {
         writeLog=true; --argc;
         ks::setLoggingEnabled(true);

src/screenshot_notifications.cpp

@@ -206,7 +206,7 @@ bool notifyUpdateAvailable(const std::wstring &version)
 {
     try {
         // Reuse the screenshot notification identity, Windows settings and COM activator.
-        registerScreenshotNotifications();
+        registerScreenshotNotificationsInHelper();
         ComPtr<Notifications::IToastNotificationManagerStatics> manager;
         String managerClass(L"Windows.UI.Notifications.ToastNotificationManager");
         check(RoGetActivationFactory(managerClass.value,IID_PPV_ARGS(&manager)));

src/screenshot_notifications.h

@@ -4,6 +4,10 @@ namespace ks {
 bool notifyScreenshot(const Clip &);
 std::string screenshotNotificationError();
 void registerScreenshotNotifications();
+// Caller owns the returned process handle; the helper exits after registration.
+HANDLE startScreenshotNotificationRegistration();
+// For background notification workers only; bounded wait, never on the UI thread.
+void registerScreenshotNotificationsInHelper();
 int runScreenshotToastActivator();
 DWORD startScreenshotActivationListener();
 bool validScreenshotToken(const std::wstring &);

src/storage.cpp

@@ -4,6 +4,7 @@
 #include <algorithm>
 #include <set>
 #include <sstream>
+#include <wincrypt.h>
 
 namespace ks
 {
@@ -108,6 +109,19 @@ void validateSettings(const Settings &s)
             throw std::runtime_error("Unsupported auto-correction language");
     if (s.autoNever.size() > 10000 || s.autoExcluded.size() > 1000)
         throw std::runtime_error("Too many auto-correction exceptions");
+    if (s.autoReplacements.size() > 10000)
+        throw std::runtime_error("Too many automatic replacements");
+    for (const auto &[from, to] : s.autoReplacements)
+    {
+        bool valid = false;
+        for (auto alphabet : {L"abcdefghijklmnopqrstuvwxyz", L"абвгґдеєжзиіїйклмнопрстуфхцчшщьюя",
+                              L"абвгдеёжзийклмнопрстуфхцчшщъыьэюя"})
+            valid |= !from.empty() && !to.empty() && from.size() <= 32 && to.size() <= 32 &&
+                     from == lower(from) && to == lower(to) && from != to &&
+                     from.find_first_not_of(alphabet) == from.npos && to.find_first_not_of(alphabet) == to.npos;
+        if (!valid)
+            throw std::runtime_error("Replacement pairs must be different lowercase words of 1-32 letters in the same language");
+    }
     for (const auto &[language, words] : s.autoWords)
     {
         std::wstring alphabet = language == L"en" ? L"abcdefghijklmnopqrstuvwxyz" :
@@ -172,6 +186,15 @@ Settings decodeSettings(const Bytes &bytes, const std::vector<Layout> &layouts)
     s.elevatedAutostart = j.value("autostartAsAdministrator", false);
     s.awake = j.value("preventScreenLock", false);
     s.autoCorrect = j.value("autoCorrectLayout", false);
+    s.autoReplace = j.value("autoCorrectReplace", false);
+    s.autoTypos = j.value("autoCorrectTypos", false);
+    if (j.contains("autoCorrectReplacements"))
+        for (auto &[from, to] : j.at("autoCorrectReplacements").items())
+        {
+            auto key = lower(wide(from));
+            if (!s.autoReplacements.emplace(key, lower(wide(to.get<std::string>()))).second)
+                throw std::runtime_error("Duplicate automatic replacement");
+        }
     s.autoMaxRank = j.value("autoCorrectMaxRank", 0);
     s.autoMinLength = j.value("autoCorrectMinLength", 3);
     s.autoPrefixChars = str(j, "autoCorrectPrefixChars", s.autoPrefixChars);
@@ -268,6 +291,11 @@ Bytes encodeSettings(const Settings &s)
     for (auto &id : s.cycle)
         j["layouts"].push_back(utf8(id));
     j["autoCorrectLayout"] = s.autoCorrect;
+    j["autoCorrectReplace"] = s.autoReplace;
+    j["autoCorrectTypos"] = s.autoTypos;
+    j["autoCorrectReplacements"] = Json::object();
+    for (const auto &[from, to] : s.autoReplacements)
+        j["autoCorrectReplacements"][utf8(from)] = utf8(to);
     j["autoCorrectMaxRank"] = s.autoMaxRank;
     j["autoCorrectMinLength"] = s.autoMinLength;
     j["autoCorrectPrefixChars"] = utf8(s.autoPrefixChars);
@@ -347,9 +375,17 @@ Clip decodeClip(const Bytes &b)
 History::History(const std::filesystem::path &folder) : folder_(folder)
 {
     std::filesystem::create_directories(folder_);
+    loadIndex();
+}
+void History::loadIndex()
+{
+    std::vector<Entry> loaded;
     auto index = folder_ / L"index.dat";
     if (!std::filesystem::exists(index))
+    {
+        entries_.clear();
         return;
+    }
     auto j = parse(unprotect(readFile(index, 16 * 1024 * 1024)));
     if (!j.is_array() || j.size() > 10000)
         throw std::runtime_error("Invalid history index");
@@ -364,8 +400,88 @@ History::History(const std::filesystem::path &folder) : folder_(folder)
                    e.value("image", false),
                    e.value("files", false), e.value("ocrState", e.value("image", false) ? 1 : 0),
                    str(e, "ocrProfile", L"windows")};
+        if (e.value("fingerprintVersion", 0) == 1) {
+            item.contentHash = e.value("contentHash", std::string{});
+            item.imageHash = e.value("imageHash", std::string{});
+            item.pixelHash = e.value("pixelHash", std::string{});
+        }
         if (validId(item.id) && std::filesystem::exists(folder_ / (item.id + L".dat")))
-            entries_.push_back(std::move(item));
+            loaded.push_back(std::move(item));
+    }
+    entries_ = std::move(loaded);
+}
+bool History::captureImage(DWORD sequence, const std::wstring &app, const Settings &settings)
+{
+    // Serialize helper index changes with all resident history mutations. Only
+    // metadata is reloaded: GetClipboardData's image allocations die with the child.
+    std::lock_guard lock(mutex_);
+    if (sequence != GetClipboardSequenceNumber()) return false;
+    auto request = std::filesystem::absolute(folder_) / (L"capture-" + newSnippetId() + L".request");
+    struct Cleanup {
+        std::filesystem::path path;
+        ~Cleanup() { std::error_code ignored; std::filesystem::remove(path, ignored); }
+    } cleanup{request};
+    Json job{{"schema", 1}, {"sequence", sequence}, {"app", utf8(app)},
+             {"settings", Json::parse(encodeSettings(settings))}};
+    atomicWrite(request, protect(jsonBytes(job)));
+    auto helper = std::filesystem::path(executable()).parent_path() / L"KSwitcher.Screenshot.exe";
+    auto command = L"\"" + helper.wstring() + L"\" --capture-history \"" + request.wstring() + L"\"";
+    STARTUPINFOW startup{sizeof(startup)};
+    startup.dwFlags = STARTF_USESHOWWINDOW; startup.wShowWindow = SW_HIDE;
+    PROCESS_INFORMATION process{};
+    if (!CreateProcessW(helper.c_str(), command.data(), nullptr, nullptr, FALSE, CREATE_NO_WINDOW,
+                        nullptr, helper.parent_path().c_str(), &startup, &process))
+        throw std::runtime_error(utf8(lastError(L"Cannot start image history helper")));
+    CloseHandle(process.hThread);
+    auto wait = WaitForSingleObject(process.hProcess, 30000);
+    DWORD result = ERROR_GEN_FAILURE;
+    if (wait != WAIT_OBJECT_0)
+    {
+        // Never release the index lock while a timed-out child can still write it.
+        TerminateProcess(process.hProcess, ERROR_TIMEOUT);
+        WaitForSingleObject(process.hProcess, INFINITE);
+    }
+    GetExitCodeProcess(process.hProcess, &result);
+    CloseHandle(process.hProcess);
+    loadIndex(); // Also reconcile any completed atomic save before a child failure.
+    if (wait != WAIT_OBJECT_0) throw std::runtime_error("Image history helper timed out");
+    if (result == 2) return false;
+    if (result == 3) throw std::runtime_error("Clipboard exceeds the configured size limit");
+    if (result) throw std::runtime_error("Image history helper failed: " + std::to_string(result));
+    return true;
+}
+int runImageHistoryCapture(const std::filesystem::path &request)
+{
+    try
+    {
+        if (!request.is_absolute() || !request.filename().wstring().starts_with(L"capture-") ||
+            request.extension() != L".request") return 1;
+        auto job = parse(unprotect(readFile(request, 4 * 1024 * 1024)));
+        if (job.at("schema") != 1) return 1;
+        auto sequence = job.at("sequence").get<DWORD>();
+        auto settings = decodeSettings(jsonBytes(job.at("settings")), readLayouts());
+        auto valid = [&] {
+            return settings.history && sequence == GetClipboardSequenceNumber() &&
+                !IsClipboardFormatAvailable(RegisterClipboardFormatW(L"ExcludeClipboardContentFromMonitorProcessing")) &&
+                !IsClipboardFormatAvailable(RegisterClipboardFormatW(L"Clipboard Viewer Ignore"));
+        };
+        if (!valid()) return 2;
+        if (!IsClipboardFormatAvailable(CF_DIB) && !IsClipboardFormatAvailable(CF_DIBV5) &&
+            !IsClipboardFormatAvailable(CF_BITMAP) &&
+            !IsClipboardFormatAvailable(RegisterClipboardFormatW(L"PNG"))) return 2;
+        auto clip = readClipboard(nullptr, size_t(settings.maxImageMiB) * 1024 * 1024);
+        if (!valid()) return 2;
+        for (const auto &format : clip.formats)
+            if (format.name == L"CanIncludeInClipboardHistory" && format.data.size() >= 4 &&
+                !format.data[0] && !format.data[1] && !format.data[2] && !format.data[3]) return 2;
+        History history(request.parent_path());
+        if (!valid()) return 2;
+        history.add(clip, str(job, "app"), settings);
+        return 0;
+    }
+    catch (const std::exception &e)
+    {
+        return std::string(e.what()) == "Clipboard exceeds the configured size limit" ? 3 : 1;
     }
 }
 void History::saveIndex()
@@ -379,7 +495,9 @@ void History::saveIndex()
                      {"at", e.at},
                      {"pinned", e.pinned},
                      {"image", e.image},
-                     {"files", e.files}, {"ocrState", e.ocrState}, {"ocrProfile", utf8(e.ocrProfile)}});
+                     {"files", e.files}, {"ocrState", e.ocrState}, {"ocrProfile", utf8(e.ocrProfile)},
+                     {"fingerprintVersion", 1}, {"contentHash", e.contentHash},
+                     {"imageHash", e.imageHash}, {"pixelHash", e.pixelHash}});
     atomicWrite(folder_ / L"index.dat", protect(jsonBytes(j)));
 }
 std::vector<Entry> History::entries() const
@@ -412,12 +530,10 @@ void History::prune(const Settings &s)
         entries_.erase(entries_.begin() + i);
     }
 }
-bool sameClipboardImage(const Clip &a, const Clip &b)
+static const Format *clipboardImageFormat(const Clip &c)
 {
     // OLE DataObject / Ole Private Data change when Snipping Tool republishes
     // the same capture. They are transport metadata, not image identity.
-    auto image = [](const Clip &c) -> const Format *
-    {
         if (!c.text().empty())
             return nullptr;
         for (const auto &f : c.formats)
@@ -431,8 +547,42 @@ bool sameClipboardImage(const Clip &a, const Clip &b)
                 if (f.id == id && !f.data.empty())
                     return &f;
         return nullptr;
-    };
+}
-    const auto *left = image(a), *right = image(b);
+static std::string clipboardHash(const Bytes &bytes)
+{
+    struct Hash {
+        HCRYPTPROV provider{}; HCRYPTHASH hash{};
+        ~Hash() { if (hash) CryptDestroyHash(hash); if (provider) CryptReleaseContext(provider, 0); }
+    } state;
+    if (!CryptAcquireContextW(&state.provider, nullptr, nullptr, PROV_RSA_AES, CRYPT_VERIFYCONTEXT) ||
+        !CryptCreateHash(state.provider, CALG_SHA_256, 0, 0, &state.hash) ||
+        !CryptHashData(state.hash, bytes.data(), static_cast<DWORD>(bytes.size()), 0))
+        throw std::runtime_error("Cannot hash clipboard data");
+    BYTE digest[32]{}; DWORD size = sizeof(digest);
+    if (!CryptGetHashParam(state.hash, HP_HASHVAL, digest, &size, 0) || size != sizeof(digest))
+        throw std::runtime_error("Cannot read clipboard hash");
+    static constexpr char hex[] = "0123456789abcdef";
+    std::string result; result.reserve(64);
+    for (auto b : digest) { result += hex[b >> 4]; result += hex[b & 15]; }
+    return result;
+}
+static void imageFingerprints(Entry &entry, const Clip &clip, bool decodePixels = true)
+{
+    const auto *image = clipboardImageFormat(clip);
+    if (!image) return;
+    if (entry.imageHash.empty())
+        entry.imageHash = std::to_string(image->id) + ":" + utf8(image->name) + ":" + clipboardHash(image->data);
+    if (!decodePixels) return;
+    try {
+        auto pixels = decodeImage(clip);
+        entry.pixelHash = std::to_string(pixels.width) + "x" + std::to_string(pixels.height) + ":" + clipboardHash(pixels.bgra);
+    } catch (const std::exception &) {
+        // Undecodable images can still be compared by their original bytes.
+    }
+}
+bool sameClipboardImage(const Clip &a, const Clip &b)
+{
+    const auto *left = clipboardImageFormat(a), *right = clipboardImageFormat(b);
     if (!left || !right)
         return false;
     if (left->id == right->id && left->name == right->name && left->data == right->data)
@@ -456,16 +606,41 @@ void History::add(const Clip &clip, const std::wstring &app, const Settings &s)
     auto data = encodeClip(clip);
     if (data.size() > uint64_t(s.maxImageMiB) * 1024 * 1024)
         return;
+    bool image = false, files = false;
+    for (const auto &f : clip.formats)
+    {
+        image |= f.id == CF_DIB || f.id == CF_DIBV5 || f.name == L"PNG";
+        files |= f.id == CF_HDROP;
+    }
     std::lock_guard lock(mutex_);
-    // Compare only the newest record; never keep image payloads in the resident index.
+    Entry fingerprints;
-    if (!entries_.empty())
+    fingerprints.contentHash = clipboardHash(data);
+    if (!entries_.empty() && entries_.front().contentHash == fingerprints.contentHash)
+        return;
+    imageFingerprints(fingerprints, clip, false);
+    if (!entries_.empty() && !fingerprints.imageHash.empty() && entries_.front().imageHash == fingerprints.imageHash)
+        return;
+    imageFingerprints(fingerprints, clip);
+    // Different payload kinds cannot be duplicates. Consult the index first so
+    // copying text after a screenshot never loads/decrypts the previous image.
+    if (!entries_.empty() && entries_.front().image == image && entries_.front().files == files)
     {
         try
         {
-            auto previous = load(entries_.front().id);
+            auto &previous = entries_.front();
-            if (encodeClip(previous) == data || sameClipboardImage(previous, clip))
+            bool migrated = previous.contentHash.empty();
+            if (migrated) {
+                auto oldClip = load(previous.id);
+                previous.contentHash = clipboardHash(encodeClip(oldClip));
+                imageFingerprints(previous, oldClip);
+            }
+            if (previous.contentHash == fingerprints.contentHash ||
+                (!fingerprints.imageHash.empty() && previous.imageHash == fingerprints.imageHash) ||
+                (!fingerprints.pixelHash.empty() && previous.pixelHash == fingerprints.pixelHash)) {
+                if (migrated) saveIndex();
                 return;
             }
+        }
         catch (...)
         {
         }
@@ -479,12 +654,6 @@ void History::add(const Clip &clip, const std::wstring &app, const Settings &s)
     auto encrypted = protect(data);
     atomicWrite(folder_ / (id + L".dat"), encrypted);
     auto text = clip.text();
-    bool image = false, files = false;
-    for (auto &f : clip.formats)
-    {
-        image |= f.id == CF_DIB || f.id == CF_DIBV5 || f.name == L"PNG";
-        files |= f.id == CF_HDROP;
-    }
     if (text.empty())
         text = files ? L"[Files]" : image ? L"[Image]" : L"[Clipboard data]";
     for (auto &c : text)
@@ -497,7 +666,8 @@ void History::add(const Clip &clip, const std::wstring &app, const Settings &s)
     entries_.insert(entries_.begin(),
                     Entry{id, text, app, encrypted.size(),
                           (uint64_t(now.dwHighDateTime) << 32) | now.dwLowDateTime, false, image, files,
-                          image ? 1 : 0, ocrProfile(s)});
+                          image ? 1 : 0, ocrProfile(s), std::move(fingerprints.contentHash),
+                          std::move(fingerprints.imageHash), std::move(fingerprints.pixelHash)});
     prune(s);
     saveIndex();
 }
@@ -536,6 +706,80 @@ void History::clear()
         std::filesystem::remove(folder_ / (e.id + L".ocr"), ec);
     }
 }
+std::wstring History::recognizeImage(const std::wstring &id, const Settings &settings,
+                                    const std::function<bool()> &cancelled) const
+{
+    if (!validId(id)) throw std::runtime_error("Invalid history ID");
+    if (cancelled && cancelled()) throw std::runtime_error("History OCR cancelled");
+    auto request = std::filesystem::absolute(folder_) / (L"ocr-" + newSnippetId() + L".request");
+    auto response = request; response += L".result";
+    struct Cleanup {
+        std::filesystem::path request, response;
+        ~Cleanup() {
+            std::error_code ignored;
+            std::filesystem::remove(request, ignored);
+            std::filesystem::remove(response, ignored);
+        }
+    } cleanup{request, response};
+    // Send only OCR options and the entry ID. The resident never loads image bytes.
+    Json job{{"schema", 1}, {"id", utf8(id)}, {"tesseract", settings.useTesseract},
+             {"path", utf8(settings.tesseractPath)}, {"languages", utf8(settings.tesseractLanguages)}};
+    atomicWrite(request, protect(jsonBytes(job)));
+    auto helper = std::filesystem::path(executable()).parent_path() / L"KSwitcher.Screenshot.exe";
+    auto command = L"\"" + helper.wstring() + L"\" --history-ocr \"" + request.wstring() + L"\"";
+    STARTUPINFOW startup{sizeof(startup)};
+    startup.dwFlags = STARTF_USESHOWWINDOW; startup.wShowWindow = SW_HIDE;
+    PROCESS_INFORMATION process{};
+    if (!CreateProcessW(helper.c_str(), command.data(), nullptr, nullptr, FALSE, CREATE_NO_WINDOW,
+                        nullptr, helper.parent_path().c_str(), &startup, &process))
+        throw std::runtime_error(utf8(lastError(L"Cannot start history OCR helper")));
+    CloseHandle(process.hThread);
+    struct Child {
+        HANDLE handle;
+        ~Child() {
+            if (WaitForSingleObject(handle, 0) != WAIT_OBJECT_0) {
+                TerminateProcess(handle, ERROR_CANCELLED);
+                WaitForSingleObject(handle, INFINITE);
+            }
+            CloseHandle(handle);
+        }
+    } child{process.hProcess};
+    auto deadline = GetTickCount64() + 60000;
+    for (;;) {
+        auto wait = WaitForSingleObject(child.handle, 100);
+        if (wait == WAIT_OBJECT_0) break;
+        if (wait != WAIT_TIMEOUT) throw std::runtime_error("Cannot wait for history OCR helper");
+        if (cancelled && cancelled()) throw std::runtime_error("History OCR cancelled");
+        if (GetTickCount64() >= deadline) throw std::runtime_error("History OCR helper timed out");
+    }
+    DWORD result{};
+    if (!GetExitCodeProcess(child.handle, &result) || result)
+        throw std::runtime_error("History OCR helper failed: " + std::to_string(result));
+    auto reply = parse(unprotect(readFile(response, 8 * 1024 * 1024)));
+    if (reply.at("schema") != 1 || str(reply, "id") != id)
+        throw std::runtime_error("Invalid history OCR response");
+    return str(reply, "text");
+}
+int runHistoryOcr(const std::filesystem::path &request)
+{
+    try {
+        if (!request.is_absolute() || !request.filename().wstring().starts_with(L"ocr-") ||
+            request.extension() != L".request") return 1;
+        auto job = parse(unprotect(readFile(request, 1024 * 1024)));
+        auto id = str(job, "id");
+        if (job.at("schema") != 1 || !validId(id)) return 1;
+        Settings settings;
+        settings.useTesseract = job.at("tesseract").get<bool>();
+        settings.tesseractPath = str(job, "path");
+        settings.tesseractLanguages = str(job, "languages");
+        auto clip = decodeClip(unprotect(readFile(request.parent_path() / (id + L".dat"), 80 * 1024 * 1024)));
+        auto text = utf8(recognizeText(clip, settings));
+        if (text.size() > 1024 * 1024) return 1;
+        auto response = request; response += L".result";
+        atomicWrite(response, protect(jsonBytes(Json{{"schema", 1}, {"id", utf8(id)}, {"text", text}})));
+        return 0;
+    } catch (...) { return 1; }
+}
 bool History::saveOcr(const std::wstring &id, const std::optional<std::wstring> &text, const Settings &settings)
 {
     std::lock_guard lock(mutex_);

src/storage.h

@@ -1,6 +1,7 @@
 #pragma once
 #include "platform.h"
 #include <mutex>
+#include <functional>
 namespace ks
 {
 Settings loadSettings(const std::filesystem::path &, const std::vector<Layout> &);
@@ -15,6 +16,7 @@ struct Entry
     bool pinned{}, image{}, files{};
     int ocrState{}; // 0: legacy/not applicable, 1: pending, 2: saved, 3: failed
     std::wstring ocrProfile = L"windows";
+    std::string contentHash, imageHash, pixelHash;
 };
 class History
 {
@@ -22,6 +24,7 @@ class History
     std::vector<Entry> entries_;
     mutable std::mutex mutex_;
     void saveIndex();
+    void loadIndex();
     void prune(const Settings &);
 
   public:
@@ -29,6 +32,9 @@ class History
     std::vector<Entry> entries() const;
     Clip load(const std::wstring &id) const;
     void add(const Clip &, const std::wstring &app, const Settings &);
+    bool captureImage(DWORD sequence, const std::wstring &app, const Settings &);
+    std::wstring recognizeImage(const std::wstring &id, const Settings &,
+                                const std::function<bool()> &cancelled = {}) const;
     bool saveOcr(const std::wstring &id, const std::optional<std::wstring> &, const Settings &);
     std::optional<std::wstring> ocrText(const std::wstring &id, const std::wstring &profile = L"") const;
     void remove(const std::wstring &);
@@ -39,4 +45,6 @@ class History
 Bytes encodeClip(const Clip &);
 Clip decodeClip(const Bytes &);
 bool sameClipboardImage(const Clip &, const Clip &);
+int runImageHistoryCapture(const std::filesystem::path &request);
+int runHistoryOcr(const std::filesystem::path &request);
 } // namespace ks

src/sync.cpp

@@ -17,7 +17,7 @@ Json configJson(const SyncConfig &c)
 {
     return {{"enabled", c.enabled}, {"provider", utf8(c.provider)}, {"server", utf8(c.server)},
         {"mount", utf8(c.mount)}, {"path", utf8(c.path)}, {"authMount", utf8(c.authMount)},
-        {"username", utf8(c.username)}};
+        {"username", utf8(c.username)}, {"keepLocalLayouts", c.keepLocalLayouts}};
 }
 std::wstring credentialName(const SyncConfig &c)
 {
@@ -154,6 +154,7 @@ SyncConfig loadSyncConfig(const std::filesystem::path &root)
     if (!syncVisible(root)) return c;
     auto j = parse(readFile(root / L"sync.json", 16384));
     c.enabled = j.value("enabled", false);
+    c.keepLocalLayouts = j.value("keepLocalLayouts", false);
     c.provider = wide(j.value("provider", "openbao"));
     c.server = wide(j.value("server", ""));
     c.mount = wide(j.value("mount", "kswitcher"));
@@ -221,30 +222,50 @@ Bytes sharedSyncSettings(const Settings &s)
         "historyEnabled", "maxItems", "maxTotalMegabytes", "maxImageMegabytes", "writeLog", "preventScreenLock"}) j.erase(key);
     return bytes(canonicalProfile(j));
 }
-Settings restoreSyncSettings(const Bytes &shared, const Settings &local, const std::vector<Layout> &layouts)
+Settings restoreSyncSettings(const Bytes &shared, const Settings &local, const std::vector<Layout> &layouts, bool keepLocalLayouts)
 {
     auto j = parse(shared), original = parse(encodeSettings(local));
     if (!j.contains("snippetTombstones")) j["snippetTombstones"] = Json::array();
+    if (!j.contains("autoCorrectReplace")) j["autoCorrectReplace"] = false;
+    if (!j.contains("autoCorrectTypos")) j["autoCorrectTypos"] = false;
+    if (!j.contains("autoCorrectReplacements")) j["autoCorrectReplacements"] = Json::object();
     auto allowed = parse(sharedSyncSettings(local));
     if (!j.is_object() || j.value("format", "") != "kswitcher-settings" || j.value("schemaVersion", 0) != 1)
         throw std::runtime_error("Unsupported synchronized settings format.");
     for (auto it = j.begin(); it != j.end(); ++it)
         if (!allowed.contains(it.key())) throw std::runtime_error("Remote profile contains unsupported or local-only fields.");
     if (j.size() != allowed.size()) throw std::runtime_error("Remote profile is incomplete.");
-    // decodeSettings intentionally ignores hotkeys for missing layouts during import.
-    // Sync must stop instead, otherwise the next upload would lose those bindings.
     std::set<std::string> installed;
     for (const auto &layout : layouts) installed.insert(utf8(layout.id));
+    std::set<std::string> missing;
     for (const auto &id : j.at("layouts"))
-        if (!installed.contains(id.get<std::string>())) throw std::runtime_error("Install the remote profile's keyboard layouts before syncing.");
+        if (!installed.contains(id.get<std::string>())) missing.insert(id.get<std::string>());
     for (const auto &key : j.at("layoutHotkeys"))
-        if (!installed.contains(key.at("layoutId").get<std::string>())) throw std::runtime_error("Install the remote profile's keyboard layouts before syncing.");
+        if (!installed.contains(key.at("layoutId").get<std::string>())) missing.insert(key.at("layoutId").get<std::string>());
+    if (!keepLocalLayouts && !missing.empty())
+    {
+        std::wstring message = L"Missing keyboard layouts on this PC: ";
+        for (const auto &id : missing)
+        {
+            auto code = id.starts_with("win:") ? id.substr(4) : id;
+            wchar_t language[128]{};
+            if (code.size() == 8 && code.find_first_not_of("0123456789abcdefABCDEF") == code.npos)
+                GetLocaleInfoW(MAKELCID(LOWORD(std::stoul(code, nullptr, 16)), SORT_DEFAULT), LOCALE_SENGLISHLANGUAGENAME,
+                               language, 128);
+            if (message.back() != L' ') message += L"; ";
+            message += (language[0] ? std::wstring(language) : L"Unknown layout") + L" [" + wide(id) + L"]";
+        }
+        message += L". Install these exact layouts, or enable 'Keep this PC's layouts' below and sync other settings.";
+        throw std::runtime_error(utf8(message));
+    }
+    if (keepLocalLayouts)
+        for (auto key : {"layouts", "layoutHotkeys"}) j[key] = original.at(key);
     original.update(j);
     return decodeSettings(bytes(original), layouts);
 }
 #include "sync_merge.inl"
 SyncResult synchronize(SyncProvider &provider, const Bytes &base, const Bytes &local, SyncAction action,
-    const std::function<void(const Bytes &)> &validate, const std::vector<SyncChoice> &choices)
+    const std::function<void(const Bytes &)> &validate, const std::vector<SyncChoice> &choices, bool keepLocalLayouts)
 {
     if (local.size() > Limit) throw std::runtime_error("Settings exceed the sync size limit.");
     if (validate) validate(local);
@@ -255,11 +276,25 @@ SyncResult synchronize(SyncProvider &provider, const Bytes &base, const Bytes &l
         return {true, local, provider.write(local, 0), L"Uploaded new profile."};
     }
     if (validate && action != SyncAction::Upload) validate(remote.settings);
+    auto mergeLocal = local, mergeBase = base;
+    if (keepLocalLayouts)
+    {
+        // Never upload a locally filtered projection over another PC's layout setup.
+        const auto remoteJson = parse(remote.settings);
+        auto preserve = [&](const Bytes &profile)
+        {
+            auto j = parse(profile);
+            for (auto key : {"layouts", "layoutHotkeys"}) j[key] = remoteJson.at(key);
+            return bytes(j);
+        };
+        mergeLocal = preserve(local);
+        if (!base.empty()) mergeBase = preserve(base);
+    }
     SyncMerge merged;
-    if (action == SyncAction::Automatic) merged = mergeSyncProfile(base, local, remote.settings, choices);
+    if (action == SyncAction::Automatic) merged = mergeSyncProfile(mergeBase, mergeLocal, remote.settings, choices);
     else
     {
-        auto selected = bytes(normalizeProfile(parse(action == SyncAction::Download ? remote.settings : local)));
+        auto selected = bytes(normalizeProfile(parse(action == SyncAction::Download ? remote.settings : mergeLocal)));
         merged = {selected, selected, selected, {}};
     }
     if (validate) { validate(merged.local); validate(merged.remote); }
@@ -308,7 +343,9 @@ Bytes loadSyncBase(const std::filesystem::path &root, const SyncConfig &c)
     auto path = root / L"sync-base.bin";
     if (!std::filesystem::exists(path)) return {};
     auto j = parse(unprotect(readFile(path, Limit + 65536)));
-    return j.at("connection") == configJson(c) ? bytes(j.at("settings")) : Bytes{};
+    auto connection = j.at("connection");
+    if (!connection.contains("keepLocalLayouts")) connection["keepLocalLayouts"] = false;
+    return connection == configJson(c) ? bytes(j.at("settings")) : Bytes{};
 }
 void saveSyncBase(const std::filesystem::path &root, const SyncConfig &c, const Bytes &base)
 {

src/sync.h

@@ -7,6 +7,7 @@ namespace ks
 struct SyncConfig
 {
     bool enabled{};
+    bool keepLocalLayouts{};
     std::wstring provider = L"openbao", server, mount = L"kswitcher",
         path = L"personal/settings", authMount = L"userpass", username;
     bool operator==(const SyncConfig &) const = default;
@@ -52,7 +53,7 @@ SyncMerge mergeSyncProfile(const Bytes &base, const Bytes &local, const Bytes &r
     const std::vector<SyncChoice> &choices = {});
 Bytes mergeSyncSettings(const Bytes &base, const Bytes &local, const Bytes &remote);
 Bytes sharedSyncSettings(const Settings &);
-Settings restoreSyncSettings(const Bytes &, const Settings &, const std::vector<Layout> &);
+Settings restoreSyncSettings(const Bytes &, const Settings &, const std::vector<Layout> &, bool keepLocalLayouts = false);
 enum class SyncAction { Automatic, Download, Upload };
 struct SyncResult
 {
@@ -64,7 +65,8 @@ struct SyncResult
     std::vector<SyncConflict> conflicts;
 };
 SyncResult synchronize(SyncProvider &, const Bytes &base, const Bytes &local, SyncAction,
-    const std::function<void(const Bytes &)> &validate = {}, const std::vector<SyncChoice> &choices = {});
+    const std::function<void(const Bytes &)> &validate = {}, const std::vector<SyncChoice> &choices = {},
+    bool keepLocalLayouts = false);
 Bytes loadSyncBase(const std::filesystem::path &, const SyncConfig &);
 void saveSyncBase(const std::filesystem::path &, const SyncConfig &, const Bytes &);
 }

src/sync_merge.inl

@@ -4,6 +4,9 @@ namespace
 {
 Json normalizeProfile(Json j)
 {
+    if (!j.contains("autoCorrectReplace")) j["autoCorrectReplace"] = false;
+    if (!j.contains("autoCorrectTypos")) j["autoCorrectTypos"] = false;
+    if (!j.contains("autoCorrectReplacements")) j["autoCorrectReplacements"] = Json::object();
     if (!j.contains("snippetTombstones")) j["snippetTombstones"] = Json::array();
     for (auto &sn : j.at("snippets"))
         if (!sn.contains("id")) sn["id"] = utf8(snippetId({wide(sn.at("trigger").get<std::string>()), L""}));
@@ -46,6 +49,10 @@ Json treeProfile(const Json &source)
 }
 Json flatProfile(Json j)
 {
+    auto &replacements = j["autoCorrectReplacements"];
+    for (auto it = replacements.begin(); it != replacements.end();)
+        if (it.value().is_null()) it = replacements.erase(it);
+        else ++it;
     Json snippets = Json::array(), deleted = Json::array();
     for (const auto &[id, item] : j.at("snippets").items())
     {
@@ -90,6 +97,8 @@ std::wstring fieldLabel(const std::string &key)
         {"convertLastWord", L"Convert recent word"}, {"switchSystemLayout", L"Switch system layout"},
         {"autoCorrectMinLength", L"Minimum word length"}, {"autoCorrectMaxRank", L"Maximum word rank"},
         {"autoCorrectLayout", L"Automatic layout correction"}, {"autoCorrectLanguages", L"Dictionary languages"},
+        {"autoCorrectReplace", L"Custom automatic replacements"}, {"autoCorrectTypos", L"Dictionary typo correction"},
+        {"autoCorrectReplacements", L"Replacement pairs"},
         {"autoCorrectPrefixChars", L"Punctuation before words"}, {"autoCorrectSuffixChars", L"Punctuation after words"},
         {"screenshotAutoOpenEditor", L"Open screenshot editor"}, {"tesseractLanguages", L"OCR languages"},
         {"trigger", L"Trigger"}, {"text", L"Text"}};
@@ -167,8 +176,9 @@ void collisionPaths(const Json &j, std::set<std::string> &paths)
 SyncMerge mergeSyncProfile(const Bytes &base, const Bytes &local, const Bytes &remote, const std::vector<SyncChoice> &choices)
 {
     auto l = treeProfile(parse(local)), r = treeProfile(parse(remote));
-    if (base.empty() && l != r) throw std::runtime_error("First connection: choose Download remote or Upload local.");
+    // With no common history, union independent entries; differing scalar values
-    auto b = base.empty() ? l : treeProfile(parse(base));
+    // remain on their respective devices until the user resolves the conflict.
+    auto b = base.empty() ? Json::object() : treeProfile(parse(base));
     SyncMerge result;
     auto merged = mergeNode(b, l, r, "", L"", choices, result.conflicts, {});
     std::set<std::string> collisions;

src/ui.cpp

@@ -83,7 +83,7 @@ void arrangeWindow(HWND w)
     {
         int id = GetDlgCtrlID(child);
         RECT next{scale(w, r.left) - layout->x,
-                  scale(w, r.top) - layout->y + (id >= 110 && id <= 114 ? extraHeight : 0)};
+                  scale(w, r.top) - layout->y + ((id >= 110 && id <= 114) || id == 116 ? extraHeight : 0)};
         next.right = next.left + scale(w, r.right - r.left) + (id == 101 || id == 102 ? extraWidth : 0);
         next.bottom = next.top + scale(w, r.bottom - r.top) + (id == 102 ? extraHeight : 0);
         if (child == layout->stretch)
@@ -468,23 +468,31 @@ struct SearchResult
     uint64_t generation;
     std::vector<Entry> items;
 };
+struct TextPreview
+{
+    std::string rtf;
+    std::wstring plain;
+};
 struct PreviewResult
 {
     uint64_t generation;
     std::wstring id;
     Pixels pixels;
-    std::string rtf;
+    TextPreview text;
 };
 struct HistoryView
 {
     App *app{};
     std::vector<Entry> items;
+    std::wstring rememberedSelection, rememberedTop;
     uint64_t generation{};
+    std::shared_ptr<std::atomic<bool>> previewActive = std::make_shared<std::atomic<bool>>(true);
     std::map<std::wstring, Pixels> thumbnails;
-    std::map<std::wstring, std::string> richTexts;
+    std::map<std::wstring, TextPreview> richTexts;
     HWND rich{};
     std::set<std::wstring> pending;
     bool scrolling{};
+    bool closed{};
 };
 bool selectedImage(HWND w, HistoryView *v)
 {
@@ -502,6 +510,9 @@ std::wstring selected(HWND w, HistoryView *v)
 }
 void search(HWND w, HistoryView *v)
 {
+    v->previewActive->store(false);
+    v->previewActive = std::make_shared<std::atomic<bool>>(true);
+    v->closed = false;
     auto q = value(w, 101);
     auto generation = ++v->generation;
     v->pending.clear();
@@ -529,23 +540,31 @@ void requestPreview(HWND w, HistoryView *v, const Entry &entry)
     if (v->thumbnails.contains(id) || v->richTexts.contains(id) || !v->pending.insert(id).second)
         return;
     auto generation = v->generation;
+    auto active = v->previewActive;
     auto *app = v->app;
     app->enqueue(
-        [w, app, id, generation, image]
+        [w, app, id, generation, image, active]
         {
+            if (!active->load()) return;
             auto result = new PreviewResult{generation, id, {}, {}};
             try
             {
                 auto clip = app->history->load(id);
+                if (!active->load()) { delete result; return; }
                 if (image)
                     result->pixels = decodeImage(clip, 208, 128);
-                else
+                else {
-                    result->rtf = richPreview(clip);
+                    result->text.rtf = richPreview(clip, false);
+                    if (result->text.rtf.empty()) {
+                        result->text.plain = clip.text();
+                        if (result->text.plain.size() > 4096) result->text.plain.resize(4096);
+                    }
+                }
             }
             catch (const std::exception &)
             {
             }
-            if (!PostMessageW(w, PreviewMessage, 0, (LPARAM)result))
+            if (!active->load() || !PostMessageW(w, PreviewMessage, 0, (LPARAM)result))
                 delete result;
         });
 }
@@ -599,9 +618,13 @@ void drawHistoryRow(HWND w, HistoryView *v, const DRAWITEMSTRUCT &draw)
     if (!entry.image && !entry.files)
     {
         auto rich = v->richTexts.find(entry.id);
-        if (rich != v->richTexts.end() && v->rich && !rich->second.empty())
+        if (rich != v->richTexts.end() && rich->second.rtf.empty())
+            text = (entry.pinned ? L"★  " : L"") + rich->second.plain;
+        if (rich != v->richTexts.end() && !rich->second.rtf.empty() && !v->rich)
+            v->rich = createRichText(w, 105, false);
+        if (rich != v->richTexts.end() && v->rich && !rich->second.rtf.empty())
         {
-            setRichText(v->rich, rich->second);
+            setRichText(v->rich, rich->second.rtf);
             CHARFORMAT2W format{};
             format.cbSize = sizeof(format);
             format.dwMask = CFM_COLOR;
@@ -730,6 +753,13 @@ LRESULT CALLBACK historyProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
             }
             if (id == 102 && HIWORD(wp) == LBN_DBLCLK)
                 id = 110;
+            if (id == 116)
+            {
+                if (MessageBoxW(w, L"Delete all clipboard history, including pinned items? This also deletes items hidden by the current search.",
+                                L"Clear history", MB_YESNO | MB_ICONWARNING | MB_DEFBUTTON2) == IDYES)
+                    v->app->clearHistory();
+                return 0;
+            }
             auto entry = selected(w, v);
             if (id == 110 || id == 111)
             {
@@ -763,6 +793,7 @@ LRESULT CALLBACK historyProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
         }
         case WM_TIMER:
             KillTimer(w, 1);
+            if (v->closed) return 0;
             search(w, v);
             return 0;
         case ResultsMessage:
@@ -771,8 +802,10 @@ LRESULT CALLBACK historyProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
             if (result->generation != v->generation)
                 return 0;
             auto old = selected(w, v);
+            if (old.empty()) old = v->rememberedSelection;
             int top=(int)SendDlgItemMessageW(w,102,LB_GETTOPINDEX,0,0);
             auto topId=top>=0 && top<(int)v->items.size()?v->items[top].id:L"";
+            if (topId.empty()) topId = v->rememberedTop;
             v->items = std::move(result->items);
             SendDlgItemMessageW(w, 102, WM_SETREDRAW, FALSE, 0);
             SendDlgItemMessageW(w, 102, LB_RESETCONTENT, 0, 0);
@@ -812,12 +845,14 @@ LRESULT CALLBACK historyProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
                 visible.insert(v->items[i].id);
                 if(v->items[i].id==result->id) { changed=intersection; repaint=true; }
             }
-            if (!result->rtf.empty())
+            if (!result->text.rtf.empty() || !result->text.plain.empty())
-                v->richTexts[result->id] = std::move(result->rtf);
+                v->richTexts[result->id] = std::move(result->text);
             else
                 v->thumbnails[result->id] = std::move(result->pixels);
-            trimHistoryPreviews(v->thumbnails,visible);
+            trimHistoryPreviews(v->thumbnails,visible,32,HistoryThumbnailBudget,
-            trimHistoryPreviews(v->richTexts,visible);
+                                [](const Pixels &p) { return p.bgra.capacity(); });
+            trimHistoryPreviews(v->richTexts,visible,32,HistoryRichTextBudget,
+                                [](const TextPreview &s) { return s.rtf.capacity() + s.plain.capacity() * sizeof(wchar_t); });
             if(repaint) InvalidateRect(list,&changed,FALSE);
             return 0;
         }
@@ -860,6 +895,7 @@ LRESULT CALLBACK historyProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
             AppendMenuW(menu, MF_STRING, 113, L"&Delete");
             AppendMenuW(menu, MF_STRING, 114, selectedImage(w,v)?L"&Edit image in screenshot editor":L"&Open full item");
             AppendMenuW(menu, MF_STRING, 115, L"&Copy text from image (OCR)");
+            showMenuAccessKeys(menu);
             int cmd = TrackPopupMenu(menu, TPM_RETURNCMD, p.x, p.y, 0, w, nullptr);
             DestroyMenu(menu);
             if (cmd)
@@ -867,15 +903,25 @@ LRESULT CALLBACK historyProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
             return 0;
         }
         case WM_CLOSE:
+        {
+            v->rememberedSelection = selected(w, v);
+            int top = (int)SendDlgItemMessageW(w,102,LB_GETTOPINDEX,0,0);
+            v->rememberedTop = top >= 0 && top < (int)v->items.size() ? v->items[top].id : L"";
+            KillTimer(w, 1);
+            v->closed = true;
+            v->previewActive->store(false);
+            ++v->generation; // Discard search/preview results queued before closing.
             ShowWindow(w, SW_HIDE);
+            SendDlgItemMessageW(w,102,LB_RESETCONTENT,0,0);
+            std::vector<Entry>().swap(v->items);
             v->thumbnails.clear();
             v->richTexts.clear();
-            if (v->rich)
+            if (v->rich) SetWindowTextW(v->rich, L"");
-                SetWindowTextW(v->rich, L"");
             v->pending.clear();
-            ++v->generation;
             return 0;
+        }
         case WM_NCDESTROY:
+            v->previewActive->store(false);
             disposeFont(w);
             v->app->historyWindow = nullptr;
             delete v;
@@ -1112,6 +1158,25 @@ LRESULT CALLBACK autoOptionsProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
             draft.autoExcluded = parseCommaList(value(w, 404));
             draft.autoPrefixChars = value(w, 408);
             draft.autoSuffixChars = value(w, 409);
+            draft.autoReplace = checked(w, 414);
+            draft.autoTypos = checked(w, 415);
+            draft.autoReplacements.clear();
+            std::wistringstream replacements(lower(value(w, 416)));
+            std::wstring line;
+            auto trim = [](std::wstring text)
+            {
+                auto first = text.find_first_not_of(L" \t\r\n");
+                return first == text.npos ? std::wstring{} : text.substr(first, text.find_last_not_of(L" \t\r\n") - first + 1);
+            };
+            while (std::getline(replacements, line))
+            {
+                if (trim(line).empty()) continue;
+                auto equals = line.find(L'=');
+                if (equals == line.npos)
+                    throw std::runtime_error("Enter one replacement per line: typo=correction");
+                if (!draft.autoReplacements.emplace(trim(line.substr(0, equals)), trim(line.substr(equals + 1))).second)
+                    throw std::runtime_error("Each replacement typo must occur only once");
+            }
             if (draft.autoLanguages.size() < 2)
                 throw std::runtime_error("Select at least two languages");
             validateSettings(draft);
@@ -1123,6 +1188,9 @@ LRESULT CALLBACK autoOptionsProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
             view->settings->draft.autoMinLength = draft.autoMinLength;
             view->settings->draft.autoPrefixChars = draft.autoPrefixChars;
             view->settings->draft.autoSuffixChars = draft.autoSuffixChars;
+            view->settings->draft.autoReplace = draft.autoReplace;
+            view->settings->draft.autoTypos = draft.autoTypos;
+            view->settings->draft.autoReplacements = std::move(draft.autoReplacements);
             DestroyWindow(w);
         }
         catch (const std::exception &e)
@@ -1153,8 +1221,8 @@ LRESULT CALLBACK autoOptionsProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
 }
 void showAutoOptions(HWND parent, SettingsView *v)
 {
-    HWND w = makeWindow(*v->app, L"KSwitcher.AutoOptions", L"Automatic layout correction", autoOptionsProc,
+    HWND w = makeWindow(*v->app, L"KSwitcher.AutoOptions", L"Automatic correction", autoOptionsProc,
-                        560, 680);
+                        560, 880);
     windowLayoutState(w)->autoOptions = true;
     SetWindowLongPtrW(w, GWLP_HWNDPARENT, (LONG_PTR)parent);
     SetWindowLongPtrW(w, GWLP_USERDATA, (LONG_PTR) new AutoOptionsView{parent, v});
@@ -1192,10 +1260,20 @@ void showAutoOptions(HWND parent, SettingsView *v)
     value(w, 408, v->draft.autoPrefixChars);
     value(w, 409, v->draft.autoSuffixChars);
     label(w, L"Enter punctuation without spaces or separators. These characters are kept.", 18, 530, 525);
-    button(w, L"Open dictionary &folder", 407, 18, 562, 220);
+    checkbox(w, L"Use custom &replacements (take priority over dictionaries)", 414, 18, 562, 524);
-    label(w, L"After editing files, click OK here, then Save in Settings to reload.", 18, 600, 525);
+    check(w, 414, v->draft.autoReplace);
-    button(w, L"&OK", IDOK, 326, 632, 100);
+    label(w, L"One pair per line: typo=correction (same language, letters only)", 18, 592, 525);
-    button(w, L"&Cancel", IDCANCEL, 440, 632, 100);
+    edit(w, 416, 18, 618, 524, 70, ES_MULTILINE | WS_VSCROLL | ES_AUTOVSCROLL | ES_WANTRETURN);
+    std::wstring pairs;
+    for (const auto &[from, to] : v->draft.autoReplacements) pairs += from + L"=" + to + L"\r\n";
+    value(w, 416, pairs);
+    checkbox(w, L"Correct spelling &typos using dictionaries (experimental)", 415, 18, 700, 524);
+    check(w, 415, v->draft.autoTypos);
+    label(w, L"Single edits, 4+ letters; ambiguous words are left unchanged.", 18, 730, 525);
+    button(w, L"Open dictionary &folder", 407, 18, 762, 220);
+    label(w, L"Click OK, then Save in Settings. Enable automatic correction there.", 18, 800, 525);
+    button(w, L"&OK", IDOK, 326, 832, 100);
+    button(w, L"&Cancel", IDCANCEL, 440, 832, 100);
     RECT initial{};
     GetWindowRect(w, &initial);
     initial.right += scale(w, 200);
@@ -1299,6 +1377,46 @@ void showOcrOptions(HWND parent, SettingsView *v)
     showRequestedWindow(w); SetForegroundWindow(w);
 }
 #include "ui_sync.inl"
+bool settingsChanged(HWND w, SettingsView *v)
+{
+    try
+    {
+        return encodeSettings(collectSettings(w, v)) != encodeSettings(v->app->settings);
+    }
+    catch (const std::exception &)
+    {
+        // Invalid edits are unsaved changes too. Allow discarding them without
+        // requiring the user to repair the fields first.
+        return true;
+    }
+}
+void closeSettings(HWND w, SettingsView *v)
+{
+    if (settingsChanged(w, v))
+    {
+        int choice = MessageBoxW(w,
+            L"You have unsaved settings changes. Save them before closing?\n\n"
+            L"Yes: save and close.\nNo: discard changes.\nCancel: keep editing.",
+            L"KSwitcher — Unsaved settings", MB_YESNOCANCEL | MB_ICONWARNING | MB_DEFBUTTON3);
+        if (choice != IDYES && choice != IDNO)
+            return;
+        if (choice == IDYES)
+        {
+            try
+            {
+                if (v->app->busy)
+                    throw std::runtime_error("Wait for the current text operation to finish");
+                v->app->applySettings(collectSettings(w, v));
+            }
+            catch (const std::exception &e)
+            {
+                error(w, e);
+                return;
+            }
+        }
+    }
+    DestroyWindow(w);
+}
 LRESULT CALLBACK settingsProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
 {
     if (msg == WM_DPICHANGED)
@@ -1364,7 +1482,7 @@ LRESULT CALLBACK settingsProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
             }
             if (id == IDCANCEL)
             {
-                DestroyWindow(w);
+                closeSettings(w, v);
                 return 0;
             }
             if (id == 250)
@@ -1415,7 +1533,7 @@ LRESULT CALLBACK settingsProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
             break;
         }
         case WM_CLOSE:
-            DestroyWindow(w);
+            closeSettings(w, v);
             return 0;
         case WM_NCDESTROY:
             disposeFont(w);
@@ -1605,7 +1723,6 @@ void showHistory(App &app, bool visible)
         HWND w = makeWindow(app, L"KSwitcher.History", L"Clipboard history", historyProc, 760, 500);
         app.historyWindow = w;
         windowLayoutState(w)->history = true;
-        ((HistoryView *)GetWindowLongPtrW(w, GWLP_USERDATA))->rich = createRichText(w, 105, false);
         label(w, L"&Search clipboard history", 16, 12, 500);
         edit(w, 101, 16, 38, 728);
         auto list = control(w, L"LISTBOX", L"",
@@ -1618,6 +1735,7 @@ void showHistory(App &app, bool visible)
         button(w, L"P&in / unpin", 112, 222, 452, 110);
         button(w, L"&Delete", 113, 340, 452, 90);
         button(w, L"&Open item", 114, 438, 452, 100);
+        button(w, L"Clear &history…", 116, 546, 452, 150);
         SetWindowSubclass(list, historyKey, 1, (DWORD_PTR)w);
         SetWindowSubclass(GetDlgItem(w, 101), historyKey, 1, (DWORD_PTR)w);
     }
@@ -1672,7 +1790,7 @@ void showSettings(App &app, bool visible)
         hotkeyEdit(app, w, 210 + i, 540, 44 + i * 30, 220);
     }
     checkbox(w, L"Open editor after screen capt&ure", 209, 420, 224, 340);
-    checkbox(w, L"Automatically correct layout (e&xperimental)", 207, 18, 210, 395);
+    checkbox(w, L"Automatic correction (e&xperimental)", 207, 18, 210, 395);
     label(w, L"Layout cycle — top to bottom", 18, 240, 400);
     control(w, L"LISTBOX", L"", WS_TABSTOP | WS_VSCROLL | LBS_NOTIFY | LBS_NOINTEGRALHEIGHT | WS_BORDER, 220,
             18, 262, 470, 172);

src/ui_sync.inl

@@ -1,9 +1,29 @@
 #include "ui_sync_conflicts.inl"
 struct SyncView { HWND parent; App *app; };
+void updateSyncControls(HWND w, App &app)
+{
+    bool enabled = checked(w, 601);
+    bool savedEnabled = loadSyncConfig(app.data).enabled;
+    for (int id : {602, 603, 604, 605, 606, 607, 610, 611, 613})
+        EnableWindow(GetDlgItem(w, id), enabled);
+    EnableWindow(GetDlgItem(w, 612), enabled && savedEnabled);
+    EnableWindow(GetDlgItem(w, IDOK), enabled || savedEnabled);
+    value(w, IDOK, enabled ? L"&Save / Sign in / Sync" : L"&Save");
+    std::wstring status;
+    if (!enabled)
+        status = savedEnabled ? L"Click Save to disable synchronization." :
+              L"Synchronization is disabled. Enable it above to configure and sync.";
+    else if (!savedEnabled)
+        status = L"Configure the connection, then click Save / Sign in / Sync to enable synchronization.";
+    else
+        status = app.syncCommand();
+    if (value(w, 608) != status) value(w, 608, status);
+}
 SyncConfig syncFields(HWND w)
 {
     SyncConfig c;
     c.enabled = checked(w, 601);
+    c.keepLocalLayouts = checked(w, 613);
     c.server = value(w, 602);
     while (!c.server.empty() && c.server.back() == L'/') c.server.pop_back();
     c.username = lower(value(w, 603)); c.mount = value(w, 605);
@@ -19,12 +39,19 @@ LRESULT CALLBACK syncProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
     {
         if (msg == WM_TIMER)
         {
-            value(w, 608, v->app->syncCommand());
+            updateSyncControls(w, *v->app);
             return 0;
         }
         if (msg == WM_COMMAND)
         {
             int id = LOWORD(wp);
+            if (id == 601 && HIWORD(wp) == BN_CLICKED)
+            {
+                updateSyncControls(w, *v->app);
+                return 0;
+            }
+            if ((id == IDOK || id == 610 || id == 611 || id == 612) &&
+                !IsWindowEnabled(GetDlgItem(w, id))) return 0;
             if (id == 612) { showSyncConflicts(w, *v->app); return 0; }
             if (id == IDCANCEL) { DestroyWindow(w); return 0; }
             if (id == 609)
@@ -35,18 +62,28 @@ LRESULT CALLBACK syncProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
                 forgetSyncPassword(c);
                 check(w, 601, false);
                 value(w, 604, L"");
+                updateSyncControls(w, *v->app);
                 value(w, 608, L"Disabled. Saved password removed. An in-flight server request may still finish.");
                 KillTimer(w, 1);
                 return 0;
             }
             if (id == IDOK || id == 610 || id == 611)
             {
+                if (!checked(w, 601))
+                {
+                    if (id != IDOK) return 0;
+                    auto c = loadSyncConfig(v->app->data);
+                    c.enabled = false;
+                    saveSyncConfig(v->app->data, c);
+                    value(w, 604, L"");
+                    updateSyncControls(w, *v->app);
+                    return 0;
+                }
                 if (id != IDOK && MessageBoxW(w, id == 610 ?
                     L"Replace this PC's shared settings with the remote profile? A local backup will be saved. Unsaved edits in Settings are not included." :
                     L"Replace the remote profile with this PC's saved settings? OpenBao retains older versions according to its retention policy. Unsaved edits are not included.",
                     L"Resolve synchronization", MB_YESNO | MB_ICONWARNING) != IDYES) return 0;
                 auto c = syncFields(w);
-                if (id != IDOK && !c.enabled) throw std::runtime_error("Enable synchronization first.");
                 if (c.enabled) validateSyncConfig(c);
                 auto password = value(w, 604);
                 try { if (!password.empty()) saveSyncPassword(c, password); }
@@ -55,6 +92,7 @@ LRESULT CALLBACK syncProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
                 value(w, 604, L"");
                 saveSyncConfig(v->app->data, c);
                 value(w, 608, v->app->syncCommand(id == 610 ? 2 : id == 611 ? 3 : 1));
+                updateSyncControls(w, *v->app);
                 SetTimer(w, 1, 1000, nullptr);
                 return 0;
             }
@@ -80,7 +118,7 @@ LRESULT CALLBACK syncProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
 void showSyncOptions(HWND parent, App &app)
 {
     auto c = loadSyncConfig(app.data);
-    HWND w = makeWindow(app, L"KSwitcher.Sync", L"Settings synchronization - OpenBao", syncProc, 660, 640);
+    HWND w = makeWindow(app, L"KSwitcher.Sync", L"Settings synchronization - OpenBao", syncProc, 660, 672);
     SetWindowLongPtrW(w, GWLP_HWNDPARENT, (LONG_PTR)parent);
     SetWindowLongPtrW(w, GWLP_USERDATA, (LONG_PTR)new SyncView{parent, &app});
     checkbox(w, L"&Enable synchronization with your OpenBao (KV v2)", 601, 18, 18, 620);
@@ -93,15 +131,18 @@ void showSyncOptions(HWND parent, App &app)
     label(w, L"Profile pa&th", 18, 250, 160); edit(w, 606, 190, 246, 450); value(w, 606, c.path);
     label(w, L"&Login mount", 18, 290, 160); edit(w, 607, 190, 286, 450); value(w, 607, c.authMount);
     label(w, L"Sync uses saved settings. Close and reopen Settings after downloading changes.", 18, 330, 622);
-    control(w, L"STATIC", L"", 0, 608, 18, 362, 622, 76);
+    edit(w, 608, 18, 362, 622, 76, ES_MULTILINE | ES_READONLY | WS_VSCROLL | ES_AUTOVSCROLL);
     value(w, 608, app.syncCommand());
-    button(w, L"&Save / Sign in / Sync", IDOK, 18, 452, 200);
+    checkbox(w, L"&Keep this PC's layouts and layout shortcuts (sync other settings)", 613, 18, 446, 622);
-    button(w, L"&Download remote", 610, 230, 452, 195);
+    check(w, 613, c.keepLocalLayouts);
-    button(w, L"&Upload local", 611, 437, 452, 203);
+    button(w, L"&Save / Sign in / Sync", IDOK, 18, 484, 200);
-    button(w, L"Resolve &individual conflicts...", 612, 18, 498, 300);
+    button(w, L"&Download remote", 610, 230, 484, 195);
-    label(w, L"Background check: every 10 minutes", 330, 502, 310);
+    button(w, L"&Upload local", 611, 437, 484, 203);
-    button(w, L"Disconnect / &forget password", 609, 18, 550, 290);
+    button(w, L"Resolve &individual conflicts...", 612, 18, 530, 300);
-    button(w, L"&Close", IDCANCEL, 540, 550, 100);
+    label(w, L"Background check: every 10 minutes", 330, 534, 310);
+    button(w, L"Disconnect / &forget password", 609, 18, 582, 290);
+    button(w, L"&Close", IDCANCEL, 540, 582, 100);
+    updateSyncControls(w, app);
     EnableWindow(parent, FALSE);
     SetTimer(w, 1, 1000, nullptr);
     showRequestedWindow(w); SetForegroundWindow(w);

src/update.h

@@ -2,7 +2,7 @@
 #include "platform.h"
 namespace ks
 {
-inline constexpr wchar_t AppVersion[] = L"0.6.27";
+inline constexpr wchar_t AppVersion[] = L"0.6.38";
 inline constexpr UINT UpdateMessage = WM_APP + 7;
 inline constexpr UINT UpdateCheckIntervalMs = 6 * 60 * 60 * 1000;
 inline constexpr UINT UpdateNotificationRetryMs = 5 * 60 * 1000;

tests/dictionary.cpp

@@ -0,0 +1,85 @@
+#include "autocorrect.h"
+#include <algorithm>
+#include <chrono>
+#include <fstream>
+#include <iostream>
+#include <psapi.h>
+#include <random>
+namespace ks {
+struct AutoCorrectorRegressionAccess {
+ static int rank(const AutoCorrector &c,const std::wstring &lang,const std::wstring &word) {
+  return c.dictionaries.at(lang)->rank(word);
+ }
+ static std::vector<int> ranks(const std::filesystem::path &path,const std::vector<std::wstring> &words) {
+  AutoCorrector::Dictionary d(path);
+  std::vector<int> values;for(const auto &word:words)values.push_back(d.rank(word));return values;
+ }
+};
+}
+int main(int argc,char **argv) {
+ try {
+  auto start=std::chrono::steady_clock::now();
+  ks::AutoCorrector c;c.configure(L"dictionaries",{L"en",L"uk",L"ru"});
+  PROCESS_MEMORY_COUNTERS_EX m{};
+  GetProcessMemoryInfo(GetCurrentProcess(),reinterpret_cast<PROCESS_MEMORY_COUNTERS*>(&m),sizeof(m));
+  std::cout<<"dictionary_bytes="<<c.memoryBytes()<<" private_bytes="<<m.PrivateUsage
+   <<" load_ms="<<std::chrono::duration<double,std::milli>(std::chrono::steady_clock::now()-start).count()<<'\n';
+  struct Query {std::wstring language,word; int rank;};
+  std::vector<Query> queries;
+  for(const auto *lang:{L"en",L"uk",L"ru"}) {
+   std::ifstream input(std::filesystem::path(L"dictionaries")/(std::wstring(lang)+L".txt"));
+   std::map<std::wstring,int> expected;
+   for(std::string line;std::getline(input,line);) {
+    auto tab=line.find('\t');auto word=ks::wide(line.substr(0,tab));auto rank=std::stoi(line.substr(tab+1));
+    auto [it,added]=expected.emplace(word,rank);if(!added)it->second=std::min(it->second,rank);
+   }
+   if(expected.empty())throw std::runtime_error("Missing benchmark dictionary");
+   for(auto &[word,rank]:expected) {
+    if(ks::AutoCorrectorRegressionAccess::rank(c,lang,word)!=rank)throw std::runtime_error("Dictionary rank differs from source");
+    if(ks::AutoCorrectorRegressionAccess::rank(c,lang,word+L"~")!=0)throw std::runtime_error("False dictionary hit");
+    queries.push_back({lang,word,rank});queries.push_back({lang,word+L"~",0});
+   }
+  }
+  std::mt19937 random(42);std::shuffle(queries.begin(),queries.end(),random);
+  uint64_t checksum=0,expected=0;
+  for(auto &q:queries)expected+=q.rank;
+  start=std::chrono::steady_clock::now();
+  for(int pass=0;pass<5;++pass)for(auto &q:queries)checksum+=ks::AutoCorrectorRegressionAccess::rank(c,q.language,q.word);
+  auto ms=std::chrono::duration<double,std::milli>(std::chrono::steady_clock::now()-start).count();
+  if(checksum!=expected*5)throw std::runtime_error("Lookup checksum mismatch");
+  std::cout<<"verified_words="<<queries.size()/2<<" queries="<<queries.size()*5<<" lookup_ms="<<ms
+   <<" ns_per_lookup="<<ms*1000000/(queries.size()*5)<<" checksum="<<checksum<<'\n';
+  auto fixture=std::filesystem::temp_directory_path()/(L"KSwitcher-dictionary-"+
+      std::to_wstring(GetCurrentProcessId())+L"-"+std::to_wstring(GetTickCount64())+L".txt");
+  struct RemoveFixture { std::filesystem::path path; ~RemoveFixture(){std::error_code ec;std::filesystem::remove(path,ec);} } cleanup{fixture};
+  auto put=[&](const std::string &text){ks::atomicWrite(fixture,ks::Bytes(text.begin(),text.end()));};
+  std::string text="duplicate\t9\r\nduplicate\t2\n";
+  std::vector<std::wstring> words;
+  std::vector<int> expectedRanks;
+  for(int i=129;i>=0;--i) {
+   auto word=L"prefix_"+std::to_wstring(i);
+   text+=ks::utf8(word)+"\t"+std::to_string(i+1)+"\n";
+   words.push_back(word);expectedRanks.push_back(i+1);
+  }
+  text+=std::string(160,'x')+"\t2147483647"; // Maximum length/rank, no final newline.
+  words.insert(words.end(),{std::wstring(160,L'x'),L"DUPLICATE",L"",L"prefix_",L"zzzz"});
+  expectedRanks.insert(expectedRanks.end(),{2147483647,2,0,0,0});
+  for(auto rank:{65534,65535,65536}) {
+   auto word=std::wstring(159,L'x')+wchar_t(L'y'+rank-65534);
+   text+="\n"+ks::utf8(word)+"\t"+std::to_string(rank);
+   words.push_back(word);expectedRanks.push_back(rank);
+  }
+  put(text);
+  if(ks::AutoCorrectorRegressionAccess::ranks(fixture,words)!=expectedRanks)
+   throw std::runtime_error("Block boundaries, duplicate ranks or maximum values failed");
+  for(const auto &invalid:std::vector<std::string>{"","missing-tab","x\t0","x\t-1","x\t2147483648",std::string(161,'x')+"\t1","\t1","x\t1bad"}) {
+   put(invalid);bool rejected=false;
+   try {ks::AutoCorrectorRegressionAccess::ranks(fixture,{L"x"});}catch(const std::runtime_error &){rejected=true;}
+   if(!rejected)throw std::runtime_error("Invalid dictionary was accepted");
+  }
+  const bool baseline=argc==2 && std::string(argv[1])=="--baseline";
+  if(!baseline && c.memoryBytes()>=1536*1024)throw std::runtime_error("Bundled dictionaries exceed compact memory budget");
+  std::cout<<"Passed complete dictionary equivalence and format regressions\n";
+  return 0;
+ }catch(const std::exception&e){std::cerr<<e.what()<<'\n';return 1;}
+}

tests/image_capture.cpp

@@ -0,0 +1,68 @@
+// Interactive clipboard test. Run with the resident stopped; the original
+// clipboard is restored. The helper must be beside this test executable.
+#include "storage.h"
+#include "ocr.h"
+#include <algorithm>
+#include <iostream>
+static void require(bool ok,const char *name) {
+    if(!ok) throw std::runtime_error(name);
+    std::cout << "PASS " << name << '\n';
+}
+int main() {
+    CoInitializeEx(nullptr,COINIT_MULTITHREADED);
+    HWND owner=CreateWindowExW(0,L"STATIC",L"Capture test",0,0,0,0,0,HWND_MESSAGE,nullptr,nullptr,nullptr);
+    ks::Clip saved; bool captured=false; int result=0;
+    auto folder=std::filesystem::temp_directory_path()/(L"KSwitcher-image-capture-"+std::to_wstring(GetCurrentProcessId()));
+    try {
+        saved=ks::readClipboard(owner,128*1024*1024); captured=true;
+        ks::Settings settings; settings.history=true;
+        ks::History history(folder);
+        history.add(ks::textClip(L"keep pinned"),L"test",settings);
+        auto pinned=history.entries().front().id; history.pin(pinned);
+        ks::Pixels pixels{32,16,ks::Bytes(32*16*4,255)};
+        ks::Clip image{{ks::imageDib(pixels),{0,L"PNG",ks::encodePng(pixels)}}};
+        auto sequence=ks::writeClipboard(owner,image);
+        require(history.captureImage(sequence,L"capture test",settings),"helper captures image");
+        auto entries=history.entries();
+        require(entries.size()==2 && entries.front().image && entries.front().ocrState==1,"resident reloads metadata with pending OCR");
+        require(entries.front().contentHash.size()==64 && !entries.front().pixelHash.empty(),
+                "helper persists fingerprints and resident reloads them");
+        require(entries.back().id==pinned && entries.back().pinned,"helper preserves existing pinned entry");
+        auto restored=history.load(entries.front().id);
+        auto has=[&](const ks::Format &expected) {
+            return std::any_of(restored.formats.begin(),restored.formats.end(),[&](const ks::Format &actual) {
+                return (expected.name.empty()?actual.id==expected.id:actual.name==expected.name) && actual.data==expected.data;
+            });
+        };
+        require(has(image.formats[0]) && has(image.formats[1]),
+                "encrypted history preserves both image representations");
+        require(ks::readFile(folder/(entries.front().id+L".dat"),1024*1024)!=ks::encodeClip(restored),"saved image is encrypted");
+        require(GetClipboardSequenceNumber()==sequence,"capture leaves clipboard unchanged");
+        require(history.captureImage(sequence,L"capture test",settings) && history.entries().size()==2,"duplicate capture is not added");
+        ks::writeClipboard(owner,ks::textClip(L"new clipboard"));
+        require(!history.captureImage(sequence,L"stale",settings) && history.entries().size()==2,"stale request does not save another clipboard");
+        for(auto name : {L"ExcludeClipboardContentFromMonitorProcessing",L"Clipboard Viewer Ignore",L"CanIncludeInClipboardHistory"}) {
+            auto blocked=image; blocked.formats.push_back({0,name,ks::Bytes(4,0)});
+            sequence=ks::writeClipboard(owner,blocked);
+            require(!history.captureImage(sequence,L"excluded",settings) && history.entries().size()==2,"clipboard privacy flag prevents capture");
+        }
+        pixels={1024,512,ks::Bytes(1024*512*4,255)};
+        sequence=ks::writeClipboard(owner,ks::Clip{{ks::imageDib(pixels)}});
+        settings.maxImageMiB=1;
+        bool rejected=false;
+        try {history.captureImage(sequence,L"oversized",settings);} catch(const std::exception &e) {
+            rejected=std::string(e.what())=="Clipboard exceeds the configured size limit";
+        }
+        require(rejected && history.entries().size()==2,"oversized image is rejected without changing index");
+        require(GetClipboardSequenceNumber()==sequence,"rejection leaves clipboard unchanged");
+        for(const auto &file:std::filesystem::directory_iterator(folder))
+            require(file.path().extension()!=L".request","encrypted capture request is cleaned up");
+    } catch(const std::exception &e) {std::cerr << "FAIL " << e.what() << '\n';result=1;}
+    if(captured) try {ks::writeClipboard(owner,saved);} catch(...) {result=1;}
+    DestroyWindow(owner); CoUninitialize();
+    // Remove only the exact PID-specific fixture under the system temp directory.
+    std::error_code ignored;
+    if(std::filesystem::weakly_canonical(folder).parent_path()==std::filesystem::weakly_canonical(std::filesystem::temp_directory_path()))
+        std::filesystem::remove_all(folder,ignored);
+    return result;
+}

tests/input.cpp

@@ -5,6 +5,19 @@
 #include <commctrl.h>
 #include <iostream>
 #include <cmath>
+static int settingsCloseChoice = IDCANCEL;
+static int settingsClosePrompts = 0;
+static void CALLBACK answerSettingsClose(HWND, UINT, UINT_PTR, DWORD)
+{
+    HWND dialog = FindWindowW(L"#32770", L"KSwitcher — Unsaved settings");
+    DWORD process{};
+    if (dialog && GetWindowThreadProcessId(dialog, &process) == GetCurrentThreadId() &&
+        process == GetCurrentProcessId())
+    {
+        ++settingsClosePrompts;
+        SendMessageW(dialog, WM_COMMAND, settingsCloseChoice, 0);
+    }
+}
 LRESULT CALLBACK countControlMoves(HWND w, UINT message, WPARAM wp, LPARAM lp, UINT_PTR, DWORD_PTR data)
 {
     if (message == WM_WINDOWPOSCHANGING) ++*reinterpret_cast<int *>(data);
@@ -12,6 +25,38 @@ LRESULT CALLBACK countControlMoves(HWND w, UINT message, WPARAM wp, LPARAM lp, U
 }
 namespace ks {
 struct InputRegressionAccess {
+    static bool idleUndo(App &a) {
+        a.last=LastTransform{}; a.last->at=100;
+        a.releaseIdleMemory(120100);
+        if (!a.last) return false;
+        a.busy=true;
+        a.releaseIdleMemory(120101);
+        if (!a.last) { a.busy=false; return false; }
+        a.busy=false;
+        a.releaseIdleMemory(120101);
+        return !a.last;
+    }
+    static bool releasedSync(const App &a) {
+        return a.syncSnapshot.capacity()==0 && a.syncResult.settings.capacity()==0 &&
+            a.syncResult.base.capacity()==0 && a.syncResult.conflicts.capacity()==0;
+    }
+    static bool completedSync(App &a, int mode) {
+        sampleConflicts(a);
+        auto conflicts=encodeSyncConflicts(a.pendingSyncConflicts);
+        a.syncConnection=loadSyncConfig(a.data);
+        a.syncSnapshot=encodeSettings(a.settings);
+        a.syncResult={mode!=1,sharedSyncSettings(a.settings),2,L"test"};
+        a.syncResult.base=a.syncResult.settings;
+        a.syncResult.conflicts=a.pendingSyncConflicts;
+        if(mode==2) a.syncResult.settings={1,2,3}; // Decode exception after joining.
+        a.syncWorker=std::thread([]{});
+        a.syncRunning=true; a.syncDone=true; a.busy=true;
+        a.pollSync();
+        bool retained=!a.syncSnapshot.empty() && a.syncRunning;
+        a.busy=false; a.pollSync();
+        return retained && releasedSync(a) && !a.syncRunning &&
+            encodeSyncConflicts(a.pendingSyncConflicts)==conflicts;
+    }
     static inline bool delivery = true;
     static inline int notifications = 0;
     static bool notify(const std::wstring &) { ++notifications; return delivery; }
@@ -31,6 +76,7 @@ struct InputRegressionAccess {
         a.syncRunning=true; a.syncDone=true;
         a.pollSync();
         return encodeSettings(a.settings)==before && !a.syncRunning &&
+            releasedSync(a) &&
             !std::filesystem::exists(a.data/L"sync-base.bin");
     }
     static bool syncBackoff(App &a) {
@@ -80,6 +126,25 @@ int main(int argc, char **argv) {
     try {
         INITCOMMONCONTROLSEX controls{sizeof(controls),ICC_STANDARD_CLASSES|ICC_LISTVIEW_CLASSES};
         InitCommonControlsEx(&controls);
+        {
+            HMENU menu = CreatePopupMenu(), child = CreatePopupMenu();
+            AppendMenuW(menu,MF_STRING | MF_CHECKED,1,L"&Settings…");
+            AppendMenuW(menu,MF_STRING,2,L"Copy\tCtrl+C");
+            AppendMenuW(child,MF_STRING,3,L"Rock && &Roll");
+            AppendMenuW(menu,MF_POPUP,(UINT_PTR)child,L"&Pause");
+            ks::showMenuAccessKeys(menu);
+            ks::showMenuAccessKeys(menu);
+            wchar_t label[128]{};
+            GetMenuStringW(menu,1,label,128,MF_BYCOMMAND);
+            require(std::wstring(label)==L"&Settings…\tS" &&
+                    (GetMenuState(menu,1,MF_BYCOMMAND)&MF_CHECKED),
+                    "visible menu mnemonic is idempotent and preserves item state");
+            GetMenuStringW(menu,2,label,128,MF_BYCOMMAND);
+            require(std::wstring(label)==L"Copy\tCtrl+C","existing menu shortcut hints are retained");
+            GetMenuStringW(child,3,label,128,MF_BYCOMMAND);
+            require(std::wstring(label)==L"Rock && &Roll\tR","submenu hints skip escaped ampersands");
+            DestroyMenu(menu);
+        }
         {
             ks::App app(GetModuleHandleW(nullptr),true,temp);
             ks::InputRegressionAccess::setup(app);
@@ -599,6 +664,9 @@ int main(int argc, char **argv) {
             require(!app.handleKeyboard(f12,true,MOD_CONTROL|MOD_SHIFT),"exact modifiers only");
             app.resetInput();
             app.handleKeyboard(event('A',0x1e),true,0);
+            if (app.run.keys!=L"a" && app.run.keys!=L"A")
+                std::cerr << "Input fixture foreground=" << (uintptr_t)GetForegroundWindow()
+                          << " recorded=" << ks::utf8(app.run.keys) << '\n';
             require(app.run.keys==L"a"||app.run.keys==L"A","external scan recorded with current CapsLock");
             auto keys=app.run.keys; auto version=app.inputVersion.load();
             for(WORD key:{WORD('V'),WORD(VK_SHIFT),WORD(VK_LEFT),WORD(VK_F15),WORD(0xE8)})
@@ -626,6 +694,49 @@ int main(int argc, char **argv) {
             fitted=ks::fitWindowRect({2000,2000,2600,2400},{-1920,0,0,1080});
             require(fitted.left==-600&&fitted.top==680&&fitted.right==0,"negative-coordinate monitor supported");
             ks::showSettings(app,false);
+            {
+                auto timer = SetTimer(nullptr, 0, 10, answerSettingsClose);
+                require(timer != 0, "settings close prompt responder");
+                SendMessageW(app.settingsWindow, WM_CLOSE, 0, 0);
+                require(!app.settingsWindow && settingsClosePrompts == 0,
+                        "unchanged settings close without prompting");
+                ks::showSettings(app,false);
+                auto settingsWindow = app.settingsWindow;
+                auto initial = SendDlgItemMessageW(settingsWindow,205,BM_GETCHECK,0,0);
+                SendDlgItemMessageW(settingsWindow,205,BM_SETCHECK,!initial,0);
+                SendMessageW(settingsWindow, WM_CLOSE, 0, 0);
+                require(IsWindow(settingsWindow) && settingsClosePrompts == 1,
+                        "cancel close preserves changed settings");
+                SendDlgItemMessageW(settingsWindow,205,BM_SETCHECK,initial,0);
+                SendMessageW(settingsWindow, WM_CLOSE, 0, 0);
+                require(!app.settingsWindow && settingsClosePrompts == 1,
+                        "reverted settings close without prompting");
+                ks::showSettings(app,false);
+                SetDlgItemTextW(app.settingsWindow,240,L"invalid");
+                settingsCloseChoice = IDNO;
+                SendMessageW(app.settingsWindow,WM_COMMAND,IDCANCEL,0);
+                require(!app.settingsWindow && settingsClosePrompts == 2,
+                        "Cancel button allows discarding invalid edits");
+                auto originalSettings = app.settings;
+                // The isolated harness has no keyboard hook; save without shortcuts.
+                app.settings.toggle = app.settings.casing = app.settings.translit =
+                    app.settings.undo = app.settings.clipboard = app.settings.screenshot = L"";
+                app.settings.direct.assign(app.layouts.size(), L"");
+                ks::showSettings(app,false);
+                SendDlgItemMessageW(app.settingsWindow,208,BM_SETCHECK,
+                                    originalSettings.writeLog ? BST_UNCHECKED : BST_CHECKED,0);
+                settingsCloseChoice = IDYES;
+                SendMessageW(app.settingsWindow,WM_CLOSE,0,0);
+                require(!app.settingsWindow && settingsClosePrompts == 3 &&
+                        app.settings.writeLog != originalSettings.writeLog &&
+                        ks::loadSettings(app.data / L"settings.json",app.layouts).writeLog == app.settings.writeLog,
+                        "Yes saves settings to disk and applies them before closing");
+                app.settings = originalSettings;
+                ks::setLoggingEnabled(originalSettings.writeLog);
+                KillTimer(nullptr,timer);
+                settingsCloseChoice = IDCANCEL;
+                ks::showSettings(app,false);
+            }
             require(GetDlgItem(app.settingsWindow,258)!=nullptr,"sync available without local opt-in");
             // Mnemonics only target visible controls; show without taking foreground focus.
             ShowWindow(app.settingsWindow,SW_SHOWNOACTIVATE);
@@ -656,6 +767,23 @@ int main(int argc, char **argv) {
             require((GetWindowLongPtrW(GetDlgItem(syncWindow,604),GWL_STYLE)&ES_PASSWORD)!=0,
                     "sync password is masked");
             require(!IsWindowEnabled(app.settingsWindow),"sync dialog owns settings interaction");
+            for(int id:{602,603,604,605,606,607,610,611,612,613,IDOK})
+                require(!IsWindowEnabled(GetDlgItem(syncWindow,id)),"disabled synchronization disables dependent controls");
+            require(IsWindowEnabled(GetDlgItem(syncWindow,601)) && IsWindowEnabled(GetDlgItem(syncWindow,609)) &&
+                    IsWindowEnabled(GetDlgItem(syncWindow,IDCANCEL)),"enable, forget password and close remain available");
+            SendMessageW(syncWindow,WM_COMMAND,612,0);
+            require(!FindWindowW(L"KSwitcher.SyncConflicts",nullptr),"disabled conflict action is ignored");
+            SendDlgItemMessageW(syncWindow,601,BM_SETCHECK,BST_CHECKED,0);
+            SendMessageW(syncWindow,WM_COMMAND,MAKEWPARAM(601,BN_CLICKED),0);
+            for(int id:{602,603,604,605,606,607,610,611,613,IDOK})
+                require(IsWindowEnabled(GetDlgItem(syncWindow,id)),"enabling synchronization immediately enables connection controls");
+            require(!ks::loadSyncConfig(app.data).enabled,"checking enable alone does not connect or persist");
+            auto enabledSync=ks::loadSyncConfig(app.data);
+            enabledSync.enabled=true;
+            enabledSync.server=L"https://sync.example.test";
+            enabledSync.username=L"test";
+            ks::saveSyncConfig(app.data,enabledSync);
+            SendMessageW(syncWindow,WM_COMMAND,MAKEWPARAM(601,BN_CLICKED),0);
             ks::InputRegressionAccess::sampleConflicts(app);
             SendMessageW(syncWindow,WM_COMMAND,612,0);
             auto conflictsWindow=FindWindowW(L"KSwitcher.SyncConflicts",nullptr);
@@ -678,7 +806,7 @@ int main(int argc, char **argv) {
             require(!IsWindowEnabled(syncWindow),"conflict dialog owns sync interaction");
             SendMessageW(conflictsWindow,WM_COMMAND,IDCANCEL,0);
             require(IsWindowEnabled(syncWindow),"closing conflict dialog restores sync window");
-            for(int id:{601,602,603,604,605,606,607,608,609,610,611,612,IDOK,IDCANCEL}) {
+            for(int id:{601,602,603,604,605,606,607,608,609,610,611,612,613,IDOK,IDCANCEL}) {
                 RECT control{},client{};
                 GetWindowRect(GetDlgItem(syncWindow,id),&control);
                 MapWindowPoints(nullptr,syncWindow,reinterpret_cast<POINT*>(&control),2);
@@ -686,12 +814,20 @@ int main(int argc, char **argv) {
                 require(control.left>=0&&control.top>=0&&control.right<=client.right&&control.bottom<=client.bottom,
                         "sync controls fit dialog");
             }
+            SendDlgItemMessageW(syncWindow,601,BM_SETCHECK,BST_UNCHECKED,0);
+            SendMessageW(syncWindow,WM_COMMAND,MAKEWPARAM(601,BN_CLICKED),0);
+            require(IsWindowEnabled(GetDlgItem(syncWindow,IDOK)),"Save remains available to persist disabling sync");
             SendMessageW(syncWindow,WM_COMMAND,IDOK,0);
             require(!ks::loadSyncConfig(app.data).enabled,"saving disabled sync does not enable network access");
+            require(!IsWindowEnabled(GetDlgItem(syncWindow,IDOK)),"Save disables after disabled state is persisted");
             SendMessageW(syncWindow,WM_COMMAND,IDCANCEL,0);
             require(IsWindowEnabled(app.settingsWindow),"closing sync restores parent");
             require(ks::InputRegressionAccess::staleSync(app,false),"in-flight sync cannot overwrite newer local edits");
             require(ks::InputRegressionAccess::staleSync(app,true),"disconnect discards in-flight downloaded profile");
+            require(ks::InputRegressionAccess::idleUndo(app),"idle cleanup retains available/busy Undo and frees expired Undo");
+            for(int mode=0;mode<3;++mode)
+                require(ks::InputRegressionAccess::completedSync(app,mode),
+                        "completed, failed and invalid sync release buffers but preserve conflict choices");
             require(ks::InputRegressionAccess::syncBackoff(app),"saving settings preserves authentication error backoff");
             SendMessageW(app.settingsWindow,WM_COMMAND,255,0);
             auto autoOptions=FindWindowW(L"KSwitcher.AutoOptions",nullptr);
@@ -704,21 +840,31 @@ int main(int argc, char **argv) {
                 GetWindowRect(autoOptions,&original);
                 // Use a client size above the scrolling baseline at every DPI.
                 UINT dpi=GetDpiForWindow(autoOptions);
-                SetWindowPos(autoOptions,nullptr,0,0,MulDiv(800,dpi,96),MulDiv(900,dpi,96),
+                SetWindowPos(autoOptions,nullptr,0,0,MulDiv(800,dpi,96),MulDiv(1100,dpi,96),
                              SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE);
                 RECT baseline{}; GetWindowRect(autoOptions,&baseline);
+                RECT clientBefore{}; GetClientRect(autoOptions,&clientBefore);
                 for(int i=0;i<3;++i) GetWindowRect(GetDlgItem(autoOptions,411+i),&before[i]);
                 GetWindowRect(GetDlgItem(autoOptions,IDOK),&buttonBefore);
                 SetWindowPos(autoOptions,nullptr,0,0,baseline.right-baseline.left+240,
                              baseline.bottom-baseline.top+120,SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE);
+                RECT clientAfter{}; GetClientRect(autoOptions,&clientAfter);
+                // Windows can constrain oversized windows to the current desktop.
+                // Check layout against the actual available client space.
+                int extraBeforeX=std::max(0,int(clientBefore.right)-MulDiv(560,dpi,96));
+                int extraAfterX=std::max(0,int(clientAfter.right)-MulDiv(560,dpi,96));
+                int extraY=std::max(0,int(clientAfter.bottom)-MulDiv(880,dpi,96))-
+                           std::max(0,int(clientBefore.bottom)-MulDiv(880,dpi,96));
                 for(int i=0;i<3;++i) {
                     GetWindowRect(GetDlgItem(autoOptions,411+i),&after[i]);
-                    require(after[i].right-after[i].left==before[i].right-before[i].left+80 &&
+                    int extraX=(extraAfterX*(i+1)/3-extraAfterX*i/3)-
-                            after[i].bottom-after[i].top==before[i].bottom-before[i].top+120,
+                               (extraBeforeX*(i+1)/3-extraBeforeX*i/3);
+                    require(after[i].right-after[i].left==before[i].right-before[i].left+extraX &&
+                            after[i].bottom-after[i].top==before[i].bottom-before[i].top+extraY,
                             "dictionary columns share extra width and receive extra height");
                 }
                 GetWindowRect(GetDlgItem(autoOptions,IDOK),&buttonAfter);
-                require(buttonAfter.left-buttonBefore.left==240 && buttonAfter.top-buttonBefore.top==120,
+                require(buttonAfter.left-buttonBefore.left==extraAfterX-extraBeforeX && buttonAfter.top-buttonBefore.top==extraY,
                         "auto-correction buttons follow bottom-right corner");
                 require(after[0].right<after[1].left && after[1].right<after[2].left &&
                             after[2].bottom<buttonAfter.top,
@@ -735,8 +881,19 @@ int main(int argc, char **argv) {
                         "personal dictionary field fits options window");
             }
             SetDlgItemTextW(autoOptions,412,L"Релізик\r\nрелізик, словечко");
+            SetDlgItemTextW(autoOptions,416,L" Првиіт = Привіт\r\nhelo=hello");
+            SendDlgItemMessageW(autoOptions,414,BM_SETCHECK,BST_CHECKED,0);
+            SendDlgItemMessageW(autoOptions,415,BM_SETCHECK,BST_CHECKED,0);
             SendMessageW(autoOptions,WM_COMMAND,IDOK,0);
             require(!IsWindow(autoOptions),"personal words accepted without file editing");
+            {
+                auto timer = SetTimer(nullptr,0,10,answerSettingsClose);
+                auto before = settingsClosePrompts;
+                SendMessageW(app.settingsWindow,WM_CLOSE,0,0);
+                KillTimer(nullptr,timer);
+                require(app.settingsWindow && settingsClosePrompts == before + 1,
+                        "accepted personal dictionary edits trigger unsaved settings warning");
+            }
             SendMessageW(app.settingsWindow,WM_COMMAND,255,0);
             autoOptions=FindWindowW(L"KSwitcher.AutoOptions",nullptr);
             ShowWindow(autoOptions,SW_HIDE);
@@ -744,11 +901,18 @@ int main(int argc, char **argv) {
             GetDlgItemTextW(autoOptions,412,personalWords,128);
             require(std::wstring(personalWords)==L"релізик, словечко",
                     "personal dictionary normalizes case, newlines and duplicate words");
+            wchar_t pairs[128]{};
+            GetDlgItemTextW(autoOptions,416,pairs,128);
+            require(std::wstring(pairs)==L"helo=hello\r\nпрвиіт=привіт\r\n" &&
+                    SendDlgItemMessageW(autoOptions,414,BM_GETCHECK,0,0)==BST_CHECKED &&
+                    SendDlgItemMessageW(autoOptions,415,BM_GETCHECK,0,0)==BST_CHECKED,
+                    "typo options and normalized replacement pairs survive reopening");
             SendMessageW(autoOptions,WM_COMMAND,IDCANCEL,0);
             if (!app.history) app.history=std::make_unique<ks::History>(temp/L"history-layout");
             ks::showHistory(app,false);
             auto history=app.historyWindow;
             require(history&&!IsWindowVisible(history),"history layout tested without changing focus");
+            require(!GetDlgItem(history,105),"history creates no RichEdit control before formatted content is displayed");
             {
                 app.history=std::make_unique<ks::History>(temp/L"history-search");
                 app.history->add(ks::textClip(L"згенеруй приклад"),L"test",app.settings);
@@ -776,6 +940,27 @@ int main(int argc, char **argv) {
                 SetDlgItemTextW(history,101,L"");
                 require(pumpUntil(2),"clearing search restores history");
                 require(GetFocus()==originalFocus,"history search preserves focus");
+                SendDlgItemMessageW(history,102,LB_SETCURSEL,1,0);
+                ks::refreshHistory(app); // A result may still be in flight when closing.
+                SendDlgItemMessageW(history,101,WM_KEYDOWN,VK_ESCAPE,0);
+                require(!IsWindowVisible(history) && !GetDlgItem(history,105),
+                        "Escape closes history and leaves no RichEdit control");
+                SendMessageW(history,WM_TIMER,1,0); // KillTimer cannot retract a posted timer message.
+                require(pumpUntil(0),"closing history releases list strings");
+                auto until=GetTickCount64()+250;
+                while(GetTickCount64()<until) {
+                    MSG message{};
+                    while(PeekMessageW(&message,nullptr,0,0,PM_REMOVE)) {
+                        TranslateMessage(&message); DispatchMessageW(&message);
+                    }
+                    Sleep(5);
+                }
+                require(SendDlgItemMessageW(history,102,LB_GETCOUNT,0,0)==0,
+                        "late search results do not refill closed history");
+                ks::refreshHistory(app);
+                require(pumpUntil(2),"history reloads after releasing hidden rows");
+                require(SendDlgItemMessageW(history,102,LB_GETCURSEL,0,0)==1,
+                        "history retains selected record across close and reload");
             }
             auto childRect=[&](int id) { RECT r{}; GetWindowRect(GetDlgItem(history,id),&r); MapWindowPoints(nullptr,history,(POINT*)&r,2); return r; };
             RECT historyFrame{}; GetWindowRect(history,&historyFrame);

tests/integration.cpp

@@ -9,6 +9,7 @@ namespace ks
 {
 struct InputRegressionAccess
 {
+    static bool hasLast(App &app) { return app.last.has_value(); }
     static bool deferring(App &app)
     {
         std::lock_guard lock(app.stateMutex);
@@ -23,10 +24,13 @@ HWND host{}, field{};
 ks::Clip saved;
 bool captured = false, failed = false;
 bool conversionOnly = false;
+bool typosOnly = false;
 int pasteBehavior = 0;
 int enterPresses = 0;
 int copyFailuresRemaining = 0, copyRequests = 0;
 int droppedSelectionKeys = 0;
+bool trimCopiedSpaces = false;
+int trimmedCopies = 0;
 bool temporaryClipboardExcluded = true;
 bool clipboardAccessTimedOut = false;
 LRESULT CALLBACK observeEnter(HWND w, UINT message, WPARAM wp, LPARAM lp, UINT_PTR, DWORD_PTR)
@@ -75,10 +79,42 @@ LRESULT CALLBACK observeEnter(HWND w, UINT message, WPARAM wp, LPARAM lp, UINT_P
                 --copyFailuresRemaining;
                 return 0;
             }
+            if (trimCopiedSpaces)
+            {
+                auto result = DefSubclassProc(w, message, wp, lp);
+                // Native EDIT closes the clipboard in its copy handler, including
+                // our outer opening. Reopen it before changing its published data.
+                if (!OpenClipboard(w))
+                {
+                    clipboardAccessTimedOut = true;
+                    return result;
+                }
+                auto handle = GetClipboardData(CF_UNICODETEXT);
+                auto data = handle ? static_cast<const wchar_t *>(GlobalLock(handle)) : nullptr;
+                if (data)
+                {
+                    std::wstring copied(data);
+                    GlobalUnlock(handle);
+                    const auto originalSize = copied.size();
+                    while (!copied.empty() && copied.back() == L' ') copied.pop_back();
+                    auto replacement = GlobalAlloc(GMEM_MOVEABLE, (copied.size() + 1) * sizeof(wchar_t));
+                    auto output = GlobalLock(replacement);
+                    memcpy(output, copied.c_str(), (copied.size() + 1) * sizeof(wchar_t));
+                    GlobalUnlock(replacement);
+                    if (!EmptyClipboard() || !SetClipboardData(CF_UNICODETEXT, replacement))
+                    {
+                        GlobalFree(replacement);
+                        clipboardAccessTimedOut = true;
+                    }
+                    else if (copied.size() != originalSize) ++trimmedCopies;
+                }
+                return result;
+            }
         }
     }
     if (message == WM_PASTE && pasteBehavior)
     {
+        if (pasteBehavior == 3) { pasteBehavior = 0; return 0; }
         if (pasteBehavior == 2) SendMessageW(w, EM_REPLACESEL, TRUE, (LPARAM)L"other!");
         return 0;
     }
@@ -370,6 +406,7 @@ LRESULT CALLBACK procedure(HWND w, UINT msg, WPARAM wp, LPARAM lp)
                 require(text() == L"ghbdtn" && rows.back().outcome == L"Original text remained",
                         "blocked paste records original text remaining in the actual editor");
                 require(ks::readClipboard(app->window).text() == sentinel, "readback preserves clipboard after blocked paste");
+                require(!ks::InputRegressionAccess::hasLast(*app), "failed paste does not retain a fictional previous result");
                 pasteBehavior = 2;
                 prepare(L"ghbdtn", true);
                 app->transform(ks::Direct + ru);
@@ -380,6 +417,7 @@ LRESULT CALLBACK procedure(HWND w, UINT msg, WPARAM wp, LPARAM lp)
                 auto rows = ks::parseOperationLog(ks::wide(diagnosticLog()));
                 require(text() == L"other!" && rows.back().outcome == L"Readback differs",
                         "unexpected editor content records readback mismatch");
+                require(!ks::InputRegressionAccess::hasLast(*app), "changed readback cannot seed repeat conversion");
                 pasteBehavior = 0;
                 prepare(L"привет", true);
                 app->transform(ks::Direct + ru);
@@ -427,6 +465,114 @@ LRESULT CALLBACK procedure(HWND w, UINT msg, WPARAM wp, LPARAM lp)
             case 47:
                 require(text() == L"OLDsnipping ", "recent Cyrillic suffix recovery preserves older prefix");
                 require(droppedSelectionKeys == 0, "recent suffix regression dropped four selection keys");
+                app->settings.writeLog = true;
+                prepare(L"prefix wrong ", false);
+                record(L"other ");
+                app->transform(ks::Direct + ru);
+                break;
+            case 48:
+            {
+                auto rows = ks::parseOperationLog(ks::wide(diagnosticLog()));
+                require(text() == L"prefix wrong " && !rows.empty() &&
+                        rows.back().outcome == L"recent-verification-mismatch",
+                        "diagnostic mismatch does not replace unverified text");
+                auto details = rows.back().details;
+                require(details.find(L"selection-mismatch") != details.npos &&
+                        details.find(L"Expected selection:\r\nother ") != details.npos &&
+                        details.find(L"Read back:\r\nwrong ") != details.npos,
+                        "failed verification includes expected and copied text in exported details");
+                require(details.find(L"Copy begin number=") != details.npos &&
+                        details.find(L"Copy result number=") != details.npos &&
+                        details.find(L"Selection initial match=0") != details.npos &&
+                        details.find(L"SelectPrevious") != details.npos,
+                        "incident includes clipboard and selection stages");
+                pasteBehavior = 3;
+                prepare(L"=nhtdjuf", true);
+                app->transform(ks::Direct + ru);
+                stage = 49;
+                break;
+            }
+            case 49:
+            {
+                require(text() == L"=тревога" && pasteBehavior == 0,
+                        "native Edit retries one ignored paste only while original remains selected");
+                require(ks::readClipboard(app->window).text() == sentinel, "native paste retry restores clipboard");
+                trimCopiedSpaces = true;
+                app->settings.writeLog = false;
+                prepare(L"OLDghbdtn  NEXT", false);
+                SendMessageW(field, EM_SETSEL, 11, 11);
+                record(L"ghbdtn  ");
+                app->transform(ks::Direct + ru);
+                break;
+            }
+            case 50:
+                require(text() == L"OLDпривет  NEXT", "trimmed clipboard recovery preserves two spaces and surrounding text without logging");
+                app->transform(ks::Direct + en);
+                break;
+            case 51:
+                require(text() == L"OLDghbdtn  NEXT", "repeat conversion preserves accessibility-proven spaces");
+                app->transform(ks::Undo);
+                break;
+            case 52:
+                require(text() == L"OLDпривет  NEXT", "undo preserves accessibility-proven spaces");
+                prepare(L"ghbdtn", false);
+                record(L"ghbdtn ");
+                app->transform(ks::Direct + ru);
+                break;
+            case 53:
+                require(text() == L"ghbdtn", "missing real space cannot be inferred from tracked keys");
+                prepare(L"wrong ", false);
+                record(L"ghbdtn ");
+                app->transform(ks::Direct + ru);
+                break;
+            case 54:
+                require(text() == L"wrong ", "unrelated selection remains rejected with trimmed clipboard");
+                app->settings.autoCorrect = true;
+                app->settings.autoLanguages = {L"en", L"ru"};
+                // The worker now shares the predictor's immutable dictionaries.
+                // This fixture changes settings directly instead of applySettings.
+                app->autoPredictor.configure(L"dictionaries", app->settings.autoLanguages);
+                app->autoCorrector = ks::AutoCorrector{};
+                ActivateKeyboardLayout(app->layouts[en].handle, 0);
+                prepare(L"ghbdtn ", false);
+                record(L"ghbdtn ");
+                app->transform(ks::AutoCorrect);
+                break;
+            case 55:
+                require(text() == L"привет ", "automatic correction recovers copied trailing space without logging");
+                app->transform(ks::Undo);
+                break;
+            case 56:
+            {
+                require(text() == L"ghbdtn ", "automatic correction undo retains recovered space");
+                require(ks::readClipboard(app->window).text() == sentinel, "space recovery restores clipboard");
+                pasteBehavior = 1;
+                prepare(L"ghbdtn ", false);
+                record(L"ghbdtn ");
+                app->transform(ks::Direct + ru);
+                break;
+            }
+            case 57:
+            {
+                require(text() == L"ghbdtn " && !ks::InputRegressionAccess::hasLast(*app),
+                        "recovered selection with blocked paste clears repeat state even without logging");
+                require(trimmedCopies >= 7, "fixture actually stripped spaces during recovery scenarios");
+                pasteBehavior = 0;
+                trimCopiedSpaces = false;
+                // User-selected middle range, followed by the same command with
+                // no selection: retain both surrounding text and trailing spaces.
+                prepare(L"OLDghbdtn  NEXT", false);
+                SendMessageW(field, EM_SETSEL, 3, 11);
+                app->transform(ks::Direct + ru);
+                break;
+            }
+            case 58:
+                require(text() == L"OLDпривет  NEXT", "explicit middle selection preserves surrounding text");
+                app->transform(ks::Direct + en);
+                break;
+            case 59:
+                require(text() == L"OLDghbdtn  NEXT", "hotkey without selection reconverts only the previous middle range");
+                require(ks::readClipboard(app->window).text() == sentinel, "selected and repeated conversions restore clipboard");
                 finish();
                 break;
             case 30:
@@ -597,6 +743,61 @@ LRESULT CALLBACK procedure(HWND w, UINT msg, WPARAM wp, LPARAM lp)
             }
             case 22:
                 require(text() == L"робить ", "automatic correction selects and converts the whole word across an internal comma");
+                app->settings.autoReplace = true;
+                app->settings.autoReplacements = {{L"helo", L"hello"}};
+                ActivateKeyboardLayout(app->layouts[en].handle, 0);
+                prepare(L"(Helo)! ", false);
+                record(L"(Helo)! ");
+                app->transform(ks::AutoCorrect);
+                break;
+            case 23:
+                require(text() == L"(Hello)! ", "explicit typo pair replaces verified text with punctuation and capital");
+                app->transform(ks::Undo);
+                break;
+            case 24:
+                require(text() == L"(Helo)! ", "Undo restores explicit typo replacement");
+                app->settings.autoReplace = false;
+                app->settings.autoTypos = true;
+                app->settings.autoWords[L"en"].push_back(L"kswitcher");
+                // Use a personal target to avoid bundled dictionary ambiguity.
+                prepare(L"kswithcer ", false);
+                record(L"kswithcer ");
+                app->transform(ks::AutoCorrect);
+                break;
+            case 25:
+                require(text() == L"kswitcher ", "dictionary typo correction replaces text in the current layout");
+                require(ks::readClipboard(app->window).text() == sentinel, "typo correction restores clipboard");
+                app->transform(ks::Undo);
+                break;
+            case 26:
+                require(text() == L"kswithcer ", "Undo restores dictionary typo correction");
+                record(L"kswithcer ");
+                app->transform(ks::AutoCorrect);
+                break;
+            case 27:
+                require(text() == L"kswithcer ", "Undo suppresses the rejected spelling correction");
+                app->settings.autoReplace = true;
+                app->settings.autoReplacements = {{L"tehh", L"the"}};
+                app->autoPredictor.configure(L"dictionaries", app->settings.autoLanguages);
+                prepare(L"", false);
+                {
+                    std::vector<INPUT> inputs;
+                    for (WORD key : std::wstring(L"TEHH X"))
+                        for (DWORD flags : {DWORD(0), DWORD(KEYEVENTF_KEYUP)})
+                        {
+                            auto input = ks::keyboardInput(key == L' ' ? VK_SPACE : key, flags);
+                            input.ki.dwExtraInfo = 123;
+                            inputs.push_back(input);
+                        }
+                    require(SendInput((UINT)inputs.size(), inputs.data(), sizeof(INPUT)) == inputs.size(),
+                            "custom typo and following word submitted without a pause");
+                }
+                break;
+            case 28:
+                require(text() == L"the x", "custom replacement through keyboard hook preserves subsequent typing");
+                app->settings.autoReplace = false;
+                app->settings.autoTypos = false;
+                if (typosOnly) { finish(); break; }
                 stage = 30;
                 break;
             }
@@ -621,6 +822,7 @@ LRESULT CALLBACK procedure(HWND w, UINT msg, WPARAM wp, LPARAM lp)
 int main(int argc, char **argv)
 {
     conversionOnly = argc > 1 && std::string(argv[1]) == "--conversion-only";
+    typosOnly = argc > 1 && std::string(argv[1]) == "--typos-only";
     CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED);
     auto root = std::filesystem::temp_directory_path() /
                 (L"KSwitcher-integration-" + std::to_wstring(GetCurrentProcessId()));
@@ -774,9 +976,9 @@ int main(int argc, char **argv)
             field =
                 CreateWindowW(L"EDIT", L"", WS_CHILD | WS_VISIBLE | WS_BORDER | ES_MULTILINE | ES_WANTRETURN,
                               20, 20, 590, 230, host, nullptr, cls.hInstance, nullptr);
-            deadline = GetTickCount64() + 30000;
+            deadline = GetTickCount64() + 60000;
             SetWindowSubclass(field, observeEnter, 1, 0);
-            if (argc > 1 && std::string(argv[1]) == "--typing-only")
+            if (typosOnly || (argc > 1 && std::string(argv[1]) == "--typing-only"))
                 stage = 20;
             if (argc > 1 && std::string(argv[1]) == "--snippets-only")
                 stage = 30;

tests/ocr.cpp

@@ -59,6 +59,24 @@ int main(int argc, char **argv)
             app.settings.history = true;
             app.history->add(clip, L"OCR fixture", app.settings);
             auto id = app.history->entries().front().id;
+            auto isolated = app.history->recognizeImage(id, config);
+            if (isolated != text) throw std::runtime_error("Helper and in-process OCR results differ");
+            bool cancelled = false;
+            try { app.history->recognizeImage(id, config, [] { return true; }); }
+            catch (const std::exception &) { cancelled = true; }
+            if (!cancelled) throw std::runtime_error("Cancelled OCR request was executed");
+            auto invalid = config;
+            invalid.useTesseract = true;
+            invalid.tesseractPath = (temp / L"missing-tesseract.exe").wstring();
+            bool failed = false;
+            try { app.history->recognizeImage(id, invalid); }
+            catch (const std::exception &) { failed = true; }
+            if (!failed || app.history->entries().front().ocrState != 1)
+                throw std::runtime_error("Failed helper modified history metadata");
+            for (const auto &file : std::filesystem::directory_iterator(temp / L"history"))
+                if (file.path().filename().wstring().starts_with(L"ocr-"))
+                    throw std::runtime_error("OCR helper left temporary files");
+            std::cout << "PASS isolated OCR equivalence, cancellation, failure and encrypted IPC cleanup\n";
             if (tesseract)
             {
                 app.history->saveOcr(id, L"old Windows result", app.settings);

tests/screenshot_registration.cpp

@@ -5,9 +5,11 @@
 static std::wstring programs;
 static std::wstring activationExecutable, activationCommand;
 static int activationCalls{};
+static DWORD launchFlags{}; static bool inheritsHandles{};
 static BOOL WINAPI testCreateProcess(LPCWSTR path, LPWSTR command, LPSECURITY_ATTRIBUTES,
-    LPSECURITY_ATTRIBUTES, BOOL, DWORD, LPVOID, LPCWSTR, LPSTARTUPINFOW, LPPROCESS_INFORMATION)
+    LPSECURITY_ATTRIBUTES, BOOL inherit, DWORD flags, LPVOID, LPCWSTR, LPSTARTUPINFOW, LPPROCESS_INFORMATION)
 {
+    launchFlags=flags; inheritsHandles=inherit;
     ++activationCalls; activationExecutable=path; activationCommand=command;
     SetLastError(ERROR_CANCELLED); return FALSE; // Inspect activation without starting any program.
 }
@@ -55,6 +57,14 @@ int main()
         valid=id.vt==VT_CLSID && *id.puuid==ks::ActivatorId; PropVariantClear(&id);
         if(!valid) throw std::runtime_error("shortcut activator missing");
         ks::registerScreenshotNotifications(); // Registration is safe to repeat.
+        bool launchFailed=false;
+        try { ks::startScreenshotNotificationRegistration(); }
+        catch(const std::exception &) { launchFailed=true; }
+        if(!launchFailed || activationExecutable!=helper.wstring() ||
+           activationCommand!=L"\""+helper.wstring()+L"\" --register-notifications" ||
+           !(launchFlags&CREATE_NO_WINDOW) || inheritsHandles)
+            throw std::runtime_error("registration must launch the sibling helper and propagate failure");
+        activationCalls=0;
         ks::Activator activator(helper.wstring(),false);
         activator.Activate(L"HrynCo.KSwitcher.Screenshot",L"check-update",nullptr,0);
         auto main=(helper.parent_path()/L"KSwitcher.exe").wstring();

tests/screenshot_ui.cpp

@@ -225,6 +225,17 @@ int main(int argc, char **argv)
             require(c.zoom>zoom && std::abs(before.x-after.x)<=1 && std::abs(before.y-after.y)<=1,
                     "Ctrl+wheel zoom keeps image point under cursor");
             require(!c.history.canUndo(),"zoom does not add image edits to undo history");
+            // A fixed zoom can still fit inside a high-DPI editor. Size the
+            // fixture from the actual viewport, with room for the tested drag
+            // on both axes, then start from a centered view.
+            const double panZoom=std::max({1.0,
+                double(c.canvas.right-c.canvas.left+128)/(c.view.right-c.view.left),
+                double(c.canvas.bottom-c.canvas.top+128)/(c.view.bottom-c.view.top)});
+            ks::zoomCanvas(window,c,panZoom,center);
+            c.panX=c.panY=0; ks::layout(window,c);
+            require(c.view.left+15<c.canvas.left && c.view.top+10<c.canvas.top &&
+                    c.view.right>c.canvas.right && c.view.bottom>c.canvas.bottom,
+                    "pan fixture has drag clearance on both axes within the supported zoom range");
             auto view=c.view;
             SendMessageW(window,WM_MBUTTONDOWN,MK_MBUTTON,MAKELPARAM(center.x,center.y));
             SendMessageW(window,WM_MOUSEMOVE,MK_MBUTTON,MAKELPARAM(center.x+15,center.y+10));
@@ -443,8 +454,16 @@ int main(int argc, char **argv)
             c.marks={{{20,20},{120,20},0}};
             require(ks::actionCursor(c,{0,ks::MarkPart::Body},true)==LoadCursorW(nullptr,IDC_SIZEALL),"move cursor overrides drawing tool");
             require(ks::actionCursor(c,{0,ks::MarkPart::Rotation},true)==LoadCursorW(nullptr,IDC_HAND),"rotation cursor overrides drawing tool");
-            require(ks::actionCursor(c,{0,ks::MarkPart::End},true)==LoadCursorW(nullptr,IDC_SIZEWE),"endpoint resize overrides drawing tool");
+            for(auto part:{ks::MarkPart::Start,ks::MarkPart::End,ks::MarkPart::Radius,
+                           ks::MarkPart::Label,ks::MarkPart::Vertex0,ks::MarkPart::Vertex1,ks::MarkPart::Vertex2})
+                require(ks::actionCursor(c,{0,part},true)==LoadCursorW(nullptr,IDC_SIZEALL),
+                        "freely movable handles use four-direction cursor for every drawing tool");
             require(ks::actionCursor(c,{0,ks::MarkPart::Thickness},true)==LoadCursorW(nullptr,IDC_SIZENS),"thickness resize is perpendicular to line");
+            c.marks[0].to={20,120};
+            require(ks::actionCursor(c,{0,ks::MarkPart::End},true)==LoadCursorW(nullptr,IDC_SIZEALL),
+                    "vertical line endpoint still moves in both axes");
+            require(ks::actionCursor(c,{0,ks::MarkPart::Thickness},true)==LoadCursorW(nullptr,IDC_SIZEWE),
+                    "vertical line thickness retains horizontal resize cursor");
         }
         c.marks.clear(); SendMessageW(window,WM_COMMAND,27,0);
         wchar_t windowTitle[128]{}; GetWindowTextW(window,windowTitle,128);

tests/sync.cpp

@@ -54,6 +54,10 @@ int main()
         rejects([&] { validateSyncConfig(invalid); }, "reject unsupported provider");
         saveSyncConfig(root, config);
         require(syncVisible(root) && loadSyncConfig(root) == config, "connection round trip");
+        auto partialConfig = config; partialConfig.keepLocalLayouts = true;
+        saveSyncConfig(root, partialConfig);
+        require(loadSyncConfig(root).keepLocalLayouts, "partial sync mode survives restart");
+        saveSyncConfig(root, config);
         auto rawConfig = parse(readFile(root / L"sync.json", 16384));
         require(!rawConfig.contains("password") && !rawConfig.contains("token"), "no secrets in config");
         Settings local;
@@ -84,9 +88,49 @@ int main()
         left = right = j; left["snippets"].push_back({{"trigger", "aaa"}, {"text", "one"}});
         right["snippets"].push_back({{"trigger", "bbb"}, {"text", "two"}});
         require(parse(mergeSyncSettings(base, bytes(left), bytes(right)))["snippets"].size() == 3, "independent snippet additions merge");
-        rejects([&] { mergeSyncSettings({}, bytes(left), base); }, "first sync needs explicit choice");
+        require(parse(mergeSyncSettings({}, bytes(left), base))["snippets"].size() == 2,
+                "first sync merges independent additions without choosing a whole profile");
         require(parse(mergeSyncSettings({}, base, base)) == j, "identical first sync safe");
+        {
+            auto l = j, r = j;
+            l["autoCorrectMinLength"] = 4; r["autoCorrectMinLength"] = 5;
+            l["autoCorrectNever"].push_back("localword");
+            r["autoCorrectNever"].push_back("remoteword");
+            auto plan = mergeSyncProfile({}, bytes(l), bytes(r));
+            require(plan.conflicts.size() == 1 && parse(plan.local)["autoCorrectNever"].size() == 2 &&
+                    parse(plan.remote)["autoCorrectNever"].size() == 2,
+                    "first sync merges lists while preserving scalar conflicts");
+            require(parse(plan.local)["autoCorrectMinLength"] == 4 && parse(plan.remote)["autoCorrectMinLength"] == 5,
+                    "first sync never guesses between different scalar values");
+            auto again = mergeSyncProfile(plan.base, plan.local, plan.remote);
+            require(again.conflicts.size() == 1, "first-sync conflicts survive saving the ancestor");
+            auto resolved = mergeSyncProfile(plan.base, plan.local, plan.remote, {{plan.conflicts[0], false}});
+            require(resolved.conflicts.empty() && parse(resolved.local)["autoCorrectMinLength"] == 5,
+                    "first-sync conflict can be resolved independently");
+        }
         require(SyncIntervalMs == 600000, "background interval is ten minutes");
+        {
+            auto l = j, r = j;
+            l["autoCorrectReplacements"]["helo"] = "hello";
+            r["autoCorrectReplacements"]["wrold"] = "world";
+            auto paired = mergeSyncSettings(base, bytes(l), bytes(r));
+            require(parse(paired)["autoCorrectReplacements"].size() == 2, "independent replacement pairs merge");
+            l = r = parse(paired);
+            l["autoCorrectReplacements"].erase("helo");
+            r["autoCorrectReplacements"]["wrold"] = "worlds";
+            auto removed = mergeSyncSettings(paired, bytes(l), bytes(r));
+            auto restored = restoreSyncSettings(removed, local, {});
+            require(restored.autoReplacements.size() == 1 && restored.autoReplacements.at(L"wrold") == L"worlds",
+                    "replacement deletion merges with an independent edit and remains loadable");
+            r["autoCorrectReplacements"]["helo"] = "help";
+            require(mergeSyncProfile(paired, bytes(l), bytes(r)).conflicts.size() == 1,
+                    "replacement deletion versus edit is a conflict");
+            auto legacy = j;
+            for (auto key : {"autoCorrectReplace", "autoCorrectTypos", "autoCorrectReplacements"}) legacy.erase(key);
+            auto migrated = restoreSyncSettings(bytes(legacy), local, {});
+            require(!migrated.autoReplace && !migrated.autoTypos && migrated.autoReplacements.empty(),
+                    "older synchronized profiles default new typo modes off");
+        }
         {
             auto l = j, r = j;
             l["autoCorrectMinLength"] = 4; r["autoCorrectMinLength"] = 5;
@@ -173,6 +217,40 @@ int main()
         rejects([&] { synchronize(provider, base, bytes(left), SyncAction::Upload); }, "racing writer protected");
         require(provider.writes == 1 && provider.remote.settings == base, "CAS failure preserves remote");
         provider.race = false;
+        {
+            auto remoteProfile = j;
+            remoteProfile["layouts"] = Json::array({"win:00000422"});
+            remoteProfile["layoutHotkeys"] = Json::array({{{"layoutId", "win:00000422"}, {"hotkey", "Ctrl+Alt+9"}}});
+            remoteProfile["autoCorrectNever"].push_back("remoteword");
+            FakeProvider partial;
+            partial.remote = {3, bytes(remoteProfile)};
+            auto validate = [&](const Bytes &b) { restoreSyncSettings(b, local, {}, true); };
+            auto result = synchronize(partial, {}, base, SyncAction::Automatic, validate, {}, true);
+            auto restored = restoreSyncSettings(result.settings, local, {}, true);
+            require(restored.cycle == local.cycle && restored.direct == local.direct &&
+                    restored.autoNever == std::vector<std::wstring>{L"remoteword"},
+                    "partial sync restores other settings and keeps local layout configuration");
+            auto next = sharedSyncSettings(restored);
+            result = synchronize(partial, result.base, next, SyncAction::Automatic, validate, {}, true);
+            require(parse(partial.remote.settings)["layouts"] == remoteProfile["layouts"] &&
+                    parse(partial.remote.settings)["layoutHotkeys"] == remoteProfile["layoutHotkeys"],
+                    "repeated partial sync never deletes unavailable server layouts or shortcuts");
+            auto changed = parse(next); changed["autoCorrectMinLength"] = 7;
+            result = synchronize(partial, result.base, bytes(changed), SyncAction::Upload, validate, {}, true);
+            require(parse(partial.remote.settings)["autoCorrectMinLength"] == 7 &&
+                    parse(partial.remote.settings)["layoutHotkeys"] == remoteProfile["layoutHotkeys"],
+                    "explicit partial upload preserves server layouts too");
+            auto downloaded = synchronize(partial, result.base, base, SyncAction::Download, validate, {}, true);
+            auto downloadedSettings = restoreSyncSettings(downloaded.settings, local, {}, true);
+            require(downloadedSettings.autoMinLength == 7 && downloadedSettings.cycle == local.cycle &&
+                    downloadedSettings.direct == local.direct, "partial Download applies other settings without replacing local layouts");
+            try { restoreSyncSettings(bytes(remoteProfile), local, {}); require(false, "full sync must identify missing layouts"); }
+            catch (const std::runtime_error &e) {
+                std::string message = e.what();
+                require(message.find("win:00000422") != message.npos && message.find("Keep this PC's layouts") != message.npos,
+                        "missing-layout error identifies IDs and offers partial sync");
+            }
+        }
         rejects([&] { synchronize(provider, base, bytes(left), SyncAction::Upload,
             [](const Bytes &) { throw std::runtime_error("invalid"); }); }, "validate before upload");
         require(provider.writes == 1, "invalid data not uploaded");

tests/tests.cpp

@@ -4,6 +4,7 @@
 #include "richtext.h"
 #include "storage.h"
 #include "diagnostics.h"
+#include "json.hpp"
 #include <algorithm>
 #include <iostream>
 #include <map>
@@ -23,20 +24,6 @@ void rejects(const std::function<void()> &f, const char *name)
     bool thrown = false;
     try
     {
-        {
-            std::map<std::wstring,int> previews;
-            std::set<std::wstring> visible;
-            for(int i=0;i<40;++i) previews[std::to_wstring(i)]=i;
-            for(int i=0;i<8;++i) visible.insert(std::to_wstring(i));
-            ks::trimHistoryPreviews(previews,visible);
-            require(previews.size()==32,"preview cache stays bounded");
-            for(const auto &id:visible) require(previews.contains(id),"visible preview survives eviction");
-            for(int i=0;i<40;++i) { auto id=std::to_wstring(i); previews[id]=i; visible.insert(id); }
-            ks::trimHistoryPreviews(previews,visible);
-            require(previews.size()==40,"tall viewport does not thrash visible previews");
-            visible.clear(); ks::trimHistoryPreviews(previews,visible);
-            require(previews.size()==32,"cache shrinks after leaving tall viewport");
-        }
         f();
     }
     catch (...)
@@ -60,6 +47,34 @@ int main(int argc, char **argv)
     }
     try
     {
+        // Byte budgets must retain visible entries even when they alone exceed the budget.
+        {
+            std::map<std::wstring, size_t> cache{{L"a", 800}, {L"b", 800}, {L"c", 100}};
+            std::set<std::wstring> visible{L"b"};
+            auto weight=[](size_t bytes) { return bytes; };
+            ks::trimHistoryPreviews(cache, visible, 32, 1000, weight);
+            require(cache.size()==2 && cache.contains(L"b") && cache.contains(L"c"),
+                    "byte budget evicts offscreen previews below count limit");
+            ks::trimHistoryPreviews(cache, visible, 32, 100, weight);
+            require(cache.size()==1 && cache.contains(L"b"), "oversized visible preview never thrashes");
+            visible.clear();
+            ks::trimHistoryPreviews(cache, visible, 32, 100, weight);
+            require(cache.empty(), "oversized preview is freed after leaving viewport");
+        }
+        {
+            std::map<std::wstring,int> previews;
+            std::set<std::wstring> visible;
+            for(int i=0;i<40;++i) previews[std::to_wstring(i)]=i;
+            for(int i=0;i<8;++i) visible.insert(std::to_wstring(i));
+            ks::trimHistoryPreviews(previews,visible);
+            require(previews.size()==32,"preview cache stays bounded");
+            for(const auto &id:visible) require(previews.contains(id),"visible preview survives eviction");
+            for(int i=0;i<40;++i) { auto id=std::to_wstring(i); previews[id]=i; visible.insert(id); }
+            ks::trimHistoryPreviews(previews,visible);
+            require(previews.size()==40,"tall viewport does not thrash visible previews");
+            visible.clear(); ks::trimHistoryPreviews(previews,visible);
+            require(previews.size()==32,"cache shrinks after leaving tall viewport");
+        }
         {
             ks::DiagnosticJson record{{"attempt", "42"}, {"process", "editor.exe"}, {"command", "Convert / cycle"},
                 {"source", "English"}, {"target", "Ukrainian"}, {"outcome", "Original text remained"},
@@ -99,6 +114,10 @@ int main(int argc, char **argv)
                 "large diagnostic selections are explicitly truncated");
         STARTUPINFOW startup{sizeof(startup)};
         ks::DiagnosticBuffer diagnostics;
+        diagnostics.record(L"idle-expiry", false, 0);
+        require(diagnostics.expire(30000)==0,"diagnostics remain available at expiry boundary");
+        require(diagnostics.expire(30001)==1,"idle expiry releases context without another log event");
+        require(diagnostics.expire(60000)==0,"repeated idle expiry is safe");
         require(diagnostics.record(L"successful-attempt", false, 100).empty(),
                 "successful diagnostics stay in memory");
         auto incident = diagnostics.record(L"failed-attempt", true, 200);
@@ -111,8 +130,8 @@ int main(int argc, char **argv)
         require(diagnostics.record(L"later-failure", true, 30500).find(L"expired-context") == std::wstring::npos,
                 "context expires after thirty seconds");
         diagnostics.record(L"oldest-context", false, 30600);
-        for (int i = 0; i < 40; ++i)
+        for (int i = 0; i < 128; ++i)
-            diagnostics.record(L"bounded-context", false, 30600 + i);
+            diagnostics.record(L"bounded-context", false, 30600);
         require(diagnostics.record(L"bounded-failure", true, 30700).find(L"oldest-context") == std::wstring::npos,
                 "context buffer has a fixed size");
         diagnostics.record(L"disabled-context", false, 30800);
@@ -171,6 +190,8 @@ int main(int argc, char **argv)
                 "HTML entities and Unicode survive without script text");
         require((effects(0, 6) & CFE_BOLD) != 0, "inline CSS bold is rendered");
         auto plain = ks::textClip(L"{\\literal} Привіт");
+        require(ks::richPreview(plain, false).empty(), "plain history preview does not require RichEdit");
+        require(!ks::richPreview(styled, false).empty(), "formatted history preview retains HTML rendering");
         ks::setRichText(rich, ks::richPreview(plain));
         GetWindowTextW(rich, rendered, 256);
         require(std::wstring(rendered) == plain.text(), "plain Unicode and RTF metacharacters are escaped");
@@ -217,6 +238,33 @@ int main(int argc, char **argv)
         require(!autoSettings.autoCorrect, "auto-correction defaults off");
         autoSettings.cycle = {L"en", L"uk"};
         corrector.configure(L"dictionaries", autoSettings.autoLanguages);
+        {
+            ks::AutoCorrector consumer;
+            consumer.shareDictionaries(corrector);
+            require(consumer.suggest(L"ghbdsn ", 0, layouts, autoSettings).has_value(),
+                    "shared dictionaries produce the same correction");
+            consumer.reject(L"ghbdsn");
+            consumer.shareDictionaries(corrector);
+            require(!consumer.suggest(L"ghbdsn ", 0, layouts, autoSettings),
+                    "refreshing shared dictionaries preserves consumer undo rejections");
+            require(corrector.suggest(L"ghbdsn ", 0, layouts, autoSettings).has_value(),
+                    "consumer rejections do not affect the predictor");
+            ks::AutoCorrector retained;
+            retained.shareDictionaries(corrector);
+            corrector.configure({}, {});
+            require(retained.suggest(L"ghbdsn ", 0, layouts, autoSettings).has_value(),
+                    "in-flight dictionary snapshot survives source reset");
+            consumer.shareDictionaries(corrector);
+            require(consumer.memoryBytes() == 0, "disabled correction releases consumer dictionaries");
+            corrector.shareDictionaries(retained);
+        }
+        {
+            auto options = autoSettings;
+            options.autoTypos = true;
+            auto typo = corrector.suggest(L"првиіт ", 2, layouts, options);
+            require(typo && typo->text == L"привіт " && typo->target == 2,
+                    "bundled Ukrainian dictionary corrects a common transposition");
+        }
         auto suggested = corrector.suggest(L"ghbdsn ", 0, layouts, autoSettings);
         require(suggested && suggested->text == L"привіт " && suggested->target == 2,
                 "dictionary corrects Ukrainian and retains trailing space");
@@ -497,8 +545,61 @@ int main(int argc, char **argv)
             auto correction = edited.suggest(L"руддщ ", 2, layouts, options);
             require(correction && correction->text == L"hello ",
                     "unsorted dictionaries and duplicates load using lowest duplicate rank");
+            require(!edited.suggest(L"hlelo ", 0, layouts, options), "spelling correction defaults off");
+            options.autoTypos = true;
+            for (auto typo : {L"hlelo ", L"helo ", L"helllo ", L"hezlo "})
+            {
+                correction = edited.suggest(typo, 0, layouts, options);
+                require(correction && correction->text == L"hello " && correction->target == 0,
+                        "single transposition, deletion, insertion and substitution retain the source layout");
+            }
+            correction = edited.suggest(L"(Hlelo), ", 0, layouts, options);
+            require(correction && correction->text == L"(Hello), ", "typos retain case and punctuation");
+            for (auto text : {L"hello ", L"HLELO ", L"hLelo ", L"h3llo ", L"h.llo ", L"hlo ", L"hello@example.com "})
+                require(!edited.suggest(text, 0, layouts, options), "known or unsafe typo input is unchanged");
+            options.autoWords[L"en"] = {L"hella"};
+            require(!edited.suggest(L"hell ", 0, layouts, options), "personal dictionary alternatives create ambiguity");
+            options.autoWords.clear();
+            options.autoReplacements = {{L"hlelo", L"greeting"}, {L"hello", L"greetings"}, {L"првиіт", L"привіт"}};
+            options.autoReplace = true;
+            correction = edited.suggest(L"Hlelo! ", 0, layouts, options);
+            require(correction && correction->text == L"Greeting! ", "explicit replacements override spelling guesses");
+            correction = edited.suggest(L"hello ", 0, layouts, options);
+            require(correction && correction->text == L"greetings ", "explicit replacements can override known words");
+            correction = edited.suggest(L"Првиіт ", 2, layouts, options);
+            require(correction && correction->text == L"Привіт " && correction->target == 2,
+                    "Ukrainian replacements work without dictionary membership");
+            options.autoNever = {L"hlelo"};
+            require(!edited.suggest(L"hlelo ", 0, layouts, options), "never-correct overrides explicit pairs");
+            options.autoNever.clear();
+            edited.reject(L"(Hlelo)! ", options);
+            require(!edited.suggest(L"hlelo ", 0, layouts, options), "undo rejection suppresses custom replacements");
+            options.autoReplace = false;
+            options.autoWords[L"uk"] = {L"привіт"};
+            correction = edited.suggest(L"првиіт ", 2, layouts, options);
+            require(correction && correction->text == L"привіт ", "Ukrainian personal words are typo targets");
+            options.cycle = {L"en"};
+            require(!edited.suggest(L"првиіт ", 2, layouts, options), "disabled source layouts do not correct typos");
+            put(L"en.txt", L"hello\t1\nhella\t99999\n");
+            ks::AutoCorrector ambiguous;
+            ambiguous.configure(folder, {L"en", L"uk"});
+            require(!ambiguous.suggest(L"hell ", 0, layouts, options), "frequency filter does not conceal ambiguous typo targets");
         }
         ks::Pixels pixels{2, 1, {10, 20, 30, 255, 40, 50, 60, 255}};
+        {
+            auto png = ks::encodePng(pixels);
+            ks::Clip encoded{{{0, L"PNG", png}}};
+            for (int i=0; i<3; ++i) {
+                auto decoded=ks::decodeImage(encoded);
+                require(decoded.bgra==pixels.bgra && decoded.width==2 && decoded.height==1,
+                        "borrowed PNG stream preserves decoded pixels on repeated reads");
+                require(encoded.formats[0].data==png,"PNG decoder never modifies the borrowed input");
+            }
+            ks::Clip fallback{{{0,L"PNG",{}},ks::imageDib(pixels)}};
+            require(ks::decodeImage(fallback).bgra==pixels.bgra,"empty PNG falls back to DIB");
+            ks::Clip invalid{{{0,L"PNG",{1,2,3}}}};
+            rejects([&] { ks::decodeImage(invalid); },"invalid borrowed PNG fails safely");
+        }
         ks::Clip firstImage{{ks::imageDib(pixels), {0, L"Ole Private Data", {1, 2, 3}}}};
         auto thumbnail = ks::decodeImage(firstImage, 1, 1);
         require(thumbnail.width == 1 && thumbnail.height == 1 && thumbnail.bgra.size() == 4,
@@ -537,11 +638,62 @@ int main(int argc, char **argv)
                     "Snipping Tool republish retains one pinned history entry");
             history.add(changedImage, L"SnippingTool", defaults);
             require(history.entries().size() == 2, "a new screenshot is retained");
+            auto copiedText = ks::textClip(L"text after screenshot");
+            history.add(copiedText, L"Editor", defaults);
+            history.add(copiedText, L"Editor", defaults);
+            require(history.entries().size() == 3 && !history.entries().front().image,
+                    "text after screenshot is retained and consecutive text duplicates are skipped");
+            history.add(changedImage, L"SnippingTool", defaults);
+            history.add(changedImage, L"SnippingTool", defaults);
+            require(history.entries().size() == 4 && history.entries().front().image,
+                    "image after text is retained and consecutive image duplicates are skipped");
+            history.add(withText, L"Editor", defaults);
+            require(history.entries().size() == 5,
+                    "mixed image and text payload is not discarded by metadata prefilter");
+        }
+        {
+            auto folder = temp / L"fingerprints";
+            ks::Settings defaults;
+            ks::History history(folder);
+            history.add(firstImage, L"test", defaults);
+            auto id = history.entries().front().id;
+            history.pin(id);
+            history.saveOcr(id, L"retained OCR", defaults);
+            ks::History reopened(folder);
+            require(reopened.entries().front().contentHash.size() == 64,
+                    "SHA-256 fingerprint survives encrypted index reload");
+            // Deny payload reads: duplicates must still be detected using only the index.
+            auto handle = CreateFileW((folder / (id + L".dat")).c_str(), GENERIC_READ, 0, nullptr,
+                                      OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
+            require(handle != INVALID_HANDLE_VALUE, "lock image payload for no-read regression");
+            reopened.add(firstImage, L"test", defaults);
+            reopened.add(secondImage, L"test", defaults);
+            reopened.add(recoded, L"test", defaults);
+            CloseHandle(handle);
+            require(reopened.entries().size() == 1 && reopened.entries().front().pinned &&
+                    reopened.ocrText(id) == std::optional<std::wstring>(L"retained OCR"),
+                    "exact, OLE and pixel-equivalent duplicates need no payload read and retain pin/OCR");
+            auto index = nlohmann::json::parse(ks::unprotect(ks::readFile(folder / L"index.dat", 1024*1024)));
+            for (auto &entry : index)
+                for (auto key : {"fingerprintVersion", "contentHash", "imageHash", "pixelHash"}) entry.erase(key);
+            auto legacy = index.dump();
+            ks::atomicWrite(folder / L"index.dat", ks::protect(ks::Bytes(legacy.begin(), legacy.end())));
+            ks::History migrated(folder);
+            migrated.add(secondImage, L"test", defaults);
+            ks::History persisted(folder);
+            require(persisted.entries().size() == 1 && persisted.entries().front().contentHash.size() == 64,
+                    "legacy duplicate migrates fingerprints without adding or losing an entry");
+            persisted.add(changedImage, L"test", defaults);
+            require(persisted.entries().size() == 2, "pixel fingerprint preserves genuinely changed images");
+            persisted.add(firstImage, L"test", defaults);
+            require(persisted.entries().size() == 3, "hash deduplication remains consecutive rather than global");
         }
         ks::Settings settings;
         settings.writeLog = false;
         settings.elevatedAutostart = true;
         settings.autoCorrect = true;
+        settings.autoReplace = settings.autoTypos = true;
+        settings.autoReplacements = {{L"првиіт", L"привіт"}, {L"helo", L"hello"}};
         settings.autoMaxRank = 10000;
         settings.autoMinLength = 5;
         settings.autoPrefixChars = L"(#";
@@ -554,6 +706,14 @@ int main(int argc, char **argv)
         ks::saveSettings(temp / L"settings.json", settings);
         auto restored = ks::loadSettings(temp / L"settings.json", {});
         require(restored.autoWords == settings.autoWords, "personal dictionaries survive settings roundtrip");
+        require(restored.autoReplace && restored.autoTypos && restored.autoReplacements == settings.autoReplacements,
+                "typo options and Unicode pairs survive settings roundtrip");
+        for (const auto &pair : {std::pair{L"hello", L"привіт"}, {L"hello", L"hello"}, {L"hi!", L"hello"}})
+        {
+            auto invalid = settings;
+            invalid.autoReplacements = {{pair.first, pair.second}};
+            rejects([&] { ks::validateSettings(invalid); }, "invalid replacement pairs rejected");
+        }
         auto invalidWords = settings;
         invalidWords.autoWords[L"uk"] = {L"hello"};
         rejects([&] { ks::validateSettings(invalidWords); }, "personal dictionary rejects wrong language letters");

tools/measure-memory-components.ps1

@@ -0,0 +1,61 @@
+param([ValidateRange(1,20)][int]$Runs=3,[ValidateRange(100,10000)][int]$SettleMilliseconds=1500)
+# Private resident pages are counted externally, so the measurement buffer is
+# allocated in PowerShell, not in the measured process. Never trim working sets.
+$ErrorActionPreference='Stop'
+$root=Split-Path $PSScriptRoot -Parent
+$output=Join-Path $root 'build/memory-components'
+New-Item -ItemType Directory -Force $output | Out-Null
+$exe=Join-Path $output 'probe.exe'
+& "$root/.tools/w64devkit/bin/g++.exe" -std=c++20 -Os -static -s -DUNICODE -D_UNICODE -D_WIN32_WINNT=0x0A00 "$PSScriptRoot/memory-components.cpp" -o $exe -lole32 -loleaut32 -lshell32 -lpropsys -lshlwapi -luuid -luiautomationcore
+if($LASTEXITCODE) { throw 'Probe compilation failed' }
+Add-Type @'
+using System;
+using System.Runtime.InteropServices;
+public static class ComponentWorkingSet {
+ [DllImport("psapi.dll", SetLastError=true)] static extern bool QueryWorkingSet(IntPtr process,IntPtr buffer,int size);
+ public static long PrivateBytes(IntPtr process) {
+  int size=4*1024*1024;
+  IntPtr buffer=Marshal.AllocHGlobal(size);
+  try {
+   if(!QueryWorkingSet(process,buffer,size)) throw new System.ComponentModel.Win32Exception();
+   long count=Marshal.ReadIntPtr(buffer).ToInt64(), pages=0;
+   if(count>(size/IntPtr.Size)-1) throw new InvalidOperationException("Working set buffer is too small");
+   for(int i=0;i<count;i++) if((Marshal.ReadIntPtr(buffer,(i+1)*IntPtr.Size).ToInt64() & 256)==0) pages++;
+   return pages*Environment.SystemPageSize;
+  } finally { Marshal.FreeHGlobal(buffer); }
+ }
+}
+'@
+$rows=[Collections.Generic.List[object]]::new()
+foreach($run in 1..$Runs) {
+ foreach($mode in @('baseline','sta','mta','shell','uia','focused','combined')) {
+  $start=[Diagnostics.ProcessStartInfo]::new($exe,$mode)
+  $start.UseShellExecute=$false; $start.CreateNoWindow=$true
+  $start.RedirectStandardOutput=$true; $start.RedirectStandardInput=$true; $start.RedirectStandardError=$true
+  $process=[Diagnostics.Process]::Start($start)
+  $errors=$process.StandardError.ReadToEndAsync()
+  try {
+   foreach($expected in @('baseline','com','active','released','uninitialized')) {
+    $pending=$process.StandardOutput.ReadLineAsync()
+    if(!$pending.Wait(15000)) { throw "Timeout: $mode/$expected" }
+    $phase=$pending.Result
+    if($phase -ne $expected) { throw "Unexpected phase '$phase', expected $expected" }
+    Start-Sleep -Milliseconds $SettleMilliseconds
+    $process.Refresh()
+    $rows.Add([pscustomobject]@{Run=$run;Mode=$mode;Phase=$phase;PrivateBytes=$process.PrivateMemorySize64;PrivateWorkingSet=[ComponentWorkingSet]::PrivateBytes($process.Handle);WorkingSet=$process.WorkingSet64;Threads=$process.Threads.Count;Modules=@($process.Modules | ForEach-Object ModuleName)})
+    $process.StandardInput.Write("`n"); $process.StandardInput.Flush()
+   }
+   if(!$process.WaitForExit(15000)) { throw 'Exit timeout' }
+   if($process.ExitCode) { throw "Probe failed: $($errors.Result)" }
+   $errors.Result | Set-Content (Join-Path $output "$run-$mode.txt")
+  } finally {
+   if(!$process.HasExited) { $process.Kill(); $process.WaitForExit() }
+   $process.Dispose()
+   $rows | ConvertTo-Json -Depth 5 | Set-Content (Join-Path $output 'results.json')
+  }
+  Write-Host "Completed $run/$Runs $mode"
+ }
+}
+$rows | Group-Object Mode,Phase | ForEach-Object {
+ [pscustomobject]@{Case=$_.Name;PrivateMiB=[math]::Round(($_.Group.PrivateBytes | Measure-Object -Average).Average/1MB,3);PrivateWorkingSetMiB=[math]::Round(($_.Group.PrivateWorkingSet | Measure-Object -Average).Average/1MB,3)}
+} | Format-Table

tools/memory-components.cpp

@@ -0,0 +1,65 @@
+// Standalone attribution probe. No clipboard, registry or user input mutations.
+#include <windows.h>
+#include <shlobj.h>
+#include <propkey.h>
+#include <propvarutil.h>
+#include <uiautomation.h>
+#include <cstdio>
+#include <cstring>
+#include <cstdlib>
+
+static void check(HRESULT hr) {
+    if (FAILED(hr)) { fprintf(stderr,"HRESULT=%08lx\n",(unsigned long)hr); exit(2); }
+}
+static void phase(const char *name) {
+    printf("%s\n",name); fflush(stdout);
+    if (getchar()==EOF) exit(3);
+}
+int main(int argc,char **argv) {
+    const char *mode=argc>1?argv[1]:"baseline";
+    const bool baseline=!strcmp(mode,"baseline");
+    const bool shell=!strcmp(mode,"shell") || !strcmp(mode,"combined");
+    const bool uia=!strcmp(mode,"uia") || !strcmp(mode,"focused") || !strcmp(mode,"combined");
+    phase("baseline");
+    if(!baseline) check(CoInitializeEx(nullptr,!strcmp(mode,"sta") || shell ? COINIT_APARTMENTTHREADED : COINIT_MULTITHREADED));
+    phase("com");
+    IShellLinkW *link{}; IPropertyStore *store{}; IPersistFile *file{};
+    IUIAutomation2 *automation{}; IUIAutomationElement *element{}; IUIAutomationTextPattern *pattern{};
+    wchar_t temporary[MAX_PATH]{},shortcut[MAX_PATH]{},exe[MAX_PATH]{};
+    if(shell) {
+        check(CoCreateInstance(CLSID_ShellLink,nullptr,CLSCTX_INPROC_SERVER,IID_PPV_ARGS(&link)));
+        GetModuleFileNameW(nullptr,exe,MAX_PATH);
+        check(link->SetPath(exe)); check(link->SetIconLocation(exe,0));
+        check(link->QueryInterface(IID_PPV_ARGS(&store)));
+        PROPVARIANT value{}; check(InitPropVariantFromString(L"KSwitcher.MemoryProbe",&value));
+        check(store->SetValue(PKEY_AppUserModel_ID,value)); PropVariantClear(&value);
+        GUID id{0xe3f78047,0xf0ad,0x49b6,{0x90,0x74,0x41,0x19,0x31,0x70,0x61,0x67}};
+        value.vt=VT_CLSID; value.puuid=&id;
+        check(store->SetValue(PKEY_AppUserModel_ToastActivatorCLSID,value)); check(store->Commit());
+        PWSTR programs{}; check(SHGetKnownFolderPath(FOLDERID_Programs,0,nullptr,&programs)); CoTaskMemFree(programs);
+        GetTempPathW(MAX_PATH,temporary); if(!GetTempFileNameW(temporary,L"ksm",0,shortcut)) return 4;
+        check(link->QueryInterface(IID_PPV_ARGS(&file))); check(file->Save(shortcut,TRUE));
+    }
+    if(uia) {
+        check(CoCreateInstance(CLSID_CUIAutomation8,nullptr,CLSCTX_INPROC_SERVER,IID_PPV_ARGS(&automation)));
+        check(automation->put_ConnectionTimeout(200)); check(automation->put_TransactionTimeout(200));
+        if(strcmp(mode,"uia")) {
+            HRESULT focused=automation->GetFocusedElement(&element);
+            fprintf(stderr,"focus=%08lx\n",(unsigned long)focused);
+            if(SUCCEEDED(focused) && element) {
+                BOOL password=TRUE,enabled=FALSE; CONTROLTYPEID type{};
+                element->get_CurrentIsPassword(&password); element->get_CurrentIsEnabled(&enabled); element->get_CurrentControlType(&type);
+                fprintf(stderr,"type=%d enabled=%d protected=%d\n",type,enabled,password);
+                if(!password) fprintf(stderr,"pattern=%08lx\n",(unsigned long)element->GetCurrentPatternAs(UIA_TextPatternId,IID_PPV_ARGS(&pattern)));
+            }
+        }
+    }
+    phase("active");
+    if(pattern) pattern->Release(); if(element) element->Release(); if(automation) automation->Release();
+    if(file) file->Release(); if(store) store->Release(); if(link) link->Release();
+    if(shortcut[0]) DeleteFileW(shortcut);
+    phase("released");
+    if(!baseline) { CoFreeUnusedLibrariesEx(0,0); CoUninitialize(); }
+    phase("uninitialized");
+    return 0;
+}