4 files changed, 1260 insertions, 136 deletions

diff --git a/accounts/gkleen@sif/niri/default.nix b/accounts/gkleen@sif/niri/default.nix
index 6a8d10a0..8752f3e3 100644
--- a/accounts/gkleen@sif/niri/default.nix
+++ b/accounts/gkleen@sif/niri/default.nix
@@ -1,15 +1,234 @@
-{ config, pkgs, lib, ... }:
+{ config, hostConfig, pkgs, lib, flakeInputs, ... }:
 let
-  niri = config.programs.niri.package;
+  cfg = config.programs.niri;
+
+  kdl = flakeInputs.niri-flake.lib.kdl;
+
+  niri = cfg.package;
   terminal = lib.getExe config.programs.kitty.package;
-  lightctl = lib.getExe' config.services.avizo.package "lightctl";
-  volumectl = lib.getExe' config.services.avizo.package "volumectl";
-  dunstctl = lib.getExe' config.services.dunst.package "dunstctl";
+  makoctl = lib.getExe' config.services.mako.package "makoctl";
+  loginctl = lib.getExe' hostConfig.systemd.package "loginctl";
+  systemctl = lib.getExe' hostConfig.systemd.package "systemctl";
+  swayosd-client = lib.getExe' config.services.swayosd.package "swayosd-client";
+
+  focus_or_spawn = pkgs.writeShellApplication {
+    name = "focus-or-spawn";
+    runtimeInputs = [ niri pkgs.gojq pkgs.gnugrep pkgs.socat ];
+    text = ''
+      window_select="$1"
+      shift
+      workspace_name="$1"
+      shift
+
+      workspaces_json="$(niri msg -j workspaces)"
+      workspace_output="$(jq -r --arg workspace_name "$workspace_name" '.[] | select(.name == $workspace_name) | .output' <<<"$workspaces_json")"
+      # active_workspace="$(jq -r --arg workspace_output "$workspace_output" '.[] | select(.output == $workspace_output and .is_active) | .id' <<<"$workspaces_json")"
+      active_output="$(jq -r '.[] | select(.is_focused) | .output' <<<"$workspaces_json")"
+      if [[ $workspace_output != "$active_output" ]]; then
+        niri msg action move-workspace-to-monitor --reference "$workspace_name" "$active_output"
+        # socat STDIO "$NIRI_SOCKET" <<<'{"Action":{"FocusWorkspace":{"reference":{"Id":'"''${active_workspace}"'}}}}'
+        # niri msg action move-workspace-to-index --reference "$workspace_name" 1
+      fi
+
+      while IFS=$'\n' read -r window_json; do
+        if [[ -n $(jq -c "$window_select" <<<"$window_json") ]]; then
+          if jq -e '.is_focused' <<<"$window_json" >/dev/null; then
+            niri msg action focus-workspace-previous
+          else
+            if [[ $(jq -r --arg workspace_name "$workspace_name" 'map(select(.name == $workspace_name)) | .[0].is_focused' <<<"$workspaces_json") != "true" ]] && [[ $(jq -r --arg workspace_name "$workspace_name" 'map(select(.name == $workspace_name)) | .[0].id' <<<"$workspaces_json") = $(jq -r '.workspace_id' <<<"$window_json") ]]; then
+                niri msg action focus-workspace "$workspace_name"
+            else
+                niri msg action focus-window --id "$(jq -r '.id' <<<"$window_json")"
+            fi
+          fi
+          exit 0
+        fi
+      done < <(niri msg -j windows | jq -c '.[]')
+
+      exec "$@"
+    '';
+  };
+  focus-or-spawn-action = config.lib.niri.actions.spawn (lib.getExe focus_or_spawn);
+
+  with_adjacent_workspace = pkgs.writeShellApplication {
+    name = "with-adjacent-workspace";
+    runtimeInputs = [ niri pkgs.gojq pkgs.socat ];
+    text = ''
+      blacklist="$1"
+      shift
+      direction="$1"
+      shift
+      action="$1"
+      shift
+
+      workspaces_json="$(niri msg -j workspaces)"
+      active_workspace="$(jq -r '.[] | select(.is_focused) | .id' <<<"$workspaces_json")"
+      workspace_output="$(jq -r --arg active_workspace "$active_workspace" '.[] | select(.id == ($active_workspace | tonumber)) | .output' <<<"$workspaces_json")"
+      workspace_idx="$(jq -r '.[] | select(.is_focused) | .idx' <<<"$workspaces_json")"
+
+      jq_script='map(select('
+      case "$direction" in
+        down)
+          # shellcheck disable=SC2016
+          jq_script=''${jq_script}'.idx > ($workspace_idx | tonumber)';;
+        up)
+          # shellcheck disable=SC2016
+          jq_script=''${jq_script}'.idx < ($workspace_idx | tonumber)';;
+      esac
+      # shellcheck disable=SC2016
+      jq_script=''${jq_script}' and .output == $workspace_output and ((.name == null) or (.name | test($blacklist) | not)))) | sort_by(.idx)'
+      [[ $direction == "up" ]] && jq_script=''${jq_script}' | reverse'
+      jq_script=''${jq_script}' | .[0]'
+
+      workspace_json=$(jq -c --arg blacklist "$blacklist" --arg workspace_output "$workspace_output" --arg workspace_idx "$workspace_idx" "$jq_script" <<<"$workspaces_json")
+      [[ -n $workspace_json && $workspace_json != null  ]] || exit 0
+      jq --arg active_workspace "$active_workspace" -c "$action" <<<"$workspace_json" | tee /dev/stderr | socat STDIO "$NIRI_SOCKET"
+    '';
+  };
+  with-adjacent-workspace-action = config.lib.niri.actions.spawn (lib.getExe with_adjacent_workspace) "^${lib.concatMapStringsSep "|" ({ name, ...}: name) cfg.scratchspaces}$";
+  focus-adjacent-workspace = direction: with-adjacent-workspace-action direction ''{"Action":{"FocusWorkspace":{"reference":{"Id": .id}}}}'';
+  move-column-to-adjacent-workspace = direction: with-adjacent-workspace-action direction ''{"Action":{"MoveColumnToWorkspace":{"reference":{"Id": .id}, "focus": true}}}'';
+
+  with_unnamed_workspace = pkgs.writeShellApplication {
+    name = "with-unnamed-workspace";
+    runtimeInputs = [ niri pkgs.gojq pkgs.socat ];
+    text = ''
+      action="$1"
+      shift
+
+      workspaces_json="$(niri msg -j workspaces)"
+      active_output="$(jq -r '.[] | select(.is_focused) | .output' <<<"$workspaces_json")"
+      active_workspace="$(jq -r '.[] | select(.is_focused) | .id' <<<"$workspaces_json")"
+
+      history_json="$(socat STDIO UNIX-CONNECT:"$XDG_RUNTIME_DIR"/niri-workspace-history.sock)"
+      workspace_json="$(jq -c --arg active_output "$active_output" --argjson history "$history_json" 'map(select(.output == $active_output and .name == null)) | map({"value": ., "history_idx": ((. as $workspace | ($history[$active_output] | index($workspace | .id))) as $active_idx | if $active_idx then $active_idx else ($history[$active_output] | length) + 1 end)}) | sort_by(.history_idx, .value.idx) | map(.value) | .[0]' <<<"$workspaces_json")"
+      [[ -n $workspace_json && $workspace_json != null ]] || exit 0
+      jq --arg active_workspace "$active_workspace" -c "$action" <<<"$workspace_json" | tee /dev/stderr | socat STDIO "$NIRI_SOCKET"
+    '';
+  };
+  with-unnamed-workspace-action = config.lib.niri.actions.spawn (lib.getExe with_unnamed_workspace);
+
+  with_empty_unnamed_workspace = pkgs.writeShellApplication {
+    name = "with-empty-unnamed-workspace";
+    runtimeInputs = [ niri pkgs.gojq pkgs.socat ];
+    text = ''
+      action="$1"
+      shift
+
+      workspaces_json="$(niri msg -j workspaces)"
+      active_output="$(jq '.[] | select(.is_focused) | .output' <<<"$workspaces_json")"
+      target_workspace_id="$(jq --argjson active_output "$active_output" 'map(select(.active_window_id == null and .name == null and .output == $active_output)) | sort_by(.idx) | .[0].id' <<<"$workspaces_json")"
+      jq --argjson workspace_id "$target_workspace_id" -nc "$action" | tee /dev/stderr | socat STDIO "$NIRI_SOCKET"
+    '';
+  };
+  with-empty-unnamed-workspace-action = config.lib.niri.actions.spawn (lib.getExe with_empty_unnamed_workspace);
+
+  with_select_window = pkgs.writeShellApplication {
+    name = "with-select-window";
+    runtimeInputs = [ niri pkgs.gojq pkgs.socat config.programs.fuzzel.package pkgs.gawk ];
+    text = ''
+      window_select="$1"
+      shift
+      action="$1"
+      shift
+
+      windows_json="$(niri msg -j windows)"
+      active_workspace="$(jq -r '.[] | select(.is_focused) | .workspace_id' <<<"$windows_json")"
+      window_ix="$(gojq -r --arg active_workspace "$active_workspace" '.[] | select('"$window_select"') | "\(.title)\u0000icon\u001f\(.app_id)"' <<<"$windows_json" | fuzzel --width=60 --log-level=warning --dmenu --index)"
+      # shellcheck disable=SC2016
+      window_json="$(gojq -rc --arg active_workspace "$active_workspace" --arg window_ix "$window_ix" 'map(select('"$window_select"')) | .[($window_ix | tonumber)]' <<<"$windows_json")"
+
+      [[ -z "$window_json" ]] && exit 1
+
+      jq -c "$action" <<<"$window_json" | socat STDIO "$NIRI_SOCKET"
+    '';
+  };
+  with-select-window-action = config.lib.niri.actions.spawn (lib.getExe with_select_window);
+
+  with_predicate_window = pred: pkgs.writeShellApplication {
+    name = "with-predicate-window";
+    runtimeInputs = [ niri pkgs.gojq pkgs.socat ];
+    text = ''
+      action="$1"
+      shift
+
+      windows_json="$(niri msg -j windows)"
+      window_json="$(gojq -rc 'map(select(${pred})) | .[0]' <<<"$windows_json")"
+
+      [[ -z "$window_json" || $window_json = "null" ]] && exit 1
+
+      jq -c "$action" <<<"$window_json" | socat STDIO "$NIRI_SOCKET"
+    '';
+  };
+
+  with-urgent-window-action = config.lib.niri.actions.spawn (lib.getExe (with_predicate_window ".is_urgent"));
+  with-focused-window-action = config.lib.niri.actions.spawn (lib.getExe (with_predicate_window ".is_focused"));
 in {
   imports = [
     ./waybar.nix
+    ./mako.nix
+    ./swayosd.nix
   ];
 
+  options = {
+    programs.niri.scratchspaces = lib.mkOption {
+      type = lib.types.listOf (lib.types.submodule ({ config, ... }: {
+        options = {
+          name = lib.mkOption {
+            type = lib.types.str;
+          };
+          match = lib.mkOption {
+            type = lib.types.listOf (lib.types.attrsOf kdl.types.kdl-args);
+            default = [];
+          };
+          exclude = lib.mkOption {
+            type = lib.types.listOf (lib.types.attrsOf kdl.types.kdl-args);
+            default = [];
+          };
+          windowRuleExtra = lib.mkOption {
+            type = kdl.types.kdl-nodes;
+            default = [];
+          };
+          key = lib.mkOption {
+            type = lib.types.nullOr lib.types.str;
+            default = null;
+          };
+          moveKey = lib.mkOption {
+            type = lib.types.nullOr lib.types.str;
+            default = let
+              keys = lib.splitString "+" config.key;
+              defMoveKey = lib.concatStringsSep "+" (lib.flatten [
+                (lib.take (lib.length keys - 1) keys)
+                ["Shift"]
+                (lib.takeEnd 1 keys)
+              ]);
+            in if config.key == null then null else defMoveKey;
+          };
+          spawn = lib.mkOption {
+            type = lib.types.nullOr (lib.types.listOf lib.types.str);
+            default = null;
+          };
+          app-id = lib.mkOption {
+            type = lib.types.nullOr lib.types.str;
+            default = null;
+          };
+          selector = lib.mkOption {
+            type = lib.types.nullOr lib.types.str;
+            default = null;
+          };
+        };
+
+        config = lib.mkMerge [
+          (lib.mkIf (config.app-id != null) {
+            match = lib.mkDefault [ { app-id = "^${lib.escapeRegex config.app-id}$"; } ];
+            selector = lib.mkDefault "select(.app_id == \"${config.app-id}\")";
+          })
+        ];
+      }));
+      default = [];
+    };
+  };
+
   config = {
     systemd.user.services.xwayland-satellite = {
       Unit = {
@@ -21,7 +240,9 @@ in {
       Service = {
         Type = "notify";
         NotifyAccess = "all";
-        ExecStart = lib.getExe pkgs.xwayland-satellite-unstable;
+        Environment = [ "DISPLAY=:0" ];
+        ExecStart = ''${lib.getExe pkgs.xwayland-satellite-unstable} ''${DISPLAY}'';
+        ExecStartPre = "${systemctl} --user import-environment DISPLAY";
         StandardOutput = "journal";
       };
       Install = {
@@ -29,111 +250,765 @@ in {
       };
     };
 
-    programs.niri.settings = {
-      prefer-no-csd = true;
-      screenshot-path = "${config.home.homeDirectory}/screenshots";
+    services.swayidle = {
+      events = [
+        { event = "after-resume"; command = "${lib.getExe niri} msg action power-on-monitors"; }
+      ];
+      timeouts = [
+        { timeout = 540;
+          command = "${lib.getExe niri} msg action power-off-monitors";
+        }
+      ];
+    };
 
-      input = {
-        keyboard.xkb = {
-          layout = "us,";
-          variant = "dvp,";
-          options = "compose:caps,grp:win_space_toggle";
-        };
+    systemd.user.sockets.niri-workspace-history = {
+      Socket = {
+        ListenStream = "%t/niri-workspace-history.sock";
+        SocketMode = "0600";
       };
-
-      environment = {
-        NIXOS_OZONE_WL = "1";
-        QT_QPA_PLATFORM = "wayland";
-        GDK_BACKEND = "wayland";
-        SDL_VIDEODRIVER = "wayland";
+    };
+    systemd.user.services.niri-workspace-history = {
+      Unit = {
+        BindsTo = [ "niri.service" ];
+        After = [ "niri.service" ];
       };
+      Install = {
+        WantedBy = [ "niri.service" ];
+      };
+      Service = {
+        Type = "simple";
+        Sockets = [ "niri-workspace-history.socket" ];
+        ExecStart = pkgs.writers.writePython3 "niri-workspace-history" { flakeIgnore = ["E501"]; } ''
+          import os
+          import socket
+          import json
+          # import sys
+          from collections import defaultdict
+          from threading import Thread, Lock
+          from socketserver import StreamRequestHandler, ThreadingTCPServer
+          from contextlib import contextmanager
+          from io import TextIOWrapper
 
-      cursor.hide-when-typing = true;
 
-      binds = with config.lib.niri.actions; {
-        "Mod+Return".action = spawn terminal;
-        "Mod+Q".action = close-window;
-        "Mod+D".action = spawn (lib.getExe config.programs.fuzzel.package);
-        "Mod+Shift+D".action = spawn (lib.getExe config.programs.fuzzel.package) "--list-executables-in-path";
+          @contextmanager
+          def detaching(thing):
+              try:
+                  yield thing
+              finally:
+                  thing.detach()
 
-        "Mod+H".action = focus-column-left;
-        "Mod+T".action = focus-window-down;
-        "Mod+N".action = focus-window-up;
-        "Mod+S".action = focus-column-right;
 
-        "Mod+Shift+H".action = move-column-left;
-        "Mod+Shift+T".action = move-window-down;
-        "Mod+Shift+N".action = move-window-up;
-        "Mod+Shift+S".action = move-column-right;
+          workspace_history = defaultdict(list)
+          history_lock = Lock()
 
-        "Mod+Control+H".action = focus-monitor-left;
-        "Mod+Control+T".action = focus-monitor-down;
-        "Mod+Control+N".action = focus-monitor-up;
-        "Mod+Control+S".action = focus-monitor-right;
 
-        "Mod+Shift+Control+H".action = move-workspace-to-monitor-left;
-        "Mod+Shift+Control+T".action = move-workspace-to-monitor-down;
-        "Mod+Shift+Control+N".action = move-workspace-to-monitor-up;
-        "Mod+Shift+Control+S".action = move-workspace-to-monitor-right;
+          def monitor_niri():
+              workspaces = list()
 
-        "Mod+G".action = focus-workspace-down;
-        "Mod+C".action = focus-workspace-up;
+              def focus_workspace(output, workspace):
+                  with history_lock:
+                      workspace_history[output] = [workspace] + [ws for ws in workspace_history[output] if ws != workspace]
+                      # print(json.dumps(workspace_history), file=sys.stderr)
 
-        "Mod+Control+G".action = move-column-to-workspace-down;
-        "Mod+Control+C".action = move-column-to-workspace-up;
+              sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+              sock.connect(os.environ["NIRI_SOCKET"])
+              sock.send(b"\"EventStream\"\n")
+              for line in sock.makefile(buffering=1, encoding='utf-8'):
+                  if line_json := json.loads(line):
+                      if "WorkspacesChanged" in line_json:
+                          workspaces = line_json["WorkspacesChanged"]["workspaces"]
+                          for ws in workspaces:
+                              if ws["is_focused"]:
+                                  focus_workspace(ws["output"], ws["id"])
+                      if "WorkspaceActivated" in line_json:
+                          for ws in workspaces:
+                              if ws["id"] != line_json["WorkspaceActivated"]["id"]:
+                                  continue
+                              focus_workspace(ws["output"], ws["id"])
+                              break
 
-        "Mod+Shift+G".action = move-workspace-down;
-        "Mod+Shift+C".action = move-workspace-up;
 
-        "Mod+M".action = consume-window-into-column;
-        "Mod+W".action = expel-window-from-column;
+          class RequestHandler(StreamRequestHandler):
+              def handle(self):
+                  with detaching(TextIOWrapper(self.wfile, encoding='utf-8', write_through=True)) as out:
+                      with history_lock:
+                          json.dump(workspace_history, out)
 
-        "Mod+F".action = maximize-column;
-        "Mod+Shift+F".action = fullscreen-window;
 
-        "Mod+Space".action = switch-focus-between-floating-and-tiling;
-        "Mod+Shift+Space".action = toggle-window-floating;
+          class Server(ThreadingTCPServer):
+              def __init__(self):
+                  ThreadingTCPServer.__init__(self, ("", 8000), RequestHandler, bind_and_activate=False)
+                  self.socket = socket.fromfd(3, self.address_family, self.socket_type)
 
-        "Mod+Left".action = set-column-width "-10%";
-        "Mod+Down".action = set-window-height "-10%";
-        "Mod+Up".action = set-window-height "+10%";
-        "Mod+Right".action = set-column-width "+10%";
 
-        "Mod+Shift+Z" = {
-          action = spawn (lib.getExe niri) "msg" "action" "power-off-monitors";
-          allow-when-locked = true;
-        };
+          def run_server():
+              with Server() as server:
+                  server.serve_forever()
 
-        "XF86MonBrightnessUp" = {
-          action = spawn lightctl "-d" "-e4" "-n1" "up";
-          allow-when-locked = true;
-        };
-        "XF86MonBrightnessDown" = {
-          action = spawn lightctl "-d" "-e4" "-n1" "down";
-          allow-when-locked = true;
-        };
-        "XF86AudioRaiseVolume" = {
-          action = spawn volumectl "-d" "-u" "up";
-          allow-when-locked = true;
-        };
-        "XF86AudioLowerVolume" = {
-          action = spawn volumectl "-d" "-u" "down";
-          allow-when-locked = true;
-        };
-        "XF86AudioMute" = {
-          action = spawn volumectl "-d" "toggle-mute";
-          allow-when-locked = true;
-        };
-        "XF86AudioMicMute" = {
-          action = spawn volumectl "-d" "-m" "toggle-mute";
-          allow-when-locked = true;
-        };
 
-        "Mod+Semicolon".action = spawn dunstctl "close";
-        "Mod+Shift+Semicolon".action = spawn dunstctl "close-all";
-        "Mod+Period".action = spawn dunstctl "context";
-        "Mod+Comma".action = spawn dunstctl "history-pop";
+          niri = Thread(target=monitor_niri)
+          niri.daemon = True
+          niri.start()
+
+          server_thread = Thread(target=run_server)
+          server_thread.daemon = True
+          server_thread.start()
+
+          while True:
+              server_thread.join(timeout=0.5)
+              niri.join(timeout=0.5)
+
+              if not (niri.is_alive() and server_thread.is_alive()):
+                  break
+        '';
       };
     };
+    systemd.user.services.niri-workspace-sort = {
+      Unit = {
+        BindsTo = [ "niri.service" ];
+        After = [ "niri.service" ];
+      };
+      Install = {
+        WantedBy = [ "niri.service" ];
+      };
+      Service = {
+        Type = "simple";
+        ExecStart = pkgs.writers.writePython3 "niri-workspace-sort" { flakeIgnore = ["E501"]; } ''
+          import os
+          import sys
+          import socket
+          import json
+
+          outputs = None
+          only = {'HDMI-A-1': {'bmr'}, 'eDP-1': {'vid'}}
+
+
+          class Niri(socket.socket):
+              def __init__(self):
+                  super().__init__(socket.AF_UNIX, socket.SOCK_STREAM)
+                  super().connect(os.environ["NIRI_SOCKET"])
+                  self.fh = super().makefile(mode='rw', buffering=1, encoding='utf-8')
+
+              def cmd(self, obj):
+                  print(json.dumps(obj, separators=(',', ':')), flush=True, file=self.fh)
+
+              def event_stream(self):
+                  self.cmd("EventStream")
+                  return self.fh
+
+
+          with Niri() as niri, Niri().event_stream() as niri_stream:
+              for line in niri_stream:
+                  workspaces = None
+                  if line_json := json.loads(line):
+                      if "WorkspacesChanged" in line_json:
+                          workspaces = line_json["WorkspacesChanged"]["workspaces"]
+
+                  if workspaces is None:
+                      continue
+
+                  old_outputs = outputs
+                  outputs = {ws["output"] for ws in workspaces}
+                  if old_outputs is None:
+                      print("Initial outputs: {}".format(outputs), file=sys.stderr)
+                      continue
+
+                  new_outputs = outputs - old_outputs
+                  if not new_outputs:
+                      continue
+                  print("New outputs: {}".format(new_outputs), file=sys.stderr)
+
+                  relevant_workspaces = list(filter(lambda ws: (ws["name"] is not None) or (ws["active_window_id"] is not None), workspaces))
+                  target_output = next(iter(outputs - set(only.keys())))
+                  if not target_output:
+                      continue
+                  for ws in relevant_workspaces:
+                      ws_ident = ws["name"] if ws["name"] is not None else (ws["output"], ws["idx"])
+                      if ws["output"] not in set(only.keys()):
+                          continue
+                      if ws_ident in only[ws["output"]]:
+                          continue
+
+                      print("{} -> {}".format(ws_ident, target_output), file=sys.stderr)
+                      niri.cmd({"Action": {"MoveWorkspaceToMonitor": {"reference": {"Id": ws["id"]}, "output": target_output}}})
+        '';
+        Restart = "on-failure";
+        RestartSec = 10;
+      };
+    };
+
+    programs.niri.scratchspaces = [
+      { name = "pwctl";
+        key = "Mod+Control+A";
+        spawn = ["pwvucontrol"];
+        app-id = "com.saivert.pwvucontrol";
+      }
+      { name = "kpxc";
+        exclude = [
+          { title = "^Unlock Database.*"; }
+          { title = "^Access Request.*"; }
+          { title = ".*Passkey credentials$"; }
+        ];
+        windowRuleExtra = with kdl; [
+          (kdl.leaf "open-focused" false)
+        ];
+        key = "Mod+Control+P";
+        app-id = "org.keepassxc.KeePassXC";
+        spawn = [ "keepassxc" ];
+      }
+      { name = "bmgr";
+        key = "Mod+Control+B";
+        app-id = ".blueman-manager-wrapped";
+        spawn = [ "blueman-manager" ];
+      }
+      { name = "term";
+        key = "Mod+Control+Return";
+        app-id = "kitty-scratch";
+        spawn = [ "kitty" "--app-id" "kitty-scratch" ];
+      }
+      { name = "edit";
+        match = [ { title = "^scratch$"; app-id = "^emacs$"; } ];
+        key = "Mod+Control+E";
+        selector = "select(.app_id == \"emacs\" and .title == \"scratch\")";
+        spawn = [ "emacsclient" "-c" "--frame-parameters=(quote (name . \"scratch\"))" ];
+      }
+      { name = "eff";
+        key = "Mod+Control+O";
+        app-id = "com.github.wwmm.easyeffects";
+        spawn = [ "easyeffects" ];
+      }
+      { name = "time";
+        key = "Mod+Control+K";
+        app-id = "chrome-kimai.yggdrasil.li__-Default";
+        spawn = [ (toString (pkgs.resholve.writeScript "kimai" {
+          interpreter = pkgs.runtimeShell;
+          inputs = [ pkgs.dex ];
+          execer = [ "cannot:${lib.getExe pkgs.dex}" ];
+        } ''
+          exec dex $HOME/.local/state/nix/profile/share/applications/kimai.desktop
+        '')) ];
+        windowRuleExtra = with kdl; [
+          (leaf "block-out-from" "screencast")
+        ];
+      }
+    ];
+    programs.niri.config =
+      let
+        inherit (kdl) node plain leaf flag;
+        optional-node = cond: v:
+          if cond
+          then v
+          else null;
+        opt-props = lib.filterAttrs (lib.const (value: value != null));
+      in
+        [ (flag "prefer-no-csd")
+
+          (leaf "screenshot-path" "~/screenshots/%Y-%m-%dT%H:%M:%S.png")
+
+          (plain "hotkey-overlay" [
+            (flag "skip-at-startup")
+          ])
+
+          (plain "input" [
+            (plain "keyboard" [
+              (leaf "repeat-delay" 300)
+              (leaf "repeat-rate" 50)
+
+              (plain "xkb" [
+                (leaf "layout" "us,us")
+                (leaf "variant" "dvp,")
+                (leaf "options" "compose:caps,grp:win_space_toggle")
+              ])
+            ])
+
+            (flag "workspace-auto-back-and-forth")
+            # (leaf "focus-follows-mouse" {})
+            # (flag "warp-mouse-to-focus")
+
+            # (plain "touchpad" [ (flag "off") ])
+            (plain "trackball" [
+              (leaf "scroll-method" "on-button-down")
+              (leaf "scroll-button" 278)
+            ])
+            (plain "touch" [
+              (leaf "map-to-output" "eDP-1")
+            ])
+          ])
+
+          (plain "gestures" [
+            (plain "hot-corners" [(flag "off")])
+          ])
+
+          (plain "environment" (lib.mapAttrsToList leaf {
+            NIXOS_OZONE_WL = "1";
+            QT_QPA_PLATFORM = "wayland";
+            QT_WAYLAND_DISABLE_WINDOWDECORATION = "1";
+            GDK_BACKEND = "wayland";
+            SDL_VIDEODRIVER = "wayland";
+            DISPLAY = ":0";
+            ELECTRON_OZONE_PLATFORM_HINT = "auto";
+            SSH_ASKPASS_REQUIRE = "prefer";
+            SSH_ASKPASS = lib.getExe pkgs.kdePackages.ksshaskpass;
+            SUDO_ASKPASS = lib.getExe pkgs.kdePackages.ksshaskpass;
+          }))
+
+          (node "output" "eDP-1" [
+            (leaf "scale" 1.5)
+            (leaf "position" { x = 0; y = 0; })
+          ])
+          (node "output" "Ancor Communications Inc ASUS PB287Q 0x0000DD9B" [
+            (leaf "scale" 1.5)
+            (leaf "position" { x = 2560; y = 0; })
+          ])
+          (node "output" "HP Inc. HP 727pu CN4417143K" [
+            (leaf "mode" "2560x1440@119.998")
+            (leaf "scale" 1)
+            (leaf "position" { x = 2560; y = 0; })
+            (flag "variable-refresh-rate")
+          ])
+
+          (plain "debug" [
+            (leaf "render-drm-device" "/dev/dri/by-path/pci-0000:00:02.0-render")
+          ])
+
+          (plain "animations" [
+            (leaf "slowdown" 0.5)
+            (plain "workspace-switch" [(flag "off")])
+          ])
+
+          (plain "layout" [
+            (leaf "gaps" 8)
+            (plain "struts" [
+              (leaf "left" 26)
+              (leaf "right" 26)
+              (leaf "top" 0)
+              (leaf "bottom" 0)
+            ])
+            (plain "border" [
+              (leaf "width" 2)
+              (leaf "active-gradient" {
+                from = "hsla(195 100% 45% 1)";
+                to = "hsla(155 100% 37.5% 1)";
+                angle = 29;
+                relative-to = "workspace-view";
+              })
+              (leaf "inactive-gradient" {
+                from = "hsla(0 0% 27.7% 1)";
+                to = "hsla(0 0% 23% 1)";
+                angle = 29;
+                relative-to = "workspace-view";
+              })
+            ])
+            (plain "focus-ring" [
+              (flag "off")
+            ])
+
+            (plain "preset-column-widths" (map (prop: leaf "proportion" prop) [
+              (1. / 4.) (1. / 3.) (1. / 2.) (2. / 3.) (3. / 4.) (1.)
+            ]))
+            (plain "default-column-width" [ (leaf "proportion" (1. / 2.)) ])
+            (plain "preset-window-heights" (map (prop: leaf "proportion" prop) [
+              (1. / 3.) (1. / 2.) (2. / 3.) (1.)
+            ]))
+
+            (flag "always-center-single-column")
+
+            (plain "tab-indicator" [
+              (leaf "gap" 4)
+              (leaf "width" 8)
+              (leaf "gaps-between-tabs" 4)
+              (flag "place-within-column")
+              (leaf "length" { total-proportion = 1.; })
+              (leaf "active-gradient" {
+                from = "hsla(195 100% 60% 0.75)";
+                to = "hsla(155 100% 50% 0.75)";
+                angle = 29;
+                relative-to = "workspace-view";
+              })
+              (leaf "inactive-gradient" {
+                from = "hsla(0 0% 42% 0.66)";
+                to = "hsla(0 0% 35% 0.66)";
+                angle = 29;
+                relative-to = "workspace-view";
+              })
+            ])
+          ])
+
+          (plain "cursor" [
+            (flag "hide-when-typing")
+          ])
+
+          (map (name:
+            (node "workspace" name [
+              (leaf "open-on-output" "eDP-1")
+            ])
+          ) (map ({name, ...}: name) cfg.scratchspaces))
+          (map (name:
+            (leaf "workspace" name)
+          ) ["comm" "web" "vid" "bmr"])
+
+          (plain "window-rule" [
+            (leaf "clip-to-geometry" true)
+          ])
+
+          (plain "window-rule" [
+            (leaf "match" { is-floating = true; })
+            (leaf "geometry-corner-radius" 8)
+            (plain "shadow" [ (flag "on") ])
+          ])
+
+          (plain "window-rule" [
+            (leaf "match" { app-id = "^org\\.keepassxc\\.KeePassXC$"; })
+            (leaf "block-out-from" "screencast")
+          ])
+          (plain "window-rule" [
+            (map (title:
+              (leaf "match" { app-id = "^org\\.keepassxc\\.KeePassXC$"; inherit title; })
+            ) ["^Unlock Database.*" "^Access Request.*" ".*Passkey credentials$" "Browser Access Request$"])
+            (leaf "open-focused" true)
+            (leaf "open-floating" true)
+          ])
+
+          (map ({ name, match, exclude, windowRuleExtra, ... }:
+            (optional-node (match != []) (plain "window-rule" [
+              (map (leaf "match") match)
+              (map (leaf "exclude") exclude)
+              (leaf "open-on-workspace" name)
+              (leaf "open-maximized" true)
+              windowRuleExtra
+            ]))
+          ) cfg.scratchspaces)
+
+          (plain "window-rule" [
+            (leaf "match" { app-id = "^emacs$"; })
+            (leaf "match" { app-id = "^firefox$"; })
+            (plain "default-column-width" [(leaf "proportion" (2. / 3.))])
+          ])
+          (plain "window-rule" [
+            (leaf "match" { app-id = "^kitty$"; })
+            (leaf "match" { app-id = "^kitty-play$"; })
+            (plain "default-column-width" [(leaf "proportion" (1. / 3.))])
+          ])
+
+          (plain "window-rule" [
+            (leaf "match" { app-id = "^thunderbird$"; })
+            (leaf "match" { app-id = "^Element$"; })
+            (leaf "match" { app-id = "^chrome-web\.openrainbow\.com__-Default$"; })
+            (leaf "open-on-workspace" "comm")
+          ])
+          (plain "window-rule" [
+            (leaf "match" { app-id = "^firefox$"; })
+            (leaf "open-on-workspace" "web")
+            (leaf "open-maximized" true)
+          ])
+          (plain "window-rule" [
+            (leaf "match" { app-id = "^mpv$"; })
+            (leaf "open-on-workspace" "vid")
+            (plain "default-column-width" [(leaf "proportion" 1.)])
+          ])
+          (plain "window-rule" [
+            (leaf "match" { app-id = "^kitty-play$"; })
+            (leaf "open-on-workspace" "vid")
+            (leaf "open-focused" false)
+          ])
+          (plain "window-rule" [
+            (leaf "match" { app-id = "^chrome-audiobookshelf\.yggdrasil\.li__-Default$"; })
+            (leaf "match" { app-id = "^YouTube Music Desktop App$"; })
+            (leaf "open-on-workspace" "vid")
+          ])
+          (plain "window-rule" [
+            (leaf "match" { app-id = "^pdfpc$"; })
+            (plain "default-column-width" [(leaf "proportion" 1.)])
+          ])
+          (plain "window-rule" [
+            (leaf "match" { app-id = "^pdfpc$"; title = "^.*presentation.*$"; })
+            (plain "default-column-width" [(leaf "proportion" 1.)])
+            (leaf "open-fullscreen" true)
+            (leaf "open-on-workspace" "bmr")
+            (leaf "open-focused" false)
+          ])
+          (plain "window-rule" [
+            (map (leaf "match") [
+              { app-id = "^Gimp-"; title = "^Quit GIMP$"; }
+              { app-id = "^org\\.kde\\.polkit-kde-authentication-agent-1$"; }
+              { app-id = "^xdg-desktop-portal-gtk$"; }
+            ])
+            (leaf "open-floating" true)
+          ])
+          (plain "window-rule" [
+            (leaf "match" { app-id = "^org\\.pwmt\\.zathura$"; })
+            (leaf "match" { app-id = "^evince$"; })
+            (leaf "match" { app-id = "^org\\.gnome\\.Papers$"; })
+            (leaf "default-column-display" "tabbed")
+          ])
+
+          (plain "layer-rule" [
+            (leaf "match" { namespace = "^notifications$"; })
+            (leaf "match" { namespace = "^waybar$"; })
+            (leaf "match" { namespace = "^launcher$"; })
+            (leaf "block-out-from" "screencast")
+          ])
+
+          (plain "binds"
+            (let
+              bind = name: cfg: node name (opt-props {
+                cooldown-ms = cfg.cooldown-ms or null;
+              }
+              // (lib.optionalAttrs (!(cfg.repeat or true)) {
+                repeat = false;
+              })
+              // (lib.optionalAttrs (cfg.allow-when-locked or false) {
+                allow-when-locked = true;
+              })) (lib.mapAttrsToList leaf (lib.removeAttrs cfg.action ["__functor"]));
+            in
+              [
+                (lib.mapAttrsToList bind (with config.lib.niri.actions; {
+                  "Mod+Slash".action = show-hotkey-overlay;
+
+                  "Mod+Return".action = spawn terminal;
+                  "Mod+Shift+Return".action =
+                    let
+                      nushellKitty = pkgs.symlinkJoin {
+                        name = "nushell-kitty";
+                        paths = [ config.programs.kitty.package ];
+                        buildInputs = [ pkgs.makeWrapper ];
+                        postBuild = ''
+                          wrapProgram $out/bin/kitty \
+                            --add-flags "--config ${pkgs.writeText "kitty.conf" ''
+                              include $HOME/${config.xdg.configFile."kitty/kitty.conf".target}
+                              shell ${lib.getExe config.programs.nushell.package}
+                            ''}"
+                        '';
+                      };
+                    in spawn (lib.getExe' nushellKitty "kitty");
+                  "Mod+Q".action = close-window;
+                  "Mod+O".action = spawn (lib.getExe config.programs.fuzzel.package);
+                  "Mod+Shift+O".action = spawn (lib.getExe config.programs.fuzzel.package) "--list-executables-in-path";
+
+                  "Mod+Alt+E".action = spawn (lib.getExe' config.services.emacs.package "emacsclient") "-c";
+                  "Mod+Alt+Y".action = spawn (lib.getExe (pkgs.writeShellApplication {
+                    name = "queue-yt-dlp";
+                    runtimeInputs = with pkgs; [ wl-clipboard-rs socat ];
+                    text = ''
+                      socat STDIO UNIX-CONNECT:"$XDG_RUNTIME_DIR"/yt-dlp.sock <<<$'{ "urls": ["'"$(wl-paste)"$'"] }'
+                    '';
+                  }));
+                  "Mod+Alt+L".action = spawn (lib.getExe (pkgs.writeShellApplication {
+                    name = "queue-yt-dlp";
+                    runtimeInputs = with pkgs; [ wl-clipboard-rs config.programs.kitty.package ];
+                    text = ''
+                      exec -- kitty --app-id kitty-play --directory "$HOME"/media mpv "$(wl-paste)"
+                    '';
+                  }));
+                  "Mod+Alt+M".action = spawn (lib.getExe' pkgs.screen-message "sm") "-n" "Fira Mono" "-a" "1" "-f" "#fff" "-b" "#000";
+
+                  "Mod+U".action = spawn (lib.getExe (pkgs.writeShellApplication {
+                    name = "qalc-fuzzel";
+                    runtimeInputs = with pkgs; [ wl-clipboard-rs libqalculate config.programs.fuzzel.package coreutils findutils libnotify gnugrep ];
+                    text = ''
+                      RESULTS_DIR="$HOME/.cache/qalc-fuzzel"
+                      prev() {
+                        FOUND=false
+                        while IFS= read -r line; do
+                          [[ -n "$line" ]] || continue
+                          FOUND=true
+                          echo "$line"
+                        done < <(export LC_ALL=C.UTF-8; echo; find "$RESULTS_DIR" -type f -printf $'%T@ %p\n' | sort -n | cut -d' ' -f2- | xargs -r cat)
+                        $FOUND || echo
+                      }
+                      FUZZEL_RES=$(prev | fuzzel --dmenu --prompt "qalc> " --width=60) || exit $?
+                      if [[ "$FUZZEL_RES" =~ .*\ =\ .* ]]; then
+                        QALC_RES="$FUZZEL_RES"
+                        QALC_RET=0
+                      else
+                        QALC_RES=$(qalc -set "autocalc off" "$FUZZEL_RES" 2>&1)
+                        QALC_RET=$?
+                      fi
+                      [[ -n "$QALC_RES" ]] || exit 1
+                      EXISTING=false
+                      set +o pipefail
+                      grep -Fxrl "$QALC_RES" "$RESULTS_DIR" | xargs -r touch
+                      [[ ''${PIPESTATUS[0]} -eq 0 ]] && EXISTING=true
+                      set -o pipefail
+                      if [[ $QALC_RET -eq 0 ]] && ! $EXISTING; then
+                        set +o pipefail
+                        RES_FILE="$RESULTS_DIR"/$(date -uIs).$(tr -Cd 'a-zA-Z0-9' </dev/random | head -c 10)
+                        set -o pipefail
+                        cat >"$RES_FILE" <<<"$QALC_RES"
+                      fi
+                      [[ "$QALC_RES" =~ .*\ =\ (.*) ]] && QALC_RES="''${BASH_REMATCH[1]}"
+                      [[ $QALC_RET -eq 0 ]] && wl-copy "$QALC_RES"
+                      notify-send "$QALC_RES"
+                    '';
+                  }));
+                  "Mod+Shift+U".action =
+                    let
+                      qalcKitty = pkgs.symlinkJoin {
+                        name = "qalc-kitty";
+                        paths = [ config.programs.kitty.package ];
+                        buildInputs = [ pkgs.makeWrapper ];
+                        postBuild = ''
+                          wrapProgram $out/bin/kitty \
+                            --add-flags "--config ${pkgs.writeText "kitty.conf" ''
+                              include $HOME/${config.xdg.configFile."kitty/kitty.conf".target}
+                              shell ${lib.getExe pkgs.libqalculate}
+                            ''}"
+                        '';
+                      };
+                    in spawn (lib.getExe' qalcKitty "kitty");
+                  "Mod+E".action = spawn (lib.getExe (pkgs.writeShellApplication {
+                    name = "emoji-fuzzel";
+                    runtimeInputs = with pkgs; [ config.programs.fuzzel.package wtype wl-clipboard-rs ];
+                    text = ''
+                      FUZZEL_RES=$(fuzzel --dmenu --prompt "emoji> " --cache "$HOME"/.cache/fuzzel-emoji --width=60 <"$HOME"/.local/share/emoji-data/list.txt) || exit $?
+                      [[ -n "$FUZZEL_RES" ]] || exit 1
+                      wl-copy "$(cut -d ':' -f 1 <<<"$FUZZEL_RES" | tr -d '\n')" && wtype -k XF86Paste
+                    '';
+                  }));
+                  "Print".action = screenshot;
+                  "Control+Print".action = screenshot-window;
+                  "Shift+Print".action = kdl.magic-leaf "screenshot-screen";
+                  "Mod+B".action = with-select-window-action ".workspace_id == ($active_workspace | tonumber)" "{\"Action\":{\"FocusWindow\":{\"id\": .id}}}";
+                  "Mod+Shift+B".action = with-select-window-action "true" "{\"Action\":{\"FocusWindow\":{\"id\": .id}}}";
+
+                  "Mod+Escape" = {
+                    allow-inhibiting = false;
+                    action = toggle-keyboard-shortcuts-inhibit;
+                  };
+
+                  "Mod+H".action = focus-column-left;
+                  "Mod+T".action = focus-window-down;
+                  "Mod+N".action = focus-window-up;
+                  "Mod+S".action = focus-column-right;
+
+                  "Mod+Shift+H".action = move-column-left;
+                  "Mod+Shift+T".action = move-window-down;
+                  "Mod+Shift+N".action = move-window-up;
+                  "Mod+Shift+S".action = move-column-right;
+
+                  "Mod+Control+H".action = focus-monitor-left;
+                  "Mod+Control+T".action = focus-monitor-down;
+                  "Mod+Control+N".action = focus-monitor-up;
+                  "Mod+Control+S".action = focus-monitor-right;
+
+                  "Mod+Shift+Control+H".action = move-workspace-to-monitor-left;
+                  "Mod+Shift+Control+T".action = move-workspace-to-monitor-down;
+                  "Mod+Shift+Control+N".action = move-workspace-to-monitor-up;
+                  "Mod+Shift+Control+S".action = move-workspace-to-monitor-right;
+
+                  "Mod+G".action = focus-adjacent-workspace "down";
+                  "Mod+C".action = focus-adjacent-workspace "up";
+
+                  "Mod+Shift+G".action = move-column-to-adjacent-workspace "down";
+                  "Mod+Shift+C".action = move-column-to-adjacent-workspace "up";
+
+                  "Mod+Shift+Control+G".action = move-workspace-down;
+                  "Mod+Shift+Control+C".action = move-workspace-up;
+
+                  "Mod+ParenLeft".action = focus-workspace "comm";
+                  "Mod+Shift+ParenLeft".action = kdl.magic-leaf "move-column-to-workspace" "comm";
+
+                  "Mod+ParenRight".action = focus-workspace "web";
+                  "Mod+Shift+ParenRight".action = kdl.magic-leaf "move-column-to-workspace" "web";
+
+                  "Mod+BraceRight".action = focus-workspace "read";
+                  "Mod+Shift+BraceRight".action = kdl.magic-leaf "move-column-to-workspace" "read";
+
+                  "Mod+BraceLeft".action = focus-workspace "mon";
+                  "Mod+Shift+BraceLeft".action = kdl.magic-leaf "move-column-to-workspace" "mon";
+
+                  "Mod+Asterisk".action = focus-workspace "vid";
+                  "Mod+Shift+Asterisk".action = kdl.magic-leaf "move-column-to-workspace" "vid";
+
+                  "Mod+Plus".action = with-unnamed-workspace-action ''{"Action":{"FocusWorkspace":{"reference":{"Id": .id}}}}'';
+                  "Mod+Shift+Plus".action = with-unnamed-workspace-action ''{"Action":{"MoveColumnToWorkspace":{"reference":{"Id": .id}, "focus": true}}}'';
+
+                  "Mod+M".action = consume-or-expel-window-left;
+                  "Mod+W".action = consume-or-expel-window-right;
+
+                  "Mod+Shift+M".action = toggle-column-tabbed-display;
+
+                  "Mod+R".action = switch-preset-column-width;
+                  "Mod+Shift+R".action = maximize-column;
+                  "Mod+Shift+Ctrl+R".action = switch-preset-window-height;
+                  "Mod+F".action = center-column;
+                  "Mod+Shift+F".action = toggle-windowed-fullscreen;
+                  "Mod+Ctrl+Shift+F".action = fullscreen-window;
+
+                  "Mod+V".action = switch-focus-between-floating-and-tiling;
+                  "Mod+Shift+V".action = toggle-window-floating;
+
+                  "Mod+Left".action = set-column-width "-10%";
+                  "Mod+Down".action = set-window-height "-10%";
+                  "Mod+Up".action = set-window-height "+10%";
+                  "Mod+Right".action = set-column-width "+10%";
+
+                  "Mod+Shift+Z" = {
+                    action = spawn (lib.getExe niri) "msg" "action" "power-off-monitors";
+                    allow-when-locked = true;
+                  };
+                  "Mod+Shift+L".action = spawn loginctl "lock-session";
+                  "Mod+Shift+E".action = quit;
+                  "Mod+Shift+Minus" = {
+                    action = spawn systemctl "suspend";
+                    allow-when-locked = true;
+                  };
+                  "Mod+Shift+Control+Minus" = {
+                    action = spawn systemctl "hibernate";
+                    allow-when-locked = true;
+                  };
+                  "Mod+Shift+P" = {
+                    action = spawn (lib.getExe pkgs.playerctl) "-a" "pause";
+                    allow-when-locked = true;
+                  };
+
+                  "XF86MonBrightnessUp" = {
+                    action = spawn swayosd-client "--brightness" "raise";
+                    allow-when-locked = true;
+                  };
+                  "XF86MonBrightnessDown" = {
+                    action = spawn swayosd-client "--brightness" "lower";
+                    allow-when-locked = true;
+                  };
+                  "XF86AudioRaiseVolume" = {
+                    action = spawn swayosd-client "--output-volume" "raise";
+                    allow-when-locked = true;
+                  };
+                  "XF86AudioLowerVolume" = {
+                    action = spawn swayosd-client "--output-volume" "lower";
+                    allow-when-locked = true;
+                  };
+                  "XF86AudioMute" = {
+                    action = spawn swayosd-client "--output-volume" "mute-toggle";
+                    allow-when-locked = true;
+                  };
+                  "XF86AudioMicMute" = {
+                    action = spawn swayosd-client "--input-volume" "mute-toggle";
+                    allow-when-locked = true;
+                  };
+
+                  "Mod+Semicolon".action = spawn makoctl "dismiss" "--group";
+                  "Mod+Shift+Semicolon".action = spawn makoctl "dismiss" "--all";
+                  "Mod+Period".action = spawn makoctl "menu" "--" (lib.getExe config.programs.fuzzel.package) "--dmenu";
+                  "Mod+Comma".action = spawn makoctl "restore";
+
+                  "Mod+Control+W".action = with-empty-unnamed-workspace-action "{\"Action\":{\"FocusWorkspace\":{\"reference\":{\"Id\": $workspace_id}}}}";
+                  "Mod+Control+Shift+W".action = with-empty-unnamed-workspace-action "{\"Action\":{\"MoveColumnToWorkspace\":{\"reference\":{\"Id\": $workspace_id}, \"focus\": true}}}";
+
+                  "Mod+X".action = set-dynamic-cast-window;
+                  "Mod+Shift+X".action = set-dynamic-cast-monitor;
+                  "Mod+Control+Shift+X".action = clear-dynamic-cast-target;
+
+                  "Mod+D".action = with-urgent-window-action "{\"Action\":{\"FocusWindow\":{\"id\": .id}}}";
+                  "Mod+Shift+D".action = with-focused-window-action "{\"Action\":{\"UnsetUrgent\":{\"id\": .id}}}";
+
+                  "Mod+K".action = spawn (lib.getExe' pkgs.worktime "worktime-ui");
+                  "Mod+Shift+K".action = spawn (lib.getExe' pkgs.worktime "worktime-stop");
+                }))
+                (map ({ name, selector, spawn, key, ...}: if key != null && selector != null && spawn != null then bind key { action = focus-or-spawn-action selector name spawn; } else null) cfg.scratchspaces)
+                (map ({ name, moveKey, ...}: if moveKey != null then bind moveKey { action = kdl.magic-leaf "move-column-to-workspace" name; } else null) cfg.scratchspaces)
+              ]
+            ))
+        ];
   };
 }
diff --git a/accounts/gkleen@sif/niri/mako.nix b/accounts/gkleen@sif/niri/mako.nix
new file mode 100644
index 00000000..eba26caa
--- /dev/null
+++ b/accounts/gkleen@sif/niri/mako.nix
@@ -0,0 +1,113 @@
+{ config, lib, pkgs, ... }:
+{
+  config = {
+    services.mako = {
+      enable = true;
+      settings = {
+        font = "Fira Sans 10";
+        format = "<i>%s</i>\\n%b";
+        margin = "2";
+        max-visible = -1;
+        background-color = "#000000dd";
+        progress-color = "source #223544ff";
+        width = 384;
+        outer-margin = 1;
+        max-history = 100;
+        max-icon-size = 48;
+      };
+      criteria = {
+        grouped.format = "<b>(%g)</b> <i>%s</i>\\n%b";
+        "urgency=low".text-color = "#999999ff";
+        "urgency=critical".background-color = "#900000dd";
+        "app-name=Element".group-by = "summary";
+        "app-name=poweralertd" = {
+          history = false;
+          ignore-timeout = true;
+          default-timeout = 2000;
+        };
+        "app-name=worktime".history = false;
+        "mode=silent".invisible = true;
+      };
+      package = pkgs.symlinkJoin {
+        name = "${pkgs.mako.name}-wrapped";
+        paths = with pkgs; [ mako ];
+        inherit (pkgs.mako) meta;
+        postBuild = ''
+          rm -r $out/share/dbus-1
+        '';
+      };
+    };
+    systemd.user.services.mako = {
+      Unit = {
+        Description = "Mako notification daemon";
+        PartOf = [ "graphical-session.target" ];
+      };
+      Install = {
+        WantedBy = [ "graphical-session.target" ];
+      };
+      Service = {
+        Type = "dbus";
+        BusName = "org.freedesktop.Notifications";
+        ExecStart = lib.getExe config.services.mako.package;
+        RestartSec = 5;
+        Restart = "always";
+      };
+    };
+
+    systemd.user.services.mako-follows-focus = {
+      Unit = {
+        BindsTo = [ "niri.service" "mako.service" ];
+        After = [ "niri.service" "mako.service" ];
+      };
+      Service = {
+        Type = "simple";
+        Restart = "always";
+        ExecStart = pkgs.writers.writePython3 "mako-follows-focus" {
+          libraries = with pkgs.python3Packages; [];
+        } ''
+          import os
+          import socket
+          import json
+          import subprocess
+
+
+          current_output = None
+          workspaces = []
+
+
+          def output_changed(new_output):
+              global current_output
+
+              if current_output == new_output:
+                  return
+
+              current_output = new_output
+              subprocess.run(["makoctl", "reload"])
+
+
+          sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+          sock.connect(os.environ["NIRI_SOCKET"])
+          sock.send(b"\"EventStream\"\n")
+          for line in sock.makefile(buffering=1, encoding='utf-8'):
+              if line_json := json.loads(line):
+                  if "WorkspacesChanged" in line_json:
+                      workspaces = line_json["WorkspacesChanged"]["workspaces"]
+                      for workspace in workspaces:
+                          if not workspace["is_focused"]:
+                              continue
+                          output_changed(workspace["output"])
+                          break
+                  if "WorkspaceActivated" in line_json and line_json["WorkspaceActivated"]["focused"]:  # noqa: E501
+                      for workspace in workspaces:
+                          if not workspace["id"] == line_json["WorkspaceActivated"]["id"]:  # noqa: E501
+                              continue
+                          output_changed(workspace["output"])
+                          break
+        '';
+      };
+      Install = {
+        WantedBy = [ "mako.service" ];
+      };
+    };
+  };
+}
diff --git a/accounts/gkleen@sif/niri/swayosd.nix b/accounts/gkleen@sif/niri/swayosd.nix
new file mode 100644
index 00000000..54ebb302
--- /dev/null
+++ b/accounts/gkleen@sif/niri/swayosd.nix
@@ -0,0 +1,66 @@
+{ pkgs, ... }:
+{
+  config = {
+    services.swayosd = {
+      enable = true;
+      topMargin = 0.4769706078;
+      stylePath = pkgs.runCommand "style.css" {
+        passAsFile = [ "src" ];
+        src = ''
+          window#osd {
+            padding: 12px 20px;
+            border-radius: 999px;
+            border: none;
+            background: rgba(0, 0, 0, 0.87);
+
+            #container {
+              margin: 16px;
+            }
+
+            image,
+            label {
+              color: rgb(255, 255, 255);
+
+              &:disabled {
+                opacity: 1;
+                color: rgb(84, 84, 84);
+              }
+            }
+
+            progressbar {
+              min-height: 6px;
+              border-radius: 999px;
+              background: transparent;
+              border: none;
+
+              trough, progress {
+                min-height: inherit;
+                border-radius: inherit;
+                border: none;
+              }
+
+              trough {
+                background: rgb(127, 127, 127);
+              }
+              progress {
+                background: rgb(255, 255, 255);
+              }
+
+              &:disabled {
+                opacity: 1;
+
+                trough {
+                  background: rgb(19, 19, 19);
+                }
+                progress {
+                  background: rgb(38, 38, 38);
+                }
+              }
+            }
+          }
+        '';
+        buildInputs = with pkgs; [sass];
+      } "scss -C --sourcemap=none --style=compact $srcPath $out";
+    };
+  };
+}
diff --git a/accounts/gkleen@sif/niri/waybar.nix b/accounts/gkleen@sif/niri/waybar.nix
index 1a25b581..c02a9a76 100644
--- a/accounts/gkleen@sif/niri/waybar.nix
+++ b/accounts/gkleen@sif/niri/waybar.nix
@@ -1,5 +1,7 @@
-{ lib, pkgs, ... }:
-{
+{ lib, config, pkgs, ... }:
+let
+  swayosd-client = lib.getExe' config.services.swayosd.package "swayosd-client";
+in {
   config = {
     programs.waybar = {
       enable = true;
@@ -18,20 +20,76 @@
         {
           layer = "top";
           position = "top";
-          height = 14;
+          height = 21;
           output = [ "eDP-1" "DP-2" "DP-3" ];
           modules-left = [ "niri/workspaces" ];
           modules-center = [ "niri/window" ];
-          modules-right = [ # "custom/worktime" "custom/worktime-today"
+          modules-right = [ "custom/worktime" "custom/worktime-today"
             "custom/weather"
-            # "custom/keymap"
-            "privacy" "tray" "wireplumber" "backlight" "battery" "idle_inhibitor" "clock" ];
+            "custom/keymap"
+            "privacy" "tray" "wireplumber" "backlight" "battery" "idle_inhibitor" "custom/mako" "custom/lid_inhibitor" "clock" ];
+
+          "custom/lid_inhibitor" = {
+            format = "{}";
+            return-type = "json";
+            exec = lib.getExe pkgs.waybar-systemd-inhibit;
+            on-click = lib.getExe' pkgs.waybar-systemd-inhibit "waybar-systemd-inhibit-toggle";
+          };
+          "custom/mako" = {
+            format = "{}";
+            return-type = "json";
+            exec = pkgs.writers.writePython3 "mako-silent" { libraries = [ pkgs.python3Packages.dbus-next ]; } ''
+              from dbus_next.aio import MessageBus
+
+              import asyncio
+
+              import json
+
+
+              loop = asyncio.new_event_loop()
+              asyncio.set_event_loop(loop)
+
+
+              async def main():
+                  bus = await MessageBus().connect()
+                  # the introspection xml would normally be included in your project, but
+                  # this is convenient for development
+                  introspection = await bus.introspect('org.freedesktop.Notifications', '/fr/emersion/Mako')  # noqa: E501
+
+                  obj = bus.get_proxy_object('org.freedesktop.Notifications', '/fr/emersion/Mako', introspection)  # noqa: E501
+                  mako = obj.get_interface('fr.emersion.Mako')
+                  properties = obj.get_interface('org.freedesktop.DBus.Properties')
+
+                  async def print_mode():
+                      modes = await mako.get_modes()
+                      is_silent = "silent" in modes
+                      icon = "&#xf009b;" if is_silent else "&#xf009a;"
+                      text = f"<span font=\"Symbols Nerd Font Mono\" size=\"90%\">{icon}</span>"  # noqa: E501
+                      if is_silent:
+                          text = f"<span color=\"#ffffff\">{text}</span>"
+                      print(json.dumps({'text': text, 'tooltip': ', '.join(modes)}, separators=(',', ':')), flush=True)  # noqa: E501
+
+                  async def on_properties_changed(interface_name, changed_properties, invalidated_properties):  # noqa: E501
+                      if "Modes" not in invalidated_properties:
+                          return
+
+                      await print_mode()
+
+                  properties.on_properties_changed(on_properties_changed)
+                  await print_mode()
 
+                  await loop.create_future()
+
+
+              loop.run_until_complete(main())
+            '';
+            on-click = "makoctl mode -t silent";
+          };
           "custom/weather" = {
             format = "{}";
             tooltip = true;
             interval = 3600;
-            exec = "${lib.getExe pkgs.wttrbar} --hide-conditions --nerd --custom-indicator \"<span font=\\\"Symbols Nerd Font Mono\\\" size=\\\"120%\\\">{ICON}</span> {FeelsLikeC}°\"";
+            exec = "${lib.getExe pkgs.wttrbar} --hide-conditions --nerd --custom-indicator \"<span font=\\\"Symbols Nerd Font Mono\\\" size=\\\"100%\\\">{ICON}</span> {FeelsLikeC}°\"";
             return-type = "json";
           };
           "custom/keymap" = {
@@ -41,8 +99,6 @@
             exec = pkgs.writers.writePython3 "keymap" {} ''
               import os
               import socket
-              import re
-              import subprocess
               import json
 
 
@@ -55,33 +111,33 @@
                   print(json.dumps({'text': short, 'tooltip': keymap}, separators=(',', ':')), flush=True)  # noqa: E501
 
 
-              r = subprocess.run(["hyprctl", "devices", "-j"], check=True, stdout=subprocess.PIPE, text=True)  # noqa: E501
-              for keyboard in json.loads(r.stdout)['keyboards']:
-                  if keyboard['name'] != "at-translated-set-2-keyboard":
-                      continue
-                  output(keyboard['active_keymap'])
+              keyboard_layouts = []
 
               sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-              sock.connect(os.environ["XDG_RUNTIME_DIR"] + "/hypr/" + os.environ["HYPRLAND_INSTANCE_SIGNATURE"] + "/.socket2.sock")  # noqa: E501
-              expected = re.compile(r'^activelayout>>at-translated-set-2-keyboard,(?P<keymap>.+)$')  # noqa: E501
+              sock.connect(os.environ["NIRI_SOCKET"])
+              sock.send(b"\"EventStream\"\n")
               for line in sock.makefile(buffering=1, encoding='utf-8'):
-                  if match := expected.match(line):
-                      output(match.group("keymap"))
+                  if line_json := json.loads(line):
+                      if "KeyboardLayoutsChanged" in line_json:
+                          keyboard_layouts = line_json["KeyboardLayoutsChanged"]["keyboard_layouts"]["names"]  # noqa: E501
+                          output(keyboard_layouts[line_json["KeyboardLayoutsChanged"]["keyboard_layouts"]["current_idx"]])  # noqa: E501
+                      if "KeyboardLayoutSwitched" in line_json:
+                          output(keyboard_layouts[line_json["KeyboardLayoutSwitched"]["idx"]])  # noqa: E501
             '';
-            on-click = "hyprctl switchxkblayout at-translated-set-2-keyboard next";
+            on-click = "niri msg action switch-layout next";
           };
           "custom/worktime" = {
             interval = 60;
-            exec = lib.getExe pkgs.worktime;
-            tooltip = false;
+            exec = "${lib.getExe pkgs.worktime} time --waybar";
+            return-type = "json";
           };
           "custom/worktime-today" = {
             interval = 60;
-            exec = "${lib.getExe pkgs.worktime} today";
-            tooltip = false;
+            exec = "${lib.getExe pkgs.worktime} today --waybar";
+            return-type = "json";
           };
           "niri/workspaces" = {
-            all-outputs = true;
+            ignore = map ({ name, ... }: name) config.programs.niri.scratchspaces;
           };
           "niri/window" = {
             separate-outputs = true;
@@ -142,8 +198,8 @@
             icon-size = iconSize;
             tooltip-format = "{percent}%";
             format-icons = ["&#xf00da;" "&#xf00db;" "&#xf00dc;" "&#xf00dd;" "&#xf00de;" "&#xf00df;" "&#xf00e0;"];
-            on-scroll-up = "lightctl -d -e4 -n1 up";
-            on-scroll-down = "lightctl -d -e4 -n1 down";
+            on-scroll-up = "${swayosd-client} --brightness raise";
+            on-scroll-down = "${swayosd-client} --brightness lower";
           };
           wireplumber = {
             format = "<span font=\"Symbols Nerd Font Mono\" size=\"90%\">{icon}</span>";
@@ -152,22 +208,22 @@
             format-icons = ["&#xf057f;" "&#xf0580;" "&#xf057e;"];
             format-muted = "<span font=\"Symbols Nerd Font Mono\" size=\"90%\">&#xf075f;</span>";
             # ignored-sinks = ["Easy Effects Sink"];
-            on-scroll-up = "volumectl -d -u up";
-            on-scroll-down = "volumectl -d -u down";
-            on-click = "volumectl -d toggle-mute";
+            on-scroll-up = "${swayosd-client} --output-volume raise";
+            on-scroll-down = "${swayosd-client} --output-volume lower";
+            on-click = "${swayosd-client} --output-volume mute-toggle";
           };
         }
         {
           layer = "top";
           position = "top";
           height = 14;
-          output = [ "!eDP-1" "!DP-2" "!DP-3" ];
+          output = [ "!eDP-1" "!DP-2" "!DP-3" "*" ];
           modules-left = [ "niri/workspaces" ];
           modules-center = [ "niri/window" ];
           modules-right = [ "clock" ];
 
           "niri/workspaces" = {
-            all-outputs = false;
+            ignore = map ({ name, ... }: name) config.programs.niri.scratchspaces;
           };
           "niri/window" = {
             separate-outputs = true;
@@ -193,7 +249,7 @@
 
         * {
           border: none;
-          font-family: "Fira Sans Nerd Font";
+          font-family: "Fira Sans";
           font-size: 10pt;
           min-height: 0;
         }
@@ -204,10 +260,10 @@
         }
 
         .modules-left {
-          margin-left: 9px;
+          margin-left: 38px;
         }
         .modules-right {
-          margin-right: 9px;
+          margin-right: 38px;
         }
 
         .module {
@@ -215,13 +271,11 @@
         }
 
         #workspaces button {
-          color: @grey;
-        }
-        #workspaces button.hosting-monitor {
           color: @white;
+          padding: 2px 5px;
         }
-        #workspaces button.visible {
-          color: @blue;
+        #workspaces button.empty {
+          color: @grey;
         }
         #workspaces button.active {
           color: @green;
@@ -234,22 +288,31 @@
           color: @grey;
           margin: 0 5px;
         }
-        #custom-weather, #custom-worktime-today {
+        #custom-weather {
           margin-right: 3px;
         }
-        #custom-keymap, #custom-weather {
+        #custom-keymap {
           margin-left: 3px;
+          margin-right: 3px;
         }
 
         #tray {
           margin: 0;
         }
-        #battery, #idle_inhibitor, #backlight, #wireplumber {
+        #battery, #idle_inhibitor, #backlight, #wireplumber, #custom-mako, #custom-lid_inhibitor {
           color: @grey;
           margin: 0 5px 0 2px;
         }
         #idle_inhibitor {
-          margin-right: 2px;
+          margin-right: 4px;
+          margin-left: 6px;
+        }
+        #custom-mako {
+          margin-right: 4px;
+          margin-left: 3px;
+        }
+        #custom-lid_inhibitor {
+          margin-right: 3px;
           margin-left: 3px;
         }
         #battery {
@@ -270,17 +333,24 @@
         #idle_inhibitor.activated {
           color: @white;
         }
+        #custom-worktime.running, #custom-worktime-today.running {
+          color: @white;
+        }
+        #custom-worktime.over, #custom-worktime-today.over {
+          color: @orange;
+        }
 
-        #idle_inhibitor {
+        #idle_inhibitor, #custom-lid_inhibitor {
           padding-top: 1px;
         }
 
         #privacy {
           color: @red;
-          margin: -1px 2px 0px 5px;
+          margin: -1px 4px 0px 3px;
         }
         #clock {
           /* margin-right: 5px; */
+          font-feature-settings: "tnum";
         }
       '';
     };