Commit Graph
102 Commits
Author SHA1 Message Date
LGUG2Z 3b40bedac3 feat(nix): drag-resize as KDE extras and shared steps 2026-10-30 12:03:01 -07:00
LGUG2Z bc5f4babc4 feat(nix): commands as shared steps and KDE extras 2026-10-30 12:03:01 -07:00
LGUG2Z b09011dce7 fix(nix): a suite step may call something that returns a value 2026-10-30 12:03:01 -07:00
LGUG2Z f5db6975b4 feat(nix): hotplug as shared steps and KDE extras 2026-10-30 12:03:01 -07:00
LGUG2Z 47123ad748 feat(nix): scoped checks and a suite helper in the core 2026-10-30 12:03:01 -07:00
LGUG2Z 15d6a5aef3 feat(nix): exe_id spells the id of a rule for a program 2026-10-30 12:03:00 -07:00
LGUG2Z dbe84192d4 feat(nix): an optional komorebi-recorder in the core suites 2026-10-30 12:03:00 -07:00
LGUG2Z 2e078f9ef6 feat(nix): config reload, exe rules and lock scenarios in the core 2026-10-30 12:03:00 -07:00
LGUG2Z 733a5a4934 feat(nix): the rules_class scenario, and an app id for Platform.spawn
A workspace rule by class sends a window to its workspace, an ignore
rule by class leaves one alone, and a window of another class stays
where it opened. Platform.spawn takes an app_id, which is foot's -a on
KDE and the window class on Windows. core-e2e passes 271 checks on KDE.
2026-10-30 12:03:00 -07:00
LGUG2Z e375d0a151 feat(nix): the scrolling scenario
In the scrolling layout each window in turn, given the focus, has it
and is inside the work area; changed back to bsp, every window is where
the layout says. core-e2e passes 265 checks on KDE.
2026-10-30 12:03:00 -07:00
LGUG2Z 672a6951bd feat(nix): the lifecycle_hidden scenario
A window put away on another workspace is managed again after the
daemon stops and starts, and the ones in view are inside the work area
and clear of each other. KdePlatform.start_komorebi waits for the unit
to be gone first: systemctl start does nothing for a unit that is still
stopping, and a daemon with a window put away took longer to exit.
core-e2e passes 261 checks on KDE.
2026-10-30 12:03:00 -07:00
LGUG2Z 74ddcce4d9 feat(nix): the tiling_off scenario
toggle-tiling leaves the windows where they are, a layout change moves
none of them, and toggled again every window is tiled where the layout
says. core-e2e passes 254 checks on KDE.
2026-10-30 12:03:00 -07:00
LGUG2Z 6e111411e7 feat(nix): the pausing scenario
A window that opens while the daemon is paused is not managed; after
toggle-pause again the next one is, and every window is where the
layout says. core-e2e passes 248 checks on KDE.
2026-10-30 12:03:00 -07:00
LGUG2Z d58353d22e feat(nix): the flipping scenario
flip-layout horizontal puts every window where the mirror of its place
is, with every window where the layout says, and flipping again gives
the places back. core-e2e passes 244 checks on KDE.
2026-10-30 12:03:00 -07:00
LGUG2Z 63d5833a84 feat(nix): the promoting scenario
promote puts the focused window on the first tile and keeps its focus,
with every window where the layout says. core-e2e passes 241 checks on
KDE.
2026-10-30 12:03:00 -07:00
LGUG2Z 9b1162dcbe feat(nix): the resize_commands scenario
resize-axis horizontal increase widens the focused window and decrease
gives the width back, with every window inside the work area and none
over another, and no pointer. core-e2e passes 237 checks on KDE.
2026-10-30 12:03:00 -07:00
LGUG2Z a8b30e1c1b feat(nix): the workspace_moves scenario
move-to-workspace takes a window to another workspace and the focus
with it, focus-last-workspace goes back and forth, and moving the window
home tiles everything again. core-e2e passes 233 checks on KDE.
2026-10-30 12:03:00 -07:00
LGUG2Z f1ea111fd0 feat(nix): the maximizing scenario
toggle-maximize gives a window the work area, with the others where they
were and the daemon naming it as the maximized window; toggled again,
every window is tiled where the layout says. core-e2e passes 225 checks
on KDE.
2026-10-30 12:03:00 -07:00
LGUG2Z d4d356c70e feat(nix): the padding scenario, and padding in Snapshot
Raising the workspace padding moves the windows in from the edge by as
much, and raising the container padding leaves them less room; putting
the padding back gives back the windows' frames. The measure is of the
padding the scenario sets itself: on KDE the state says 0 and 0 while
the windows sit 10 px in, and the first run's padding is not what the
state says. Workspace has workspace_padding and container_padding now.
core-e2e passes 220 checks on KDE.
2026-10-30 12:03:00 -07:00
LGUG2Z 4471cc01a8 feat(nix): the minimizing scenario, and Platform.minimize
A minimized window leaves its room to the others, and a restored one
takes it back. Platform.minimize is new: the title bar button on KDE;
activate restores. core-e2e passes 213 checks on KDE.
2026-10-30 12:03:00 -07:00
LGUG2Z 4835907b2e feat(nix): the layouts and floating scenarios
layouts changes the layout of the first workspace to each of eight, with
three windows and with five, and checks every window is where the
daemon's layout says, inside the work area and clear of the others.
floating floats a window, checks the others take its room, and that
floating it again tiles it back. Both run in core-e2e: 209 checks pass
on KDE.
2026-10-30 12:03:00 -07:00
LGUG2Z 4158f63557 fix(nix): focus_follows_mouse rests the pointer over the focused window
On again, the scenario moved the pointer over the first window, which
already had the focus, so it waited for nothing and moved on to the
second at once. A platform that follows the pointer by a hover delay
never saw it enter the first. The pointer now rests there for a
moment, as it would for a person.
2026-10-30 12:03:00 -07:00
LGUG2Z ddab35b5b9 feat(nix): the focus_follows_mouse scenario, with a pointer
With focus follows mouse on, the pointer over a window gives it the
focus, and the daemon follows; turned off, it moves nothing; turned on
again, it follows again. The scenario needs a pointer and is skipped
without one. The toggle passes --implementation windows, which kfw's
subcommand requires. drag-resize runs it after resize.
2026-10-30 12:03:00 -07:00
LGUG2Z efeaafad28 feat(nix): the startup_rules scenario, workspace rules of a file
A window that was open before the daemon, and one that opens after, go
to the workspace a rule in the config names, by the start of their
title; a window no rule names stays on the first. The rule is in the
file, so what is checked is how the file is read at start. core-e2e
runs it as section 12a2.
2026-10-30 12:03:00 -07:00
LGUG2Z b1e041f53d feat(nix): placement takes known failures by case
A port that cannot start with a case's rules, or orders its windows
otherwise, is recorded as a known failure for that case, and the other
cases run on. kfw does not accept the place as a JSON number, so
BEHAVIOUR.md lists the case as a known failure there.
2026-10-30 12:03:00 -07:00
LGUG2Z b5e9cf5301 feat(nix): the placement scenario, and Platform.restart_with
Where a window that opens goes, from the placement rules of the
config: none, Primary, a number as a number and as text, and rules by
title for the first and the last place. restart_with starts the daemon
afresh with a komorebi.json the scenario gives. KdePlatform.spawn
quotes the title, which a title with spaces needs. core-e2e runs it as
section 12a.
2026-10-30 12:03:00 -07:00
LGUG2Z 8fc7c961d0 feat(nix): known failures, with unknown_monitor the first
Checks.known_failure records a check that fails for a reason that is
to be followed up on: the suite does not fail, the totals say how many
known failures there are, and one that holds fails the suite so the
marker goes. unknown_monitor takes the reason, and core-e2e runs it
last, because the window it loses stays lost. BEHAVIOUR.md says so.
2026-10-30 12:03:00 -07:00
LGUG2Z 54d866f83a feat(nix): rules, a window the cleared rules matched stays put
After clear-all-workspace-rules a window that the old rules matched
opens on the workspace in view and stays there. The first window of
that title is closed before the next opens, because the title is how
a window is named on both ports.
2026-10-30 12:03:00 -07:00
LGUG2Z 6dbc4d8f63 feat(nix): the lifecycle scenario, a daemon that starts again
The daemon stops, every window stays, and a daemon that starts again
manages the windows that were in view, tiled inside the work area and
clear of each other, and also a window opened afterwards. The fake
platform learns to stop and to start with no memory of workspaces.
core-e2e runs it before its final stop.
2026-10-30 12:03:00 -07:00
LGUG2Z 93c786242b feat(nix): give the sweep's toggle-focus-follows-mouse its option
kfw declares the subcommand with arg_required_else_help, so without an
argument it prints help and exits 2, although the option has a default.
kfde accepts the same option, so the sweep passes it explicitly:
--implementation windows, the default on both ports.
2026-10-30 12:03:00 -07:00
LGUG2Z 32b08d1b77 feat(nix): unknown_monitor, a window sent to no monitor must stay managed
The scenario sends the focused window to monitor 7 with send-to-monitor and
move-to-monitor, which no display has, and checks that the daemon still
manages every window. A port may refuse or ignore the command, but a window
that was managed has to stay so: one that is not is left on the screen with
nothing tiling it.

It found a bug in both ports. kfw managed one window fewer than the OS had
afterwards (seen by hand on a Windows guest), and kfde failed it in
core-e2e on a real KWin: move_container_to_monitor takes the focused
container out of its workspace before it looks the monitor up, so the
error for a monitor that is not there comes after the container is gone.
It is not fixed, so the scenario is not in core-e2e, which would fail;
BEHAVIOUR.md has the finding. Its unit tests run it against a fake that
loses the window and one that ignores the command.
2026-10-30 12:03:00 -07:00
LGUG2Z b22ae83e6a feat(nix): the command sweep plugs in a second display when it needs one
The sweep has commands that name the second monitor, send-to-monitor 1 and
the ones after it, so it needs two displays. The KDE suite runs with two
outputs and never noticed. On Windows, with one display, the first run of
the sweep reported that after send-to-monitor 1 kfw managed one window
fewer than the OS had, and every command after it was reported unhealthy;
whether that is kfw losing a window sent to a monitor that does not exist
has not been confirmed by hand. The sweep now plugs in a display first if
the platform has one, and a fake with one display shows it does.
2026-10-30 12:03:00 -07:00
LGUG2Z 1c0bc9eae9 feat(nix): the commands, rules and hotplug scenarios, for every platform
commands is every layout, a sweep of 216 commands and the commands that
only print, each of which must be understood and leave the daemon healthy
(it answers state and manages the windows the OS has). A command the port
lacks, which komorebic says with 'unrecognized subcommand', is skipped with
its name, which is what a behaviour matrix is made of: Checks.skip records
it and finish prints how many. The commands suite runs it instead of its
own copy of the list: 270 checks pass, none skipped.

rules gives the daemon an initial rule, a rule that is not, and an ignore
rule, by title, and checks where each window goes. It found that
enforce-workspace-rules applies initial rules again on purpose, so the
scenario asks whether the daemon sends the window back on its own.

hotplug unplugs a display, plugs one in and sends a window to it, and
starts by plugging one in if the platform has only one. Platform gets
displays, add_display and remove_display, and KdePlatform does them with
kscreen-doctor. The hotplug suite runs it: 34 checks pass.

core-e2e runs rules after the others, then leaves a window for the stop to
leave behind: 130 checks pass on KVM. One run failed the check that the
daemon had exited after komorebic stop and the next did not; the cause is
not known, and the suite now prints the unit's status when it happens.
Snapshot.workspace_of tells which workspace has a window.
2026-10-30 12:03:00 -07:00
LGUG2Z ed792445d0 feat(nix): the monocle and closing scenarios, and Platform.close
monocle toggles monocle on the focused window and checks that it fills the
work area up to the layout's padding, that the state has it as the monocle
container, that every other window is put away, that it keeps the focus,
and that toggling back puts every window in view on the tile it had.
closing closes a window and checks that the OS has no frame for it, that
the daemon manages one window fewer, and that the windows left in view
take more room between them, inside the work area and clear of each other.

Platform.close closes a window as its button would; KdePlatform does it
with kdotool. The fake daemon models monocle and closing, and its
os_window now knows the workspace a window is on, which the workspaces
scenario had passed without. core-e2e runs both: 120 checks pass on KVM.
2026-10-30 12:03:00 -07:00
LGUG2Z 37b75f8205 feat(nix): the resize scenario and a pointer on the Platform
Platform.has says whether a platform can do what a scenario needs, and
Platform.pointer is a Pointer (move, down, up, drag) where it has one;
KdePlatform takes the pointer of a session node. scenarios.resize drags the
edge two tiles share by 60 pixels and checks that the tiles that end at the
edge are that much wider, the ones that start after it start that much
later and end where they did, nothing moves up or down, and tiles that do
not touch the edge are where they were. A platform with no pointer skips
it, and says so.

The fake daemon has a pointer that moves an edge. The scenario runs on KDE
at the end of drag-resize: 19 checks pass on KVM. Its first run failed one
check that was the scenario's: both tiles of a BSP column share the dragged
edge, and the check took the second for one that had not moved.
2026-10-30 12:03:00 -07:00
LGUG2Z e385bace05 test(nix): Snapshot against states recorded from both ports
core-e2e writes the komorebic state of kfde, with three tiled windows and
with one stacked onto another, into its output, and the files are kept in
tests/fixtures beside kfw's three, recorded from a Windows guest (tiled,
stacked, one window floated). test_recorded.py reads all five with the
same checks: three containers of one window, a layout rectangle for each
inside the work area, each window where its container's rectangle is up to
a terminal cell (foot rounds to cells, kfw's test window does not), and a
stack that is a container of two whose focused window is the one the ring
names. Nothing in the parser had to change; the checks passed on the first
real kfw state.

The scenes written from the serializers stay for the shapes no run has
recorded. The sync script copies the fixtures too. The workspaces scenario
prints which windows are in view after the switch: one run of core-e2e
failed that check and passed on the next, and the log did not say which
window had been in view.
2026-10-30 12:03:00 -07:00
LGUG2Z 030e580a49 build(repo): sync the neutral core to kfw while it is on its way there
scripts/sync-e2e-core copies komorebi_vm.core and the unit tests that
belong to it into another directory, and --check says whether the copy is
in step, so that kfw's Windows platform can be written against the code it
will run with while the move is not made. This repository is the source
until the move, and the script goes with it.

Two of those tests imported Rect and Checks from komorebi_vm, which pulls
in the KDE half; they import them from komorebi_vm.core now. The copy
passes its 25 tests in a directory with nothing but pytest and Pillow.
2026-10-30 12:02:55 -07:00
LGUG2Z c59f5dddd0 build(nix): scale of 1.5 on every Linux host, and what the suites take on WSL 2
latency measured a p95 of 128.9 ms against its 100 ms times scale on the
WSL2 machine, under nested KVM with nothing else running, where x86-1 had
passed it at scale 1. Every Linux host is no faster than a Mac to the
suites that time the daemon, so scale is 1.5 on all of them: latency
passes at it with a p95 of 132.4 ms against 150 ms. The run-to-run
difference (p50 46.0 ms, then 70.0) is as large as the margin left, which
PLATFORM.md says.

PLATFORM.md records the wall times of the suites on this machine. All 33
were run there after the library was split: 32 passed at scale 1, and
latency is the one that failed. The other 32 were not rerun at 1.5, which
changes their derivations.
2026-10-30 12:02:55 -07:00
LGUG2Z 875a9ef41d feat(nix): the workspaces scenario, for every platform
workspaces sends the focused window to workspace 1, checks that it is put
away and that the daemon has it there while the others stay in view,
switches to workspace 1 and checks that only that window is in view and has
the focus, and switches back.

hidden now says a window is out of sight for any reason the daemon has: on
KDE that is the parking desktop and also a desktop that is not the one in
view. Snapshot's workspace, containers and focused_title take the focused
workspace when none is given, and the fake daemon has two workspaces. The
scenario passes in core-e2e on KVM: 106 checks.
2026-10-30 12:02:55 -07:00
LGUG2Z 0f73ba3a55 feat(nix): the stacks scenario, and Platform.hidden
hidden says that a window exists but the daemon has put it away: the others
of a stack, here, and later those of another workspace or behind a monocle.
It is a window on the parking desktop on KDE and will be a cloaked one on
Windows. scenarios.stacks stacks the focused window onto its neighbor,
cycles the stack, checks that the window in view has the focus and fills
the tile the first had, and takes the stack apart.

The scenario's fake daemon now models stacks. Running it on KDE found a bug
in Snapshot: focused_title took the first window of the focused container,
and a stack's focused window is the one its ring names. Snapshot keeps that
index now. core-e2e runs the scenario after the others: 98 checks pass on
KVM.
2026-10-30 12:02:55 -07:00
LGUG2Z c861f4f789 feat(nix): the focus and moving scenarios, for every platform
focus moves the focus with focus and cycle-focus and checks that the OS and
the daemon's state agree on the window that has it and that no window moved.
moving swaps the focused window with its neighbor with move and puts every
window back with cycle-move, and checks that the focus stays with it. Both
read the windows through the Platform, so they are what kfw's suite will
run.

Their unit tests run against a fake daemon that follows the commands over
three tiles, and against two that do not (a move that moves nothing, a move
that loses the focus). core-e2e runs them after tiling on KDE: 85 checks
pass on KVM.
2026-10-30 12:02:55 -07:00
LGUG2Z bb8299410f feat(nix): KDE as a Platform, and the tiling scenario in core-e2e
KdePlatform is a Kde session seen through the neutral vocabulary: kdotool
for the OS's frames, foot for clients, the cell of its font as the
tolerance. The core-e2e suite runs scenarios.tiling through it as a new
section, so that the scenario that will run on Windows is checked on the
one platform that works; the suite's own sections are unchanged. It passes
on KVM (74 checks) on the WSL2 machine.
2026-10-30 12:02:55 -07:00
LGUG2Z 2c5e8f57dc feat(nix): the Platform protocol and the first neutral scenario
A scenario drives the daemon and looks at the desktop only through a
Platform: start the daemon, komorebic, state as a Snapshot, spawn a window,
os_window (the OS's own account of its frame, which is the oracle: the
daemon's state is what is under test), work_area, activate and screenshot.
Only what a scenario uses is there; a method is added with the first
scenario that needs it.

scenarios.tiling opens windows and checks, against the OS's frames, that
each is where the layout says, inside the work area and clear of the
others. Its tests run it against a fake platform that tiles correctly and
against two that do not.
2026-10-30 12:02:55 -07:00
LGUG2Z b02df47e34 feat(nix): Snapshot, the daemon's state in one shape for every port
komorebic state prints a different JSON on kfde and on kfw: a window is
{id, rect, details} on one and {hwnd, title, exe, class, rect} on the
other, and a monitor and the state itself have fields the other lacks.
core.snapshot.parse reads either into monitors, workspaces, containers and
windows with the same names, keeping what only one has in Snapshot.extra,
so that a scenario does not have to care which port it runs on.

The fixtures in its tests are written from the two serializers, not
recorded; they are replaced by recorded states once a run on each port
exists.
2026-10-30 12:02:55 -07:00
LGUG2Z a37a9faf3d refactor(nix): a platform-neutral core in the VM library
Checks, Rect and the pixel helpers depend on no compositor. They move to
komorebi_vm.core, which may not import komorebi_vm.kde, so that the package
can go to the Windows port unchanged. komorebi_vm re-exports them and no
suite changes. This is the first step of the cross-platform e2e plan.
2026-10-30 12:02:55 -07:00
LGUG2Z 0e8e25957c build(nix): the demo guest as a VM suite
The demo guest is what the command `run-kde` starts, so it should not stop
working between the times somebody runs it by hand. The suite `run-kde` puts the
guest module, nix/dev/run-kde.nix, on the session node, as the rdp suite does
with krdp.nix, and checks what only a booted session can say: the demo opens two
Konsole windows, Kate and Dolphin and komorebi tiles them clear of the panel,
the cheat sheet is a window that is not a tile, what it shows of `komorebic
check` has no error, and KWin says what it draws with.

The node makes the directory the host shares as the guest finds it once it has
mounted it: owned by a user the guest does not have, with a password and a
public key in it. The suite checks that the guest takes them as root before the
login, that ssh lets in that key and no other, that KRDP starts by itself and
listens, and that a client with the password is let in and shows the display.

The client of those RDP checks moves from the rdp suite into the library as
RdpClient, with unit tests against the fake machine, so that both suites run the
same checks; the machine protocol gains copy_from_machine for it.
2026-10-28 14:20:08 -07:00
LGUG2Z 8b9cde08d0 build(nix): Plasma guests to develop against
The VM tests boot a machine, run a scenario and power it off. Trying a change by
hand needs a Plasma session that stays up, and on a Mac, one that renders on its
GPU.

nix/dev/plasma-vm.nix is a guest for QEMU on an Apple silicon Mac, headless or
with a Plasma session that logs in by itself, and nix/dev/plasma-utm.nix is that
session as a disk image for UTM, whose QEMU renders on the Mac's GPU. They are
nixosConfigurations of the flake, and install komorebi with services.komorebi
from the flake's packages. They carry no key, password or configuration of
anyone's: the console logs in by itself, ssh takes the keys a user puts in the
guest, and the RDP password is a file in the guest. plasma-guests-eval evaluates
the three on every system.

nix/dev/krdp.nix runs KRDP in the session, and the slow suite vm-rdp runs the
same unit in the session node: it waits for a password and listens once it has
one, FreeRDP's client is let in with the password and not with another, and the
picture the client gets on an X server of its own is the display. FreeRDP
decodes KRDP's H.264 with OpenH264 and shows nothing, so the guests' client is
built without it and decodes with FFmpeg. Keys over RDP stay unverified, since
no client can script them against KRDP; PLATFORM.md says so and what the suite
checks.

docs/dev/utm.md says how to build and run the guests, and what a builder has to
be.
2026-10-28 07:39:49 -07:00
LGUG2Z 9cb26daf38 build(nix): keybindings in the module
On NixOS the key bindings belong in the configuration, with the rest of
komorebi. services.komorebi.keybindings takes the format (skhd, whkd or sxhkd),
the bindings as text or as a file (exactly one of the two, asserted), the mode
(auto, engine or static; engine by default, as PlanMode::default() is),
chordTimeout (3000 ms), layout (us, the only one), strict and appAliases. skhd's
.load is refused by an assertion: the file it reads would not be in the store.

At build time the module runs komorebic hotkeys compile on the file in the
package komorebi-keybindings, whose share/kglobalaccel goes into the system
profile, where KWin finds the static shortcuts when the session starts. Its
diagnostics are in the build log and in diagnostics.txt, and strict passes
--strict, which fails the build on a warning or an error. execStart gains
--keybindings with the same store file, its format and mode, --chord-timeout and
an --app-alias per alias, so the daemon plans the file as the build did and runs
the bindings the build left to the engine. The unit already releases the keys
after the daemon stops.

The check keybindings-fixtures runs every file of the fixture corpus through
komorebic hotkeys compile --mode auto --dry-run, the command the module runs,
and diffs what it prints against nix/tests/keybindings.expected; it also checks
that docs/{skhdrc,whkdrc,sxhkdrc}.sample are the corpus's sample case.
nixos-module-eval gains the key binding scenarios: text, file, both, no format,
.load and a layout that is not us, and one with the typed config together with
key bindings, whose execStart has the checked file and then the keys. The corpus
gains the case vm, in the three formats: a binding a shortcut file can hold, and
one on the comma key, which X-KDE-Shortcuts cannot, so that the engine runs it
in auto mode. The VM suites vm-keys-skhd, vm-keys-whkd and vm-keys-sxhkd
configure the module with that case in their format and press both keys; they
share one script through the generator's script attribute.

For strict, nixos-module-eval has two scenarios with the same skhd text, which
has a line komorebic cannot read: strict = true and the default. Evaluation
never reads the key bindings, so the checks read the script of the build: with
strict it runs hotkeys compile --strict and exits 1 when that fails, without it
there is no --strict and the diagnostics are only printed to the build log. A
third check says the daemon gets the same command line either way. ARCHITECTURE
names them in the row for strict.

komorebic quickstart writes the sample skhdrc next to komorebi.json and
applications.json, from docs/skhdrc.sample, where the daemon and hotkeys compile
read it; the flake's source filter keeps that file for the build.

Docs: the user guide docs/usage/keybindings.md, the three sample files,
docs/example-configurations.md for KDE and NixOS, the options in
docs/installation.md, and the module's section of ARCHITECTURE. Whether the
engine or static shortcuts should be the default stays open in DESIGN: a static
shortcut took 233 ms to run its command at the median on KWin 6.8.1, the engine
3 ms, but only the static shortcut survives a dead daemon.
2026-10-28 07:39:49 -07:00
LGUG2Z 2f61b62276 feat(kwin): survive restarts of the daemon and KWin
kglobalaccel keeps the actions of a client that died, and their keys: a daemon
that is killed leaves its keys swallowed and running nothing until they are
unregistered. And kglobalaccel runs inside KWin, so a KWin that restarts forgets
every key komorebi registered. Neither should leave a user without keys.

kwin::hotkeys::release unregisters every action of the component, whatever
registered it, and komorebic hotkeys release runs it, with or without a daemon.
The NixOS module's unit runs it after the daemon stops (ExecStopPost), however
it stops, and a start already takes over what is left. The KWin backend's
NameOwnerChanged watch now also follows org.kde.kglobalaccel: when it has an
owner again, kwin::hotkeys::rebind loads the key bindings into the new one,
trying for 15 seconds.

Loading moves from the daemon's main into kwin::hotkeys::load, which keeps its
settings (Keybindings: file, format, plan mode, engine options), so that reload
can read the file again: the message ReloadHotkeys, komorebic hotkeys reload. A
new engine replaces the running one without unregistering its keys, and takes
them over as a start does, so the keys both files have stay grabbed. The message
HotkeysState answers with the engine's mode, the combos it holds and whether a
chain is pending (null without an engine); komorebic hotkeys state prints it
with the actions kglobalaccel has for the component. komorebic now depends on
komorebi for the two calls to kglobalaccel, and on serde_json for the state.

Tests: the socket messages without key bindings, state and release without a
session bus, reload without a daemon, and a nixos-module-eval check of
ExecStopPost. The VM test vm-restart-survival runs the module's unit in a Plasma
session: a key works, hotkeys state shows it; with the daemon stopped by SIGSTOP
the key runs nothing until hotkeys release gives it back; after SIGKILL the
unit's journal shows the release and the restarted daemon has the key; after the
KWin process is killed, the daemon registers the key with the new KWin; and a
reload of a changed file swaps the key.

vm-keys-engine asks the engine and does not sleep. A key that is not grabbed yet
reaches the focused window, which showed as a binding that does not run, so the
suite presses one once komorebic hotkeys state answers, which it does when the
engine has made the calls of its last event: for a mode, for a chord chain
beginning and ending, and for the keys of the application that takes the focus.
It waits for the old daemon to exit before it starts the next (a daemon started
meanwhile failed to load its KWin script), and activates a window until KWin has
it (KWin lists a window before it can have the focus). The last check reloads
the key bindings with komorebic hotkeys reload while wev has the focus and every
binding is for the terminal, a start with no key to grab.
2026-10-28 07:39:49 -07:00
LGUG2Z 47d3a471d7 feat(kwin): per-application key bindings follow the focus
skhd and whkd can give one key a different action in each application, or none
(skhd's ~, whkd's Ignore), and skhd has a blacklist of applications in which no
key is taken. The engine decides from the focused application whether such a key
is active: inactive, it reaches the application, which is how a key passes
through. What it needs is to be told which application has the focus.

The bridge reports the desktop entry of every window with its class, and the
table now keeps it. Table::focused_application returns the executable, the app
id (or X11 class) and the desktop entry of the window KWin activated last, a
dialog included, or nothing once that window is gone. The KWin backend hands it
to kwin::hotkeys::focus after every event of the bridge; only a change reaches
the engine's thread, and an engine that starts begins with the focus as it was
last seen. The engine matches the names of the file against the three, ignoring
case.

The names in an skhdrc or a whkdrc are those of macOS and Windows applications,
so the daemon takes --app-alias NAME=ALIAS[,ALIAS]..., more than once, for the
engine's app_aliases.

Unit tests cover the focus of the table and the calls of a scoped key as the
focus moves, an alias included. The VM test vm-keys-engine grows a section with
wev and foot open and --app-alias terminal=foot: in wev, Alt+G (for the terminal
only) and Alt+N (which wev ignores) reach wev and run nothing; in foot both run
their bindings; back in wev, Alt+G reaches wev again.
2026-10-28 07:39:49 -07:00