Release v0.6.10: preserve typing during correction and add personal dictionaries

Release v0.6.9: notify about updates and fix Settings scroll flicker
Release v0.6.8: add background image OCR and optional Tesseract
2026-10-29 22:44:08 +02:00 · 2026-10-29 22:15:30 +02:00 · 2026-10-29 21:40:29 +02:00
31 changed files with 1115 additions and 83 deletions
@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.24)
-project(KSwitcher VERSION 0.6.1 LANGUAGES CXX RC)
+project(KSwitcher VERSION 0.6.10 LANGUAGES CXX RC)
 if(NOT WIN32)
  message(FATAL_ERROR "KSwitcher uses native Windows APIs")
 endif()
@@ -9,7 +9,7 @@ add_library(kscore src/core.cpp src/platform.cpp src/autostart.cpp src/autocorre
 target_include_directories(kscore PUBLIC src PRIVATE vendor)
 target_compile_definitions(kscore PUBLIC UNICODE _UNICODE WIN32_LEAN_AND_MEAN NOMINMAX _WIN32_WINNT=0x0A00)
 target_link_libraries(kscore PUBLIC user32 shell32 shlwapi advapi32 crypt32 imm32 comctl32 gdi32 ole32 oleaut32 taskschd comdlg32 uuid windowscodecs runtimeobject uiautomationcore)
-add_executable(KSwitcher WIN32 src/main.cpp src/app.cpp src/screenshot_launcher.cpp src/screenshot_activation.cpp src/configuration.cpp src/ui.cpp resources/app.rc)
+add_executable(KSwitcher WIN32 src/main.cpp src/app.cpp src/screenshot_notifications.cpp src/screenshot_launcher.cpp src/screenshot_activation.cpp src/configuration.cpp src/ui.cpp resources/app.rc)
 target_compile_definitions(KSwitcher PRIVATE KS_RESIDENT_APP)
 target_link_libraries(KSwitcher PRIVATE kscore)
 add_executable(KSwitcherConfig WIN32 src/config_main.cpp src/configuration.cpp src/ui.cpp resources/app.rc)
@@ -18,9 +18,9 @@ target_compile_definitions(KSwitcherConfig PRIVATE KS_CONFIG_APP)
 target_link_libraries(KSwitcherConfig PRIVATE kscore)
 add_executable(KSwitcherTests tests/tests.cpp)
 target_link_libraries(KSwitcherTests PRIVATE kscore)
-add_executable(KSwitcherIntegration tests/integration.cpp src/screenshot_launcher.cpp src/screenshot_activation.cpp src/app.cpp src/screenshot.cpp src/configuration.cpp src/ui.cpp resources/app.rc)
+add_executable(KSwitcherIntegration tests/integration.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(KSwitcherIntegration PRIVATE kscore)
-add_executable(KSwitcherInputTests tests/input.cpp src/screenshot_launcher.cpp src/screenshot_activation.cpp src/app.cpp src/screenshot.cpp src/configuration.cpp src/ui.cpp resources/app.rc)
+add_executable(KSwitcherInputTests tests/input.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(KSwitcherInputTests PRIVATE kscore)
 target_compile_definitions(KSwitcherInputTests PRIVATE KS_SCREENSHOT_RESOURCES)
 add_executable(KSwitcherScreenshotUITests tests/screenshot_ui.cpp resources/app.rc)
@@ -36,7 +36,7 @@ if(MSVC)
 else()
  target_link_options(KSwitcherScreenshotUITests PRIVATE -static -static-libgcc -static-libstdc++)
 endif()
-add_executable(KSwitcherOcrTests tests/ocr.cpp)
+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)
 if(MSVC)
  set_property(TARGET kscore KSwitcher KSwitcherConfig KSwitcherScreenshot KSwitcherTests KSwitcherIntegration KSwitcherInputTests KSwitcherOcrTests PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
@@ -90,7 +90,7 @@ broker can load them even when the profile directory is inaccessible to it.
 Notifications expire after 24 hours. Cache cleanup runs on capture/open; each cache is bounded to
 40 files and 256 MiB. Expired or evicted notifications cannot reopen their screenshot.
 In the editor, **Ctrl+C** or **Enter** copies the current result without closing the window.
-The editor starts with **Pointer (V)**: select objects, move them, and edit geometry, thickness and
+The editor starts with **Pencil / Freehand (F)** for drawing. Choose **Pointer (V)** to select objects, move them, and edit geometry, thickness and
 other properties using handles and controls. Clicking empty space clears selection; dragging empty
 space adds nothing. Choose a drawing tool to create objects, then return to **V** to edit them.
 The cursor identifies the active tool: pointer, text caret, pencil, or a crosshair with the drawing
@@ -178,6 +178,11 @@ Select **Update** in the tray menu to check the stable Releases of
 [this repository](https://gitea.hrynco.com/hrynco/hrynco-kswitcher/releases).
 A background check runs shortly after startup and every 6 hours while KSwitcher is running.
 It reports each available version once per session and never installs automatically.
+Update availability uses the same Windows toast notification channel as screenshot notifications.
+Click the notification or **Review update** to check the latest release and confirm installation;
+**Later** dismisses it. Windows Do Not Disturb may send it directly to Notification Center.
+Failed notification submissions are logged and retried after five minutes instead of being marked
+as delivered. Check results and successful submissions are recorded in the log when logging is enabled.
 Network failures stay in diagnostics; the next scheduled check retries. You can also check manually at any time.
 Confirm the offered version to download and install it. The updater uses the existing
 `KSwitcher-win-x64.zip` and `SHA256SUMS.txt` assets, checks the checksum, package contents, x64
@@ -223,8 +228,24 @@ thumbnails and source labels aligned with the scaled fonts and spacing.
  stylesheet rules are not reproduced; preview text uses the list's colors for readability.
 - Consecutive screenshot copies are compared by image content, ignoring changing OLE transport
  metadata (including Snipping Tool's repeated clipboard publication).
- Windows OCR, entirely native and offline. Right-click an image in history and select
-  **Copy text from image**. Requires a Windows OCR language installed for the user profile.
+- New images are recognized automatically in a separate background worker using native, offline
+  Windows OCR. Recognized text is saved in a per-user DPAPI-encrypted sidecar and included in search,
+  without changing the image or clipboard. Completed results (including empty text) are reused;
+  pending work resumes after restart. Older images without OCR are processed once in the background,
+  starting with the newest entries.
+  Right-click an image and select **Copy text from image** to copy the saved text or explicitly
+  retry recognition. Requires a Windows OCR language installed for the user profile; automatic
+  failures are logged quietly. OCR sidecars count toward the history size limit and are removed
+  with their images.
+- Optional Tesseract 5 support is available in **Settings → OCR options…**. Windows OCR remains
+  the default and has no Tesseract dependency. Install the 64-bit Tesseract 5 Windows package
+  separately, then enable it and choose language codes such as `ukr+eng+rus`. Leave the executable
+  path blank to detect a standard installation, or select `tesseract.exe`; its neighboring
+  `libtesseract-5.dll`, dependencies and `tessdata` language files are required. **Check installation**
+  validates the selected models. **Download Tesseract…** opens the Windows installer page in your
+  browser. No packages or models are downloaded automatically.
+  Tesseract processes screenshots locally in memory with a 30-second recognition deadline.
+  Changing engine, executable path or languages refreshes cached image text in the background.
 - History exclusion flags and excluded processes, pause/resume, count/size limits.
 - Per-user Windows DPAPI encryption for both history payloads and the preview index.
 - Autostart, keep-screen-awake, idle-only F15 activity signal, settings import/export.
@@ -322,14 +343,23 @@ after Space, not immediately after a punctuation key. Save Settings to apply cha
 **Frequency rank limit** defaults to **0 (entire dictionary)**. A positive value allows corrections
 only to words with a rank at or below that number (for example, 10000). All dictionary words still
 protect already valid input, and ambiguous alternatives remain unchanged regardless of this limit.
+**My dictionary** provides separate English, Ukrainian and Russian fields for correct words missing
+from the bundled dictionaries. Enter words separated by commas or new lines, then click OK and Save
+in Settings. Case and duplicates are normalized automatically; no file editing or ranks are needed.
+These entries are stored in settings and survive dictionary updates. They protect correct input and
+are eligible as correction targets at any frequency limit. The language and target layout must still
+be enabled. **Never correct these words** is a separate exception list and takes precedence.
 **Open dictionary folder** opens the files beside the running executable. After editing, click OK
 in the options window and Save in Settings to validate and reload the dictionaries without restarting.
-Use UTF-8, one lowercase word followed by a Tab and a positive rank per line; keep words sorted and
-unique. For a personal addition, rank 1 makes it eligible at every positive limit. Back up your edited
+Use UTF-8, one lowercase word followed by a Tab and a positive rank per line. Entries can be appended;
+loading sorts them and merges duplicates using the lowest rank. Back up your edited
 files before replacing dictionaries with a new distribution.

 After Space and a 250 ms typing pause, KSwitcher checks the last physically typed word against local
-dictionaries. For example, `ghbdsn ` can become `привіт `. Continuing to type cancels pending work.
+dictionaries. For example, `ghbdsn ` can become `привіт `. Continuing to type before selection cancels
+pending work. During the replacement itself, key presses and releases are queued and replayed after
+clipboard restoration and layout switching, preserving typing order, modifiers and Backspace.
+If the active window changes, queued typing is not sent to another window and a warning is shown.
 It only corrects unknown words when exactly one alternative is a dictionary word.
 **Minimum word length** defaults to 3 and can be set from 1 to 32 letters. Surrounding punctuation
 does not count toward this minimum; the maximum word length is 32 letters.
@@ -1,30 +1,25 @@
 # Latest Windows release

-## v0.6.7 — 2026-10-29
+## v0.6.10 — 2026-10-29

 ## Changes
- Show a distinct cursor for each screenshot editor tool: pointer, text caret, pencil, and crosshairs with symbols for numbers, arrows, straight lines, rectangles, circles, ellipses and highlights.
- Preserve action cursor priority for moving, resizing, changing thickness and rotating objects.
- Scale custom cursors with display DPI and add contrasting outlines for light and dark backgrounds. Tool changes refresh the cursor immediately.
+- Preserve typing during automatic layout correction: queue key presses and releases until replacement, clipboard restoration and layout switching finish. Preserve modifiers and Backspace; collapse temporary selection before replay when a correction is rejected.
+- Add My dictionary fields for English, Ukrainian and Russian in Auto-correction options. Enter correct words separated by commas or new lines; save them with settings without editing dictionary files, sorting entries or assigning ranks.
+- Accept unsorted dictionary files and duplicate entries, retaining the lowest rank for duplicates. Include Ukrainian `реліз` in the bundled vocabulary so `релыз` can be corrected when Russian and Ukrainian are enabled.

 ## Validation
-176 native checks, 440 input/layout checks at 240 DPI, screenshot editor UI integration, isolated notification registration, and 45 updater checks. Cursor coverage verifies tool selection, action overrides, hotspots and masks at 32/48/64/96 pixels. Cursor previews were visually checked on light and dark backgrounds.
+Native regression checks cover personal words, settings persistence, language validation, dictionary ordering and duplicate ranks. Input/UI checks cover personal-word entry and normalization. Native editor integration covers typing with Shift and Backspace during successful and rejected corrections. Release checks also cover screenshot UI, isolated notification registration and updater validation.

-**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 and extract the entire ZIP into its installation folder.
-Keep personal `data/` and customized dictionaries.
+**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 and extract the entire ZIP into its installation folder. Keep personal `data/` and customized dictionaries. Existing customized dictionary files may be preserved by the updater; use My dictionary to add missing words without replacing those files.

-Download **KSwitcher-win-x64.zip** with **SHA256SUMS.txt**. The package contains the resident,
-configurator and screenshot executables, a release manifest, offline dictionaries, documentation
-and license notices; no personal settings or clipboard history.
+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, clipboard history, Tesseract installation or language models.

 Build and package:

 ```powershell
-.\build.ps1 -Stage -Test
+.\build.ps1 -Stage -Test -Integration
 .\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.
+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.
@@ -1 +1 @@
-3c5fd91f163e54440fb144b5ef7c301695eb9d8df36dea6f807521b9c171a489  KSwitcher-win-x64.zip
+36966eb0b2b0af47c245aec6337a16703e0fbdca4d3eda7a8f25fa14a20f347e  KSwitcher-win-x64.zip
@@ -27,7 +27,7 @@ try {
    & windres --codepage=65001 -DKS_SCREENSHOT_RESOURCES resources/app.rc -O coff -o build/screenshot-res.o
    if ($LASTEXITCODE) { throw 'Screenshot resource compilation failed' }
    New-Item -ItemType Directory -Force build/release | Out-Null
-    & $compiler -mwindows -municode -static -s '-Wl,--gc-sections' build/core.o build/platform.o build/autostart.o build/autocorrect.o build/storage.o build/ocr.o build/richtext.o build/update.o build/screenshot_launcher.o build/screenshot_activation.o build/app.o build/configuration.o build/ui-resident.o build/main.o build/app-res.o @libs -o $executablePath
+    & $compiler -mwindows -municode -static -s '-Wl,--gc-sections' build/core.o build/platform.o build/autostart.o build/autocorrect.o build/storage.o build/ocr.o build/richtext.o build/update.o build/screenshot_launcher.o build/screenshot_activation.o build/screenshot_notifications.o build/app.o build/configuration.o build/ui-resident.o build/main.o build/app-res.o @libs -o $executablePath
    if ($LASTEXITCODE) { throw 'Link failed' }
    Copy-Item -LiteralPath $executablePath -Destination build/release/KSwitcher.exe -Force
    $configPath = Join-Path (Split-Path $executablePath) 'KSwitcher.Config.exe'
@@ -43,7 +43,7 @@ try {
        if ($LASTEXITCODE) { throw 'Test build failed' }
        & .\build\KSwitcherTests.exe
        if ($LASTEXITCODE) { throw 'Tests failed' }
-        & $compiler @common tests/input.cpp build/core.o build/platform.o build/autostart.o build/autocorrect.o build/storage.o build/ocr.o build/richtext.o build/update.o build/screenshot.o build/screenshot_launcher.o build/screenshot_activation.o build/app.o build/configuration.o build/ui.o build/screenshot-res.o @libs -static -s -o build/KSwitcherInputTests.exe
+        & $compiler @common tests/input.cpp build/core.o build/platform.o build/autostart.o build/autocorrect.o build/storage.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/KSwitcherInputTests.exe
        if ($LASTEXITCODE) { throw 'Input test build failed' }
        & .\build\KSwitcherInputTests.exe
        if ($LASTEXITCODE) { throw 'Input tests failed' }
@@ -63,13 +63,13 @@ try {
        if ($LASTEXITCODE) { throw 'Updater tests failed' }
    }
    if ($Integration) {
-        & $compiler @common tests/integration.cpp build/core.o build/platform.o build/autostart.o build/autocorrect.o build/storage.o build/ocr.o build/richtext.o build/update.o build/screenshot.o build/screenshot_launcher.o build/screenshot_activation.o build/app.o build/configuration.o build/ui.o build/screenshot-res.o @libs -static -s -o build/KSwitcherIntegration.exe
+        & $compiler @common tests/integration.cpp build/core.o build/platform.o build/autostart.o build/autocorrect.o build/storage.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/ocr.o @libs -static -s -o build/KSwitcherOcrTests.exe
+        & $compiler @common tests/ocr.cpp build/core.o build/platform.o build/autostart.o build/autocorrect.o build/storage.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
        if ($LASTEXITCODE) { throw 'OCR test build failed' }
        & .\build\KSwitcherOcrTests.exe
        if ($LASTEXITCODE) { throw 'OCR tests failed' }
@@ -17,9 +17,19 @@ replace counts with original frequency ranks, sort lexically. Reproduce with
 hashes. The lists contain word forms from subtitles, not a complete spelling
 or grammar dictionary. Recognition can miss names, jargon and uncommon forms.

-File format: UTF-8 word, TAB, positive original frequency rank, newline.
+Supplemental Ukrainian vocabulary: `реліз`. These additions use rank 50001,
+after the upstream 50k list, rather than claiming a measured corpus frequency.
+They are included with the default unlimited rank setting and recorded in sources.json.
+
+File format: UTF-8 word, TAB, positive frequency rank (or supplemental rank), newline.
 All entries protect known words. The frequency rank limit in Auto-correction options defaults to 0
 (entire dictionary); a positive limit only permits correction candidates at or below that rank.
-Personal words may use rank 1. Keep entries lowercase, unique and sorted, with a Tab separator.
+Prefer Settings > Auto-correction options > My dictionary for personal words.
+Enter correct spellings in the matching language field, separated by commas or new lines.
+These words are stored in settings, survive dictionary updates, and need no ranks or sorting.
+Click OK, then Save in Settings to apply them.
+
+For advanced file edits, personal words may use rank 1. Keep entries lowercase with a Tab separator.
+Words may be appended: loading sorts entries and merges duplicates using the lowest rank.
 Save the UTF-8 file, then click OK in Auto-correction options and Save in Settings to reload it.
 Back up edited files before replacing dictionaries with a new distribution.
@@ -9,9 +9,12 @@
  "uk": {
    "source": "https://raw.githubusercontent.com/hermitdave/FrequencyWords/525f9b560de45753a5ea01069454e72e9aa541c6/content/2016/uk/uk_50k.txt",
    "sourceSha256": "9548b79a608d33f39c5546037a69117d679730b1fda08dd0ce67c043dbf3335a",
-    "words": 42549,
-    "bytes": 898210,
-    "sha256": "b4104898dcccbc1331ec01e9cd690e30285fe58481460e47438e973964d09802"
+    "words": 42550,
+    "bytes": 898227,
+    "sha256": "c94605e6be676d2d64f89a3bc16f92b9128f9977d226a97b103cf22a3e6835e3",
+    "supplementalWords": {
+      "\u0440\u0435\u043b\u0456\u0437": 50001
+    }
  },
  "ru": {
    "source": "https://raw.githubusercontent.com/hermitdave/FrequencyWords/525f9b560de45753a5ea01069454e72e9aa541c6/content/2016/ru/ru_50k.txt",
@@ -31207,6 +31207,7 @@
 релігію	26138
 релігія	22202
 релігії	23427
+реліз	50001
 рембо	28603
 ремень	23872
 ремені	28385
@@ -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,7,0
- PRODUCTVERSION 0,6,7,0
+ FILEVERSION 0,6,10,0
+ PRODUCTVERSION 0,6,10,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.7"
+   VALUE "FileVersion", "0.6.10"
  END
 END
 BLOCK "VarFileInfo"
@@ -233,6 +233,7 @@ class Transaction
 } // namespace
 App::App(HINSTANCE h, bool test, const std::filesystem::path &dataRoot) : instance(h), smoke(test)
 {
+    updateNotifier = notifyUpdateAvailable;
    current = this;
    data = dataRoot.empty() ? dataDirectory() : dataRoot;
    std::filesystem::create_directories(data);
@@ -269,8 +270,15 @@ App::~App()
        std::lock_guard lock(jobsMutex);
        stop = true;
        jobs.clear();
+        pendingHistorySearch = {};
    }
    jobsReady.notify_all();
+    historySearchReady.notify_all();
+    historyOcrReady.notify_all();
+    if (historyOcrWorker.joinable())
+        historyOcrWorker.join();
+    if (historySearchWorker.joinable())
+        historySearchWorker.join();
    if (worker.joinable())
        worker.join();
    RemoveClipboardFormatListener(window);
@@ -291,6 +299,83 @@ void App::enqueue(std::function<void()> job)
    }
    jobsReady.notify_one();
 }
+void App::enqueueHistorySearch(std::function<void()> job)
+{
+    {
+        std::lock_guard lock(jobsMutex);
+        if (stop) return;
+        // Only the latest query matters. Clipboard capture and OCR must not delay it.
+        pendingHistorySearch = std::move(job);
+        if (!historySearchWorker.joinable())
+            historySearchWorker = std::thread([this]
+            {
+                for (;;)
+                {
+                    std::function<void()> searchJob;
+                    {
+                        std::unique_lock lock(jobsMutex);
+                        historySearchReady.wait(lock, [&] { return stop || bool(pendingHistorySearch); });
+                        if (stop) return;
+                        searchJob = std::move(pendingHistorySearch);
+                        pendingHistorySearch = {};
+                    }
+                    try { searchJob(); }
+                    catch (const std::exception &e) { report(wide(e.what())); }
+                }
+            });
+    }
+    historySearchReady.notify_one();
+}
+void App::scheduleHistoryOcr(const Settings &config)
+{
+    {
+        std::lock_guard lock(jobsMutex);
+        if (stop || !history || !config.history) return;
+        historyOcrSettings = config;
+        historyOcrRequested = true;
+        if (!historyOcrWorker.joinable())
+            historyOcrWorker = std::thread([this]
+            {
+                for (;;)
+                {
+                    Settings config;
+                    {
+                        std::unique_lock lock(jobsMutex);
+                        historyOcrReady.wait(lock, [&] { return stop || historyOcrRequested; });
+                        if (stop) return;
+                        historyOcrRequested = false;
+                        config = historyOcrSettings;
+                    }
+                    for (const auto &entry : history->entries())
+                    {
+                        { std::lock_guard lock(jobsMutex); if (stop) return; }
+                        auto profile = ocrProfile(config);
+                        if (!entry.image || (entry.ocrState != 1 && entry.ocrProfile == profile)) continue;
+                        try
+                        {
+                            auto text = recognizeText(history->load(entry.id), config);
+                            std::lock_guard lock(jobsMutex);
+                            if (stop || ocrProfile(historyOcrSettings) != profile) continue;
+                            if (history->saveOcr(entry.id, text, config))
+                                PostMessageW(window, HistoryMessage, 0, 0);
+                        }
+                        catch (const std::exception &e)
+                        {
+                            // Automatic OCR never changes the clipboard or opens error dialogs.
+                            log(L"History OCR: " + wide(e.what()));
+                            try {
+                                std::lock_guard lock(jobsMutex);
+                                if (!stop && ocrProfile(historyOcrSettings) == profile)
+                                    history->saveOcr(entry.id, std::nullopt, config);
+                            }
+                            catch (const std::exception &saveError) { log(L"History OCR save: " + wide(saveError.what())); }
+                        }
+                    }
+                }
+            });
+    }
+    historyOcrReady.notify_one();
+}
 void App::report(const std::wstring &text)
 {
    log(text);
@@ -333,6 +418,7 @@ void App::applySettings(const Settings &s)
 {
    bool autostartChanged = false;
    validateSettings(s);
+    validateTesseract(s);
    if (s.autoCorrect)
    {
        AutoCorrector probe;
@@ -375,6 +461,7 @@ void App::applySettings(const Settings &s)
    }
    // Clear on the worker so the next check reloads edits to dictionary files.
    enqueue([this] { autoCorrector.configure({}, {}); });
+    scheduleHistoryOcr(s);
    SetThreadExecutionState(ES_CONTINUOUS |
                            (settings.awake ? (ES_DISPLAY_REQUIRED | ES_SYSTEM_REQUIRED) : 0));
 }
@@ -511,6 +598,27 @@ bool App::handleKeyboard(const KBDLLHOOKSTRUCT &key, bool down, UINT mods)
    // down AND up events use exactly the same path as physical keyboard input.
    if (ownKeyboardInput(key) || installingUpdate)
        return false;
+    {
+        std::lock_guard lock(stateMutex);
+        if (typingTarget && GetForegroundWindow() == typingTarget)
+        {
+            INPUT input{};
+            input.type = INPUT_KEYBOARD;
+            input.ki.wVk = static_cast<WORD>(key.vkCode);
+            input.ki.wScan = static_cast<WORD>(key.scanCode);
+            input.ki.dwFlags = (down ? 0 : KEYEVENTF_KEYUP) |
+                               ((key.flags & LLKHF_EXTENDED) ? KEYEVENTF_EXTENDEDKEY : 0);
+            if (key.vkCode == VK_PACKET)
+            {
+                input.ki.wVk = 0;
+                input.ki.dwFlags |= KEYEVENTF_UNICODE;
+            }
+            // Replay as ordinary input so tracking and shortcuts see it once,
+            // after the replacement and layout switch have finished.
+            deferredTyping.push_back(input);
+            return true;
+        }
+    }
    DWORD captureProcess{};
    if (hotkeyCapture) GetWindowThreadProcessId(hotkeyCapture, &captureProcess);
    if (hotkeyCapture && (!captureProcess || captureProcess != hotkeyCaptureProcess))
@@ -553,6 +661,41 @@ bool App::handleKeyboard(const KBDLLHOOKSTRUCT &key, bool down, UINT mods)
        return true;
    return false;
 }
+bool App::beginTypingDeferral(HWND target, uint64_t version)
+{
+    std::lock_guard lock(stateMutex);
+    if (inputVersion != version || GetForegroundWindow() != target || !modifiersReleased())
+        return false;
+    typingTarget = target;
+    return true;
+}
+void App::replayTyping()
+{
+    std::vector<INPUT> inputs;
+    HWND target;
+    {
+        std::lock_guard lock(stateMutex);
+        target = typingTarget;
+        typingTarget = nullptr;
+        inputs.swap(deferredTyping);
+    }
+    busy = false;
+    if (inputs.empty())
+        return;
+    if (GetForegroundWindow() != target)
+    {
+        resetInput();
+        report(L"Typing during correction was not replayed because the active window changed.");
+        return;
+    }
+    // Runs on the hook thread: no physical key can pass between releasing the
+    // gate and submitting the entire ordered batch to the Windows input queue.
+    if (SendInput(static_cast<UINT>(inputs.size()), inputs.data(), sizeof(INPUT)) != inputs.size())
+    {
+        resetInput();
+        report(L"Windows could not replay all typing buffered during correction.");
+    }
+}
 LRESULT CALLBACK App::keyProc(int code, WPARAM wp, LPARAM lp)
 {
    if (code == HC_ACTION && current &&
@@ -588,6 +731,7 @@ void App::dispatch(int command)
        return;
    try
    {
+        if (command == 23) { checkUpdate(true); return; }
        if (command == Screenshot)
        {
            if (!busy) { resetInput(); launchScreenshot(*this); }
@@ -674,11 +818,16 @@ void App::transform(int command, int snippet)
            struct BusyReset
            {
                std::atomic<bool> &b;
+                HWND window;
+                bool deferred{};
                ~BusyReset()
                {
-                    b = false;
+                    if (deferred)
+                        PostMessageW(window, ReplayTypingMessage, 0, 0);
+                    else
+                        b = false;
                }
-            } reset{busy};
+            } reset{busy, window};
            auto start = GetTickCount64();
            std::wstring reason = L"cancelled-before-selection";
            std::wstring text, result, expected;
@@ -761,6 +910,21 @@ void App::transform(int command, int snippet)
                        return;
                }
                reason = L"clipboard-snapshot";
+                if (command == AutoCorrect)
+                {
+                    if (!beginTypingDeferral(target, version))
+                        return;
+                    reset.deferred = true;
+                }
+                // Collapse a temporary selection on every failed auto-correction,
+                // including clipboard exceptions, before queued typing is replayed.
+                bool autoSelected = false;
+                struct SelectionReset
+                {
+                    bool &selected;
+                    std::function<bool()> valid;
+                    ~SelectionReset() { if (selected && valid()) chord(VK_RIGHT); }
+                } selectionReset{autoSelected, valid};
                Transaction tx(*this, target, version);
                reason = L"selection-unavailable";
                diagnosticEvent(L"Transform target=" + processName(target) + L" command=" + std::to_wstring(command) +
@@ -777,6 +941,7 @@ void App::transform(int command, int snippet)
                    // conversion, automatic correction must never fall back to a suffix.
                    if (!tx.valid() || !chord(VK_LEFT, MOD_CONTROL | MOD_SHIFT))
                        return;
+                    autoSelected = true;
                    Sleep(25);
                    text = tx.copy();
                    // Some editors first select only ") ". Extend by whole-word
@@ -793,7 +958,10 @@ void App::transform(int command, int snippet)
                    if (!suggestion || !tx.valid() || !autoCorrectionAllowed(target, config))
                    {
                        if (tx.valid())
+                        {
                            chord(VK_RIGHT);
+                            autoSelected = false;
+                        }
                        return;
                    }
                    to = suggestion->target;
@@ -930,6 +1098,8 @@ void App::transform(int command, int snippet)
                    sent = tx.paste(textClip(result));
                else if (automatic && tx.valid())
                    chord(VK_RIGHT);
+                if (sent || result == text)
+                    autoSelected = false;
                reason = result == text ? L"conversion-unchanged" :
                         sent ? L"paste-sent-unverified" : L"paste-cancelled";
                if (result == text &&
@@ -1051,6 +1221,7 @@ void App::captureHistory()
                        !f.data[1] && !f.data[2] && !f.data[3])
                        return;
                history->add(clip, app, config);
+                scheduleHistoryOcr(config);
                PostMessageW(window, HistoryMessage, 0, 0);
            }
            catch (const std::exception &e)
@@ -1078,7 +1249,9 @@ void App::recognizeEntry(std::wstring id)
            } reset{busy};
            try
            {
-                auto text = recognizeText(history->load(id));
+                auto cached = history->ocrText(id, ocrProfile(config));
+                auto text = cached ? *cached : recognizeText(history->load(id), config);
+                if (!cached) history->saveOcr(id, text, config);
                if (text.empty())
                {
                    report(L"No text was found in the image.");
@@ -1239,6 +1412,8 @@ LRESULT CALLBACK App::windowProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
        if (app->updateWorker.joinable()) app->updateWorker.join();
        app->updateRunning = false;
        app->installingUpdate = false;
+        log(L"Update check: " + result->state + (result->version.empty() ? L"" : L" " + result->version) +
+            (result->error.empty() ? L"" : L"; " + result->error));
        if (result->state == L"prepared")
        {
            // The helper has verified and staged the package; it waits for process exit.
@@ -1256,13 +1431,16 @@ LRESULT CALLBACK App::windowProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
            }
            else if (app->notifiedUpdate != result->version)
            {
-                app->notifiedUpdate = result->version;
-                NOTIFYICONDATAW icon{sizeof(icon)};
-                icon.hWnd = hwnd; icon.uID = 1; icon.uFlags = NIF_INFO; icon.dwInfoFlags = NIIF_INFO;
-                wcscpy_s(icon.szInfoTitle, L"KSwitcher update available");
-                auto text = result->version + L" is available. Select Update in the tray menu to install.";
-                wcsncpy_s(icon.szInfo, text.c_str(), _TRUNCATE);
-                Shell_NotifyIconW(NIM_MODIFY, &icon);
+                if (app->updateNotifier(result->version))
+                {
+                    app->notifiedUpdate = result->version;
+                    log(L"Update notification submitted to Windows: " + result->version);
+                }
+                else
+                {
+                    log(L"Update notification failed; retrying in 5 minutes: " + result->version);
+                    SetTimer(hwnd, 5, UpdateNotificationRetryMs, nullptr);
+                }
            }
        }
        else if (result->state == L"current")
@@ -1281,6 +1459,9 @@ LRESULT CALLBACK App::windowProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
    case WM_HOTKEY:
        app->dispatch((int)wp);
        return 0;
+    case ReplayTypingMessage:
+        app->replayTyping();
+        return 0;
    case TrayMessage:
        if (LOWORD(lp) == WM_CONTEXTMENU)
            app->trayMenu();
@@ -1442,6 +1623,8 @@ int App::execute()
    if (!keyboardHook || !mouseHook)
        report(L"Input tracking could not start. Automatic recent-text conversion is unavailable.");
    AddClipboardFormatListener(window);
+    // Resume pending OCR, including older images without a saved OCR state.
+    scheduleHistoryOcr(settings);
    addTray();
    SetTimer(window, 1, 60000, nullptr);
    SetThreadExecutionState(ES_CONTINUOUS |
@@ -16,6 +16,7 @@ inline constexpr UINT TrayMessage = WM_APP + 1, ErrorMessage = WM_APP + 2, Histo
 inline constexpr int Toggle = 1, Case = 2, Translit = 3, Undo = 4, ShowHistory = 5, AutoCorrect = 6,
                     Screenshot = 7, Direct = 100;
 inline constexpr UINT AutoCorrectMessage = WM_APP + 6;
+inline constexpr UINT ReplayTypingMessage = WM_APP + 30;
 inline constexpr UINT CaptureHotkeyMessage = WM_APP + 5;
 struct LastTransform
 {
@@ -61,6 +62,7 @@ class App
    void recognizeEntry(std::wstring);
    void captureHistory();
    void enqueue(std::function<void()>);
+    void enqueueHistorySearch(std::function<void()>);
    void report(const std::wstring &);
    void trayMenu();
    void addTray();
@@ -83,9 +85,18 @@ class App
    std::condition_variable jobsReady;
    std::deque<std::function<void()>> jobs;
    std::thread worker;
+    std::thread historySearchWorker;
+    std::condition_variable historySearchReady;
+    std::function<void()> pendingHistorySearch;
+    std::thread historyOcrWorker;
+    std::condition_variable historyOcrReady;
+    bool historyOcrRequested{};
+    Settings historyOcrSettings;
+    void scheduleHistoryOcr(const Settings &);
    std::thread updateWorker;
    bool updateRunning{}, installingUpdate{};
    std::wstring availableUpdate, notifiedUpdate;
+    bool (*updateNotifier)(const std::wstring &){};
    bool stop{};
    UINT taskbarCreated{};
    uint64_t pendingAutoVersion{};
@@ -95,6 +106,10 @@ class App
    int previousAttemptCommand{}, repeatAttempts{};
    std::vector<std::pair<int, Hotkey>> hookBindings;
    HotkeyHook hotkeyHook;
+    HWND typingTarget{};
+    std::vector<INPUT> deferredTyping;
+    bool beginTypingDeferral(HWND, uint64_t);
+    void replayTyping();
    static LRESULT CALLBACK windowProc(HWND, UINT, WPARAM, LPARAM);
    static LRESULT CALLBACK keyProc(int, WPARAM, LPARAM);
    static LRESULT CALLBACK mouseProc(int, WPARAM, LPARAM);
@@ -70,9 +70,18 @@ AutoCorrector::Dictionary::Dictionary(const std::filesystem::path &path)
    }
    if (offsets.empty())
        throw std::runtime_error("Empty auto-correction dictionary");
-    for (size_t i = 1; i < offsets.size(); ++i)
-        if (word(i - 1) >= word(i))
-            throw std::runtime_error("Dictionary must be uniquely sorted");
+    auto entry = [&](uint32_t offset) { return std::string_view(bytes).substr(offset, bytes.find('\t', offset) - 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);
+        return rank;
+    };
+    std::sort(offsets.begin(), offsets.end(), [&](uint32_t a, uint32_t 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());
    offsets.shrink_to_fit();
    bytes.shrink_to_fit();
 }
@@ -151,9 +160,16 @@ std::optional<AutoSuggestion> AutoCorrector::suggest(const std::wstring &typed,
    auto sourceLanguage = layoutLanguage(layouts[source]);
    if (!dictionaries.contains(sourceLanguage))
        return {};
+    auto personal = [&](const std::wstring &language, const std::wstring &candidate)
+    {
+        auto found = settings.autoWords.find(language);
+        return found != settings.autoWords.end() &&
+            std::any_of(found->second.begin(), found->second.end(), [&](const std::wstring &known)
+                        { return lower(known) == lower(candidate); });
+    };
    // Valid words from either selected language are never changed.
    for (auto &[language, d] : dictionaries)
-        if (d.rank(word))
+        if (d.rank(word) || personal(language, word))
            return {};
    std::optional<AutoSuggestion> candidate;
    int matches = 0;
@@ -168,7 +184,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 = dictionary->second.rank(converted);
+        int rank = personal(dictionary->first, converted) ? 1 : dictionary->second.rank(converted);
        if (!rank)
            continue;
        if (++matches > 1)
@@ -1,6 +1,7 @@
 #pragma once
 #include <cstdint>
 #include <functional>
+#include <map>
 #include <optional>
 #include <string>
 #include <vector>
@@ -49,12 +50,16 @@ struct Settings
    bool autoCorrect = false;
    bool writeLog = true;
    bool screenshotAutoOpenEditor = false;
+    bool useTesseract = false;
+    std::wstring tesseractPath;
+    std::wstring tesseractLanguages = L"ukr+eng+rus";
    int autoMaxRank = 0;
    int autoMinLength = 3;
    std::wstring autoPrefixChars = L"([{«“‘\"";
    std::wstring autoSuffixChars = L")]}»”’\".,!?:;";
    std::vector<std::wstring> autoLanguages{L"en", L"uk"};
    std::vector<std::wstring> autoNever;
+    std::map<std::wstring, std::vector<std::wstring>> autoWords;
    std::vector<std::wstring> autoExcluded{
        L"Code", L"rider64",  L"devenv", L"WindowsTerminal", L"cmd",       L"powershell", L"pwsh",
        L"Far",  L"ConEmu64", L"putty",  L"KeePass",         L"KeePassXC", L"1Password",  L"Bitwarden"};
@@ -45,12 +45,15 @@ int WINAPI wWinMain(HINSTANCE instance, HINSTANCE, PWSTR, int)
        cmd = 21;
    else if (arg == L"--exit")
        cmd = 99;
+    else if (arg == L"--check-update")
+        cmd = 23;
    LocalFree(argv);
    if (existing)
    {
        HWND window = FindWindowW(L"KSwitcher.Main", L"KSwitcher");
        if (window)
        {
+            if (cmd == 23) { DWORD pid{}; GetWindowThreadProcessId(window, &pid); AllowSetForegroundWindow(pid); }
            COPYDATASTRUCT data{1, sizeof(cmd), &cmd};
            DWORD_PTR result{};
            SendMessageTimeoutW(window, WM_COPYDATA, 0, (LPARAM)&data, SMTO_ABORTIFHUNG, 1000, &result);
@@ -271,4 +271,119 @@ std::wstring recognizeText(const Clip &clip)
    WindowsDeleteString(text);
    return out;
 }
+std::filesystem::path tesseractExecutable(const Settings &s)
+{
+    if (!s.tesseractPath.empty())
+    {
+        std::filesystem::path path(s.tesseractPath);
+        if (!path.is_absolute()) throw std::runtime_error("Select an absolute path to tesseract.exe");
+        return path;
+    }
+    for (auto variable : {L"ProgramW6432", L"ProgramFiles", L"LOCALAPPDATA"})
+    {
+        wchar_t base[32768]{};
+        auto length = GetEnvironmentVariableW(variable, base, std::size(base));
+        if (!length || length >= std::size(base)) continue;
+        auto root = std::filesystem::path(base);
+        for (auto relative : {L"Tesseract-OCR/tesseract.exe", L"Programs/Tesseract-OCR/tesseract.exe"})
+            if (std::filesystem::is_regular_file(root / relative)) return root / relative;
+    }
+    throw std::runtime_error("Tesseract was not found. Install the optional 64-bit Tesseract 5 package or select tesseract.exe in OCR options.");
+}
+std::wstring ocrProfile(const Settings &s)
+{
+    return s.useTesseract ? L"tesseract:" + lower(s.tesseractPath) + L":" + s.tesseractLanguages : L"windows";
+}
+namespace
+{
+struct TessLibrary
+{
+    HMODULE module{};
+    explicit TessLibrary(const Settings &s)
+    {
+        auto exe = tesseractExecutable(s);
+        if (!std::filesystem::is_regular_file(exe)) throw std::runtime_error("Tesseract executable does not exist");
+        auto library = exe.parent_path() / L"libtesseract-5.dll";
+        module = LoadLibraryExW(library.c_str(), nullptr,
+                               LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR | LOAD_LIBRARY_SEARCH_DEFAULT_DIRS);
+        if (!module) throw std::runtime_error("Cannot load Tesseract 5. Select a complete 64-bit installation with libtesseract-5.dll and its dependencies.");
+    }
+    ~TessLibrary() { if (module) FreeLibrary(module); }
+    template<class T> T symbol(const char *name)
+    {
+        auto address = GetProcAddress(module, name);
+        if (!address) throw std::runtime_error(std::string("Unsupported Tesseract library: missing ") + name);
+        T result; static_assert(sizeof(result) == sizeof(address));
+        memcpy(&result, &address, sizeof(result));
+        return result;
+    }
+};
+struct TessEngine
+{
+    TessLibrary library;
+    void *handle{};
+    void (*destroy)(void *){};
+    explicit TessEngine(const Settings &s) : library(s)
+    {
+        auto folder = tesseractExecutable(s).parent_path() / L"tessdata";
+        size_t start = 0;
+        do
+        {
+            auto end = s.tesseractLanguages.find(L'+', start);
+            auto language = s.tesseractLanguages.substr(start, end == std::wstring::npos ? end : end - start);
+            if (!std::filesystem::is_regular_file(folder / (language + L".traineddata")))
+                throw std::runtime_error("Tesseract language is not installed: " + utf8(language));
+            if (end == std::wstring::npos) break;
+            start = end + 1;
+        } while (true);
+        auto create = library.symbol<void *(*)()>("TessBaseAPICreate");
+        destroy = library.symbol<void (*)(void *)>("TessBaseAPIDelete");
+        auto init = library.symbol<int (*)(void *, const char *, const char *)>("TessBaseAPIInit3");
+        handle = create();
+        if (!handle) throw std::runtime_error("Cannot create Tesseract engine");
+        if (init(handle, utf8(folder.wstring()).c_str(), utf8(s.tesseractLanguages).c_str()) != 0)
+        {
+            destroy(handle); handle = nullptr;
+            throw std::runtime_error("Cannot initialize the selected Tesseract languages");
+        }
+    }
+    ~TessEngine() { if (handle) destroy(handle); }
+};
+}
+void validateTesseract(const Settings &s)
+{
+    if (s.useTesseract) { TessEngine engine(s); }
+}
+std::wstring recognizeText(const Clip &clip, const Settings &s)
+{
+    if (!s.useTesseract) return recognizeText(clip);
+    auto apartmentResult = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
+    if (FAILED(apartmentResult) && apartmentResult != RPC_E_CHANGED_MODE) check(apartmentResult);
+    struct Apartment { bool owned; ~Apartment() { if (owned) CoUninitialize(); } } apartment{SUCCEEDED(apartmentResult)};
+    // Load the optional C API dynamically: Windows OCR users need no Tesseract DLLs.
+    TessEngine engine(s);
+    auto &lib = engine.library;
+    auto image = lib.symbol<void (*)(void *, const unsigned char *, int, int, int, int)>("TessBaseAPISetImage");
+    auto mode = lib.symbol<void (*)(void *, int)>("TessBaseAPISetPageSegMode");
+    auto recognize = lib.symbol<int (*)(void *, void *)>("TessBaseAPIRecognize");
+    auto getText = lib.symbol<char *(*)(void *)>("TessBaseAPIGetUTF8Text");
+    auto freeText = lib.symbol<void (*)(const char *)>("TessDeleteText");
+    auto createMonitor = lib.symbol<void *(*)()>("TessMonitorCreate");
+    auto freeMonitor = lib.symbol<void (*)(void *)>("TessMonitorDelete");
+    auto deadline = lib.symbol<void (*)(void *, int)>("TessMonitorSetDeadlineMSecs");
+    std::unique_ptr<void, void (*)(void *)> monitor(createMonitor(), freeMonitor);
+    if (!monitor) throw std::runtime_error("Cannot create Tesseract progress monitor");
+    auto pixels = decodeImage(clip);
+    Bytes gray(size_t(pixels.width) * pixels.height);
+    for (size_t i = 0; i < gray.size(); ++i)
+        gray[i] = BYTE((29 * pixels.bgra[4*i] + 150 * pixels.bgra[4*i+1] + 77 * pixels.bgra[4*i+2]) >> 8);
+    image(engine.handle, gray.data(), pixels.width, pixels.height, 1, pixels.width);
+    mode(engine.handle, 11); // Sparse text: screenshots often contain separate labels and paragraphs.
+    deadline(monitor.get(), 30000);
+    if (recognize(engine.handle, monitor.get()) != 0)
+        throw std::runtime_error("Tesseract recognition failed or exceeded 30 seconds");
+    std::unique_ptr<char, void (*)(const char *)> text(getText(engine.handle), freeText);
+    if (!text) throw std::runtime_error("Tesseract returned no result");
+    return wide(text.get());
+}
 } // namespace ks
@@ -10,4 +10,8 @@ struct Pixels
 Pixels decodeImage(const Clip &, UINT maxWidth = 0, UINT maxHeight = 0);
 Format imageDib(const Pixels &);
 std::wstring recognizeText(const Clip &);
+std::wstring recognizeText(const Clip &, const Settings &);
+std::filesystem::path tesseractExecutable(const Settings &);
+void validateTesseract(const Settings &);
+std::wstring ocrProfile(const Settings &);
 } // namespace ks
@@ -169,7 +169,7 @@ struct Capture
    bool editing{}, dragging{}, arrow{}, owned{}, copied{};
    bool autoOpenEditor;
    bool highlight{};
-    bool pointer=true, freehand=false;
+    bool pointer=false, freehand=true;
    bool straight{}, textTool{};
    Mark textDefaults{};
    ScreenshotShape shape=ScreenshotShape::None;
@@ -83,8 +83,12 @@ public:
    ULONG STDMETHODCALLTYPE AddRef() override { return ++references; }
    ULONG STDMETHODCALLTYPE Release() override { auto count=--references; if(!count) delete this; return count; }
    HRESULT STDMETHODCALLTYPE Activate(LPCWSTR app,LPCWSTR args,const NotificationInput *,ULONG) override {
-        if(!app || std::wstring(app)!=AppId || !args || !validScreenshotToken(args)) return E_INVALIDARG;
-        auto path=target; auto command=L"\""+path+L"\" --open \"kswitcher-screenshot:"+args+L"\"";
+        if(!app || std::wstring(app)!=AppId || !args) return E_INVALIDARG;
+        const bool update=std::wstring(args)==L"check-update";
+        if(!update && !validScreenshotToken(args)) return E_INVALIDARG;
+        auto path=update ? (std::filesystem::path(target).parent_path()/L"KSwitcher.exe").wstring() : target;
+        auto command=update ? L"\""+path+L"\" --check-update" :
+            L"\""+path+L"\" --open \"kswitcher-screenshot:"+args+L"\"";
        STARTUPINFOW startup{sizeof(startup)}; PROCESS_INFORMATION process{};
        auto ok=CreateProcessW(path.c_str(),command.data(),nullptr,nullptr,FALSE,CREATE_SUSPENDED,nullptr,nullptr,&startup,&process);
        auto result=ok?S_OK:HRESULT_FROM_WIN32(GetLastError());
@@ -181,5 +181,44 @@ bool notifyScreenshot(const Clip &clip)
 }
 std::string screenshotNotificationError() { return notificationError; }

+std::wstring updateToastXml(const std::wstring &version)
+{
+    return L"<toast launch=\"check-update\"><visual><binding template=\"ToastGeneric\">"
+           L"<text>KSwitcher update available</text><text>Version " + escapeXml(version) +
+           L" is available. Click to review and install.</text></binding></visual>"
+           L"<actions><action content=\"Review update\" arguments=\"check-update\" activationType=\"foreground\"/>"
+           L"<action content=\"Later\" arguments=\"dismiss\" activationType=\"system\"/></actions></toast>";
+}
+bool notifyUpdateAvailable(const std::wstring &version)
+{
+    try {
+        // Reuse the screenshot notification identity, Windows settings and COM activator.
+        registerScreenshotNotifications();
+        ComPtr<Notifications::IToastNotificationManagerStatics> manager;
+        String managerClass(L"Windows.UI.Notifications.ToastNotificationManager");
+        check(RoGetActivationFactory(managerClass.value,IID_PPV_ARGS(&manager)));
+        ComPtr<Notifications::IToastNotifier> notifier; String appId(AppId);
+        check(manager->CreateToastNotifierWithId(appId.value,&notifier));
+        Notifications::NotificationSetting setting{};
+        auto settingsResult=notifier->get_Setting(&setting);
+        if(settingsResult!=HRESULT_FROM_WIN32(ERROR_NOT_FOUND)) check(settingsResult);
+        if(setting!=Notifications::NotificationSetting_Enabled)
+            throw std::runtime_error("Windows notifications for KSwitcher Screenshot are disabled");
+        String documentClass(L"Windows.Data.Xml.Dom.XmlDocument"); ComPtr<IInspectable> instance;
+        check(RoActivateInstance(documentClass.value,&instance));
+        ComPtr<Xml::IXmlDocument> document; check(instance.As(&document));
+        ComPtr<Xml::IXmlDocumentIO> io; check(document.As(&io));
+        String content(updateToastXml(version)); check(io->LoadXml(content.value));
+        ComPtr<Notifications::IToastNotificationFactory> factory; String toastClass(L"Windows.UI.Notifications.ToastNotification");
+        check(RoGetActivationFactory(toastClass.value,IID_PPV_ARGS(&factory)));
+        ComPtr<Notifications::IToastNotification> toast; check(factory->CreateToastNotification(document.Get(),&toast));
+        // Repeated submissions replace the existing update card in Notification Center.
+        ComPtr<Notifications::IToastNotification2> tagged; check(toast.As(&tagged));
+        String tag(L"update"),group(L"KSwitcher"); check(tagged->put_Tag(tag.value)); check(tagged->put_Group(group.value));
+        check(notifier->Show(toast.Get()));
+        return true;
+    } catch(const std::exception &e) { log(L"Update toast: "+wide(e.what())); return false; }
+}
+

 }
@@ -44,6 +44,13 @@ bool validId(const std::wstring &id)
 } // namespace
 void validateSettings(const Settings &s)
 {
+    if (s.tesseractPath.size() > 32700 || s.tesseractPath.find_first_of(L"\r\n\"") != s.tesseractPath.npos)
+        throw std::runtime_error("Invalid Tesseract executable path");
+    if (s.tesseractLanguages.empty() || s.tesseractLanguages.size() > 128 ||
+        s.tesseractLanguages.front() == L'+' || s.tesseractLanguages.back() == L'+' ||
+        s.tesseractLanguages.find(L"++") != s.tesseractLanguages.npos ||
+        s.tesseractLanguages.find_first_not_of(L"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_+") != s.tesseractLanguages.npos)
+        throw std::runtime_error("Use Tesseract language codes separated by +, for example ukr+eng+rus");
    std::vector<Hotkey> used;
    std::vector<std::wstring> keys{s.toggle, s.casing, s.translit, s.undo, s.clipboard, s.screenshot};
    keys.insert(keys.end(), s.direct.begin(), s.direct.end());
@@ -85,6 +92,17 @@ 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");
+    for (const auto &[language, words] : s.autoWords)
+    {
+        std::wstring alphabet = language == L"en" ? L"abcdefghijklmnopqrstuvwxyz" :
+            language == L"uk" ? L"абвгґдеєжзиіїйклмнопрстуфхцчшщьюя" :
+            language == L"ru" ? L"абвгдеёжзийклмнопрстуфхцчшщъыьэюя" : L"";
+        if (alphabet.empty() || words.size() > 10000)
+            throw std::runtime_error("Invalid personal dictionary language or too many words");
+        for (const auto &word : words)
+            if (word.empty() || word.size() > 32 || lower(word).find_first_not_of(alphabet) != word.npos)
+                throw std::runtime_error("Personal words must contain 1-32 letters of their selected language");
+    }
    if (s.maxItems < 10 || s.maxItems > 10000 || s.maxMiB < 1 || s.maxMiB > 2048 || s.maxImageMiB < 1 ||
        s.maxImageMiB > 64)
        throw std::runtime_error("History limits: 10–10000 items, 1–2048 MiB total, 1–64 MiB per image");
@@ -125,6 +143,9 @@ Settings decodeSettings(const Bytes &bytes, const std::vector<Layout> &layouts)
    s.switchLayout = j.value("switchSystemLayout", true);
    s.writeLog = j.value("writeLog", true);
    s.history = j.value("historyEnabled", true);
+    s.useTesseract = j.value("useTesseract", false);
+    s.tesseractPath = str(j, "tesseractPath");
+    s.tesseractLanguages = str(j, "tesseractLanguages", s.tesseractLanguages);
    s.autostart = j.value("startWithSystem", false);
    s.elevatedAutostart = j.value("autostartAsAdministrator", false);
    s.awake = j.value("preventScreenLock", false);
@@ -133,6 +154,10 @@ Settings decodeSettings(const Bytes &bytes, const std::vector<Layout> &layouts)
    s.autoMinLength = j.value("autoCorrectMinLength", 3);
    s.autoPrefixChars = str(j, "autoCorrectPrefixChars", s.autoPrefixChars);
    s.autoSuffixChars = str(j, "autoCorrectSuffixChars", s.autoSuffixChars);
+    if (j.contains("autoCorrectWords"))
+        for (auto &[language, words] : j.at("autoCorrectWords").items())
+            for (auto &word : words)
+                s.autoWords[wide(language)].push_back(lower(wide(word.get<std::string>())));
    for (auto pair : {std::pair{"autoCorrectLanguages", &s.autoLanguages},
                      {"autoCorrectNever", &s.autoNever},
                      {"autoCorrectExcludedApps", &s.autoExcluded}})
@@ -196,6 +221,9 @@ Bytes encodeSettings(const Settings &s)
              {"writeLog", s.writeLog},
              {"autostartAsAdministrator", s.elevatedAutostart},
              {"historyEnabled", s.history},
+              {"useTesseract", s.useTesseract},
+              {"tesseractPath", utf8(s.tesseractPath)},
+              {"tesseractLanguages", utf8(s.tesseractLanguages)},
              {"startWithSystem", s.autostart},
              {"preventScreenLock", s.awake},
              {"maxItems", s.maxItems},
@@ -216,6 +244,13 @@ Bytes encodeSettings(const Settings &s)
    j["autoCorrectMinLength"] = s.autoMinLength;
    j["autoCorrectPrefixChars"] = utf8(s.autoPrefixChars);
    j["autoCorrectSuffixChars"] = utf8(s.autoSuffixChars);
+    j["autoCorrectWords"] = Json::object();
+    for (const auto &[language, words] : s.autoWords)
+    {
+        auto &items = j["autoCorrectWords"][utf8(language)] = Json::array();
+        for (const auto &word : words)
+            items.push_back(utf8(lower(word)));
+    }
    for (auto pair : {std::pair{"autoCorrectLanguages", &s.autoLanguages},
                      {"autoCorrectNever", &s.autoNever},
                      {"autoCorrectExcludedApps", &s.autoExcluded}})
@@ -297,7 +332,8 @@ History::History(const std::filesystem::path &folder) : folder_(folder)
                   e.value("at", uint64_t{}),
                   e.value("pinned", false),
                   e.value("image", false),
-                   e.value("files", false)};
+                   e.value("files", false), e.value("ocrState", e.value("image", false) ? 1 : 0),
+                   str(e, "ocrProfile", L"windows")};
        if (validId(item.id) && std::filesystem::exists(folder_ / (item.id + L".dat")))
            entries_.push_back(std::move(item));
    }
@@ -313,7 +349,7 @@ void History::saveIndex()
                     {"at", e.at},
                     {"pinned", e.pinned},
                     {"image", e.image},
-                     {"files", e.files}});
+                     {"files", e.files}, {"ocrState", e.ocrState}, {"ocrProfile", utf8(e.ocrProfile)}});
    atomicWrite(folder_ / L"index.dat", protect(jsonBytes(j)));
 }
 std::vector<Entry> History::entries() const
@@ -342,6 +378,7 @@ void History::prune(const Settings &s)
        total -= entries_[i].bytes;
        std::error_code ec;
        std::filesystem::remove(folder_ / (entries_[i].id + L".dat"), ec);
+        std::filesystem::remove(folder_ / (entries_[i].id + L".ocr"), ec);
        entries_.erase(entries_.begin() + i);
    }
 }
@@ -429,7 +466,8 @@ void History::add(const Clip &clip, const std::wstring &app, const Settings &s)
    GetSystemTimeAsFileTime(&now);
    entries_.insert(entries_.begin(),
                    Entry{id, text, app, encrypted.size(),
-                          (uint64_t(now.dwHighDateTime) << 32) | now.dwLowDateTime, false, image, files});
+                          (uint64_t(now.dwHighDateTime) << 32) | now.dwLowDateTime, false, image, files,
+                          image ? 1 : 0, ocrProfile(s)});
    prune(s);
    saveIndex();
 }
@@ -445,6 +483,7 @@ void History::remove(const std::wstring &id)
    saveIndex();
    std::error_code ec;
    std::filesystem::remove(folder_ / (id + L".dat"), ec);
+    std::filesystem::remove(folder_ / (id + L".ocr"), ec);
 }
 void History::pin(const std::wstring &id)
 {
@@ -464,8 +503,49 @@ void History::clear()
    {
        std::error_code ec;
        std::filesystem::remove(folder_ / (e.id + L".dat"), ec);
+        std::filesystem::remove(folder_ / (e.id + L".ocr"), ec);
    }
 }
+bool History::saveOcr(const std::wstring &id, const std::optional<std::wstring> &text, const Settings &settings)
+{
+    std::lock_guard lock(mutex_);
+    auto it = std::find_if(entries_.begin(), entries_.end(), [&](auto &e) { return e.id == id; });
+    // A late OCR completion must never recreate a deleted/pruned image.
+    auto profile = ocrProfile(settings);
+    if (it == entries_.end() || !it->image || (it->ocrState == 2 && it->ocrProfile == profile)) return false;
+    if (text)
+    {
+        auto utf = utf8(*text);
+        if (utf.size() > 1024 * 1024) throw std::runtime_error("OCR text exceeds storage limit");
+        // A version byte also makes empty recognition results encryptable by DPAPI.
+        Bytes payload{1};
+        payload.insert(payload.end(), utf.begin(), utf.end());
+        auto encrypted = protect(payload);
+        auto path = folder_ / (id + L".ocr");
+        std::error_code ec;
+        auto previousBytes = std::filesystem::file_size(path, ec);
+        if (ec) previousBytes = 0;
+        atomicWrite(path, encrypted);
+        it->bytes = it->bytes - std::min(it->bytes, uint64_t(previousBytes)) + encrypted.size();
+        it->ocrState = 2;
+    }
+    else it->ocrState = 3;
+    it->ocrProfile = profile;
+    prune(settings);
+    saveIndex();
+    return true;
+}
+std::optional<std::wstring> History::ocrText(const std::wstring &id, const std::wstring &profile) const
+{
+    {
+        std::lock_guard lock(mutex_);
+        auto it = std::find_if(entries_.begin(), entries_.end(), [&](auto &e) { return e.id == id; });
+        if (it == entries_.end() || it->ocrState != 2 || (!profile.empty() && it->ocrProfile != profile)) return std::nullopt;
+    }
+    auto bytes = unprotect(readFile(folder_ / (id + L".ocr"), 2 * 1024 * 1024));
+    if (bytes.empty() || bytes.front() != 1) throw std::runtime_error("Invalid OCR text format");
+    return wide(std::string(bytes.begin() + 1, bytes.end()));
+}
 std::vector<Entry> History::search(const std::wstring &query) const
 {
    auto items = entries();
@@ -477,6 +557,21 @@ std::vector<Entry> History::search(const std::wstring &query) const
                  {
                      if (lower(e.preview + L" " + e.app).find(q) != q.npos)
                          return false;
+                      if (e.ocrState == 2)
+                      {
+                          try
+                          {
+                              auto text = ocrText(e.id);
+                              if (text && lower(*text).find(q) != q.npos) return false;
+                          }
+                          catch (...) {} // Missing/corrupt OCR must not hide the original clip.
+                      }
+                      // Short previews contain the complete text (or a placeholder for
+                      // textless clips). Do not decrypt image payloads just to rule them out.
+                      // Newlines/tabs are flattened in previews, so those queries still
+                      // need the original text. Exactly 240 characters may be truncated.
+                      if (e.preview.size() < 240 && q.find_first_of(L"\r\n\t") == q.npos)
+                          return true;
                      try
                      {
                          return lower(load(e.id).text()).find(q) == q.npos;
@@ -13,6 +13,8 @@ struct Entry
    std::wstring id, preview, app;
    uint64_t bytes{}, at{};
    bool pinned{}, image{}, files{};
+    int ocrState{}; // 0: legacy/not applicable, 1: pending, 2: saved, 3: failed
+    std::wstring ocrProfile = L"windows";
 };
 class History
 {
@@ -27,6 +29,8 @@ 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 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 &);
    void pin(const std::wstring &);
    void clear();
@@ -71,17 +71,48 @@ void arrangeWindow(HWND w)
    RECT client{}; GetClientRect(w, &client);
    int extraWidth = layout->history ? std::max(0, int(client.right) - scale(w, layout->width)) : 0;
    int extraHeight = layout->history ? std::max(0, int(client.bottom) - scale(w, layout->height)) : 0;
+    struct Move { HWND child; RECT rect; };
+    std::vector<Move> moves;
    for (const auto &[child, r] : layout->controls)
    {
        int id = GetDlgCtrlID(child);
-        SetWindowPos(child, nullptr, scale(w, r.left) - layout->x,
-                         scale(w, r.top) - layout->y + (id >= 110 && id <= 114 ? extraHeight : 0),
-                         scale(w, r.right - r.left) + (id == 101 || id == 102 ? extraWidth : 0),
-                         scale(w, r.bottom - r.top) + (id == 102 ? extraHeight : 0),
-                         SWP_NOACTIVATE | SWP_NOZORDER);
+        RECT next{scale(w, r.left) - layout->x,
+                  scale(w, r.top) - layout->y + (id >= 110 && id <= 114 ? 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);
+        RECT current{}; GetWindowRect(child, &current);
+        MapWindowPoints(nullptr, w, reinterpret_cast<POINT *>(&current), 2);
+        if (!EqualRect(&current, &next)) moves.push_back({child, next});
+    }
+    if (!moves.empty())
+    {
+        auto batch = BeginDeferWindowPos((int)moves.size());
+        for (const auto &move : moves)
+        {
+            if (!batch) break;
+            auto r = move.rect;
+            batch = DeferWindowPos(batch, move.child, nullptr, r.left, r.top, r.right-r.left, r.bottom-r.top,
+                                   SWP_NOACTIVATE | SWP_NOZORDER);
+        }
+        if (!batch || !EndDeferWindowPos(batch))
+            for (const auto &move : moves)
+            {
+                auto r = move.rect;
+                SetWindowPos(move.child, nullptr, r.left, r.top, r.right-r.left, r.bottom-r.top,
+                             SWP_NOACTIVATE | SWP_NOZORDER);
+            }
    }
    layout->arranging = false;
-    InvalidateRect(w, nullptr, TRUE);
+}
+void scrollWindow(HWND w, WindowLayout *layout, bool horizontal, int requested)
+{
+    SCROLLINFO info{sizeof(info), SIF_RANGE | SIF_PAGE};
+    GetScrollInfo(w, horizontal ? SB_HORZ : SB_VERT, &info);
+    int next = std::clamp(requested, info.nMin, std::max(info.nMin, info.nMax - std::max(0, (int)info.nPage - 1)));
+    int &position = horizontal ? layout->x : layout->y;
+    if (position == next) return;
+    position = next;
+    arrangeWindow(w);
 }
 void revealControl(HWND child)
 {
@@ -127,7 +158,7 @@ LRESULT CALLBACK layoutProc(HWND w, UINT msg, WPARAM wp, LPARAM lp, UINT_PTR, DW
        bool vertical = msg == WM_VSCROLL;
        SCROLLINFO info{sizeof(info), SIF_ALL};
        GetScrollInfo(w, vertical ? SB_VERT : SB_HORZ, &info);
-        int &position = vertical ? layout->y : layout->x;
+        int position = vertical ? layout->y : layout->x;
        switch (LOWORD(wp))
        {
        case SB_LINEUP: position -= scale(w, 32); break;
@@ -138,7 +169,7 @@ LRESULT CALLBACK layoutProc(HWND w, UINT msg, WPARAM wp, LPARAM lp, UINT_PTR, DW
        case SB_BOTTOM: position = info.nMax; break;
        case SB_THUMBTRACK: case SB_THUMBPOSITION: position = info.nTrackPos; break;
        }
-        arrangeWindow(w);
+        scrollWindow(w, layout, !vertical, position);
        return 0;
    }
    if (layout->scrolling && (msg == WM_MOUSEWHEEL || msg == WM_MOUSEHWHEEL))
@@ -148,8 +179,9 @@ LRESULT CALLBACK layoutProc(HWND w, UINT msg, WPARAM wp, LPARAM lp, UINT_PTR, DW
        remainder += GET_WHEEL_DELTA_WPARAM(wp);
        int steps = remainder / WHEEL_DELTA;
        remainder %= WHEEL_DELTA;
-        (horizontal ? layout->x : layout->y) += steps * scale(w, 48) * (msg == WM_MOUSEHWHEEL ? 1 : -1);
-        arrangeWindow(w);
+        if (steps)
+            scrollWindow(w, layout, horizontal, (horizontal ? layout->x : layout->y) +
+                         steps * scale(w, 48) * (msg == WM_MOUSEHWHEEL ? 1 : -1));
        return 0;
    }
    if (msg == WM_NCDESTROY)
@@ -276,7 +308,7 @@ HWND makeWindow(App &app, const wchar_t *cls, const wchar_t *title, WNDPROC proc
    RegisterClassW(&wc);
    UINT dpi = GetDpiForSystem();
    RECT rect{0, 0, MulDiv(width, dpi, 96), MulDiv(height, dpi, 96)};
-    DWORD style = WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | extra;
+    DWORD style = WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_CLIPCHILDREN | extra;
    if (resizable) style |= WS_THICKFRAME | WS_MAXIMIZEBOX;
    AdjustWindowRectExForDpi(&rect, style, FALSE, WS_EX_APPWINDOW, dpi);
    POINT cursor{};
@@ -420,7 +452,7 @@ void search(HWND w, HistoryView *v)
    auto generation = ++v->generation;
    v->pending.clear();
    auto *app = v->app;
-    app->enqueue(
+    app->enqueueHistorySearch(
        [w, app, q, generation]
        {
            try
@@ -625,6 +657,8 @@ LRESULT CALLBACK historyProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
            int id = LOWORD(wp);
            if (id == 101 && HIWORD(wp) == EN_CHANGE)
            {
+                // Reject an older result even during the debounce interval.
+                ++v->generation;
                SetTimer(w, 1, 180, nullptr);
                return 0;
            }
@@ -732,7 +766,7 @@ LRESULT CALLBACK historyProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
            AppendMenuW(menu, MF_STRING, 112, L"Pin / unpin");
            AppendMenuW(menu, MF_STRING, 113, L"Delete");
            AppendMenuW(menu, MF_STRING, 114, L"Open full item");
-            AppendMenuW(menu, MF_STRING, 115, L"Copy text from image (Windows OCR)");
+            AppendMenuW(menu, MF_STRING, 115, L"Copy text from image (OCR)");
            POINT p;
            GetCursorPos(&p);
            int cmd = TrackPopupMenu(menu, TPM_RETURNCMD, p.x, p.y, 0, w, nullptr);
@@ -975,6 +1009,15 @@ LRESULT CALLBACK autoOptionsProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
            if (checked(w, 403))
                draft.autoLanguages.push_back(L"ru");
            draft.autoNever = parseCommaList(value(w, 405));
+            for (auto [id, language] : {std::pair{411, L"en"}, {412, L"uk"}, {413, L"ru"}})
+            {
+                auto text = lower(value(w, id));
+                std::replace(text.begin(), text.end(), L'\n', L',');
+                auto words = parseCommaList(text);
+                std::sort(words.begin(), words.end());
+                words.erase(std::unique(words.begin(), words.end()), words.end());
+                draft.autoWords[language] = std::move(words);
+            }
            draft.autoExcluded = parseCommaList(value(w, 404));
            draft.autoPrefixChars = value(w, 408);
            draft.autoSuffixChars = value(w, 409);
@@ -983,6 +1026,7 @@ LRESULT CALLBACK autoOptionsProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
            validateSettings(draft);
            view->settings->draft.autoLanguages = draft.autoLanguages;
            view->settings->draft.autoNever = draft.autoNever;
+            view->settings->draft.autoWords = draft.autoWords;
            view->settings->draft.autoExcluded = draft.autoExcluded;
            view->settings->draft.autoMaxRank = draft.autoMaxRank;
            view->settings->draft.autoMinLength = draft.autoMinLength;
@@ -1029,13 +1073,20 @@ void showAutoOptions(HWND parent, SettingsView *v)
    for (auto &lang : v->draft.autoLanguages)
        check(w, lang == L"en" ? 401 : lang == L"uk" ? 402 : 403, true);
    label(w, L"Excluded applications (process names, comma-separated)", 18, 94, 525);
-    edit(w, 404, 18, 122, 524, 84, ES_MULTILINE | WS_VSCROLL | ES_AUTOVSCROLL);
+    edit(w, 404, 18, 122, 524, 52, ES_MULTILINE | WS_VSCROLL | ES_AUTOVSCROLL);
    value(w, 404, commaList(v->draft.autoExcluded));
-    label(w, L"Personal dictionary: never correct these words (comma-separated)", 18, 220, 525);
-    edit(w, 405, 18, 248, 524, 84, ES_MULTILINE | WS_VSCROLL | ES_AUTOVSCROLL);
+    label(w, L"Never correct these words (comma-separated)", 18, 184, 525);
+    edit(w, 405, 18, 212, 524, 52, ES_MULTILINE | WS_VSCROLL | ES_AUTOVSCROLL);
    value(w, 405, commaList(v->draft.autoNever));
-    label(w, L"Corrects after Space and a short pause.", 18, 344, 525);
-    label(w, L"Undo skips this word until KSwitcher restarts.", 18, 366, 525);
+    label(w, L"My dictionary: correct words, separated by commas or new lines", 18, 276, 525);
+    for (auto [id, language] : {std::pair{411, L"en"}, {412, L"uk"}, {413, L"ru"}})
+    {
+        int x = 18 + (id - 411) * 178;
+        label(w, id == 411 ? L"English" : id == 412 ? L"Ukrainian" : L"Russian", x, 302, 168);
+        edit(w, id, x, 328, 168, 56, ES_MULTILINE | WS_VSCROLL | ES_AUTOVSCROLL | ES_WANTRETURN);
+        auto words = v->draft.autoWords.find(language);
+        if (words != v->draft.autoWords.end()) value(w, id, commaList(words->second));
+    }
    label(w, L"Frequency rank limit (0 = entire dictionary)", 18, 400, 390);
    edit(w, 406, 420, 396, 122, 26, ES_NUMBER);
    value(w, 406, std::to_wstring(v->draft.autoMaxRank));
@@ -1057,6 +1108,99 @@ void showAutoOptions(HWND parent, SettingsView *v)
    showRequestedWindow(w);
    SetForegroundWindow(w);
 }
+struct OcrOptionsView { HWND parent; SettingsView *settings; };
+Settings ocrDraft(HWND w, OcrOptionsView *v)
+{
+    auto draft = v->settings->draft;
+    draft.useTesseract = checked(w, 501);
+    draft.tesseractPath = value(w, 502);
+    draft.tesseractLanguages = value(w, 503);
+    validateSettings(draft);
+    return draft;
+}
+LRESULT CALLBACK ocrOptionsProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
+{
+    auto *v = reinterpret_cast<OcrOptionsView *>(GetWindowLongPtrW(w, GWLP_USERDATA));
+    if (!v) return DefWindowProcW(w, msg, wp, lp);
+    if (msg == WM_COMMAND)
+    {
+        int id = LOWORD(wp);
+        try
+        {
+            if (id == 507)
+            {
+                if ((INT_PTR)ShellExecuteW(w, L"open", L"https://github.com/UB-Mannheim/tesseract/wiki#tesseract-installer-for-windows",
+                                         nullptr, nullptr, SW_SHOWNORMAL) <= 32)
+                    throw std::runtime_error("Could not open the Tesseract download page in your browser");
+                return 0;
+            }
+            if (id == 504)
+            {
+                wchar_t path[32768]{};
+                OPENFILENAMEW picker{sizeof(picker)};
+                picker.hwndOwner = w; picker.lpstrFile = path; picker.nMaxFile = std::size(path);
+                picker.lpstrFilter = L"Tesseract executable (tesseract.exe)\0tesseract.exe\0Executables\0*.exe\0";
+                picker.Flags = OFN_FILEMUSTEXIST | OFN_NOCHANGEDIR;
+                if (GetOpenFileNameW(&picker)) value(w, 502, path);
+                return 0;
+            }
+            if (id == 505 || id == IDOK)
+            {
+                auto draft = ocrDraft(w, v);
+                if (id == 505)
+                {
+                    draft.useTesseract = true;
+                    validateTesseract(draft);
+                    SetDlgItemTextW(w, 506, (L"Ready: " + draft.tesseractLanguages).c_str());
+                    return 0;
+                }
+                validateTesseract(draft);
+                v->settings->draft.useTesseract = draft.useTesseract;
+                v->settings->draft.tesseractPath = draft.tesseractPath;
+                v->settings->draft.tesseractLanguages = draft.tesseractLanguages;
+                DestroyWindow(w);
+                return 0;
+            }
+            if (id == IDCANCEL) { DestroyWindow(w); return 0; }
+        }
+        catch (const std::exception &e) { error(w, e); return 0; }
+    }
+    if (msg == WM_CLOSE) { DestroyWindow(w); return 0; }
+    if (msg == WM_NCDESTROY)
+    {
+        EnableWindow(v->parent, TRUE);
+        SetForegroundWindow(v->parent);
+        disposeFont(w); delete v;
+        SetWindowLongPtrW(w, GWLP_USERDATA, 0);
+    }
+    return DefWindowProcW(w, msg, wp, lp);
+}
+void showOcrOptions(HWND parent, SettingsView *v)
+{
+    HWND w = makeWindow(*v->app, L"KSwitcher.OcrOptions", L"Image text recognition", ocrOptionsProc, 640, 450);
+    SetWindowLongPtrW(w, GWLP_HWNDPARENT, (LONG_PTR)parent);
+    SetWindowLongPtrW(w, GWLP_USERDATA, (LONG_PTR)new OcrOptionsView{parent, v});
+    label(w, L"Windows OCR is used by default. Recognition stays on this computer.", 18, 16, 600);
+    checkbox(w, L"Use optional Tesseract 5 instead of Windows OCR", 501, 18, 48, 600);
+    check(w, 501, v->draft.useTesseract);
+    label(w, L"Tesseract executable (blank = detect installed location)", 18, 90, 600);
+    edit(w, 502, 18, 118, 484);
+    value(w, 502, v->draft.tesseractPath);
+    button(w, L"Browse…", 504, 514, 117, 106);
+    label(w, L"Languages used together (for example ukr+eng+rus)", 18, 160, 600);
+    edit(w, 503, 18, 188, 602);
+    value(w, 503, v->draft.tesseractLanguages);
+    button(w, L"Check installation", 505, 18, 228, 180);
+    control(w, L"STATIC", L"", 0, 506, 212, 232, 408, 24);
+    button(w, L"Download Tesseract…", 507, 18, 266, 180);
+    label(w, L"Opens the Windows installer page in your browser.", 212, 270, 408);
+    label(w, L"Changing the engine or languages reprocesses saved images in the background.", 18, 314, 602);
+    label(w, L"Click OK here, then Save in Settings to apply. No downloads are automatic.", 18, 344, 602);
+    button(w, L"OK", IDOK, 406, 390, 100);
+    button(w, L"Cancel", IDCANCEL, 520, 390, 100);
+    EnableWindow(parent, FALSE);
+    showRequestedWindow(w); SetForegroundWindow(w);
+}
 LRESULT CALLBACK settingsProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
 {
    if (msg == WM_DPICHANGED)
@@ -1092,6 +1236,7 @@ LRESULT CALLBACK settingsProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
                showLogs(*v->app);
                return 0;
            }
+            if (id == 257) { showOcrOptions(w, v); return 0; }
            if (id == 230)
            {
                collectLayout(w, v);
@@ -1685,6 +1830,7 @@ void showSettings(App &app, bool visible)
    edit(w, 243, 18, 544, 742);
    button(w, L"Auto-correction options…", 255, 18, 575, 240);
    button(w, L"View log…", 256, 278, 575, 220);
+    button(w, L"OCR options…", 257, 518, 575, 242);
    button(w, L"Import settings…", 250, 18, 606, 145);
    button(w, L"Export settings…", 251, 173, 606, 145);
    button(w, L"Snippets…", 252, 328, 606, 110);
@@ -2,9 +2,12 @@
 #include "platform.h"
 namespace ks
 {
-inline constexpr wchar_t AppVersion[] = L"0.6.7";
+inline constexpr wchar_t AppVersion[] = L"0.6.10";
 inline constexpr UINT UpdateMessage = WM_APP + 7;
 inline constexpr UINT UpdateCheckIntervalMs = 6 * 60 * 60 * 1000;
+inline constexpr UINT UpdateNotificationRetryMs = 5 * 60 * 1000;
+bool notifyUpdateAvailable(const std::wstring &version);
+std::wstring updateToastXml(const std::wstring &version);
 struct UpdateResult
 {
    std::wstring state, version, error;
@@ -4,8 +4,17 @@
 #include <commctrl.h>
 #include <iostream>
 #include <cmath>
+LRESULT CALLBACK countControlMoves(HWND w, UINT message, WPARAM wp, LPARAM lp, UINT_PTR, DWORD_PTR data)
+{
+    if (message == WM_WINDOWPOSCHANGING) ++*reinterpret_cast<int *>(data);
+    return DefSubclassProc(w, message, wp, lp);
+}
 namespace ks {
 struct InputRegressionAccess {
+    static inline bool delivery = true;
+    static inline int notifications = 0;
+    static bool notify(const std::wstring &) { ++notifications; return delivery; }
+    static void notificationSetup(App &a) { a.updateNotifier = notify; }
    static void setup(App &a) { a.hookBindings = {{Toggle,{MOD_CONTROL,VK_F12}}, {Case,{MOD_CONTROL|MOD_SHIFT,'U'}}}; }
    static bool updateTimer(App &a) {
        a.updateRunning=true; // Exercise timer scheduling without launching a network request.
@@ -42,6 +51,7 @@ int main(int argc, char **argv) {
        {
            ks::App app(GetModuleHandleW(nullptr),true,temp);
            ks::InputRegressionAccess::setup(app);
+            ks::InputRegressionAccess::notificationSetup(app);
            // Message-only window: no hooks, synthetic input, clipboard changes or visible editor.
            app.window=CreateWindowExW(0,L"STATIC",L"Input tests",0,0,0,0,0,HWND_MESSAGE,nullptr,nullptr,nullptr);
            require(app.window!=nullptr,"message-only test window");
@@ -49,8 +59,18 @@ int main(int argc, char **argv) {
            require(ks::InputRegressionAccess::updateTimer(app),"update timer rearms and avoids overlapping checks");
            require(ks::InputRegressionAccess::updateResult(app,L"available",L"99.0.0")==L"99.0.0","background update records announced version");
            require(ks::InputRegressionAccess::updateResult(app,L"available",L"99.0.0")==L"99.0.0","same available version remains deduplicated");
+            require(ks::InputRegressionAccess::notifications==1,"successful background notification is submitted only once");
            require(ks::InputRegressionAccess::updateResult(app,L"error",L"")==L"99.0.0","network error preserves announced version");
            require(ks::InputRegressionAccess::updateResult(app,L"available",L"99.0.1")==L"99.0.1","new version can be announced after an error");
+            ks::InputRegressionAccess::delivery=false;
+            require(ks::InputRegressionAccess::updateResult(app,L"available",L"99.0.2")==L"99.0.1","failed notification is not marked delivered");
+            require(KillTimer(app.window,5)!=FALSE,"failed notification schedules a retry");
+            ks::InputRegressionAccess::delivery=true;
+            require(ks::InputRegressionAccess::updateResult(app,L"available",L"99.0.2")==L"99.0.2","notification can succeed on retry");
+            auto toast=ks::updateToastXml(L"1&2<3\"");
+            require(toast.find(L"1&amp;2&lt;3&quot;")!=toast.npos,"update version is XML escaped");
+            require(toast.find(L"launch=\"check-update\"")!=toast.npos && toast.find(L"arguments=\"check-update\"")!=toast.npos,
+                    "toast body and action both review the update instead of installing automatically");
            for(int variant=0;variant<3;++variant) for(int icon=0;icon<15;++icon)
                for(int size:{22,44,55}) {
                    auto handle=(HICON)LoadImageW(app.instance,MAKEINTRESOURCEW(icon<9?300+variant*10+icon:400+variant*10+icon-9),IMAGE_ICON,size,size,0);
@@ -566,10 +586,61 @@ 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);
+            SendMessageW(app.settingsWindow,WM_COMMAND,255,0);
+            auto autoOptions=FindWindowW(L"KSwitcher.AutoOptions",nullptr);
+            require(autoOptions!=nullptr,"auto-correction options open");
+            ShowWindow(autoOptions,SW_HIDE);
+            for(int id:{411,412,413}) {
+                RECT control{},client{};
+                GetWindowRect(GetDlgItem(autoOptions,id),&control);
+                MapWindowPoints(nullptr,autoOptions,reinterpret_cast<POINT*>(&control),2);
+                GetClientRect(autoOptions,&client);
+                require(control.left>=0&&control.top>=0&&control.right<=client.right&&control.bottom<=client.bottom,
+                        "personal dictionary field fits options window");
+            }
+            SetDlgItemTextW(autoOptions,412,L"Релізик\r\nрелізик, словечко");
+            SendMessageW(autoOptions,WM_COMMAND,IDOK,0);
+            require(!IsWindow(autoOptions),"personal words accepted without file editing");
+            SendMessageW(app.settingsWindow,WM_COMMAND,255,0);
+            autoOptions=FindWindowW(L"KSwitcher.AutoOptions",nullptr);
+            ShowWindow(autoOptions,SW_HIDE);
+            wchar_t personalWords[128]{};
+            GetDlgItemTextW(autoOptions,412,personalWords,128);
+            require(std::wstring(personalWords)==L"релізик, словечко",
+                    "personal dictionary normalizes case, newlines and duplicate words");
+            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");
+            {
+                app.history=std::make_unique<ks::History>(temp/L"history-search");
+                app.history->add(ks::textClip(L"згенеруй приклад"),L"test",app.settings);
+                app.history->add(ks::textClip(L"unrelated entry"),L"test",app.settings);
+                // This App has no general worker: a search on that queue can never finish.
+                auto originalFocus=GetFocus();
+                auto pumpUntil=[&](int count) {
+                    auto deadline=GetTickCount64()+3000;
+                    do {
+                        MSG message{};
+                        while(PeekMessageW(&message,nullptr,0,0,PM_REMOVE)) {
+                            TranslateMessage(&message); DispatchMessageW(&message);
+                        }
+                        if(SendDlgItemMessageW(history,102,LB_GETCOUNT,0,0)==count) return true;
+                        Sleep(5);
+                    } while(GetTickCount64()<deadline);
+                    return false;
+                };
+                ks::refreshHistory(app);
+                require(pumpUntil(2),"history loads independently of general worker queue");
+                SetDlgItemTextW(history,101,L"згенеруй");
+                require(pumpUntil(1),"typing filters history via debounce without focus change");
+                SetDlgItemTextW(history,101,L"missing query");
+                require(pumpUntil(0),"unmatched search clears history list");
+                SetDlgItemTextW(history,101,L"");
+                require(pumpUntil(2),"clearing search restores history");
+                require(GetFocus()==originalFocus,"history search preserves focus");
+            }
            auto childRect=[&](int id) { RECT r{}; GetWindowRect(GetDlgItem(history,id),&r); MapWindowPoints(nullptr,history,(POINT*)&r,2); return r; };
            RECT historyFrame{}; GetWindowRect(history,&historyFrame);
            auto listBefore=childRect(102),searchBefore=childRect(101),buttonBefore=childRect(110);
@@ -612,8 +683,27 @@ int main(int argc, char **argv) {
            require(scroll.nMax+1>(int)scroll.nPage,"small settings window has vertical scrolling");
            GetScrollInfo(settings,SB_HORZ,&scroll);
            require(scroll.nMax+1>(int)scroll.nPage,"small settings window has horizontal scrolling");
+            int controlMoves = 0;
+            auto trackedControl = GetDlgItem(settings,201);
+            SetWindowSubclass(trackedControl,countControlMoves,99,(DWORD_PTR)&controlMoves);
+            SendMessageW(settings,WM_VSCROLL,SB_TOP,0);
+            SendMessageW(settings,WM_HSCROLL,SB_LEFT,0);
+            controlMoves=0;
+            ValidateRect(settings,nullptr);
+            SendMessageW(settings,WM_MOUSEWHEEL,MAKEWPARAM(0,WHEEL_DELTA),0);
+            require(controlMoves==0 && !GetUpdateRect(settings,nullptr,FALSE),"wheel at top does not move controls or erase the window");
+            SendMessageW(settings,WM_MOUSEWHEEL,MAKEWPARAM(0,WORD(short(-WHEEL_DELTA/2))),0);
+            require(controlMoves==0,"partial wheel step does not rearrange controls");
+            SendMessageW(settings,WM_MOUSEWHEEL,MAKEWPARAM(0,WORD(short(-WHEEL_DELTA/2))),0);
+            require(controlMoves==1,"wheel scroll batches each control movement once");
            SendMessageW(settings,WM_VSCROLL,SB_BOTTOM,0);
            SendMessageW(settings,WM_HSCROLL,SB_RIGHT,0);
+            controlMoves=0;
+            SendMessageW(settings,WM_MOUSEWHEEL,MAKEWPARAM(0,-WHEEL_DELTA),0);
+            SendMessageW(settings,WM_MOUSEHWHEEL,MAKEWPARAM(0,WHEEL_DELTA),0);
+            require(controlMoves==0,"wheel at bottom and right boundaries does not rearrange controls");
+            require((GetWindowLongPtrW(settings,GWL_STYLE)&WS_CLIPCHILDREN)!=0,"parent background excludes child controls");
+            RemoveWindowSubclass(trackedControl,countControlMoves,99);
            GetClientRect(settings,&client);
            GetWindowRect(GetDlgItem(settings,IDCANCEL),&cancel);
            MapWindowPoints(nullptr,settings,(POINT*)&cancel,2);
@@ -3,6 +3,17 @@
 #include <fstream>
 #include <commctrl.h>

+namespace ks
+{
+struct InputRegressionAccess
+{
+    static bool deferring(App &app)
+    {
+        std::lock_guard lock(app.stateMutex);
+        return app.typingTarget != nullptr;
+    }
+};
+}
 namespace
 {
 ks::App *app{};
@@ -11,6 +22,7 @@ ks::Clip saved;
 bool captured = false, failed = false;
 int stage = 0, ru = -1, en = -1;
 size_t punctuationCase = 0;
+bool typeDuringCorrection = false, typedDuringCorrection = false;
 const std::vector<std::pair<std::wstring, std::wstring>> punctuationCases{
    {L"(ljvf) ", L"(дома) "}, {L"[ljvf] ", L"[дома] "}, {L"{ljvf} ", L"{дома} "},
    {L"ljvf: ", L"дома: "},   {L"ljvf; ", L"дома; "},   {L"#ljvf%; ", L"#дома%; "}};
@@ -25,7 +37,14 @@ size_t diagnosticStart{};
 void require(bool ok, const char *name)
 {
    if (!ok)
+    {
+        wchar_t observed[2048]{};
+        GetWindowTextW(field, observed, 2048);
+        std::cerr << "Editor at failure: " << ks::utf8(observed)
+                  << "; foregroundSame=" << (GetForegroundWindow() == host)
+                  << "; inputVersion=" << app->inputVersion.load() << '\n';
        throw std::runtime_error(name);
+    }
    std::cout << "PASS " << name << '\n';
 }
 std::wstring text()
@@ -80,7 +99,26 @@ LRESULT CALLBACK procedure(HWND w, UINT msg, WPARAM wp, LPARAM lp)
            if (GetTickCount64() > deadline)
                throw std::runtime_error("Native integration timed out");
            if (app->busy)
+            {
+                if (typeDuringCorrection && ks::InputRegressionAccess::deferring(*app))
+                {
+                    typeDuringCorrection = false;
+                    typedDuringCorrection = true;
+                    std::vector<INPUT> inputs;
+                    for (auto [key, up] : std::vector<std::pair<WORD, bool>>{
+                             {'F', false}, {'F', true}, {VK_LSHIFT, false},
+                             {'F', false}, {'F', true}, {VK_LSHIFT, true},
+                             {'B', false}, {'B', true}, {VK_BACK, false}, {VK_BACK, true}})
+                    {
+                        auto input = ks::keyboardInput(key, up ? KEYEVENTF_KEYUP : 0);
+                        input.ki.dwExtraInfo = 123; // External input must traverse the actual hook.
+                        inputs.push_back(input);
+                    }
+                    require(SendInput((UINT)inputs.size(), inputs.data(), sizeof(INPUT)) == inputs.size(),
+                            "concurrent typing submitted during selection/paste transaction");
+                }
                return 0;
+            }
            switch (stage++)
            {
            case 0:
@@ -242,6 +280,41 @@ LRESULT CALLBACK procedure(HWND w, UINT msg, WPARAM wp, LPARAM lp)
                break;
            case 17:
                require(text() == punctuationCases.back().first, "undo preserves custom punctuation");
+                [[fallthrough]];
+            case 20:
+                if (!captured)
+                {
+                    saved = ks::readClipboard(app->window, 64 * 1024 * 1024);
+                    captured = true;
+                    app->ownSequence = ks::writeClipboard(app->window, ks::textClip(sentinel));
+                }
+                app->settings.autoCorrect = true;
+                app->settings.switchLayout = true;
+                app->settings.autoLanguages = {L"en", L"ru"};
+                app->settings.cycle = {app->layouts[en].id, app->layouts[ru].id};
+                app->autoCorrector = ks::AutoCorrector{};
+                ActivateKeyboardLayout(app->layouts[en].handle, 0);
+                prepare(L"ghbdtn ", false);
+                record(L"ghbdtn ");
+                typeDuringCorrection = true;
+                app->transform(ks::AutoCorrect);
+                stage = 18;
+                break;
+            case 18:
+                require(typedDuringCorrection && text() == L"привет аА",
+                        "typing during correction replays in order with shift and backspace in new layout");
+                require(ks::readClipboard(app->window).text() == sentinel,
+                        "concurrent typing preserves clipboard restoration");
+                ActivateKeyboardLayout(app->layouts[en].handle, 0);
+                prepare(L"OLDghbdtn ", false);
+                record(L"ghbdtn ");
+                typedDuringCorrection = false;
+                typeDuringCorrection = true;
+                app->transform(ks::AutoCorrect);
+                break;
+            case 19:
+                require(typedDuringCorrection && text() == L"OLDghbdtn fF",
+                        "rejected correction collapses selection before replaying typing in original layout");
                finish();
                break;
            }
@@ -366,6 +439,8 @@ int main(int argc, char **argv)
                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;
+            if (argc > 1 && std::string(argv[1]) == "--typing-only")
+                stage = 20;
            SetTimer(host, 1, 100, nullptr);
            app->execute();
        }
@@ -1,7 +1,14 @@
 #include "ocr.h"
+#include "app.h"
 #include <iostream>
-int main()
+namespace ks {
+struct InputRegressionAccess {
+    static void scheduleOcr(App &app) { app.scheduleHistoryOcr(app.settings); }
+};
+}
+int main(int argc, char **argv)
 {
+    const bool tesseract = argc == 2 && std::string(argv[1]) == "--tesseract";
    CoInitializeEx(nullptr, COINIT_MULTITHREADED);
    try
    {
@@ -24,7 +31,8 @@ int main()
        auto oldFont = SelectObject(dc, font);
        SetTextColor(dc, RGB(0, 0, 0));
        SetBkColor(dc, RGB(255, 255, 255));
-        TextOutW(dc, 20, 40, L"HELLO KSWITCHER", 15);
+        std::wstring fixture = tesseract ? L"Привіт Україно HELLO" : L"HELLO KSWITCHER";
+        TextOutW(dc, 20, 40, fixture.c_str(), (int)fixture.size());
        GdiFlush();
        ks::Pixels pixels{800, 150, ks::Bytes((BYTE *)data, (BYTE *)data + 800 * 150 * 4)};
        SelectObject(dc, oldFont);
@@ -36,11 +44,45 @@ int main()
        auto decoded = ks::decodeImage(clip);
        if (decoded.width != 800 || decoded.height != 150)
            throw std::runtime_error("WIC decode size mismatch");
-        auto text = ks::recognizeText(clip);
+        ks::Settings config;
+        config.useTesseract = tesseract;
+        auto text = ks::recognizeText(clip, config);
        std::cout << "OCR: " << ks::utf8(text) << '\n';
        if (ks::upper(text).find(L"HELLO") == std::wstring::npos)
            throw std::runtime_error("OCR fixture was not recognized");
-        std::cout << "PASS native Windows OCR, DIB decoding and async result retrieval\n";
+        if (tesseract && ks::lower(text).find(L"привіт") == std::wstring::npos)
+            throw std::runtime_error("Ukrainian OCR fixture was not recognized");
+        auto temp = std::filesystem::temp_directory_path() / (L"KSwitcher-auto-ocr-" + std::to_wstring(GetCurrentProcessId()));
+        auto sequence = GetClipboardSequenceNumber();
+        {
+            ks::App app(GetModuleHandleW(nullptr), true, temp);
+            app.settings.history = true;
+            app.history->add(clip, L"OCR fixture", app.settings);
+            auto id = app.history->entries().front().id;
+            if (tesseract)
+            {
+                app.history->saveOcr(id, L"old Windows result", app.settings);
+                app.settings.useTesseract = true;
+            }
+            ks::InputRegressionAccess::scheduleOcr(app);
+            auto deadline = GetTickCount64() + 35000;
+            while ((app.history->entries().front().ocrState == 1 ||
+                    app.history->entries().front().ocrProfile != ks::ocrProfile(app.settings)) &&
+                   GetTickCount64() < deadline) Sleep(20);
+            if (app.history->search(L"HELLO").size() != 1)
+                throw std::runtime_error("Background OCR did not make the image searchable");
+            ks::History restored(temp / L"history");
+            if (!restored.ocrText(id) || restored.search(L"HELLO").size() != 1)
+                throw std::runtime_error("Background OCR did not persist its result");
+            if (tesseract && (restored.search(L"привіт").size() != 1 || !restored.search(L"old Windows result").empty()))
+                throw std::runtime_error("Engine change did not replace cached Windows OCR with Ukrainian text");
+            if (GetClipboardSequenceNumber() != sequence)
+                throw std::runtime_error("Background OCR changed the clipboard");
+            std::cout << "PASS automatic background OCR, persisted search and unchanged clipboard\n";
+        }
+        std::filesystem::remove_all(temp);
+        std::cout << (tesseract ? "PASS optional Tesseract, mixed Ukrainian/English and cache migration\n" :
+                                  "PASS native Windows OCR, DIB decoding and async result retrieval\n");
        CoUninitialize();
        return 0;
    }
@@ -3,6 +3,14 @@
 #include <shlobj.h>
 #include <iostream>
 static std::wstring programs;
+static std::wstring activationExecutable, activationCommand;
+static int activationCalls{};
+static BOOL WINAPI testCreateProcess(LPCWSTR path, LPWSTR command, LPSECURITY_ATTRIBUTES,
+    LPSECURITY_ATTRIBUTES, BOOL, DWORD, LPVOID, LPCWSTR, LPSTARTUPINFOW, LPPROCESS_INFORMATION)
+{
+    ++activationCalls; activationExecutable=path; activationCommand=command;
+    SetLastError(ERROR_CANCELLED); return FALSE; // Inspect activation without starting any program.
+}
 static HRESULT testKnownFolder(REFKNOWNFOLDERID, DWORD, HANDLE, PWSTR *out)
 {
    *out=(PWSTR)CoTaskMemAlloc((programs.size()+1)*sizeof(wchar_t));
@@ -10,8 +18,10 @@ static HRESULT testKnownFolder(REFKNOWNFOLDERID, DWORD, HANDLE, PWSTR *out)
    wcscpy(*out,programs.c_str()); return S_OK;
 }
 #define SHGetKnownFolderPath testKnownFolder
+#define CreateProcessW testCreateProcess
 #include "../src/screenshot_activation.cpp"
 #undef SHGetKnownFolderPath
+#undef CreateProcessW
 int main()
 {
    CoInitializeEx(nullptr,COINIT_APARTMENTTHREADED);
@@ -45,6 +55,18 @@ 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.
+        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();
+        if(activationCalls!=1 || activationExecutable!=main || activationCommand!=L"\""+main+L"\" --check-update")
+            throw std::runtime_error("update toast must open review, never install automatically");
+        if(activator.Activate(L"other-app",L"check-update",nullptr,0)!=E_INVALIDARG ||
+           activator.Activate(L"HrynCo.KSwitcher.Screenshot",L"--install",nullptr,0)!=E_INVALIDARG || activationCalls!=1)
+            throw std::runtime_error("invalid notification activation must not launch a process");
+        const wchar_t *token=L"12345678-1234-1234-1234-123456789abc";
+        activator.Activate(L"HrynCo.KSwitcher.Screenshot",token,nullptr,0);
+        if(activationCalls!=2 || activationExecutable!=helper.wstring() || activationCommand.find(token)==activationCommand.npos)
+            throw std::runtime_error("screenshot activation must retain its existing route");
        std::cout<<"Passed isolated screenshot registration checks\n";
    } catch(const std::exception &e) { std::cerr<<e.what()<<'\n'; result=1; }
    RegOverridePredefKey(HKEY_CURRENT_USER,nullptr);
@@ -22,6 +22,8 @@ int main()
                "editor is an independent Alt+Tab application window");
        require(GetDlgItem(window,50)!=nullptr && c.statusHeight>0,"status bar is created");
        require(c.pencilCursor!=nullptr,"pencil drawing cursor loads");
+        require(c.freehand && !c.pointer && ks::toolCursor(c)==c.pencilCursor,
+                "new screenshot editor starts with the pencil tool");
        for(int size:{32,48,64,96}) {
            auto cursor=(HCURSOR)LoadImageW(app.instance,MAKEINTRESOURCEW(IDC_SCREENSHOT_PENCIL),IMAGE_CURSOR,size,size,0);
            ICONINFO info{};
@@ -241,6 +241,37 @@ int main(int argc, char **argv)
        require(corrector.memoryBytes() < 3 * 1024 * 1024, "two dictionaries fit within 3 MiB");
        require(!ks::autoCorrectionAllowed(nullptr, autoSettings), "missing focused editor fails closed");
        ks::AutoCorrector missing;
+        {
+            ks::AutoCorrector supplemental;
+            auto options = autoSettings;
+            options.autoLanguages = {L"en", L"uk", L"ru"};
+            options.cycle = {L"en", L"uk", L"ru"};
+            supplemental.configure(L"dictionaries", options.autoLanguages);
+            auto release = supplemental.suggest(L"релыз ", 1, layouts, options);
+            require(release && release->text == L"реліз " && release->target == 2,
+                    "supplemental Ukrainian release word corrects from Russian layout");
+            require(!supplemental.suggest(L"реліз ", 2, layouts, options),
+                    "correct Ukrainian release word stays unchanged");
+            require(!supplemental.suggest(L"релиз ", 1, layouts, options),
+                    "valid Russian release word stays unchanged");
+            options.autoMaxRank = 50000;
+            require(!supplemental.suggest(L"релыз ", 1, layouts, options),
+                    "supplemental vocabulary respects explicit frequency limit");
+            options.autoWords[L"uk"] = {L"релізик"};
+            options.autoMaxRank = 1;
+            auto custom = supplemental.suggest(L"релызик ", 1, layouts, options);
+            require(custom && custom->text == L"релізик " && custom->target == 2,
+                    "personal word enables correction without editing dictionary files");
+            require(!supplemental.suggest(L"релізик ", 2, layouts, options),
+                    "personal word is protected from correction");
+            options.autoNever = {L"релызик"};
+            require(!supplemental.suggest(L"релызик ", 1, layouts, options),
+                    "never-correct list takes precedence over personal word");
+            options.autoNever.clear();
+            options.cycle = {L"en", L"ru"};
+            require(!supplemental.suggest(L"релызик ", 1, layouts, options),
+                    "personal dictionary respects disabled target layouts");
+        }
        rejects([&] { missing.configure(L"missing-dictionaries", {L"en"}); }, "missing dictionary rejected");
        require(ks::convertTo(L"ghbdtn", layouts, 1, 0) == L"привет", "hint conversion");
        require(ks::convertTo(L"привет", layouts, 1, 1) == L"привет", "same source is unchanged");
@@ -335,6 +366,25 @@ int main(int argc, char **argv)
        auto temp = std::filesystem::temp_directory_path() /
                    (L"KSwitcher-tests-" + std::to_wstring(GetCurrentProcessId()));
        std::filesystem::create_directories(temp);
+        {
+            auto folder = temp / L"dictionaries";
+            std::filesystem::create_directories(folder);
+            auto put = [&](const wchar_t *name, const std::wstring &text)
+            {
+                auto data = ks::utf8(text);
+                ks::atomicWrite(folder / name, ks::Bytes(data.begin(), data.end()));
+            };
+            put(L"en.txt", L"zoo\t3\nhello\t99\nhello\t1\n");
+            put(L"uk.txt", L"дім\t3\n");
+            ks::AutoCorrector edited;
+            edited.configure(folder, {L"en", L"uk"});
+            auto options = ks::Settings{};
+            options.cycle = {L"en", L"uk"};
+            options.autoMaxRank = 1;
+            auto correction = edited.suggest(L"руддщ ", 2, layouts, options);
+            require(correction && correction->text == L"hello ",
+                    "unsorted dictionaries and duplicates load using lowest duplicate rank");
+        }
        ks::Pixels pixels{2, 1, {10, 20, 30, 255, 40, 50, 60, 255}};
        ks::Clip firstImage{{ks::imageDib(pixels), {0, L"Ole Private Data", {1, 2, 3}}}};
        auto thumbnail = ks::decodeImage(firstImage, 1, 1);
@@ -384,11 +434,16 @@ int main(int argc, char **argv)
        settings.autoPrefixChars = L"(#";
        settings.autoSuffixChars = L");%";
        settings.autoNever = {L"myWord"};
+        settings.autoWords = {{L"uk", {L"релізик"}}, {L"en", {L"kswitcher"}}};
        settings.autoExcluded = {L"Code.exe"};
        settings.cycle = {L"en", L"uk"};
        settings.snippets = {{L";address", L"Line 1\r\n{cursor}Line 2"}};
        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");
+        auto invalidWords = settings;
+        invalidWords.autoWords[L"uk"] = {L"hello"};
+        rejects([&] { ks::validateSettings(invalidWords); }, "personal dictionary rejects wrong language letters");
        require(ks::encodeSettings(ks::decodeSettings(ks::encodeSettings(settings), {})) == ks::encodeSettings(settings),
                "configurator snapshot survives serialization without changing the concurrency token");
        rejects([&] { ks::decodeSettings(ks::Bytes{'{', '}'}, {}); },
@@ -468,6 +523,75 @@ int main(int argc, char **argv)
            history.clear();
            require(history.entries().empty(), "clear history");
        }
+        {
+            ks::History history(temp / L"search");
+            history.add(ks::textClip(std::wstring(260, L'x') + L" hidden needle"), L"Test", settings);
+            history.add(ks::textClip(L"first\nsecond\tthird"), L"Test", settings);
+            require(history.search(L"hidden needle").size() == 1, "search beyond truncated preview");
+            require(history.search(L"first\nsecond").size() == 1, "search retains original newlines");
+            require(history.search(L"second\tthird").size() == 1, "search retains original tabs");
+            require(history.search(L"absent").empty(), "short previews reject unmatched queries");
+            require(history.search(L"FIRST").size() == 1, "short preview search ignores case");
+        }
+        {
+            auto folder = temp / L"ocr-history";
+            ks::History history(folder);
+            ks::Clip image{{ks::imageDib(ks::Pixels{2, 2, ks::Bytes(16, 255)})}};
+            history.add(image, L"OCR test", settings);
+            auto id = history.entries().front().id;
+            require(history.entries().front().ocrState == 1, "new images await background OCR");
+            require(ks::History(folder).entries().front().ocrState == 1, "pending OCR survives restart");
+            auto original = ks::encodeClip(history.load(id));
+            auto beforeBytes = history.entries().front().bytes;
+            require(history.saveOcr(id, L"Розпізнаний текст HELLO", settings), "save image OCR");
+            require(history.entries().front().bytes > beforeBytes, "OCR storage counts against history size");
+            require(ks::encodeClip(history.load(id)) == original, "OCR preserves original image formats");
+            require(!history.saveOcr(id, L"replacement", settings), "completed OCR is not overwritten");
+            ks::History restored(folder);
+            require(restored.search(L"розпізнаний").size() == 1, "persisted Ukrainian OCR is searchable");
+            require(restored.ocrText(id) == L"Розпізнаний текст HELLO", "OCR text survives restart");
+            auto raw = ks::readFile(folder / (id + L".ocr"), 2 * 1024 * 1024);
+            require(std::string(raw.begin(), raw.end()).find("HELLO") == std::string::npos, "OCR sidecar is encrypted");
+            restored.remove(id);
+            require(!std::filesystem::exists(folder / (id + L".ocr")), "deleting image removes OCR sidecar");
+            require(!restored.saveOcr(id, L"late result", settings), "late OCR cannot resurrect deleted image");
+            restored.add(image, L"OCR test", settings);
+            id = restored.entries().front().id;
+            restored.saveOcr(id, L"", settings);
+            require(restored.ocrText(id).has_value() && restored.ocrText(id)->empty(), "empty OCR is a completed result");
+            restored.clear();
+            require(!std::filesystem::exists(folder / (id + L".ocr")), "clear removes OCR sidecars");
+            restored.add(image, L"OCR test", settings);
+            id = restored.entries().front().id;
+            restored.saveOcr(id, std::nullopt, settings);
+            require(ks::History(folder).entries().front().ocrState == 3, "failed OCR is not retried on every search or restart");
+            restored.saveOcr(id, L"manual retry", settings);
+            require(restored.search(L"manual retry").size() == 1, "explicit retry can recover failed OCR");
+            restored.add(ks::textClip(L"newer"), L"test", settings);
+            auto limited = settings; limited.maxItems = 1;
+            restored.add(ks::textClip(L"newest"), L"test", limited);
+            require(!std::filesystem::exists(folder / (id + L".ocr")), "pruning image removes OCR sidecar");
+        }
+        {
+            ks::Settings options;
+            require(!options.useTesseract, "Tesseract is opt-in by default");
+            options.useTesseract = true;
+            options.tesseractPath = L"C:\\Program Files\\Tesseract-OCR\\tesseract.exe";
+            options.tesseractLanguages = L"ukr+eng+rus";
+            auto restored = ks::decodeSettings(ks::encodeSettings(options), {});
+            require(restored.useTesseract && restored.tesseractPath == options.tesseractPath &&
+                    restored.tesseractLanguages == options.tesseractLanguages, "OCR settings roundtrip");
+            options.tesseractLanguages = L"ukr+../eng";
+            rejects([&] { ks::validateSettings(options); }, "OCR language paths rejected");
+            options.tesseractLanguages = L"ukr++eng";
+            rejects([&] { ks::validateSettings(options); }, "empty OCR language rejected");
+            options.tesseractLanguages = L"ukr+eng";
+            options.tesseractPath = L"C:\\missing-tesseract\\tesseract.exe";
+            rejects([&] { ks::validateTesseract(options); }, "missing optional Tesseract reports clear failure");
+            options.useTesseract = false;
+            ks::validateTesseract(options);
+            require(true, "Windows OCR works without optional installation");
+        }
        // Test-owned directory only; never touch the user's clipboard or stored history.
        std::filesystem::remove_all(temp);
        CoUninitialize();
@@ -3,6 +3,8 @@ from pathlib import Path
 import urllib.request, hashlib, json
 ROOT=Path(__file__).resolve().parents[1]/'dictionaries'
 REV='525f9b560de45753a5ea01069454e72e9aa541c6'
+# Supplemental vocabulary has no corpus frequency: rank after the 50k source list.
+SUPPLEMENTAL={'uk': {'реліз': 50001}}
 ROOT.mkdir(exist_ok=True)
 manifest={}
 for lang in ('en','uk','ru'):
@@ -15,8 +17,12 @@ for lang in ('en','uk','ru'):
        if not (2<=len(word)<=40 and all(c in alphabet for c in word)):continue
        if int(count)<5:continue
        rows.setdefault(word,rank)
+    for word,rank in SUPPLEMENTAL.get(lang,{}).items():
+        rows.setdefault(word,rank)
    out=''.join(f'{word}\t{rows[word]}\n' for word in sorted(rows))
    (ROOT/f'{lang}.txt').write_bytes(out.encode('utf-8'))
    manifest[lang]={'source':url,'sourceSha256':hashlib.sha256(data).hexdigest(),'words':len(rows),'bytes':len(out.encode()),'sha256':hashlib.sha256(out.encode()).hexdigest()}
+    if lang in SUPPLEMENTAL:
+        manifest[lang]['supplementalWords']=SUPPLEMENTAL[lang]
 (ROOT/'sources.json').write_text(json.dumps(manifest,indent=2)+'\n',encoding='utf-8')
 print(json.dumps(manifest,indent=2))
Author	SHA1	Message	Date
agrynco	8b5f632ad7	Release v0.6.10: preserve typing during correction and add personal dictionaries	2026-10-29 22:44:08 +02:00
agrynco	5c786e12a9	Release v0.6.9: notify about updates and fix Settings scroll flicker	2026-10-29 22:15:30 +02:00
agrynco	107d2f8852	Release v0.6.8: add background image OCR and optional Tesseract	2026-10-29 21:40:29 +02:00