feat(wm): add cmds for titlebar removal

This commit introduces some basic commands to read from/add to a whitelist of applications which that user has determined that are safe to remove the titlebar from. Titlebars and removed and added by removing and adding the WS_CAPTION and WS_THICKFRAME styles (this is the approach that Workspacer also takes) from the windows. Wherever possible, the user should prefer native preferences and settings that remove the titlebar in popular apps (Windows Terminal, Firefox etc). re #57
2026-03-10 12:45:58 +01:00 · 2021-10-27 17:37:57 -07:00
227 changed files with 3905 additions and 17792 deletions
--- a/.czrc
+++ b/.czrc
@@ -1,3 +0,0 @@
 {
  "path": "cz-conventional-changelog"
 }
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@@ -1,2 +0,0 @@
 github: LGUG2Z
 ko_fi: lgug2z
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -1,52 +0,0 @@
 ---
 name: Bug report
 about: Create a report to help us improve
 title: "[BUG]: Short descriptive title"
 labels: bug
 assignees: ''
 ---
 **Describe the bug**
 A clear and concise description of what the bug is.
 **To Reproduce**
 Steps to reproduce the behavior:
 1. Go to '...'
 2. Click on '....'
 3. Scroll down to '....'
 4. See bug
 **Expected behavior**
 A clear and concise description of what you expected to happen.
 **Screenshots and Videos**
 Add screenshots and videos to help explain your problem.
 **Operating System**
 Provide the output of `systeminfo | grep "^OS Name\|^OS Version"`
 For example:
 ```
 OS Name:                   Microsoft Windows 11 Pro
 OS Version:                10.0.22000 N/A Build 22000
 ```
 **`komorebic check` Output**
 Provide the output of `komorebic check`
 For example:
 ```
 No KOMOREBI_CONFIG_HOME detected, defaulting to C:\Users\LGUG2Z
 Looking for configuration files in C:\Users\LGUG2Z
 No komorebi configuration found in C:\Users\LGUG2Z
 If running 'komorebic start --await-configuration', you will manually have to call the following command to begin tiling: komorebic complete-configuration
 ```
 **Additional context**
 Add any other context about the problem here.
 In particular, if you have any other AHK scripts or software running that handle any aspect of window management or manipulation
--- a/.github/ISSUE_TEMPLATE/feature_request.md
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@@ -1,20 +0,0 @@
 ---
 name: Feature request
 about: Suggest an idea for this project
 title: "[FEAT]: Short descriptive title"
 labels: enhancement
 assignees: ''
 ---
 **Is your feature request related to a problem? Please describe.**
 A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
 **Describe the solution you'd like**
 A clear and concise description of what you want to happen.
 **Describe alternatives you've considered**
 A clear and concise description of any alternative solutions or features you've considered.
 **Additional context**
 Add any other context or screenshots about the feature request here.
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -13,7 +13,7 @@ updates:
  - package-ecosystem: "cargo"
    directory: "/"
    schedule:
-      interval: "weekly"
+      interval: "monthly"
    assignees:
      - "LGUG2Z"
    commit-message:
--- a/.github/workflows/windows.yaml
+++ b/.github/workflows/windows.yaml
@@ -28,7 +28,7 @@ jobs:
        target:
          - x86_64-pc-windows-msvc
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v2
        with:
          fetch-depth: 0
      - name: Prep cargo dirs
@@ -42,7 +42,7 @@ jobs:
          echo "TARGET=${{ matrix.target }}" | Out-File -Append -FilePath $env:GITHUB_ENV -Encoding utf8
          echo "SKIP_TESTS=" | Out-File -Append -FilePath $env:GITHUB_ENV -Encoding utf8
      - name: Cache cargo registry, git trees and binaries
-        uses: actions/cache@v4
+        uses: actions/cache@v2
        with:
          path: |
            ~/.cargo/registry
@@ -55,7 +55,7 @@ jobs:
          echo "::set-output name=rust_hash::$(rustc -Vv | grep commit-hash | awk '{print $2}')"
        shell: bash
      - name: Cache cargo build
-        uses: actions/cache@v4
+        uses: actions/cache@v2
        with:
          path: target
          key: ${{ github.base_ref }}-${{ github.head_ref }}-${{ matrix.target }}-cargo-target-dir-${{ steps.cargo-target-cache.outputs.rust_hash }}-${{ hashFiles('**/Cargo.lock') }}
@@ -73,67 +73,29 @@ jobs:
      - name: Install the target
        run: |
          rustup target install ${{ matrix.target }}
      - name: Run Cargo checks
        run: |
          cargo fmt --check
          cargo check
          cargo clippy
      - name: Run a full build
        run: |
          cargo build --locked --release --target ${{ matrix.target }}
      - name: Create MSI installer
        run: |
          cargo install cargo-wix
          cargo wix -p komorebi --nocapture -I .\wix\main.wxs --target x86_64-pc-windows-msvc
      - name: Upload the built artifacts
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v2
        with:
          name: komorebi-${{ matrix.target }}
          path: |
            target/${{ matrix.target }}/release/komorebi.exe
            target/${{ matrix.target }}/release/komorebic.exe
            target/${{ matrix.target }}/release/komorebic-no-console.exe
            target/${{ matrix.target }}/release/komorebi.pdb
            target/${{ matrix.target }}/release/komorebic.pdb
            target/${{ matrix.target }}/release/komorebic-no-console.pdb
            target/wix/komorebi-*.msi
          retention-days: 7
      - name: Check GoReleaser
        uses: goreleaser/goreleaser-action@v3
        with:
          version: latest
          args: build --skip=validate --clean
      # Release
      - name: Generate changelog
-        if: startsWith(github.ref, 'refs/tags/v')
+        if: startsWith(github.ref, 'refs/tags/')
        shell: bash
        run: |
          if ! type kokai >/dev/null; then cargo install --locked kokai --force; fi
          kokai release --no-emoji --add-links github:commits,issues --ref "$(git tag --points-at HEAD)" >"CHANGELOG.md"
      - name: Run GoReleaser
-        uses: goreleaser/goreleaser-action@v3
+        uses: goreleaser/goreleaser-action@v2
-        if: startsWith(github.ref, 'refs/tags/v')
+        if: startsWith(github.ref, 'refs/tags/')
        with:
          version: latest
-          args: release --skip=validate --clean --release-notes=CHANGELOG.md
+          args: release --skip-validate --rm-dist --release-notes=CHANGELOG.md
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          SCOOP_TOKEN: ${{ secrets.SCOOP_TOKEN }}
      - name: Add MSI to release
        uses: softprops/action-gh-release@v2
        if: startsWith(github.ref, 'refs/tags/v')
        with:
          files: "target/wix/komorebi-*.msi"
  winget:
    name: Publish to WinGet
    runs-on: ubuntu-latest
    needs: build
    if: startsWith(github.ref, 'refs/tags/v')
    steps:
      - uses: vedantmgoyal2009/winget-releaser@v2
        with:
          identifier: LGUG2Z.komorebi
          token: ${{ secrets.WINGET_TOKEN }}
--- a/.gitignore
+++ b/.gitignore
@@ -3,5 +3,4 @@
 /target
 CHANGELOG.md
 dummy.go
-komorebi.ahk
+komorebi.ahk
 komorebic/applications.yaml
--- a/.goreleaser.yml
+++ b/.goreleaser.yml
@@ -16,7 +16,7 @@ builds:
    hooks:
      post:
        - mkdir -p dist/windows_amd64
-        - cp ".\target\x86_64-pc-windows-msvc\release\komorebi.exe" ".\dist\komorebi_windows_amd64_v1\komorebi.exe"
+        - cp ".\target\x86_64-pc-windows-msvc\release\komorebi.exe" ".\dist\komorebi_windows_amd64\komorebi.exe"
  - id: komorebic
    main: dummy.go
    goos: ["windows"]
@@ -25,22 +25,17 @@ builds:
    hooks:
      post:
        - mkdir -p dist/windows_amd64
-        - cp ".\target\x86_64-pc-windows-msvc\release\komorebic.exe" ".\dist\komorebic_windows_amd64_v1\komorebic.exe"
+        - cp ".\target\x86_64-pc-windows-msvc\release\komorebic.exe" ".\dist\komorebic_windows_amd64\komorebic.exe"
  - id: komorebic-no-console
    main: dummy.go
    goos: ["windows"]
    goarch: ["amd64"]
    binary: komorebic-no-console
    hooks:
      post:
        - mkdir -p dist/windows_amd64
        - cp ".\target\x86_64-pc-windows-msvc\release\komorebic-no-console.exe" ".\dist\komorebic-no-console_windows_amd64_v1\komorebic-no-console.exe"
 archives:
-  - name_template: "{{ .ProjectName }}-{{ .Version }}-x86_64-pc-windows-msvc"
+  - replacements:
      windows: pc-windows-msvc
      amd64: x86_64
    format: zip
    name_template: "{{ .ProjectName }}-{{ .Version }}-{{ .Arch }}-{{ .Os }}"
    files:
      - LICENSE
      - komorebi.sample.ahk
      - CHANGELOG.md
 checksum:
@@ -48,3 +43,18 @@ checksum:
 changelog:
  sort: asc
 scoop:
  bucket:
    owner: LGUG2Z
    name: komorebi-bucket
    token: "{{ .Env.SCOOP_TOKEN }}"
  homepage: https://github.com/LGUG2Z/komorebi
  description: A tiling window manager for Windows
  license: MIT
  pre_install:
    - if (Get-Process -Name komorebi -ErrorAction SilentlyContinue) { komorebic stop }
  post_install:
    - Write-Host "`nRun 'cp $original_dir\komorebi.sample.ahk $Env:UserProfile\komorebi.ahk' to get started with the sample configuration"
    - Write-Host "`nRun 'komorebic ahk-library' if you would like to generate an AHK helper library to use in your configuration"
    - Write-Host "`nOnce you have a configuration file in place, you can run 'komorebic start' to start the window manager"
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,40 +1,9 @@
 [workspace]
 resolver = "2"
 members = [
    "bindings",
    "derive-ahk",
    "komorebi",
    "komorebi-client",
    "komorebi-core",
-    "komorebic",
+    "komorebic"
    "komorebic-no-console",
 ]
 [workspace.dependencies]
 windows-interface = { version = "0.53" }
 windows-implement = { version = "0.53" }
 dunce = "1"
 dirs = "5"
 color-eyre = "0.6"
 serde_json = { package = "serde_json_lenient", version = "0.1" }
 [workspace.dependencies.windows]
 version = "0.54"
 features = [
    "implement",
    "Win32_System_Com",
    "Win32_UI_Shell_Common", # for IObjectArray
    "Win32_Foundation",
    "Win32_Graphics_Dwm",
    "Win32_Graphics_Gdi",
    "Win32_System_LibraryLoader",
    "Win32_System_RemoteDesktop",
    "Win32_System_Threading",
    "Win32_UI_Accessibility",
    "Win32_UI_HiDpi",
    "Win32_UI_Input_KeyboardAndMouse",
    "Win32_UI_Shell",
    "Win32_UI_Shell_Common",
    "Win32_UI_WindowsAndMessaging",
    "Win32_System_SystemServices"
 ]
--- a/README.md
+++ b/README.md
@@ -2,175 +2,415 @@
 Tiling Window Management for Windows.
-<p>
+![screenshot](https://i.ibb.co/BTqNS45/komorebi.png)
  <a href="https://techforpalestine.org/learn-more">
    <img alt="Tech for Palestine" src="https://badge.techforpalestine.org/default">
  </a>
  <img alt="GitHub Workflow Status" src="https://img.shields.io/github/actions/workflow/status/LGUG2Z/komorebi/.github/workflows/windows.yaml">
  <img alt="GitHub" src="https://img.shields.io/github/license/LGUG2Z/komorebi">
  <img alt="GitHub all releases" src="https://img.shields.io/github/downloads/LGUG2Z/komorebi/total">
  <img alt="GitHub commits since latest release (by date) for a branch" src="https://img.shields.io/github/commits-since/LGUG2Z/komorebi/latest">
  <a href="https://discord.gg/mGkn66PHkx">
    <img alt="Discord" src="https://img.shields.io/discord/898554690126630914">
  </a>
  <a href="https://github.com/sponsors/LGUG2Z">
    <img alt="GitHub Sponsors" src="https://img.shields.io/github/sponsors/LGUG2Z">
  </a>
  <a href="https://ko-fi.com/lgug2z">
    <img alt="Ko-fi" src="https://img.shields.io/badge/kofi-tip-green">
  </a>
  <a href="https://notado.app/feeds/jado/software-development">
    <img alt="Notado Feed" src="https://img.shields.io/badge/Notado-Subscribe-informational">
  </a>
  <a href="https://www.youtube.com/channel/UCeai3-do-9O4MNy9_xjO6mg?sub_confirmation=1">
    <img alt="YouTube" src="https://img.shields.io/youtube/channel/subscribers/UCeai3-do-9O4MNy9_xjO6mg">
  </a>
 </p>
-![screenshot](https://user-images.githubusercontent.com/13164844/184027064-f5a6cec2-2865-4d65-a549-a1f1da589abf.png)
+## About
-_komorebi_ is a tiling window manager that works as an extension to Microsoft's
+_komorebi_ is a tiling window manager that works as an extension to
-[Desktop Window
+Microsoft's [Desktop Window Manager](https://docs.microsoft.com/en-us/windows/win32/dwm/dwm-overview) in Windows 10 and
-Manager](https://docs.microsoft.com/en-us/windows/win32/dwm/dwm-overview) in
+above.
 Windows 10 and above.
 _komorebi_ allows you to control application windows, virtual workspaces and display monitors with a CLI which can be
-used with third-party software such as [`whkd`](https://github.com/LGUG2Z/whkd)
+used with third-party software such as [AutoHotKey](https://github.com/Lexikos/AutoHotkey_L) to set user-defined
-and [AutoHotKey](https://github.com/Lexikos/AutoHotkey_L) to set user-defined keyboard shortcuts.
+keyboard shortcuts.
-_komorebi_ aims to make _as few modifications as possible_ to the operating
+Translations of this document can be found in the project wiki:
 system and desktop environment by default. Users are free to make such
 modifications in their own configuration files for _komorebi_, but these will
 remain opt-in and off-by-default for the foreseeable future.
-Please refer to the [documentation](https://lgug2z.github.io/komorebi) for instructions on how
+- [komorebi 中文用户指南](https://github.com/LGUG2Z/komorebi/wiki/README-zh) (by [@crosstyan](https://github.com/crosstyan))
 to [install](https://lgug2z.github.io/komorebi/installation.html) and
 [configure](https://lgug2z.github.io/komorebi/example-configurations.html)
 _komorebi_, [common workflows](https://lgug2z.github.io/komorebi/common-workflows/komorebi-config-home.html), a complete
 [configuration schema reference](https://komorebi.lgug2z.com/schema) and a
 complete [CLI reference](https://lgug2z.github.io/komorebi/cli/quickstart.html).
-There is a [Discord server](https://discord.gg/mGkn66PHkx) available for
+There is a [Discord server](https://discord.gg/vzBmPm6RkQ) available for _komorebi_-related discussion, help,
-_komorebi_-related discussion, help, troubleshooting etc. If you have any
+troubleshooting etc. If you have any specific feature requests or bugs to report, please create an issue in this
 specific feature requests or bugs to report, please create an issue in this
 repository.
-There is a [YouTube
+## Description
 channel](https://www.youtube.com/channel/UCeai3-do-9O4MNy9_xjO6mg) where I post
 _komorebi_ development videos. If you would like to be notified of upcoming
 videos please subscribe and turn on notifications.
-_komorebi_ is a free and open-source project, and one that encourages you to
+_komorebi_ only responds to [WinEvents](https://docs.microsoft.com/en-us/windows/win32/winauto/event-constants) and the
-make charitable donations if you find the software to be useful and have the
+messages it receives on a dedicated socket.
 financial means.
-I encourage you to make a charitable donation to the [Palestine Children's
+_komorebic_ is a CLI that writes messages on _komorebi_'s socket.
 Relief Fund](https://pcrf1.app.neoncrm.com/forms/gaza-recovery) before you
 consider sponsoring me on GitHub.
-[GitHub Sponsors is enabled for this
+_komorebi_ doesn't handle any keyboard or mouse inputs; a third party program (e.g. AutoHotKey) is needed in order to
-project](https://github.com/sponsors/LGUG2Z). Unfortunately I don't have
+translate keyboard and mouse events to _komorebic_ commands.
 anything specific to offer besides my gratitude and shout outs at the end of
 _komorebi_ live development videos and tutorials.
-If you would like to tip or sponsor the project but are unable to use GitHub
+This architecture, popularised by [_bspwm_](https://github.com/baskerville/bspwm) on Linux and
-Sponsors, you may also sponsor through [Ko-fi](https://ko-fi.com/lgug2z).
+[_yabai_](https://github.com/koekeishiya/yabai) on macOS, is outlined as follows:
-# Installation
+```
     PROCESS                SOCKET
 ahk  -------->  komorebic  <------>  komorebi
 ```
-A [detailed installation and quickstart
+## Design
 guide](https://lgug2z.github.io/komorebi/installation.html) is available which shows how to get started
 using `scoop`, `winget` or building from source.
-[![Watch the quickstart walkthrough video](https://img.youtube.com/vi/H9-_c1egQ4g/hqdefault.jpg)](https://www.youtube.com/watch?v=H9-_c1egQ4g)
+_komorebi_ is the successor to [_yatta_](https://github.com/LGUG2Z/yatta) and as such aims to build on the learnings
 from that project.
-# Demonstrations
+While _yatta_ was primary an attempt to learn how to work with and call Windows APIs from Rust, while secondarily
 implementing a minimal viable tiling window manager for my own needs (largely single monitor, single workspace),
 _komorebi_ has been redesigned from the ground-up to support more complex features that have become standard in tiling
 window managers on other platforms.
-[@haxibami](https://github.com/haxibami) showing _komorebi_ running on Windows
+_komorebi_ holds a list of physical monitors.
 11 with a terminal emulator, a web browser and a code editor. The original
 video can be viewed
 [here](https://twitter.com/haxibami/status/1501560766578659332).
-https://user-images.githubusercontent.com/13164844/163496447-20c3ff0a-c5d8-40d1-9cc8-156c4cebf12e.mp4
+A monitor is just a rectangle of the available work area which contains one or more virtual workspaces.
-[@aik2mlj](https://github.com/aik2mlj) showing _komorebi_ running on Windows 11
+A workspace holds a list of containers.
 with multiple workspaces, terminal emulators, a web browser, and the
 [yasb](https://github.com/DenBot/yasb) status bar with the _komorebi_ workspace
 widget enabled. The original video can be viewed
 [here](https://zhuanlan.zhihu.com/p/455064481).
-https://user-images.githubusercontent.com/13164844/163496414-a9cde3d1-b8a7-4a7a-96fb-a8985380bc70.mp4
+A container is just a rectangle where one or more application windows can be displayed.
-# Contribution Guidelines
+This means that:
-If you would like to contribute to `komorebi` please take the time to carefully read the guidelines below.
+- Every monitor has its own collection of virtual workspaces
 - Workspaces only know about containers and their dimensions, not about individual application windows
 - Every application window must belong to a container, even if that container only contains one application window
 - Many application windows can be stacked and cycled through in the same container within a workspace
-## Commit hygiene
+## Getting Started
 ### GitHub Releases
 Prebuilt binaries are available on the [releases page](https://github.com/LGUG2Z/komorebi/releases) in a `zip` archive.
 Once downloaded, you will need to move the `komorebi.exe` and `komorebic.exe` binaries to a directory in your `Path` (
 you can see these directories by running `$Env:Path.split(";")` at a PowerShell prompt).
 Alternatively, you may add a new directory to your `Path`
 using [`setx`](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/setx) or the Environment
 Variables pop up in System Properties Advanced (which can be launched with `SystemPropertiesAdvanced.exe` at a
 PowerShell prompt), and then move the binaries to that directory.
 ### Scoop
 If you use the [Scoop](https://scoop.sh/) command line installer, you can run the following commands to install the
 binaries from the latest GitHub Release:
 ```
 scoop bucket add komorebi https://github.com/LGUG2Z/komorebi-bucket
 scoop install komorebi
 ```
 If you install _komorebi_ using Scoop, the binaries will automatically be added to your `Path` and a command will be
 shown for you to run in order to get started using the sample configuration file.
 ### Building from Source
 If you prefer to compile _komorebi_ from source, you will need
 a [working Rust development environment on Windows 10](https://rustup.rs/). The `x86_64-pc-windows-msvc` toolchain is
 required, so make sure you have also installed
 the [Build Tools for Visual Studio 2019](https://stackoverflow.com/a/55603112).
 You can then clone this repo and compile the source code to install the binaries for `komorebi` and `komorebic`:
 ```powershell
 cargo install --path komorebi --locked
 cargo install --path komorebic --locked
 ```
 ### Running
 Once you have either the prebuilt binaries in your `Path`, or have compiled the binaries from source (these will already
 be in your `Path` if you installed Rust with [rustup](https://rustup.rs), which you absolutely should), you can
 run `komorebic start` at a Powershell prompt, and you will see the following output:
 ```
 Start-Process komorebi -WindowStyle hidden
 ```
 This means that `komorebi` is now running in the background, tiling all your windows, and listening for commands sent to
 it by `komorebic`. You can similarly stop the process by running `komorebic stop`.
 ### Configuring
 Once `komorebi` is running, you can execute the `komorebi.sample.ahk` script to set up the default keybindings via AHK
 (the file includes comments to help you start building your own configuration).
 If you have AutoHotKey installed and a `komorebi.ahk` file in your home directory (run `$Env:UserProfile` at a
 PowerShell prompt to find your home directory), `komorebi` will automatically try to load it when starting.
 There is also tentative support for loading a AutoHotKey v2 files, if the file is named `komorebi.ahk2` and
 the `AutoHotKey64.exe` executable for AutoHotKey v2 is in your `Path`. If both `komorebi.ahk` and `komorebi.ahk2` files
 exist in your home directory, only `komorebi.ahk` will be loaded. An example of an AutoHotKey v2 configuration file
 for _komorebi_ can be found [here](https://gist.github.com/crosstyan/dafacc0778dabf693ce9236c57b201cd).
 ### Common First-Time Tips
 #### Floating Windows
 Sometimes you will want a specific application to never be tiled, and instead float all the time. You add add rules to
 enforce this behaviour:
 ```powershell
 komorebic.exe float-rule title "Control Panel"
 # komorebic.exe float-rule exe [EXE NAME]
 # komorebic.exe float-rule class [CLASS NAME]
 ```
 #### Windows Not Getting Managed
 In some rare cases, a window may not automatically be registered to be managed by `komorebi`. When this happens, you can
 manually add a rule to force `komorebi` to manage it:
 ```powershell
 komorebic.exe manage-rule exe TIM.exe
 # komorebic.exe manage-rule class [CLASS NAME]
 # komorebic.exe manage-rule title [TITLE]
 ```
 #### Tray Applications
 If you are experiencing behaviour where
 [closing a window leaves a blank tile, but minimizing the same window does not](https://github.com/LGUG2Z/komorebi/issues/6)
 , you have probably enabled a 'close/minimize to tray' option for that application. You can tell _komorebi_ to handle
 this application appropriately by identifying it via the executable name or the window class:
 ```powershell
 komorebic.exe identify-tray-application exe Discord.exe
 # komorebic.exe identify-tray-application class [CLASS NAME]
 # komorebic.exe identify-tray-application title [TITLE]
 ```
 #### Focus Follows Mouse
 `komorebi` supports two focus-follows-mouse implementations; the native Windows Xmouse implementation, which treats the
 desktop, the task bar, and the system tray as windows and switches focus to them eagerly, and a custom `komorebi`
 implementation, which only considers windows managed by `komorebi` as valid targets to switch focus to when moving the
 mouse.
 To enable the `komorebi` implementation you must start the process with the `--ffm` flag to explicitly enable the feature.
 This is because the mouse tracking required for this feature significantly increases the CPU usage of the process (on my
 machine, it jumps from <1% to ~4~), and this CPU increase persists regardless of whether focus-follows-mouse is enabled
 or disabled at any given time via `komorebic`'s configuration commands.
 When calling any of the `komorebic` commands related to focus-follows-mouse functionality, the `windows`
 implementation will be chosen as the default implementation. You can optionally specify the `komorebi` implementation by
 passing it as an argument to the `--implementation` flag:
 ```powershell
 komorebic.exe toggle-focus-follows-mouse --implementation komorebi
 ```
 #### Saving and Loading Resized Layouts
 If you create a BSP layout through various resize adjustments that you want to be able to restore easily in the future,
 it is possible to "quicksave" that layout to the system's temporary folder and load it later in the same session, or
 alternatively, you may save it to a specific file to be loaded again at any point in the future.
 ```powershell
 komorebic.exe quick-save # saves the focused workspace to $Env:TEMP\komorebi.quicksave.json
 komorebic.exe quick-load # loads $Env:TEMP\komorebi.quicksave.json on the focused workspace
 komorebic.exe save ~/layouts/primary.json # saves the focused workspace to $Env:USERPROFILE\layouts\primary.json
 komorebic.exe load ~/layouts/secondary.json # loads $Env:USERPROFILE\layouts\secondary.json on the focused workspace
 ```
 These layouts can be applied to arbitrary collections of windows on any workspace, as they only track the layout
 dimensions and are not coupled to the applications that were running at the time of saving.
 When layouts that expect more or less windows than the number currently on the focused workspace are loaded, `komorebi`
 will automatically reconcile the difference.
 #### Creating and Loading Custom Layouts
 Particularly for users of ultrawide monitors, traditional tiling layouts may not seem like the most efficient use of
 screen space. If you feel this is the case with any of the default layouts, you are also welcome to create your own
 custom layouts and save them as JSON or YAML.
 If you're not comfortable writing the layouts directly in JSON or YAML, you can use
 the [komorebi Custom Layout Generator](https://lgug2z.github.io/komorebi-custom-layout-generator/) to interactively
 define a custom layout, and then copy the generated JSON content.
 Custom layouts can be loaded on the current workspace or configured for a specific workspace with the following
 commands:
 ```powershell
 komorebic.exe load-custom-layout ~/custom.yaml
 komorebic.exe workspace-custom-layout 0 0 ~/custom.yaml
 ```
 The fundamental building block of a custom _komorebi_ layout is the Column.
 Columns come in three variants:
 - **Primary**: This is where your primary focus will be on the screen most of the time. There must be exactly one Primary
  Column in any custom layout. Optionally, you can specify the percentage of the screen width that you want the Primary
  Column to occupy.
 - **Secondary**: This is an optional column that can either be full height of split horizontally into a fixed number of
  maximum rows. There can be any number of Secondary Columns in a custom layout.
 - **Tertiary**: This is the final column where any remaining windows will be split horizontally into rows as they get added.
 If there is only one window on the screen when a custom layout is selected, that window will take up the full work area
 of the screen.
 If the number of windows is equal to or less than the total number of columns defined in a custom layout, the windows
 will be arranged in an equal-width columns.
 When the number of windows is greater than the number of columns defined in the custom layout, the windows will begin to
 be arranged according to the constraints set on the Primary and Secondary columns of the layout.
 Here is an example custom layout that can be used as a starting point for your own:
 YAML
 ```yaml
 - column: Secondary
  configuration:
    Horizontal: 2 # max number of rows,
 - column: Primary
  configuration:
    WidthPercentage: 45 # percentage of screen
 - column: Tertiary
  configuration: Horizontal
 ```
 ## Configuration with `komorebic`
 As previously mentioned, this project does not handle anything related to keybindings and shortcuts directly. I
 personally use AutoHotKey to manage my window management shortcuts, and have provided a
 sample [komorebi.ahk](komorebi.sample.ahk) AHK script that you can use as a starting point for your own.
 You can run `komorebic.exe` to get a full list of the commands that you can use to customise `komorebi` and create
 keybindings with. You can run `komorebic.exe <COMMAND> --help` to get a full explanation of the arguments required for
 each command.
 ```
 start                         Start komorebi.exe as a background process
 stop                          Stop the komorebi.exe process and restore all hidden windows
 state                         Show a JSON representation of the current window manager state
 query                         Query the current window manager state
 subscribe                     Subscribe to komorebi events
 unsubscribe                   Unsubscribe from komorebi events
 log                           Tail komorebi.exe's process logs (cancel with Ctrl-C)
 quick-save                    Quicksave the current resize layout dimensions
 quick-load                    Load the last quicksaved resize layout dimensions
 save                          Save the current resize layout dimensions to a file
 load                          Load the resize layout dimensions from a file
 focus                         Change focus to the window in the specified direction
 move                          Move the focused window in the specified direction
 cycle-focus                   Change focus to the window in the specified cycle direction
 cycle-move                    Move the focused window in the specified cycle direction
 stack                         Stack the focused window in the specified direction
 resize                        Resize the focused window in the specified direction
 unstack                       Unstack the focused window
 cycle-stack                   Cycle the focused stack in the specified cycle direction
 move-to-monitor               Move the focused window to the specified monitor
 move-to-workspace             Move the focused window to the specified workspace
 send-to-monitor               Send the focused window to the specified monitor
 send-to-workspace             Send the focused window to the specified workspace
 focus-monitor                 Focus the specified monitor
 focus-workspace               Focus the specified workspace on the focused monitor
 cycle-monitor                 Focus the monitor in the given cycle direction
 cycle-workspace               Focus the workspace in the given cycle direction
 new-workspace                 Create and append a new workspace on the focused monitor
 invisible-borders             Set the invisible border dimensions around each window
 work-area-offset              Set offsets to exclude parts of the work area from tiling
 adjust-container-padding      Adjust container padding on the focused workspace
 adjust-workspace-padding      Adjust workspace padding on the focused workspace
 change-layout                 Set the layout on the focused workspace
 load-custom-layout            Load a custom layout from file for the focused workspace
 flip-layout                   Flip the layout on the focused workspace (BSP only)
 promote                       Promote the focused window to the top of the tree
 retile                        Force the retiling of all managed windows
 ensure-workspaces             Create at least this many workspaces for the specified monitor
 container-padding             Set the container padding for the specified workspace
 workspace-padding             Set the workspace padding for the specified workspace
 workspace-layout              Set the layout for the specified workspace
 workspace-custom-layout       Set a custom layout for the specified workspace
 workspace-tiling              Enable or disable window tiling for the specified workspace
 workspace-name                Set the workspace name for the specified workspace
 toggle-pause                  Toggle the window manager on and off across all monitors
 toggle-tiling                 Toggle window tiling on the focused workspace
 toggle-float                  Toggle floating mode for the focused window
 toggle-monocle                Toggle monocle mode for the focused container
 toggle-maximize               Toggle native maximization for the focused window
 restore-windows               Restore all hidden windows (debugging command)
 manage                        Force komorebi to manage the focused window
 unmanage                      Unmanage a window that was forcibly managed
 reload-configuration          Reload ~/komorebi.ahk (if it exists)
 watch-configuration           Enable or disable watching of ~/komorebi.ahk (if it exists)
 float-rule                    Add a rule to always float the specified application
 manage-rule                   Add a rule to always manage the specified application
 workspace-rule                Add a rule to associate an application with a workspace
 identify-tray-application     Identify an application that closes to the system tray
 identify-border-overflow      Identify an application that has overflowing borders
 focus-follows-mouse           Enable or disable focus follows mouse for the operating system
 toggle-focus-follows-mouse    Toggle focus follows mouse for the operating system
 ahk-library                   Generate a library of AutoHotKey helper functions
 help                          Print this message or the help of the given subcommand(s)
 ```
 ### AutoHotKey Helper Library for `komorebic`
 Additionally, you may run `komorebic.exe ahk-library` to
 generate [a helper library for AutoHotKey](komorebic.lib.sample.ahk) which wraps every `komorebic` command in a native
 AHK function.
 If you include the generated library at the top of your `~/komorebi.ahk` configuration file, you will be able to call
 any of the functions that it contains. A sample AHK script that shows how this library can be
 used [is available here](komorebi.sample.with.lib.ahk).
 ## Features
 - [x] Multi-monitor
 - [x] Virtual workspaces
 - [x] Window stacks
 - [x] Cycle through stacked windows
 - [x] Change focused window by direction
 - [x] Move focused window container in direction
 - [x] Move focused window container to monitor and follow
 - [x] Move focused window container to workspace follow
 - [x] Send focused window container to monitor
 - [x] Send focused window container to workspace
 - [x] Mouse follows focused container
 - [x] Resize window container in direction
 - [ ] Resize child window containers by split ratio
 - [x] Quicksave and quickload layouts with resize dimensions
 - [x] Save and load layouts with resize dimensions to/from specific files
 - [x] Mouse drag to swap window container position
 - [x] Mouse drag to resize window container
 - [x] Configurable workspace and container gaps
 - [x] BSP tree layout (`bsp`)
 - [x] Flip BSP tree layout horizontally or vertically
 - [x] Equal-width, max-height column layout (`columns`)
 - [x] Equal-height, max-width row layout (`rows`)
 - [x] Main half-height window with vertical stack layout (`horizontal-stack`)
 - [x] Main half-width window with horizontal stack layout (`vertical-stack`)
 - [x] 2x Main window (half and quarter-width) with horizontal stack layout (`ultrawide-vertical-stack`)
 - [x] Load custom layouts from JSON and YAML representations
 - [x] Floating rules based on exe name, window title and class
 - [x] Workspace rules based on exe name and window class
 - [x] Additional manage rules based on exe name and window class
 - [x] Identify applications which overflow their borders by exe name and class
 - [x] Identify 'close/minimize to tray' applications by exe name and class
 - [x] Configure work area offsets to preserve space for custom taskbars
 - [x] Configure and compensate for the size of Windows 10's invisible borders
 - [x] Toggle floating windows
 - [x] Toggle monocle window
 - [x] Toggle native maximization
 - [x] Toggle Xmouse/Windows focus follows mouse implementation
 - [x] Toggle Komorebi focus follows mouse implementation (desktop and system tray-aware)
 - [x] Toggle automatic tiling
 - [x] Pause all window management
 - [x] Load configuration on startup
 - [x] Manually reload configuration
 - [x] Watch configuration for changes
 - [x] Helper library for AutoHotKey
 - [x] View window manager state
 - [x] Query window manager state
 - [x] Subscribe to event and message notifications
 ## Development
 If you would like to contribute code to this repository, there are a few requests that I have to ensure a foundation of
 code quality, consistency and commit hygiene:
 - Flatten all `use` statements
- Run `cargo +stable clippy` and ensure that all lints and suggestions have been addressed before committing
+- Run `cargo +nightly clippy` and ensure that all lints and suggestions have been addressed before committing
 - Run `cargo +nightly fmt --all` to ensure consistent formatting before committing
 - Use `git cz` with
  the [Commitizen CLI](https://github.com/commitizen/cz-cli#conventional-commit-messages-as-a-global-utility) to prepare
  commit messages
- Provide **at least** one short sentence or paragraph in your commit message body to describe your thought process for the
+- Provide at least one short sentence or paragraph in your commit message body to describe your thought process for the
  changes being committed
 ## PRs should contain only a single feature or bug fix
 It is very difficult to review pull requests which touch multiple unrelated features and parts of the codebase.
 Please do not submit pull requests like this; you will be asked to separate them into smaller PRs that deal only with
 one feature or bug fix at a time.
 If you are working on multiple features and bug fixes, I suggest that you cut a branch called `local-trunk`
 from `master` which you keep up to date, and rebase the various independent branches you are working on onto that branch
 if you want to test them together or create a build with everything integrated.
 ## Refactors to the codebase must have prior approval
 `komorebi` is a mature codebase with an internal consistency and structure that has developed organically over close to
 half a decade.
 There are [countless hours of live coding videos](https://youtube.com/@LGUG2Z) demonstrating work on this project and
 showing new contributors how to do everything from basic tasks like implementing new `komorebic` commands to
 distinguishing monitors by manufacturer hardware identifiers and video card ports.
 Refactors to the structure of the codebase are not taken lightly and require prior discussion and approval.
 Please do not start refactoring the codebase with the expectation of having your changes integrated until you receive an
 explicit approval or a request to do so.
 Similarly, when implementing features and bug fixes, please stick to the structure of the codebase as much as possible
 and do not take this as an opportunity to do some "refactoring along the way".
 It is extremely difficult to review PRs for features and bug fixes if they are lost in sweeping changes to the structure
 of the codebase.
 ## Breaking changes to user-facing interfaces are unacceptable
 This includes but is not limited to:
 - All `komorebic` commands
 - The `komorebi.json` schema
 - The [`komorebi-application-specific-configuration`](https://github.com/LGUG2Z/komorebi-application-specific-configuration)
  schema
 No user should ever find that their configuration file has stopped working after upgrading to a new version
 of `komorebi`.
 More often than not there are ways to reformulate changes that may initially seem like they require breaking user-facing
 interfaces into additive changes.
 For some inspiration please take a look
 at [this commit](https://github.com/LGUG2Z/komorebi/commit/e7d928a065eb63bb4ea1fb864c69c1cae8cc763b) which added the
 ability for users to specify colours in `komorebi.json` in Hex format alongside RGB.
 There is also a process in place for graceful, non-breaking, deprecation of configuration options that are no longer
 required.
 # Development
 If you use IntelliJ, you should enable the following settings to ensure that code generated by macros is recognised by
 the IDE for completions and navigation:
@@ -180,23 +420,23 @@ the IDE for completions and navigation:
  - `org.rust.cargo.evaluate.build.scripts`
  - `org.rust.macros.proc`
-# Logs and Debugging
+## Logs and Debugging
-Logs from `komorebi` will be appended to `%LOCALAPPDATA%/komorebi/komorebi.log`; this file is never rotated or overwritten, so it will keep
+Logs from `komorebi` will be appended to `~/komorebi.log`; this file is never rotated or overwritten, so it will keep
 growing until it is deleted by the user.
 Whenever running the `komorebic stop` command or sending a Ctrl-C signal to `komorebi` directly, the `komorebi` process
 ensures that all hidden windows are restored before termination.
 If however, you ever end up with windows that are hidden and cannot be restored, a list of window handles known
-to `komorebi` are stored and continuously updated in `%LOCALAPPDATA%/komorebi//komorebi.hwnd.json`.
+to `komorebi` are stored and continuously updated in `~/komorebi.hwnd.json`.
-## Restoring Windows
+### Restoring Windows
 Running `komorebic restore-windows` will read the list of window handles and forcibly restore them, regardless of
 whether the main `komorebi` process is running.
-## Panics and Deadlocks
+### Panics and Deadlocks
 If `komorebi` ever stops responding, it is most likely either due to either a panic or a deadlock. In the case of a
 panic, this will be reported in the log. In the case of a deadlock, there will not be any errors in the log, but the
@@ -206,24 +446,23 @@ If you believe you have encountered a deadlock, you can compile `komorebi` with
 reproducing the deadlock again. This will check for deadlocks every 5 seconds in the background, and if a deadlock is
 found, information about it will appear in the log which can be shared when opening an issue.
-# Window Manager State and Integrations
+## Window Manager State and Integrations
 The current state of the window manager can be queried using the `komorebic state` command, which returns a JSON
-representation of the `State` struct.
+representation of the `State` struct, which includes the current state of `WindowManager`.
-This may also be polled to build further integrations and widgets on top of.
+This may also be polled to build further integrations and widgets on top of (if you ever wanted to build something
 like [Stackline](https://github.com/AdamWagner/stackline) for Windows, you could do it by polling this command).
-# Window Manager Event Subscriptions
+## Window Manager Event Subscriptions
-## Named Pipes
+It is also possible to subscribe to notifications of every `WindowManagerEvent` and `SocketMessage` handled
 It is possible to subscribe to notifications of every `WindowManagerEvent` and `SocketMessage` handled
 by `komorebi` using [Named Pipes](https://docs.microsoft.com/en-us/windows/win32/ipc/named-pipes).
 First, your application must create a named pipe. Once the named pipe has been created, run the following command:
 ```powershell
-komorebic.exe subscribe-pipe <your pipe name>
+komorebic.exe subscribe <your pipe name>
 ```
 Note that you do not have to include the full path of the named pipe, just the name.
@@ -231,180 +470,22 @@ Note that you do not have to include the full path of the named pipe, just the n
 If the named pipe exists, `komorebi` will start pushing JSON data of successfully handled events and messages:
 ```json lines
-{"event":{"type":"AddSubscriber","content":"yasb"},"state":{}}
+{"event":{"type":"AddSubscriber","content":"yasb"},"state":{...}}
-{"event":{"type":"FocusWindow","content":"Left"},"state":{}}
+{"event":{"type":"FocusWindow","content":"Left"},"state":{...}}
-{"event":{"type":"FocusChange","content":["SystemForeground",{"hwnd":131444,"title":"komorebi – README.md","exe":"idea64.exe","class":"SunAwtFrame","rect":{"left":13,"top":60,"right":1520,"bottom":1655}}]},"state":{}}
+{"event":{"type":"FocusChange","content":["SystemForeground",{"hwnd":131444,"title":"komorebi – README.md","exe":"idea64.exe","class":"SunAwtFrame","rect":{"left":13,"top":60,"right":1520,"bottom":1655}}]},"state":{...}}
-{"event":{"type":"MonitorPoll","content":["ObjectCreate",{"hwnd":5572450,"title":"OLEChannelWnd","exe":"explorer.exe","class":"OleMainThreadWndClass","rect":{"left":0,"top":0,"right":0,"bottom":0}}]},"state":{}}
+{"event":{"type":"MonitorPoll","content":["ObjectCreate",{"hwnd":5572450,"title":"OLEChannelWnd","exe":"explorer.exe","class":"OleMainThreadWndClass","rect":{"left":0,"top":0,"right":0,"bottom":0}}]},"state":{...}}
-{"event":{"type":"FocusWindow","content":"Right"},"state":{}}
+{"event":{"type":"FocusWindow","content":"Right"},"state":{...}}
-{"event":{"type":"FocusChange","content":["SystemForeground",{"hwnd":132968,"title":"Windows PowerShell","exe":"WindowsTerminal.exe","class":"CASCADIA_HOSTING_WINDOW_CLASS","rect":{"left":1539,"top":60,"right":1520,"bottom":821}}]},"state":{}}
+{"event":{"type":"FocusChange","content":["SystemForeground",{"hwnd":132968,"title":"Windows PowerShell","exe":"WindowsTerminal.exe","class":"CASCADIA_HOSTING_WINDOW_CLASS","rect":{"left":1539,"top":60,"right":1520,"bottom":821}}]},"state":{}...}
-{"event":{"type":"FocusWindow","content":"Down"},"state":{}}
+{"event":{"type":"FocusWindow","content":"Down"},"state":{...}}
-{"event":{"type":"FocusChange","content":["SystemForeground",{"hwnd":329264,"title":"den — Mozilla Firefox","exe":"firefox.exe","class":"MozillaWindowClass","rect":{"left":1539,"top":894,"right":1520,"bottom":821}}]},"state":{}}
+{"event":{"type":"FocusChange","content":["SystemForeground",{"hwnd":329264,"title":"den — Mozilla Firefox","exe":"firefox.exe","class":"MozillaWindowClass","rect":{"left":1539,"top":894,"right":1520,"bottom":821}}]},"state":{...}}
-{"event":{"type":"FocusWindow","content":"Up"},"state":{}}
+{"event":{"type":"FocusWindow","content":"Up"},"state":{...}}
-{"event":{"type":"FocusChange","content":["SystemForeground",{"hwnd":132968,"title":"Windows PowerShell","exe":"WindowsTerminal.exe","class":"CASCADIA_HOSTING_WINDOW_CLASS","rect":{"left":1539,"top":60,"right":1520,"bottom":821}}]},"state":{}}
+{"event":{"type":"FocusChange","content":["SystemForeground",{"hwnd":132968,"title":"Windows PowerShell","exe":"WindowsTerminal.exe","class":"CASCADIA_HOSTING_WINDOW_CLASS","rect":{"left":1539,"top":60,"right":1520,"bottom":821}}]},"state":{...}}
 ```
 You may then filter on the `type` key to listen to the events that you are interested in. For a full list of possible
 notification types, refer to the enum variants of `WindowManagerEvent` in `komorebi` and `SocketMessage`
 in `komorebi-core`.
-Below is an example of how you can subscribe to and filter on events using a named pipe in `nodejs`.
+An example of how to create a named pipe and a subscription to `komorebi`'s handled events in Python
-
+by [@denBot](https://github.com/denBot) can be
-```javascript
+found [here](https://gist.github.com/denBot/4136279812f87819f86d99eba77c1ee0).
 const { exec } = require("child_process");
 const net = require("net");
 const pipeName = "\\\\.\\pipe\\komorebi-js";
 const server = net.createServer((stream) => {
  console.log("Client connected");
  // Every time there is a workspace-related event, let's log the names of all
  // workspaces on the currently focused monitor, and then log the name of the
  // currently focused workspace on that monitor
  stream.on("data", (data) => {
    let json = JSON.parse(data.toString());
    let event = json.event;
    if (event.type.includes("Workspace")) {
      let monitors = json.state.monitors;
      let current_monitor = monitors.elements[monitors.focused];
      let workspaces = monitors.elements[monitors.focused].workspaces;
      let current_workspace = workspaces.elements[workspaces.focused];
      console.log(
        workspaces.elements
          .map((workspace) => workspace.name)
          .filter((name) => name !== null)
      );
      console.log(current_workspace.name);
    }
  });
  stream.on("end", () => {
    console.log("Client disconnected");
  });
 });
 server.listen(pipeName, () => {
  console.log("Named pipe server listening");
 });
 const command = "komorebic subscribe-pipe komorebi-js";
 exec(command, (error, stdout, stderr) => {
  if (error) {
    console.error(`Error executing command: ${error}`);
    return;
  }
 });
 ```
 ## Unix Domain Sockets
 It is possible to subscribe to notifications of every `WindowManagerEvent` and `SocketMessage` handled
 by `komorebi` using [Unix Domain Sockets](https://devblogs.microsoft.com/commandline/af_unix-comes-to-windows/).
 UDS are also the only mode of communication between `komorebi` and `komorebic`.
 First, your application must create a socket in `$ENV:LocalAppData\komorebi`. Once the socket has been created, run the
 following command:
 ```powershell
 komorebic.exe subscribe-socket <your socket name>
 ```
 If the socket exists, komorebi will start pushing JSON data of successfully handled events and messages as in the
 example above in the Named Pipes section.
 ## Rust Client
 As of `v0.1.22` it is possible to use the `komorebi-client` crate to subscribe to notifications of
 every `WindowManagerEvent` and `SocketMessage` handled by `komorebi` in a Rust codebase.
 Below is a simple example of how to use `komorebi-client` in a basic Rust application.
 ```rust
 // komorebi-client = { git = "https://github.com/LGUG2Z/komorebi", tag = "v0.1.22"}
 use anyhow::Result;
 use komorebi_client::Notification;
 use komorebi_client::NotificationEvent;
 use komorebi_client::UnixListener;
 use komorebi_client::WindowManagerEvent;
 use std::io::BufRead;
 use std::io::BufReader;
 use std::io::Read;
 pub fn main() -> anyhow::Result<()> {
  let socket = komorebi_client::subscribe(NAME)?;
  for incoming in socket.incoming() {
    match incoming {
      Ok(data) => {
        let reader = BufReader::new(data.try_clone()?);
        for line in reader.lines().flatten() {
          let notification: Notification = match serde_json::from_str(&line) {
            Ok(notification) => notification,
            Err(error) => {
              log::debug!("discarding malformed komorebi notification: {error}");
              continue;
            }
          };
          // match and filter on desired notifications
        }
      }
      Err(error) => {
        log::debug!("{error}");
      }
    }
  }
 }
 ```
 A read-world example can be found
 in [komokana](https://github.com/LGUG2Z/komokana/blob/feature/komorebi-uds/src/main.rs).
 ## Subscription Event Notification Schema
 A [JSON Schema](https://json-schema.org/) of the event notifications emitted to subscribers can be generated with
 the `komorebic notification-schema` command. The output of this command can be redirected to the clipboard or a file,
 which can be used with services such as [Quicktype](https://app.quicktype.io/) to generate type definitions in different
 programming languages.
 ## Communication over TCP
 A TCP listener can optionally be exposed on a port of your choosing with the `--tcp-port=N` flag. If this flag is not
 provided to `komorebi` or `komorebic start`, no TCP listener will be created.
 Once created, your client may send
 any [SocketMessage](https://github.com/LGUG2Z/komorebi/blob/master/komorebi-core/src/lib.rs#L37) to `komorebi` in the
 same way that `komorebic` would.
 This can be used if you would like to create your own alternative to `komorebic` which incorporates scripting and
 various middleware layers, and similarly it can be used if you would like to integrate `komorebi` with
 a [custom input handler](https://github.com/LGUG2Z/komorebi/issues/176#issue-1302643961).
 If a client sends an unrecognized message, it will be disconnected and have to reconnect before trying to communicate
 again.
 ## Socket Message Schema
 A [JSON Schema](https://json-schema.org/) of socket messages used to send instructions to `komorebi` can be generated
 with the `komorebic socket-schema` command. The output of this command can be redirected to the clipboard or a file,
 which can be used with services such as [Quicktype](https://app.quicktype.io/) to generate type definitions in different
 programming languages.
 # Appreciations
 - First and foremost, thank you to my wife, both for naming this project and for her patience throughout its never-ending development
 - Thank you to [@sitiom](https://github.com/sitiom) for being [an exemplary open source community leader](https://jeezy.substack.com/p/the-open-source-contributions-i-appreciate)
 - Thank you to the developers of [nog](https://github.com/TimUntersberger/nog) who came before me and whose work taught me more than I can ever hope to repay
 - Thank you to the developers of [GlazeWM](https://github.com/lars-berger/GlazeWM) for pushing the boundaries of tiling window management on Windows with me and having an excellent spirit of collaboration
 - Thank you to [@Ciantic](https://github.com/Ciantic) for helping me bring the [hidden Virtual Desktops cloaking function](https://github.com/Ciantic/AltTabAccessor/issues/1) to `komorebi`
--- a/bindings/Cargo.toml
+++ b/bindings/Cargo.toml
@@ -0,0 +1,13 @@
 [package]
 name = "bindings"
 version = "0.1.0"
 authors = ["Jade Iqbal"]
 edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [dependencies]
 windows = "0.21"
 [build-dependencies]
 windows = "0.21"
--- a/bindings/build.rs
+++ b/bindings/build.rs
@@ -0,0 +1,26 @@
 fn main() {
    windows::build!(
        Windows::Win32::Foundation::RECT,
        Windows::Win32::Foundation::POINT,
        Windows::Win32::Foundation::BOOL,
        Windows::Win32::Foundation::PWSTR,
        Windows::Win32::Foundation::HWND,
        Windows::Win32::Foundation::LPARAM,
        // error: `Windows.Win32.Graphics.Dwm.DWMWA_CLOAKED` not found in metadata
        Windows::Win32::Graphics::Dwm::*,
        // error: `Windows.Win32.Graphics.Gdi.MONITOR_DEFAULTTONEAREST` not found in metadata
        Windows::Win32::Graphics::Gdi::*,
        Windows::Win32::System::Threading::PROCESS_ACCESS_RIGHTS,
        Windows::Win32::System::Threading::PROCESS_NAME_FORMAT,
        Windows::Win32::System::Threading::OpenProcess,
        Windows::Win32::System::Threading::QueryFullProcessImageNameW,
        Windows::Win32::System::Threading::GetCurrentThreadId,
        Windows::Win32::System::Threading::AttachThreadInput,
        Windows::Win32::System::Threading::GetCurrentProcessId,
        Windows::Win32::UI::KeyboardAndMouseInput::SetFocus,
        Windows::Win32::UI::Accessibility::SetWinEventHook,
        Windows::Win32::UI::Accessibility::HWINEVENTHOOK,
        // error: `Windows.Win32.UI.WindowsAndMessaging.GWL_EXSTYLE` not found in metadata
        Windows::Win32::UI::WindowsAndMessaging::*,
    );
 }
--- a/bindings/src/lib.rs
+++ b/bindings/src/lib.rs
@@ -0,0 +1,4 @@
 pub use windows::Handle;
 pub use windows::Result;
 ::windows::include_bindings!();
--- a/derive-ahk/Cargo.toml
+++ b/derive-ahk/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "derive-ahk"
-version = "0.1.1"
+version = "0.1.0"
 edition = "2021"
 [lib]
--- a/derive-ahk/src/lib.rs
+++ b/derive-ahk/src/lib.rs
@@ -5,15 +5,12 @@
 use ::std::clone::Clone;
 use ::std::convert::From;
 use ::std::convert::Into;
 use ::std::format;
 use ::std::iter::Extend;
 use ::std::iter::Iterator;
 use ::std::matches;
 use ::std::option::Option::Some;
 use ::std::string::String;
 use ::std::string::ToString;
 use ::std::unreachable;
 use ::std::vec::Vec;
 use ::quote::quote;
 use ::syn::parse_macro_input;
@@ -105,8 +102,7 @@ pub fn ahk_function(input: ::proc_macro::TokenStream) -> ::proc_macro::TokenStre
                    let flag_idents_clone = flag_idents.clone();
                    let flags = quote! {#(--#flag_idents_clone) *}
                        .to_string()
-                        .replace("- - ", "--")
+                        .replace("- - ", "--");
                        .replace('_', "-");
                    let called_flag_arguments = quote! {#(%#flag_idents%) *}
                        .to_string()
@@ -114,28 +110,19 @@ pub fn ahk_function(input: ::proc_macro::TokenStream) -> ::proc_macro::TokenStre
                        .replace("% ", "%")
                        .replace("%%", "% %");
                    let flags_split: Vec<_> = flags.split(' ').collect();
                    let flag_args_split: Vec<_> = called_flag_arguments.split(' ').collect();
                    let mut consolidated_flags: Vec<String> = Vec::new();
                    for (idx, flag) in flags_split.iter().enumerate() {
                        consolidated_flags.push(format!("{} {}", flag, flag_args_split[idx]));
                    }
                    let all_flags = consolidated_flags.join(" ");
                    quote! {
                        impl AhkFunction for #name {
                            fn generate_ahk_function() -> String {
                                ::std::format!(r#"
 {}({}) {{
-    RunWait, komorebic.exe {} {} {}, , Hide
+    Run, komorebic.exe {} {} {} {}, , Hide
 }}"#,
                                    ::std::stringify!(#name),
                                    #all_arguments,
                                    ::std::stringify!(#name).to_kebab_case(),
                                    #called_arguments,
-                                    #all_flags,
+                                    #flags,
                                    #called_flag_arguments
                                )
                           }
                        }
@@ -148,7 +135,7 @@ pub fn ahk_function(input: ::proc_macro::TokenStream) -> ::proc_macro::TokenStre
                            fn generate_ahk_function() -> String {
                                ::std::format!(r#"
 {}({}) {{
-    RunWait, komorebic.exe {} {}, , Hide
+    Run, komorebic.exe {} {}, , Hide
 }}"#, 
                                    ::std::stringify!(#name),
                                    #arguments,
@@ -194,7 +181,7 @@ pub fn ahk_library(input: ::proc_macro::TokenStream) -> ::proc_macro::TokenStrea
                        stream.extend(quote! {
                            v.push(::std::format!(r#"
 {}() {{
-    RunWait, komorebic.exe {}, , Hide
+    Run, komorebic.exe {}, , Hide
 }}"#, 
                                ::std::stringify!(#name),
                                ::std::stringify!(#name).to_kebab_case()
--- a/docs/cli/active-window-border-colour.md
+++ b/docs/cli/active-window-border-colour.md
@@ -1,26 +0,0 @@
 # active-window-border-colour
 ```
 Set the colour for the active window border
 Usage: komorebic.exe active-window-border-colour [OPTIONS] <R> <G> <B>
 Arguments:
  <R>
          Red
  <G>
          Green
  <B>
          Blue
 Options:
  -w, --window-kind <WINDOW_KIND>
          [default: single]
          [possible values: single, stack, monocle]
  -h, --help
          Print help
 ```
--- a/docs/cli/active-window-border-offset.md
+++ b/docs/cli/active-window-border-offset.md
@@ -1,16 +0,0 @@
 # active-window-border-offset
 ```
 Set the offset for the active window border
 Usage: komorebic.exe active-window-border-offset <OFFSET>
 Arguments:
  <OFFSET>
          Desired offset of the active window border
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/active-window-border-width.md
+++ b/docs/cli/active-window-border-width.md
@@ -1,16 +0,0 @@
 # active-window-border-width
 ```
 Set the width for the active window border
 Usage: komorebic.exe active-window-border-width <WIDTH>
 Arguments:
  <WIDTH>
          Desired width of the active window border
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/active-window-border.md
+++ b/docs/cli/active-window-border.md
@@ -1,16 +0,0 @@
 # active-window-border
 ```
 Enable or disable the active window border
 Usage: komorebic.exe active-window-border <BOOLEAN_STATE>
 Arguments:
  <BOOLEAN_STATE>
          [possible values: enable, disable]
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/adjust-container-padding.md
+++ b/docs/cli/adjust-container-padding.md
@@ -1,19 +0,0 @@
 # adjust-container-padding
 ```
 Adjust container padding on the focused workspace
 Usage: komorebic.exe adjust-container-padding <SIZING> <ADJUSTMENT>
 Arguments:
  <SIZING>
          [possible values: increase, decrease]
  <ADJUSTMENT>
          Pixels to adjust by as an integer
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/adjust-workspace-padding.md
+++ b/docs/cli/adjust-workspace-padding.md
@@ -1,19 +0,0 @@
 # adjust-workspace-padding
 ```
 Adjust workspace padding on the focused workspace
 Usage: komorebic.exe adjust-workspace-padding <SIZING> <ADJUSTMENT>
 Arguments:
  <SIZING>
          [possible values: increase, decrease]
  <ADJUSTMENT>
          Pixels to adjust by as an integer
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/ahk-app-specific-configuration.md
+++ b/docs/cli/ahk-app-specific-configuration.md
@@ -1,19 +0,0 @@
 # ahk-app-specific-configuration
 ```
 Generate common app-specific configurations and fixes to use in komorebi.ahk
 Usage: komorebic.exe ahk-app-specific-configuration <PATH> [OVERRIDE_PATH]
 Arguments:
  <PATH>
          YAML file from which the application-specific configurations should be loaded
  [OVERRIDE_PATH]
          Optional YAML file of overrides to apply over the first file
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/ahk-library.md
+++ b/docs/cli/ahk-library.md
@@ -1,12 +0,0 @@
 # ahk-library
 ```
 Generate a library of AutoHotKey helper functions
 Usage: komorebic.exe ahk-library
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/alt-focus-hack.md
+++ b/docs/cli/alt-focus-hack.md
@@ -1,16 +0,0 @@
 # alt-focus-hack
 ```
 DEPRECATED since v0.1.22
 Usage: komorebic.exe alt-focus-hack <BOOLEAN_STATE>
 Arguments:
  <BOOLEAN_STATE>
          [possible values: enable, disable]
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/application-specific-configuration-schema.md
+++ b/docs/cli/application-specific-configuration-schema.md
@@ -1,12 +0,0 @@
 # application-specific-configuration-schema
 ```
 Generate a JSON Schema for applications.yaml
 Usage: komorebic.exe application-specific-configuration-schema
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/change-layout.md
+++ b/docs/cli/change-layout.md
@@ -1,16 +0,0 @@
 # change-layout
 ```
 Set the layout on the focused workspace
 Usage: komorebic.exe change-layout <DEFAULT_LAYOUT>
 Arguments:
  <DEFAULT_LAYOUT>
          [possible values: bsp, columns, rows, vertical-stack, horizontal-stack, ultrawide-vertical-stack, grid]
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/check.md
+++ b/docs/cli/check.md
@@ -1,12 +0,0 @@
 # check
 ```
 Check komorebi configuration and related files for common errors
 Usage: komorebic.exe check
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/clear-named-workspace-layout-rules.md
+++ b/docs/cli/clear-named-workspace-layout-rules.md
@@ -1,16 +0,0 @@
 # clear-named-workspace-layout-rules
 ```
 Clear all dynamic layout rules for the specified workspace
 Usage: komorebic.exe clear-named-workspace-layout-rules <WORKSPACE>
 Arguments:
  <WORKSPACE>
          Target workspace name
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/clear-workspace-layout-rules.md
+++ b/docs/cli/clear-workspace-layout-rules.md
@@ -1,19 +0,0 @@
 # clear-workspace-layout-rules
 ```
 Clear all dynamic layout rules for the specified workspace
 Usage: komorebic.exe clear-workspace-layout-rules <MONITOR> <WORKSPACE>
 Arguments:
  <MONITOR>
          Monitor index (zero-indexed)
  <WORKSPACE>
          Workspace index on the specified monitor (zero-indexed)
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/close.md
+++ b/docs/cli/close.md
@@ -1,12 +0,0 @@
 # close
 ```
 Close the focused window
 Usage: komorebic.exe close
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/complete-configuration.md
+++ b/docs/cli/complete-configuration.md
@@ -1,12 +0,0 @@
 # complete-configuration
 ```
 Signal that the final configuration option has been sent
 Usage: komorebic.exe complete-configuration
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/configuration.md
+++ b/docs/cli/configuration.md
@@ -1,12 +0,0 @@
 # configuration
 ```
 Show the path to komorebi.json
 Usage: komorebic.exe configuration
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/container-padding.md
+++ b/docs/cli/container-padding.md
@@ -1,22 +0,0 @@
 # container-padding
 ```
 Set the container padding for the specified workspace
 Usage: komorebic.exe container-padding <MONITOR> <WORKSPACE> <SIZE>
 Arguments:
  <MONITOR>
          Monitor index (zero-indexed)
  <WORKSPACE>
          Workspace index on the specified monitor (zero-indexed)
  <SIZE>
          Pixels to pad with as an integer
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/cross-monitor-move-behaviour.md
+++ b/docs/cli/cross-monitor-move-behaviour.md
@@ -1,18 +0,0 @@
 # cross-monitor-move-behaviour
 ```
 Set the behaviour when moving windows across monitor boundaries
 Usage: komorebic.exe cross-monitor-move-behaviour <MOVE_BEHAVIOUR>
 Arguments:
  <MOVE_BEHAVIOUR>
          Possible values:
          - swap:   Swap the window container with the window container at the edge of the adjacent monitor
          - insert: Insert the window container into the focused workspace on the adjacent monitor
 Options:
  -h, --help
          Print help (see a summary with '-h')
 ```
--- a/docs/cli/cycle-focus.md
+++ b/docs/cli/cycle-focus.md
@@ -1,16 +0,0 @@
 # cycle-focus
 ```
 Change focus to the window in the specified cycle direction
 Usage: komorebic.exe cycle-focus <CYCLE_DIRECTION>
 Arguments:
  <CYCLE_DIRECTION>
          [possible values: previous, next]
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/cycle-layout.md
+++ b/docs/cli/cycle-layout.md
@@ -1,16 +0,0 @@
 # cycle-layout
 ```
 Cycle between available layouts
 Usage: komorebic.exe cycle-layout <CYCLE_DIRECTION>
 Arguments:
  <CYCLE_DIRECTION>
          [possible values: previous, next]
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/cycle-monitor.md
+++ b/docs/cli/cycle-monitor.md
@@ -1,16 +0,0 @@
 # cycle-monitor
 ```
 Focus the monitor in the given cycle direction
 Usage: komorebic.exe cycle-monitor <CYCLE_DIRECTION>
 Arguments:
  <CYCLE_DIRECTION>
          [possible values: previous, next]
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/cycle-move-to-monitor.md
+++ b/docs/cli/cycle-move-to-monitor.md
@@ -1,16 +0,0 @@
 # cycle-move-to-monitor
 ```
 Move the focused window to the monitor in the given cycle direction
 Usage: komorebic.exe cycle-move-to-monitor <CYCLE_DIRECTION>
 Arguments:
  <CYCLE_DIRECTION>
          [possible values: previous, next]
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/cycle-move-to-workspace.md
+++ b/docs/cli/cycle-move-to-workspace.md
@@ -1,16 +0,0 @@
 # cycle-move-to-workspace
 ```
 Move the focused window to the workspace in the given cycle direction
 Usage: komorebic.exe cycle-move-to-workspace <CYCLE_DIRECTION>
 Arguments:
  <CYCLE_DIRECTION>
          [possible values: previous, next]
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/cycle-move.md
+++ b/docs/cli/cycle-move.md
@@ -1,16 +0,0 @@
 # cycle-move
 ```
 Move the focused window in the specified cycle direction
 Usage: komorebic.exe cycle-move <CYCLE_DIRECTION>
 Arguments:
  <CYCLE_DIRECTION>
          [possible values: previous, next]
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/cycle-send-to-monitor.md
+++ b/docs/cli/cycle-send-to-monitor.md
@@ -1,16 +0,0 @@
 # cycle-send-to-monitor
 ```
 Send the focused window to the monitor in the given cycle direction
 Usage: komorebic.exe cycle-send-to-monitor <CYCLE_DIRECTION>
 Arguments:
  <CYCLE_DIRECTION>
          [possible values: previous, next]
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/cycle-send-to-workspace.md
+++ b/docs/cli/cycle-send-to-workspace.md
@@ -1,16 +0,0 @@
 # cycle-send-to-workspace
 ```
 Send the focused window to the workspace in the given cycle direction
 Usage: komorebic.exe cycle-send-to-workspace <CYCLE_DIRECTION>
 Arguments:
  <CYCLE_DIRECTION>
          [possible values: previous, next]
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/cycle-stack.md
+++ b/docs/cli/cycle-stack.md
@@ -1,16 +0,0 @@
 # cycle-stack
 ```
 Cycle the focused stack in the specified cycle direction
 Usage: komorebic.exe cycle-stack <CYCLE_DIRECTION>
 Arguments:
  <CYCLE_DIRECTION>
          [possible values: previous, next]
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/cycle-workspace.md
+++ b/docs/cli/cycle-workspace.md
@@ -1,16 +0,0 @@
 # cycle-workspace
 ```
 Focus the workspace in the given cycle direction
 Usage: komorebic.exe cycle-workspace <CYCLE_DIRECTION>
 Arguments:
  <CYCLE_DIRECTION>
          [possible values: previous, next]
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/disable-autostart.md
+++ b/docs/cli/disable-autostart.md
@@ -1,12 +0,0 @@
 # disable-autostart
 ```
 Deletes the komorebi.lnk shortcut in shell:startup to disable autostart
 Usage: komorebic.exe disable-autostart
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/display-index-preference.md
+++ b/docs/cli/display-index-preference.md
@@ -1,19 +0,0 @@
 # display-index-preference
 ```
 Set the display index preference for a monitor identified using its display name
 Usage: komorebic.exe display-index-preference <INDEX_PREFERENCE> <DISPLAY>
 Arguments:
  <INDEX_PREFERENCE>
          Preferred monitor index (zero-indexed)
  <DISPLAY>
          Display name as identified in komorebic state
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/enable-autostart.md
+++ b/docs/cli/enable-autostart.md
@@ -1,24 +0,0 @@
 # enable-autostart
 ```
 Generates the komorebi.lnk shortcut in shell:startup to autostart komorebi
 Usage: komorebic.exe enable-autostart [OPTIONS]
 Options:
  -c, --config <CONFIG>
          Path to a static configuration JSON file
  -f, --ffm
          Enable komorebi's custom focus-follows-mouse implementation
      --whkd
          Enable autostart of whkd
      --ahk
          Enable autostart of ahk
  -h, --help
          Print help
 ```
--- a/docs/cli/ensure-named-workspaces.md
+++ b/docs/cli/ensure-named-workspaces.md
@@ -1,19 +0,0 @@
 # ensure-named-workspaces
 ```
 Create these many named workspaces for the specified monitor
 Usage: komorebic.exe ensure-named-workspaces <MONITOR> [NAMES]...
 Arguments:
  <MONITOR>
          Monitor index (zero-indexed)
  [NAMES]...
          Names of desired workspaces
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/ensure-workspaces.md
+++ b/docs/cli/ensure-workspaces.md
@@ -1,19 +0,0 @@
 # ensure-workspaces
 ```
 Create at least this many workspaces for the specified monitor
 Usage: komorebic.exe ensure-workspaces <MONITOR> <WORKSPACE_COUNT>
 Arguments:
  <MONITOR>
          Monitor index (zero-indexed)
  <WORKSPACE_COUNT>
          Number of desired workspaces
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/fetch-app-specific-configuration.md
+++ b/docs/cli/fetch-app-specific-configuration.md
@@ -1,12 +0,0 @@
 # fetch-app-specific-configuration
 ```
 Fetch the latest version of applications.yaml from komorebi-application-specific-configuration
 Usage: komorebic.exe fetch-app-specific-configuration
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/flip-layout.md
+++ b/docs/cli/flip-layout.md
@@ -1,16 +0,0 @@
 # flip-layout
 ```
 Flip the layout on the focused workspace (BSP only)
 Usage: komorebic.exe flip-layout <AXIS>
 Arguments:
  <AXIS>
          [possible values: horizontal, vertical, horizontal-and-vertical]
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/float-rule.md
+++ b/docs/cli/float-rule.md
@@ -1,19 +0,0 @@
 # float-rule
 ```
 Add a rule to always float the specified application
 Usage: komorebic.exe float-rule <IDENTIFIER> <ID>
 Arguments:
  <IDENTIFIER>
          [possible values: exe, class, title]
  <ID>
          Identifier as a string
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/focus-follows-mouse.md
+++ b/docs/cli/focus-follows-mouse.md
@@ -1,23 +0,0 @@
 # focus-follows-mouse
 ```
 Enable or disable focus follows mouse for the operating system
 Usage: komorebic.exe focus-follows-mouse [OPTIONS] <BOOLEAN_STATE>
 Arguments:
  <BOOLEAN_STATE>
          [possible values: enable, disable]
 Options:
  -i, --implementation <IMPLEMENTATION>
          [default: windows]
          Possible values:
          - komorebi: A custom FFM implementation (slightly more CPU-intensive)
          - windows:  The native (legacy) Windows FFM implementation
  -h, --help
          Print help (see a summary with '-h')
 ```
--- a/docs/cli/focus-last-workspace.md
+++ b/docs/cli/focus-last-workspace.md
@@ -1,12 +0,0 @@
 # focus-last-workspace
 ```
 Focus the last focused workspace on the focused monitor
 Usage: komorebic.exe focus-last-workspace
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/focus-monitor-workspace.md
+++ b/docs/cli/focus-monitor-workspace.md
@@ -1,19 +0,0 @@
 # focus-monitor-workspace
 ```
 Focus the specified workspace on the target monitor
 Usage: komorebic.exe focus-monitor-workspace <TARGET_MONITOR> <TARGET_WORKSPACE>
 Arguments:
  <TARGET_MONITOR>
          Target monitor index (zero-indexed)
  <TARGET_WORKSPACE>
          Workspace index on the target monitor (zero-indexed)
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/focus-monitor.md
+++ b/docs/cli/focus-monitor.md
@@ -1,16 +0,0 @@
 # focus-monitor
 ```
 Focus the specified monitor
 Usage: komorebic.exe focus-monitor <TARGET>
 Arguments:
  <TARGET>
          Target index (zero-indexed)
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/focus-named-workspace.md
+++ b/docs/cli/focus-named-workspace.md
@@ -1,16 +0,0 @@
 # focus-named-workspace
 ```
 Focus the specified workspace
 Usage: komorebic.exe focus-named-workspace <WORKSPACE>
 Arguments:
  <WORKSPACE>
          Target workspace name
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/focus-workspace.md
+++ b/docs/cli/focus-workspace.md
@@ -1,16 +0,0 @@
 # focus-workspace
 ```
 Focus the specified workspace on the focused monitor
 Usage: komorebic.exe focus-workspace <TARGET>
 Arguments:
  <TARGET>
          Target index (zero-indexed)
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/focus-workspaces.md
+++ b/docs/cli/focus-workspaces.md
@@ -1,16 +0,0 @@
 # focus-workspaces
 ```
 Focus the specified workspace on all monitors
 Usage: komorebic.exe focus-workspaces <TARGET>
 Arguments:
  <TARGET>
          Target index (zero-indexed)
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/focus.md
+++ b/docs/cli/focus.md
@@ -1,16 +0,0 @@
 # focus
 ```
 Change focus to the window in the specified direction
 Usage: komorebic.exe focus <OPERATION_DIRECTION>
 Arguments:
  <OPERATION_DIRECTION>
          [possible values: left, right, up, down]
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/focused-workspace-container-padding.md
+++ b/docs/cli/focused-workspace-container-padding.md
@@ -1,16 +0,0 @@
 # focused-workspace-container-padding
 ```
 Set container padding on the focused workspace
 Usage: komorebic.exe focused-workspace-container-padding <SIZE>
 Arguments:
  <SIZE>
          Pixels size to set as an integer
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/focused-workspace-padding.md
+++ b/docs/cli/focused-workspace-padding.md
@@ -1,16 +0,0 @@
 # focused-workspace-padding
 ```
 Set workspace padding on the focused workspace
 Usage: komorebic.exe focused-workspace-padding <SIZE>
 Arguments:
  <SIZE>
          Pixels size to set as an integer
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/force-focus.md
+++ b/docs/cli/force-focus.md
@@ -1,12 +0,0 @@
 # force-focus
 ```
 Forcibly focus the window at the cursor with a left mouse click
 Usage: komorebic.exe force-focus
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/format-app-specific-configuration.md
+++ b/docs/cli/format-app-specific-configuration.md
@@ -1,16 +0,0 @@
 # format-app-specific-configuration
 ```
 Format a YAML file for use with the 'ahk-app-specific-configuration' command
 Usage: komorebic.exe format-app-specific-configuration <PATH>
 Arguments:
  <PATH>
          YAML file from which the application-specific configurations should be loaded
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/generate-static-config.md
+++ b/docs/cli/generate-static-config.md
@@ -1,12 +0,0 @@
 # generate-static-config
 ```
 Generates a static configuration JSON file based on the current window manager state
 Usage: komorebic.exe generate-static-config
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/global-work-area-offset.md
+++ b/docs/cli/global-work-area-offset.md
@@ -1,25 +0,0 @@
 # global-work-area-offset
 ```
 Set offsets to exclude parts of the work area from tiling
 Usage: komorebic.exe global-work-area-offset <LEFT> <TOP> <RIGHT> <BOTTOM>
 Arguments:
  <LEFT>
          Size of the left work area offset (set right to left * 2 to maintain right padding)
  <TOP>
          Size of the top work area offset (set bottom to the same value to maintain bottom padding)
  <RIGHT>
          Size of the right work area offset
  <BOTTOM>
          Size of the bottom work area offset
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/identify-border-overflow-application.md
+++ b/docs/cli/identify-border-overflow-application.md
@@ -1,19 +0,0 @@
 # identify-border-overflow-application
 ```
 Identify an application that has overflowing borders
 Usage: komorebic.exe identify-border-overflow-application <IDENTIFIER> <ID>
 Arguments:
  <IDENTIFIER>
          [possible values: exe, class, title]
  <ID>
          Identifier as a string
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/identify-layered-application.md
+++ b/docs/cli/identify-layered-application.md
@@ -1,19 +0,0 @@
 # identify-layered-application
 ```
 Identify an application that has WS_EX_LAYERED, but should still be managed
 Usage: komorebic.exe identify-layered-application <IDENTIFIER> <ID>
 Arguments:
  <IDENTIFIER>
          [possible values: exe, class, title]
  <ID>
          Identifier as a string
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/identify-object-name-change-application.md
+++ b/docs/cli/identify-object-name-change-application.md
@@ -1,19 +0,0 @@
 # identify-object-name-change-application
 ```
 Identify an application that sends EVENT_OBJECT_NAMECHANGE on launch
 Usage: komorebic.exe identify-object-name-change-application <IDENTIFIER> <ID>
 Arguments:
  <IDENTIFIER>
          [possible values: exe, class, title]
  <ID>
          Identifier as a string
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/identify-tray-application.md
+++ b/docs/cli/identify-tray-application.md
@@ -1,19 +0,0 @@
 # identify-tray-application
 ```
 Identify an application that closes to the system tray
 Usage: komorebic.exe identify-tray-application <IDENTIFIER> <ID>
 Arguments:
  <IDENTIFIER>
          [possible values: exe, class, title]
  <ID>
          Identifier as a string
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/initial-named-workspace-rule.md
+++ b/docs/cli/initial-named-workspace-rule.md
@@ -1,22 +0,0 @@
 # initial-named-workspace-rule
 ```
 Add a rule to associate an application with a named workspace on first show
 Usage: komorebic.exe initial-named-workspace-rule <IDENTIFIER> <ID> <WORKSPACE>
 Arguments:
  <IDENTIFIER>
          [possible values: exe, class, title]
  <ID>
          Identifier as a string
  <WORKSPACE>
          Name of a workspace
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/initial-workspace-rule.md
+++ b/docs/cli/initial-workspace-rule.md
@@ -1,25 +0,0 @@
 # initial-workspace-rule
 ```
 Add a rule to associate an application with a workspace on first show
 Usage: komorebic.exe initial-workspace-rule <IDENTIFIER> <ID> <MONITOR> <WORKSPACE>
 Arguments:
  <IDENTIFIER>
          [possible values: exe, class, title]
  <ID>
          Identifier as a string
  <MONITOR>
          Monitor index (zero-indexed)
  <WORKSPACE>
          Workspace index on the specified monitor (zero-indexed)
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/invisible-borders.md
+++ b/docs/cli/invisible-borders.md
@@ -1,25 +0,0 @@
 # invisible-borders
 ```
 Set the invisible border dimensions around each window
 Usage: komorebic.exe invisible-borders <LEFT> <TOP> <RIGHT> <BOTTOM>
 Arguments:
  <LEFT>
          Size of the left invisible border
  <TOP>
          Size of the top invisible border (usually 0)
  <RIGHT>
          Size of the right invisible border (usually left * 2)
  <BOTTOM>
          Size of the bottom invisible border (usually the same as left)
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/load-custom-layout.md
+++ b/docs/cli/load-custom-layout.md
@@ -1,16 +0,0 @@
 # load-custom-layout
 ```
 Load a custom layout from file for the focused workspace
 Usage: komorebic.exe load-custom-layout <PATH>
 Arguments:
  <PATH>
          JSON or YAML file from which the custom layout definition should be loaded
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/load-resize.md
+++ b/docs/cli/load-resize.md
@@ -1,16 +0,0 @@
 # load-resize
 ```
 Load the resize layout dimensions from a file
 Usage: komorebic.exe load-resize <PATH>
 Arguments:
  <PATH>
          File from which the resize layout dimensions should be loaded
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/log.md
+++ b/docs/cli/log.md
@@ -1,12 +0,0 @@
 # log
 ```
 Tail komorebi.exe's process logs (cancel with Ctrl-C)
 Usage: komorebic.exe log
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/manage-rule.md
+++ b/docs/cli/manage-rule.md
@@ -1,19 +0,0 @@
 # manage-rule
 ```
 Add a rule to always manage the specified application
 Usage: komorebic.exe manage-rule <IDENTIFIER> <ID>
 Arguments:
  <IDENTIFIER>
          [possible values: exe, class, title]
  <ID>
          Identifier as a string
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/manage.md
+++ b/docs/cli/manage.md
@@ -1,12 +0,0 @@
 # manage
 ```
 Force komorebi to manage the focused window
 Usage: komorebic.exe manage
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/minimize.md
+++ b/docs/cli/minimize.md
@@ -1,12 +0,0 @@
 # minimize
 ```
 Minimize the focused window
 Usage: komorebic.exe minimize
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/monitor-index-preference.md
+++ b/docs/cli/monitor-index-preference.md
@@ -1,28 +0,0 @@
 # monitor-index-preference
 ```
 Set the monitor index preference for a monitor identified using its size
 Usage: komorebic.exe monitor-index-preference <INDEX_PREFERENCE> <LEFT> <TOP> <RIGHT> <BOTTOM>
 Arguments:
  <INDEX_PREFERENCE>
          Preferred monitor index (zero-indexed)
  <LEFT>
          Left value of the monitor's size Rect
  <TOP>
          Top value of the monitor's size Rect
  <RIGHT>
          Right value of the monitor's size Rect
  <BOTTOM>
          Bottom value of the monitor's size Rect
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/monitor-work-area-offset.md
+++ b/docs/cli/monitor-work-area-offset.md
@@ -1,28 +0,0 @@
 # monitor-work-area-offset
 ```
 Set offsets for a monitor to exclude parts of the work area from tiling
 Usage: komorebic.exe monitor-work-area-offset <MONITOR> <LEFT> <TOP> <RIGHT> <BOTTOM>
 Arguments:
  <MONITOR>
          Monitor index (zero-indexed)
  <LEFT>
          Size of the left work area offset (set right to left * 2 to maintain right padding)
  <TOP>
          Size of the top work area offset (set bottom to the same value to maintain bottom padding)
  <RIGHT>
          Size of the right work area offset
  <BOTTOM>
          Size of the bottom work area offset
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/mouse-follows-focus.md
+++ b/docs/cli/mouse-follows-focus.md
@@ -1,16 +0,0 @@
 # mouse-follows-focus
 ```
 Enable or disable mouse follows focus on all workspaces
 Usage: komorebic.exe mouse-follows-focus <BOOLEAN_STATE>
 Arguments:
  <BOOLEAN_STATE>
          [possible values: enable, disable]
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/move-to-monitor.md
+++ b/docs/cli/move-to-monitor.md
@@ -1,16 +0,0 @@
 # move-to-monitor
 ```
 Move the focused window to the specified monitor
 Usage: komorebic.exe move-to-monitor <TARGET>
 Arguments:
  <TARGET>
          Target index (zero-indexed)
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/move-to-named-workspace.md
+++ b/docs/cli/move-to-named-workspace.md
@@ -1,16 +0,0 @@
 # move-to-named-workspace
 ```
 Move the focused window to the specified workspace
 Usage: komorebic.exe move-to-named-workspace <WORKSPACE>
 Arguments:
  <WORKSPACE>
          Target workspace name
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/move-to-workspace.md
+++ b/docs/cli/move-to-workspace.md
@@ -1,16 +0,0 @@
 # move-to-workspace
 ```
 Move the focused window to the specified workspace
 Usage: komorebic.exe move-to-workspace <TARGET>
 Arguments:
  <TARGET>
          Target index (zero-indexed)
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/move-workspace-to-monitor.md
+++ b/docs/cli/move-workspace-to-monitor.md
@@ -1,16 +0,0 @@
 # move-workspace-to-monitor
 ```
 Move the focused workspace to the specified monitor
 Usage: komorebic.exe move-workspace-to-monitor <TARGET>
 Arguments:
  <TARGET>
          Target index (zero-indexed)
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/move.md
+++ b/docs/cli/move.md
@@ -1,16 +0,0 @@
 # move
 ```
 Move the focused window in the specified direction
 Usage: komorebic.exe move <OPERATION_DIRECTION>
 Arguments:
  <OPERATION_DIRECTION>
          [possible values: left, right, up, down]
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/named-workspace-container-padding.md
+++ b/docs/cli/named-workspace-container-padding.md
@@ -1,19 +0,0 @@
 # named-workspace-container-padding
 ```
 Set the container padding for the specified workspace
 Usage: komorebic.exe named-workspace-container-padding <WORKSPACE> <SIZE>
 Arguments:
  <WORKSPACE>
          Target workspace name
  <SIZE>
          Pixels to pad with as an integer
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/named-workspace-custom-layout-rule.md
+++ b/docs/cli/named-workspace-custom-layout-rule.md
@@ -1,22 +0,0 @@
 # named-workspace-custom-layout-rule
 ```
 Add a dynamic custom layout for the specified workspace
 Usage: komorebic.exe named-workspace-custom-layout-rule <WORKSPACE> <AT_CONTAINER_COUNT> <PATH>
 Arguments:
  <WORKSPACE>
          Target workspace name
  <AT_CONTAINER_COUNT>
          The number of window containers on-screen required to trigger this layout rule
  <PATH>
          JSON or YAML file from which the custom layout definition should be loaded
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/named-workspace-custom-layout.md
+++ b/docs/cli/named-workspace-custom-layout.md
@@ -1,19 +0,0 @@
 # named-workspace-custom-layout
 ```
 Set a custom layout for the specified workspace
 Usage: komorebic.exe named-workspace-custom-layout <WORKSPACE> <PATH>
 Arguments:
  <WORKSPACE>
          Target workspace name
  <PATH>
          JSON or YAML file from which the custom layout definition should be loaded
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/named-workspace-layout-rule.md
+++ b/docs/cli/named-workspace-layout-rule.md
@@ -1,22 +0,0 @@
 # named-workspace-layout-rule
 ```
 Add a dynamic layout rule for the specified workspace
 Usage: komorebic.exe named-workspace-layout-rule <WORKSPACE> <AT_CONTAINER_COUNT> <LAYOUT>
 Arguments:
  <WORKSPACE>
          Target workspace name
  <AT_CONTAINER_COUNT>
          The number of window containers on-screen required to trigger this layout rule
  <LAYOUT>
          [possible values: bsp, columns, rows, vertical-stack, horizontal-stack, ultrawide-vertical-stack, grid]
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/named-workspace-layout.md
+++ b/docs/cli/named-workspace-layout.md
@@ -1,19 +0,0 @@
 # named-workspace-layout
 ```
 Set the layout for the specified workspace
 Usage: komorebic.exe named-workspace-layout <WORKSPACE> <VALUE>
 Arguments:
  <WORKSPACE>
          Target workspace name
  <VALUE>
          [possible values: bsp, columns, rows, vertical-stack, horizontal-stack, ultrawide-vertical-stack, grid]
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/named-workspace-padding.md
+++ b/docs/cli/named-workspace-padding.md
@@ -1,19 +0,0 @@
 # named-workspace-padding
 ```
 Set the workspace padding for the specified workspace
 Usage: komorebic.exe named-workspace-padding <WORKSPACE> <SIZE>
 Arguments:
  <WORKSPACE>
          Target workspace name
  <SIZE>
          Pixels to pad with as an integer
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/named-workspace-rule.md
+++ b/docs/cli/named-workspace-rule.md
@@ -1,22 +0,0 @@
 # named-workspace-rule
 ```
 Add a rule to associate an application with a named workspace
 Usage: komorebic.exe named-workspace-rule <IDENTIFIER> <ID> <WORKSPACE>
 Arguments:
  <IDENTIFIER>
          [possible values: exe, class, title]
  <ID>
          Identifier as a string
  <WORKSPACE>
          Name of a workspace
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/named-workspace-tiling.md
+++ b/docs/cli/named-workspace-tiling.md
@@ -1,19 +0,0 @@
 # named-workspace-tiling
 ```
 Enable or disable window tiling for the specified workspace
 Usage: komorebic.exe named-workspace-tiling <WORKSPACE> <VALUE>
 Arguments:
  <WORKSPACE>
          Target workspace name
  <VALUE>
          [possible values: enable, disable]
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/new-workspace.md
+++ b/docs/cli/new-workspace.md
@@ -1,12 +0,0 @@
 # new-workspace
 ```
 Create and append a new workspace on the focused monitor
 Usage: komorebic.exe new-workspace
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/notification-schema.md
+++ b/docs/cli/notification-schema.md
@@ -1,12 +0,0 @@
 # notification-schema
 ```
 Generate a JSON Schema of subscription notifications
 Usage: komorebic.exe notification-schema
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/promote-focus.md
+++ b/docs/cli/promote-focus.md
@@ -1,12 +0,0 @@
 # promote-focus
 ```
 Promote the user focus to the top of the tree
 Usage: komorebic.exe promote-focus
 Options:
  -h, --help
          Print help
 ```
--- a/docs/cli/promote.md
+++ b/docs/cli/promote.md
@@ -1,12 +0,0 @@
 # promote
 ```
 Promote the focused window to the top of the tree
 Usage: komorebic.exe promote
 Options:
  -h, --help
          Print help
 ```
--- a/Show More
+++ b/Show More