Merge remote-tracking branch 'origin/staging-next' into staging

.github/workflows/periodic-merge-24h.yml

···
         pairs:
           - from: master
             into: haskell-updates
-          - from: release-24.05
-            into: staging-next-24.05
-          - from: staging-next-24.05
-            into: staging-24.05
           - from: release-24.11
             into: staging-next-24.11
           - from: staging-next-24.11

doc/doc-support/lib-function-docs.nix

···
 stdenvNoCC.mkDerivation {
   name = "nixpkgs-lib-docs";
 
-  src = lib.fileset.toSource {
-    root = ../..;
-    fileset = ../../lib;
-  };
+  src = ../../lib;
 
   nativeBuildInputs = [
     nixdoc
···
   ];
 
   installPhase = ''
+    cd ..
+
     export NIX_STATE_DIR=$(mktemp -d)
     nix-instantiate --eval --strict --json ${./lib-function-locations.nix} \
       --arg nixpkgsPath "./." \

doc/doc-support/package.nix

···
 
     nativeBuildInputs = [ nixos-render-docs ];
 
-    src = lib.fileset.toSource {
-      root = ../.;
-      fileset = lib.fileset.unions [
-        (lib.fileset.fileFilter (file: file.hasExt "md" || file.hasExt "md.in") ../.)
-        ../style.css
-        ../anchor-use.js
-        ../anchor.min.js
-        ../manpage-urls.json
-        ../redirects.json
-      ];
+    src = lib.cleanSourceWith {
+      src = ../.;
+      filter =
+        path: type:
+        type == "directory"
+        || lib.hasSuffix ".md" path
+        || lib.hasSuffix ".md.in" path
+        || lib.elem path (
+          map toString [
+            ../style.css
+            ../anchor-use.js
+            ../anchor.min.js
+            ../manpage-urls.json
+            ../redirects.json
+          ]
+        );
     };
 
     postPatch = ''

lib/trivial.nix

···
   */
   oldestSupportedRelease =
     # Update on master only. Do not backport.
-    2405;
+    2411;
 
   /**
     Whether a feature is supported in all supported releases (at the time of

nixos/lib/test-driver/default.nix

···
   extraPythonPackages ? (_: [ ]),
   nixosTests,
 }:
-let
-  fs = lib.fileset;
-in
 python3Packages.buildPythonApplication {
   pname = "nixos-test-driver";
   version = "1.1";
   pyproject = true;
 
-  src = fs.toSource {
-    root = ./.;
-    fileset = fs.unions [
-      ./pyproject.toml
-      ./test_driver
-      ./extract-docstrings.py
-    ];
-  };
+  src = ./src;
 
   build-system = with python3Packages; [
     setuptools

nixos/lib/test-driver/nixos-test-driver-docstrings.nix

···
 
 runCommand "nixos-test-driver-docstrings" env ''
   mkdir $out
-  python3 ${./extract-docstrings.py} ${./test_driver/machine.py} \
+  python3 ${./src/extract-docstrings.py} ${./src/test_driver/machine.py} \
     > $out/machine-methods.md
 ''

nixos/modules/services/continuous-integration/hydra/default.nix

···
           ''
             set -eou pipefail
             compression=$(sed -nr 's/compress_build_logs_compression = ()/\1/p' ${baseDir}/hydra.conf)
-            if [[ $compression == "" ]]; then
-              compression="bzip2"
+            if [[ $compression == "" || $compression == bzip2 ]]; then
+              compressionCmd=(bzip2)
             elif [[ $compression == zstd ]]; then
-              compression="zstd --rm"
+              compressionCmd=(zstd --rm)
             fi
-            find ${baseDir}/build-logs -type f -name "*.drv" -mtime +3 -size +0c -print0 | xargs -0 -r "$compression" --force --quiet
+            find ${baseDir}/build-logs -type f -name "*.drv" -mtime +3 -size +0c -print0 | xargs -0 -r "''${compressionCmd[@]}" --force --quiet
           '';
         startAt = "Sun 01:45";
         serviceConfig.Slice = "system-hydra.slice";

nixos/modules/services/x11/colord.nix

···
   pkgs,
   ...
 }:
+
+with lib;
+
 let
 
   cfg = config.services.colord;
···
   options = {
 
     services.colord = {
-      enable = lib.mkEnableOption "colord, the color management daemon";
+      enable = mkEnableOption "colord, the color management daemon";
     };
 
   };
 
-  config = lib.mkIf cfg.enable {
+  config = mkIf cfg.enable {
 
     environment.systemPackages = [ pkgs.colord ];
 

nixos/modules/services/x11/desktop-managers/cde.nix

···
   pkgs,
   ...
 }:
+
+with lib;
+
 let
   xcfg = config.services.xserver;
   cfg = xcfg.desktopManager.cde;
 in
 {
   options.services.xserver.desktopManager.cde = {
-    enable = lib.mkEnableOption "Common Desktop Environment";
+    enable = mkEnableOption "Common Desktop Environment";
 
-    extraPackages = lib.mkOption {
-      type = with lib.types; listOf package;
+    extraPackages = mkOption {
+      type = with types; listOf package;
       default = with pkgs.xorg; [
         xclock
         bitmap
···
         xwd
         xwud
       ];
-      defaultText = lib.literalExpression ''
+      defaultText = literalExpression ''
         with pkgs.xorg; [
           xclock bitmap xlsfonts xfd xrefresh xload xwininfo xdpyinfo xwd xwud
         ]
···
     };
   };
 
-  config = lib.mkIf (xcfg.enable && cfg.enable) {
+  config = mkIf (xcfg.enable && cfg.enable) {
     environment.systemPackages = cfg.extraPackages;
 
     services.rpcbind.enable = true;

nixos/modules/services/x11/desktop-managers/cinnamon.nix

···
 { config, lib, pkgs, utils, ... }:
+
+with lib;
+
 let
 
   cfg = config.services.xserver.desktopManager.cinnamon;
···
 {
   options = {
     services.cinnamon = {
-      apps.enable = lib.mkEnableOption "Cinnamon default applications";
+      apps.enable = mkEnableOption "Cinnamon default applications";
     };
 
     services.xserver.desktopManager.cinnamon = {
-      enable = lib.mkEnableOption "the cinnamon desktop manager";
+      enable = mkEnableOption "the cinnamon desktop manager";
 
-      sessionPath = lib.mkOption {
+      sessionPath = mkOption {
         default = [];
-        type = lib.types.listOf lib.types.package;
-        example = lib.literalExpression "[ pkgs.gpaste ]";
+        type = types.listOf types.package;
+        example = literalExpression "[ pkgs.gpaste ]";
         description = ''
           Additional list of packages to be added to the session search path.
           Useful for GSettings-conditional autostart.
···
         '';
       };
 
-      extraGSettingsOverrides = lib.mkOption {
+      extraGSettingsOverrides = mkOption {
         default = "";
-        type = lib.types.lines;
+        type = types.lines;
         description = "Additional gsettings overrides.";
       };
 
-      extraGSettingsOverridePackages = lib.mkOption {
+      extraGSettingsOverridePackages = mkOption {
         default = [];
-        type = lib.types.listOf lib.types.path;
+        type = types.listOf types.path;
         description = "List of packages for which gsettings are overridden.";
       };
     };
 
-    environment.cinnamon.excludePackages = lib.mkOption {
+    environment.cinnamon.excludePackages = mkOption {
       default = [];
-      example = lib.literalExpression "[ pkgs.blueman ]";
-      type = lib.types.listOf lib.types.package;
+      example = literalExpression "[ pkgs.blueman ]";
+      type = types.listOf types.package;
       description = "Which packages cinnamon should exclude from the default environment";
     };
 
   };
 
-  config = lib.mkMerge [
-    (lib.mkIf cfg.enable {
+  config = mkMerge [
+    (mkIf cfg.enable {
       services.displayManager.sessionPackages = [ pkgs.cinnamon-common ];
 
       services.xserver.displayManager.lightdm.greeters.slick = {
-        enable = lib.mkDefault true;
+        enable = mkDefault true;
 
         # Taken from mint-artwork.gschema.override
-        theme = lib.mkIf (notExcluded pkgs.mint-themes) {
-          name = lib.mkDefault "Mint-Y-Aqua";
-          package = lib.mkDefault pkgs.mint-themes;
+        theme = mkIf (notExcluded pkgs.mint-themes) {
+          name = mkDefault "Mint-Y-Aqua";
+          package = mkDefault pkgs.mint-themes;
         };
-        iconTheme = lib.mkIf (notExcluded pkgs.mint-y-icons) {
-          name = lib.mkDefault "Mint-Y-Sand";
-          package = lib.mkDefault pkgs.mint-y-icons;
+        iconTheme = mkIf (notExcluded pkgs.mint-y-icons) {
+          name = mkDefault "Mint-Y-Sand";
+          package = mkDefault pkgs.mint-y-icons;
         };
-        cursorTheme = lib.mkIf (notExcluded pkgs.mint-cursor-themes) {
-          name = lib.mkDefault "Bibata-Modern-Classic";
-          package = lib.mkDefault pkgs.mint-cursor-themes;
+        cursorTheme = mkIf (notExcluded pkgs.mint-cursor-themes) {
+          name = mkDefault "Bibata-Modern-Classic";
+          package = mkDefault pkgs.mint-cursor-themes;
         };
       };
 
       # Have to take care of GDM + Cinnamon on Wayland users
       environment.extraInit = ''
-        ${lib.concatMapStrings (p: ''
+        ${concatMapStrings (p: ''
           if [ -d "${p}/share/gsettings-schemas/${p.name}" ]; then
             export XDG_DATA_DIRS=$XDG_DATA_DIRS''${XDG_DATA_DIRS:+:}${p}/share/gsettings-schemas/${p.name}
           fi
···
       '';
 
       # Default services
-      services.blueman.enable = lib.mkDefault (notExcluded pkgs.blueman);
-      hardware.bluetooth.enable = lib.mkDefault true;
+      services.blueman.enable = mkDefault (notExcluded pkgs.blueman);
+      hardware.bluetooth.enable = mkDefault true;
       security.polkit.enable = true;
       services.accounts-daemon.enable = true;
-      services.system-config-printer.enable = (lib.mkIf config.services.printing.enable (lib.mkDefault true));
+      services.system-config-printer.enable = (mkIf config.services.printing.enable (mkDefault true));
       services.dbus.packages = with pkgs; [
         cinnamon-common
         cinnamon-screensaver
         nemo-with-extensions
         xapp
       ];
-      services.cinnamon.apps.enable = lib.mkDefault true;
+      services.cinnamon.apps.enable = mkDefault true;
       services.gnome.evolution-data-server.enable = true;
       services.gnome.glib-networking.enable = true;
       services.gnome.gnome-keyring.enable = true;
       services.gvfs.enable = true;
-      services.power-profiles-daemon.enable = lib.mkDefault true;
-      services.switcherooControl.enable = lib.mkDefault true; # xapp-gpu-offload-helper
-      services.touchegg.enable = lib.mkDefault true;
+      services.power-profiles-daemon.enable = mkDefault true;
+      services.switcherooControl.enable = mkDefault true; # xapp-gpu-offload-helper
+      services.touchegg.enable = mkDefault true;
       services.udisks2.enable = true;
-      services.upower.enable = lib.mkDefault config.powerManagement.enable;
-      services.libinput.enable = lib.mkDefault true;
+      services.upower.enable = mkDefault config.powerManagement.enable;
+      services.libinput.enable = mkDefault true;
       services.xserver.updateDbusEnvironment = true;
-      networking.networkmanager.enable = lib.mkDefault true;
+      networking.networkmanager.enable = mkDefault true;
 
       # Enable colord server
       services.colord.enable = true;
···
         pkgs.xdg-desktop-portal-gtk
       ];
 
-      services.orca.enable = lib.mkDefault (notExcluded pkgs.orca);
+      services.orca.enable = mkDefault (notExcluded pkgs.orca);
 
-      xdg.portal.configPackages = lib.mkDefault [ pkgs.cinnamon-common ];
+      xdg.portal.configPackages = mkDefault [ pkgs.cinnamon-common ];
 
       # Override GSettings schemas
       environment.sessionVariables.NIX_GSETTINGS_OVERRIDES_DIR = "${nixos-gsettings-overrides}/share/gsettings-schemas/nixos-gsettings-overrides/glib-2.0/schemas";
···
       ];
 
       # Shell integration for VTE terminals
-      programs.bash.vteIntegration = lib.mkDefault true;
-      programs.zsh.vteIntegration = lib.mkDefault true;
+      programs.bash.vteIntegration = mkDefault true;
+      programs.zsh.vteIntegration = mkDefault true;
 
       # Default Fonts
       fonts.packages = with pkgs; [
···
       ];
     })
 
-    (lib.mkIf serviceCfg.apps.enable {
-      programs.gnome-disks.enable = lib.mkDefault (notExcluded pkgs.gnome-disk-utility);
-      programs.gnome-terminal.enable = lib.mkDefault (notExcluded pkgs.gnome-terminal);
-      programs.file-roller.enable = lib.mkDefault (notExcluded pkgs.file-roller);
+    (mkIf serviceCfg.apps.enable {
+      programs.gnome-disks.enable = mkDefault (notExcluded pkgs.gnome-disk-utility);
+      programs.gnome-terminal.enable = mkDefault (notExcluded pkgs.gnome-terminal);
+      programs.file-roller.enable = mkDefault (notExcluded pkgs.file-roller);
 
       environment.systemPackages = with pkgs; utils.removePackagesByName [
         # cinnamon team apps

nixos/modules/services/x11/desktop-managers/deepin.nix

···
   utils,
   ...
 }:
+
+with lib;
+
 let
   xcfg = config.services.xserver;
   cfg = xcfg.desktopManager.deepin;
···
   options = {
 
     services.xserver.desktopManager.deepin = {
-      enable = lib.mkEnableOption "Deepin desktop manager";
-      extraGSettingsOverrides = lib.mkOption {
+      enable = mkEnableOption "Deepin desktop manager";
+      extraGSettingsOverrides = mkOption {
         default = "";
-        type = lib.types.lines;
+        type = types.lines;
         description = "Additional gsettings overrides.";
       };
-      extraGSettingsOverridePackages = lib.mkOption {
+      extraGSettingsOverridePackages = mkOption {
         default = [ ];
-        type = lib.types.listOf lib.types.path;
+        type = types.listOf types.path;
         description = "List of packages for which gsettings are overridden.";
       };
     };
 
-    environment.deepin.excludePackages = lib.mkOption {
+    environment.deepin.excludePackages = mkOption {
       default = [ ];
-      type = lib.types.listOf lib.types.package;
+      type = types.listOf types.package;
       description = "List of default packages to exclude from the configuration";
     };
 
   };
 
-  config = lib.mkIf cfg.enable {
+  config = mkIf cfg.enable {
     services.displayManager.sessionPackages = [ pkgs.deepin.dde-session ];
-    services.displayManager.defaultSession = lib.mkDefault "dde-x11";
+    services.displayManager.defaultSession = mkDefault "dde-x11";
 
     # Update the DBus activation environment after launching the desktop manager.
     services.xserver.displayManager.sessionCommands = ''
       ${lib.getBin pkgs.dbus}/bin/dbus-update-activation-environment --systemd --all
     '';
 
-    hardware.bluetooth.enable = lib.mkDefault true;
+    hardware.bluetooth.enable = mkDefault true;
     security.polkit.enable = true;
 
-    services.deepin.dde-daemon.enable = lib.mkForce true;
-    services.deepin.dde-api.enable = lib.mkForce true;
-    services.deepin.app-services.enable = lib.mkForce true;
+    services.deepin.dde-daemon.enable = mkForce true;
+    services.deepin.dde-api.enable = mkForce true;
+    services.deepin.app-services.enable = mkForce true;
 
-    services.colord.enable = lib.mkDefault true;
-    services.accounts-daemon.enable = lib.mkDefault true;
-    services.gvfs.enable = lib.mkDefault true;
-    services.gnome.glib-networking.enable = lib.mkDefault true;
-    services.gnome.gnome-keyring.enable = lib.mkDefault true;
-    services.bamf.enable = lib.mkDefault true;
+    services.colord.enable = mkDefault true;
+    services.accounts-daemon.enable = mkDefault true;
+    services.gvfs.enable = mkDefault true;
+    services.gnome.glib-networking.enable = mkDefault true;
+    services.gnome.gnome-keyring.enable = mkDefault true;
+    services.bamf.enable = mkDefault true;
 
-    services.libinput.enable = lib.mkDefault true;
+    services.libinput.enable = mkDefault true;
     services.udisks2.enable = true;
-    services.upower.enable = lib.mkDefault config.powerManagement.enable;
-    networking.networkmanager.enable = lib.mkDefault true;
-    programs.dconf.enable = lib.mkDefault true;
-    programs.gnupg.agent.pinentryPackage = lib.mkDefault pkgs.pinentry-qt;
+    services.upower.enable = mkDefault config.powerManagement.enable;
+    networking.networkmanager.enable = mkDefault true;
+    programs.dconf.enable = mkDefault true;
+    programs.gnupg.agent.pinentryPackage = mkDefault pkgs.pinentry-qt;
 
     fonts.packages = with pkgs; [ noto-fonts ];
     xdg.mime.enable = true;
     xdg.menus.enable = true;
     xdg.icons.enable = true;
-    xdg.portal.enable = lib.mkDefault true;
-    xdg.portal.extraPortals = lib.mkDefault [
+    xdg.portal.enable = mkDefault true;
+    xdg.portal.extraPortals = mkDefault [
       pkgs.xdg-desktop-portal-gtk
     ];
 
     # https://github.com/NixOS/nixpkgs/pull/247766#issuecomment-1722839259
-    xdg.portal.config.deepin.default = lib.mkDefault [ "gtk" ];
+    xdg.portal.config.deepin.default = mkDefault [ "gtk" ];
 
     environment.sessionVariables = {
       NIX_GSETTINGS_OVERRIDES_DIR = "${nixos-gsettings-overrides}/share/gsettings-schemas/nixos-gsettings-overrides/glib-2.0/schemas";

nixos/modules/services/x11/desktop-managers/enlightenment.nix

···
   lib,
   ...
 }:
+
+with lib;
+
 let
 
   e = pkgs.enlightenment;
···
 
 {
   meta = {
-    maintainers = lib.teams.enlightenment.members;
+    maintainers = teams.enlightenment.members;
   };
 
   imports = [
-    (lib.mkRenamedOptionModule
+    (mkRenamedOptionModule
       [ "services" "xserver" "desktopManager" "e19" "enable" ]
       [ "services" "xserver" "desktopManager" "enlightenment" "enable" ]
     )
···
 
   options = {
 
-    services.xserver.desktopManager.enlightenment.enable = lib.mkOption {
-      type = lib.types.bool;
+    services.xserver.desktopManager.enlightenment.enable = mkOption {
+      type = types.bool;
       default = false;
       description = "Enable the Enlightenment desktop environment.";
     };
 
   };
 
-  config = lib.mkIf cfg.enable {
+  config = mkIf cfg.enable {
 
     environment.systemPackages = with pkgs; [
       enlightenment.econnman
···
 
     services.udisks2.enable = true;
     services.upower.enable = config.powerManagement.enable;
-    services.libinput.enable = lib.mkDefault true;
+    services.libinput.enable = mkDefault true;
 
     services.dbus.packages = [ e.efl ];
 

nixos/modules/services/x11/desktop-managers/kodi.nix

···
   pkgs,
   ...
 }:
+
+with lib;
+
 let
   cfg = config.services.xserver.desktopManager.kodi;
 in
···
 {
   options = {
     services.xserver.desktopManager.kodi = {
-      enable = lib.mkOption {
-        type = lib.types.bool;
+      enable = mkOption {
+        type = types.bool;
         default = false;
         description = "Enable the kodi multimedia center.";
       };
 
-      package = lib.mkPackageOption pkgs "kodi" {
+      package = mkPackageOption pkgs "kodi" {
         example = "kodi.withPackages (p: with p; [ jellyfin pvr-iptvsimple vfs-sftp ])";
       };
     };
   };
 
-  config = lib.mkIf cfg.enable {
+  config = mkIf cfg.enable {
     services.xserver.desktopManager.session = [
       {
         name = "kodi";

nixos/modules/services/x11/desktop-managers/lumina.nix

···
   pkgs,
   ...
 }:
+
+with lib;
+
 let
 
   xcfg = config.services.xserver;
···
 
 {
   meta = {
-    maintainers = lib.teams.lumina.members;
+    maintainers = teams.lumina.members;
   };
 
   options = {
 
-    services.xserver.desktopManager.lumina.enable = lib.mkOption {
-      type = lib.types.bool;
+    services.xserver.desktopManager.lumina.enable = mkOption {
+      type = types.bool;
       default = false;
       description = "Enable the Lumina desktop manager";
     };
 
   };
 
-  config = lib.mkIf cfg.enable {
+  config = mkIf cfg.enable {
 
     services.displayManager.sessionPackages = [
       pkgs.lumina.lumina

nixos/modules/services/x11/desktop-managers/lxqt.nix

···
 { config, lib, pkgs, utils, ... }:
+
+with lib;
+
 let
   xcfg = config.services.xserver;
   cfg = xcfg.desktopManager.lxqt;
···
 
 {
   meta = {
-    maintainers = lib.teams.lxqt.members;
+    maintainers = teams.lxqt.members;
   };
 
   options = {
 
-    services.xserver.desktopManager.lxqt.enable = lib.mkOption {
-      type = lib.types.bool;
+    services.xserver.desktopManager.lxqt.enable = mkOption {
+      type = types.bool;
       default = false;
       description = "Enable the LXQt desktop manager";
     };
 
-    environment.lxqt.excludePackages = lib.mkOption {
+    environment.lxqt.excludePackages = mkOption {
       default = [];
-      example = lib.literalExpression "[ pkgs.lxqt.qterminal ]";
-      type = lib.types.listOf lib.types.package;
+      example = literalExpression "[ pkgs.lxqt.qterminal ]";
+      type = types.listOf types.package;
       description = "Which LXQt packages to exclude from the default environment";
     };
 
   };
 
-  config = lib.mkIf cfg.enable {
+  config = mkIf cfg.enable {
 
-    services.xserver.desktopManager.session = lib.singleton {
+    services.xserver.desktopManager.session = singleton {
       name = "lxqt";
       bgSupport = true;
       start = ''
···
     # Link some extra directories in /run/current-system/software/share
     environment.pathsToLink = [ "/share" ];
 
-    programs.gnupg.agent.pinentryPackage = lib.mkDefault pkgs.pinentry-qt;
+    programs.gnupg.agent.pinentryPackage = mkDefault pkgs.pinentry-qt;
 
     # virtual file systems support for PCManFM-QT
     services.gvfs.enable = true;
 
     services.upower.enable = config.powerManagement.enable;
 
-    services.libinput.enable = lib.mkDefault true;
+    services.libinput.enable = mkDefault true;
 
-    xdg.portal.lxqt.enable = lib.mkDefault true;
+    xdg.portal.lxqt.enable = mkDefault true;
 
     # https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=1050804
-    xdg.portal.config.lxqt.default = lib.mkDefault [ "lxqt" "gtk" ];
+    xdg.portal.config.lxqt.default = mkDefault [ "lxqt" "gtk" ];
   };
 
 }

nixos/modules/services/x11/desktop-managers/mate.nix

···
   utils,
   ...
 }:
+
+with lib;
+
 let
 
   xcfg = config.services.xserver;
···
   options = {
 
     services.xserver.desktopManager.mate = {
-      enable = lib.mkOption {
-        type = lib.types.bool;
+      enable = mkOption {
+        type = types.bool;
         default = false;
         description = "Enable the MATE desktop environment";
       };
 
-      debug = lib.mkEnableOption "mate-session debug messages";
+      debug = mkEnableOption "mate-session debug messages";
 
-      extraPanelApplets = lib.mkOption {
+      extraPanelApplets = mkOption {
         default = [ ];
-        example = lib.literalExpression "with pkgs.mate; [ mate-applets ]";
-        type = lib.types.listOf lib.types.package;
+        example = literalExpression "with pkgs.mate; [ mate-applets ]";
+        type = types.listOf types.package;
         description = "Extra applets to add to mate-panel.";
       };
 
-      extraCajaExtensions = lib.mkOption {
+      extraCajaExtensions = mkOption {
         default = [ ];
         example = lib.literalExpression "with pkgs.mate; [ caja-extensions ]";
-        type = lib.types.listOf lib.types.package;
+        type = types.listOf types.package;
         description = "Extra extensions to add to caja.";
       };
 
-      enableWaylandSession = lib.mkEnableOption "MATE Wayland session";
+      enableWaylandSession = mkEnableOption "MATE Wayland session";
     };
 
-    environment.mate.excludePackages = lib.mkOption {
+    environment.mate.excludePackages = mkOption {
       default = [ ];
-      example = lib.literalExpression "[ pkgs.mate.mate-terminal pkgs.mate.pluma ]";
-      type = lib.types.listOf lib.types.package;
+      example = literalExpression "[ pkgs.mate.mate-terminal pkgs.mate.pluma ]";
+      type = types.listOf types.package;
       description = "Which MATE packages to exclude from the default environment";
     };
 
   };
 
-  config = lib.mkMerge [
-    (lib.mkIf (cfg.enable || cfg.enableWaylandSession) {
+  config = mkMerge [
+    (mkIf (cfg.enable || cfg.enableWaylandSession) {
       services.displayManager.sessionPackages = [
         pkgs.mate.mate-session-manager
       ];
 
       # Debugging
-      environment.sessionVariables.MATE_SESSION_DEBUG = lib.mkIf cfg.debug "1";
+      environment.sessionVariables.MATE_SESSION_DEBUG = mkIf cfg.debug "1";
 
       environment.systemPackages = utils.removePackagesByName (
         pkgs.mate.basePackages
···
 
       programs.dconf.enable = true;
       # Shell integration for VTE terminals
-      programs.bash.vteIntegration = lib.mkDefault true;
-      programs.zsh.vteIntegration = lib.mkDefault true;
+      programs.bash.vteIntegration = mkDefault true;
+      programs.zsh.vteIntegration = mkDefault true;
 
       # Mate uses this for printing
-      programs.system-config-printer.enable = (
-        lib.mkIf config.services.printing.enable (lib.mkDefault true)
-      );
+      programs.system-config-printer.enable = (mkIf config.services.printing.enable (mkDefault true));
 
       services.gnome.at-spi2-core.enable = true;
       services.gnome.glib-networking.enable = true;
···
       services.udev.packages = [ pkgs.mate.mate-settings-daemon ];
       services.gvfs.enable = true;
       services.upower.enable = config.powerManagement.enable;
-      services.libinput.enable = lib.mkDefault true;
+      services.libinput.enable = mkDefault true;
 
       security.pam.services.mate-screensaver.unixAuth = true;
 
-      xdg.portal.configPackages = lib.mkDefault [ pkgs.mate.mate-desktop ];
+      xdg.portal.configPackages = mkDefault [ pkgs.mate.mate-desktop ];
 
       environment.pathsToLink = [ "/share" ];
     })
-    (lib.mkIf cfg.enableWaylandSession {
+    (mkIf cfg.enableWaylandSession {
       programs.wayfire.enable = true;
       programs.wayfire.plugins = [ pkgs.wayfirePlugins.firedecor ];
 

nixos/modules/services/x11/desktop-managers/none.nix

···
   pkgs,
   ...
 }:
+with lib;
 let
   runXdgAutostart = config.services.xserver.desktopManager.runXdgAutostartIfNone;
 in
 {
   options = {
-    services.xserver.desktopManager.runXdgAutostartIfNone = lib.mkOption {
-      type = lib.types.bool;
+    services.xserver.desktopManager.runXdgAutostartIfNone = mkOption {
+      type = types.bool;
       default = false;
       description = ''
         Whether to run XDG autostart files for sessions without a desktop manager
···
     };
   };
 
-  config = lib.mkMerge [
+  config = mkMerge [
     {
       services.xserver.desktopManager.session = [
         {
           name = "none";
-          start = lib.optionalString runXdgAutostart ''
+          start = optionalString runXdgAutostart ''
             /run/current-system/systemd/bin/systemctl --user start xdg-autostart-if-no-desktop-manager.target
           '';
         }
       ];
     }
-    (lib.mkIf runXdgAutostart {
+    (mkIf runXdgAutostart {
       systemd.user.targets.xdg-autostart-if-no-desktop-manager = {
         description = "Run XDG autostart files";
         # From `plasma-workspace`, `share/systemd/user/plasma-workspace@.target`.

nixos/modules/services/x11/desktop-managers/pantheon.nix

···
 { config, lib, utils, pkgs, ... }:
+
+with lib;
+
 let
 
   cfg = config.services.xserver.desktopManager.pantheon;
···
 
   meta = {
     doc = ./pantheon.md;
-    maintainers = lib.teams.pantheon.members;
+    maintainers = teams.pantheon.members;
   };
 
   options = {
···
     services.pantheon = {
 
       contractor = {
-         enable = lib.mkEnableOption "contractor, a desktop-wide extension service used by Pantheon";
+         enable = mkEnableOption "contractor, a desktop-wide extension service used by Pantheon";
       };
 
-      apps.enable = lib.mkEnableOption "Pantheon default applications";
+      apps.enable = mkEnableOption "Pantheon default applications";
 
     };
 
     services.xserver.desktopManager.pantheon = {
-      enable = lib.mkOption {
-        type = lib.types.bool;
+      enable = mkOption {
+        type = types.bool;
         default = false;
         description = "Enable the pantheon desktop manager";
       };
 
-      sessionPath = lib.mkOption {
+      sessionPath = mkOption {
         default = [];
-        type = lib.types.listOf lib.types.package;
-        example = lib.literalExpression "[ pkgs.gpaste ]";
+        type = types.listOf types.package;
+        example = literalExpression "[ pkgs.gpaste ]";
         description = ''
           Additional list of packages to be added to the session search path.
           Useful for GSettings-conditional autostart.
···
         '';
       };
 
-      extraWingpanelIndicators = lib.mkOption {
+      extraWingpanelIndicators = mkOption {
         default = null;
-        type = with lib.types; nullOr (listOf package);
+        type = with types; nullOr (listOf package);
         description = "Indicators to add to Wingpanel.";
       };
 
-      extraSwitchboardPlugs = lib.mkOption {
+      extraSwitchboardPlugs = mkOption {
         default = null;
-        type = with lib.types; nullOr (listOf package);
+        type = with types; nullOr (listOf package);
         description = "Plugs to add to Switchboard.";
       };
 
-      extraGSettingsOverrides = lib.mkOption {
+      extraGSettingsOverrides = mkOption {
         default = "";
-        type = lib.types.lines;
+        type = types.lines;
         description = "Additional gsettings overrides.";
       };
 
-      extraGSettingsOverridePackages = lib.mkOption {
+      extraGSettingsOverridePackages = mkOption {
         default = [];
-        type = lib.types.listOf lib.types.path;
+        type = types.listOf types.path;
         description = "List of packages for which gsettings are overridden.";
       };
 
-      debug = lib.mkEnableOption "gnome-session debug messages";
+      debug = mkEnableOption "gnome-session debug messages";
 
     };
 
-    environment.pantheon.excludePackages = lib.mkOption {
+    environment.pantheon.excludePackages = mkOption {
       default = [];
-      example = lib.literalExpression "[ pkgs.pantheon.elementary-camera ]";
-      type = lib.types.listOf lib.types.package;
+      example = literalExpression "[ pkgs.pantheon.elementary-camera ]";
+      type = types.listOf types.package;
       description = "Which packages pantheon should exclude from the default environment";
     };
 
   };
 
 
-  config = lib.mkMerge [
-    (lib.mkIf cfg.enable {
+  config = mkMerge [
+    (mkIf cfg.enable {
       services.xserver.desktopManager.pantheon.sessionPath = utils.removePackagesByName [
         pkgs.pantheon.pantheon-agent-geoclue2
       ] config.environment.pantheon.excludePackages;
···
 
       # Ensure lightdm is used when Pantheon is enabled
       # Without it screen locking will be nonfunctional because of the use of lightlocker
-      warnings = lib.optional (config.services.xserver.displayManager.lightdm.enable != true)
+      warnings = optional (config.services.xserver.displayManager.lightdm.enable != true)
         ''
           Using Pantheon without LightDM as a displayManager will break screenlocking from the UI.
         '';
 
-      services.xserver.displayManager.lightdm.greeters.pantheon.enable = lib.mkDefault true;
+      services.xserver.displayManager.lightdm.greeters.pantheon.enable = mkDefault true;
 
       # Without this, elementary LightDM greeter will pre-select non-existent `default` session
       # https://github.com/elementary/greeter/issues/368
-      services.displayManager.defaultSession = lib.mkDefault "pantheon";
+      services.displayManager.defaultSession = mkDefault "pantheon";
 
       services.xserver.displayManager.sessionCommands = ''
         if test "$XDG_CURRENT_DESKTOP" = "Pantheon"; then
             true
-            ${lib.concatMapStrings (p: ''
+            ${concatMapStrings (p: ''
               if [ -d "${p}/share/gsettings-schemas/${p.name}" ]; then
                 export XDG_DATA_DIRS=$XDG_DATA_DIRS''${XDG_DATA_DIRS:+:}${p}/share/gsettings-schemas/${p.name}
               fi
···
       '';
 
       # Default services
-      hardware.bluetooth.enable = lib.mkDefault true;
+      hardware.bluetooth.enable = mkDefault true;
       security.polkit.enable = true;
       services.accounts-daemon.enable = true;
       services.bamf.enable = true;
-      services.colord.enable = lib.mkDefault true;
-      services.fwupd.enable = lib.mkDefault true;
+      services.colord.enable = mkDefault true;
+      services.fwupd.enable = mkDefault true;
       # TODO: Enable once #177946 is resolved
       # services.packagekit.enable = mkDefault true;
-      services.power-profiles-daemon.enable = lib.mkDefault true;
-      services.touchegg.enable = lib.mkDefault true;
+      services.power-profiles-daemon.enable = mkDefault true;
+      services.touchegg.enable = mkDefault true;
       services.touchegg.package = pkgs.pantheon.touchegg;
-      services.tumbler.enable = lib.mkDefault true;
-      services.system-config-printer.enable = (lib.mkIf config.services.printing.enable (lib.mkDefault true));
+      services.tumbler.enable = mkDefault true;
+      services.system-config-printer.enable = (mkIf config.services.printing.enable (mkDefault true));
       services.dbus.packages = with pkgs.pantheon; [
         switchboard-plug-power
         elementary-default-settings # accountsservice extensions
       ];
-      services.pantheon.apps.enable = lib.mkDefault true;
-      services.pantheon.contractor.enable = lib.mkDefault true;
+      services.pantheon.apps.enable = mkDefault true;
+      services.pantheon.contractor.enable = mkDefault true;
       services.gnome.at-spi2-core.enable = true;
       services.gnome.evolution-data-server.enable = true;
       services.gnome.glib-networking.enable = true;
       services.gnome.gnome-keyring.enable = true;
       services.gvfs.enable = true;
-      services.gnome.rygel.enable = lib.mkDefault true;
+      services.gnome.rygel.enable = mkDefault true;
       services.udisks2.enable = true;
       services.upower.enable = config.powerManagement.enable;
-      services.libinput.enable = lib.mkDefault true;
-      services.switcherooControl.enable = lib.mkDefault true;
+      services.libinput.enable = mkDefault true;
+      services.switcherooControl.enable = mkDefault true;
       services.xserver.updateDbusEnvironment = true;
-      services.zeitgeist.enable = lib.mkDefault true;
-      services.geoclue2.enable = lib.mkDefault true;
+      services.zeitgeist.enable = mkDefault true;
+      services.geoclue2.enable = mkDefault true;
       # pantheon has pantheon-agent-geoclue2
       services.geoclue2.enableDemoAgent = false;
       services.geoclue2.appConfig."io.elementary.desktop.agent-geoclue2" = {
···
         # https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1443
         pkgs.pantheon.mutter
       ];
-      services.orca.enable = lib.mkDefault (notExcluded pkgs.orca);
+      services.orca.enable = mkDefault (notExcluded pkgs.orca);
       systemd.packages = with pkgs; [
         gnome-session
         pantheon.gala
···
         pantheon.elementary-session-settings
       ];
       programs.dconf.enable = true;
-      networking.networkmanager.enable = lib.mkDefault true;
+      networking.networkmanager.enable = mkDefault true;
 
       systemd.user.targets."gnome-session-x11-services".wants = [
         "org.gnome.SettingsDaemon.XSettings.service"
···
         xdg-desktop-portal-pantheon
       ]);
 
-      xdg.portal.configPackages = lib.mkDefault [ pkgs.pantheon.elementary-default-settings ];
+      xdg.portal.configPackages = mkDefault [ pkgs.pantheon.elementary-default-settings ];
 
       # Override GSettings schemas
       environment.sessionVariables.NIX_GSETTINGS_OVERRIDES_DIR = "${nixos-gsettings-desktop-schemas}/share/gsettings-schemas/nixos-gsettings-overrides/glib-2.0/schemas";
 
-      environment.sessionVariables.GNOME_SESSION_DEBUG = lib.mkIf cfg.debug "1";
+      environment.sessionVariables.GNOME_SESSION_DEBUG = mkIf cfg.debug "1";
 
       environment.pathsToLink = [
         # FIXME: modules should link subdirs of `/share` rather than relying on this
···
       programs.nm-applet.indicator = false;
 
       # Shell integration for VTE terminals
-      programs.bash.vteIntegration = lib.mkDefault true;
-      programs.zsh.vteIntegration = lib.mkDefault true;
+      programs.bash.vteIntegration = mkDefault true;
+      programs.zsh.vteIntegration = mkDefault true;
 
       # Default Fonts
       fonts.packages = with pkgs; [
···
       };
     })
 
-    (lib.mkIf serviceCfg.apps.enable {
-      programs.evince.enable = lib.mkDefault (notExcluded pkgs.evince);
-      programs.file-roller.enable = lib.mkDefault (notExcluded pkgs.file-roller);
+    (mkIf serviceCfg.apps.enable {
+      programs.evince.enable = mkDefault (notExcluded pkgs.evince);
+      programs.file-roller.enable = mkDefault (notExcluded pkgs.file-roller);
 
       environment.systemPackages = utils.removePackagesByName ([
         pkgs.gnome-font-viewer
···
       ];
     })
 
-    (lib.mkIf serviceCfg.contractor.enable {
+    (mkIf serviceCfg.contractor.enable {
       environment.systemPackages = with pkgs.pantheon; [
         contractor
         file-roller-contract

nixos/modules/services/x11/desktop-managers/retroarch.nix

···
   pkgs,
   ...
 }:
+
+with lib;
+
 let
   cfg = config.services.xserver.desktopManager.retroarch;
 
 in
 {
   options.services.xserver.desktopManager.retroarch = {
-    enable = lib.mkEnableOption "RetroArch";
+    enable = mkEnableOption "RetroArch";
 
-    package = lib.mkPackageOption pkgs "retroarch" {
+    package = mkPackageOption pkgs "retroarch" {
       example = "retroarch-full";
     };
 
-    extraArgs = lib.mkOption {
-      type = lib.types.listOf lib.types.str;
+    extraArgs = mkOption {
+      type = types.listOf types.str;
       default = [ ];
       example = [
         "--verbose"
···
     };
   };
 
-  config = lib.mkIf cfg.enable {
+  config = mkIf cfg.enable {
     services.xserver.desktopManager.session = [
       {
         name = "RetroArch";
         start = ''
-          ${cfg.package}/bin/retroarch -f ${lib.escapeShellArgs cfg.extraArgs} &
+          ${cfg.package}/bin/retroarch -f ${escapeShellArgs cfg.extraArgs} &
           waitPID=$!
         '';
       }
···
     environment.systemPackages = [ cfg.package ];
   };
 
-  meta.maintainers = with lib.maintainers; [ j0hax ];
+  meta.maintainers = with maintainers; [ j0hax ];
 }

nixos/modules/services/x11/desktop-managers/surf-display.nix

···
   pkgs,
   ...
 }:
+
+with lib;
+
 let
   cfg = config.services.xserver.desktopManager.surf-display;
 
···
 {
   options = {
     services.xserver.desktopManager.surf-display = {
-      enable = lib.mkEnableOption "surf-display as a kiosk browser session";
+      enable = mkEnableOption "surf-display as a kiosk browser session";
 
-      defaultWwwUri = lib.mkOption {
-        type = lib.types.str;
+      defaultWwwUri = mkOption {
+        type = types.str;
         default = "${pkgs.surf-display}/share/surf-display/empty-page.html";
-        defaultText = lib.literalExpression ''"''${pkgs.surf-display}/share/surf-display/empty-page.html"'';
+        defaultText = literalExpression ''"''${pkgs.surf-display}/share/surf-display/empty-page.html"'';
         example = "https://www.example.com/";
         description = "Default URI to display.";
       };
 
-      inactivityInterval = lib.mkOption {
-        type = lib.types.int;
+      inactivityInterval = mkOption {
+        type = types.int;
         default = 300;
         example = 0;
         description = ''
···
         '';
       };
 
-      screensaverSettings = lib.mkOption {
-        type = lib.types.separatedString " ";
+      screensaverSettings = mkOption {
+        type = types.separatedString " ";
         default = "";
         description = ''
           Screensaver settings, see `man 1 xset` for possible options.
         '';
       };
 
-      pointerButtonMap = lib.mkOption {
-        type = lib.types.str;
+      pointerButtonMap = mkOption {
+        type = types.str;
         default = "1 0 0 4 5 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0";
         description = ''
           Disable right and middle pointer device click in browser sessions
···
         '';
       };
 
-      hideIdlePointer = lib.mkOption {
-        type = lib.types.str;
+      hideIdlePointer = mkOption {
+        type = types.str;
         default = "yes";
         example = "no";
         description = "Hide idle mouse pointer.";
       };
 
-      extraConfig = lib.mkOption {
-        type = lib.types.lines;
+      extraConfig = mkOption {
+        type = types.lines;
         default = "";
         example = ''
           # Enforce fixed resolution for all displays (default: not set):
···
     };
   };
 
-  config = lib.mkIf cfg.enable {
+  config = mkIf cfg.enable {
     services.displayManager.sessionPackages = [
       pkgs.surf-display
     ];

nixos/modules/services/x11/desktop-managers/xfce.nix

···
 { config, lib, pkgs, utils, ... }:
+
+with lib;
+
 let
   cfg = config.services.xserver.desktopManager.xfce;
   excludePackages = config.environment.xfce.excludePackages;
···
 in
 {
   meta = {
-    maintainers = lib.teams.xfce.members;
+    maintainers = teams.xfce.members;
   };
 
   imports = [
     # added 2019-08-18
     # needed to preserve some semblance of UI familarity
     # with original XFCE module
-    (lib.mkRenamedOptionModule
+    (mkRenamedOptionModule
       [ "services" "xserver" "desktopManager" "xfce4-14" "extraSessionCommands" ]
       [ "services" "xserver" "displayManager" "sessionCommands" ])
 
     # added 2019-11-04
     # xfce4-14 module removed and promoted to xfce.
     # Needed for configs that used xfce4-14 module to migrate to this one.
-    (lib.mkRenamedOptionModule
+    (mkRenamedOptionModule
       [ "services" "xserver" "desktopManager" "xfce4-14" "enable" ]
       [ "services" "xserver" "desktopManager" "xfce" "enable" ])
-    (lib.mkRenamedOptionModule
+    (mkRenamedOptionModule
       [ "services" "xserver" "desktopManager" "xfce4-14" "noDesktop" ]
       [ "services" "xserver" "desktopManager" "xfce" "noDesktop" ])
-    (lib.mkRenamedOptionModule
+    (mkRenamedOptionModule
       [ "services" "xserver" "desktopManager" "xfce4-14" "enableXfwm" ]
       [ "services" "xserver" "desktopManager" "xfce" "enableXfwm" ])
-    (lib.mkRenamedOptionModule
+    (mkRenamedOptionModule
       [ "services" "xserver" "desktopManager" "xfce" "extraSessionCommands" ]
       [ "services" "xserver" "displayManager" "sessionCommands" ])
-    (lib.mkRemovedOptionModule [ "services" "xserver" "desktopManager" "xfce" "screenLock" ] "")
+    (mkRemovedOptionModule [ "services" "xserver" "desktopManager" "xfce" "screenLock" ] "")
 
     # added 2022-06-26
     # thunar has its own module
-    (lib.mkRenamedOptionModule
+    (mkRenamedOptionModule
       [ "services" "xserver" "desktopManager" "xfce" "thunarPlugins" ]
       [ "programs" "thunar" "plugins" ])
   ];
 
   options = {
     services.xserver.desktopManager.xfce = {
-      enable = lib.mkOption {
-        type = lib.types.bool;
+      enable = mkOption {
+        type = types.bool;
         default = false;
         description = "Enable the Xfce desktop environment.";
       };
 
-      noDesktop = lib.mkOption {
-        type = lib.types.bool;
+      noDesktop = mkOption {
+        type = types.bool;
         default = false;
         description = "Don't install XFCE desktop components (xfdesktop and panel).";
       };
 
-      enableXfwm = lib.mkOption {
-        type = lib.types.bool;
+      enableXfwm = mkOption {
+        type = types.bool;
         default = true;
         description = "Enable the XFWM (default) window manager.";
       };
 
-      enableScreensaver = lib.mkOption {
-        type = lib.types.bool;
+      enableScreensaver = mkOption {
+        type = types.bool;
         default = true;
         description = "Enable the XFCE screensaver.";
       };
 
-      enableWaylandSession = lib.mkEnableOption "the experimental Xfce Wayland session";
+      enableWaylandSession = mkEnableOption "the experimental Xfce Wayland session";
 
-      waylandSessionCompositor = lib.mkOption {
+      waylandSessionCompositor = mkOption {
         type = lib.types.str;
         default = "";
         example = "wayfire";
···
       };
     };
 
-    environment.xfce.excludePackages = lib.mkOption {
+    environment.xfce.excludePackages = mkOption {
       default = [];
-      example = lib.literalExpression "[ pkgs.xfce.xfce4-volumed-pulse ]";
-      type = lib.types.listOf lib.types.package;
+      example = literalExpression "[ pkgs.xfce.xfce4-volumed-pulse ]";
+      type = types.listOf types.package;
       description = "Which packages XFCE should exclude from the default environment";
     };
   };
 
-  config = lib.mkIf cfg.enable {
+  config = mkIf cfg.enable {
     environment.systemPackages = utils.removePackagesByName (with pkgs; [
       glib # for gsettings
       gtk3.out # gtk-update-icon-cache
···
       xfce.xfce4-taskmanager
       xfce.xfce4-terminal
     ] # TODO: NetworkManager doesn't belong here
-      ++ optional config.networking.networkmanager.enable networkmanagerapplet
-      ++ optional config.powerManagement.enable xfce.xfce4-power-manager
-      ++ optionals (config.services.pulseaudio.enable || config.services.pipewire.pulse.enable) [
+      ++ lib.optional config.networking.networkmanager.enable networkmanagerapplet
+      ++ lib.optional config.powerManagement.enable xfce.xfce4-power-manager
+      ++ lib.optionals (config.services.pulseaudio.enable || config.services.pipewire.pulse.enable) [
         pavucontrol
         # volume up/down keys support:
         # xfce4-pulseaudio-plugin includes all the functionalities of xfce4-volumed-pulse
         # but can only be used with xfce4-panel, so for no-desktop usage we still include
         # xfce4-volumed-pulse
         (if cfg.noDesktop then xfce.xfce4-volumed-pulse else xfce.xfce4-pulseaudio-plugin)
-      ] ++ optionals cfg.enableXfwm [
+      ] ++ lib.optionals cfg.enableXfwm [
         xfce.xfwm4
         xfce.xfwm4-themes
-      ] ++ optionals (!cfg.noDesktop) [
+      ] ++ lib.optionals (!cfg.noDesktop) [
         xfce.xfce4-panel
         xfce.xfdesktop
-      ] ++ optional cfg.enableScreensaver xfce.xfce4-screensaver) excludePackages;
+      ] ++ lib.optional cfg.enableScreensaver xfce.xfce4-screensaver) excludePackages;
 
-    programs.gnupg.agent.pinentryPackage = lib.mkDefault pkgs.pinentry-gtk2;
+    programs.gnupg.agent.pinentryPackage = mkDefault pkgs.pinentry-gtk2;
     programs.xfconf.enable = true;
     programs.thunar.enable = true;
-    programs.labwc.enable = lib.mkDefault (cfg.enableWaylandSession && (
+    programs.labwc.enable = mkDefault (cfg.enableWaylandSession && (
       cfg.waylandSessionCompositor == "" || lib.substring 0 5 cfg.waylandSessionCompositor == "labwc"));
 
     environment.pathsToLink = [
···
 
     # Copied from https://gitlab.xfce.org/xfce/xfce4-session/-/blob/xfce4-session-4.19.2/xfce-wayland.desktop.in
     # to maintain consistent l10n state with X11 session file and to support the waylandSessionCompositor option.
-    services.displayManager.sessionPackages = lib.optionals cfg.enableWaylandSession [
+    services.displayManager.sessionPackages = optionals cfg.enableWaylandSession [
       ((pkgs.writeTextDir "share/wayland-sessions/xfce-wayland.desktop" ''
         [Desktop Entry]
         Version=1.0
···
     services.gnome.glib-networking.enable = true;
     services.gvfs.enable = true;
     services.tumbler.enable = true;
-    services.system-config-printer.enable = (lib.mkIf config.services.printing.enable (lib.mkDefault true));
-    services.libinput.enable = lib.mkDefault true; # used in xfce4-settings-manager
-    services.colord.enable = lib.mkDefault true;
+    services.system-config-printer.enable = (mkIf config.services.printing.enable (mkDefault true));
+    services.libinput.enable = mkDefault true; # used in xfce4-settings-manager
+    services.colord.enable = mkDefault true;
 
     # Enable default programs
     programs.dconf.enable = true;
 
     # Shell integration for VTE terminals
-    programs.bash.vteIntegration = lib.mkDefault true;
-    programs.zsh.vteIntegration = lib.mkDefault true;
+    programs.bash.vteIntegration = mkDefault true;
+    programs.zsh.vteIntegration = mkDefault true;
 
     # Systemd services
     systemd.packages = utils.removePackagesByName (with pkgs.xfce; [
···
 
     security.pam.services.xfce4-screensaver.unixAuth = cfg.enableScreensaver;
 
-    xdg.portal.configPackages = lib.mkDefault [ pkgs.xfce.xfce4-session ];
+    xdg.portal.configPackages = mkDefault [ pkgs.xfce.xfce4-session ];
   };
 }

nixos/modules/services/x11/desktop-managers/xterm.nix

···
   pkgs,
   ...
 }:
+
+with lib;
+
 let
 
   cfg = config.services.xserver.desktopManager.xterm;
···
 {
   options = {
 
-    services.xserver.desktopManager.xterm.enable = lib.mkOption {
-      type = lib.types.bool;
-      default = lib.versionOlder config.system.stateVersion "19.09" && xSessionEnabled;
-      defaultText = lib.literalExpression ''versionOlder config.system.stateVersion "19.09" && config.services.xserver.enable;'';
+    services.xserver.desktopManager.xterm.enable = mkOption {
+      type = types.bool;
+      default = versionOlder config.system.stateVersion "19.09" && xSessionEnabled;
+      defaultText = literalExpression ''versionOlder config.system.stateVersion "19.09" && config.services.xserver.enable;'';
       description = "Enable a xterm terminal as a desktop manager.";
     };
 
   };
 
-  config = lib.mkIf cfg.enable {
+  config = mkIf cfg.enable {
 
-    services.xserver.desktopManager.session = lib.singleton {
+    services.xserver.desktopManager.session = singleton {
       name = "xterm";
       start = ''
         ${pkgs.xterm}/bin/xterm -ls &

nixos/modules/services/x11/display-managers/lightdm-greeters/enso-os.nix

···
   pkgs,
   ...
 }:
+
+with lib;
 let
   dmcfg = config.services.xserver.displayManager;
   ldmcfg = dmcfg.lightdm;
···
 {
   options = {
     services.xserver.displayManager.lightdm.greeters.enso = {
-      enable = lib.mkOption {
-        type = lib.types.bool;
+      enable = mkOption {
+        type = types.bool;
         default = false;
         description = ''
           Whether to enable enso-os-greeter as the lightdm greeter
···
       };
 
       theme = {
-        package = lib.mkOption {
-          type = lib.types.package;
+        package = mkOption {
+          type = types.package;
           default = pkgs.gnome-themes-extra;
-          defaultText = lib.literalExpression "pkgs.gnome-themes-extra";
+          defaultText = literalExpression "pkgs.gnome-themes-extra";
           description = ''
             The package path that contains the theme given in the name option.
           '';
         };
 
-        name = lib.mkOption {
-          type = lib.types.str;
+        name = mkOption {
+          type = types.str;
           default = "Adwaita";
           description = ''
             Name of the theme to use for the lightdm-enso-os-greeter
···
       };
 
       iconTheme = {
-        package = lib.mkOption {
-          type = lib.types.package;
+        package = mkOption {
+          type = types.package;
           default = pkgs.papirus-icon-theme;
-          defaultText = lib.literalExpression "pkgs.papirus-icon-theme";
+          defaultText = literalExpression "pkgs.papirus-icon-theme";
           description = ''
             The package path that contains the icon theme given in the name option.
           '';
         };
 
-        name = lib.mkOption {
-          type = lib.types.str;
+        name = mkOption {
+          type = types.str;
           default = "ePapirus";
           description = ''
             Name of the icon theme to use for the lightdm-enso-os-greeter
···
       };
 
       cursorTheme = {
-        package = lib.mkOption {
-          type = lib.types.package;
+        package = mkOption {
+          type = types.package;
           default = pkgs.capitaine-cursors;
-          defaultText = lib.literalExpression "pkgs.capitaine-cursors";
+          defaultText = literalExpression "pkgs.capitaine-cursors";
           description = ''
             The package path that contains the cursor theme given in the name option.
           '';
         };
 
-        name = lib.mkOption {
-          type = lib.types.str;
+        name = mkOption {
+          type = types.str;
           default = "capitane-cursors";
           description = ''
             Name of the cursor theme to use for the lightdm-enso-os-greeter
···
         };
       };
 
-      blur = lib.mkOption {
-        type = lib.types.bool;
+      blur = mkOption {
+        type = types.bool;
         default = false;
         description = ''
           Whether or not to enable blur
         '';
       };
 
-      brightness = lib.mkOption {
-        type = lib.types.int;
+      brightness = mkOption {
+        type = types.int;
         default = 7;
         description = ''
           Brightness
         '';
       };
 
-      extraConfig = lib.mkOption {
-        type = lib.types.lines;
+      extraConfig = mkOption {
+        type = types.lines;
         default = "";
         description = ''
           Extra configuration that should be put in the greeter.conf
···
     };
   };
 
-  config = lib.mkIf (ldmcfg.enable && cfg.enable) {
+  config = mkIf (ldmcfg.enable && cfg.enable) {
     environment.etc."lightdm/greeter.conf".source = ensoGreeterConf;
 
     environment.systemPackages = [
···
     ];
 
     services.xserver.displayManager.lightdm = {
-      greeter = lib.mkDefault {
+      greeter = mkDefault {
         package = pkgs.lightdm-enso-os-greeter.xgreeters;
         name = "pantheon-greeter";
       };
 
       greeters = {
         gtk = {
-          enable = lib.mkDefault false;
+          enable = mkDefault false;
         };
       };
     };

nixos/modules/services/x11/display-managers/lightdm-greeters/gtk.nix

···
   pkgs,
   ...
 }:
+
+with lib;
+
 let
 
   dmcfg = config.services.xserver.displayManager;
···
     cursor-theme-name = ${cfg.cursorTheme.name}
     cursor-theme-size = ${toString cfg.cursorTheme.size}
     background = ${ldmcfg.background}
-    ${lib.optionalString (cfg.clock-format != null) "clock-format = ${cfg.clock-format}"}
-    ${lib.optionalString (
-      cfg.indicators != null
-    ) "indicators = ${lib.concatStringsSep ";" cfg.indicators}"}
-    ${lib.optionalString (xcfg.dpi != null) "xft-dpi=${toString xcfg.dpi}"}
+    ${optionalString (cfg.clock-format != null) "clock-format = ${cfg.clock-format}"}
+    ${optionalString (cfg.indicators != null) "indicators = ${concatStringsSep ";" cfg.indicators}"}
+    ${optionalString (xcfg.dpi != null) "xft-dpi=${toString xcfg.dpi}"}
     ${cfg.extraConfig}
   '';
 
···
 
     services.xserver.displayManager.lightdm.greeters.gtk = {
 
-      enable = lib.mkOption {
-        type = lib.types.bool;
+      enable = mkOption {
+        type = types.bool;
         default = true;
         description = ''
           Whether to enable lightdm-gtk-greeter as the lightdm greeter.
···
 
       theme = {
 
-        package = lib.mkOption {
-          type = lib.types.package;
+        package = mkOption {
+          type = types.package;
           default = pkgs.gnome-themes-extra;
-          defaultText = lib.literalExpression "pkgs.gnome-themes-extra";
+          defaultText = literalExpression "pkgs.gnome-themes-extra";
           description = ''
             The package path that contains the theme given in the name option.
           '';
         };
 
-        name = lib.mkOption {
-          type = lib.types.str;
+        name = mkOption {
+          type = types.str;
           default = "Adwaita";
           description = ''
             Name of the theme to use for the lightdm-gtk-greeter.
···
 
       iconTheme = {
 
-        package = lib.mkOption {
-          type = lib.types.package;
+        package = mkOption {
+          type = types.package;
           default = pkgs.adwaita-icon-theme;
-          defaultText = lib.literalExpression "pkgs.adwaita-icon-theme";
+          defaultText = literalExpression "pkgs.adwaita-icon-theme";
           description = ''
             The package path that contains the icon theme given in the name option.
           '';
         };
 
-        name = lib.mkOption {
-          type = lib.types.str;
+        name = mkOption {
+          type = types.str;
           default = "Adwaita";
           description = ''
             Name of the icon theme to use for the lightdm-gtk-greeter.
···
 
       cursorTheme = {
 
-        package = lib.mkOption {
-          type = lib.types.package;
+        package = mkOption {
+          type = types.package;
           default = pkgs.adwaita-icon-theme;
-          defaultText = lib.literalExpression "pkgs.adwaita-icon-theme";
+          defaultText = literalExpression "pkgs.adwaita-icon-theme";
           description = ''
             The package path that contains the cursor theme given in the name option.
           '';
         };
 
-        name = lib.mkOption {
-          type = lib.types.str;
+        name = mkOption {
+          type = types.str;
           default = "Adwaita";
           description = ''
             Name of the cursor theme to use for the lightdm-gtk-greeter.
           '';
         };
 
-        size = lib.mkOption {
-          type = lib.types.int;
+        size = mkOption {
+          type = types.int;
           default = 16;
           description = ''
             Size of the cursor theme to use for the lightdm-gtk-greeter.
···
         };
       };
 
-      clock-format = lib.mkOption {
-        type = lib.types.nullOr lib.types.str;
+      clock-format = mkOption {
+        type = types.nullOr types.str;
         default = null;
         example = "%F";
         description = ''
···
         '';
       };
 
-      indicators = lib.mkOption {
-        type = lib.types.nullOr (lib.types.listOf lib.types.str);
+      indicators = mkOption {
+        type = types.nullOr (types.listOf types.str);
         default = null;
         example = [
           "~host"
···
         '';
       };
 
-      extraConfig = lib.mkOption {
-        type = lib.types.lines;
+      extraConfig = mkOption {
+        type = types.lines;
         default = "";
         description = ''
           Extra configuration that should be put in the lightdm-gtk-greeter.conf
···
 
   };
 
-  config = lib.mkIf (ldmcfg.enable && cfg.enable) {
+  config = mkIf (ldmcfg.enable && cfg.enable) {
 
-    services.xserver.displayManager.lightdm.greeter = lib.mkDefault {
+    services.xserver.displayManager.lightdm.greeter = mkDefault {
       package = pkgs.lightdm-gtk-greeter.xgreeters;
       name = "lightdm-gtk-greeter";
     };

nixos/modules/services/x11/display-managers/lightdm-greeters/mini.nix

···
   pkgs,
   ...
 }:
+
+with lib;
+
 let
 
   dmcfg = config.services.xserver.displayManager;
···
 
     services.xserver.displayManager.lightdm.greeters.mini = {
 
-      enable = lib.mkOption {
-        type = lib.types.bool;
+      enable = mkOption {
+        type = types.bool;
         default = false;
         description = ''
           Whether to enable lightdm-mini-greeter as the lightdm greeter.
···
         '';
       };
 
-      user = lib.mkOption {
-        type = lib.types.str;
+      user = mkOption {
+        type = types.str;
         default = "root";
         description = ''
           The user to login as.
         '';
       };
 
-      extraConfig = lib.mkOption {
-        type = lib.types.lines;
+      extraConfig = mkOption {
+        type = types.lines;
         default = "";
         description = ''
           Extra configuration that should be put in the lightdm-mini-greeter.conf
···
 
   };
 
-  config = lib.mkIf (ldmcfg.enable && cfg.enable) {
+  config = mkIf (ldmcfg.enable && cfg.enable) {
 
     services.xserver.displayManager.lightdm.greeters.gtk.enable = false;
 
-    services.xserver.displayManager.lightdm.greeter = lib.mkDefault {
+    services.xserver.displayManager.lightdm.greeter = mkDefault {
       package = pkgs.lightdm-mini-greeter.xgreeters;
       name = "lightdm-mini-greeter";
     };

nixos/modules/services/x11/display-managers/lightdm-greeters/mobile.nix

···
   pkgs,
   ...
 }:
+
+with lib;
 let
   dmcfg = config.services.xserver.displayManager;
   ldmcfg = dmcfg.lightdm;
···
 {
   options = {
     services.xserver.displayManager.lightdm.greeters.mobile = {
-      enable = lib.mkEnableOption "lightdm-mobile-greeter as the lightdm greeter";
+      enable = mkEnableOption "lightdm-mobile-greeter as the lightdm greeter";
     };
   };
 
-  config = lib.mkIf (ldmcfg.enable && cfg.enable) {
+  config = mkIf (ldmcfg.enable && cfg.enable) {
     services.xserver.displayManager.lightdm.greeters.gtk.enable = false;
 
-    services.xserver.displayManager.lightdm.greeter = lib.mkDefault {
+    services.xserver.displayManager.lightdm.greeter = mkDefault {
       package = pkgs.lightdm-mobile-greeter.xgreeters;
       name = "lightdm-mobile-greeter";
     };

nixos/modules/services/x11/display-managers/lightdm-greeters/pantheon.nix

···
   pkgs,
   ...
 }:
+
+with lib;
+
 let
 
   dmcfg = config.services.xserver.displayManager;
···
 
     services.xserver.displayManager.lightdm.greeters.pantheon = {
 
-      enable = lib.mkOption {
-        type = lib.types.bool;
+      enable = mkOption {
+        type = types.bool;
         default = false;
         description = ''
           Whether to enable elementary-greeter as the lightdm greeter.
···
 
   };
 
-  config = lib.mkIf (ldmcfg.enable && cfg.enable) {
+  config = mkIf (ldmcfg.enable && cfg.enable) {
 
     services.xserver.displayManager.lightdm.greeters.gtk.enable = false;
 
-    services.xserver.displayManager.lightdm.greeter = lib.mkDefault {
+    services.xserver.displayManager.lightdm.greeter = mkDefault {
       package = pkgs.pantheon.elementary-greeter.xgreeters;
       name = "io.elementary.greeter";
     };

nixos/modules/services/x11/display-managers/lightdm-greeters/slick.nix

···
   pkgs,
   ...
 }:
+
+with lib;
+
 let
   ldmcfg = config.services.xserver.displayManager.lightdm;
   cfg = ldmcfg.greeters.slick;
···
     font-name=${cfg.font.name}
     cursor-theme-name=${cfg.cursorTheme.name}
     cursor-theme-size=${toString cfg.cursorTheme.size}
-    draw-user-backgrounds=${lib.boolToString cfg.draw-user-backgrounds}
+    draw-user-backgrounds=${boolToString cfg.draw-user-backgrounds}
     ${cfg.extraConfig}
   '';
 in
 {
   options = {
     services.xserver.displayManager.lightdm.greeters.slick = {
-      enable = lib.mkEnableOption "lightdm-slick-greeter as the lightdm greeter";
+      enable = mkEnableOption "lightdm-slick-greeter as the lightdm greeter";
 
       theme = {
-        package = lib.mkOption {
-          type = lib.types.package;
+        package = mkOption {
+          type = types.package;
           default = pkgs.gnome-themes-extra;
-          defaultText = lib.literalExpression "pkgs.gnome-themes-extra";
+          defaultText = literalExpression "pkgs.gnome-themes-extra";
           description = ''
             The package path that contains the theme given in the name option.
           '';
         };
 
-        name = lib.mkOption {
-          type = lib.types.str;
+        name = mkOption {
+          type = types.str;
           default = "Adwaita";
           description = ''
             Name of the theme to use for the lightdm-slick-greeter.
···
       };
 
       iconTheme = {
-        package = lib.mkOption {
-          type = lib.types.package;
+        package = mkOption {
+          type = types.package;
           default = pkgs.adwaita-icon-theme;
-          defaultText = lib.literalExpression "pkgs.adwaita-icon-theme";
+          defaultText = literalExpression "pkgs.adwaita-icon-theme";
           description = ''
             The package path that contains the icon theme given in the name option.
           '';
         };
 
-        name = lib.mkOption {
-          type = lib.types.str;
+        name = mkOption {
+          type = types.str;
           default = "Adwaita";
           description = ''
             Name of the icon theme to use for the lightdm-slick-greeter.
···
       };
 
       font = {
-        package = lib.mkOption {
-          type = lib.types.package;
+        package = mkOption {
+          type = types.package;
           default = pkgs.ubuntu-classic;
-          defaultText = lib.literalExpression "pkgs.ubuntu-classic";
+          defaultText = literalExpression "pkgs.ubuntu-classic";
           description = ''
             The package path that contains the font given in the name option.
           '';
         };
 
-        name = lib.mkOption {
-          type = lib.types.str;
+        name = mkOption {
+          type = types.str;
           default = "Ubuntu 11";
           description = ''
             Name of the font to use.
···
       };
 
       cursorTheme = {
-        package = lib.mkOption {
-          type = lib.types.package;
+        package = mkOption {
+          type = types.package;
           default = pkgs.adwaita-icon-theme;
-          defaultText = lib.literalExpression "pkgs.adwaita-icon-theme";
+          defaultText = literalExpression "pkgs.adwaita-icon-theme";
           description = ''
             The package path that contains the cursor theme given in the name option.
           '';
         };
 
-        name = lib.mkOption {
-          type = lib.types.str;
+        name = mkOption {
+          type = types.str;
           default = "Adwaita";
           description = ''
             Name of the cursor theme to use for the lightdm-slick-greeter.
           '';
         };
 
-        size = lib.mkOption {
-          type = lib.types.int;
+        size = mkOption {
+          type = types.int;
           default = 24;
           description = ''
             Size of the cursor theme to use for the lightdm-slick-greeter.
···
         };
       };
 
-      draw-user-backgrounds = lib.mkEnableOption "draw user backgrounds";
+      draw-user-backgrounds = mkEnableOption "draw user backgrounds";
 
-      extraConfig = lib.mkOption {
-        type = lib.types.lines;
+      extraConfig = mkOption {
+        type = types.lines;
         default = "";
         description = ''
           Extra configuration that should be put in the lightdm-slick-greeter.conf
···
     };
   };
 
-  config = lib.mkIf (ldmcfg.enable && cfg.enable) {
+  config = mkIf (ldmcfg.enable && cfg.enable) {
     services.xserver.displayManager.lightdm = {
       greeters.gtk.enable = false;
-      greeter = lib.mkDefault {
+      greeter = mkDefault {
         package = pkgs.lightdm-slick-greeter.xgreeters;
         name = "lightdm-slick-greeter";
       };

nixos/modules/services/x11/display-managers/lightdm-greeters/tiny.nix

···
   pkgs,
   ...
 }:
+
+with lib;
+
 let
 
   dmcfg = config.services.xserver.displayManager;
···
 
     services.xserver.displayManager.lightdm.greeters.tiny = {
 
-      enable = lib.mkOption {
-        type = lib.types.bool;
+      enable = mkOption {
+        type = types.bool;
         default = false;
         description = ''
           Whether to enable lightdm-tiny-greeter as the lightdm greeter.
···
       };
 
       label = {
-        user = lib.mkOption {
-          type = lib.types.str;
+        user = mkOption {
+          type = types.str;
           default = "Username";
           description = ''
             The string to represent the user_text label.
           '';
         };
 
-        pass = lib.mkOption {
-          type = lib.types.str;
+        pass = mkOption {
+          type = types.str;
           default = "Password";
           description = ''
             The string to represent the pass_text label.
···
         };
       };
 
-      extraConfig = lib.mkOption {
-        type = lib.types.lines;
+      extraConfig = mkOption {
+        type = types.lines;
         default = "";
         description = ''
           Section to describe style and ui.
···
 
   };
 
-  config = lib.mkIf (ldmcfg.enable && cfg.enable) {
+  config = mkIf (ldmcfg.enable && cfg.enable) {
 
     services.xserver.displayManager.lightdm.greeters.gtk.enable = false;
 
···
           static const char *pass_text = "${cfg.label.pass}";
           static const char *session = "${dmcfg.defaultSession}";
         '';
-        config = lib.optionalString (cfg.extraConfig != "") (configHeader + cfg.extraConfig);
+        config = optionalString (cfg.extraConfig != "") (configHeader + cfg.extraConfig);
         package = pkgs.lightdm-tiny-greeter.override { conf = config; };
       in
-      lib.mkDefault {
+      mkDefault {
         package = package.xgreeters;
         name = "lightdm-tiny-greeter";
       };

nixos/modules/services/x11/display-managers/lightdm.nix

···
   pkgs,
   ...
 }:
+
+with lib;
+
 let
 
   xcfg = config.services.xserver;
···
   # lightdm runs with clearenv(), but we need a few things in the environment for X to startup
   xserverWrapper = writeScript "xserver-wrapper" ''
     #! ${pkgs.bash}/bin/bash
-    ${lib.concatMapStrings (n: "export ${n}=\"${lib.getAttr n xEnv}\"\n") (lib.attrNames xEnv)}
+    ${concatMapStrings (n: "export ${n}=\"${getAttr n xEnv}\"\n") (attrNames xEnv)}
 
     display=$(echo "$@" | xargs -n 1 | grep -P ^:\\d\$ | head -n 1 | sed s/^://)
     if [ -z "$display" ]
···
   usersConf = writeText "users.conf" ''
     [UserList]
     minimum-uid=1000
-    hidden-users=${lib.concatStringsSep " " dmcfg.hiddenUsers}
+    hidden-users=${concatStringsSep " " dmcfg.hiddenUsers}
     hidden-shells=/run/current-system/sw/bin/nologin
   '';
 
   lightdmConf = writeText "lightdm.conf" ''
     [LightDM]
-    ${lib.optionalString cfg.greeter.enable ''
+    ${optionalString cfg.greeter.enable ''
       greeter-user = ${config.users.users.lightdm.name}
       greeters-directory = ${cfg.greeter.package}
     ''}
···
     [Seat:*]
     xserver-command = ${xserverWrapper}
     session-wrapper = ${dmcfg.sessionData.wrapper}
-    ${lib.optionalString cfg.greeter.enable ''
+    ${optionalString cfg.greeter.enable ''
       greeter-session = ${cfg.greeter.name}
     ''}
-    ${lib.optionalString dmcfg.autoLogin.enable ''
+    ${optionalString dmcfg.autoLogin.enable ''
       autologin-user = ${dmcfg.autoLogin.user}
       autologin-user-timeout = ${toString cfg.autoLogin.timeout}
       autologin-session = ${sessionData.autologinSession}
     ''}
-    ${lib.optionalString (xcfg.displayManager.setupCommands != "") ''
+    ${optionalString (xcfg.displayManager.setupCommands != "") ''
       display-setup-script=${pkgs.writeScript "lightdm-display-setup" ''
         #!${pkgs.bash}/bin/bash
         ${xcfg.displayManager.setupCommands}
···
     ./lightdm-greeters/tiny.nix
     ./lightdm-greeters/slick.nix
     ./lightdm-greeters/mobile.nix
-    (lib.mkRenamedOptionModule
+    (mkRenamedOptionModule
       [ "services" "xserver" "displayManager" "lightdm" "autoLogin" "enable" ]
       [
         "services"
···
         "enable"
       ]
     )
-    (lib.mkRenamedOptionModule
+    (mkRenamedOptionModule
       [ "services" "xserver" "displayManager" "lightdm" "autoLogin" "user" ]
       [
         "services"
···
 
     services.xserver.displayManager.lightdm = {
 
-      enable = lib.mkOption {
-        type = lib.types.bool;
+      enable = mkOption {
+        type = types.bool;
         default = false;
         description = ''
           Whether to enable lightdm as the display manager.
···
       };
 
       greeter = {
-        enable = lib.mkOption {
-          type = lib.types.bool;
+        enable = mkOption {
+          type = types.bool;
           default = true;
           description = ''
             If set to false, run lightdm in greeterless mode. This only works if autologin
             is enabled and autoLogin.timeout is zero.
           '';
         };
-        package = lib.mkOption {
-          type = lib.types.package;
+        package = mkOption {
+          type = types.package;
           description = ''
             The LightDM greeter to login via. The package should be a directory
             containing a .desktop file matching the name in the 'name' option.
           '';
 
         };
-        name = lib.mkOption {
-          type = lib.types.str;
+        name = mkOption {
+          type = types.str;
           description = ''
             The name of a .desktop file in the directory specified
             in the 'package' option.
···
         };
       };
 
-      extraConfig = lib.mkOption {
-        type = lib.types.lines;
+      extraConfig = mkOption {
+        type = types.lines;
         default = "";
         example = ''
           user-authority-in-system-dir = true
···
         description = "Extra lines to append to LightDM section.";
       };
 
-      background = lib.mkOption {
-        type = lib.types.either lib.types.path (lib.types.strMatching "^#[0-9]\{6\}$");
+      background = mkOption {
+        type = types.either types.path (types.strMatching "^#[0-9]\{6\}$");
         # Manual cannot depend on packages, we are actually setting the default in config below.
-        defaultText = lib.literalExpression "pkgs.nixos-artwork.wallpapers.simple-dark-gray-bottom.gnomeFilePath";
+        defaultText = literalExpression "pkgs.nixos-artwork.wallpapers.simple-dark-gray-bottom.gnomeFilePath";
         description = ''
           The background image or color to use.
         '';
       };
 
-      extraSeatDefaults = lib.mkOption {
-        type = lib.types.lines;
+      extraSeatDefaults = mkOption {
+        type = types.lines;
         default = "";
         example = ''
           greeter-show-manual-login=true
···
       };
 
       # Configuration for automatic login specific to LightDM
-      autoLogin.timeout = lib.mkOption {
-        type = lib.types.int;
+      autoLogin.timeout = mkOption {
+        type = types.int;
         default = 0;
         description = ''
           Show the greeter for this many seconds before automatic login occurs.
···
     };
   };
 
-  config = lib.mkIf cfg.enable {
+  config = mkIf cfg.enable {
 
     assertions = [
       {
···
 
     # Keep in sync with the defaultText value from the option definition.
     services.xserver.displayManager.lightdm.background =
-      lib.mkDefault pkgs.nixos-artwork.wallpapers.simple-dark-gray-bottom.gnomeFilePath;
+      mkDefault pkgs.nixos-artwork.wallpapers.simple-dark-gray-bottom.gnomeFilePath;
 
     # Set default session in session chooser to a specified values – basically ignore session history.
     # Auto-login is already covered by a config value.
     services.displayManager.preStart =
-      lib.optionalString (!dmcfg.autoLogin.enable && dmcfg.defaultSession != null)
+      optionalString (!dmcfg.autoLogin.enable && dmcfg.defaultSession != null)
         ''
           ${setSessionScript}/bin/set-session ${dmcfg.defaultSession}
         '';

nixos/modules/services/x11/display-managers/slim.nix

···
   pkgs,
   ...
 }:
+
+with lib;
+
 {
   # added 2019-11-11
   imports = [
-    (lib.mkRemovedOptionModule [ "services" "xserver" "displayManager" "slim" ] ''
+    (mkRemovedOptionModule [ "services" "xserver" "displayManager" "slim" ] ''
       The SLIM project is abandoned and their last release was in 2013.
       Because of this it poses a security risk to your system.
       Other issues include it not fully supporting systemd and logind sessions.

nixos/modules/services/x11/display-managers/startx.nix

···
   pkgs,
   ...
 }:
+
+with lib;
+
 let
 
   cfg = config.services.xserver.displayManager.startx;
···
 
   options = {
     services.xserver.displayManager.startx = {
-      enable = lib.mkOption {
-        type = lib.types.bool;
+      enable = mkOption {
+        type = types.bool;
         default = false;
         description = ''
           Whether to enable the dummy "startx" pseudo-display manager,
···
 
   ###### implementation
 
-  config = lib.mkIf cfg.enable {
+  config = mkIf cfg.enable {
     services.xserver = {
       exportConfiguration = true;
     };
···
     #
     # To send log to Xorg's default log location ($XDG_DATA_HOME/xorg/), we do
     # not specify a log file when running X
-    services.xserver.logFile = lib.mkDefault null;
+    services.xserver.logFile = mkDefault null;
 
     # Implement xserverArgs via xinit's system-wide xserverrc
     environment.etc."X11/xinit/xserverrc".source = pkgs.writeShellScript "xserverrc" ''

nixos/modules/services/x11/display-managers/xpra.nix

···
 { config, lib, pkgs, ... }:
+
+with lib;
+
 let
   cfg = config.services.xserver.displayManager.xpra;
   dmcfg = config.services.xserver.displayManager;
···
 
   options = {
     services.xserver.displayManager.xpra = {
-      enable = lib.mkOption {
-        type = lib.types.bool;
+      enable = mkOption {
+        type = types.bool;
         default = false;
         description = "Whether to enable xpra as display manager.";
       };
 
-      bindTcp = lib.mkOption {
+      bindTcp = mkOption {
         default = "127.0.0.1:10000";
         example = "0.0.0.0:10000";
-        type = lib.types.nullOr lib.types.str;
+        type = types.nullOr types.str;
         description = "Bind xpra to TCP";
       };
 
-      desktop = lib.mkOption {
-        type = lib.types.nullOr lib.types.str;
+      desktop = mkOption {
+        type = types.nullOr types.str;
         default = null;
         example = "gnome-shell";
         description = "Start a desktop environment instead of seamless mode";
       };
 
-      auth = lib.mkOption {
-        type = lib.types.str;
+      auth = mkOption {
+        type = types.str;
         default = "pam";
         example = "password:value=mysecret";
         description = "Authentication to use when connecting to xpra";
       };
 
-      pulseaudio = lib.mkEnableOption "pulseaudio audio streaming";
+      pulseaudio = mkEnableOption "pulseaudio audio streaming";
 
-      extraOptions = lib.mkOption {
+      extraOptions = mkOption {
         description = "Extra xpra options";
         default = [];
-        type = lib.types.listOf lib.types.str;
+        type = types.listOf types.str;
       };
     };
   };
 
   ###### implementation
 
-  config = lib.mkIf cfg.enable {
+  config = mkIf cfg.enable {
     services.xserver.videoDrivers = ["dummy"];
 
     services.xserver.monitorSection = ''
···
     '';
 
     services.displayManager.execCmd = ''
-      ${lib.optionalString (cfg.pulseaudio)
+      ${optionalString (cfg.pulseaudio)
         "export PULSE_COOKIE=/run/pulse/.config/pulse/cookie"}
       exec ${pkgs.xpra}/bin/xpra ${if cfg.desktop == null then "start" else "start-desktop --start=${cfg.desktop}"} \
         --daemon=off \
···
         --speaker=yes \
         --mdns=no \
         --pulseaudio=no \
-        ${lib.optionalString (cfg.pulseaudio) "--sound-source=pulse"} \
+        ${optionalString (cfg.pulseaudio) "--sound-source=pulse"} \
         --socket-dirs=/run/xpra \
-        --xvfb="xpra_Xdummy ${lib.concatStringsSep " " dmcfg.xserverArgs}" \
-        ${lib.optionalString (cfg.bindTcp != null) "--bind-tcp=${cfg.bindTcp}"} \
+        --xvfb="xpra_Xdummy ${concatStringsSep " " dmcfg.xserverArgs}" \
+        ${optionalString (cfg.bindTcp != null) "--bind-tcp=${cfg.bindTcp}"} \
         --auth=${cfg.auth} \
-        ${lib.concatStringsSep " " cfg.extraOptions}
+        ${concatStringsSep " " cfg.extraOptions}
     '';
 
     services.xserver.terminateOnReset = false;
 
     environment.systemPackages = [pkgs.xpra];
 
-    services.pulseaudio.enable = lib.mkDefault cfg.pulseaudio;
-    services.pulseaudio.systemWide = lib.mkDefault cfg.pulseaudio;
+    services.pulseaudio.enable = mkDefault cfg.pulseaudio;
+    services.pulseaudio.systemWide = mkDefault cfg.pulseaudio;
   };
 
 }

nixos/modules/services/x11/extra-layouts.nix

···
   pkgs,
   ...
 }:
+
+with lib;
+
 let
   layouts = config.services.xserver.xkb.extraLayouts;
 
   layoutOpts = {
     options = {
-      description = lib.mkOption {
-        type = lib.types.str;
+      description = mkOption {
+        type = types.str;
         description = "A short description of the layout.";
       };
 
-      languages = lib.mkOption {
-        type = lib.types.listOf lib.types.str;
+      languages = mkOption {
+        type = types.listOf types.str;
         description = ''
           A list of languages provided by the layout.
           (Use ISO 639-2 codes, for example: "eng" for english)
         '';
       };
 
-      compatFile = lib.mkOption {
-        type = lib.types.nullOr lib.types.path;
+      compatFile = mkOption {
+        type = types.nullOr types.path;
         default = null;
         description = ''
           The path to the xkb compat file.
···
         '';
       };
 
-      geometryFile = lib.mkOption {
-        type = lib.types.nullOr lib.types.path;
+      geometryFile = mkOption {
+        type = types.nullOr types.path;
         default = null;
         description = ''
           The path to the xkb geometry file.
···
         '';
       };
 
-      keycodesFile = lib.mkOption {
-        type = lib.types.nullOr lib.types.path;
+      keycodesFile = mkOption {
+        type = types.nullOr types.path;
         default = null;
         description = ''
           The path to the xkb keycodes file.
···
         '';
       };
 
-      symbolsFile = lib.mkOption {
-        type = lib.types.nullOr lib.types.path;
+      symbolsFile = mkOption {
+        type = types.nullOr types.path;
         default = null;
         description = ''
           The path to the xkb symbols file.
···
         '';
       };
 
-      typesFile = lib.mkOption {
-        type = lib.types.nullOr lib.types.path;
+      typesFile = mkOption {
+        type = types.nullOr types.path;
         default = null;
         description = ''
           The path to the xkb types file.
···
   ###### interface
 
   options.services.xserver.xkb = {
-    extraLayouts = lib.mkOption {
-      type = lib.types.attrsOf (lib.types.submodule layoutOpts);
+    extraLayouts = mkOption {
+      type = types.attrsOf (types.submodule layoutOpts);
       default = { };
-      example = lib.literalExpression ''
+      example = literalExpression ''
         {
           mine = {
             description = "My custom xkb layout.";
···
 
   ###### implementation
 
-  config = lib.mkIf (layouts != { }) {
+  config = mkIf (layouts != { }) {
 
     environment.sessionVariables = {
       # runtime override supported by multiple libraries e. g. libxkbcommon

nixos/modules/services/x11/fractalart.nix

···
   pkgs,
   ...
 }:
+with lib;
 let
   cfg = config.services.fractalart;
 in
 {
   options.services.fractalart = {
-    enable = lib.mkOption {
-      type = lib.types.bool;
+    enable = mkOption {
+      type = types.bool;
       default = false;
       example = true;
       description = "Enable FractalArt for generating colorful wallpapers on login";
     };
 
-    width = lib.mkOption {
-      type = lib.types.nullOr lib.types.int;
+    width = mkOption {
+      type = types.nullOr types.int;
       default = null;
       example = 1920;
       description = "Screen width";
     };
 
-    height = lib.mkOption {
-      type = lib.types.nullOr lib.types.int;
+    height = mkOption {
+      type = types.nullOr types.int;
       default = null;
       example = 1080;
       description = "Screen height";
     };
   };
 
-  config = lib.mkIf cfg.enable {
+  config = mkIf cfg.enable {
     environment.systemPackages = [ pkgs.haskellPackages.FractalArt ];
     services.xserver.displayManager.sessionCommands =
       "${pkgs.haskellPackages.FractalArt}/bin/FractalArt --no-bg -f .background-image"
-      + lib.optionalString (cfg.width != null) " -w ${toString cfg.width}"
-      + lib.optionalString (cfg.height != null) " -h ${toString cfg.height}";
+      + optionalString (cfg.width != null) " -w ${toString cfg.width}"
+      + optionalString (cfg.height != null) " -h ${toString cfg.height}";
   };
 }

nixos/modules/services/x11/hardware/cmt.nix

···
   pkgs,
   ...
 }:
+
+with lib;
+
 let
 
   cfg = config.services.xserver.cmt;
···
   options = {
 
     services.xserver.cmt = {
-      enable = lib.mkOption {
-        type = lib.types.bool;
+      enable = mkOption {
+        type = types.bool;
         default = false;
         description = "Enable chrome multitouch input (cmt). Touchpad drivers that are configured for chromebooks.";
       };
-      models = lib.mkOption {
-        type = lib.types.enum [
+      models = mkOption {
+        type = types.enum [
           "atlas"
           "banjo"
           "candy"
···
     }; # closes services
   }; # closes options
 
-  config = lib.mkIf cfg.enable {
+  config = mkIf cfg.enable {
 
     services.xserver.modules = [ pkgs.xf86_input_cmt ];
 

nixos/modules/services/x11/hardware/digimend.nix

···
   pkgs,
   ...
 }:
+
+with lib;
+
 let
 
   cfg = config.services.xserver.digimend;
···
 
     services.xserver.digimend = {
 
-      enable = lib.mkEnableOption "the digimend drivers for Huion/XP-Pen/etc. tablets";
+      enable = mkEnableOption "the digimend drivers for Huion/XP-Pen/etc. tablets";
 
     };
 
   };
 
-  config = lib.mkIf cfg.enable {
+  config = mkIf cfg.enable {
 
     # digimend drivers use xsetwacom and wacom X11 drivers
     services.xserver.wacom.enable = true;

nixos/modules/services/x11/hardware/synaptics.nix

···
   pkgs,
   ...
 }:
+
+with lib;
+
 let
   cfg = config.services.xserver.synaptics;
   opt = options.services.xserver.synaptics;
···
 
     services.xserver.synaptics = {
 
-      enable = lib.mkOption {
-        type = lib.types.bool;
+      enable = mkOption {
+        type = types.bool;
         default = false;
         description = "Whether to enable touchpad support. Deprecated: Consider services.libinput.enable.";
       };
 
-      dev = lib.mkOption {
-        type = lib.types.nullOr lib.types.str;
+      dev = mkOption {
+        type = types.nullOr types.str;
         default = null;
         example = "/dev/input/event0";
         description = ''
···
         '';
       };
 
-      accelFactor = lib.mkOption {
-        type = lib.types.nullOr lib.types.str;
+      accelFactor = mkOption {
+        type = types.nullOr types.str;
         default = "0.001";
         description = "Cursor acceleration (how fast speed increases from minSpeed to maxSpeed).";
       };
 
-      minSpeed = lib.mkOption {
-        type = lib.types.nullOr lib.types.str;
+      minSpeed = mkOption {
+        type = types.nullOr types.str;
         default = "0.6";
         description = "Cursor speed factor for precision finger motion.";
       };
 
-      maxSpeed = lib.mkOption {
-        type = lib.types.nullOr lib.types.str;
+      maxSpeed = mkOption {
+        type = types.nullOr types.str;
         default = "1.0";
         description = "Cursor speed factor for highest-speed finger motion.";
       };
 
-      scrollDelta = lib.mkOption {
-        type = lib.types.nullOr lib.types.int;
+      scrollDelta = mkOption {
+        type = types.nullOr types.int;
         default = null;
         example = 75;
         description = "Move distance of the finger for a scroll event.";
       };
 
-      twoFingerScroll = lib.mkOption {
-        type = lib.types.bool;
+      twoFingerScroll = mkOption {
+        type = types.bool;
         default = false;
         description = "Whether to enable two-finger drag-scrolling. Overridden by horizTwoFingerScroll and vertTwoFingerScroll.";
       };
 
-      horizTwoFingerScroll = lib.mkOption {
-        type = lib.types.bool;
+      horizTwoFingerScroll = mkOption {
+        type = types.bool;
         default = cfg.twoFingerScroll;
-        defaultText = lib.literalExpression "config.${opt.twoFingerScroll}";
+        defaultText = literalExpression "config.${opt.twoFingerScroll}";
         description = "Whether to enable horizontal two-finger drag-scrolling.";
       };
 
-      vertTwoFingerScroll = lib.mkOption {
-        type = lib.types.bool;
+      vertTwoFingerScroll = mkOption {
+        type = types.bool;
         default = cfg.twoFingerScroll;
-        defaultText = lib.literalExpression "config.${opt.twoFingerScroll}";
+        defaultText = literalExpression "config.${opt.twoFingerScroll}";
         description = "Whether to enable vertical two-finger drag-scrolling.";
       };
 
-      horizEdgeScroll = lib.mkOption {
-        type = lib.types.bool;
+      horizEdgeScroll = mkOption {
+        type = types.bool;
         default = !cfg.horizTwoFingerScroll;
-        defaultText = lib.literalExpression "! config.${opt.horizTwoFingerScroll}";
+        defaultText = literalExpression "! config.${opt.horizTwoFingerScroll}";
         description = "Whether to enable horizontal edge drag-scrolling.";
       };
 
-      vertEdgeScroll = lib.mkOption {
-        type = lib.types.bool;
+      vertEdgeScroll = mkOption {
+        type = types.bool;
         default = !cfg.vertTwoFingerScroll;
-        defaultText = lib.literalExpression "! config.${opt.vertTwoFingerScroll}";
+        defaultText = literalExpression "! config.${opt.vertTwoFingerScroll}";
         description = "Whether to enable vertical edge drag-scrolling.";
       };
 
-      tapButtons = lib.mkOption {
-        type = lib.types.bool;
+      tapButtons = mkOption {
+        type = types.bool;
         default = true;
         description = "Whether to enable tap buttons.";
       };
 
-      buttonsMap = lib.mkOption {
-        type = lib.types.listOf lib.types.int;
+      buttonsMap = mkOption {
+        type = types.listOf types.int;
         default = [
           1
           2
···
         apply = map toString;
       };
 
-      fingersMap = lib.mkOption {
-        type = lib.types.listOf lib.types.int;
+      fingersMap = mkOption {
+        type = types.listOf types.int;
         default = [
           1
           2
···
         apply = map toString;
       };
 
-      palmDetect = lib.mkOption {
-        type = lib.types.bool;
+      palmDetect = mkOption {
+        type = types.bool;
         default = false;
         description = "Whether to enable palm detection (hardware support required)";
       };
 
-      palmMinWidth = lib.mkOption {
-        type = lib.types.nullOr lib.types.int;
+      palmMinWidth = mkOption {
+        type = types.nullOr types.int;
         default = null;
         example = 5;
         description = "Minimum finger width at which touch is considered a palm";
       };
 
-      palmMinZ = lib.mkOption {
-        type = lib.types.nullOr lib.types.int;
+      palmMinZ = mkOption {
+        type = types.nullOr types.int;
         default = null;
         example = 20;
         description = "Minimum finger pressure at which touch is considered a palm";
       };
 
-      horizontalScroll = lib.mkOption {
-        type = lib.types.bool;
+      horizontalScroll = mkOption {
+        type = types.bool;
         default = true;
         description = "Whether to enable horizontal scrolling (on touchpad)";
       };
 
-      additionalOptions = lib.mkOption {
-        type = lib.types.str;
+      additionalOptions = mkOption {
+        type = types.str;
         default = "";
         example = ''
           Option "RTCornerButton" "2"
···
 
   };
 
-  config = lib.mkIf cfg.enable {
+  config = mkIf cfg.enable {
 
     services.xserver.modules = [ pkg.out ];
 
···
       Section "InputClass"
         Identifier "synaptics touchpad catchall"
         MatchIsTouchpad "on"
-        ${lib.optionalString (cfg.dev != null) ''MatchDevicePath "${cfg.dev}"''}
+        ${optionalString (cfg.dev != null) ''MatchDevicePath "${cfg.dev}"''}
         Driver "synaptics"
-        ${lib.optionalString (cfg.minSpeed != null) ''Option "MinSpeed" "${cfg.minSpeed}"''}
-        ${lib.optionalString (cfg.maxSpeed != null) ''Option "MaxSpeed" "${cfg.maxSpeed}"''}
-        ${lib.optionalString (cfg.accelFactor != null) ''Option "AccelFactor" "${cfg.accelFactor}"''}
-        ${lib.optionalString cfg.tapButtons tapConfig}
+        ${optionalString (cfg.minSpeed != null) ''Option "MinSpeed" "${cfg.minSpeed}"''}
+        ${optionalString (cfg.maxSpeed != null) ''Option "MaxSpeed" "${cfg.maxSpeed}"''}
+        ${optionalString (cfg.accelFactor != null) ''Option "AccelFactor" "${cfg.accelFactor}"''}
+        ${optionalString cfg.tapButtons tapConfig}
         Option "ClickFinger1" "${builtins.elemAt cfg.buttonsMap 0}"
         Option "ClickFinger2" "${builtins.elemAt cfg.buttonsMap 1}"
         Option "ClickFinger3" "${builtins.elemAt cfg.buttonsMap 2}"
···
         Option "HorizTwoFingerScroll" "${if cfg.horizTwoFingerScroll then "1" else "0"}"
         Option "VertEdgeScroll" "${if cfg.vertEdgeScroll then "1" else "0"}"
         Option "HorizEdgeScroll" "${if cfg.horizEdgeScroll then "1" else "0"}"
-        ${lib.optionalString cfg.palmDetect ''Option "PalmDetect" "1"''}
-        ${lib.optionalString (
+        ${optionalString cfg.palmDetect ''Option "PalmDetect" "1"''}
+        ${optionalString (
           cfg.palmMinWidth != null
         ) ''Option "PalmMinWidth" "${toString cfg.palmMinWidth}"''}
-        ${lib.optionalString (cfg.palmMinZ != null) ''Option "PalmMinZ" "${toString cfg.palmMinZ}"''}
-        ${lib.optionalString (
+        ${optionalString (cfg.palmMinZ != null) ''Option "PalmMinZ" "${toString cfg.palmMinZ}"''}
+        ${optionalString (
           cfg.scrollDelta != null
         ) ''Option "VertScrollDelta" "${toString cfg.scrollDelta}"''}
         ${
           if !cfg.horizontalScroll then
             ''Option "HorizScrollDelta" "0"''
           else
-            (lib.optionalString (
+            (optionalString (
               cfg.scrollDelta != null
             ) ''Option "HorizScrollDelta" "${toString cfg.scrollDelta}"'')
         }

nixos/modules/services/x11/hardware/wacom.nix

···
   pkgs,
   ...
 }:
+
+with lib;
+
 let
 
   cfg = config.services.xserver.wacom;
···
 
     services.xserver.wacom = {
 
-      enable = lib.mkOption {
-        type = lib.types.bool;
+      enable = mkOption {
+        type = types.bool;
         default = false;
         description = ''
           Whether to enable the Wacom touchscreen/digitizer/tablet.
···
 
   };
 
-  config = lib.mkIf cfg.enable {
+  config = mkIf cfg.enable {
 
     environment.systemPackages = [ pkgs.xf86_input_wacom ]; # provides xsetwacom
 

nixos/modules/services/x11/imwheel.nix

···
   pkgs,
   ...
 }:
+with lib;
 let
   cfg = config.services.xserver.imwheel;
 in
 {
   options = {
     services.xserver.imwheel = {
-      enable = lib.mkEnableOption "IMWheel service";
+      enable = mkEnableOption "IMWheel service";
 
-      extraOptions = lib.mkOption {
-        type = lib.types.listOf lib.types.str;
+      extraOptions = mkOption {
+        type = types.listOf types.str;
         default = [ "--buttons=45" ];
         example = [ "--debug" ];
         description = ''
···
         '';
       };
 
-      rules = lib.mkOption {
-        type = lib.types.attrsOf lib.types.str;
+      rules = mkOption {
+        type = types.attrsOf types.str;
         default = { };
-        example = lib.literalExpression ''
+        example = literalExpression ''
           {
             ".*" = '''
               None,      Up,   Button4, 8
···
     };
   };
 
-  config = lib.mkIf cfg.enable {
+  config = mkIf cfg.enable {
     environment.systemPackages = [ pkgs.imwheel ];
 
     environment.etc."X11/imwheel/imwheelrc".source = pkgs.writeText "imwheelrc" (
-      lib.concatStringsSep "\n\n" (lib.mapAttrsToList (rule: conf: "\"${rule}\"\n${conf}") cfg.rules)
+      concatStringsSep "\n\n" (mapAttrsToList (rule: conf: "\"${rule}\"\n${conf}") cfg.rules)
     );
 
     systemd.user.services.imwheel = {
···
       serviceConfig = {
         ExecStart =
           "${pkgs.imwheel}/bin/imwheel "
-          + lib.escapeShellArgs (
+          + escapeShellArgs (
             [
               "--detach"
               "--kill"

nixos/modules/services/x11/picom.nix

···
   pkgs,
   ...
 }:
+
+with lib;
+
 let
 
   cfg = config.services.picom;
···
 
   pairOf =
     x:
-    with lib.types;
+    with types;
     addCheck (listOf x) (y: length y == 2) // { description = "pair of ${x.description}"; };
 
-  mkDefaultAttrs = lib.mapAttrs (n: v: lib.mkDefault v);
+  mkDefaultAttrs = mapAttrs (n: v: mkDefault v);
 
   # Basically a tinkered lib.generators.mkKeyValueDefault
   # It either serializes a top-level definition "key: { values };"
   # or an expression "key = { values };"
   mkAttrsString =
     top:
-    lib.mapAttrsToList (
+    mapAttrsToList (
       k: v:
       let
-        sep = if (top && lib.isAttrs v) then ":" else "=";
+        sep = if (top && isAttrs v) then ":" else "=";
       in
-      "${lib.escape [ sep ] k}${sep}${mkValueString v};"
+      "${escape [ sep ] k}${sep}${mkValueString v};"
     );
 
   # This serializes a Nix expression to the libconfig format.
   mkValueString =
     v:
-    if lib.types.bool.check v then
-      lib.boolToString v
-    else if lib.types.int.check v then
+    if types.bool.check v then
+      boolToString v
+    else if types.int.check v then
       toString v
-    else if lib.types.float.check v then
+    else if types.float.check v then
       toString v
-    else if lib.types.str.check v then
-      "\"${lib.escape [ "\"" ] v}\""
+    else if types.str.check v then
+      "\"${escape [ "\"" ] v}\""
     else if builtins.isList v then
-      "[ ${lib.concatMapStringsSep " , " mkValueString v} ]"
-    else if lib.types.attrs.check v then
-      "{ ${lib.concatStringsSep " " (mkAttrsString false v)} }"
+      "[ ${concatMapStringsSep " , " mkValueString v} ]"
+    else if types.attrs.check v then
+      "{ ${concatStringsSep " " (mkAttrsString false v)} }"
     else
       throw ''
         invalid expression used in option services.picom.settings:
         ${v}
       '';
 
-  toConf = attrs: lib.concatStringsSep "\n" (mkAttrsString true cfg.settings);
+  toConf = attrs: concatStringsSep "\n" (mkAttrsString true cfg.settings);
 
   configFile = pkgs.writeText "picom.conf" (toConf cfg.settings);
 
···
 {
 
   imports = [
-    (lib.mkAliasOptionModuleMD [ "services" "compton" ] [ "services" "picom" ])
-    (lib.mkRemovedOptionModule [ "services" "picom" "refreshRate" ] ''
+    (mkAliasOptionModuleMD [ "services" "compton" ] [ "services" "picom" ])
+    (mkRemovedOptionModule [ "services" "picom" "refreshRate" ] ''
       This option corresponds to `refresh-rate`, which has been unused
       since picom v6 and was subsequently removed by upstream.
       See https://github.com/yshui/picom/commit/bcbc410
     '')
-    (lib.mkRemovedOptionModule [ "services" "picom" "experimentalBackends" ] ''
+    (mkRemovedOptionModule [ "services" "picom" "experimentalBackends" ] ''
       This option was removed by upstream since picom v10.
     '')
   ];
 
   options.services.picom = {
-    enable = lib.mkOption {
-      type = lib.types.bool;
+    enable = mkOption {
+      type = types.bool;
       default = false;
       description = ''
         Whether or not to enable Picom as the X.org composite manager.
       '';
     };
 
-    package = lib.mkPackageOption pkgs "picom" { };
+    package = mkPackageOption pkgs "picom" { };
 
-    fade = lib.mkOption {
-      type = lib.types.bool;
+    fade = mkOption {
+      type = types.bool;
       default = false;
       description = ''
         Fade windows in and out.
       '';
     };
 
-    fadeDelta = lib.mkOption {
-      type = lib.types.ints.positive;
+    fadeDelta = mkOption {
+      type = types.ints.positive;
       default = 10;
       example = 5;
       description = ''
···
       '';
     };
 
-    fadeSteps = lib.mkOption {
-      type = pairOf (lib.types.numbers.between 0.01 1);
+    fadeSteps = mkOption {
+      type = pairOf (types.numbers.between 0.01 1);
       default = [
         0.028
         0.03
···
       '';
     };
 
-    fadeExclude = lib.mkOption {
-      type = lib.types.listOf lib.types.str;
+    fadeExclude = mkOption {
+      type = types.listOf types.str;
       default = [ ];
       example = [
         "window_type *= 'menu'"
···
       '';
     };
 
-    shadow = lib.mkOption {
-      type = lib.types.bool;
+    shadow = mkOption {
+      type = types.bool;
       default = false;
       description = ''
         Draw window shadows.
       '';
     };
 
-    shadowOffsets = lib.mkOption {
-      type = pairOf lib.types.int;
+    shadowOffsets = mkOption {
+      type = pairOf types.int;
       default = [
         (-15)
         (-15)
···
       '';
     };
 
-    shadowOpacity = lib.mkOption {
-      type = lib.types.numbers.between 0 1;
+    shadowOpacity = mkOption {
+      type = types.numbers.between 0 1;
       default = 0.75;
       example = 0.8;
       description = ''
···
       '';
     };
 
-    shadowExclude = lib.mkOption {
-      type = lib.types.listOf lib.types.str;
+    shadowExclude = mkOption {
+      type = types.listOf types.str;
       default = [ ];
       example = [
         "window_type *= 'menu'"
···
       '';
     };
 
-    activeOpacity = lib.mkOption {
-      type = lib.types.numbers.between 0 1;
+    activeOpacity = mkOption {
+      type = types.numbers.between 0 1;
       default = 1.0;
       example = 0.8;
       description = ''
···
       '';
     };
 
-    inactiveOpacity = lib.mkOption {
-      type = lib.types.numbers.between 0.1 1;
+    inactiveOpacity = mkOption {
+      type = types.numbers.between 0.1 1;
       default = 1.0;
       example = 0.8;
       description = ''
···
       '';
     };
 
-    menuOpacity = lib.mkOption {
-      type = lib.types.numbers.between 0 1;
+    menuOpacity = mkOption {
+      type = types.numbers.between 0 1;
       default = 1.0;
       example = 0.8;
       description = ''
···
       '';
     };
 
-    wintypes = lib.mkOption {
-      type = lib.types.attrs;
+    wintypes = mkOption {
+      type = types.attrs;
       default = {
         popup_menu = {
           opacity = cfg.menuOpacity;
···
           opacity = cfg.menuOpacity;
         };
       };
-      defaultText = lib.literalExpression ''
+      defaultText = literalExpression ''
         {
           popup_menu = { opacity = config.${opt.menuOpacity}; };
           dropdown_menu = { opacity = config.${opt.menuOpacity}; };
···
       '';
     };
 
-    opacityRules = lib.mkOption {
-      type = lib.types.listOf lib.types.str;
+    opacityRules = mkOption {
+      type = types.listOf types.str;
       default = [ ];
       example = [
         "95:class_g = 'URxvt' && !_NET_WM_STATE@:32a"
···
       '';
     };
 
-    backend = lib.mkOption {
-      type = lib.types.enum [
+    backend = mkOption {
+      type = types.enum [
         "egl"
         "glx"
         "xrender"
···
       '';
     };
 
-    vSync = lib.mkOption {
+    vSync = mkOption {
       type =
-        with lib.types;
+        with types;
         either bool (enum [
           "none"
           "drm"
···
           res = x != "none";
           msg =
             "The type of services.picom.vSync has changed to bool:"
-            + " interpreting ${x} as ${lib.boolToString res}";
+            + " interpreting ${x} as ${boolToString res}";
         in
-        if lib.isBool x then x else lib.warn msg res;
+        if isBool x then x else warn msg res;
 
       description = ''
         Enable vertical synchronization. Chooses the best method
···
     };
 
     settings =
-      with lib.types;
+      with types;
       let
         scalar =
           oneOf [
···
         };
 
       in
-      lib.mkOption {
+      mkOption {
         type = topLevel;
         default = { };
-        example = lib.literalExpression ''
+        example = literalExpression ''
           blur =
             { method = "gaussian";
               size = 10;
···
       };
   };
 
-  config = lib.mkIf cfg.enable {
+  config = mkIf cfg.enable {
     services.picom.settings = mkDefaultAttrs {
       # fading
       fading = cfg.fade;
       fade-delta = cfg.fadeDelta;
-      fade-in-step = lib.elemAt cfg.fadeSteps 0;
-      fade-out-step = lib.elemAt cfg.fadeSteps 1;
+      fade-in-step = elemAt cfg.fadeSteps 0;
+      fade-out-step = elemAt cfg.fadeSteps 1;
       fade-exclude = cfg.fadeExclude;
 
       # shadows
       shadow = cfg.shadow;
-      shadow-offset-x = lib.elemAt cfg.shadowOffsets 0;
-      shadow-offset-y = lib.elemAt cfg.shadowOffsets 1;
+      shadow-offset-x = elemAt cfg.shadowOffsets 0;
+      shadow-offset-y = elemAt cfg.shadowOffsets 1;
       shadow-opacity = cfg.shadowOpacity;
       shadow-exclude = cfg.shadowExclude;
 
···
       partOf = [ "graphical-session.target" ];
 
       # Temporarily fixes corrupt colours with Mesa 18
-      environment = lib.mkIf (cfg.backend == "glx") {
+      environment = mkIf (cfg.backend == "glx") {
         allow_rgb10_configs = "false";
       };
 
       serviceConfig = {
-        ExecStart = "${lib.getExe cfg.package} --config ${configFile}";
+        ExecStart = "${getExe cfg.package} --config ${configFile}";
         RestartSec = 3;
         Restart = "always";
       };

nixos/modules/services/x11/redshift.nix

···
   pkgs,
   ...
 }:
+
+with lib;
+
 let
 
   cfg = config.services.redshift;
···
 {
 
   imports = [
-    (lib.mkChangedOptionModule [ "services" "redshift" "latitude" ] [ "location" "latitude" ] (
+    (mkChangedOptionModule [ "services" "redshift" "latitude" ] [ "location" "latitude" ] (
       config:
       let
-        value = lib.getAttrFromPath [ "services" "redshift" "latitude" ] config;
+        value = getAttrFromPath [ "services" "redshift" "latitude" ] config;
       in
       if value == null then
         throw "services.redshift.latitude is set to null, you can remove this"
       else
         builtins.fromJSON value
     ))
-    (lib.mkChangedOptionModule [ "services" "redshift" "longitude" ] [ "location" "longitude" ] (
+    (mkChangedOptionModule [ "services" "redshift" "longitude" ] [ "location" "longitude" ] (
       config:
       let
-        value = lib.getAttrFromPath [ "services" "redshift" "longitude" ] config;
+        value = getAttrFromPath [ "services" "redshift" "longitude" ] config;
       in
       if value == null then
         throw "services.redshift.longitude is set to null, you can remove this"
       else
         builtins.fromJSON value
     ))
-    (lib.mkRenamedOptionModule [ "services" "redshift" "provider" ] [ "location" "provider" ])
+    (mkRenamedOptionModule [ "services" "redshift" "provider" ] [ "location" "provider" ])
   ];
 
   options.services.redshift = {
-    enable = lib.mkOption {
-      type = lib.types.bool;
+    enable = mkOption {
+      type = types.bool;
       default = false;
       description = ''
         Enable Redshift to change your screen's colour temperature depending on
···
     };
 
     temperature = {
-      day = lib.mkOption {
-        type = lib.types.int;
+      day = mkOption {
+        type = types.int;
         default = 5500;
         description = ''
           Colour temperature to use during the day, between
           `1000` and `25000` K.
         '';
       };
-      night = lib.mkOption {
-        type = lib.types.int;
+      night = mkOption {
+        type = types.int;
         default = 3700;
         description = ''
           Colour temperature to use at night, between
···
     };
 
     brightness = {
-      day = lib.mkOption {
-        type = lib.types.str;
+      day = mkOption {
+        type = types.str;
         default = "1";
         description = ''
           Screen brightness to apply during the day,
           between `0.1` and `1.0`.
         '';
       };
-      night = lib.mkOption {
-        type = lib.types.str;
+      night = mkOption {
+        type = types.str;
         default = "1";
         description = ''
           Screen brightness to apply during the night,
···
       };
     };
 
-    package = lib.mkPackageOption pkgs "redshift" { };
+    package = mkPackageOption pkgs "redshift" { };
 
-    executable = lib.mkOption {
-      type = lib.types.str;
+    executable = mkOption {
+      type = types.str;
       default = "/bin/redshift";
       example = "/bin/redshift-gtk";
       description = ''
···
       '';
     };
 
-    extraOptions = lib.mkOption {
-      type = lib.types.listOf lib.types.str;
+    extraOptions = mkOption {
+      type = types.listOf types.str;
       default = [ ];
       example = [
         "-v"
···
     };
   };
 
-  config = lib.mkIf cfg.enable {
+  config = mkIf cfg.enable {
     # needed so that .desktop files are installed, which geoclue cares about
     environment.systemPackages = [ cfg.package ];
 

nixos/modules/services/x11/touchegg.nix

···
   pkgs,
   ...
 }:
+
+with lib;
+
 let
   cfg = config.services.touchegg;
 
 in
 {
   meta = {
-    maintainers = lib.teams.pantheon.members;
+    maintainers = teams.pantheon.members;
   };
 
   ###### interface
   options.services.touchegg = {
-    enable = lib.mkEnableOption "touchegg, a multi-touch gesture recognizer";
+    enable = mkEnableOption "touchegg, a multi-touch gesture recognizer";
 
-    package = lib.mkPackageOption pkgs "touchegg" { };
+    package = mkPackageOption pkgs "touchegg" { };
   };
 
   ###### implementation
-  config = lib.mkIf cfg.enable {
+  config = mkIf cfg.enable {
     systemd.services.touchegg = {
       description = "Touchegg Daemon";
       serviceConfig = {

nixos/modules/services/x11/unclutter-xfixes.nix

···
   pkgs,
   ...
 }:
+
+with lib;
+
 let
   cfg = config.services.unclutter-xfixes;
 
···
 {
   options.services.unclutter-xfixes = {
 
-    enable = lib.mkOption {
+    enable = mkOption {
       description = "Enable unclutter-xfixes to hide your mouse cursor when inactive.";
-      type = lib.types.bool;
+      type = types.bool;
       default = false;
     };
 
-    package = lib.mkPackageOption pkgs "unclutter-xfixes" { };
+    package = mkPackageOption pkgs "unclutter-xfixes" { };
 
-    timeout = lib.mkOption {
+    timeout = mkOption {
       description = "Number of seconds before the cursor is marked inactive.";
-      type = lib.types.int;
+      type = types.int;
       default = 1;
     };
 
-    threshold = lib.mkOption {
+    threshold = mkOption {
       description = "Minimum number of pixels considered cursor movement.";
-      type = lib.types.int;
+      type = types.int;
       default = 1;
     };
 
-    extraOptions = lib.mkOption {
+    extraOptions = mkOption {
       description = "More arguments to pass to the unclutter-xfixes command.";
-      type = lib.types.listOf lib.types.str;
+      type = types.listOf types.str;
       default = [ ];
       example = [
         "exclude-root"
···
     };
   };
 
-  config = lib.mkIf cfg.enable {
+  config = mkIf cfg.enable {
     systemd.user.services.unclutter-xfixes = {
       description = "unclutter-xfixes";
       wantedBy = [ "graphical-session.target" ];
···
         ${cfg.package}/bin/unclutter \
           --timeout ${toString cfg.timeout} \
           --jitter ${toString (cfg.threshold - 1)} \
-          ${lib.concatMapStrings (x: " --" + x) cfg.extraOptions} \
+          ${concatMapStrings (x: " --" + x) cfg.extraOptions} \
       '';
       serviceConfig.RestartSec = 3;
       serviceConfig.Restart = "always";

nixos/modules/services/x11/unclutter.nix

···
   pkgs,
   ...
 }:
+
+with lib;
+
 let
   cfg = config.services.unclutter;
 
···
 {
   options.services.unclutter = {
 
-    enable = lib.mkOption {
+    enable = mkOption {
       description = "Enable unclutter to hide your mouse cursor when inactive";
-      type = lib.types.bool;
+      type = types.bool;
       default = false;
     };
 
-    package = lib.mkPackageOption pkgs "unclutter" { };
+    package = mkPackageOption pkgs "unclutter" { };
 
-    keystroke = lib.mkOption {
+    keystroke = mkOption {
       description = "Wait for a keystroke before hiding the cursor";
-      type = lib.types.bool;
+      type = types.bool;
       default = false;
     };
 
-    timeout = lib.mkOption {
+    timeout = mkOption {
       description = "Number of seconds before the cursor is marked inactive";
-      type = lib.types.int;
+      type = types.int;
       default = 1;
     };
 
-    threshold = lib.mkOption {
+    threshold = mkOption {
       description = "Minimum number of pixels considered cursor movement";
-      type = lib.types.int;
+      type = types.int;
       default = 1;
     };
 
-    excluded = lib.mkOption {
+    excluded = mkOption {
       description = "Names of windows where unclutter should not apply";
-      type = lib.types.listOf lib.types.str;
+      type = types.listOf types.str;
       default = [ ];
       example = [ "" ];
     };
 
-    extraOptions = lib.mkOption {
+    extraOptions = mkOption {
       description = "More arguments to pass to the unclutter command";
-      type = lib.types.listOf lib.types.str;
+      type = types.listOf types.str;
       default = [ ];
       example = [
         "noevent"
···
     };
   };
 
-  config = lib.mkIf cfg.enable {
+  config = mkIf cfg.enable {
     systemd.user.services.unclutter = {
       description = "unclutter";
       wantedBy = [ "graphical-session.target" ];
···
         ${cfg.package}/bin/unclutter \
           -idle ${toString cfg.timeout} \
           -jitter ${toString (cfg.threshold - 1)} \
-          ${lib.optionalString cfg.keystroke "-keystroke"} \
-          ${lib.concatMapStrings (x: " -" + x) cfg.extraOptions} \
-          -not ${lib.concatStringsSep " " cfg.excluded} \
+          ${optionalString cfg.keystroke "-keystroke"} \
+          ${concatMapStrings (x: " -" + x) cfg.extraOptions} \
+          -not ${concatStringsSep " " cfg.excluded} \
       '';
       serviceConfig.PassEnvironment = "DISPLAY";
       serviceConfig.RestartSec = 3;
···
   };
 
   imports = [
-    (lib.mkRenamedOptionModule
+    (mkRenamedOptionModule
       [ "services" "unclutter" "threeshold" ]
       [ "services" "unclutter" "threshold" ]
     )

nixos/modules/services/x11/urxvtd.nix

···
   pkgs,
   ...
 }:
+
 # maintainer: siddharthist
+
+with lib;
+
 let
   cfg = config.services.urxvtd;
 in
 {
   options.services.urxvtd = {
-    enable = lib.mkOption {
-      type = lib.types.bool;
+    enable = mkOption {
+      type = types.bool;
       default = false;
       description = ''
         Enable urxvtd, the urxvt terminal daemon. To use urxvtd, run
···
       '';
     };
 
-    package = lib.mkPackageOption pkgs "rxvt-unicode" { };
+    package = mkPackageOption pkgs "rxvt-unicode" { };
   };
 
-  config = lib.mkIf cfg.enable {
+  config = mkIf cfg.enable {
     systemd.user.services.urxvtd = {
       description = "urxvt terminal daemon";
       wantedBy = [ "graphical-session.target" ];

nixos/modules/services/x11/window-managers/2bwm.nix

···
   pkgs,
   ...
 }:
+
+with lib;
+
 let
 
   cfg = config.services.xserver.windowManager."2bwm";
···
   ###### interface
 
   options = {
-    services.xserver.windowManager."2bwm".enable = lib.mkEnableOption "2bwm";
+    services.xserver.windowManager."2bwm".enable = mkEnableOption "2bwm";
   };
 
   ###### implementation
 
-  config = lib.mkIf cfg.enable {
+  config = mkIf cfg.enable {
 
-    services.xserver.windowManager.session = lib.singleton {
+    services.xserver.windowManager.session = singleton {
       name = "2bwm";
       start = ''
         ${pkgs._2bwm}/bin/2bwm &

nixos/modules/services/x11/window-managers/afterstep.nix

···
   pkgs,
   ...
 }:
+
+with lib;
+
 let
   cfg = config.services.xserver.windowManager.afterstep;
 in
 {
   ###### interface
   options = {
-    services.xserver.windowManager.afterstep.enable = lib.mkEnableOption "afterstep";
+    services.xserver.windowManager.afterstep.enable = mkEnableOption "afterstep";
   };
 
   ###### implementation
-  config = lib.mkIf cfg.enable {
-    services.xserver.windowManager.session = lib.singleton {
+  config = mkIf cfg.enable {
+    services.xserver.windowManager.session = singleton {
       name = "afterstep";
       start = ''
         ${pkgs.afterstep}/bin/afterstep &

nixos/modules/services/x11/window-managers/awesome.nix

···
   pkgs,
   ...
 }:
+
+with lib;
+
 let
 
   cfg = config.services.xserver.windowManager.awesome;
···
 
     services.xserver.windowManager.awesome = {
 
-      enable = lib.mkEnableOption "Awesome window manager";
+      enable = mkEnableOption "Awesome window manager";
 
-      luaModules = lib.mkOption {
+      luaModules = mkOption {
         default = [ ];
-        type = lib.types.listOf lib.types.package;
+        type = types.listOf types.package;
         description = "List of lua packages available for being used in the Awesome configuration.";
-        example = lib.literalExpression "[ pkgs.luaPackages.vicious ]";
+        example = literalExpression "[ pkgs.luaPackages.vicious ]";
       };
 
-      package = lib.mkPackageOption pkgs "awesome" { };
+      package = mkPackageOption pkgs "awesome" { };
 
-      noArgb = lib.mkOption {
+      noArgb = mkOption {
         default = false;
-        type = lib.types.bool;
+        type = types.bool;
         description = "Disable client transparency support, which can be greatly detrimental to performance in some setups";
       };
     };
···
 
   ###### implementation
 
-  config = lib.mkIf cfg.enable {
+  config = mkIf cfg.enable {
 
-    services.xserver.windowManager.session = lib.singleton {
+    services.xserver.windowManager.session = singleton {
       name = "awesome";
       start = ''
         ${awesome}/bin/awesome ${lib.optionalString cfg.noArgb "--no-argb"} ${makeSearchPath cfg.luaModules} &

nixos/modules/services/x11/window-managers/berry.nix

···
   pkgs,
   ...
 }:
+
+with lib;
+
 let
   cfg = config.services.xserver.windowManager.berry;
 in
 {
   ###### interface
   options = {
-    services.xserver.windowManager.berry.enable = lib.mkEnableOption "berry";
+    services.xserver.windowManager.berry.enable = mkEnableOption "berry";
   };
 
   ###### implementation
-  config = lib.mkIf cfg.enable {
-    services.xserver.windowManager.session = lib.singleton {
+  config = mkIf cfg.enable {
+    services.xserver.windowManager.session = singleton {
       name = "berry";
       start = ''
         ${pkgs.berry}/bin/berry &

nixos/modules/services/x11/window-managers/bspwm.nix

···
   pkgs,
   ...
 }:
+
+with lib;
+
 let
   cfg = config.services.xserver.windowManager.bspwm;
 in
···
 {
   options = {
     services.xserver.windowManager.bspwm = {
-      enable = lib.mkEnableOption "bspwm";
+      enable = mkEnableOption "bspwm";
 
-      package = lib.mkPackageOption pkgs "bspwm" {
+      package = mkPackageOption pkgs "bspwm" {
         example = "bspwm-unstable";
       };
-      configFile = lib.mkOption {
-        type = with lib.types; nullOr path;
-        example = lib.literalExpression ''"''${pkgs.bspwm}/share/doc/bspwm/examples/bspwmrc"'';
+      configFile = mkOption {
+        type = with types; nullOr path;
+        example = literalExpression ''"''${pkgs.bspwm}/share/doc/bspwm/examples/bspwmrc"'';
         default = null;
         description = ''
           Path to the bspwm configuration file.
···
       };
 
       sxhkd = {
-        package = lib.mkPackageOption pkgs "sxhkd" {
+        package = mkPackageOption pkgs "sxhkd" {
           example = "sxhkd-unstable";
         };
-        configFile = lib.mkOption {
-          type = with lib.types; nullOr path;
-          example = lib.literalExpression ''"''${pkgs.bspwm}/share/doc/bspwm/examples/sxhkdrc"'';
+        configFile = mkOption {
+          type = with types; nullOr path;
+          example = literalExpression ''"''${pkgs.bspwm}/share/doc/bspwm/examples/sxhkdrc"'';
           default = null;
           description = ''
             Path to the sxhkd configuration file.
···
     };
   };
 
-  config = lib.mkIf cfg.enable {
-    services.xserver.windowManager.session = lib.singleton {
+  config = mkIf cfg.enable {
+    services.xserver.windowManager.session = singleton {
       name = "bspwm";
       start = ''
         export _JAVA_AWT_WM_NONREPARENTING=1
         SXHKD_SHELL=/bin/sh ${cfg.sxhkd.package}/bin/sxhkd ${
-          lib.optionalString (cfg.sxhkd.configFile != null) "-c \"${cfg.sxhkd.configFile}\""
+          optionalString (cfg.sxhkd.configFile != null) "-c \"${cfg.sxhkd.configFile}\""
         } &
-        ${cfg.package}/bin/bspwm ${lib.optionalString (cfg.configFile != null) "-c \"${cfg.configFile}\""} &
+        ${cfg.package}/bin/bspwm ${optionalString (cfg.configFile != null) "-c \"${cfg.configFile}\""} &
         waitPID=$!
       '';
     };
···
   };
 
   imports = [
-    (lib.mkRemovedOptionModule [ "services" "xserver" "windowManager" "bspwm-unstable" "enable" ]
+    (mkRemovedOptionModule [ "services" "xserver" "windowManager" "bspwm-unstable" "enable" ]
       "Use services.xserver.windowManager.bspwm.enable and set services.xserver.windowManager.bspwm.package to pkgs.bspwm-unstable to use the unstable version of bspwm."
     )
-    (lib.mkRemovedOptionModule [
+    (mkRemovedOptionModule [
       "services"
       "xserver"
       "windowManager"
       "bspwm"
       "startThroughSession"
     ] "bspwm package does not provide bspwm-session anymore.")
-    (lib.mkRemovedOptionModule [
+    (mkRemovedOptionModule [
       "services"
       "xserver"
       "windowManager"

nixos/modules/services/x11/window-managers/clfswm.nix

···
   pkgs,
   ...
 }:
+
+with lib;
+
 let
   cfg = config.services.xserver.windowManager.clfswm;
 in
···
 {
   options = {
     services.xserver.windowManager.clfswm = {
-      enable = lib.mkEnableOption "clfswm";
-      package = lib.mkPackageOption pkgs [ "sbclPackages" "clfswm" ] { };
+      enable = mkEnableOption "clfswm";
+      package = mkPackageOption pkgs [ "sbclPackages" "clfswm" ] { };
     };
   };
 
-  config = lib.mkIf cfg.enable {
-    services.xserver.windowManager.session = lib.singleton {
+  config = mkIf cfg.enable {
+    services.xserver.windowManager.session = singleton {
       name = "clfswm";
       start = ''
         ${cfg.package}/bin/clfswm &

nixos/modules/services/x11/window-managers/cwm.nix

···
   pkgs,
   ...
 }:
+
+with lib;
+
 let
   cfg = config.services.xserver.windowManager.cwm;
 in
 {
   options = {
-    services.xserver.windowManager.cwm.enable = lib.mkEnableOption "cwm";
+    services.xserver.windowManager.cwm.enable = mkEnableOption "cwm";
   };
-  config = lib.mkIf cfg.enable {
-    services.xserver.windowManager.session = lib.singleton {
+  config = mkIf cfg.enable {
+    services.xserver.windowManager.session = singleton {
       name = "cwm";
       start = ''
         cwm &

nixos/modules/services/x11/window-managers/dwm.nix

···
 { config, lib, pkgs, ... }:
+
+with lib;
+
 let
 
   cfg = config.services.xserver.windowManager.dwm;
···
 
   options = {
     services.xserver.windowManager.dwm = {
-      enable = lib.mkEnableOption "dwm";
-      package = lib.mkPackageOption pkgs "dwm" {
+      enable = mkEnableOption "dwm";
+      package = mkPackageOption pkgs "dwm" {
         example = ''
           pkgs.dwm.overrideAttrs (oldAttrs: rec {
             patches = [
···
 
   ###### implementation
 
-  config = lib.mkIf cfg.enable {
+  config = mkIf cfg.enable {
 
-    services.xserver.windowManager.session = lib.singleton
+    services.xserver.windowManager.session = singleton
       { name = "dwm";
         start =
           ''

nixos/modules/services/x11/window-managers/e16.nix

···
   pkgs,
   ...
 }:
+
+with lib;
+
 let
   cfg = config.services.xserver.windowManager.e16;
 in
 {
   ###### interface
   options = {
-    services.xserver.windowManager.e16.enable = lib.mkEnableOption "e16";
+    services.xserver.windowManager.e16.enable = mkEnableOption "e16";
   };
 
   ###### implementation
-  config = lib.mkIf cfg.enable {
-    services.xserver.windowManager.session = lib.singleton {
+  config = mkIf cfg.enable {
+    services.xserver.windowManager.session = singleton {
       name = "E16";
       start = ''
         ${pkgs.e16}/bin/e16 &

pkgs/applications/audio/ardour/default.nix

···
 , libltc
 , libogg
 , libpulseaudio
-, librdf_raptor
 , librdf_rasqal
 , libsamplerate
 , libsigcxx
···
     libltc
     libogg
     libpulseaudio
-    librdf_raptor
     librdf_rasqal
     libsamplerate
     libsigcxx

pkgs/applications/networking/discordo/default.nix

···
 
 buildGoModule rec {
   pname = "discordo";
-  version = "0-unstable-2024-12-12";
+  version = "0-unstable-2024-12-22";
 
   src = fetchFromGitHub {
     owner = "ayn2op";
     repo = pname;
-    rev = "c97307d5425ba0fef24f0bdd5b9d63f660e11b20";
-    hash = "sha256-I2rO0PKtxQUiyaAt4BmE4zvOmqShbydGwWbPmnzUjHY=";
+    rev = "9f15a6342413f68531402b8aeb5ed272159fc370";
+    hash = "sha256-8VBw7DsX/xnNkfiIe8jiG2oXjIp1tNT6wy6eTDBZxUg=";
   };
 
   vendorHash = "sha256-UTZIx4zXIMdQBQXfzk3+j43yx7vlitw4Mwmon8oYjd8=";

pkgs/applications/office/qownnotes/default.nix

···
-{ lib
-, stdenv
-, fetchurl
-, cmake
-, qttools
-, qtbase
-, qtdeclarative
-, qtsvg
-, qtwayland
-, qtwebsockets
-, makeWrapper
-, wrapQtAppsHook
-, botan2
-, pkg-config
-, nixosTests
-, installShellFiles
-, xvfb-run
-}:
-
-let
-  pname = "qownnotes";
-  appname = "QOwnNotes";
-  version = "24.12.7";
-in
-stdenv.mkDerivation {
-  inherit pname version;
-
-  src = fetchurl {
-    url = "https://github.com/pbek/QOwnNotes/releases/download/v${version}/qownnotes-${version}.tar.xz";
-    hash = "sha256-48puEyScG6EIrsXZpFc62dl4a23p+TO2buzuwq9m3Sw=";
-  };
-
-  nativeBuildInputs = [
-    cmake
-    qttools
-    wrapQtAppsHook
-    pkg-config
-    installShellFiles
-  ] ++ lib.optionals stdenv.hostPlatform.isLinux [ xvfb-run ] ++ lib.optionals stdenv.hostPlatform.isDarwin [ makeWrapper ];
-
-  buildInputs = [
-    qtbase
-    qtdeclarative
-    qtsvg
-    qtwebsockets
-    botan2
-  ] ++ lib.optionals stdenv.hostPlatform.isLinux [ qtwayland ];
-
-  cmakeFlags = [
-    "-DQON_QT6_BUILD=ON"
-    "-DBUILD_WITH_SYSTEM_BOTAN=ON"
-  ];
-
-  # Install shell completion on Linux (with xvfb-run)
-  postInstall = lib.optionalString stdenv.hostPlatform.isLinux ''
-      installShellCompletion --cmd ${appname} \
-        --bash <(xvfb-run $out/bin/${appname} --completion bash) \
-        --fish <(xvfb-run $out/bin/${appname} --completion fish)
-      installShellCompletion --cmd ${pname} \
-        --bash <(xvfb-run $out/bin/${appname} --completion bash) \
-        --fish <(xvfb-run $out/bin/${appname} --completion fish)
-  ''
-  # Install shell completion on macOS
-  + lib.optionalString stdenv.isDarwin ''
-      installShellCompletion --cmd ${pname} \
-        --bash <($out/bin/${appname} --completion bash) \
-        --fish <($out/bin/${appname} --completion fish)
-  ''
-  # Create a lowercase symlink for Linux
-  + lib.optionalString stdenv.hostPlatform.isLinux ''
-    ln -s $out/bin/${appname} $out/bin/${pname}
-  ''
-  # Rename application for macOS as lowercase binary
-  + lib.optionalString stdenv.hostPlatform.isDarwin ''
-    # Prevent "same file" error
-    mv $out/bin/${appname} $out/bin/${pname}.bin
-    mv $out/bin/${pname}.bin $out/bin/${pname}
-  '';
-
-  # Tests QOwnNotes using the NixOS module by launching xterm:
-  passthru.tests.basic-nixos-module-functionality = nixosTests.qownnotes;
-
-  meta = with lib; {
-    description = "Plain-text file notepad and todo-list manager with markdown support and Nextcloud/ownCloud integration";
-    homepage = "https://www.qownnotes.org/";
-    changelog = "https://www.qownnotes.org/changelog.html";
-    downloadPage = "https://github.com/pbek/QOwnNotes/releases/tag/v${version}";
-    license = licenses.gpl2Only;
-    maintainers = with maintainers; [ pbek totoroot ];
-    platforms = platforms.unix;
-  };
-}

pkgs/applications/office/treesheets/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "treesheets";
-  version = "0-unstable-2024-12-11";
+  version = "0-unstable-2024-12-22";
 
   src = fetchFromGitHub {
     owner = "aardappel";
     repo = "treesheets";
-    rev = "81e74a0f3f325ada0abe35211e90b74132f91470";
-    hash = "sha256-6Ao1dl0tRLAZZxx0xV7uaojuCO9i3bUIdccsZ37Jm/g=";
+    rev = "b3bf8f2763aa9efaac428107d62194582839df1b";
+    hash = "sha256-qY5DSFW6jnngvHCBgz9Go9Xsfo2nd7xDyZWuKSpyMMM=";
   };
 
   nativeBuildInputs = [

pkgs/applications/video/mplayer/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "mplayer";
-  version = "1.5-unstable-2024-07-03";
+  version = "1.5-unstable-2024-12-21";
 
   src = fetchsvn {
     url = "svn://svn.mplayerhq.hu/mplayer/trunk";
-    rev = "38637";
-    hash = "sha256-9KQOB6QIs1VZhazJqW8dY4ASiMgoxV6davfpKgLPbmE=";
+    rev = "38668";
+    hash = "sha256-ezWYBkhiSBgf/SeTrO6sKGbL/IrX+82KXCIlqYMEtgY=";
   };
 
   prePatch = ''
···
     description = "Movie player that supports many video formats";
     homepage = "http://mplayerhq.hu";
     license = licenses.gpl2Only;
-    maintainers = [ ];
+    # Picking it up: no idea about the origin of some choices (but seems fine)
+    maintainers = [ maintainers.raskin ];
     platforms = [
       "i686-linux"
       "x86_64-linux"

pkgs/applications/window-managers/i3/status-rust.nix

···
 , lm_sensors
 , iw
 , iproute2
+, pipewire
 , withICUCalendar ? false
+, withPipewire ? true
 }:
 
 rustPlatform.buildRustPackage rec {
···
 
   cargoHash = "sha256-9jbJVnZhFbMYldBkRVSIiorUYDNtF3AAwNEpyNJXpjo=";
 
-  nativeBuildInputs = [ pkg-config makeWrapper ];
+  nativeBuildInputs = [ pkg-config makeWrapper ]
+    ++ (lib.optionals withPipewire [ rustPlatform.bindgenHook ]);
 
-  buildInputs = [ dbus libpulseaudio notmuch openssl lm_sensors ];
+  buildInputs = [ dbus libpulseaudio notmuch openssl lm_sensors ]
+    ++ (lib.optionals withPipewire [ pipewire ]);
 
   buildFeatures = [
     "notmuch"
     "maildir"
     "pulseaudio"
-  ] ++ (lib.optionals withICUCalendar [ "icu_calendar" ]);
+  ] ++ (lib.optionals withICUCalendar [ "icu_calendar" ])
+  ++ (lib.optionals withPipewire [ "pipewire" ]);
 
   prePatch = ''
     substituteInPlace src/util.rs \

pkgs/build-support/testers/shellcheck/tester.nix

···
 {
   lib,
   stdenv,
+  runCommand,
   shellcheck,
 }:
 
···
 # Tests: ./tests.nix
 { src }:
 let
-  inherit (lib) fileset pathType isPath;
+  inherit (lib) pathType isPath;
 in
 stdenv.mkDerivation {
   name = "run-shellcheck";
···
     if
       isPath src && pathType src == "regular" # note that for strings this would have been IFD, which we prefer to avoid
     then
-      fileset.toSource {
-        root = dirOf src;
-        fileset = src;
-      }
+      runCommand "testers-shellcheck-src" { } ''
+        mkdir $out
+        cp ${src} $out
+      ''
     else
       src;
   nativeBuildInputs = [ shellcheck ];

pkgs/build-support/testers/shellcheck/tests.nix

···
   testers,
   runCommand,
 }:
-let
-  inherit (lib) fileset;
-in
 lib.recurseIntoAttrs {
 
   example-dir =
···
       {
         failure = testers.testBuildFailure (
           testers.shellcheck {
-            src = fileset.toSource {
-              root = ./.;
-              fileset = fileset.unions [
-                ./example.sh
-              ];
-            };
+            src = ./src;
           }
         );
       }
···
       {
         failure = testers.testBuildFailure (
           testers.shellcheck {
-            src = ./example.sh;
+            src = ./src/example.sh;
           }
         );
       }

pkgs/by-name/at/atlantis/package.nix

···
 
 buildGoModule rec {
   pname = "atlantis";
-  version = "0.30.0";
+  version = "0.32.0";
 
   src = fetchFromGitHub {
     owner = "runatlantis";
     repo = "atlantis";
     rev = "v${version}";
-    hash = "sha256-hM4IycRE3/jiwFLqkU/jz9sPP9KTfeu8ouIJlqgPxmk=";
+    hash = "sha256-7D7msKDnHym3uiMJur2kCRf6MurwkMEKI+aYcwqOVX0=";
   };
   ldflags = [
     "-X=main.version=${version}"
     "-X=main.date=1970-01-01T00:00:00Z"
   ];
 
-  vendorHash = "sha256-uH+Q5NXBL1+LFa6tw3x2CE1B5QElqK9KuFeYQpCFAW0=";
+  vendorHash = "sha256-wPsEE6sR1GDD3Npdcf/JmeZc451+x9UBE8+DwXkj/qE=";
 
   subPackages = [ "." ];
 

pkgs/by-name/av/avro-cpp/0001-get-rid-of-fmt-fetchcontent.patch

···
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 19059a41b..6e3ae0ad7 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -82,15 +82,7 @@ endif ()
+ find_package (Boost 1.38 REQUIRED
+     COMPONENTS filesystem iostreams program_options regex system)
+ 
+-include(FetchContent)
+-FetchContent_Declare(
+-        fmt
+-        GIT_REPOSITORY  https://github.com/fmtlib/fmt.git
+-        GIT_TAG         10.2.1
+-        GIT_PROGRESS    TRUE
+-        USES_TERMINAL_DOWNLOAD TRUE
+-)
+-FetchContent_MakeAvailable(fmt)
++find_package(fmt REQUIRED)
+ 
+ find_package(Snappy)
+ if (SNAPPY_FOUND)

pkgs/by-name/av/avro-cpp/package.nix

···
   lib,
   stdenv,
   fetchurl,
-  fetchpatch,
   cmake,
   boost,
   python3,
+  fmt,
+  versionCheckHook,
 }:
 
 stdenv.mkDerivation rec {
   pname = "avro-c++";
-  version = "1.11.3";
+  version = "1.12.0";
 
   src = fetchurl {
     url = "mirror://apache/avro/avro-${version}/cpp/avro-cpp-${version}.tar.gz";
-    hash = "sha256-+6JCrvd+yBnQdWH8upN1FyGVbejQyujh8vMAtUszG64=";
+    hash = "sha256-8u33cSanWw7BrRZncr4Fg1HOo9dESL5+LO8gBQwPmKs=";
   };
+
   patches = [
-    # This patch fixes boost compatibility and can be removed when
-    # upgrading beyond 1.11.3 https://github.com/apache/avro/pull/1920
-    (fetchpatch {
-      name = "fix-boost-compatibility.patch";
-      url = "https://github.com/apache/avro/commit/016323828f147f185d03f50d2223a2f50bfafce1.patch";
-      hash = "sha256-hP/5J2JzSplMvg8EjEk98Vim8DfTyZ4hZ/WGiVwvM1A=";
-    })
+    ./0001-get-rid-of-fmt-fetchcontent.patch
   ];
-  patchFlags = [ "-p3" ];
 
   nativeBuildInputs = [
     cmake
     python3
   ];
-  buildInputs = [ boost ];
+
+  propagatedBuildInputs = [
+    boost
+    fmt
+  ];
+
+  doCheck = true;
 
-  preConfigure = ''
-    substituteInPlace test/SchemaTests.cc --replace "BOOST_CHECKPOINT" "BOOST_TEST_CHECKPOINT"
-    substituteInPlace test/buffertest.cc --replace "BOOST_MESSAGE" "BOOST_TEST_MESSAGE"
-  '';
+  nativeInstallCheckInputs = [
+    versionCheckHook
+  ];
+  doInstallCheck = true;
+  versionCheckProgram = "${placeholder "out"}/bin/avrogencpp";
+  versionCheckProgramArg = [ "--version" ];
 
   meta = {
     description = "C++ library which implements parts of the Avro Specification";

pkgs/by-name/ba/bazarr/package.nix

···
 in
 stdenv.mkDerivation rec {
   pname = "bazarr";
-  version = "1.4.5";
+  version = "1.5.0";
 
   src = fetchzip {
     url = "https://github.com/morpheus65535/bazarr/releases/download/v${version}/bazarr.zip";
-    hash = "sha256-BV+ON+SavPc0ZUlIk6tlsvmWub8TiYSSJSRutZb1q+g=";
+    hash = "sha256-Q/KlqvVWhegSxkxHls0WwCClaQwkmLAfuzfi3X4xgAY=";
     stripRoot = false;
   };
 

pkgs/by-name/bi/bitwuzla/package.nix

···
 
 stdenv.mkDerivation (finalAttrs: {
   pname = "bitwuzla";
-  version = "0.6.1";
+  version = "0.7.0";
 
   src = fetchFromGitHub {
     owner = "bitwuzla";
     repo = "bitwuzla";
     rev = finalAttrs.version;
-    hash = "sha256-auW+YeUCpl7SzVAMTyHxrWh6ShwElq6wTEP7Qf2M7jk=";
+    hash = "sha256-S8CtK8WEehUdOoqOmu5KnoqHFpCGrYWjZKv1st4M7bo=";
   };
 
   strictDeps = true;

pkgs/by-name/bk/bkcrack/package.nix

···
 
 stdenv.mkDerivation (finalAttrs: {
   pname = "bkcrack";
-  version = "1.7.0";
+  version = "1.7.1";
 
   src = fetchFromGitHub {
     owner = "kimci86";
     repo = "bkcrack";
     rev = "v${finalAttrs.version}";
-    hash = "sha256-smDmnqmYuFT3ip3ULQfiiF5YxkwzPwPYBujqq9GUyMs=";
+    hash = "sha256-88zAR1XE+C5UNmvY/ph1I1tL2nVGbywqh6zHRGbImXU=";
   };
 
   passthru.updateScript = nix-update-script { };

pkgs/by-name/bo/bodyclose/package.nix

···
 
 buildGoModule {
   pname = "bodyclose";
-  version = "0-unstable-2024-10-17";
+  version = "0-unstable-2024-12-22";
 
   src = fetchFromGitHub {
     owner = "timakin";
     repo = "bodyclose";
-    rev = "adbc21e6bf369ca6d936dbb140733f34867639bd";
-    hash = "sha256-GNZNzXEZnIxep5BS1sBZsMl876FwwIkOBwHAMk/73fo=";
+    rev = "1db5c5ca4d6719fe28430df1ae8d337ee2ac09c7";
+    hash = "sha256-s5bWvpV6gHGEsuiNXJl2ZuyDaffD82/rCbusov3zsyw=";
   };
 
   vendorHash = "sha256-8grdJuV8aSETsJr2VazC/3ctfnGh3UgjOWD4/xf3uC8=";

pkgs/by-name/ca/cairo-lang/package.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "cairo";
-  version = "2.8.5";
+  version = "2.9.2";
 
   src = fetchFromGitHub {
     owner = "starkware-libs";
     repo = "cairo";
     rev = "v${version}";
-    hash = "sha256-zNSQVMF5ciGGUBQyPFvIVtePNMbJ3e0LXBmRWMohoGA=";
+    hash = "sha256-zjgCOrTlIPN4aU0+FCohJmISPiwpppj3zO/7unVi/iU=";
   };
 
-  cargoHash = "sha256-jVQErw89rCm9f3uJftmyytru1xQa+FKsUkszHJWBGNU=";
+  cargoHash = "sha256-2qm2hL4M2xHidRYF9Fhxxn2IG22mPEBZW5yhu6wPVDY=";
 
   # openssl crate requires perl during build process
   nativeBuildInputs = [

pkgs/by-name/cl/clusterctl/package.nix

···
 
 buildGoModule rec {
   pname = "clusterctl";
-  version = "1.9.0";
+  version = "1.9.2";
 
   src = fetchFromGitHub {
     owner = "kubernetes-sigs";
     repo = "cluster-api";
     rev = "v${version}";
-    hash = "sha256-ENbNgstu+YsNESJ2RsJri3B4zO8UI3Dt60/8AFgsxn8=";
+    hash = "sha256-H86EkdGmzvQDGC/a+J6ISB0aYkJabBjE2P6Ab5FRlv4=";
   };
 
-  vendorHash = "sha256-rjo8fwUAnVDM7XvY31I5z6RMRSrNSur6wH7NfGTIdcc=";
+  vendorHash = "sha256-JSWk6FgjWnDcVmp/9+M0x7QsiX08QtIOn5RRifjs2mI=";
 
   subPackages = [ "cmd/clusterctl" ];
 

pkgs/by-name/co/codeium/package.nix

···
 
   hash =
     {
-      x86_64-linux = "sha256-xbMiPmFGte4I6p+Zt4HaLL4MuHoMs++gf5iVPl7+h70=";
-      aarch64-linux = "sha256-2bu8cI0u8Q3mCxZFoM0W/gQ4BipLUIoVe2e0a16ZQco=";
-      x86_64-darwin = "sha256-lGRqxZxIpioTA5I9lsWIQ8S7AN8AXR7NGgSMCNN3cQI=";
-      aarch64-darwin = "sha256-MGqT4Jhq81rvnMhQtg+N0C4ElOfUvLpVBq7EtwKztOE=";
+      x86_64-linux = "sha256-/VkobDCai9+Lac0TCzm9gg/pNFDA1T2OJiad3qdz/2o=";
+      aarch64-linux = "sha256-glJRQIFSs5D7b3BVblaL0o8Rndh3QuCup45AfRWymG0=";
+      x86_64-darwin = "sha256-TBCgbaJ5Yyp+I8VCljYf3tlNnVaLkfwusJMlfY+Rggo=";
+      aarch64-darwin = "sha256-MfJ/zIfmKJN4Fe6a50NwAqvetxB/W+BriQ+5mEIhWMg=";
     }
     .${system} or throwSystem;
 
···
 in
 stdenv.mkDerivation (finalAttrs: {
   pname = "codeium";
-  version = "1.30.2";
+  version = "1.30.18";
   src = fetchurl {
     name = "${finalAttrs.pname}-${finalAttrs.version}.gz";
     url = "https://github.com/Exafunction/codeium/releases/download/language-server-v${finalAttrs.version}/language_server_${plat}.gz";

pkgs/by-name/co/coroot-node-agent/package.nix

···
 
 buildGoModule rec {
   pname = "coroot-node-agent";
-  version = "1.22.2";
+  version = "1.23.1";
 
   src = fetchFromGitHub {
     owner = "coroot";
     repo = "coroot-node-agent";
     rev = "v${version}";
-    hash = "sha256-b9JI0q6CF4D+sdfuwTkouAwJF/ghJByzsQBehwXttoU=";
+    hash = "sha256-kisYm0bM+IZJ9qRx1lDlcFtZIdjsNfu6Ao75q84ruDM=";
   };
 
-  vendorHash = "sha256-OZj3t8eFDbk2zZ+zGlgV8o9VC4/vYalIEm2dhD2JwK8=";
+  vendorHash = "sha256-EXI4xpo4j/EzugW8zyu0Dvk2i6bYFBIF+SsL6GZ+J2Q=";
 
   buildInputs = [ systemdLibs ];
 

pkgs/by-name/co/coursier/package.nix

···
 in
 stdenv.mkDerivation rec {
   pname = "coursier";
-  version = "2.1.19";
+  version = "2.1.22";
 
   src = fetchurl {
     url = "https://github.com/coursier/coursier/releases/download/v${version}/coursier";
-    hash = "sha256-E6LEi2m/BMCT9T5UYzMbIcoj42MKP2OIc27XGDMUI7w=";
+    hash = "sha256-0ugWgvG3AHt7h8F8W8kCksyx93YO51i5StqGAEZXGmg=";
   };
 
   dontUnpack = true;

pkgs/by-name/de/deck/package.nix

···
 
 buildGoModule rec {
   pname = "deck";
-  version = "1.40.3";
+  version = "1.42.1";
 
   src = fetchFromGitHub {
     owner = "Kong";
     repo = "deck";
     rev = "refs/tags/v${version}";
-    hash = "sha256-n6WASCtDwBX4FASSWI17JpU7rDXIeSidPWhj/MB2tUs=";
+    hash = "sha256-+HXTBTE8oEvyEwzwJbM0snVV0sKcKFHFnHB1iJ+4LJc=";
   };
 
   nativeBuildInputs = [ installShellFiles ];
···
   ];
 
   proxyVendor = true; # darwin/linux hash mismatch
-  vendorHash = "sha256-csoSvu7uce1diB4EsQCRRt08mX+rJoxfZqAtaoo0x4M=";
+  vendorHash = "sha256-YFEiv+mbU8ZE9u1lL4cZUo+7sVSu9P1UEkuKyAGwlkg=";
 
   postInstall = ''
     installShellCompletion --cmd deck \

pkgs/by-name/do/dolt/package.nix

···
 
 buildGoModule rec {
   pname = "dolt";
-  version = "1.44.0";
+  version = "1.45.1";
 
   src = fetchFromGitHub {
     owner = "dolthub";
     repo = "dolt";
     rev = "v${version}";
-    sha256 = "sha256-sumd663G9Tztkuo21w7AE7ylzH2GnwNIL+/cGQz1SX8=";
+    sha256 = "sha256-O5y3AdFOtxNwpt8uGkTC7XHY1M/6Cv3vTyeHyVlTRGw=";
   };
 
   modRoot = "./go";
   subPackages = [ "cmd/dolt" ];
-  vendorHash = "sha256-bHLudlThXd4ttgmDyVwGD+SI9KJxIMo2iZARREZUSxk=";
+  vendorHash = "sha256-h9HE90mOaDid2/uZcDBKZdbi6K1P2o27LZDnLAm+XSE=";
   proxyVendor = true;
   doCheck = false;
 

pkgs/by-name/du/dumbpipe/package.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "dumbpipe";
-  version = "0.21.0";
+  version = "0.22.0";
 
   src = fetchFromGitHub {
     owner = "n0-computer";
     repo = pname;
     rev = "v${version}";
-    hash = "sha256-WJwjxVtv022Qm1NUnibh2jq1g0P/hi0HjeA9l7fMdRw=";
+    hash = "sha256-NNSR8qAikwXC0bJ4jGQQ2gZZmgPin5M6xAaY2YhuBvw=";
   };
 
-  cargoHash = "sha256-oq8jWRFVEB9sMZ7ufke5D1BMpGms8WJWVL/LGV+g/GI=";
+  cargoHash = "sha256-yAz/VjdS4FeKKM9vjOPcASGByNQp2StvrFHwJnk2YUg=";
 
   buildInputs = lib.optionals stdenv.hostPlatform.isDarwin (
     with darwin.apple_sdk.frameworks;

pkgs/by-name/du/duo-unix/package.nix

···
 
 stdenv.mkDerivation rec {
   pname = "duo-unix";
-  version = "2.0.2";
+  version = "2.0.4";
 
   src = fetchurl {
     url    = "https://dl.duosecurity.com/duo_unix-${version}.tar.gz";
-    sha256 = "sha256-7huWd71SdnTe1ef8OoHgQKjYQKVpE8k/oNT7bA+OJR0=";
+    sha256 = "sha256-P7IVX4RyMER2BX99FJUgv2JZx7KddktiJ101rTJJwmQ=";
   };
 
   buildInputs = [ pam openssl zlib ];

pkgs/by-name/du/duplicity/package.nix

···
         paramiko
         pyasn1
         pycrypto
-        pydrive2
+        # Currently marked as broken.
+        # pydrive2
         future
       ]
       ++ paramiko.optional-dependencies.invoke;

pkgs/by-name/ec/eclint/package.nix

···
 
 buildGoModule rec {
   pname = "eclint";
-  version = "0.5.0";
+  version = "0.5.1";
 
   src = fetchFromGitLab {
     owner = "greut";
     repo = pname;
     rev = "v${version}";
-    hash = "sha256-x0dBiRHaDxKrTCR2RfP2/bpBo6xewu8FX7Bv4ugaUAY=";
+    hash = "sha256-XY+D0bRIgWTm2VH+uDVodYeyGeu+8Xyyq4xDvTDLii4=";
   };
 
-  vendorHash = "sha256-aNQuALDe37lsmTGpClIBOQJlL0NFSAZCgcmTjx0kP+U=";
+  vendorHash = "sha256-4bka3GRl75aUYpZrWuCIvKNwPY8ykp25e+kn+G6JQ/I=";
 
   ldflags = [ "-X main.version=${version}" ];
 

pkgs/by-name/fl/flattenReferencesGraph/package.nix

···
 {
   callPackage,
-  lib,
+  nix-gitignore,
   python3Packages,
 }:
 let
-  inherit (lib) fileset;
   helpers = callPackage ./helpers.nix { };
   pythonPackages = python3Packages;
+
 in
 pythonPackages.buildPythonApplication {
   version = "0.1.0";
   pname = "flatten-references-graph";
 
-  src = fileset.toSource {
-    root = ./src;
-    fileset = fileset.unions [
-      ./src/.flake8
-      ./src/flatten_references_graph
-      ./src/setup.py
-    ];
-  };
+  # Note: this uses only ./src/.gitignore
+  src = nix-gitignore.gitignoreSource [ ] ./src;
 
   propagatedBuildInputs = with pythonPackages; [
     igraph

pkgs/by-name/fl/flexget/package.nix

···
 {
   lib,
-  python3,
+  python3Packages,
   fetchFromGitHub,
+  stdenv,
 }:
 
-python3.pkgs.buildPythonApplication rec {
+python3Packages.buildPythonApplication rec {
   pname = "flexget";
-  version = "3.13.2";
+  version = "3.13.5";
   pyproject = true;
 
   # Fetch from GitHub in order to use `requirements.in`
···
     owner = "Flexget";
     repo = "Flexget";
     tag = "v${version}";
-    hash = "sha256-UjKYHZwAOOv3Adj13r2zJkVmxwEpJLQk87UslddX9Qk=";
+    hash = "sha256-R6E5NWnrnezJsDm+Nnqgibv4e6mXVrOrKaCl/MBqUnY=";
   };
 
   # relax dep constrains, keep environment constraints
   pythonRelaxDeps = true;
 
-  build-system = with python3.pkgs; [ setuptools ];
+  build-system = with python3Packages; [ setuptools ];
 
-  dependencies = with python3.pkgs; [
+  dependencies = with python3Packages; [
     # See https://github.com/Flexget/Flexget/blob/master/pyproject.toml
     # and https://github.com/Flexget/Flexget/blob/develop/requirements.txt
     apscheduler
···
     pyrss2gen
     python-dateutil
     pyyaml
+    rarfile
     rebulk
     requests
     rich
···
     deluge-client
     cloudscraper
     python-telegram-bot
+    boto3
   ];
 
   pythonImportsCheck = [
···
     "flexget.plugins.services.pogcal_acquired"
   ];
 
-  # ~400 failures
-  doCheck = false;
+  nativeCheckInputs = [
+    python3Packages.pytestCheckHook
+    python3Packages.pytest-vcr
+    python3Packages.paramiko
+  ];
 
-  meta = with lib; {
+  doCheck = !stdenv.isDarwin;
+
+  disabledTests = [
+    # reach the Internet
+    "TestExistsMovie"
+    "TestImdb"
+    "TestImdbLookup"
+    "TestImdbParser"
+    "TestInputHtml"
+    "TestInputSites"
+    "TestNfoLookupWithMovies"
+    "TestNpoWatchlistInfo"
+    "TestNpoWatchlistLanguageTheTVDBLookup"
+    "TestNpoWatchlistPremium"
+    "TestPlex"
+    "TestRadarrListActions"
+    "TestRssOnline"
+    "TestSeriesRootAPI"
+    "TestSftpDownload"
+    "TestSftpList"
+    "TestSonarrListActions"
+    "TestSubtitleList"
+    "TestTMDBMovieLookupAPI"
+    "TestTVDBEpisodeABSLookupAPI"
+    "TestTVDBEpisodeAirDateLookupAPI"
+    "TestTVDBEpisodeLookupAPI"
+    "TestTVDBExpire"
+    "TestTVDBFavorites"
+    "TestTVDBLanguages"
+    "TestTVDBList"
+    "TestTVDBLookup"
+    "TestTVDBLookup"
+    "TestTVDBSeriesActorsLookupAPI"
+    "TestTVDBSeriesLookupAPI"
+    "TestTVDSearchIMDBLookupAPI"
+    "TestTVDSearchNameLookupAPI"
+    "TestTVDSearchZAP2ITLookupAPI"
+    "TestTVMAzeSeriesLookupAPI"
+    "TestTVMazeSeasonLookup"
+    "TestTVMazeShowLookup"
+    "TestTVMazeUnicodeLookup"
+    "TestTaskParsing::test_selected_parser_cleared"
+    "TestTheTVDBLanguages"
+    "TestTheTVDBList"
+    "TestTmdbLookup"
+    "TestURLRewriters"
+    "TestURLRewriters::test_ettv"
+    # others
+    "TestRegexp"
+    "TestYamlLists"
+  ];
+
+  meta = {
     homepage = "https://flexget.com/";
     changelog = "https://github.com/Flexget/Flexget/releases/tag/v${version}";
     description = "Multipurpose automation tool for all of your media";
-    license = licenses.mit;
-    maintainers = with maintainers; [ pbsds ];
+    license = lib.licenses.mit;
+    maintainers = with lib.maintainers; [ pbsds ];
   };
 }

pkgs/by-name/gh/ghostty/darwin.nix

···
-{
-  pname,
-  version,
-  outputs,
-  meta,
-  lib,
-  stdenvNoCC,
-  fetchurl,
-  _7zz,
-  makeWrapper,
-}:
-
-stdenvNoCC.mkDerivation (finalAttrs: {
-  inherit pname version outputs;
-
-  src = fetchurl {
-    url = "https://release.files.ghostty.org/${finalAttrs.version}/Ghostty.dmg";
-    sha256 = "sha256-CR96Kz9BYKFtfVKygiEku51XFJk4FfYqfXACeYQ3JlI=";
-  };
-
-  nativeBuildInputs = [
-    _7zz
-    makeWrapper
-  ];
-
-  sourceRoot = ".";
-  installPhase = ''
-    runHook preInstall
-
-    mkdir -p $out/Applications
-    mv Ghostty.app $out/Applications/
-    makeWrapper $out/Applications/Ghostty.app/Contents/MacOS/ghostty $out/bin/ghostty
-
-    runHook postInstall
-  '';
-
-  postFixup =
-    let
-      resources = "$out/Applications/Ghostty.app/Contents/Resources";
-    in
-    ''
-      mkdir -p $man/share
-      ln -s ${resources}/man $man/share/man
-
-      mkdir -p $terminfo/share
-      ln -s ${resources}/terminfo $terminfo/share/terminfo
-
-      mkdir -p $shell_integration
-      for folder in "${resources}/ghostty/shell-integration"/*; do
-        ln -s $folder $shell_integration/$(basename "$folder")
-      done
-
-      mkdir -p $vim
-      for folder in "${resources}/vim/vimfiles"/*; do
-        ln -s $folder $vim/$(basename "$folder")
-      done
-    '';
-
-  meta = meta // {
-    sourceProvenance = [ lib.sourceTypes.binaryNativeCode ];
-  };
-})

pkgs/by-name/gh/ghostty/deps.nix

···
 # generated by zon2nix (https://github.com/Cloudef/zig2nix)
+
 {
   lib,
   linkFarm,
···
   zig,
   name ? "zig-packages",
 }:
+
 with builtins;
 with lib;
+
 let
   unpackZigArtifact =
-    {
-      name,
-      artifact,
-    }:
+    { name, artifact }:
     runCommandLocal name
       {
         nativeBuildInputs = [ zig ];
···
     };
   }
   {
-    name = "12204358b2848ffd993d3425055bff0a5ba9b1b60bead763a6dea0517965d7290a6c";
+    name = "1220cc25b537556a42b0948437c791214c229efb78b551c80b1e9b18d70bf0498620";
     path = fetchZigArtifact {
       name = "iterm2_themes";
-      url = "https://github.com/mbadolato/iTerm2-Color-Schemes/archive/d6c42066b3045292e0b1154ad84ff22d6863ebf7.tar.gz";
-      hash = "sha256-s6us3PkOPmQCtLS9QNPM7BDLt7x+37KbmYF9d4NMD/c=";
+      url = "https://github.com/mbadolato/iTerm2-Color-Schemes/archive/e030599a6a6e19fcd1ea047c7714021170129d56.tar.gz";
+      hash = "sha256-hFGjD0rNfZ7Qd7uJZgVn+FmIVXunbjLT+E1BoXhXoJE=";
     };
   }
   {

pkgs/by-name/gh/ghostty/linux.nix

···
-{
-  pname,
-  version,
-  outputs,
-  meta,
-  lib,
-  stdenv,
-  bzip2,
-  callPackage,
-  fetchFromGitHub,
-  fontconfig,
-  freetype,
-  glib,
-  glslang,
-  harfbuzz,
-  libGL,
-  libX11,
-  libadwaita,
-  ncurses,
-  nixosTests,
-  oniguruma,
-  pandoc,
-  pkg-config,
-  removeReferencesTo,
-  versionCheckHook,
-  wrapGAppsHook4,
-  zig_0_13,
-  # Usually you would override `zig.hook` with this, but we do that internally
-  # since upstream recommends a non-default level
-  # https://github.com/ghostty-org/ghostty/blob/4b4d4062dfed7b37424c7210d1230242c709e990/PACKAGING.md#build-options
-  optimizeLevel ? "ReleaseFast",
-  # https://github.com/ghostty-org/ghostty/blob/4b4d4062dfed7b37424c7210d1230242c709e990/build.zig#L106
-  withAdwaita ? true,
-}:
-
-let
-  zig_hook = zig_0_13.hook.overrideAttrs {
-    zig_default_flags = "-Dcpu=baseline -Doptimize=${optimizeLevel} --color off";
-  };
-
-  # https://github.com/ghostty-org/ghostty/blob/4b4d4062dfed7b37424c7210d1230242c709e990/src/apprt.zig#L72-L76
-  appRuntime = if stdenv.hostPlatform.isLinux then "gtk" else "none";
-  # https://github.com/ghostty-org/ghostty/blob/4b4d4062dfed7b37424c7210d1230242c709e990/src/font/main.zig#L94
-  fontBackend = if stdenv.hostPlatform.isDarwin then "coretext" else "fontconfig_freetype";
-  # https://github.com/ghostty-org/ghostty/blob/4b4d4062dfed7b37424c7210d1230242c709e990/src/renderer.zig#L51-L52
-  renderer = if stdenv.hostPlatform.isDarwin then "metal" else "opengl";
-in
-
-stdenv.mkDerivation (finalAttrs: {
-  inherit
-    pname
-    version
-    outputs
-    meta
-    ;
-
-  src = fetchFromGitHub {
-    owner = "ghostty-org";
-    repo = "ghostty";
-    tag = "v${finalAttrs.version}";
-    hash = "sha256-AHI1Z4mfgXkNwQA8xYq4tS0/BARbHL7gQUT41vCxQTM=";
-  };
-
-  # Avoid using runtime hacks to help find X11
-  postPatch = lib.optionalString (appRuntime == "gtk") ''
-    substituteInPlace src/apprt/gtk/x11.zig \
-      --replace-warn 'std.DynLib.open("libX11.so");' 'std.DynLib.open("${lib.getLib libX11}/lib/libX11.so");'
-  '';
-
-  deps = callPackage ./deps.nix {
-    name = "${finalAttrs.pname}-cache-${finalAttrs.version}";
-  };
-
-  strictDeps = true;
-
-  nativeBuildInputs =
-    [
-      ncurses
-      pandoc
-      pkg-config
-      removeReferencesTo
-      zig_hook
-    ]
-    ++ lib.optionals (appRuntime == "gtk") [
-      glib # Required for `glib-compile-schemas`
-      wrapGAppsHook4
-    ];
-
-  buildInputs =
-    [
-      glslang
-      oniguruma
-    ]
-    ++ lib.optional (appRuntime == "gtk" && withAdwaita) libadwaita
-    ++ lib.optional (appRuntime == "gtk") libX11
-    ++ lib.optional (renderer == "opengl") libGL
-    ++ lib.optionals (fontBackend == "fontconfig_freetype") [
-      bzip2
-      fontconfig
-      freetype
-      harfbuzz
-    ];
-
-  zigBuildFlags =
-    [
-      "--system"
-      "${finalAttrs.deps}"
-      "-Dversion-string=${finalAttrs.version}"
-
-      "-Dapp-runtime=${appRuntime}"
-      "-Dfont-backend=${fontBackend}"
-      "-Dgtk-adwaita=${lib.boolToString withAdwaita}"
-      "-Drenderer=${renderer}"
-    ]
-    ++ lib.mapAttrsToList (name: package: "-fsys=${name} --search-prefix ${lib.getLib package}") {
-      inherit glslang;
-    };
-
-  zigCheckFlags = finalAttrs.zigBuildFlags;
-
-  # Unit tests currently fail inside the sandbox
-  doCheck = false;
-
-  /**
-    Ghostty really likes all of it's resources to be in the same directory, so link them back after we split them
-
-    - https://github.com/ghostty-org/ghostty/blob/4b4d4062dfed7b37424c7210d1230242c709e990/src/os/resourcesdir.zig#L11-L52
-    - https://github.com/ghostty-org/ghostty/blob/4b4d4062dfed7b37424c7210d1230242c709e990/src/termio/Exec.zig#L745-L750
-    - https://github.com/ghostty-org/ghostty/blob/4b4d4062dfed7b37424c7210d1230242c709e990/src/termio/Exec.zig#L818-L834
-
-    terminfo and shell integration should also be installable on remote machines
-
-    ```nix
-    { pkgs, ... }: {
-      environment.systemPackages = [ pkgs.ghostty.terminfo ];
-
-      programs.bash = {
-        interactiveShellInit = ''
-          if [[ "$TERM" == "xterm-ghostty" ]]; then
-            builtin source ${pkgs.ghostty.shell_integration}/bash/ghostty.bash
-          fi
-        '';
-      };
-    }
-    ```
-  */
-  postFixup = ''
-    ln -s $man/share/man $out/share/man
-
-    moveToOutput share/terminfo $terminfo
-    ln -s $terminfo/share/terminfo $out/share/terminfo
-
-    mv $out/share/ghostty/shell-integration $shell_integration
-    ln -s $shell_integration $out/share/ghostty/shell-integration
-
-    mv $out/share/vim/vimfiles $vim
-    rmdir $out/share/vim
-    ln -s $vim $out/share/vim-plugins
-
-    remove-references-to -t ${finalAttrs.deps} $out/bin/.ghostty-wrapped
-  '';
-
-  nativeInstallCheckInputs = [
-    versionCheckHook
-  ];
-
-  doInstallCheck = true;
-
-  versionCheckProgramArg = [ "--version" ];
-
-  passthru = {
-    tests = lib.optionalAttrs stdenv.hostPlatform.isLinux {
-      inherit (nixosTests) allTerminfo;
-      nixos = nixosTests.terminal-emulators.ghostty;
-    };
-  };
-
-})

pkgs/by-name/gh/ghostty/package.nix

···
 {
-  stdenvNoCC,
+  lib,
+  stdenv,
+  bzip2,
   callPackage,
-  lib,
+  fetchFromGitHub,
+  fontconfig,
+  freetype,
+  glib,
+  glslang,
+  harfbuzz,
+  libGL,
+  libX11,
+  libadwaita,
+  ncurses,
+  nixosTests,
+  oniguruma,
+  pandoc,
+  pkg-config,
+  removeReferencesTo,
+  versionCheckHook,
+  wrapGAppsHook4,
+  zig_0_13,
+  # Usually you would override `zig.hook` with this, but we do that internally
+  # since upstream recommends a non-default level
+  # https://github.com/ghostty-org/ghostty/blob/4b4d4062dfed7b37424c7210d1230242c709e990/PACKAGING.md#build-options
+  optimizeLevel ? "ReleaseFast",
+  # https://github.com/ghostty-org/ghostty/blob/4b4d4062dfed7b37424c7210d1230242c709e990/build.zig#L106
+  withAdwaita ? true,
 }:
 
 let
+  zig_hook = zig_0_13.hook.overrideAttrs {
+    zig_default_flags = "-Dcpu=baseline -Doptimize=${optimizeLevel} --color off";
+  };
+
+  # https://github.com/ghostty-org/ghostty/blob/4b4d4062dfed7b37424c7210d1230242c709e990/src/apprt.zig#L72-L76
+  appRuntime = if stdenv.hostPlatform.isLinux then "gtk" else "none";
+  # https://github.com/ghostty-org/ghostty/blob/4b4d4062dfed7b37424c7210d1230242c709e990/src/font/main.zig#L94
+  fontBackend = if stdenv.hostPlatform.isDarwin then "coretext" else "fontconfig_freetype";
+  # https://github.com/ghostty-org/ghostty/blob/4b4d4062dfed7b37424c7210d1230242c709e990/src/renderer.zig#L51-L52
+  renderer = if stdenv.hostPlatform.isDarwin then "metal" else "opengl";
+in
+
+stdenv.mkDerivation (finalAttrs: {
   pname = "ghostty";
-  version = "1.0.0";
+  version = "1.0.1";
   outputs = [
     "out"
     "man"
···
     "terminfo"
     "vim"
   ];
+
+  src = fetchFromGitHub {
+    owner = "ghostty-org";
+    repo = "ghostty";
+    tag = "v${finalAttrs.version}";
+    hash = "sha256-BiXFNeoL+BYpiqzCuDIrZGQ6JVI8cBOXerJH48CbnxU=";
+  };
+
+  deps = callPackage ./deps.nix {
+    name = "${finalAttrs.pname}-cache-${finalAttrs.version}";
+  };
+
+  strictDeps = true;
+
+  nativeBuildInputs =
+    [
+      ncurses
+      pandoc
+      pkg-config
+      removeReferencesTo
+      zig_hook
+    ]
+    ++ lib.optionals (appRuntime == "gtk") [
+      glib # Required for `glib-compile-schemas`
+      wrapGAppsHook4
+    ];
+
+  buildInputs =
+    [
+      glslang
+      oniguruma
+    ]
+    ++ lib.optional (appRuntime == "gtk" && withAdwaita) libadwaita
+    ++ lib.optional (appRuntime == "gtk") libX11
+    ++ lib.optional (renderer == "opengl") libGL
+    ++ lib.optionals (fontBackend == "fontconfig_freetype") [
+      bzip2
+      fontconfig
+      freetype
+      harfbuzz
+    ];
+
+  zigBuildFlags =
+    [
+      "--system"
+      "${finalAttrs.deps}"
+      "-Dversion-string=${finalAttrs.version}"
+
+      "-Dapp-runtime=${appRuntime}"
+      "-Dfont-backend=${fontBackend}"
+      "-Dgtk-adwaita=${lib.boolToString withAdwaita}"
+      "-Drenderer=${renderer}"
+    ]
+    ++ lib.mapAttrsToList (name: package: "-fsys=${name} --search-prefix ${lib.getLib package}") {
+      inherit glslang;
+    };
+
+  zigCheckFlags = finalAttrs.zigBuildFlags;
+
+  doCheck = true;
+
+  /**
+    Ghostty really likes all of it's resources to be in the same directory, so link them back after we split them
+
+    - https://github.com/ghostty-org/ghostty/blob/4b4d4062dfed7b37424c7210d1230242c709e990/src/os/resourcesdir.zig#L11-L52
+    - https://github.com/ghostty-org/ghostty/blob/4b4d4062dfed7b37424c7210d1230242c709e990/src/termio/Exec.zig#L745-L750
+    - https://github.com/ghostty-org/ghostty/blob/4b4d4062dfed7b37424c7210d1230242c709e990/src/termio/Exec.zig#L818-L834
+
+    terminfo and shell integration should also be installable on remote machines
+
+    ```nix
+    { pkgs, ... }: {
+      environment.systemPackages = [ pkgs.ghostty.terminfo ];
+
+      programs.bash = {
+        interactiveShellInit = ''
+          if [[ "$TERM" == "xterm-ghostty" ]]; then
+            builtin source ${pkgs.ghostty.shell_integration}/bash/ghostty.bash
+          fi
+        '';
+      };
+    }
+    ```
+  */
+  postFixup = ''
+    ln -s $man/share/man $out/share/man
+
+    moveToOutput share/terminfo $terminfo
+    ln -s $terminfo/share/terminfo $out/share/terminfo
+
+    mv $out/share/ghostty/shell-integration $shell_integration
+    ln -s $shell_integration $out/share/ghostty/shell-integration
+
+    mv $out/share/vim/vimfiles $vim
+    rmdir $out/share/vim
+    ln -s $vim $out/share/vim-plugins
+
+
+    remove-references-to -t ${finalAttrs.deps} $out/bin/.ghostty-wrapped
+  '';
+
+  nativeInstallCheckInputs = [
+    versionCheckHook
+  ];
+
+  doInstallCheck = true;
+
+  versionCheckProgramArg = [ "--version" ];
+
+  passthru = {
+    tests = lib.optionalAttrs stdenv.hostPlatform.isLinux {
+      inherit (nixosTests) allTerminfo;
+      nixos = nixosTests.terminal-emulators.ghostty;
+    };
+  };
+
   meta = {
     description = "Fast, native, feature-rich terminal emulator pushing modern features";
     longDescription = ''
···
     '';
     homepage = "https://ghostty.org/";
     downloadPage = "https://ghostty.org/download";
-
+    changelog = "https://ghostty.org/docs/install/release-notes/${
+      builtins.replaceStrings [ "." ] [ "-" ] finalAttrs.version
+    }";
     license = lib.licenses.mit;
     mainProgram = "ghostty";
     maintainers = with lib.maintainers; [
       jcollie
       pluiedev
       getchoo
-      DimitarNestorov
     ];
     outputsToInstall = [
       "out"
···
       "terminfo"
     ];
     platforms = lib.platforms.linux ++ lib.platforms.darwin;
+    # Issues finding the SDK in the sandbox
+    broken = stdenv.hostPlatform.isDarwin;
   };
-in
-
-if stdenvNoCC.hostPlatform.isDarwin then
-  callPackage ./darwin.nix {
-    inherit
-      pname
-      version
-      outputs
-      meta
-      ;
-  }
-else
-  callPackage ./linux.nix {
-    inherit
-      pname
-      version
-      outputs
-      meta
-      ;
-  }
+})

pkgs/by-name/gi/gi-crystal/package.nix

···
 }:
 crystal.buildCrystalPackage rec {
   pname = "gi-crystal";
-  version = "0.22.2";
+  version = "0.24.0";
 
   src = fetchFromGitHub {
     owner = "hugopl";
     repo = "gi-crystal";
     rev = "v${version}";
-    hash = "sha256-JfBbKqobikpTGMryeO86zZ46EbOHybem+Cc5FZEL6i4=";
+    hash = "sha256-0LsYREn4zWLQYUTpNWJhLLHWmg7UQzxOoQiAMmw3ZXQ=";
   };
 
   # Make sure gi-crystal picks up the name of the so or dylib and not the leading nix store path

pkgs/by-name/gl/glib/package.nix

···
+{
+  config,
+  lib,
+  stdenv,
+  fetchurl,
+  gettext,
+  meson,
+  ninja,
+  pkg-config,
+  perl,
+  python3,
+  python3Packages,
+  libiconv,
+  zlib,
+  libffi,
+  pcre2,
+  elfutils,
+  gnome,
+  libselinux,
+  bash,
+  gnum4,
+  libxslt,
+  docutils,
+  gi-docgen,
+  # use util-linuxMinimal to avoid circular dependency (util-linux, systemd, glib)
+  util-linuxMinimal ? null,
+  buildPackages,
+
+  # this is just for tests (not in the closure of any regular package)
+  dbus,
+  tzdata,
+  desktop-file-utils,
+  shared-mime-info,
+  darwin,
+  makeHardcodeGsettingsPatch,
+  testers,
+  gobject-introspection,
+  libsystemtap,
+  libsysprof-capture,
+  mesonEmulatorHook,
+  withIntrospection ?
+    stdenv.hostPlatform.emulatorAvailable buildPackages
+    && lib.meta.availableOn stdenv.hostPlatform gobject-introspection
+    && stdenv.hostPlatform.isLittleEndian == stdenv.buildPlatform.isLittleEndian,
+}:
+
+assert stdenv.hostPlatform.isLinux -> util-linuxMinimal != null;
+
+let
+  gobject-introspection' = buildPackages.gobject-introspection.override {
+    propagateFullGlib = false;
+    # Avoid introducing cairo, which enables gobjectSupport by default.
+    x11Support = false;
+  };
+
+  librarySuffix =
+    if (stdenv.hostPlatform.extensions.library == ".so") then
+      "2.0.so.0"
+    else if (stdenv.hostPlatform.extensions.library == ".dylib") then
+      "2.0.0.dylib"
+    else if (stdenv.hostPlatform.extensions.library == ".a") then
+      "2.0.a"
+    else if (stdenv.hostPlatform.extensions.library == ".dll") then
+      "2.0-0.dll"
+    else
+      "2.0-0.lib";
+
+  systemtap' = buildPackages.linuxPackages.systemtap.override { withStap = false; };
+
+  withDtrace =
+    lib.meta.availableOn stdenv.buildPlatform systemtap'
+    &&
+      # dtrace support requires sys/sdt.h header
+      lib.meta.availableOn stdenv.hostPlatform libsystemtap;
+in
+
+stdenv.mkDerivation (finalAttrs: {
+  pname = "glib";
+  version = "2.82.4";
+
+  outputs = [
+    "bin"
+    "out"
+    "dev"
+    "devdoc"
+  ];
+
+  setupHook = ./setup-hook.sh;
+
+  src = fetchurl {
+    url = "mirror://gnome/sources/glib/${lib.versions.majorMinor finalAttrs.version}/glib-${finalAttrs.version}.tar.xz";
+    hash = "sha256-N90Id/6WTNFemicQsEShgw+xvZNlKm0Mtriy3/GHxwk=";
+  };
+
+  patches =
+    lib.optionals stdenv.hostPlatform.isDarwin [
+      ./darwin-compilation.patch
+    ]
+    ++ lib.optionals stdenv.hostPlatform.isMusl [
+      ./quark_init_on_demand.patch
+      ./gobject_init_on_demand.patch
+    ]
+    ++ [
+      # This patch lets GLib's GDesktopAppInfo API watch and notice changes
+      # to the Nix user and system profiles.  That way, the list of available
+      # applications shown by the desktop environment is immediately updated
+      # when the user installs or removes any
+      # (see <https://issues.guix.gnu.org/35594>).
+
+      # It does so by monitoring /nix/var/nix/profiles (for changes to the system
+      # profile) and /nix/var/nix/profiles/per-user/USER (for changes to the user
+      # profile) as well as /etc/profiles/per-user (for chanes to the user
+      # environment profile) and crawling their share/applications sub-directory when
+      # changes happen.
+      ./glib-appinfo-watch.patch
+
+      ./schema-override-variable.patch
+
+      # Add support for Pantheon’s terminal emulator.
+      ./elementary-terminal-support.patch
+
+      # GLib contains many binaries used for different purposes;
+      # we will install them to different outputs:
+      # 1. Tools for desktop environment and introspection ($bin)
+      #    * gapplication (non-darwin)
+      #    * gdbus
+      #    * gi-compile-repository
+      #    * gi-decompile-typelib
+      #    * gi-inspect-typelib
+      #    * gio
+      #    * gio-launch-desktop (symlink to $out)
+      #    * gsettings
+      # 2. Development/build tools ($dev)
+      #    * gdbus-codegen
+      #    * gio-querymodules
+      #    * glib-compile-resources
+      #    * glib-compile-schemas
+      #    * glib-genmarshal
+      #    * glib-gettextize
+      #    * glib-mkenums
+      #    * gobject-query
+      #    * gresource
+      #    * gtester
+      #    * gtester-report
+      # 3. Tools for desktop environment that cannot go to $bin due to $out depending on them ($out)
+      #    * gio-launch-desktop
+      ./split-dev-programs.patch
+
+      # Tell Meson to install gdb scripts next to the lib
+      # GDB only looks there and in ${gdb}/share/gdb/auto-load,
+      # and by default meson installs in to $out/share/gdb/auto-load
+      # which does not help
+      ./gdb_script.patch
+    ];
+
+  strictDeps = true;
+
+  buildInputs =
+    [
+      finalAttrs.setupHook
+    ]
+    ++ lib.optionals (!stdenv.hostPlatform.isFreeBSD) [
+      libsysprof-capture
+    ]
+    ++ [
+      pcre2
+    ]
+    ++ lib.optionals (!stdenv.hostPlatform.isWindows) [
+      bash
+      gnum4 # install glib-gettextize and m4 macros for other apps to use
+    ]
+    ++ lib.optionals (lib.meta.availableOn stdenv.hostPlatform elfutils) [
+      elfutils
+    ]
+    ++ lib.optionals withDtrace [
+      libsystemtap
+    ]
+    ++ lib.optionals stdenv.hostPlatform.isLinux [
+      libselinux
+      util-linuxMinimal # for libmount
+    ]
+    ++ lib.optionals stdenv.hostPlatform.isDarwin (
+      with darwin.apple_sdk.frameworks;
+      [
+        AppKit
+        Carbon
+        Cocoa
+        CoreFoundation
+        CoreServices
+        Foundation
+      ]
+    );
+
+  depsBuildBuild = [
+    pkg-config # required to find native gi-docgen
+  ];
+
+  nativeBuildInputs =
+    [
+      docutils # for rst2man, rst2html5
+      meson
+      ninja
+      pkg-config
+      perl
+      python3
+      python3Packages.packaging # mostly used to make meson happy
+      python3Packages.wrapPython # for patchPythonScript
+      gettext
+      libxslt
+    ]
+    ++ lib.optionals withIntrospection [
+      gi-docgen
+      gobject-introspection'
+    ]
+    ++ lib.optionals (withIntrospection && !stdenv.buildPlatform.canExecute stdenv.hostPlatform) [
+      mesonEmulatorHook
+    ]
+    ++ lib.optionals withDtrace [
+      systemtap' # for dtrace
+    ];
+
+  propagatedBuildInputs = [
+    zlib
+    libffi
+    gettext
+    libiconv
+  ];
+
+  nativeCheckInputs = [
+    tzdata
+    desktop-file-utils
+    shared-mime-info
+  ];
+
+  mesonFlags =
+    [
+      "-Dglib_debug=disabled" # https://gitlab.gnome.org/GNOME/glib/-/issues/3421#note_2206315
+      "-Ddocumentation=true" # gvariant specification can be built without gi-docgen
+      (lib.mesonEnable "dtrace" withDtrace)
+      (lib.mesonEnable "systemtap" withDtrace) # requires dtrace option to be enabled
+      "-Dnls=enabled"
+      "-Ddevbindir=${placeholder "dev"}/bin"
+      (lib.mesonEnable "introspection" withIntrospection)
+      # FIXME: Fails when linking target glib/tests/libconstructor-helper.so
+      # relocation R_X86_64_32 against hidden symbol `__TMC_END__' can not be used when making a shared object
+      "-Dtests=${lib.boolToString (!stdenv.hostPlatform.isStatic)}"
+    ]
+    ++ lib.optionals (!lib.meta.availableOn stdenv.hostPlatform elfutils) [
+      "-Dlibelf=disabled"
+    ]
+    ++ lib.optionals stdenv.hostPlatform.isFreeBSD [
+      "-Db_lundef=false"
+      "-Dxattr=false"
+      "-Dsysprof=disabled" # sysprof-capture does not build on FreeBSD
+    ];
+
+  env = {
+    NIX_CFLAGS_COMPILE = toString [
+      "-Wno-error=nonnull"
+      # Default for release buildtype but passed manually because
+      # we're using plain
+      "-DG_DISABLE_CAST_CHECKS"
+    ];
+  };
+
+  postPatch =
+    ''
+      patchShebangs glib/gen-unicode-tables.pl
+      patchShebangs glib/tests/gen-casefold-txt.py
+      patchShebangs glib/tests/gen-casemap-txt.py
+      patchShebangs tools/gen-visibility-macros.py
+      patchShebangs tests
+
+      # Needs machine-id, comment the test
+      sed -e '/\/gdbus\/codegen-peer-to-peer/ s/^\/*/\/\//' -i gio/tests/gdbus-peer.c
+      sed -e '/g_test_add_func/ s/^\/*/\/\//' -i gio/tests/gdbus-address-get-session.c
+      # All gschemas fail to pass the test, upstream bug?
+      sed -e '/g_test_add_data_func/ s/^\/*/\/\//' -i gio/tests/gschema-compile.c
+      # Cannot reproduce the failing test_associations on hydra
+      sed -e '/\/appinfo\/associations/d' -i gio/tests/appinfo.c
+      # Needed because of libtool wrappers
+      sed -e '/g_subprocess_launcher_set_environ (launcher, envp);/a g_subprocess_launcher_setenv (launcher, "PATH", g_getenv("PATH"), TRUE);' -i gio/tests/gsubprocess.c
+    ''
+    + lib.optionalString stdenv.hostPlatform.isWindows ''
+      substituteInPlace gio/win32/meson.build \
+        --replace "libintl, " ""
+    '';
+
+  postConfigure = ''
+    patchShebangs gio/gdbus-2.0/codegen/gdbus-codegen gobject/glib-{genmarshal,mkenums}
+  '';
+
+  DETERMINISTIC_BUILD = 1;
+
+  postInstall = ''
+    moveToOutput "share/glib-2.0" "$dev"
+    moveToOutput "share/glib-2.0/gdb" "$out"
+    substituteInPlace "$dev/bin/gdbus-codegen" --replace "$out" "$dev"
+    sed -i "$dev/bin/glib-gettextize" -e "s|^gettext_dir=.*|gettext_dir=$dev/share/glib-2.0/gettext|"
+
+    # This file is *included* in gtk3 and would introduce runtime reference via __FILE__.
+    sed '1i#line 1 "glib-${finalAttrs.version}/include/glib-2.0/gobject/gobjectnotifyqueue.c"' \
+      -i "$dev"/include/glib-2.0/gobject/gobjectnotifyqueue.c
+    for i in $bin/bin/*; do
+      moveToOutput "share/bash-completion/completions/''${i##*/}" "$bin"
+    done
+    for i in $dev/bin/*; do
+      moveToOutput "share/bash-completion/completions/''${i##*/}" "$dev"
+    done
+  '';
+
+  preFixup = lib.optionalString (!stdenv.hostPlatform.isStatic) ''
+    buildPythonPath ${python3Packages.packaging}
+    patchPythonScript "$dev/share/glib-2.0/codegen/utils.py"
+  '';
+
+  # Move man pages to the same output as their binaries (needs to be
+  # done after preFixupHooks which moves man pages too - in
+  # _multioutDocs)
+  postFixup = ''
+    for i in $dev/bin/*; do
+      moveToOutput "share/man/man1/''${i##*/}.1.*" "$dev"
+    done
+
+    # Cannot be in postInstall, otherwise _multioutDocs hook in preFixup will move right back.
+    moveToOutput "share/doc" "$devdoc"
+  '';
+
+  # Conditional necessary to break infinite recursion with passthru.tests
+  preCheck = lib.optionalString finalAttrs.finalPackage.doCheck or config.doCheckByDefault or false ''
+    export LD_LIBRARY_PATH="$NIX_BUILD_TOP/glib-${finalAttrs.version}/glib/.libs''${LD_LIBRARY_PATH:+:}$LD_LIBRARY_PATH"
+    export TZDIR="${tzdata}/share/zoneinfo"
+    export XDG_CACHE_HOME="$TMP"
+    export XDG_RUNTIME_HOME="$TMP"
+    export HOME="$TMP"
+    export XDG_DATA_DIRS="${desktop-file-utils}/share:${shared-mime-info}/share"
+    export G_TEST_DBUS_DAEMON="${dbus}/bin/dbus-daemon"
+
+    # pkg_config_tests expects a PKG_CONFIG_PATH that points to meson-private, wrapped pkg-config
+    # tries to be clever and picks up the wrong glib at the end.
+    export PATH="${buildPackages.pkg-config-unwrapped}/bin:$PATH:$(pwd)/gobject"
+    echo "PATH=$PATH"
+
+    # Our gobject-introspection patches make the shared library paths absolute
+    # in the GIR files. When running tests, the library is not yet installed,
+    # though, so we need to replace the absolute path with a local one during build.
+    # We are using a symlink that we will delete before installation.
+    mkdir -p $out/lib
+    ln -s $PWD/gobject/libgobject-${librarySuffix} $out/lib/libgobject-${librarySuffix}
+    ln -s $PWD/gio/libgio-${librarySuffix} $out/lib/libgio-${librarySuffix}
+    ln -s $PWD/glib/libglib-${librarySuffix} $out/lib/libglib-${librarySuffix}
+  '';
+
+  postCheck = ''
+    rm $out/lib/libgobject-${librarySuffix}
+    rm $out/lib/libgio-${librarySuffix}
+    rm $out/lib/libglib-${librarySuffix}
+  '';
+
+  separateDebugInfo = stdenv.hostPlatform.isLinux;
+
+  passthru = rec {
+    gioModuleDir = "lib/gio/modules";
+
+    makeSchemaDataDirPath = dir: name: "${dir}/share/gsettings-schemas/${name}";
+    makeSchemaPath = dir: name: "${makeSchemaDataDirPath dir name}/glib-2.0/schemas";
+    getSchemaPath = pkg: makeSchemaPath pkg pkg.name;
+    getSchemaDataDirPath = pkg: makeSchemaDataDirPath pkg pkg.name;
+
+    tests = {
+      withChecks = finalAttrs.finalPackage.overrideAttrs (_: {
+        doCheck = true;
+      });
+      pkg-config = testers.testMetaPkgConfig finalAttrs.finalPackage;
+    };
+
+    updateScript = gnome.updateScript {
+      packageName = "glib";
+      versionPolicy = "odd-unstable";
+    };
+
+    mkHardcodeGsettingsPatch =
+      {
+        src,
+        glib-schema-to-var,
+      }:
+      builtins.trace
+        "glib.mkHardcodeGsettingsPatch is deprecated, please use makeHardcodeGsettingsPatch instead"
+        (makeHardcodeGsettingsPatch {
+          inherit src;
+          schemaIdToVariableMapping = glib-schema-to-var;
+        });
+  };
+
+  meta = with lib; {
+    description = "C library of programming buildings blocks";
+    homepage = "https://gitlab.gnome.org/GNOME/glib";
+    license = licenses.lgpl21Plus;
+    maintainers =
+      teams.gnome.members
+      ++ (with maintainers; [
+        lovek323
+        raskin
+      ]);
+    pkgConfigModules = [
+      "gio-2.0"
+      "gobject-2.0"
+      "gthread-2.0"
+    ];
+    platforms = platforms.unix ++ platforms.windows;
+
+    longDescription = ''
+      GLib provides the core application building blocks for libraries
+      and applications written in C.  It provides the core object
+      system used in GNOME, the main loop implementation, and a large
+      set of utility functions for strings and common data structures.
+    '';
+  };
+})

pkgs/by-name/gr/grml-zsh-config/package.nix

···
 { stdenv, fetchFromGitHub, lib, zsh, coreutils, inetutils, procps, txt2tags }:
 stdenv.mkDerivation rec {
   pname = "grml-zsh-config";
-  version = "0.19.8";
+  version = "0.19.11";
 
   src = fetchFromGitHub {
     owner = "grml";
     repo = "grml-etc-core";
     rev = "v${version}";
-    sha256 = "sha256-Tx9u0mH3hFYmyKGAmI5lLxrau/tmE9/BaU43gSr7iFw=";
+    sha256 = "sha256-plVyzuVFw7wxFlhfCCjZe2QqkytTgUvsxrIdB7nv66g=";
   };
 
   strictDeps = true;

pkgs/by-name/hy/hyprutils/package.nix

···
 
 stdenv.mkDerivation (finalAttrs: {
   pname = "hyprutils";
-  version = "0.2.6";
+  version = "0.3.0";
 
   src = fetchFromGitHub {
     owner = "hyprwm";
     repo = "hyprutils";
     rev = "refs/tags/v${finalAttrs.version}";
-    hash = "sha256-+JeO9gevnXannQxMfR5xzZtF4sYmSlWkX/BPmPx0mWk=";
+    hash = "sha256-5Wvsn+0/Hu6eUUToK9hBWwRlbg1i++lc9or4yPYBUuk=";
   };
 
   nativeBuildInputs = [

pkgs/by-name/in/intentrace/package.nix

···
 }:
 
 let
-  version = "0.4.1";
+  version = "0.4.2";
 in
 rustPlatform.buildRustPackage {
   inherit version;
···
     owner = "sectordistrict";
     repo = "intentrace";
     rev = "refs/tags/v${version}";
-    hash = "sha256-9BlCDtWnBDJuo6ovDi347jAQSOG8LizJAyQ/xN+HJ0w=";
+    hash = "sha256-ZcGZK4GX78ls3nHb7SBKszmZXMAbCxS4osW3MLqgnHQ=";
   };
 
-  cargoHash = "sha256-eJlAQpkI+RgfpDJGP9evWH28nU891PF4jeRpf2Os4Ts=";
+  cargoHash = "sha256-LkLSPFCfQxBb5DJZ67I7xPxzIYqTzKccyLW0S65/MLU=";
 
   meta = {
     description = "Prettified Linux syscall tracing tool (like strace)";

pkgs/by-name/ku/kube-bench/package.nix

···
 
 buildGoModule rec {
   pname = "kube-bench";
-  version = "0.9.3";
+  version = "0.9.4";
 
   src = fetchFromGitHub {
     owner = "aquasecurity";
     repo = pname;
     rev = "refs/tags/v${version}";
-    hash = "sha256-i0iSIK3nJ83bCuxIVxLBjJbBCpTU5TavmX2DTEJzG+Q=";
+    hash = "sha256-SkXf8zZif1l+yOSUjYpW474gYOmxifaLtj/DNK+ZNfg=";
   };
 
-  vendorHash = "sha256-c4+ruUR52TcjI+Xvuv9Xt8GAyjpbEvJhqDqWSRgVGWI=";
+  vendorHash = "sha256-6ApPEt9SkPI5yu3ejzR1AU1ZCHmltp8Cxso6j//pEAk=";
 
   nativeBuildInputs = [ installShellFiles ];
 

pkgs/by-name/li/libserdes/package.nix

···
   fetchFromGitHub,
   perl,
   which,
-  boost,
   rdkafka,
   jansson,
   curl,
···
   ];
 
   buildInputs = [
-    boost
     rdkafka
     jansson
     curl
···
     avro-cpp
   ];
 
-  makeFlags = [ "GEN_PKG_CONFIG=y" ];
+  configureFlags = [
+    # avro-cpp public headers use at least C++17 features, but libserdes configure scripts
+    # basically cap it at C++11. It's really unfortunate that we have to patch the configure scripts for this,
+    # but this seems to be the most sensible way.
+    # - NIX_CFLAGS_COMPILE - fails because of -Werror in compiler checks since --std=... has no effect for C compilers.
+    # - CXXFLAGS without patching configure.self does nothing, because --std=c++11 is appended to the final flags, overriding
+    #   everything specified manually.
+    "--CXXFLAGS=${toString [ "--std=c++17" ]}"
+  ];
+
+  makeFlags = [
+    "GEN_PKG_CONFIG=y"
+  ];
 
   postPatch = ''
     patchShebangs configure lds-gen.pl
+    # Don't append the standard to CXXFLAGS, since we want to set it higher for avro-cpp.
+    substituteInPlace configure.self --replace-fail \
+      'mkl_mkvar_append CXXFLAGS CXXFLAGS "--std=c++11"' \
+      ":" # Do nothing, we set the standard ourselves.
   '';
 
   # Has a configure script but it’s not Autoconf so steal some bits from multiple-outputs.sh:

pkgs/by-name/lt/ltex-ls-plus/package.nix

···
 
 stdenvNoCC.mkDerivation rec {
   pname = "ltex-ls-plus";
-  version = "18.3.0";
+  version = "18.4.0";
 
   src = fetchurl {
     url = "https://github.com/ltex-plus/ltex-ls-plus/releases/download/${version}/ltex-ls-plus-${version}.tar.gz";
-    sha256 = "sha256-TV8z8nYz2lFsL86yxpIWDh3hDEZn/7P0kax498oicls=";
+    sha256 = "sha256-BkVPLtyF62keDDEnET8zF7g0FqDz6UkDWI6BM8W2qMQ=";
   };
 
   nativeBuildInputs = [ makeBinaryWrapper ];

pkgs/by-name/ma/mani/package.nix

···
 
 buildGoModule rec {
   pname = "mani";
-  version = "0.25.0";
+  version = "0.30.0";
 
   src = fetchFromGitHub {
     owner = "alajmo";
     repo = "mani";
     rev = "v${version}";
-    sha256 = "sha256-TqxoU2g4ZegJGHrnNO+ivPu209NDFcLnxpHGj8pOA4E=";
+    sha256 = "sha256-LxW9LPK4cXIXhBWPhOYWLeV5PIf+o710SWX8JVpZhPI=";
   };
 
-  vendorHash = "sha256-mFan09oJ+BPVJHAxoROj282WJ+4e7TD0ZqeQH1kDabQ=";
+  vendorHash = "sha256-8ckflry+KsEu+QgqjocXg6yyfS9R7fCfCMXwUqUSlhE=";
 
   nativeBuildInputs = [
     installShellFiles

pkgs/by-name/mi/micronaut/package.nix

···
 
 stdenv.mkDerivation rec {
   pname = "micronaut";
-  version = "4.7.2";
+  version = "4.7.3";
 
   src = fetchzip {
     url = "https://github.com/micronaut-projects/micronaut-starter/releases/download/v${version}/micronaut-cli-${version}.zip";
-    sha256 = "sha256-oyLJ3PGXT7/PDtXiPl0vX/jhaaYavwtoxuFPRLdGV8w=";
+    sha256 = "sha256-rCGJnZ+WD0chYVa6XqkhHJqJUQKw2K+AebzYSftAsOk=";
   };
 
   nativeBuildInputs = [

pkgs/by-name/ns/nsc/package.nix

···
 
 buildGoModule rec {
   pname = "nsc";
-  version = "2.10.1";
+  version = "2.10.2";
 
   src = fetchFromGitHub {
     owner = "nats-io";
     repo = pname;
     rev = "v${version}";
-    hash = "sha256-8HFlWrkDgekW/0IV9LQdn68vygFq0QtR6p4xyJZwAw4=";
+    hash = "sha256-F/9yAF1vXG4eWMmS6l/qWqlEV8YkS7nihHN2vK3JFbE=";
   };
 
   ldflags = [
···
   # the test strips table formatting from the command output in a naive way
   # that removes all the table characters, including '-'.
   # The nix build directory looks something like:
-  # /private/tmp/nix-build-nsc-2.10.1.drv-0/nsc_test2000598938/keys
+  # /private/tmp/nix-build-nsc-2.10.2.drv-0/nsc_test2000598938/keys
   # Then the `-` are removed from the path unintentionally and the test fails.
   # This should be fixed upstream to avoid mangling the path when
   # removing the table decorations from the command output.

pkgs/by-name/op/open-in-mpv/package.nix

···
 
 buildGoModule rec {
   pname = "open-in-mpv";
-  version = "2.4.0";
+  version = "2.4.2";
 
   src = fetchFromGitHub {
     owner = "Baldomo";
     repo = "open-in-mpv";
     rev = "v${version}";
-    hash = "sha256-EkWz28X+pPfSjinYEMP2y1YiZ46HdnjRGjXRDwO28PY=";
+    hash = "sha256-5Hu/BXUMI8CSOvE09I0YXfQ6BuIRA37yLlSTqWrrqy0=";
   };
 
   vendorHash = "sha256-G6GZO2+CfEAYcf7zBcqDa808A0eJjM8dq7+4VGZ+P4c=";

pkgs/by-name/pl/plumber/package.nix

···
 
 buildGoModule rec {
   pname = "plumber";
-  version = "2.8.0";
+  version = "2.9.0";
 
   src = fetchFromGitHub {
     owner = "streamdal";
     repo = pname;
     rev = "v${version}";
-    hash = "sha256-38tLlFeQtXIiHuQa9c/IfIYbyf+GrOsERAdWQnHSeck=";
+    hash = "sha256-0pyeCTkmS7gG51Xm4Gc62p+I5DRUA2F9tPHaZjO+/WE=";
   };
 
   vendorHash = null;

pkgs/by-name/pl/pluto/package.nix

···
 
 buildGoModule rec {
   pname = "pluto";
-  version = "5.20.3";
+  version = "5.21.0";
 
   src = fetchFromGitHub {
     owner = "FairwindsOps";
     repo = "pluto";
     rev = "v${version}";
-    hash = "sha256-WbXIg453VewOejX/hyGi1DEi0cSwcQ+hKUFG8Ne4cPE=";
+    hash = "sha256-jz1hne6Lwow1a2Ckfp4C1/gD57V2kYFdik9DQ/EkjLI=";
   };
 
   vendorHash = "sha256-VkaFANSzKOpmHWUwFp7YjwvsJegcJOrvJOBNNAIxOak=";

pkgs/by-name/pu/purescm/README.rst

···
 To update this package
 ======================
 
-#. Bump the ``./package.json`` version pin
-#. Run ``nix-shell -p nodejs --command "npm i --package-lock-only"``
+#. Bump the ``./manifests/package.json`` version pin
+#. Run ``(cd manifests && nix-shell -p nodejs --command "npm i --package-lock-only")``
 #. Update ``npmDeps.hash`` in the ``package.nix``

pkgs/by-name/pu/purescm/package.nix

···
 let
   inherit (lib) fileset;
 
-  packageLock = builtins.fromJSON (builtins.readFile ./package-lock.json);
+  packageLock = builtins.fromJSON (builtins.readFile ./manifests/package-lock.json);
 
   pname = "purescm";
   version = packageLock.packages."node_modules/${pname}".version;
···
   package = buildNpmPackage {
     inherit pname version;
 
-    src = fileset.toSource {
-      root = ./.;
-      fileset = fileset.unions [
-        ./package.json
-        ./package-lock.json
-        ./.gitignore
-      ];
-    };
+    src = ./manifests;
     dontNpmBuild = true;
 
     npmDeps = fetchNpmDeps {
-      src = fileset.toSource {
-        root = ./.;
-        fileset = fileset.unions [
-          ./package-lock.json
-          ./package.json
-        ];
-      };
+      src = ./manifests;
       hash = "sha256-ljeFcLvIET77Q0OR6O5Ok1fGnaxaKaoywpcy2aHq/6o=";
     };
 

pkgs/by-name/qb/qbittorrent-enhanced/package.nix

···
 
 (qbittorrent.override { inherit guiSupport; }).overrideAttrs (old: rec {
   pname = "qbittorrent-enhanced" + lib.optionalString (!guiSupport) "-nox";
-  version = "5.0.2.10";
+  version = "5.0.3.10";
 
   src = fetchFromGitHub {
     owner = "c0re100";
     repo = "qBittorrent-Enhanced-Edition";
     rev = "release-${version}";
-    hash = "sha256-9RCG530zWQ+qzP0Y+y69NFlBWVA8GT29dY8aC1cvq7o=";
+    hash = "sha256-efQFjdJeVMrPvCQ5aYtUb65hozKc73MnP0/Kheti9BI=";
   };
 
   meta = old.meta // {

pkgs/by-name/qo/qownnotes/package.nix

···
+{
+  lib,
+  stdenv,
+  fetchurl,
+  qt6Packages,
+  cmake,
+  makeWrapper,
+  botan2,
+  pkg-config,
+  nixosTests,
+  installShellFiles,
+  xvfb-run,
+}:
+
+let
+  pname = "qownnotes";
+  appname = "QOwnNotes";
+  version = "24.12.7";
+in
+qt6Packages.stdenv.mkDerivation {
+  inherit pname version;
+
+  src = fetchurl {
+    url = "https://github.com/pbek/QOwnNotes/releases/download/v${version}/qownnotes-${version}.tar.xz";
+    hash = "sha256-48puEyScG6EIrsXZpFc62dl4a23p+TO2buzuwq9m3Sw=";
+  };
+
+  nativeBuildInputs =
+    [
+      cmake
+      qt6Packages.qttools
+      qt6Packages.wrapQtAppsHook
+      pkg-config
+      installShellFiles
+    ]
+    ++ lib.optionals stdenv.hostPlatform.isLinux [ xvfb-run ]
+    ++ lib.optionals stdenv.hostPlatform.isDarwin [ makeWrapper ];
+
+  buildInputs = [
+    qt6Packages.qtbase
+    qt6Packages.qtdeclarative
+    qt6Packages.qtsvg
+    qt6Packages.qtwebsockets
+    botan2
+  ] ++ lib.optionals stdenv.hostPlatform.isLinux [ qt6Packages.qtwayland ];
+
+  cmakeFlags = [
+    "-DQON_QT6_BUILD=ON"
+    "-DBUILD_WITH_SYSTEM_BOTAN=ON"
+  ];
+
+  # Install shell completion on Linux (with xvfb-run)
+  postInstall =
+    lib.optionalString stdenv.hostPlatform.isLinux ''
+      installShellCompletion --cmd ${appname} \
+        --bash <(xvfb-run $out/bin/${appname} --completion bash) \
+        --fish <(xvfb-run $out/bin/${appname} --completion fish)
+      installShellCompletion --cmd ${pname} \
+        --bash <(xvfb-run $out/bin/${appname} --completion bash) \
+        --fish <(xvfb-run $out/bin/${appname} --completion fish)
+    ''
+    # Install shell completion on macOS
+    + lib.optionalString stdenv.isDarwin ''
+      installShellCompletion --cmd ${pname} \
+        --bash <($out/bin/${appname} --completion bash) \
+        --fish <($out/bin/${appname} --completion fish)
+    ''
+    # Create a lowercase symlink for Linux
+    + lib.optionalString stdenv.hostPlatform.isLinux ''
+      ln -s $out/bin/${appname} $out/bin/${pname}
+    ''
+    # Rename application for macOS as lowercase binary
+    + lib.optionalString stdenv.hostPlatform.isDarwin ''
+      # Prevent "same file" error
+      mv $out/bin/${appname} $out/bin/${pname}.bin
+      mv $out/bin/${pname}.bin $out/bin/${pname}
+    '';
+
+  # Tests QOwnNotes using the NixOS module by launching xterm:
+  passthru.tests.basic-nixos-module-functionality = nixosTests.qownnotes;
+
+  meta = with lib; {
+    description = "Plain-text file notepad and todo-list manager with markdown support and Nextcloud/ownCloud integration";
+    homepage = "https://www.qownnotes.org/";
+    changelog = "https://www.qownnotes.org/changelog.html";
+    downloadPage = "https://github.com/pbek/QOwnNotes/releases/tag/v${version}";
+    license = licenses.gpl2Only;
+    maintainers = with maintainers; [
+      pbek
+      totoroot
+    ];
+    platforms = platforms.unix;
+  };
+}

pkgs/by-name/qu/quarkus/package.nix

···
 
 stdenv.mkDerivation (finalAttrs: {
   pname = "quarkus-cli";
-  version = "3.17.3";
+  version = "3.17.5";
 
   src = fetchurl {
     url = "https://github.com/quarkusio/quarkus/releases/download/${finalAttrs.version}/quarkus-cli-${finalAttrs.version}.tar.gz";
-    hash = "sha256-Nm0tu4YYjD1NH4n0qV1YZl7ZXfN5jccFV6EPn5mPu+8=";
+    hash = "sha256-EFSL1FDbpZ7uue+MHeeKp+2+Hp4Hi7lCOIBww4/k9yE=";
   };
 
   nativeBuildInputs = [ makeWrapper ];

pkgs/by-name/se/sendme/package.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "sendme";
-  version = "0.20.0";
+  version = "0.21.0";
 
   src = fetchFromGitHub {
     owner = "n0-computer";
     repo = pname;
     rev = "v${version}";
-    hash = "sha256-wnQ2NO+s6HumdxpO/qS/UeVdHgk9MvE6jpiSiBO0EIg=";
+    hash = "sha256-t6861ct4zGqm4MuQGVIyGUlRY+ZhojKpbCYbip6Uoec=";
   };
 
-  cargoHash = "sha256-5H/AQBPNSE5J+NQsSFn0z9dfG0ssxungpFJR220scgY=";
+  cargoHash = "sha256-nYdJbuBwW66uZs3gK05cRlQni0vT3BNlohaysYmddhQ=";
 
   buildInputs = lib.optionals stdenv.hostPlatform.isDarwin (
     with darwin.apple_sdk.frameworks;

pkgs/by-name/sh/shopify-cli/package.nix

···
   pname = "shopify";
   version = version;
 
-  src = lib.fileset.toSource {
-    root = ./.;
-    fileset = with lib.fileset; unions [
-      ./package.json
-      ./package-lock.json
-    ];
-  };
+  src = ./manifests;
 
   npmDepsHash = "sha256-QhbOKOs/0GEOeySG4uROzgtD4o7C+6tS/TAaPcmC3xk=";
   dontNpmBuild = true;

pkgs/by-name/sh/shopify-cli/update.sh

···
     exit 0
 fi
 
+pushd manifests
+
 # Update the package.json
 sed -i "s|$UPDATE_NIX_OLD_VERSION|$version|g" package.json
 
···
 rm -f package-lock.json
 npm i --package-lock-only
 npm_hash=$(prefetch-npm-deps package-lock.json)
+
+popd
+
 sed -i "s|npmDepsHash = \".*\";|npmDepsHash = \"$npm_hash\";|" package.nix
 
 popd

pkgs/by-name/si/simple64-netplay-server/package.nix

···
 
 buildGoModule rec {
   pname = "simple64-netplay-server";
-  version = "2024.10.1";
+  version = "2024.12.2";
 
   src = fetchFromGitHub {
     owner = "simple64";
     repo = "simple64-netplay-server";
     rev = "refs/tags/v${version}";
-    hash = "sha256-p9hHVf1LD95w280ScUkxHKmBJLJ9eiH3WEYV+kaALgQ=";
+    hash = "sha256-B0elTjklyXGpBAoqPN1HHeC9FIXsggKNKiDVvl8xgeU=";
   };
 
-  vendorHash = "sha256-HeYA/nR0NuP/fPMJXGGuN2eP6vB4yj1yWFfFDyp34QE=";
+  vendorHash = "sha256-1gySXbp1N0lnWToVQU3N9zQxl9Z0e9ICCeAIKwSoxaY=";
 
   meta = {
     description = "Dedicated server for simple64 netplay";

pkgs/by-name/si/simple64/package.nix

···
 in
 stdenv.mkDerivation (finalAttrs: {
   pname = "simple64";
-  version = "2024.11.1";
+  version = "2024.12.1";
 
   src = fetchFromGitHub {
     owner = "simple64";
     repo = "simple64";
     rev = "refs/tags/v${finalAttrs.version}";
-    hash = "sha256-wWBW+iYPY+5C3pvyyFYb4iIK8GlAyCbaAzr2Q5RL+n8=";
+    hash = "sha256-rvoUyvhpbibXbAreu6twTeeVRTCbhJiJuyKaJz0uT5k=";
   };
 
   patches = [

pkgs/by-name/si/simplex-chat-desktop/package.nix

···
 
 let
   pname = "simplex-chat-desktop";
-  version = "6.2.1";
+  version = "6.2.3";
 
   src = fetchurl {
     url = "https://github.com/simplex-chat/simplex-chat/releases/download/v${version}/simplex-desktop-x86_64.AppImage";
-    hash = "sha256-JEe4dmbb/T2A4+t1ycvgJofes2CkEphytFMnWJgpZ7s=";
+    hash = "sha256-yS3KnR9JLUEwtV8e2J5l4WW+XNHWg7PDOKtlfT/zfUE=";
   };
 
   appimageContents = appimageTools.extract {

pkgs/by-name/sp/spring-boot-cli/package.nix

···
 
 stdenv.mkDerivation (finalAttrs: {
   pname = "spring-boot-cli";
-  version = "3.4.0";
+  version = "3.4.1";
 
   src = fetchzip {
     url = "mirror://maven/org/springframework/boot/spring-boot-cli/${finalAttrs.version}/spring-boot-cli-${finalAttrs.version}-bin.zip";
-    hash = "sha256-jmqmWlp40DE/CWzPEMfApb3OTDDb0upcePCHj1+yTs4=";
+    hash = "sha256-XJGopVQclKVfVXNlHj9LXu8Kt3hcfsajH5p63k6nQ94=";
   };
 
   nativeBuildInputs = [

pkgs/by-name/ta/taproot-assets/package.nix

···
 
 buildGoModule rec {
   pname = "taproot-assets";
-  version = "0.4.1";
+  version = "0.5.0";
 
   src = fetchFromGitHub {
     owner = "lightninglabs";
     repo = "taproot-assets";
     rev = "v${version}";
-    hash = "sha256-aQYVPSDudLK4ZBcBN/wNjVoF/9inOaJRbcyTP6VMdA0=";
+    hash = "sha256-XOEbrz0kFJKoYG91VUeSAuMVJRfGRNTQ8jucMtnvxJo=";
   };
 
-  vendorHash = "sha256-IFzYW5vAtBoUC2ebFYnxS/TojQR4kXxQACNbyn2ZkCs=";
+  vendorHash = "sha256-hDmRyWSf4jokomfJQBLlIbm9I3v2/sg/xD52BW3Wvy4=";
 
   subPackages = [
     "cmd/tapcli"

pkgs/by-name/te/termscp/package.nix

···
     ++ lib.optionals stdenvNoCC.hostPlatform.isDarwin [
       "--skip=system::watcher::test::should_poll_file_removed"
       "--skip=system::watcher::test::should_poll_file_update"
+      "--skip=system::watcher::test::should_poll_nothing"
     ];
 
   passthru = {

pkgs/by-name/te/terraform-ls/package.nix

···
 
 buildGoModule rec {
   pname = "terraform-ls";
-  version = "0.36.2";
+  version = "0.36.3";
 
   src = fetchFromGitHub {
     owner = "hashicorp";
     repo = pname;
     rev = "v${version}";
-    hash = "sha256-XihFvQZQ+cJrFd9ly9mDVcXUDBXwndd796bterxaaAQ=";
+    hash = "sha256-bn4eDAR3fYioT2kB7Hp0zP1190FMFAJ1L5lYFUUwhWk=";
   };
 
-  vendorHash = "sha256-/ZlWx8/6eJfoiCl6yOtotoju2LVPP6YHqjk+5WE7jzQ=";
+  vendorHash = "sha256-Qx18IisnEt0xr6Mb0nxjRp+ORu5xbmSJKrRCgRJFlbc=";
 
   ldflags = [
     "-s"

pkgs/by-name/te/tex-fmt/package.nix

···
   lib,
   fetchFromGitHub,
   rustPlatform,
+  installShellFiles,
 }:
 
 rustPlatform.buildRustPackage rec {
   pname = "tex-fmt";
-  version = "0.4.7";
+  version = "0.5.1";
 
   src = fetchFromGitHub {
     owner = "WGUNDERWOOD";
     repo = "tex-fmt";
     rev = "refs/tags/v${version}";
-    hash = "sha256-jVrd3yZ07+ppsdt+8sNKX1rdmU+UiRCyx80EMXdoK54=";
+    hash = "sha256-LeoV500tnvnvl869NXi4b4LpBvX1FclYJzYAcC0QVRo=";
   };
 
-  cargoHash = "sha256-XQ1oEF+axp8pC6OkLlab1qI7RJeAyeSb58oChgaaS1s=";
+  cargoHash = "sha256-jjBPGrdCJ3zk/kuIImEXkZTI5+492yekt5+iNyYhHGM=";
+
+  nativeBuildInputs = [ installShellFiles ];
+
+  postInstall = ''
+    installManPage man/tex-fmt.1
+    installShellCompletion \
+      --bash completion/tex-fmt.bash \
+      --fish completion/tex-fmt.fish \
+      --zsh completion/_tex-fmt
+  '';
 
   meta = {
     description = "LaTeX formatter written in Rust";
     homepage = "https://github.com/WGUNDERWOOD/tex-fmt";
+    changelog = "https://github.com/WGUNDERWOOD/tex-fmt/releases/tag/v${version}";
     license = lib.licenses.mit;
     mainProgram = "tex-fmt";
     maintainers = with lib.maintainers; [ wgunderwood ];

pkgs/by-name/tf/tftp-hpa/package.nix

···
 {
   lib,
   stdenv,
-  fetchurl,
+  fetchgit,
+  autoconf,
+  automake,
 }:
 
 stdenv.mkDerivation rec {
   pname = "tftp-hpa";
-  version = "5.2";
-  src = fetchurl {
-    url = "mirror://kernel/software/network/tftp/tftp-hpa/${pname}-${version}.tar.xz";
-    sha256 = "12vidchglhyc20znq5wdsbhi9mqg90jnl7qr9qs8hbvaz4fkdvmg";
+  version = "5.2-untagged-2024-06-10";
+  src = fetchgit {
+    url = "git://git.kernel.org/pub/scm/network/tftp/tftp-hpa.git";
+    hash = "sha256-lTMldYO/cZdLj0UjOPPBHfYf2GBG0O+5lhP9ikqn3tY=";
+    rev = "2c86ff58dcc003107b47f2d35aa0fdc4a3fd95e1";
   };
 
   # Workaround build failure on -fno-common toolchains like upstream
···
   #   ld: main.o:/build/tftp-hpa-5.2/tftp/main.c:98: multiple definition of
   #     `toplevel'; tftp.o:/build/tftp-hpa-5.2/tftp/tftp.c:51: first defined here
   env.NIX_CFLAGS_COMPILE = "-fcommon";
+
+  preConfigure = ''
+    ./autogen.sh
+  '';
+
+  nativeBuildInputs = [
+    autoconf
+    automake
+  ];
 
   meta = with lib; {
     description = "TFTP tools - a lot of fixes on top of BSD TFTP";

pkgs/by-name/to/todo-txt-cli/package.nix

···
   fetchurl,
 }:
 let
-  version = "2.12.0";
+  version = "2.13.0";
 in
 stdenv.mkDerivation {
   pname = "todo.txt-cli";
···
 
   src = fetchurl {
     url = "https://github.com/ginatrapani/todo.txt-cli/releases/download/v${version}/todo.txt_cli-${version}.tar.gz";
-    sha256 = "0gni8nj3wwdf7nl98d1bpx064bz5xari65hb998qqr92h0n9pnp6";
+    sha256 = "sha256-07klQ0ApqsISITwQP7ZXOk+WDHTdRno++sm9mv6J0V8=";
   };
 
   installPhase = ''

pkgs/by-name/tr/trunk/package.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "trunk";
-  version = "0.21.4";
+  version = "0.21.5";
 
   src = fetchFromGitHub {
     owner = "trunk-rs";
     repo = "trunk";
     rev = "v${version}";
-    hash = "sha256-tU0Xob0dS1+rrfRVitwOe0K1AG05LHlGPHhFL0yOjxM=";
+    hash = "sha256-AHW686xPGCMLISrOLLfDR5g+2XpMJ+zfmWGn3fMfKbA=";
   };
 
   nativeBuildInputs = [ pkg-config ];
···
   # requires network
   checkFlags = [ "--skip=tools::tests::download_and_install_binaries" ];
 
-  cargoHash = "sha256-iuxACtr91qWzojKWaieAd6kk/q9j5JSD1Fa50oCKogA=";
+  cargoHash = "sha256-m09ZV0Z4bNyAfO6XNiDKyqMeqv2/tx4vpQnWlesCW2A=";
 
   meta = with lib; {
     homepage = "https://github.com/trunk-rs/trunk";

pkgs/by-name/wa/waveterm/package.nix

···
   lib,
   stdenv,
   fetchurl,
-  makeDesktopItem,
-  copyDesktopItems,
+  dpkg,
   autoPatchelfHook,
   atk,
   at-spi2-atk,
···
   wrapGAppsHook3,
   udev,
   libGL,
-  fetchzip,
   unzip,
+  makeWrapper,
 }:
 let
   selectSystem = attrs: attrs.${stdenv.hostPlatform.system};
   pname = "waveterm";
-  version = "0.10.1";
-  passthru.updateScript = ./update.sh;
+  version = "0.10.4";
 
-  desktopItems = [
-    (makeDesktopItem {
-      name = "waveterm";
-      exec = "waveterm --no-sandbox %U";
-      icon = fetchurl {
-        url = "https://raw.githubusercontent.com/wavetermdev/waveterm/refs/tags/v${version}/build/appicon.png";
-        hash = "sha256-qob27/64C9XPBtXghxg5/g0qRaiOUOpuFYL1n7/aEB0=";
-      };
-      startupWMClass = "Wave";
-      comment = "Open-Source AI-Native Terminal Built for Seamless Workflows";
-      desktopName = "Wave";
-      genericName = "Terminal Emulator";
-      categories = [
-        "Development"
-        "Utility"
-        "TerminalEmulator"
-      ];
-      keywords = [
-        "developer"
-        "terminal"
-        "emulator"
-      ];
-    })
-  ];
+  passthru.updateScript = ./update.sh;
 
-  meta = {
+  metaCommon = {
     description = "Open-source, cross-platform terminal for seamless workflows";
     homepage = "https://www.waveterm.dev";
-    mainProgram = "waveterm";
     sourceProvenance = with lib.sourceTypes; [ binaryNativeCode ];
     license = lib.licenses.asl20;
     platforms = [
···
   };
 
   linux = stdenv.mkDerivation {
-    inherit
-      pname
-      version
-      desktopItems
-      meta
-      passthru
-      ;
+    inherit pname version passthru;
 
     src =
       let
         arch = selectSystem {
-          x86_64-linux = "x64";
+          x86_64-linux = "amd64";
           aarch64-linux = "arm64";
         };
+      in
+      fetchurl {
+        url = "https://github.com/wavetermdev/waveterm/releases/download/v${version}/waveterm-linux-${arch}-${version}.deb";
         hash = selectSystem {
-          x86_64-linux = "sha256-zv8ndwMt4VqsdJEEdfXzK4rnyslxF/gwnFdUu5OavNY=";
-          aarch64-linux = "sha256-6EFk1CDPeYc1KWeIxBQEsMLA9tYpnSxjG+yRg5CkGZA=";
+          x86_64-linux = "sha256-dwBnRuskajMpfaBQ5zr19+CQ3A/qen2RtxmV7GnXx0E=";
+          aarch64-linux = "sha256-HfzvbAV8RkmuwvuBtgvHgzAslbejlPJJJO7juGSMm1o=";
         };
-      in
-      fetchzip {
-        url = "https://github.com/wavetermdev/waveterm/releases/download/v${version}/waveterm-linux-${arch}-${version}.zip";
-        inherit hash;
-        stripRoot = false;
       };
 
     nativeBuildInputs = [
-      copyDesktopItems
+      dpkg
       autoPatchelfHook
       wrapGAppsHook3
+      makeWrapper
     ];
 
     buildInputs = [
···
     installPhase = ''
       runHook preInstall
 
-      mkdir $out
-      cp -r . $out/waveterm
+      cp -r opt $out
+      cp -r usr/share $out/share
+      substituteInPlace $out/share/applications/waveterm.desktop \
+        --replace-fail "/opt/Wave/" ""
 
       runHook postInstall
     '';
 
     preFixup = ''
       mkdir $out/bin
-      makeWrapper $out/waveterm/waveterm $out/bin/waveterm \
+      makeWrapper $out/Wave/waveterm $out/bin/waveterm \
         --prefix LD_LIBRARY_PATH : "${
           lib.makeLibraryPath [
             libGL
           ]
         }"
     '';
+
+    meta = metaCommon // {
+      mainProgram = "waveterm";
+    };
   };
 
-  darwin = stdenv.mkDerivation rec {
-    inherit
-      pname
-      version
-      meta
-      passthru
-      ;
+  darwin = stdenv.mkDerivation {
+    inherit pname version passthru;
 
     src =
       let
···
           x86_64-darwin = "x64";
           aarch64-darwin = "arm64";
         };
-        hash = selectSystem {
-          x86_64-darwin = "sha256-7TCDg0TU0Bx9WLwLiQRcyzrFTlmkXYQIpya2SUiEXoc=";
-          aarch64-darwin = "sha256-pVxPmTz1bCKREUOvA3Jrf7kiOI5iLzqgnutblEqc4IA=";
-        };
       in
       fetchurl {
         url = "https://github.com/wavetermdev/waveterm/releases/download/v${version}/Wave-darwin-${arch}-${version}.zip";
-        inherit hash;
+        hash = selectSystem {
+          x86_64-darwin = "sha256-iQimmHhpojimZvJtPgOExLaEu/io6BrWWkTsx/1avjY=";
+          aarch64-darwin = "sha256-4txsd3aKIcsjSvx+XeDm7a6M9YRkZNLUuvv5adLOVx8=";
+        };
       };
 
     nativeBuildInputs = [
       unzip
     ];
-
-    sourceRoot = "Wave.app";
 
     installPhase = ''
       runHook preInstall
 
       mkdir -p $out/Applications
-      cp -r . $out/Applications/Wave.app
+      cp -r . "$out/Applications/Wave.app"
 
       runHook postInstall
     '';
+
+    meta = metaCommon // {
+      mainProgram = "Wave";
+    };
   };
 in
 if stdenv.hostPlatform.isDarwin then darwin else linux

pkgs/by-name/wa/waveterm/update.sh

···
 fi
 
 for i in \
-    "x86_64-linux waveterm-linux-x64" \
-    "aarch64-linux waveterm-linux-arm64"; do
+    "x86_64-linux amd64" \
+    "aarch64-linux arm64"; do
     set -- $i
-    prefetch=$(nix-prefetch-url --unpack "https://github.com/wavetermdev/waveterm/releases/download/v$latestVersion/$2-$latestVersion.zip")
+    prefetch=$(nix-prefetch-url "https://github.com/wavetermdev/waveterm/releases/download/v$latestVersion/waveterm-linux-$2-$latestVersion.deb")
     hash=$(nix hash convert --hash-algo sha256 --to sri $prefetch)
     update-source-version waveterm $latestVersion $hash --system=$1 --ignore-same-version
 done
 
 for i in \
-    "x86_64-darwin Wave-darwin-x64" \
-    "aarch64-darwin Wave-darwin-arm64"; do
+    "x86_64-darwin x64" \
+    "aarch64-darwin arm64"; do
     set -- $i
-    prefetch=$(nix-prefetch-url "https://github.com/wavetermdev/waveterm/releases/download/v$latestVersion/$2-$latestVersion.zip")
+    prefetch=$(nix-prefetch-url "https://github.com/wavetermdev/waveterm/releases/download/v$latestVersion/Wave-darwin-$2-$latestVersion.zip")
     hash=$(nix hash convert --hash-algo sha256 --to sri $prefetch)
     update-source-version waveterm $latestVersion $hash --system=$1 --ignore-same-version
 done

pkgs/by-name/we/weaviate/package.nix

···
 
 buildGoModule rec {
   pname = "weaviate";
-  version = "1.28.0";
+  version = "1.28.2";
 
   src = fetchFromGitHub {
     owner = "weaviate";
     repo = "weaviate";
     rev = "v${version}";
-    hash = "sha256-HSBgsnjkkWie1hjo3WlZmh3InLnUz+8f7FhRMfRFpeU=";
+    hash = "sha256-yIa8AHyoT1z/M/tyPtlNtSMgOhU3XyWtw9OsqrDjO7A=";
   };
 
-  vendorHash = "sha256-A6Ikxy+zrAgy617ldtj4BkIFN/KiiEgjMb0ZNG6mVrs=";
+  vendorHash = "sha256-u1pfPsc1NuzONyuXPVNO5UcA6vekChnBkLT3MHa2xcc=";
 
   subPackages = [ "cmd/weaviate-server" ];
 

pkgs/by-name/wg/wgcf/package.nix

···
 
 buildGoModule rec {
   pname = "wgcf";
-  version = "2.2.23";
+  version = "2.2.24";
 
   src = fetchFromGitHub {
     owner = "ViRb3";
     repo = pname;
     rev = "refs/tags/v${version}";
-    hash = "sha256-zASb21C3GX4wQGf5V5Y+rKwq28S3CDi0gh696lspVnM=";
+    hash = "sha256-BtZvR+dZzauByQR5+VWzh6tOgAQV1sXfr0ThOy05uRo=";
   };
 
   subPackages = ".";
 
-  vendorHash = "sha256-ihcIEoVNSPJzJGeH2bRot4fldIhZ0r/yuYU6Jp9F1Eo=";
+  vendorHash = "sha256-txE00e8n9JJ89G1Exp/k8LTv36+MkGduCjqL7mHXuoQ=";
 
   meta = with lib; {
     description = "Cross-platform, unofficial CLI for Cloudflare Warp";

pkgs/by-name/xq/xq-xml/package.nix

···
 
 buildGoModule rec {
   pname = "xq";
-  version = "1.2.5";
+  version = "1.3.0";
 
   src = fetchFromGitHub {
     owner = "sibprogrammer";
     repo = "xq";
     rev = "v${version}";
-    hash = "sha256-Xr5k7YBx8GjrBapmThpLnPPvzEP6mcQG4mKXxZaEan4=";
+    hash = "sha256-KLpf4db3D+SQzbitc9ROO+k/VHggWpwZmwwhV3QVNiE=";
   };
 
-  vendorHash = "sha256-UV6Z4GyeFPkiyhUll7hCFkt+iBdWAl02QdzYYX0N2e4=";
+  vendorHash = "sha256-LKkYA0wZ+MQ67Gox2e+iuWSgbxF0daJj7RWLA6C+v+I=";
 
   ldflags = [
     "-s"

pkgs/by-name/zo/zoekt/package.nix

···
 
 buildGoModule {
   pname = "zoekt";
-  version = "3.7.2-2-unstable-2024-12-09";
+  version = "3.7.2-2-unstable-2024-12-18";
 
   src = fetchFromGitHub {
     owner = "sourcegraph";
     repo = "zoekt";
-    rev = "37c4df87f75cb0de7b71181301e0f6df6aa9ade6";
-    hash = "sha256-pH21Kz/qMs7Cy1nKoaWOzUt6W9jBYtmgIiF6GIcdwsg=";
+    rev = "dc1b23bb0da9a0fa91056ad6d5fcf9b8e641f67d";
+    hash = "sha256-sMYGFA6zazY64IGELbp4H1xNfKeH72pJ7bJ0Vy9YYFk=";
   };
 
   vendorHash = "sha256-Dvs8XMOxZEE9moA8aCxuxg947+x/6C8cKtgdcByL4Eo=";

pkgs/data/fonts/iosevka/bin.nix

···
 in
 stdenv.mkDerivation rec {
   pname = "${name}-bin";
-  version = "32.2.1";
+  version = "32.3.0";
 
   src = fetchurl {
     url = "https://github.com/be5invis/Iosevka/releases/download/v${version}/PkgTTC-${name}-${version}.zip";

pkgs/data/fonts/iosevka/variants.nix

···
 # This file was autogenerated. DO NOT EDIT!
 {
-  Iosevka = "0y1gsyjj0931rfhimszjcbmwkffznbhjdnjiqszg6g9wiqd3q8kv";
-  IosevkaAile = "04qynqhpzcz45plpdrik4y5x2h2pz2l2jzymdb1smp3dm4f6sk5p";
-  IosevkaCurly = "02qrd3j6xiz69a932cn6qdnz4bab7ycsg48dzxdwkakyympmhh7c";
-  IosevkaCurlySlab = "0sc4hylp72x84f6y3sjrc0jkw5nx0hynr0swram8fs4yvddqgrq8";
-  IosevkaEtoile = "0qkjivzjm3h2cwydxy5rhrk37qb5ci2bsrdmggmlv6v1syyn46kn";
-  IosevkaSlab = "1bg43x2baifa3y44bwsjav5lhbn7i0g5fhvwz0c55j16sqb4rizi";
-  IosevkaSS01 = "10pzgi0vhkmlnwsyc9jqjkzi4id5gmspyd1x467x3wrdjhm9zihv";
-  IosevkaSS02 = "1kyciyfdlvxvi4gbn5x8921mz71nxkhpyb48mwcmqjri6h7a4hkb";
-  IosevkaSS03 = "15f0khxancql140bivimg3mgn0kmzcykarrgqd0lmjqdv3iyng9a";
-  IosevkaSS04 = "1ym8pynzgsm16fr2myh2z9z6dn38lny736jbn8q92ngcl6mca0bl";
-  IosevkaSS05 = "0a3dkc2by23qls050ahri14sdgqclfagjhsxhhzv9cc66qvmr3xr";
-  IosevkaSS06 = "09d2ir6hrzpr5vq85j4jkhqkpghjid1zp0dxinps4digbix9ylc0";
-  IosevkaSS07 = "1m4mmr4px56b4fhpn77s0gf46as153c23gslhhbldj1jiyzfd1q8";
-  IosevkaSS08 = "01iv4sx21f2mkg6cspkpxcq9a1pp7b897jcwnf1gx6y4r9s04zj7";
-  IosevkaSS09 = "15v6y640qadq27rh5vx35ay6qj2xgyirza8182m7ypjrvnb96rip";
-  IosevkaSS10 = "1b35zy0rv5kgaiwm8wqak7drq3mncbvdgqbkwrk1hrfpf9j0hxch";
-  IosevkaSS11 = "0qdz0x9rbwycddq4yhmzf8daihqkpgpbn8kk0781vcfc38jayfbd";
-  IosevkaSS12 = "0lq23n4n9pyrb4z2zgp8y45asb36yl2r2s80y2p5l7anjndpwczs";
-  IosevkaSS13 = "13csq6ka9mhs5y2dl6l2imgldw5dm9ivjckx9ap1h90aq73ld3m1";
-  IosevkaSS14 = "1hv5y0z123a3a28wxargpkw9yvrciyvb48z29viwrlm3laf14f78";
-  IosevkaSS15 = "1pxh0nqnw8901d964hjiddzgaxnhhgbjsc4dv2gbs1nvfp4wz613";
-  IosevkaSS16 = "1bja13nxf5iqy6kzwqjpwxrv74kdaydamk3325km1lgaca6b13a9";
-  IosevkaSS17 = "00c4807ligsx29ipm75g7a3siqi4lfaf5dqjqrll5x2f5l04q4c1";
-  IosevkaSS18 = "1bk0p24h0vizjrlx4dzyz4yyi1b6s9ymakckprx4gxa97jln71z9";
-  SGr-Iosevka = "1vrxg8kbrm767mzrzlainfqv2prqmkwgip0ab4wd875x8lv3mq1w";
-  SGr-IosevkaCurly = "0mm0bmdr9ca29096bcb4z583ivyz7qf8h6bin74dd9vvvi3rlkla";
-  SGr-IosevkaCurlySlab = "0f45a6p3kgjqgyci5m7gj1bnlsdv2cif2yx8yp1npgqdyyaiq8ah";
-  SGr-IosevkaFixed = "1jfwj3w2rmhf00l628c9813yrx65cvjbl2q74xmwxwp4m7gjh7m6";
-  SGr-IosevkaFixedCurly = "05230lnw2p7hz77bgch20fibb2kvn1jqp0zl92vdim3f13n7yfv4";
-  SGr-IosevkaFixedCurlySlab = "1xqv070hfzng7bdi7dwhypi8vx4b7nlkz2d65gsvfxj1vk229c5l";
-  SGr-IosevkaFixedSlab = "14v3fawjijzzn94zgybkjkgz6bw2g4hqwxjz0rwflvr1w5m3fh1z";
-  SGr-IosevkaFixedSS01 = "1n221fd0ln91q2p506c2rgfc46xhgxksaajnbwan5hlll618y90v";
-  SGr-IosevkaFixedSS02 = "1zm8kzn2layp17glbs7l6243kmvmfz1cngbrgj3iwgraman6ac62";
-  SGr-IosevkaFixedSS03 = "0bgmgdipk1xysc658ngdhqyy6plfkcb4vbmq2vk8cjz8ixk12mh6";
-  SGr-IosevkaFixedSS04 = "046yjmmir4cxyl8mk3wyp3zy6rnm85mzxcpy8gmd9yb4qnbq9nm1";
-  SGr-IosevkaFixedSS05 = "106ii42m4wpffpynd35r97ks5q6a8py3g1h8k8q5919kxqakrfnh";
-  SGr-IosevkaFixedSS06 = "1g0d5jhb76g1x50z8qg934s5j97c60fg1aqga1n1dmqvmm0zmdwv";
-  SGr-IosevkaFixedSS07 = "13z7f78p01v0225rq49zv8wq7p4g303rj17zh8y96ggyajbhfn6y";
-  SGr-IosevkaFixedSS08 = "1sbkhmzdlh9z3zfmy1mdag4nccb2ndvz0lnli2hsk72iszjsk325";
-  SGr-IosevkaFixedSS09 = "1fkg5qhdx19v9k56kbrf69sfg87skc0h57mpz7jdiwzwpzlqv79v";
-  SGr-IosevkaFixedSS10 = "0smg99rxh27b8i7p07r0gmywpxlhn75ln8ccf18jlzv4baa12pn7";
-  SGr-IosevkaFixedSS11 = "07winxlw5di447j0yjxg7fxyj7vl1iwa766rx44xj9vz34s62v9l";
-  SGr-IosevkaFixedSS12 = "1l23f8d0gbddcawx2sdk2zcz8pqkj03gi9l0bw05pig72i3ipls6";
-  SGr-IosevkaFixedSS13 = "1b7yvrmfnspxa14kwb6rinqx9h712iadii4yf8v6z14iss6vrk87";
-  SGr-IosevkaFixedSS14 = "0fxwsss5mrizrg426gn1g0aj4imnr0ghkfbyx081hjbgn9569mid";
-  SGr-IosevkaFixedSS15 = "18xr3100ixq6p5s80ixlrdxna21cy9hqw1x6vypyvbqz9fc3nakx";
-  SGr-IosevkaFixedSS16 = "05j75njl8pi54kdp0hbaww4hm9mpyswl4msk0vma1v1jjasvggxp";
-  SGr-IosevkaFixedSS17 = "0xqp0dy1srqlzf92fvg45msay8r42k0bcfv04hsii87h6xq28q6i";
-  SGr-IosevkaFixedSS18 = "0rs2vwr3v6wy471cd604rm5qc5m35gg1pyna2l3kch1vrcjcvfas";
-  SGr-IosevkaSlab = "1g7aidcc43ibc7jwwmrlbwj2v0yq34cb5rs3q76bhyl498hizvn4";
-  SGr-IosevkaSS01 = "0wjsjv9g2xmvw1338lah688lj7hw8dlfn2y6x0pafffach2a42cs";
-  SGr-IosevkaSS02 = "1l7l4gpi0vk4d1rx8j2fysfwfdq8ifkx88qh610z3lqd9lia25ik";
-  SGr-IosevkaSS03 = "1pal6kg3dd4rq5vyr22ngziqrbs48prvz40jaynb78nd4v5hfm96";
-  SGr-IosevkaSS04 = "0381kgbx3l26wqi9i9fvsprqjxlvj2jfczni4qsiw4vczdiclkg8";
-  SGr-IosevkaSS05 = "0fzgncaln6il7zp5bxx47kygawkpaibvcchznpfr1kmb6i8mcy4a";
-  SGr-IosevkaSS06 = "0yh9gpzddwi8j752h7d9k4xmqp2092xhjpfd6qwzs98g180czqyx";
-  SGr-IosevkaSS07 = "1i6rnbddc7r69133y1pn44hng461hcdanl2xksjws49wcyhrdclz";
-  SGr-IosevkaSS08 = "0d4j6x79nlsrb1fpg52bscxdl8bsfzp2qjr3lmn1kph5n12g91an";
-  SGr-IosevkaSS09 = "1lmqi80hqb3nx5nl5w0fdbakkqp0w261zh19m48yii2wq8bl48sj";
-  SGr-IosevkaSS10 = "083g92r66mlklsh4xn6v650p1czcg0vszl758861jmsqrj1irknp";
-  SGr-IosevkaSS11 = "006fybldx9iz48yc1ndwnhxjdqjy9k1raxibcdgdm73n0y1fiwg6";
-  SGr-IosevkaSS12 = "0r2w6wk82yws1qnvipia5srxrvxcp17hvy1zzbs7756h9xq2qyjv";
-  SGr-IosevkaSS13 = "0q7z5a8z9dwvi3ax6f2zix020icx78wz8xq6i7mb1p9v5mr7vh22";
-  SGr-IosevkaSS14 = "16ii7aynq3q1k1h22q0hz5jxxhrwx9w06c7jfyqcmc4166xmz1bc";
-  SGr-IosevkaSS15 = "1lbi138qxpwbasl10447ql23j26ib0rsmvb3db54rdd458yhc99b";
-  SGr-IosevkaSS16 = "0xq8fnmlz7v6jamsqfvdg81vry8ccc0164nzl93rfj7i6ri0jvg0";
-  SGr-IosevkaSS17 = "0j3gzn6mghyjndzkxyrjbgpr5284hpwr9b9aifq0m4ri1pmsbwnn";
-  SGr-IosevkaSS18 = "0b3hgfl4r5s1f5i7n401yp22glbjghkh2wcx7k4mn8qrci7lhvwv";
-  SGr-IosevkaTerm = "0ijcrzh91pinf83wdqdk42z3raas2mjw2p872xgkkx0wpzy01vbn";
-  SGr-IosevkaTermCurly = "0s2g9dpnc1nw7f9cpgnw6yjfm71c4q63qvmf5ld35sp4h21qgc3w";
-  SGr-IosevkaTermCurlySlab = "1kndi5p6w7pm64621v9bjkmk80r1wq5p8ihxmnzv7va84r43sjdy";
-  SGr-IosevkaTermSlab = "0ah7vn8ycrwxvarpmxjf07spky9r3fa3qvjy38nvagwh3ppx0xxd";
-  SGr-IosevkaTermSS01 = "1c36199qjdvcs0h237xy0pvcbk6rjkrrsnq35k432y7b1jp9nyy2";
-  SGr-IosevkaTermSS02 = "0b16096xihjy1ny5k35rg2nm73fpkk9yb05gf2i8b34nwmysif8m";
-  SGr-IosevkaTermSS03 = "17kq2cylrgccqkmzjg03m3apib4z0zjs25sp9sdx2wahjh07bw6d";
-  SGr-IosevkaTermSS04 = "12qsqpp3jlw6961mdal8ihx07x4lb8c8ckiwaks00y53shrknq6s";
-  SGr-IosevkaTermSS05 = "0yy8ls7vvsj5h411cg1x7ys1va1qp1dkza8zrr562r04q671748m";
-  SGr-IosevkaTermSS06 = "01dd1pbfj0ga4h1bvzk8z16hw5syc41appbdc6ysr3rcr982p8as";
-  SGr-IosevkaTermSS07 = "1181rabk0abiny2ifs3v0431s8i9zm8ins7pdfk1qlgjfx0axkwb";
-  SGr-IosevkaTermSS08 = "07az3bnr0l7igybcm4a0mhh6l0disvrih61zdvm2c2nx8308bl4l";
-  SGr-IosevkaTermSS09 = "0fssz0j9nlph94hqzwgiqs1hdbw8qkr5f442hw0f1j1fmkbr8h41";
-  SGr-IosevkaTermSS10 = "0847d38s6dpkagymna374wqnw7bg05idj370bgjnk7l6xqbwh096";
-  SGr-IosevkaTermSS11 = "1d5in68yzllcq6bkmdyws4amysh7fi8i9mvphdd4sdw26abwpyw6";
-  SGr-IosevkaTermSS12 = "0wdax0f8w1qrczaa9dyg9b2jkl37vnm0ms4bwa7gzifg1v6rkl83";
-  SGr-IosevkaTermSS13 = "1vh13gc5dddjkb4qmdr1dpq2vqwbf2xggpn6mdj6s2my1irgqhv1";
-  SGr-IosevkaTermSS14 = "1bcjhxpdl0m2nc895rg4ha90mpakz4l8xdhhlm88fvdakjp3wa53";
-  SGr-IosevkaTermSS15 = "0mwxzjdrrnl85q3y97hlsb63n2rl6ysvcpi2yf0828f81x9xgldj";
-  SGr-IosevkaTermSS16 = "1cglchggcb49p6v6irapkx9dwdic0qalrpk447p6lg2vhv0ka676";
-  SGr-IosevkaTermSS17 = "00d0cydhjxplyavp47bsaijrxb06hnriqili5mq8p0g01r1fzxqb";
-  SGr-IosevkaTermSS18 = "1n6mc2hfkgyb0rqffnc65i07p94p61sf0yf9vr8k6ir7m7fb30n9";
+  Iosevka = "0x9h41jhhxgafad7zc39jb4la30sxkqcz1m4l2har9zfakc3jhnm";
+  IosevkaAile = "1rf70nsqkza1zwzpl2i015rhxs2wqq9msvkjhghg6scfir2bmpky";
+  IosevkaCurly = "0hqn94k9vh9ds077m4gmdhdhcg1x8libb6cp1c2iqgy7nyc9qywd";
+  IosevkaCurlySlab = "18ya3c8fw0hwifxdkyyfrnqybpwhf21ir3lhajs0x772ifs7xs22";
+  IosevkaEtoile = "1ycwyfyg1dk47mxgnc729liqnffyk2f5f0vzavdamydfdqnd9wrq";
+  IosevkaSlab = "1dfgbx0clsz7dxy32n7gzza8bx63gfq2j77vyfqwi9201qbmsyqr";
+  IosevkaSS01 = "1x4fayq749lcn857v5kls4kizdn2nm7sv3n5r9ac3x1vhnjp03c9";
+  IosevkaSS02 = "0ghwab6cx958kk5znc8d59bkjw1pfif3cz583j99n2jyd524y6bf";
+  IosevkaSS03 = "04g41ds76nkva8ai23xbq62szfdvrn659hrn0bjn1f754aq921h8";
+  IosevkaSS04 = "1c34cbmnmfnss9sncrkh92n054q8lhdpn7qvvi0p3kq1xbg17iny";
+  IosevkaSS05 = "03ii0w908k9xvgal7ja6sw3bmc3gnvhkgd6j023whrcjis77ryi9";
+  IosevkaSS06 = "1hv41jn17zacmfck1r6kc905i0aikz51xwx4zdnmmqq0xyyxdkrn";
+  IosevkaSS07 = "0vfys80wc4rznynvv8zck8h41nfz5ig01by03f6m8qd5fnjdbhw1";
+  IosevkaSS08 = "0ramm4jd6wfkfnwymfqpcgapbrqcsq1irfh33mkzamj35racnkgm";
+  IosevkaSS09 = "0f0y536nfmbkz5b57wm978ywrn5qc3f1wzfmwpdc7h3jqygakbdc";
+  IosevkaSS10 = "030blnwf75psiiqi5haypwvp9f9jnh5h24fz9x6swxx23x6pl6gn";
+  IosevkaSS11 = "06c9ka1ca57srnn81ahbmnvimcyb090izw22yrkkyd6nnf59ma34";
+  IosevkaSS12 = "11jv4xy9xva97v1lhz7w8c1qj9yb69a7l17aycdq1ma3mx73dpk0";
+  IosevkaSS13 = "07l3adjiz9i7hqfs8174db1283m2ly6nn0c91njx84fm541sizfn";
+  IosevkaSS14 = "1862fcq9zxdm5dh2032bvs2l2wg3ryrcsyjz0addgih7arp4gzfd";
+  IosevkaSS15 = "111pj1l1vmfcpj1jcb1cpdl1xbm2pjvmlvpmxbn8qh3ms2cvdgra";
+  IosevkaSS16 = "14dk6j8dw8scd0kn7hazld41731fgf5ym6ylljdq4jcgi6kygsiz";
+  IosevkaSS17 = "0ci8l5i2iwb8yjdxdzs41204x3zypsbcdn7a4sgjwc0fcg6ln89m";
+  IosevkaSS18 = "1wkwfdlz0kxymiii4i1wg1kiwbksnqkdpd5xjlg5abixj9dg2kcf";
+  SGr-Iosevka = "1q3x9b9h7daxfhz56mnlgsbcl3a4sr3h87f04dl3cxqxwmf1c65q";
+  SGr-IosevkaCurly = "0xplpj2na2427znwphrifyh5firc2z1pdq6sf7rc5apfizydspxc";
+  SGr-IosevkaCurlySlab = "1jbsq475fg0bmjjbrl0ylxzpi59cn9wm00693y3f2n900lrbbd6x";
+  SGr-IosevkaFixed = "1kw90cqj9fkjhhgjpi2pmjjxljhirfk68jz2k07b213qvg1ca1ab";
+  SGr-IosevkaFixedCurly = "1kpvimfga2harfb13i1gp4h5nl8qffa6a4dg9fcjwi56j9p1r0hq";
+  SGr-IosevkaFixedCurlySlab = "03r9h4gh7g7b80pwddm9vvldps9b32wfzd4bysmgn918wqiqkcwh";
+  SGr-IosevkaFixedSlab = "0q9l1djgsg15qhwl11kxdckrds05pkr6w34048r2hdxgvzr7f6gm";
+  SGr-IosevkaFixedSS01 = "1acc8cv14vv21p60iv0ldpmkd7a0hzpi6s1mw5z1zilnrm8swbfk";
+  SGr-IosevkaFixedSS02 = "1kp2b891wna0k4y8k40hdmm34a0p7788ja2ip9h7xvc2n1g64yl8";
+  SGr-IosevkaFixedSS03 = "1vgb6vdwc2kmh0219rpzqhg27zamka801zv7gm9ic24hfizy713x";
+  SGr-IosevkaFixedSS04 = "1g49bqkzsjdb5bli3pxh1rbmr8n6c0dxn2vdxjachxcz5mf4ja9z";
+  SGr-IosevkaFixedSS05 = "1sni2mxlwsbpvgh0rpjmr3ifjq4awgsc44s3yjiqw0y8wmd90qmg";
+  SGr-IosevkaFixedSS06 = "0nsv3bxjbm2r6dnva74d67f9r3k42jdvcjfrdgxkpwgydrcrkar7";
+  SGr-IosevkaFixedSS07 = "0qxx9mmg5i7rgqwl7zy3m11bhrqr6akv4jqlns4119clfq1bh1ip";
+  SGr-IosevkaFixedSS08 = "0w9v8slpp9q2ywn5absc97zqmg3f55vfd52rrv6rcc7jkd7zsz72";
+  SGr-IosevkaFixedSS09 = "19js1wah54mbkpf3vjqrxwk6lf2y7nq86dc5xxrj015yimkzsbsw";
+  SGr-IosevkaFixedSS10 = "03vvjfm69mvm0873b1ws93vkjbqjzd7f3kg65h7zwxg6r9l20ikc";
+  SGr-IosevkaFixedSS11 = "0jcwgblwx0bhvfibnlizsgwqryjqhyj80cz4dqhhrjlviirm17v3";
+  SGr-IosevkaFixedSS12 = "1pm1kmlmpaz5nnkbk4s0n12am134kb5mh2b6rhs104dkngf1zfkf";
+  SGr-IosevkaFixedSS13 = "1h3v8c7qsf7iyypvbhn7qsmm0a7mfyyh7i0p4f3pvkfdpb1sd509";
+  SGr-IosevkaFixedSS14 = "1fpwrck8dhha5rkrbz7dykyqrlg46fgih3sn1c36s7j737j69vch";
+  SGr-IosevkaFixedSS15 = "16iwab1gpc3xzgxld8km43n9dm6jxv0z39zgyxknw7xdxkwy247z";
+  SGr-IosevkaFixedSS16 = "0di6sr995gjadky3nd6k68i88cl745i2awq69cnv6akvcyy53fhd";
+  SGr-IosevkaFixedSS17 = "1p7qm49ww201yaddc0m18vjgp5xjn69cpmg3lsxav4bapf3yq01q";
+  SGr-IosevkaFixedSS18 = "08858lgilwqhrvpzciagh95a2cqc4bfipdyidl9bj718z67vwmgq";
+  SGr-IosevkaSlab = "10y6ykq3aaki5m4j4kmsv5y79li3l9bqisrwbvzw6vcs4895z6qw";
+  SGr-IosevkaSS01 = "0mdkm5fb6srxd9bmw41a1rglnap0fmfv78anzff6w0g4azvxlwxj";
+  SGr-IosevkaSS02 = "1z6bf14qcx5qkhfd99g0p26flin8wqmvlkqmxl32r0697a1yhaqm";
+  SGr-IosevkaSS03 = "1jvf58qnx89f90h1gwlm8nzfb4ab1wv6z39p9fzawcrsk70fj29q";
+  SGr-IosevkaSS04 = "11akqjhjc1nnmc1b0x05v78b3pr2mq4x1w9ldq07mq088cp9n1v8";
+  SGr-IosevkaSS05 = "0dn1d4gkgfqars6nj84lbic3ybld3h0h321kkrbl4s5wplli264k";
+  SGr-IosevkaSS06 = "1lxjvgipr4w7865xvcrx5vl5w40c9bz91rb7wm6lnxs9fljg9nim";
+  SGr-IosevkaSS07 = "0kyb0qyvq7z0m1z8561w6bkz73hfhnxp4hshx68pcbvyh3ah25hs";
+  SGr-IosevkaSS08 = "07f1qy450v6k9dn2l15b8xfdhkx2ri773lnld2jv482wm8nqn54z";
+  SGr-IosevkaSS09 = "1gkxlaip18fnxkcdf6iqh7in0qgjk4kvjqky3qjwhww3nbkww5cl";
+  SGr-IosevkaSS10 = "0g25n440ad8n2xxc4m9mrjfi5lf77jhjg9hld26w9ir5fhbg5gd9";
+  SGr-IosevkaSS11 = "06xgh13qsmfjzk925s30qwrvdhaxk3f04qrsyb12fyns7r8q39k2";
+  SGr-IosevkaSS12 = "05s9x6h609mrmq9dn1ca25crbb2nkf4v3av0mb7phc9narp2nl9d";
+  SGr-IosevkaSS13 = "1yz26cgb1mcbqhn2x85yh3hhivkdmrxpnkkqh28kqhp6yajb7cma";
+  SGr-IosevkaSS14 = "0ql72ic7m28p1k5c2zbrgpdllsciggcm26iylxxqvirsvrxpa4gg";
+  SGr-IosevkaSS15 = "1j3xib3szygxjx658jj1kzn8sn5qyyw14w7ayz9zi5dr2l86cnzy";
+  SGr-IosevkaSS16 = "0m48y236m5incc8p45mq7rryqyisjfrpihym7fsv10hylvfmjfp4";
+  SGr-IosevkaSS17 = "1c7hwxjzjcdil0vl44pndsa89rlp4i9p254zsr7qb23frjrd1jn5";
+  SGr-IosevkaSS18 = "0m09ilj16p2fl6mcf6hx2v3v2zshr1fwm49jvhcc1l72niafm2wm";
+  SGr-IosevkaTerm = "0n91a4icwxxbg3nhr4jc0ssjxf70wh7r5k7rhacha80kbb3n5yai";
+  SGr-IosevkaTermCurly = "0fbkad52yi2svh309klhr36pf79avp62nnh0sgh3pi5ss0fs1msr";
+  SGr-IosevkaTermCurlySlab = "0pzffbjjb8rm1cbc8v6qpl0xavgq0hdfipi3fafw5grl79hiz266";
+  SGr-IosevkaTermSlab = "01sif6fvszbsjq35gpydiy450n3l9s6zcgv16yg0yl7qpkcdjnyj";
+  SGr-IosevkaTermSS01 = "06x65513mr1xjqhvq72l28ki341v9zy51006pjm7q47gryvj9z9g";
+  SGr-IosevkaTermSS02 = "1wxryjk65idhkjbzamxr82zbqhh5vzc6kfi8f4zjsqi5mvd3x1fc";
+  SGr-IosevkaTermSS03 = "08vdzxy4rvpsdn2q1014ma4v9sk7f75i4633x2d3cysj08yq62qg";
+  SGr-IosevkaTermSS04 = "143wf50dfwn734zmq69d9nm98ynhicv0685d8s86kdn9lwrviz6a";
+  SGr-IosevkaTermSS05 = "1myql01syc1d9i61jrfdkk6j515dj6v01dkn8fcn1rcqkavz0r6j";
+  SGr-IosevkaTermSS06 = "1sha89llc72n4jf76yqh87pa2dx0rqwz1pq2v2gcljlmimmvknki";
+  SGr-IosevkaTermSS07 = "1ksd28c7i047ms01jih3xfkq39l1dvfmrr8zb994363qrxa8ycp8";
+  SGr-IosevkaTermSS08 = "02f35fkr31zm5z7zd081v2slv65f584lymbf5a6hjdpvf5bl42br";
+  SGr-IosevkaTermSS09 = "130xq18wwkbfr8myvga9zrpwf3y57ca5943ff1j88prmsq4m2gpx";
+  SGr-IosevkaTermSS10 = "0wj8k7a0ddgysrdfwqvcr615ch4d55rd22cr96jwmindx0k86az3";
+  SGr-IosevkaTermSS11 = "0bv4jxpq43gp8y6wbml06zbdzwb7zzk3l593c1zq41vs28lk6qb0";
+  SGr-IosevkaTermSS12 = "0nijgws4mlv6sp34l9fqlrk78krrbc2zxzkbbn7a0yalpnzddilz";
+  SGr-IosevkaTermSS13 = "04i434zafahf1wkdj87zd8fdvpi7nc83h00d844afcx8rdamm3fq";
+  SGr-IosevkaTermSS14 = "0qsb5jdq4b0p749fksqvj6givkn8ba5lqpm93rjrf2xxqv1bacy4";
+  SGr-IosevkaTermSS15 = "1j9jcr1823vw8bfvvvlw1v1sar14csmmwwcam4m69p9f3yxp8l2c";
+  SGr-IosevkaTermSS16 = "02v6qb7j0rnzm87mx4mvhkfj2888752a850sflsfv97fk5g4dnxs";
+  SGr-IosevkaTermSS17 = "1d1b5h8z21yqqzppnfwx22q3938a9r5gdkr5183608jrqhwnjlzr";
+  SGr-IosevkaTermSS18 = "1jzihaabkj33bxp2wxi6mndkxwfiv153i3941hmh5p6gmbm386a7";
 }

pkgs/development/cuda-modules/saxpy/default.nix

···
     libcublas
     ;
   inherit (lib) getDev getLib getOutput;
-  fs = lib.fileset;
 in
 backendStdenv.mkDerivation {
   pname = "saxpy";
   version = "unstable-2023-07-11";
 
-  src = fs.toSource {
-    root = ./.;
-    fileset = fs.unions [
-      ./CMakeLists.txt
-      ./saxpy.cu
-    ];
-  };
+  src = ./src;
 
   __structuredAttrs = true;
   strictDeps = true;

pkgs/development/interpreters/babashka/clojure-tools.nix

···
 }:
 clojure.overrideAttrs (previousAttrs: {
   pname = "babashka-clojure-tools";
-  version = "1.12.0.1479";
+  version = "1.12.0.1488";
 
   src = fetchurl {
     url = previousAttrs.src.url;
-    hash = "sha256-KlFcRXVd8e3zeP36+zgCUcdzbeLbFffb5V7XKV8NKWw=";
+    hash = "sha256-vBm+ABC+8EIcJv077HvDvKCMGSgo1ZoVGEVCLcRCB0I=";
   };
 })

pkgs/development/interpreters/babashka/default.nix

···
 let
   babashka-unwrapped = buildGraalvmNativeImage rec {
     pname = "babashka-unwrapped";
-    version = "1.12.195";
+    version = "1.12.196";
 
     src = fetchurl {
       url = "https://github.com/babashka/babashka/releases/download/v${version}/babashka-${version}-standalone.jar";
-      sha256 = "sha256-1bZaWg1AtStF1uuoY8Z0V4s0fMSchSTR/pTSWdEzcuw=";
+      sha256 = "sha256-11HrLQi/BYX+LqqUAN3mZx13775dzXCDFxpJP33bKQY=";
     };
 
     graalvmDrv = graalvmPackages.graalvm-ce;

pkgs/development/libraries/glib/default.nix

···
-{ config
-, lib
-, stdenv
-, fetchurl
-, gettext
-, meson
-, ninja
-, pkg-config
-, perl
-, python3
-, python3Packages
-, libiconv, zlib, libffi, pcre2, elfutils, gnome, libselinux, bash, gnum4, libxslt
-, docutils, gi-docgen
-# use util-linuxMinimal to avoid circular dependency (util-linux, systemd, glib)
-, util-linuxMinimal ? null
-, buildPackages
-
-# this is just for tests (not in the closure of any regular package)
-, dbus, tzdata
-, desktop-file-utils, shared-mime-info
-, darwin
-, makeHardcodeGsettingsPatch
-, testers
-, gobject-introspection
-, libsystemtap
-, libsysprof-capture
-, mesonEmulatorHook
-, withIntrospection ?
-  stdenv.hostPlatform.emulatorAvailable buildPackages &&
-  lib.meta.availableOn stdenv.hostPlatform gobject-introspection &&
-  stdenv.hostPlatform.isLittleEndian == stdenv.buildPlatform.isLittleEndian
-}:
-
-assert stdenv.hostPlatform.isLinux -> util-linuxMinimal != null;
-
-let
-  gobject-introspection' = buildPackages.gobject-introspection.override {
-    propagateFullGlib = false;
-    # Avoid introducing cairo, which enables gobjectSupport by default.
-    x11Support = false;
-  };
-
-  librarySuffix = if (stdenv.hostPlatform.extensions.library == ".so") then "2.0.so.0"
-                  else if (stdenv.hostPlatform.extensions.library == ".dylib") then "2.0.0.dylib"
-                  else if (stdenv.hostPlatform.extensions.library == ".a") then "2.0.a"
-                  else if (stdenv.hostPlatform.extensions.library == ".dll") then "2.0-0.dll"
-                  else "2.0-0.lib";
-
-  systemtap' = buildPackages.linuxPackages.systemtap.override { withStap = false; };
-  withDtrace =
-    lib.meta.availableOn stdenv.buildPlatform systemtap' &&
-    # dtrace support requires sys/sdt.h header
-    lib.meta.availableOn stdenv.hostPlatform libsystemtap;
-in
-
-stdenv.mkDerivation (finalAttrs: {
-  pname = "glib";
-  version = "2.82.4";
-
-  src = fetchurl {
-    url = "mirror://gnome/sources/glib/${lib.versions.majorMinor finalAttrs.version}/glib-${finalAttrs.version}.tar.xz";
-    hash = "sha256-N90Id/6WTNFemicQsEShgw+xvZNlKm0Mtriy3/GHxwk=";
-  };
-
-  patches = lib.optionals stdenv.hostPlatform.isDarwin [
-    ./darwin-compilation.patch
-  ] ++ lib.optionals stdenv.hostPlatform.isMusl [
-    ./quark_init_on_demand.patch
-    ./gobject_init_on_demand.patch
-  ] ++ [
-    # This patch lets GLib's GDesktopAppInfo API watch and notice changes
-    # to the Nix user and system profiles.  That way, the list of available
-    # applications shown by the desktop environment is immediately updated
-    # when the user installs or removes any
-    # (see <https://issues.guix.gnu.org/35594>).
-
-    # It does so by monitoring /nix/var/nix/profiles (for changes to the system
-    # profile) and /nix/var/nix/profiles/per-user/USER (for changes to the user
-    # profile) as well as /etc/profiles/per-user (for chanes to the user
-    # environment profile) and crawling their share/applications sub-directory when
-    # changes happen.
-    ./glib-appinfo-watch.patch
-
-    ./schema-override-variable.patch
-
-    # Add support for Pantheon’s terminal emulator.
-    ./elementary-terminal-support.patch
-
-    # GLib contains many binaries used for different purposes;
-    # we will install them to different outputs:
-    # 1. Tools for desktop environment and introspection ($bin)
-    #    * gapplication (non-darwin)
-    #    * gdbus
-    #    * gi-compile-repository
-    #    * gi-decompile-typelib
-    #    * gi-inspect-typelib
-    #    * gio
-    #    * gio-launch-desktop (symlink to $out)
-    #    * gsettings
-    # 2. Development/build tools ($dev)
-    #    * gdbus-codegen
-    #    * gio-querymodules
-    #    * glib-compile-resources
-    #    * glib-compile-schemas
-    #    * glib-genmarshal
-    #    * glib-gettextize
-    #    * glib-mkenums
-    #    * gobject-query
-    #    * gresource
-    #    * gtester
-    #    * gtester-report
-    # 3. Tools for desktop environment that cannot go to $bin due to $out depending on them ($out)
-    #    * gio-launch-desktop
-    ./split-dev-programs.patch
-
-    # Tell Meson to install gdb scripts next to the lib
-    # GDB only looks there and in ${gdb}/share/gdb/auto-load,
-    # and by default meson installs in to $out/share/gdb/auto-load
-    # which does not help
-    ./gdb_script.patch
-  ];
-
-  outputs = [ "bin" "out" "dev" "devdoc" ];
-
-  setupHook = ./setup-hook.sh;
-
-  buildInputs = [
-    finalAttrs.setupHook
-  ] ++ lib.optionals (!stdenv.hostPlatform.isFreeBSD) [
-    libsysprof-capture
-  ] ++ [
-    pcre2
-  ] ++ lib.optionals (!stdenv.hostPlatform.isWindows) [
-    bash gnum4 # install glib-gettextize and m4 macros for other apps to use
-  ] ++ lib.optionals (lib.meta.availableOn stdenv.hostPlatform elfutils) [
-    elfutils
-  ] ++ lib.optionals withDtrace [
-    libsystemtap
-  ] ++ lib.optionals stdenv.hostPlatform.isLinux [
-    libselinux
-    util-linuxMinimal # for libmount
-  ] ++ lib.optionals stdenv.hostPlatform.isDarwin (with darwin.apple_sdk.frameworks; [
-    AppKit Carbon Cocoa CoreFoundation CoreServices Foundation
-  ]);
-
-  strictDeps = true;
-
-  depsBuildBuild = [
-    pkg-config # required to find native gi-docgen
-  ];
-
-  nativeBuildInputs = [
-    docutils # for rst2man, rst2html5
-    meson
-    ninja
-    pkg-config
-    perl
-    python3
-    python3Packages.packaging # mostly used to make meson happy
-    python3Packages.wrapPython # for patchPythonScript
-    gettext
-    libxslt
-  ] ++ lib.optionals withIntrospection [
-    gi-docgen
-    gobject-introspection'
-  ] ++ lib.optionals (withIntrospection && !stdenv.buildPlatform.canExecute stdenv.hostPlatform) [
-    mesonEmulatorHook
-  ] ++ lib.optionals withDtrace [
-    systemtap' # for dtrace
-  ];
-
-  propagatedBuildInputs = [ zlib libffi gettext libiconv ];
-
-  mesonFlags = [
-    "-Dglib_debug=disabled" # https://gitlab.gnome.org/GNOME/glib/-/issues/3421#note_2206315
-    "-Ddocumentation=true" # gvariant specification can be built without gi-docgen
-    (lib.mesonEnable "dtrace" withDtrace)
-    (lib.mesonEnable "systemtap" withDtrace) # requires dtrace option to be enabled
-    "-Dnls=enabled"
-    "-Ddevbindir=${placeholder "dev"}/bin"
-    (lib.mesonEnable "introspection" withIntrospection)
-    # FIXME: Fails when linking target glib/tests/libconstructor-helper.so
-    # relocation R_X86_64_32 against hidden symbol `__TMC_END__' can not be used when making a shared object
-    "-Dtests=${lib.boolToString (!stdenv.hostPlatform.isStatic)}"
-  ] ++ lib.optionals (!lib.meta.availableOn stdenv.hostPlatform elfutils) [
-    "-Dlibelf=disabled"
-  ] ++ lib.optionals stdenv.hostPlatform.isFreeBSD [
-    "-Db_lundef=false"
-    "-Dxattr=false"
-    "-Dsysprof=disabled"  # sysprof-capture does not build on FreeBSD
-  ];
-
-  env.NIX_CFLAGS_COMPILE = toString [
-    "-Wno-error=nonnull"
-    # Default for release buildtype but passed manually because
-    # we're using plain
-    "-DG_DISABLE_CAST_CHECKS"
-  ];
-
-  postPatch = ''
-    patchShebangs glib/gen-unicode-tables.pl
-    patchShebangs glib/tests/gen-casefold-txt.py
-    patchShebangs glib/tests/gen-casemap-txt.py
-    patchShebangs tools/gen-visibility-macros.py
-    patchShebangs tests
-
-    # Needs machine-id, comment the test
-    sed -e '/\/gdbus\/codegen-peer-to-peer/ s/^\/*/\/\//' -i gio/tests/gdbus-peer.c
-    sed -e '/g_test_add_func/ s/^\/*/\/\//' -i gio/tests/gdbus-address-get-session.c
-    # All gschemas fail to pass the test, upstream bug?
-    sed -e '/g_test_add_data_func/ s/^\/*/\/\//' -i gio/tests/gschema-compile.c
-    # Cannot reproduce the failing test_associations on hydra
-    sed -e '/\/appinfo\/associations/d' -i gio/tests/appinfo.c
-    # Needed because of libtool wrappers
-    sed -e '/g_subprocess_launcher_set_environ (launcher, envp);/a g_subprocess_launcher_setenv (launcher, "PATH", g_getenv("PATH"), TRUE);' -i gio/tests/gsubprocess.c
-  '' + lib.optionalString stdenv.hostPlatform.isWindows ''
-    substituteInPlace gio/win32/meson.build \
-      --replace "libintl, " ""
-  '';
-
-  postConfigure = ''
-    patchShebangs gio/gdbus-2.0/codegen/gdbus-codegen gobject/glib-{genmarshal,mkenums}
-  '';
-
-  DETERMINISTIC_BUILD = 1;
-
-  postInstall = ''
-    moveToOutput "share/glib-2.0" "$dev"
-    moveToOutput "share/glib-2.0/gdb" "$out"
-    substituteInPlace "$dev/bin/gdbus-codegen" --replace "$out" "$dev"
-    sed -i "$dev/bin/glib-gettextize" -e "s|^gettext_dir=.*|gettext_dir=$dev/share/glib-2.0/gettext|"
-
-    # This file is *included* in gtk3 and would introduce runtime reference via __FILE__.
-    sed '1i#line 1 "glib-${finalAttrs.version}/include/glib-2.0/gobject/gobjectnotifyqueue.c"' \
-      -i "$dev"/include/glib-2.0/gobject/gobjectnotifyqueue.c
-    for i in $bin/bin/*; do
-      moveToOutput "share/bash-completion/completions/''${i##*/}" "$bin"
-    done
-    for i in $dev/bin/*; do
-      moveToOutput "share/bash-completion/completions/''${i##*/}" "$dev"
-    done
-  '';
-
-  preFixup = lib.optionalString (!stdenv.hostPlatform.isStatic) ''
-    buildPythonPath ${python3Packages.packaging}
-    patchPythonScript "$dev/share/glib-2.0/codegen/utils.py"
-  '';
-
-  # Move man pages to the same output as their binaries (needs to be
-  # done after preFixupHooks which moves man pages too - in
-  # _multioutDocs)
-  postFixup = ''
-    for i in $dev/bin/*; do
-      moveToOutput "share/man/man1/''${i##*/}.1.*" "$dev"
-    done
-
-    # Cannot be in postInstall, otherwise _multioutDocs hook in preFixup will move right back.
-    moveToOutput "share/doc" "$devdoc"
-  '';
-
-  nativeCheckInputs = [ tzdata desktop-file-utils shared-mime-info ];
-
-  # Conditional necessary to break infinite recursion with passthru.tests
-  preCheck = lib.optionalString finalAttrs.finalPackage.doCheck or config.doCheckByDefault or false ''
-    export LD_LIBRARY_PATH="$NIX_BUILD_TOP/glib-${finalAttrs.version}/glib/.libs''${LD_LIBRARY_PATH:+:}$LD_LIBRARY_PATH"
-    export TZDIR="${tzdata}/share/zoneinfo"
-    export XDG_CACHE_HOME="$TMP"
-    export XDG_RUNTIME_HOME="$TMP"
-    export HOME="$TMP"
-    export XDG_DATA_DIRS="${desktop-file-utils}/share:${shared-mime-info}/share"
-    export G_TEST_DBUS_DAEMON="${dbus}/bin/dbus-daemon"
-
-    # pkg_config_tests expects a PKG_CONFIG_PATH that points to meson-private, wrapped pkg-config
-    # tries to be clever and picks up the wrong glib at the end.
-    export PATH="${buildPackages.pkg-config-unwrapped}/bin:$PATH:$(pwd)/gobject"
-    echo "PATH=$PATH"
-
-    # Our gobject-introspection patches make the shared library paths absolute
-    # in the GIR files. When running tests, the library is not yet installed,
-    # though, so we need to replace the absolute path with a local one during build.
-    # We are using a symlink that we will delete before installation.
-    mkdir -p $out/lib
-    ln -s $PWD/gobject/libgobject-${librarySuffix} $out/lib/libgobject-${librarySuffix}
-    ln -s $PWD/gio/libgio-${librarySuffix} $out/lib/libgio-${librarySuffix}
-    ln -s $PWD/glib/libglib-${librarySuffix} $out/lib/libglib-${librarySuffix}
-  '';
-
-  postCheck = ''
-    rm $out/lib/libgobject-${librarySuffix}
-    rm $out/lib/libgio-${librarySuffix}
-    rm $out/lib/libglib-${librarySuffix}
-  '';
-
-  separateDebugInfo = stdenv.hostPlatform.isLinux;
-
-  passthru = rec {
-    gioModuleDir = "lib/gio/modules";
-
-    makeSchemaDataDirPath = dir: name: "${dir}/share/gsettings-schemas/${name}";
-    makeSchemaPath = dir: name: "${makeSchemaDataDirPath dir name}/glib-2.0/schemas";
-    getSchemaPath = pkg: makeSchemaPath pkg pkg.name;
-    getSchemaDataDirPath = pkg: makeSchemaDataDirPath pkg pkg.name;
-
-    tests = {
-      withChecks = finalAttrs.finalPackage.overrideAttrs (_: { doCheck = true; });
-      pkg-config = testers.testMetaPkgConfig finalAttrs.finalPackage;
-    };
-
-    updateScript = gnome.updateScript {
-      packageName = "glib";
-      versionPolicy = "odd-unstable";
-    };
-
-    mkHardcodeGsettingsPatch =
-      {
-        src,
-        glib-schema-to-var,
-      }:
-      builtins.trace
-        "glib.mkHardcodeGsettingsPatch is deprecated, please use makeHardcodeGsettingsPatch instead"
-        (makeHardcodeGsettingsPatch {
-          inherit src;
-          schemaIdToVariableMapping = glib-schema-to-var;
-        });
-  };
-
-  meta = with lib; {
-    description = "C library of programming buildings blocks";
-    homepage    = "https://gitlab.gnome.org/GNOME/glib";
-    license     = licenses.lgpl21Plus;
-    maintainers = teams.gnome.members ++ (with maintainers; [ lovek323 raskin ]);
-    pkgConfigModules = [
-      "gio-2.0"
-      "gobject-2.0"
-      "gthread-2.0"
-    ];
-    platforms   = platforms.unix ++ platforms.windows;
-
-    longDescription = ''
-      GLib provides the core application building blocks for libraries
-      and applications written in C.  It provides the core object
-      system used in GNOME, the main loop implementation, and a large
-      set of utility functions for strings and common data structures.
-    '';
-  };
-})

pkgs/development/python-modules/ansitable/default.nix

···
 
 buildPythonPackage rec {
   pname = "ansitable";
-  version = "0.11.3";
+  version = "0.11.4";
   pyproject = true;
 
   disabled = pythonOlder "3.7";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-navayezkSSHgwOysC3fbgTQahRZjIV24JzIAQl+X5Jk=";
+    hash = "sha256-XUjXVs9/ETlbbtvYz8YJqCsP1BFajqQKQfSM+Rvm4O0=";
   };
 
   build-system = [ setuptools ];

pkgs/development/python-modules/awscrt/default.nix

···
 
 buildPythonPackage rec {
   pname = "awscrt";
-  version = "0.23.0";
+  version = "0.23.6";
   format = "setuptools";
 
   disabled = pythonOlder "3.7";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-/fV2FX2CMt3jjpnJ4XjhfWVa1yWmWna7eYO/6npPxig=";
+    hash = "sha256-FMT4E0TseXccmqk4AFlClu5+qknbD7n9FatmKiH634o=";
   };
 
   buildInputs = lib.optionals stdenv.hostPlatform.isDarwin [

pkgs/development/python-modules/azure-servicebus/default.nix

···
 
 buildPythonPackage rec {
   pname = "azure-servicebus";
-  version = "7.12.3";
+  version = "7.13.0";
   pyproject = true;
 
   disabled = pythonOlder "3.8";
···
   src = fetchPypi {
     pname = "azure_servicebus";
     inherit version;
-    hash = "sha256-PwdZcxrSIRxo60sh5byimCf31v8Ccr3H7vEDwcE/gyI=";
+    hash = "sha256-p16aYUNco606eX8di/T90Nhz66nl04OJSsh+9eGnDPA=";
   };
 
   build-system = [ setuptools ];

pkgs/development/python-modules/bandit/default.nix

···
 
 buildPythonPackage rec {
   pname = "bandit";
-  version = "1.7.10";
+  version = "1.8.0";
   pyproject = true;
 
-  disabled = pythonOlder "3.8";
+  disabled = pythonOlder "3.9";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-We1cr12Stq2kv2W8ZDf+6kqdoQkzhERf7U1HKsxs/3s=";
+    hash = "sha256-tb/lWglavZ/iAJkXinxsBg+ES/1P5MdtKONeTFK50x4=";
   };
 
   nativeBuildInputs = [ pbr ];

pkgs/development/python-modules/berkeleydb/default.nix

···
 
 buildPythonPackage rec {
   pname = "berkeleydb";
-  version = "18.1.10";
+  version = "18.1.12";
   pyproject = true;
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-QmNBoWAHqQAtmHpvTZcib46v/8saBIhIgFPTijEnyBo=";
+    hash = "sha256-SVqBecajayLQ+i9ogfp4PPdSIUooV2BSlgX2CBAd6yg=";
   };
 
   build-system = [ setuptools ];

pkgs/development/python-modules/bottleneck/default.nix

···
 
 buildPythonPackage rec {
   pname = "bottleneck";
-  version = "1.4.0";
+  version = "1.4.2";
   format = "setuptools";
 
-  disabled = pythonOlder "3.7";
+  disabled = pythonOlder "3.9";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-vrNt9Rm4cJ59NXwMljmwO4hcpjVbv15TdSxoXeUWBbg=";
+    hash = "sha256-+o6OF5nepUg85maUYmYPnZqVZJ9vmKgNMVuE7In0SfQ=";
   };
 
   propagatedBuildInputs = [ numpy ];

pkgs/development/python-modules/cloudsmith-api/default.nix

···
 
 buildPythonPackage rec {
   pname = "cloudsmith-api";
-  version = "2.0.13";
+  version = "2.0.16";
   format = "wheel";
 
   disabled = pythonOlder "3.7";
···
   src = fetchPypi {
     pname = "cloudsmith_api";
     inherit format version;
-    hash = "sha256-xPPARaxclTRy7thJXtXaMK0F5/91q7o35LyzSmx1HPU=";
+    hash = "sha256-Hgg2mwBdUwW26h0mkgTIFLyigefAENDItQ0EvPGAOc0=";
   };
 
   propagatedBuildInputs = [

pkgs/development/python-modules/confluent-kafka/default.nix

···
 
 buildPythonPackage rec {
   pname = "confluent-kafka";
-  version = "2.5.3";
+  version = "2.6.1";
   pyproject = true;
 
   disabled = pythonOlder "3.7";
···
   src = fetchFromGitHub {
     owner = "confluentinc";
     repo = "confluent-kafka-python";
-    rev = "refs/tags/v${version}";
-    hash = "sha256-b9RTz4wUtDzGkoeB0cp5vbZEBk8jSw2JiXEx6tUuPVw=";
+    tag = "v${version}";
+    hash = "sha256-SFmZ/KriysvLkGT5mvIS9SJcUHWmvZXrqFAY0lC6bGc=";
   };
 
   buildInputs = [ rdkafka ];

pkgs/development/python-modules/consolekit/default.nix

···
 }:
 buildPythonPackage rec {
   pname = "consolekit";
-  version = "1.7.1";
+  version = "1.7.2";
   pyproject = true;
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-TU5sufqJ0znCD/QOidrT7jB1NCXJ1p8Z7FPFNPp97qg=";
+    hash = "sha256-3qa58lA2nquII99W+SGEQHHlb1BRrAWdihUOiQYmcns=";
   };
 
   build-system = [ flit-core ];

pkgs/development/python-modules/cx-freeze/default.nix

···
 {
   lib,
+  stdenv,
   buildPythonPackage,
   distutils,
   fetchPypi,
···
   packaging,
   setuptools,
   filelock,
-  wheel,
   patchelf,
+  tomli,
+  importlib-metadata,
+  typing-extensions,
+  dmgbuild,
 }:
 
 buildPythonPackage rec {
   pname = "cx-freeze";
-  version = "7.2.2";
+  version = "7.2.7";
   pyproject = true;
 
-  disabled = pythonOlder "3.11";
+  disabled = pythonOlder "3.8";
 
   src = fetchPypi {
     pname = "cx_freeze";
     inherit version;
-    hash = "sha256-6bLEvWjr9PuZtq8v8oHA5TewSa7pSIBcxKAo4XGKvGo=";
+    hash = "sha256-xNQ6TlNXNSrFqJID/aOoz63wM9Q2gvc6u+/ThgzlD7Q=";
   };
 
   postPatch = ''
···
 
   build-system = [
     setuptools
-    wheel
   ];
 
   buildInputs = [ ncurses ];
 
-  dependencies = [
-    distutils
-    filelock
-    packaging
-    setuptools
-    wheel
-  ];
+  dependencies =
+    [
+      distutils
+      packaging
+      setuptools
+    ]
+    ++ lib.optionals (pythonOlder "3.11") [
+      tomli
+    ]
+    ++ lib.optionals (pythonOlder "3.10") [
+      importlib-metadata
+      typing-extensions
+    ]
+    ++ lib.optional stdenv.hostPlatform.isLinux filelock
+    ++ lib.optional stdenv.hostPlatform.isDarwin dmgbuild;
 
   makeWrapperArgs = [
     "--prefix"

pkgs/development/python-modules/django-pgactivity/default.nix

···
 
 buildPythonPackage rec {
   pname = "django-pgactivity";
-  version = "1.7.0";
+  version = "1.7.1";
   pyproject = true;
 
   src = fetchFromGitHub {
-    owner = "Opus10";
+    owner = "AmbitionEng";
     repo = "django-pgactivity";
     tag = version;
-    hash = "sha256-XJDnNMhkoaRQBVsAdDqnFjOobUHi/RaMQZJnI61MuVI=";
+    hash = "sha256-PDJJf0PI5aqFn1HODv6wRSgTCr9ajfpPSDCB8twrFcQ=";
   };
 
   build-system = [ poetry-core ];
···
 
   meta = {
     description = "View, filter, and kill Postgres queries";
-    homepage = "https://github.com/Opus10/django-pgactivity";
-    changelog = "https://github.com/Opus10/django-pgactivity/blob/${version}/CHANGELOG.md";
+    homepage = "https://github.com/AmbitionEng/django-pgactivity";
+    changelog = "https://github.com/AmbitionEng/django-pgactivity/blob/${version}/CHANGELOG.md";
     license = lib.licenses.bsd3;
     maintainers = with lib.maintainers; [ jopejoe1 ];
   };

pkgs/development/python-modules/django-pglock/default.nix

···
 
 buildPythonPackage rec {
   pname = "django-pglock";
-  version = "1.7.0";
+  version = "1.7.1";
   pyproject = true;
 
   src = fetchFromGitHub {
-    owner = "Opus10";
+    owner = "AmbitionEng";
     repo = "django-pglock";
     tag = version;
-    hash = "sha256-7PBZvI4OTDIZjjLWnfOwGAdEJr3D6snmR20hPboLvXc=";
+    hash = "sha256-WbifapA2A0grxePozwDSPzREIzmgBV+V5wpA9jeYfJ8=";
   };
 
   build-system = [ poetry-core ];
···
 
   meta = {
     description = "Postgres advisory locks, table locks, and blocking lock management";
-    homepage = "https://github.com/Opus10/django-pglock";
-    changelog = "https://github.com/Opus10/django-pglock/blob/${version}/CHANGELOG.md";
+    homepage = "https://github.com/AmbitionEng/django-pglock";
+    changelog = "https://github.com/AmbitionEng/django-pglock/blob/${version}/CHANGELOG.md";
     license = lib.licenses.bsd3;
     maintainers = with lib.maintainers; [ jopejoe1 ];
   };

pkgs/development/python-modules/django-soft-delete/default.nix

···
 
 buildPythonPackage rec {
   pname = "django-soft-delete";
-  version = "1.0.14";
+  version = "1.0.16";
   pyproject = true;
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-Qo31bqT7sT9C1PdS8R8qUXqjGsPRtFDmt4xMXV2d/Ds=";
+    hash = "sha256-zEA5jM2GnHWm1rp/Um4WxK/isMCBHCE6MY2Wu0xYp4c=";
   };
 
   dependencies = [ django ];

pkgs/development/python-modules/dploot/default.nix

···
 
 buildPythonPackage rec {
   pname = "dploot";
-  version = "3.0.0";
+  version = "3.0.3";
   pyproject = true;
 
-  disabled = pythonOlder "3.7";
+  disabled = pythonOlder "3.10";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-G39dzP5A6ZySo7AhDIZWXjhtk2zm15wSnrdknLqHHcY=";
+    hash = "sha256-MBuO9anCe8wDD+72pR/bFrV5pAmEIWY2pKSvPSTq0yQ=";
   };
 
   pythonRelaxDeps = [

pkgs/development/python-modules/etils/default.nix

···
 
 buildPythonPackage rec {
   pname = "etils";
-  version = "1.10.0";
+  version = "1.11.0";
   pyproject = true;
 
   disabled = pythonOlder "3.10";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-Tqqdckj9Tut15E1HyimHWlzOoETMFKF0NXlL+KwRagU=";
+    hash = "sha256-r/Mnijvn/d8wLf2AM16fkkJEZmxxI5zZHoNvPQVfHEo=";
   };
 
   nativeBuildInputs = [ flit-core ];

pkgs/development/python-modules/fabio/default.nix

···
 
 buildPythonPackage rec {
   pname = "fabio";
-  version = "2024.4.0";
+  version = "2024.9.0";
   pyproject = true;
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-NPVxu4sZ7hIvrHrh1iRakraa5fj1cUnH259tTDByRNc=";
+    hash = "sha256-+HPfUfRoUxwRqufgzYihTyIfTvCUMfvFpspnse1HU1s=";
   };
 
   pythonImportsCheck = [ "fabio" ];

pkgs/development/python-modules/flask-restx/default.nix

···
   pytest-flask,
   pytest-mock,
   pytest-benchmark,
+  pytest-vcr,
   pytestCheckHook,
   setuptools,
 }:
···
     pytest-benchmark
     pytest-flask
     pytest-mock
+    pytest-vcr
     pytestCheckHook
   ];
 
···
     ];
 
   disabledTests = [
+    "test_specs_endpoint_host_and_subdomain"
     # broken in werkzeug 2.3 upgrade
     "test_media_types_method"
     "test_media_types_q"

pkgs/development/python-modules/githubkit/default.nix

···
 
 buildPythonPackage rec {
   pname = "githubkit";
-  version = "0.12.1";
+  version = "0.12.3";
   pyproject = true;
 
   disabled = pythonOlder "3.9";
···
     owner = "yanyongyu";
     repo = "githubkit";
     tag = "v${version}";
-    hash = "sha256-ewPCALnkGDhzxn3P9GO5QUaFZDhqsbQNeCmyTCXd7kE=";
+    hash = "sha256-sI24tSvwbh+zPTPVjkNlBg7TM6D5qMxfeF4pfj+6Q+E=";
   };
 
   pythonRelaxDeps = [ "hishel" ];

pkgs/development/python-modules/glyphslib/default.nix

···
 
 buildPythonPackage rec {
   pname = "glyphslib";
-  version = "6.9.0";
+  version = "6.9.5";
 
   format = "pyproject";
 
···
     owner = "googlefonts";
     repo = "glyphsLib";
     rev = "refs/tags/v${version}";
-    hash = "sha256-NanqjZZkxrhPaBsR+FrARvsO3vdT2MYnWFtkO0hpbQg=";
+    hash = "sha256-9b4nPiGyBsTplEhfmPdhjalV0fexYXerdRqUbOUXlh0=";
   };
 
   nativeBuildInputs = [ setuptools-scm ];

pkgs/development/python-modules/gnureadline/default.nix

···
 }:
 
 buildPythonPackage rec {
-  version = "8.2.10";
+  version = "8.2.13";
   format = "setuptools";
   pname = "gnureadline";
   disabled = isPyPy;
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-p0a6mNTeN7B55C2Um3BMM8FoswvR+QcaHSXJ2ppEmZc=";
+    hash = "sha256-ybnh57qZqAu1DBICfWzmkldPd6Zb9XvJcEHPgcD0m9E=";
   };
 
   buildInputs = [ pkgs.ncurses ];

pkgs/development/python-modules/google-cloud-dataproc/default.nix

···
 
 buildPythonPackage rec {
   pname = "google-cloud-dataproc";
-  version = "5.12.0";
+  version = "5.16.0";
   pyproject = true;
 
   disabled = pythonOlder "3.7";
···
   src = fetchPypi {
     pname = "google_cloud_dataproc";
     inherit version;
-    hash = "sha256-S1jXIPAgxONTeKKeqHzoKGr2Mes7w4LMvL/zncAZnik=";
+    hash = "sha256-I7LYrk9kjgG2b+0KvqEUtgDTNj2VW4VYx2Rak/KNbjw=";
   };
 
   build-system = [ setuptools ];

pkgs/development/python-modules/google-cloud-dlp/default.nix

···
 
 buildPythonPackage rec {
   pname = "google-cloud-dlp";
-  version = "3.25.1";
+  version = "3.26.0";
   pyproject = true;
 
   disabled = pythonOlder "3.7";
···
   src = fetchPypi {
     pname = "google_cloud_dlp";
     inherit version;
-    hash = "sha256-6R4CSOyB+beTUPNtj8wQc7uQmMUxhyO8lebV0PDu1Lg=";
+    hash = "sha256-+kxjk9deiNQU+Vhjs53Xpgo/UZEtA2gDylr7WR1obzQ=";
   };
 
   build-system = [ setuptools ];

pkgs/development/python-modules/hg-evolve/default.nix

···
 
 buildPythonPackage rec {
   pname = "hg-evolve";
-  version = "11.1.4";
+  version = "11.1.6";
   format = "setuptools";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-Yph2g254fSnPVfgmkmeRSqlmsUfHgP+wqN0GHLIV/wc=";
+    hash = "sha256-Jun1gZYZXv8nuJBnberK1bcTPTLCDgGGd543OeOEVOs=";
   };
 
   nativeCheckInputs = [ mercurial ];

pkgs/development/python-modules/import-expression/default.nix

···
   pytestCheckHook,
   pythonOlder,
   setuptools,
-  typing-extensions,
 }:
 
 buildPythonPackage rec {
   pname = "import-expression";
-  version = "2.1.0.post1";
+  version = "2.2.1.post1";
   pyproject = true;
 
   disabled = pythonOlder "3.9";
···
   src = fetchPypi {
     pname = "import_expression";
     inherit version;
-    hash = "sha256-mclYGeuISXUDrOS1mhpVgDp1439KnHAwzHKIbRtdibQ=";
+    hash = "sha256-HIMb8mvvft82qXs0xoe5Yuer4GEWxm8A4U+aMhhiPU8=";
   };
 
   build-system = [ setuptools ];
-
-  dependencies = [ typing-extensions ];
 
   nativeCheckInputs = [ pytestCheckHook ];
 

pkgs/development/python-modules/influxdb-client/default.nix

···
 
 buildPythonPackage rec {
   pname = "influxdb-client";
-  version = "1.47.0";
+  version = "1.48.0";
   pyproject = true;
 
   disabled = pythonOlder "3.7";
···
     owner = "influxdata";
     repo = "influxdb-client-python";
     rev = "refs/tags/v${version}";
-    hash = "sha256-1QWy+mdVttowdbIBmtW6gYwkJ4p9sL0D+DxsHk3xgvc=";
+    hash = "sha256-MKTfRsqizZDXPMqJAypUDQBm+a2s6FaEG3TM30wucrI=";
   };
 
   build-system = [ setuptools ];

pkgs/development/python-modules/jianpu-ly/default.nix

···
 
 buildPythonPackage rec {
   pname = "jianpu-ly";
-  version = "1.801";
+  version = "1.826";
   pyproject = true;
 
   src = fetchPypi {
     inherit version;
     pname = "jianpu_ly";
-    hash = "sha256-piK9Ym94cKdaHGz/ogX7ylyAF1ww0jCdRXnHN6lu2MI=";
+    hash = "sha256-9vNCwXCOEHG2WNu8nDqCKJ3Z4vrsfX1lwKvkVGRrPPA=";
   };
 
   dependencies = [ lilypond ];

pkgs/development/python-modules/json-repair/default.nix

···
 
 buildPythonPackage rec {
   pname = "json-repair";
-  version = "0.32.0";
+  version = "0.35.0";
   pyproject = true;
 
   src = fetchFromGitHub {
     owner = "mangiucugna";
     repo = "json_repair";
     tag = "v${version}";
-    hash = "sha256-js2XTplrRZyyVHztA3yGicdjfBFNoUTvjzT/U2NESWQ=";
+    hash = "sha256-39MxXX3bBYLmpaUpNYLWq+8Huoy0zQSyURQiZvXFaZc=";
   };
 
   build-system = [ setuptools ];
 
-  nativeBuildInputs = [ pytestCheckHook ];
+  nativeCheckInputs = [ pytestCheckHook ];
 
   disabledTestPaths = [
     "tests/test_performance.py"

pkgs/development/python-modules/langcodes/default.nix

···
 
 buildPythonPackage rec {
   pname = "langcodes";
-  version = "3.4.1";
-  format = "pyproject";
+  version = "3.5.0";
+  pyproject = true;
 
-  disabled = pythonOlder "3.6";
+  disabled = pythonOlder "3.9";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-okh5/tI4ATrDryQkudESTji0o4sgRP0pfI/zjlkS5xg=";
+    hash = "sha256-Hu+BaNB+UeExokl//srUtmP2II58OuO43BXFFzSm+AE=";
   };
 
-  nativeBuildInputs = [
+  build-system = [
     setuptools
     setuptools-scm
   ];
 
-  propagatedBuildInputs = [
+  dependencies = [
     language-data
     marisa-trie
     setuptools # pkg_resources import in language_data/util.py

pkgs/development/python-modules/libusbsio/default.nix

···
 buildPythonPackage rec {
   pname = "libusbsio";
   format = "setuptools";
-  version = "2.1.12";
+  version = "2.1.13";
   # If the versions come back into sync switch back to inheriting from c lib
   # inherit (libusbsio) version;
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-RdUhwilBOwg19ay3Po3zsxqlBV9FTy3btJDbO4YEKS8=";
+    hash = "sha256-3xudSyqfXq3wsFdOgBeGK1nSY0NZjx9UhmTqbQGXWyU=";
   };
 
   # The source includes both the python module directly and also prebuilt binaries

pkgs/development/python-modules/limnoria/default.nix

···
 
 buildPythonPackage rec {
   pname = "limnoria";
-  version = "2024.8.26";
+  version = "2024.12.20";
   pyproject = true;
 
   disabled = pythonOlder "3.6";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-X1Nvm7bccwHn9KIKQuRb+mLzUwEdeiLNkzyxKa2Jk8Y=";
+    hash = "sha256-e8YvB29tggssX8aMRSoLvprsSBWeKVKfhDrSZeA2rCQ=";
   };
 
   build-system = [ setuptools ];

pkgs/development/python-modules/line-profiler/default.nix

···
 
 buildPythonPackage rec {
   pname = "line-profiler";
-  version = "4.1.3";
+  version = "4.2.0";
   format = "setuptools";
 
-  disabled = pythonOlder "3.6" || isPyPy;
+  disabled = pythonOlder "3.8" || isPyPy;
 
   src = fetchPypi {
     pname = "line_profiler";
     inherit version;
-    hash = "sha256-5fESPDZywyGLoGPCO9ZKURWeRGSf7WeAuZPHgfte0xg=";
+    hash = "sha256-CeEPJfh2UUOAs/rubek/sMIoq7qFgguhpZHds+tFGpY=";
   };
 
   nativeBuildInputs = [

pkgs/development/python-modules/linode-api/default.nix

···
 
 buildPythonPackage rec {
   pname = "linode-api";
-  version = "5.22.0";
+  version = "5.25.0";
   pyproject = true;
 
   disabled = pythonOlder "3.6";
···
   src = fetchFromGitHub {
     owner = "linode";
     repo = "python-linode-api";
-    rev = "refs/tags/v${version}";
-    hash = "sha256-f9v9xhlOfSCKEWHmzi/tpoMIXccGwA6isoAAIZOf3r4=";
+    tag = "v${version}";
+    hash = "sha256-rEBMZft4o7R2e0N7x1ZEaCisRmhKggMbZWdtDvraoD0=";
   };
 
   nativeBuildInputs = [ setuptools ];

pkgs/development/python-modules/manuel/default.nix

···
 
 buildPythonPackage rec {
   pname = "manuel";
-  version = "1.12.4";
+  version = "1.13.0";
   format = "setuptools";
   disabled = isPy27;
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-A5Wq32mR+SSseVz61Z2l3AYYcyqMxYrQ9HSWWrco9/Q=";
+    hash = "sha256-XWMSDej6bZJ3gLaa4oqj6dFmmxCvPTJ4Xz+6EaW+iFo=";
   };
 
   patches = lib.optionals (lib.versionAtLeast python.version "3.11") [

pkgs/development/python-modules/marimo/default.nix

···
 
 buildPythonPackage rec {
   pname = "marimo";
-  version = "0.9.27";
+  version = "0.10.5";
   pyproject = true;
 
   # The github archive does not include the static assets
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-vs1miLjM/xRrnFYpHte65CfDt4ZRoCKjFMClWukIWZY=";
+    hash = "sha256-KJKnGVOM0ahZOWDXHyS5meRS1xXypKzgo3X9RvD1tJs=";
   };
 
   build-system = [ hatchling ];

pkgs/development/python-modules/mecab-python3/default.nix

···
 
 buildPythonPackage rec {
   pname = "mecab-python3";
-  version = "1.0.9";
+  version = "1.0.10";
   format = "setuptools";
 
   disabled = pythonOlder "3.7";
···
   src = fetchPypi {
     pname = "mecab_python3";
     inherit version;
-    hash = "sha256-LYkfSgEZ+3Zvp5bijYgaVXk6DDVE5EbP9k3JRq1yJ8w=";
+    hash = "sha256-Ic1EFgQ+mpk/z7mG3ek+Q2agdUPdlYSbXvLlDJqa/M4=";
   };
 
   nativeBuildInputs = [

pkgs/development/python-modules/meraki/default.nix

···
 
 buildPythonPackage rec {
   pname = "meraki";
-  version = "1.52.0";
+  version = "1.53.0";
   format = "setuptools";
 
   disabled = pythonOlder "3.8";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-8fNrHRZZ58FW0UOBdbUUzI3y+Y6kAyue4uHnPoODdzw=";
+    hash = "sha256-GC07gpx0Yeajm8LPcHFtkz/Uuc4kO46TUQs58/IEzyg=";
   };
 
   propagatedBuildInputs = [

pkgs/development/python-modules/mkdocs-git-authors-plugin/default.nix

···
 
 buildPythonPackage rec {
   pname = "mkdocs-git-authors-plugin";
-  version = "0.9.0";
+  version = "0.9.2";
   format = "setuptools";
 
-  disabled = pythonOlder "3.7";
+  disabled = pythonOlder "3.8";
 
   src = fetchFromGitHub {
     owner = "timvink";
     repo = "mkdocs-git-authors-plugin";
-    rev = "refs/tags/v${version}";
-    hash = "sha256-UomcEXWNt5aVE9JxP9wskkHkFYXKN/+jXwr1SXCmeyE=";
+    tag = "v${version}";
+    hash = "sha256-2ITro34lZ+tz7ev7Yuh1wJjsSNik6VUTt3dupIajmLU=";
   };
 
   propagatedBuildInputs = [ mkdocs ];

pkgs/development/python-modules/mkdocs-material/default.nix

···
 
 buildPythonPackage rec {
   pname = "mkdocs-material";
-  version = "9.5.39";
+  version = "9.5.45";
   pyproject = true;
 
   disabled = pythonOlder "3.7";
···
     owner = "squidfunk";
     repo = "mkdocs-material";
     rev = "refs/tags/${version}";
-    hash = "sha256-ArCd7NbqvPw3kHJd4MG62FplgXwW1gFTfdCHZqfxuqU=";
+    hash = "sha256-uhUatalHcObQbar1xbdR44FnQs/+qS4ad0sdB2jH/OU=";
   };
 
   nativeBuildInputs = [

pkgs/development/python-modules/num2words/default.nix

···
 }:
 
 buildPythonPackage rec {
-  version = "0.5.13";
+  version = "0.5.14";
   format = "setuptools";
   pname = "num2words";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-owZHFvu/kNdcRJRQzr+8c6ahPmOyUx0JvezDqxoiCc8=";
+    hash = "sha256-sGbsGOVrZhajs4CGtXR9qvuqiGiyJqNhJ+BFHAzzecY=";
   };
 
   propagatedBuildInputs = [ docopt ];

pkgs/development/python-modules/oci/default.nix

···
   fetchFromGitHub,
   pyopenssl,
   python-dateutil,
-  pythonOlder,
   pytz,
   setuptools,
 }:
 
 buildPythonPackage rec {
   pname = "oci";
-  version = "2.139.0";
-  format = "setuptools";
-
-  disabled = pythonOlder "3.7";
+  version = "2.141.1";
+  pyproject = true;
 
   src = fetchFromGitHub {
     owner = "oracle";
     repo = "oci-python-sdk";
     tag = "v${version}";
-    hash = "sha256-FjP68c1h97KwCCuqLVB677YyR4/HMstGfwlLUqdtNLU=";
+    hash = "sha256-D2iaEK25ryU1oRRahnlC3wuEIxtyjR6rAa7TXFTaRi4=";
   };
 
   pythonRelaxDeps = [
···
     "pyOpenSSL"
   ];
 
-  nativeBuildInputs = [
-    setuptools
-  ];
+  build-system = [ setuptools ];
 
-  propagatedBuildInputs = [
+  dependencies = [
     certifi
     circuitbreaker
     cryptography
···
 
   pythonImportsCheck = [ "oci" ];
 
-  meta = with lib; {
+  meta = {
     description = "Oracle Cloud Infrastructure Python SDK";
     homepage = "https://github.com/oracle/oci-python-sdk";
     changelog = "https://github.com/oracle/oci-python-sdk/blob/v${version}/CHANGELOG.rst";
-    license = with licenses; [
+    license = with lib.licenses; [
       asl20 # or
       upl
     ];
-    maintainers = with maintainers; [ ilian ];
+    maintainers = with lib.maintainers; [ ilian ];
   };
 }

pkgs/development/python-modules/panel/default.nix

···
 
 buildPythonPackage rec {
   pname = "panel";
-  version = "1.5.1";
+  version = "1.5.5";
 
   format = "wheel";
 
···
   # tries to fetch even more artifacts
   src = fetchPypi {
     inherit pname version format;
-    hash = "sha256-cglT8X3x6tb5ewWluKdTNDi4lFUQqeJQIBSmHGAGDmI=";
+    hash = "sha256-MfdvzTr+OoawjPGstBAhK7XpkqgVxk/CMApYsllRVv0=";
     dist = "py3";
     python = "py3";
   };

pkgs/development/python-modules/parsedmarc/default.nix

···
 in
 buildPythonPackage rec {
   pname = "parsedmarc";
-  version = "8.15.4";
+  version = "8.16.0";
   pyproject = true;
 
   disabled = pythonOlder "3.7";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-lxW92jlSWgGVxOO+CwIZi5sKHqoZuR5VQCnDVORXmXU=";
+    hash = "sha256-yoDvEja9UIubfWfpfEE/LhPa085QM3B5TmiwOPRBDDA=";
   };
 
   nativeBuildInputs = [

pkgs/development/python-modules/peewee/default.nix

···
 
 buildPythonPackage rec {
   pname = "peewee";
-  version = "3.17.7";
+  version = "3.17.8";
   pyproject = true;
 
   disabled = pythonOlder "3.7";
···
     owner = "coleifer";
     repo = "peewee";
     rev = "refs/tags/${version}";
-    hash = "sha256-j10c3mnrHISk04l65ieUB11jt3a3iiQsroTt/L0tKaw=";
+    hash = "sha256-2mViwo39adzzhpFS056C1JU5fXr3zKorzkVyJrKKRhI=";
   };
 
   build-system = [ setuptools ];

pkgs/development/python-modules/py-scrypt/default.nix

···
 
 buildPythonPackage rec {
   pname = "py-scrypt";
-  version = "0.8.24";
+  version = "0.8.27";
 
   src = fetchPypi {
     pname = "scrypt";
     inherit version;
-    hash = "sha256-mP/eReSpVGHXPe1UunomhXZ5kg1Pj/Mg9vet5uKVMb0=";
+    hash = "sha256-p7Y3hI7VGMHqKzGp7Kqj9JYWWY2EQt6HBs8fAfur8Kc=";
   };
 
   buildInputs = [ openssl ];

pkgs/development/python-modules/pydata-sphinx-theme/default.nix

···
 
 buildPythonPackage rec {
   pname = "pydata-sphinx-theme";
-  version = "0.16.0";
+  version = "0.16.1";
 
   format = "wheel";
 
···
     dist = "py3";
     python = "py3";
     pname = "pydata_sphinx_theme";
-    hash = "sha256-GMgQ7k5n4FKB43HhVsH7W7D6HydHJARhsiUnL32NV9g=";
+    hash = "sha256-IlMx6KxLMmgsGPysWlem9xfE5jLOpd0OJHtVFV+uzN4=";
   };
 
   propagatedBuildInputs = [

pkgs/development/python-modules/pydrive2/default.nix

···
     description = "Google Drive API Python wrapper library";
     homepage = "https://github.com/iterative/PyDrive2";
     changelog = "https://github.com/iterative/PyDrive2/releases/tag/${version}";
+    # Not compatible with pyopenssl 24.3.0
+    # https://github.com/iterative/PyDrive2/issues/361
+    # TODO: re-enable it in `duplicity` when fixed
+    broken = true;
     license = licenses.asl20;
     maintainers = with maintainers; [ sei40kr ];
   };

pkgs/development/python-modules/pyexcel/default.nix

···
 
 buildPythonPackage rec {
   pname = "pyexcel";
-  version = "0.7.0";
+  version = "0.7.1";
   format = "setuptools";
 
   disabled = !isPy3k;
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-+/Du5dk7ls728ZqfAHA/IsCmTxlyjZG5VCgAmlISlwk=";
+    hash = "sha256-yHWZHB3pAUBjRdE8fd5sSs/V8IsWr2xKiBpSxsPDqwY=";
   };
 
   propagatedBuildInputs = [

pkgs/development/python-modules/pyinstaller/default.nix

···
 
 buildPythonPackage rec {
   pname = "pyinstaller";
-  version = "6.11.0";
+  version = "6.11.1";
   pyproject = true;
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-y01DOj2zDZ0Xz18s97tN+Ap4jUk8HWfdgi3FeR2YZK8=";
+    hash = "sha256-SR37TZ1dHZZQ2VB9rsH/aClSeiVNjjlrrdYKCv/Lcu8=";
   };
 
   build-system = [ setuptools ];

pkgs/development/python-modules/pylibftdi/default.nix

···
 
 buildPythonPackage rec {
   pname = "pylibftdi";
-  version = "0.22.0";
+  version = "0.23.0";
   pyproject = true;
 
   disabled = pythonOlder "3.7";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-haaqtDj3ZTQoQ6otWbso+7DTCEemIfuYAJhRhZkPAa8=";
+    hash = "sha256-v1tMa6c9eab234ScNFsAunY9AjIBvtm6Udh2pDl7Ftg=";
   };
 
   build-system = [ poetry-core ];

pkgs/development/python-modules/pymssql/default.nix

···
 
 buildPythonPackage rec {
   pname = "pymssql";
-  version = "2.3.1";
+  version = "2.3.2";
   pyproject = true;
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-3e4VxMGT4UyS/izXIMqb4duh4PQXgkA4C49fbwDaBMY=";
+    hash = "sha256-GAiWQbaHvh69D2Tw0f+XdHijl/+hrzcr3xDb7CnPbS4=";
   };
 
   build-system = [

pkgs/development/python-modules/pyspellchecker/default.nix

···
 
 buildPythonPackage rec {
   pname = "pyspellchecker";
-  version = "0.8.1";
+  version = "0.8.2";
   format = "pyproject";
 
   src = fetchFromGitHub {
     owner = "barrust";
     repo = "pyspellchecker";
-    rev = "refs/tags/v${version}";
-    hash = "sha256-8IwTMj/RqMc9UqhzyvmrirPGuMEwj3iMr+FmF+8312U=";
+    tag = "v${version}";
+    hash = "sha256-sQNYtm+EK/F4S/Kfy87MwqDjCfV33/v8bYi48UBz+qc=";
   };
 
   nativeBuildInputs = [ setuptools ];

pkgs/development/python-modules/pytapo/default.nix

···
 
 buildPythonPackage rec {
   pname = "pytapo";
-  version = "3.3.32";
+  version = "3.3.37";
   pyproject = true;
 
   disabled = pythonOlder "3.7";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-OYRcgX30O0/F+0H4x2jbPyVNh6xVeBSdfqbtuqUgoNE=";
+    hash = "sha256-InDbfWzRb+Q+E6feeatHIliq83g83oUfo3Yze/BAJdM=";
   };
 
   build-system = [ setuptools ];

pkgs/development/python-modules/python-sql/default.nix

···
 
 buildPythonPackage rec {
   pname = "python-sql";
-  version = "1.5.1";
+  version = "1.5.2";
   format = "setuptools";
 
   disabled = pythonOlder "3.7";
···
   src = fetchPypi {
     pname = "python_sql";
     inherit version;
-    hash = "sha256-93RnHx0IT6a6Q4mJJM3r5O0NAHHfjWCAQKzU8cjYaqM=";
+    hash = "sha256-c19SNyGHy5VrGu6MoHADn3O6iRO7i33vlC78FNUGzTY=";
   };
 
   nativeCheckInputs = [ pytestCheckHook ];

pkgs/development/python-modules/pyvcd/default.nix

···
 }:
 
 buildPythonPackage rec {
-  version = "0.4.0";
+  version = "0.4.1";
   format = "setuptools";
   pname = "pyvcd";
   disabled = pythonOlder "3.6";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-Mb4/UBRBqbjF3HJmD/e5z++bQ7ISGiPZb1htKGMnApA=";
+    hash = "sha256-3GJ16Vp5SbgjYIarLm0Dr+3nNEEkPsUQnJ6okHfz1pY=";
   };
 
   buildInputs = [ setuptools-scm ];

pkgs/development/python-modules/pywebpush/default.nix

···
 
 buildPythonPackage rec {
   pname = "pywebpush";
-  version = "2.0.1";
+  version = "2.0.3";
   pyproject = true;
 
   disabled = pythonOlder "3.6";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-cuNYauyJoGNzwFheb5fG/QuBUZ5B8yiWo2OZCez0XbA=";
+    hash = "sha256-WEh448JD6HOiLbiJVQXZVxW8eW73TMG4/pn1lhdBYeM=";
   };
 
   build-system = [ setuptools ];

pkgs/development/python-modules/redshift-connector/default.nix

···
 
 buildPythonPackage rec {
   pname = "redshift-connector";
-  version = "2.1.3";
+  version = "2.1.5";
   format = "setuptools";
 
   disabled = pythonOlder "3.6";
···
   src = fetchFromGitHub {
     owner = "aws";
     repo = "amazon-redshift-python-driver";
-    rev = "refs/tags/v${version}";
-    hash = "sha256-NjUgmvmy0buBFpXjcEsZU0F2JNeXE3GBpkaxClvo4T0=";
+    tag = "v${version}";
+    hash = "sha256-q8OF8osAfnAXL1BSgnhE3vQpLHfD/8vPeU2+wCCGSQs=";
   };
 
   # remove addops as they add test directory and coverage parameters to pytest

pkgs/development/python-modules/reportlab/default.nix

···
 in
 buildPythonPackage rec {
   pname = "reportlab";
-  version = "4.2.4";
+  version = "4.2.5";
   pyproject = true;
 
   # See https://bitbucket.org/pypy/compatibility/wiki/reportlab%20toolkit
···
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-oAtXKS4VanvahO3zHWDCVXgVMHbI+5YzHQxZ7d2gUsg=";
+    hash = "sha256-XPNbj9YJtoCArHu7CuHjdhBPfV97LTkUx63GPyWTlB8=";
   };
 
   postPatch = ''

pkgs/development/python-modules/returns/default.nix

···
 
 buildPythonPackage rec {
   pname = "returns";
-  version = "0.23.0";
-  format = "pyproject";
+  version = "0.24.0";
+  pyproject = true;
 
-  disabled = pythonOlder "3.7";
+  disabled = pythonOlder "3.10";
 
   src = fetchFromGitHub {
     owner = "dry-python";
     repo = "returns";
-    rev = "refs/tags/${version}";
-    hash = "sha256-4ZP/wvPgqQQec/BaXuL9r7BEc2G+LztMdFul0NeEJTc=";
+    tag = version;
+    hash = "sha256-qmBxW1XxUlFpAqf2t2ix01TN5NSxOtnYqLyE5ovZU58=";
   };
 
   postPatch = ''

pkgs/development/python-modules/rjsmin/default.nix

···
 
 buildPythonPackage rec {
   pname = "rjsmin";
-  version = "1.2.2";
+  version = "1.2.3";
   format = "setuptools";
 
   disabled = pythonOlder "3.7";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-jBvNghFD/s8jJCAStV4TYQhAqDnNRns1jxY1kBDWLa4=";
+    hash = "sha256-E4i1JJOkwE+8lwotdXwwH6BaPDdkAxTCzp38jYpzDMY=";
   };
 
   # The package does not ship tests, and the setup machinary confuses

pkgs/development/python-modules/roombapy/default.nix

···
 
 buildPythonPackage rec {
   pname = "roombapy";
-  version = "1.8.1";
+  version = "1.8.2";
   pyproject = true;
 
   disabled = pythonOlder "3.10";
···
     owner = "pschmitt";
     repo = "roombapy";
     rev = "refs/tags/${version}";
-    hash = "sha256-1yfmaTzZ7cZW2+Yb3Zbo8+5TfD+H1sA0+SzC1c9MdsQ=";
+    hash = "sha256-plmdGVfrkdz7pyyAztzZKlDpUjKxBIRtDVeBXoqaB5s=";
   };
 
   nativeBuildInputs = [

pkgs/development/python-modules/rotary-embedding-torch/default.nix

···
 
 buildPythonPackage rec {
   pname = "rotary-embedding-torch";
-  version = "0.8.5";
+  version = "0.8.6";
   pyproject = true;
 
   src = fetchFromGitHub {
     owner = "lucidrains";
     repo = "rotary-embedding-torch";
-    rev = "refs/tags/${version}";
-    hash = "sha256-sd2zi0dKXLo9HCFDQrLr4icaJnwWeMPoaeTV8qaoyhQ=";
+    tag = version;
+    hash = "sha256-4/vKf5RwWbiFYKCQo4kAQzXLM85L4CwaL/MR7/xTkH8=";
   };
 
   nativeBuildInputs = [

pkgs/development/python-modules/simplemma/default.nix

···
 
 buildPythonPackage rec {
   pname = "simplemma";
-  version = "1.1.1";
+  version = "1.1.2";
   pyproject = true;
 
   src = fetchFromGitHub {
     owner = "adbar";
     repo = "simplemma";
     rev = "refs/tags/v${version}";
-    hash = "sha256-X0mqFPdCo0/sTexv4bi4bND7LFHOJvlOPH6tB39ybZY=";
+    hash = "sha256-aFN/cOSqsrTJ5GMw0/SM7uoC+T1RhDTQFf8AF00Tz/o=";
   };
 
   build-system = [

pkgs/development/python-modules/sopel/default.nix

···
 
 buildPythonPackage rec {
   pname = "sopel";
-  version = "8.0.0";
+  version = "8.0.1";
   pyproject = true;
 
   disabled = isPyPy || pythonOlder "3.7";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-juLJp0Et5qMZwBZzw0e4tKg1cBYqAsH8KUzqNoIP70U=";
+    hash = "sha256-Z9Tcn2lb5a7c6aVbhPjuO6trrZQwSBA1iaMiDzpe+DA=";
   };
 
   build-system = [ setuptools ];

pkgs/development/python-modules/sphinxawesome-theme/default.nix

···
 
 buildPythonPackage rec {
   pname = "sphinxawesome-theme";
-  version = "5.2.0";
+  version = "5.3.2";
   pyproject = true;
 
   src = fetchPypi {
     inherit version;
     pname = "sphinxawesome_theme";
-    hash = "sha256-wk8eXAueR1OA0W/F8fO/2ElVgX2gkF2V9+IICdfNPF0=";
+    hash = "sha256-BinTi4Cu/CebEYbFOnpvryHnIbWy7NoU9IjKEHTiYx8=";
   };
 
   build-system = [ poetry-core ];

pkgs/development/python-modules/strawberry-graphql/default.nix

···
 
 buildPythonPackage rec {
   pname = "strawberry-graphql";
-  version = "0.253.1";
+  version = "0.254.0";
   pyproject = true;
 
   disabled = pythonOlder "3.10";
···
   src = fetchFromGitHub {
     owner = "strawberry-graphql";
     repo = "strawberry";
-    rev = "refs/tags/${version}";
-    hash = "sha256-lerQynV/c0fLX+Du1j9bX0i2kvuWKmtH7RIBZxuDkK8=";
+    tag = version;
+    hash = "sha256-lD5TQvBxv4+1fuDHoX45kkTFRHrURRL2jLH/rPfCzzA=";
   };
 
   postPatch = ''

pkgs/development/python-modules/torchdiffeq/default.nix

···
 
 buildPythonPackage rec {
   pname = "torchdiffeq";
-  version = "0.2.4";
+  version = "0.2.5";
   format = "setuptools";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-wOV8PIif7dp/I6YBXb/Nba5QcqBt1u0Q6CAMIAmEQEM=";
+    hash = "sha256-tQ03YNE/0TjczqxlH0uAOW9E/vzr0DegM/7P6qnMEuc=";
   };
 
   propagatedBuildInputs = [

pkgs/development/python-modules/types-dateutil/default.nix

···
 
 buildPythonPackage rec {
   pname = "types-dateutil";
-  version = "2.9.0.20240906";
+  version = "2.9.0.20241003";
   pyproject = true;
 
   src = fetchPypi {
     pname = "types-python-dateutil";
     inherit version;
-    hash = "sha256-lwbDtoKEwlrf/Ecxnsx5R+W7hrN3P4Q8c5Bv1Zi8F24=";
+    hash = "sha256-WMuFRJsqVtZoTkGu77TEKAYxJGoNoacZvb5vP7AxdEY=";
   };
 
   nativeBuildInputs = [ setuptools ];

pkgs/development/python-modules/types-redis/default.nix

···
 
 buildPythonPackage rec {
   pname = "types-redis";
-  version = "4.6.0.20240903";
+  version = "4.6.0.20241004";
   pyproject = true;
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-S6saN42/I8LJXDcN/biajwM5V8T9GlP+5xtSnBgv4Ag=";
+    hash = "sha256-XxfSs/kJGrdThBU7+idmGf+hz2o42mDhDV5nScxbkC4=";
   };
 
   build-system = [ setuptools ];

pkgs/development/python-modules/types-s3transfer/default.nix

···
 
 buildPythonPackage rec {
   pname = "types-s3transfer";
-  version = "0.10.2";
+  version = "0.10.4";
   pyproject = true;
 
   disabled = pythonOlder "3.8";
···
   src = fetchPypi {
     pname = "types_s3transfer";
     inherit version;
-    hash = "sha256-YBZ6O/tcU27GzbWBj3+aKO3KncPgtf+FrjdFJvxeV24=";
+    hash = "sha256-AxI0d+MGTIHv5xK/nTcsfHLyeQcRQx+bqlnPlupgcmc=";
   };
 
   build-system = [ setuptools ];

pkgs/development/python-modules/virtualenvwrapper/default.nix

···
 
 buildPythonPackage rec {
   pname = "virtualenvwrapper";
-  version = "6.1.0";
+  version = "6.1.1";
   format = "setuptools";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-1Ge+rFpEvgD7XNG88zI5jD2rX7O9OveBXqhrTWuz06Q=";
+    hash = "sha256-ES5+o0qaPOkKrqVBgvDTr+9NGpE+63XpiiY7SXjNc8Y=";
   };
 
   # pip depend on $HOME setting

pkgs/development/python-modules/viv-utils/default.nix

···
 
 buildPythonPackage rec {
   pname = "viv-utils";
-  version = "0.7.11";
+  version = "0.7.13";
   pyproject = true;
 
   disabled = pythonOlder "3.9";
···
     owner = "williballenthin";
     repo = "viv-utils";
     rev = "refs/tags/v${version}";
-    hash = "sha256-zYamhG5oeoYYVLEvv1EdZ1buFDByZatuCxbl0uRhk6Y=";
+    hash = "sha256-NiXLNsRQ/ah+fB2r91A1oqf/8Yt95Vdt2JQFJE73HXo=";
   };
 
   build-system = [ setuptools-scm ];

pkgs/development/python-modules/waitress-django/default.nix

···
   waitress,
 }:
 
-let
-  fs = lib.fileset;
-in
-
 buildPythonPackage {
   pname = "waitress-django";
   version = "1.0.0";
   pyproject = true;
 
-  src = fs.toSource {
-    root = ./.;
-    fileset = fs.unions [
-      ./setup.py
-      ./src
-    ];
-  };
+  src = ./src;
 
   build-system = [ setuptools ];
 

pkgs/development/python-modules/waitress-django/setup.py pkgs/development/python-modules/waitress-django/src/setup.py

···
      , description  = "A waitress WSGI server serving django"
      , author       = "Bas van Dijk"
      , author_email = "[e-mail]"
-     , package_dir  = {"" : "src"}
-     , scripts      = ["src/waitress-serve-django"]
+     , scripts      = ["waitress-serve-django"]
      )

pkgs/development/python-modules/wheel-inspect/default.nix

···
 
 buildPythonPackage rec {
   pname = "wheel-inspect";
-  version = "1.7.1";
+  version = "1.7.2";
   pyproject = true;
 
   disabled = pythonOlder "3.6";
···
     owner = "jwodder";
     repo = "wheel-inspect";
     rev = "refs/tags/v${version}";
-    hash = "sha256-pB9Rh+A7GlxnYuka2mTSBoxpoyYCzoaMPVgsHDlpos0=";
+    hash = "sha256-Mdw9IlY/2qDlb5FumNH+VHmg7vrUzo3vn+03QsUGgo8=";
   };
 
   pythonRelaxDeps = [

pkgs/development/python-modules/yark/default.nix

···
 
 buildPythonPackage rec {
   pname = "yark";
-  version = "1.2.10";
+  version = "1.2.12";
   pyproject = true;
 
   disabled = pythonOlder "3.9";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-Y1fWHpvrqGuBPyJ2dO2y0W2zhEgcTJABtkOAoZ7uyZU=";
+    hash = "sha256-K66LC/HhajAMCWU7PPfxkoaK84kLlAccYAH5FXoc+yE=";
   };
 
   pythonRelaxDeps = [

pkgs/development/python-modules/zope-testrunner/default.nix

···
 
 buildPythonPackage rec {
   pname = "zope.testrunner";
-  version = "6.4";
+  version = "6.6";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-C4Wfx01vK2xd2K353uTsdAX3PykOyrJXCsY2+DYSKMg=";
+    hash = "sha256-sReX6XWocHseM7ZUTKz5A3KHiG7leA7P7UvxiZ1CFe8=";
   };
 
   propagatedBuildInputs = [

pkgs/development/tools/misc/linuxkit/default.nix

···
 
 buildGoModule rec {
   pname = "linuxkit";
-  version = "1.5.2";
+  version = "1.5.3";
 
   src = fetchFromGitHub {
     owner = "linuxkit";
     repo = "linuxkit";
     rev = "v${version}";
-    sha256 = "sha256-M/M4m/vsvvtSDnNNy8p6x+xpv1QmVzyfPRf/BNBX7zA=";
+    sha256 = "sha256-dCRTBy2Nbl5KP8dxXt+1ww1BF/gWm3PfLtSBAaVcBvw=";
   };
 
   vendorHash = null;

pkgs/development/tools/yarn2nix-moretea/yarn2nix/default.nix pkgs/development/tools/yarn2nix-moretea/default.nix

···
     });
 
   yarn2nix = mkYarnPackage {
-    src = lib.fileset.toSource {
-      root = ./.;
-      fileset = lib.fileset.unions [
-        ./bin
-        ./lib
-        ./package.json
-        ./yarn.lock
-      ];
-    };
+    src = ./yarn2nix;
 
     # yarn2nix is the only package that requires the yarnNix option.
     # All the other projects can auto-generate that file.
···
     # Using the filter above and importing package.json from the filtered
     # source results in an error in restricted mode. To circumvent this,
     # we import package.json from the unfiltered source
-    packageJSON = ./package.json;
+    packageJSON = ./yarn2nix/package.json;
 
     yarnFlags = defaultYarnFlags ++ [ "--ignore-scripts" "--production=true" ];
 
···
     mkdir -p $out/lib
     mkdir -p $out/bin
 
-    cp ${./lib/urlToName.js} $out/lib/urlToName.js
+    cp ${./yarn2nix/lib/urlToName.js} $out/lib/urlToName.js
     cp ${./internal/fixup_yarn_lock.js} $out/bin/fixup_yarn_lock
 
     patchShebangs $out

pkgs/servers/monitoring/prometheus/mongodb-exporter.nix

···
 
 buildGoModule rec {
   pname = "mongodb_exporter";
-  version = "0.43.0";
+  version = "0.43.1";
 
   src = fetchFromGitHub {
     owner = "percona";
     repo = "mongodb_exporter";
     rev = "v${version}";
-    hash = "sha256-MmevWy5RJaSC1ocuuxqFYpagyjIaHBbd5PQ8HfCF0R0=";
+    hash = "sha256-lf5sh9ADz1L5thNsjj1EdGJGuNmlcFOMUxwOUZUf8Xo=";
   };
 
-  vendorHash = "sha256-VHQdmEOCHTwszUUOF5JTbBWacgLM6MyuxAC6FNFD5PI=";
+  vendorHash = "sha256-c5PET4xGR2RzgOW9gUxo2JB/P1XO1JgWr2hQ/vGfk6E=";
 
   ldflags = [
     "-s"

pkgs/servers/web-apps/bookstack/default.nix

···
 in
 package.override rec {
   pname = "bookstack";
-  version = "24.10.3";
+  version = "24.12";
 
   src = fetchFromGitHub {
     owner = "bookstackapp";
     repo = pname;
     rev = "v${version}";
-    sha256 = "11gbzx5qb79vknrs2ci5g21jxz7sxm3b69m0xhqpkbpdfnrgp4pl";
+    sha256 = "sha256-7ZC4C84XNGAR8efwQsupbAQbRGA8LUixuDoirCHPkiQ=";
   };
 
   meta = with lib; {

pkgs/shells/carapace/default.nix

···
 
 buildGoModule rec {
   pname = "carapace";
-  version = "1.1.0";
+  version = "1.1.1";
 
   src = fetchFromGitHub {
     owner = "carapace-sh";
     repo = "carapace-bin";
     rev = "v${version}";
-    hash = "sha256-UUWZ/ZI8GTwvS8811Uzc8CjBsM/9ALxJLSFnzEE5pi4=";
+    hash = "sha256-4tsqzXQwLTJ3icoCFJAmUWEXvv/RwzBnOXJd4vXOE7s=";
   };
 
-  vendorHash = "sha256-Fd1tbeBfbGnhOfowas2lF90TwjoRwOuk5xx9GhYEiRc=";
+  vendorHash = "sha256-8EuPHhTNK+7OnjYKAdkSmIS/iZR2AYrDw4nfY5ixYIo=";
 
   ldflags = [
     "-s"

pkgs/test/haskell/cabalSdist/default.nix

···
 }:
 
 let
-  src = lib.fileset.toSource {
-    root = ./local;
-    fileset = lib.fileset.unions [
-      ./local/app
-      ./local/CHANGELOG.md
-      ./local/local.cabal
-    ];
-  };
-  # This prevents the source from depending on the formatting of the ./local/generated.nix file
-  localRaw = haskell.lib.compose.overrideSrc {
-    inherit src;
-  } (haskellPackages.callPackage ./local/generated.nix { });
+  localRaw = haskellPackages.callPackage ./generated.nix { };
 in
 lib.recurseIntoAttrs rec {
 
···
 
   localFromCabalSdist = haskellPackages.buildFromCabalSdist localRaw;
 
-  # NOTE: ./local refers to the "./." path in `./local/generated.nix`.
   # This test makes sure that localHasNoDirectReference can actually fail if
   # it doesn't do anything. If this test fails, either the test setup was broken,
   # or Haskell packaging has changed the way `src` is treated in such a way that
···
         drvPath = builtins.unsafeDiscardOutputDependency localRaw.drvPath;
       }
       ''
-        grep ${src} $drvPath >/dev/null
+        grep ${localRaw.src} $drvPath >/dev/null
         touch $out
       '';
 
···
         drvPath = builtins.unsafeDiscardOutputDependency localFromCabalSdist.drvPath;
       }
       ''
-        grep -v ${src} $drvPath >/dev/null
+        grep -v ${localRaw.src} $drvPath >/dev/null
         touch $out
       '';
 }

pkgs/test/haskell/cabalSdist/local/generated.nix pkgs/test/haskell/cabalSdist/generated.nix

···
-# nix run ../../../../..#cabal2nix -- ./.
+# nix run ../../../../..#cabal2nix -- ./local
 {
   mkDerivation,
   base,
···
 mkDerivation {
   pname = "local";
   version = "0.1.0.0";
-  src = ./.; # also referred to as ./local in the test; these are the same path constants
+  src = ./local;
   isLibrary = false;
   isExecutable = true;
   executableHaskellDepends = [ base ];
   description = "Nixpkgs test case";
   license = lib.licenses.mit;
+  mainProgram = "local";
 }

pkgs/test/haskell/setBuildTarget/default.nix

···
 { pkgs, haskellPackages }:
 
 let
-  # This can be regenerated by running `cabal2nix .` in the current directory.
+  # This can be regenerated by running `cabal2nix ./src` in the current directory.
   pkgDef =
     {
       mkDerivation,
···
     mkDerivation {
       pname = "haskell-setBuildTarget";
       version = "0.1.0.0";
-      src = lib.fileset.toSource {
-        root = ./.;
-        fileset = lib.fileset.unions [
-          ./haskell-setBuildTarget.cabal
-          ./Bar.hs
-          ./Foo.hs
-          ./Setup.hs
-        ];
-      };
+      src = ./src;
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base ];
-      license = lib.licenses.bsd3;
+      license = "unknown";
     };
 
   drv = haskellPackages.callPackage pkgDef { };

pkgs/test/make-binary-wrapper/default.nix

···
     runCommand "make-binary-wrapper-test-${testname}" env ''
       mkdir -p tmp/foo # for the chdir test
 
-      source=${
-        lib.fileset.toSource {
-          root = ./.;
-          fileset = lib.fileset.unions [
-            (./. + "/${testname}.cmdline")
-            (./. + "/${testname}.c")
-            (lib.fileset.maybeMissing (./. + "/${testname}.env"))
-          ];
-        }
-      }
+      source=${./${testname}}
 
       params=$(<"$source/${testname}.cmdline")
       eval "makeCWrapper /send/me/flags $params" > wrapper.c

pkgs/tools/package-management/apk-tools/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "apk-tools";
-  version = "2.14.5";
+  version = "2.14.7";
 
   src = fetchFromGitLab {
     domain = "gitlab.alpinelinux.org";
     owner = "alpine";
     repo = "apk-tools";
     rev = "v${version}";
-    sha256 = "sha256-GtWwLQoN0106uErEDjPrwlz8pmOKdV3OrtfisFhGqoY=";
+    sha256 = "sha256-4MA+wP8G1Qbv8mbzx1R0eFG7gbwUAfSAFJZ6ulrBHUY=";
   };
 
   nativeBuildInputs = [ pkg-config scdoc ]

pkgs/tools/security/gotrue/supabase.nix

···
 
 buildGoModule rec {
   pname = "auth";
-  version = "2.165.1";
+  version = "2.166.0";
 
   src = fetchFromGitHub {
     owner = "supabase";
     repo = "auth";
     rev = "v${version}";
-    hash = "sha256-Tp8h20GM2YULlElFtHS41rFyWSIT3EGGXKtExkuO5P8=";
+    hash = "sha256-e4PLop+enPt0IkPYRNH0UyZwiBhQKsk0mTFXokGcLug=";
   };
 
-  vendorHash = "sha256-w6qbqHHdXdDYHO5Asa0fkf0UBI7Wr2Voc2K4Ss1zDCE=";
+  vendorHash = "sha256-em1dBnNHsVPI7owd2gjERcJnrQbiVtZGtIqnFyker6M=";
 
   ldflags = [
     "-s"

pkgs/top-level/all-packages.nix

···
 
   qosmic = libsForQt5.callPackage ../applications/graphics/qosmic { };
 
-  qownnotes = qt6Packages.callPackage ../applications/office/qownnotes {
-    stdenv = if stdenv.hostPlatform.isDarwin then darwin.apple_sdk_11_0.stdenv else stdenv;
-  };
-
   qtikz = libsForQt5.callPackage ../applications/graphics/ktikz { };
 
   qtspim = libsForQt5.callPackage ../development/tools/misc/qtspim { };
···
 
   yarn-berry = callPackage ../development/tools/yarn-berry { };
 
-  yarn2nix-moretea = callPackage ../development/tools/yarn2nix-moretea/yarn2nix { pkgs = pkgs.__splicedPackages; };
+  yarn2nix-moretea = callPackage ../development/tools/yarn2nix-moretea { pkgs = pkgs.__splicedPackages; };
 
   inherit (yarn2nix-moretea)
     yarn2nix
···
 
   grantlee = libsForQt5.callPackage ../development/libraries/grantlee { };
 
-  glib = callPackage ../development/libraries/glib (let
+  glib = callPackage ../by-name/gl/glib/package.nix (let
     glib-untested = glib.overrideAttrs { doCheck = false; };
   in {
     # break dependency cycles

pkgs/top-level/default.nix

···
 , # Allow a configuration attribute set to be passed in as an argument.
   config ? {}
 
+, # Temporary hack to let Nixpkgs forbid internal use of `lib.fileset`
+  # until <https://github.com/NixOS/nix/issues/11503> is fixed.
+  __allowFileset ? true
+
 , # List of overlays layers used to extend Nixpkgs.
   overlays ? []
 
···
   crossSystem0 = crossSystem;
 
 in let
-  lib = import ../../lib;
+  pristineLib = import ../../lib;
+
+  lib =
+    if __allowFileset then
+      pristineLib
+    else
+      pristineLib.extend (_: _: {
+        fileset = abort ''
+
+          The use of `lib.fileset` is currently forbidden in Nixpkgs due to the
+          upstream Nix bug <https://github.com/NixOS/nix/issues/11503>. This
+          causes difficult‐to‐debug errors when combined with chroot stores,
+          such as in the NixOS installer.
+
+          For packages that require source to be vendored inside Nixpkgs,
+          please use a subdirectory of the package instead.
+        '';
+      });
 
   inherit (lib) throwIfNot;
 

pkgs/top-level/release-cross.nix

···
 , # Strip most of attributes when evaluating to spare memory usage
   scrubJobs ? true
 , # Attributes passed to nixpkgs. Don't build packages marked as unfree.
-  nixpkgsArgs ? { config = { allowUnfree = false; inHydra = true; }; }
+  nixpkgsArgs ? {
+    config = { allowUnfree = false; inHydra = true; };
+    __allowFileset = false;
+  }
 }:
 
 let

pkgs/top-level/release-cuda.nix

···
       "${variant}Support" = true;
       inHydra = true;
     };
+
+    __allowFileset = false;
   },
   ...
 }@args:

pkgs/top-level/release-lib.nix

···
 , packageSet ? (import ../..)
 , scrubJobs ? true
 , # Attributes passed to nixpkgs. Don't build packages marked as unfree.
-  nixpkgsArgs ? { config = { allowUnfree = false; inHydra = true; }; }
+  nixpkgsArgs ? {
+    config = { allowUnfree = false; inHydra = true; };
+    __allowFileset = false;
+  }
 }:
 
 let

pkgs/top-level/release-outpaths.nix

···
 
             inHydra = true;
           };
+
+          __allowFileset = false;
         };
       };
   recurseIntoAttrs = attrs: attrs // { recurseForDerivations = true; };

pkgs/top-level/release-python.nix

···
       allowUnfree = false;
       inHydra = true;
     };
+
+    __allowFileset = false;
   },
 }:
 

pkgs/top-level/release-small.nix

···
       allowUnfree = false;
       inHydra = true;
     };
+
+    __allowFileset = false;
   },
 }:
 

pkgs/top-level/release-unfree-redistributable.nix

···
       cudaSupport = true;
       inHydra = true;
     };
+
+    __allowFileset = false;
   },
   # We only build the full package set on infrequently releasing channels.
   full ? false,

pkgs/top-level/release.nix

···
   # Strip most of attributes when evaluating to spare memory usage
 , scrubJobs ? true
   # Attributes passed to nixpkgs. Don't build packages marked as unfree.
-, nixpkgsArgs ? { config = {
-    allowUnfree = false;
-    inHydra = true;
-    # Exceptional unsafe packages that we still build and distribute,
-    # so users choosing to allow don't have to rebuild them every time.
-    permittedInsecurePackages = [
-      "olm-3.2.16" # see PR #347899
-      "kanidm_1_3-1.3.3"
-    ];
-  }; }
+, nixpkgsArgs ? {
+    config = {
+      allowUnfree = false;
+      inHydra = true;
+      # Exceptional unsafe packages that we still build and distribute,
+      # so users choosing to allow don't have to rebuild them every time.
+      permittedInsecurePackages = [
+        "olm-3.2.16" # see PR #347899
+        "kanidm_1_3-1.3.3"
+      ];
+    };
+
+    __allowFileset = false;
+  }
 
   # This flag, if set to true, will inhibit the use of `mapTestOn`
   # and `release-lib.packagePlatforms`.  Generally, it causes the