Merge staging-next into staging

maintainers/maintainer-list.nix

···
     githubId = 57130301;
     keys = [ { fingerprint = "1CC5 B67C EB9A 13A5 EDF6 F10E 0B4A 3662 FC58 9202"; } ];
   };
-  jonafato = {
-    email = "[e-mail]";
-    github = "jonafato";
-    githubId = 392720;
-    name = "Jon Banafato";
-  };
   jonas-w = {
     email = "[e-mail]";
     github = "jonas-w";
···
     github = "philtaken";
     githubId = 13309623;
     name = "Philipp Herzog";
+  };
+  PhilVoel = {
+    github = "PhilVoel";
+    githubId = 56931301;
+    name = "Philipp Völler";
   };
   phip1611 = {
     email = "[e-mail]";

nixos/maintainers/scripts/ec2/amazon-image.nix

···
-{ config, lib, pkgs, ... }:
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}:
 
 let
-  inherit (lib) mkOption optionalString types versionAtLeast;
+  inherit (lib)
+    mkOption
+    optionalString
+    types
+    versionAtLeast
+    ;
   inherit (lib.options) literalExpression;
   cfg = config.amazonImage;
   amiBootMode = if config.ec2.efi then "uefi" else "legacy-bios";
+  virtualisationOptions = import ../../../modules/virtualisation/virtualisation-options.nix;
 
-in {
-
-  imports = [ ../../../modules/virtualisation/amazon-image.nix ];
+in
+{
+  imports = [
+    ../../../modules/virtualisation/amazon-image.nix
+    virtualisationOptions.diskSize
+    (lib.mkRenamedOptionModuleWith {
+      sinceRelease = 2411;
+      from = [
+        "virtualisation"
+        "amazonImage"
+        "sizeMB"
+      ];
+      to = [
+        "virtualisation"
+        "diskSize"
+      ];
+    })
+  ];
 
   # Amazon recommends setting this to the highest possible value for a good EBS
   # experience, which prior to 4.15 was 255.
   # https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/nvme-ebs-volumes.html#timeout-nvme-ebs-volumes
   config.boot.kernelParams =
-    let timeout =
-      if versionAtLeast config.boot.kernelPackages.kernel.version "4.15"
-      then "4294967295"
-      else  "255";
-    in [ "nvme_core.io_timeout=${timeout}" ];
+    let
+      timeout =
+        if versionAtLeast config.boot.kernelPackages.kernel.version "4.15" then "4294967295" else "255";
+    in
+    [ "nvme_core.io_timeout=${timeout}" ];
 
   options.amazonImage = {
     name = mkOption {
···
           }
         ]
       '';
-      default = [];
+      default = [ ];
       description = ''
         This option lists files to be copied to fixed locations in the
         generated image. Glob patterns work.
       '';
     };
 
-    sizeMB = mkOption {
-      type = with types; either (enum [ "auto" ]) int;
-      default = 3072;
-      example = 8192;
-      description = "The size in MB of the image";
-    };
-
     format = mkOption {
-      type = types.enum [ "raw" "qcow2" "vpc" ];
+      type = types.enum [
+        "raw"
+        "qcow2"
+        "vpc"
+      ];
       default = "vpc";
       description = "The image format to output";
     };
   };
 
-  config.system.build.amazonImage = let
-    configFile = pkgs.writeText "configuration.nix"
-      ''
+  config.virtualisation.diskSize = lib.mkDefault (3 * 1024);
+  config.virtualisation.diskSizeAutoSupported = !config.ec2.zfs.enable;
+
+  config.system.build.amazonImage =
+    let
+      configFile = pkgs.writeText "configuration.nix" ''
         { modulesPath, ... }: {
           imports = [ "''${modulesPath}/virtualisation/amazon-image.nix" ];
           ${optionalString config.ec2.efi ''
···
         }
       '';
 
-    zfsBuilder = import ../../../lib/make-multi-disk-zfs-image.nix {
-      inherit lib config configFile pkgs;
-      inherit (cfg) contents format name;
+      zfsBuilder = import ../../../lib/make-multi-disk-zfs-image.nix {
+        inherit
+          lib
+          config
+          configFile
+          pkgs
+          ;
+        inherit (cfg) contents format name;
 
-      includeChannel = true;
+        includeChannel = true;
 
-      bootSize = 1000; # 1G is the minimum EBS volume
+        bootSize = 1000; # 1G is the minimum EBS volume
 
-      rootSize = cfg.sizeMB;
-      rootPoolProperties = {
-        ashift = 12;
-        autoexpand = "on";
-      };
+        rootSize = config.virtualisation.diskSize;
+        rootPoolProperties = {
+          ashift = 12;
+          autoexpand = "on";
+        };
 
-      datasets = config.ec2.zfs.datasets;
+        datasets = config.ec2.zfs.datasets;
 
-      postVM = ''
-        extension=''${rootDiskImage##*.}
-        friendlyName=$out/${cfg.name}
-        rootDisk="$friendlyName.root.$extension"
-        bootDisk="$friendlyName.boot.$extension"
-        mv "$rootDiskImage" "$rootDisk"
-        mv "$bootDiskImage" "$bootDisk"
+        postVM = ''
+           extension=''${rootDiskImage##*.}
+           friendlyName=$out/${cfg.name}
+           rootDisk="$friendlyName.root.$extension"
+           bootDisk="$friendlyName.boot.$extension"
+           mv "$rootDiskImage" "$rootDisk"
+           mv "$bootDiskImage" "$bootDisk"
 
-        mkdir -p $out/nix-support
-        echo "file ${cfg.format} $bootDisk" >> $out/nix-support/hydra-build-products
-        echo "file ${cfg.format} $rootDisk" >> $out/nix-support/hydra-build-products
+           mkdir -p $out/nix-support
+           echo "file ${cfg.format} $bootDisk" >> $out/nix-support/hydra-build-products
+           echo "file ${cfg.format} $rootDisk" >> $out/nix-support/hydra-build-products
 
-       ${pkgs.jq}/bin/jq -n \
-         --arg system_label ${lib.escapeShellArg config.system.nixos.label} \
-         --arg system ${lib.escapeShellArg pkgs.stdenv.hostPlatform.system} \
-         --arg root_logical_bytes "$(${pkgs.qemu_kvm}/bin/qemu-img info --output json "$rootDisk" | ${pkgs.jq}/bin/jq '."virtual-size"')" \
-         --arg boot_logical_bytes "$(${pkgs.qemu_kvm}/bin/qemu-img info --output json "$bootDisk" | ${pkgs.jq}/bin/jq '."virtual-size"')" \
-         --arg boot_mode "${amiBootMode}" \
-         --arg root "$rootDisk" \
-         --arg boot "$bootDisk" \
-        '{}
-          | .label = $system_label
-          | .boot_mode = $boot_mode
-          | .system = $system
-          | .disks.boot.logical_bytes = $boot_logical_bytes
-          | .disks.boot.file = $boot
-          | .disks.root.logical_bytes = $root_logical_bytes
-          | .disks.root.file = $root
-          ' > $out/nix-support/image-info.json
-      '';
-    };
+          ${pkgs.jq}/bin/jq -n \
+            --arg system_label ${lib.escapeShellArg config.system.nixos.label} \
+            --arg system ${lib.escapeShellArg pkgs.stdenv.hostPlatform.system} \
+            --arg root_logical_bytes "$(${pkgs.qemu_kvm}/bin/qemu-img info --output json "$rootDisk" | ${pkgs.jq}/bin/jq '."virtual-size"')" \
+            --arg boot_logical_bytes "$(${pkgs.qemu_kvm}/bin/qemu-img info --output json "$bootDisk" | ${pkgs.jq}/bin/jq '."virtual-size"')" \
+            --arg boot_mode "${amiBootMode}" \
+            --arg root "$rootDisk" \
+            --arg boot "$bootDisk" \
+           '{}
+             | .label = $system_label
+             | .boot_mode = $boot_mode
+             | .system = $system
+             | .disks.boot.logical_bytes = $boot_logical_bytes
+             | .disks.boot.file = $boot
+             | .disks.root.logical_bytes = $root_logical_bytes
+             | .disks.root.file = $root
+             ' > $out/nix-support/image-info.json
+        '';
+      };
 
-    extBuilder = import ../../../lib/make-disk-image.nix {
-      inherit lib config configFile pkgs;
+      extBuilder = import ../../../lib/make-disk-image.nix {
+        inherit
+          lib
+          config
+          configFile
+          pkgs
+          ;
 
-      inherit (cfg) contents format name;
+        inherit (cfg) contents format name;
 
-      fsType = "ext4";
-      partitionTableType = if config.ec2.efi then "efi" else "legacy+gpt";
+        fsType = "ext4";
+        partitionTableType = if config.ec2.efi then "efi" else "legacy+gpt";
 
-      diskSize = cfg.sizeMB;
+        inherit (config.virtualisation) diskSize;
 
-      postVM = ''
-        extension=''${diskImage##*.}
-        friendlyName=$out/${cfg.name}.$extension
-        mv "$diskImage" "$friendlyName"
-        diskImage=$friendlyName
+        postVM = ''
+           extension=''${diskImage##*.}
+           friendlyName=$out/${cfg.name}.$extension
+           mv "$diskImage" "$friendlyName"
+           diskImage=$friendlyName
 
-        mkdir -p $out/nix-support
-        echo "file ${cfg.format} $diskImage" >> $out/nix-support/hydra-build-products
+           mkdir -p $out/nix-support
+           echo "file ${cfg.format} $diskImage" >> $out/nix-support/hydra-build-products
 
-       ${pkgs.jq}/bin/jq -n \
-         --arg system_label ${lib.escapeShellArg config.system.nixos.label} \
-         --arg system ${lib.escapeShellArg pkgs.stdenv.hostPlatform.system} \
-         --arg logical_bytes "$(${pkgs.qemu_kvm}/bin/qemu-img info --output json "$diskImage" | ${pkgs.jq}/bin/jq '."virtual-size"')" \
-         --arg boot_mode "${amiBootMode}" \
-         --arg file "$diskImage" \
-          '{}
-          | .label = $system_label
-          | .boot_mode = $boot_mode
-          | .system = $system
-          | .logical_bytes = $logical_bytes
-          | .file = $file
-          | .disks.root.logical_bytes = $logical_bytes
-          | .disks.root.file = $file
-          ' > $out/nix-support/image-info.json
-      '';
-    };
-  in if config.ec2.zfs.enable then zfsBuilder else extBuilder;
+          ${pkgs.jq}/bin/jq -n \
+            --arg system_label ${lib.escapeShellArg config.system.nixos.label} \
+            --arg system ${lib.escapeShellArg pkgs.stdenv.hostPlatform.system} \
+            --arg logical_bytes "$(${pkgs.qemu_kvm}/bin/qemu-img info --output json "$diskImage" | ${pkgs.jq}/bin/jq '."virtual-size"')" \
+            --arg boot_mode "${amiBootMode}" \
+            --arg file "$diskImage" \
+             '{}
+             | .label = $system_label
+             | .boot_mode = $boot_mode
+             | .system = $system
+             | .logical_bytes = $logical_bytes
+             | .file = $file
+             | .disks.root.logical_bytes = $logical_bytes
+             | .disks.root.file = $file
+             ' > $out/nix-support/image-info.json
+        '';
+      };
+    in
+    if config.ec2.zfs.enable then zfsBuilder else extBuilder;
 
   meta.maintainers = with lib.maintainers; [ arianvp ];
 }

nixos/maintainers/scripts/openstack/openstack-image-zfs.nix

···
 # nix-build '<nixpkgs/nixos>' -A config.system.build.openstackImage --arg configuration "{ imports = [ ./nixos/maintainers/scripts/openstack/openstack-image.nix ]; }"
 
-{ config, lib, pkgs, ... }:
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}:
 let
   inherit (lib) mkOption types;
   copyChannel = true;
   cfg = config.openstackImage;
   imageBootMode = if config.openstack.efi then "uefi" else "legacy-bios";
+  virtualisationOptions = import ../../../modules/virtualisation/virtualisation-options.nix;
 in
 {
   imports = [
     ../../../modules/virtualisation/openstack-config.nix
-  ] ++ (lib.optional copyChannel ../../../modules/installer/cd-dvd/channel.nix);
+    virtualisationOptions.diskSize
+    (lib.mkRenamedOptionModuleWith {
+      sinceRelease = 2411;
+      from = [
+        "virtualisation"
+        "openstackImage"
+        "sizeMB"
+      ];
+      to = [
+        "virtualisation"
+        "diskSize"
+      ];
+    })
 
+  ] ++ (lib.optional copyChannel ../../../modules/installer/cd-dvd/channel.nix);
 
   options.openstackImage = {
     name = mkOption {
···
 
     ramMB = mkOption {
       type = types.int;
-      default = 1024;
+      default = (3 * 1024);
       description = "RAM allocation for build VM";
     };
 
-    sizeMB = mkOption {
-      type = types.int;
-      default = 8192;
-      description = "The size in MB of the image";
-    };
-
     format = mkOption {
-      type = types.enum [ "raw" "qcow2" ];
+      type = types.enum [
+        "raw"
+        "qcow2"
+      ];
       default = "qcow2";
       description = "The image format to output";
     };
···
       };
     };
 
+    virtualisation.diskSize = lib.mkDefault (8 * 1024);
+    virtualisation.diskSizeAutoSupported = false;
+
     system.build.openstackImage = import ../../../lib/make-single-disk-zfs-image.nix {
       inherit lib config;
       inherit (cfg) contents format name;
       pkgs = import ../../../.. { inherit (pkgs) system; }; # ensure we use the regular qemu-kvm package
 
-      configFile = pkgs.writeText "configuration.nix"
-        ''
-          { modulesPath, ... }: {
-            imports = [ "''${modulesPath}/virtualisation/openstack-config.nix" ];
-            openstack.zfs.enable = true;
-          }
-        '';
+      configFile = pkgs.writeText "configuration.nix" ''
+        { modulesPath, ... }: {
+          imports = [ "''${modulesPath}/virtualisation/openstack-config.nix" ];
+          openstack.zfs.enable = true;
+        }
+      '';
 
       includeChannel = copyChannel;
 
       bootSize = 1000;
       memSize = cfg.ramMB;
-      rootSize = cfg.sizeMB;
+      rootSize = config.virtualisation.diskSize;
       rootPoolProperties = {
         ashift = 12;
         autoexpand = "on";

nixos/modules/profiles/macos-builder.nix

···
-{ config, lib, options, ... }:
+{
+  config,
+  lib,
+  options,
+  ...
+}:
 
 let
   keysDirectory = "/var/keys";
···
   imports = [
     ../virtualisation/qemu-vm.nix
 
+    (lib.mkRenamedOptionModuleWith {
+      sinceRelease = 2411;
+      from = [
+        "virtualisation"
+        "darwin-builder"
+        "diskSize"
+      ];
+      to = [
+        "virtualisation"
+        "diskSize"
+      ];
+    })
+
     # Avoid a dependency on stateVersion
     {
       disabledModules = [
···
       ];
       # swraid's default depends on stateVersion
       config.boot.swraid.enable = false;
-      options.boot.isContainer = lib.mkOption { default = false; internal = true; };
+      options.boot.isContainer = lib.mkOption {
+        default = false;
+        internal = true;
+      };
     }
   ];
+
+  options.virtualisation.description = "The maximum disk space allocated to the runner in megabytes";
 
   options.virtualisation.darwin-builder = with lib; {
-    diskSize = mkOption {
-      default = 20 * 1024;
-      type = types.int;
-      example = 30720;
-      description = "The maximum disk space allocated to the runner in MB";
-    };
     memorySize = mkOption {
       default = 3 * 1024;
       type = types.int;
···
       '';
     };
     workingDirectory = mkOption {
-       default = ".";
-       type = types.str;
-       example = "/var/lib/darwin-builder";
-       description = ''
-         The working directory to use to run the script. When running
-         as part of a flake will need to be set to a non read-only filesystem.
-       '';
+      default = ".";
+      type = types.str;
+      example = "/var/lib/darwin-builder";
+      description = ''
+        The working directory to use to run the script. When running
+        as part of a flake will need to be set to a non read-only filesystem.
+      '';
     };
     hostPort = mkOption {
       default = 31022;
···
         script = hostPkgs.writeShellScriptBin "create-builder" (
           ''
             set -euo pipefail
-          '' +
-          # When running as non-interactively as part of a DarwinConfiguration the working directory
-          # must be set to a writeable directory.
-        (if cfg.workingDirectory != "." then ''
-          ${hostPkgs.coreutils}/bin/mkdir --parent "${cfg.workingDirectory}"
-          cd "${cfg.workingDirectory}"
-        '' else "") + ''
-          KEYS="''${KEYS:-./keys}"
-          ${hostPkgs.coreutils}/bin/mkdir --parent "''${KEYS}"
-          PRIVATE_KEY="''${KEYS}/${user}_${keyType}"
-          PUBLIC_KEY="''${PRIVATE_KEY}.pub"
-          if [ ! -e "''${PRIVATE_KEY}" ] || [ ! -e "''${PUBLIC_KEY}" ]; then
-              ${hostPkgs.coreutils}/bin/rm --force -- "''${PRIVATE_KEY}" "''${PUBLIC_KEY}"
-              ${hostPkgs.openssh}/bin/ssh-keygen -q -f "''${PRIVATE_KEY}" -t ${keyType} -N "" -C 'builder@localhost'
-          fi
-          if ! ${hostPkgs.diffutils}/bin/cmp "''${PUBLIC_KEY}" ${publicKey}; then
-            (set -x; sudo --reset-timestamp ${installCredentials} "''${KEYS}")
-          fi
-          KEYS="$(${hostPkgs.nix}/bin/nix-store --add "$KEYS")" ${lib.getExe config.system.build.vm}
-        '');
+          ''
+          +
+            # When running as non-interactively as part of a DarwinConfiguration the working directory
+            # must be set to a writeable directory.
+            (
+              if cfg.workingDirectory != "." then
+                ''
+                  ${hostPkgs.coreutils}/bin/mkdir --parent "${cfg.workingDirectory}"
+                  cd "${cfg.workingDirectory}"
+                ''
+              else
+                ""
+            )
+          + ''
+            KEYS="''${KEYS:-./keys}"
+            ${hostPkgs.coreutils}/bin/mkdir --parent "''${KEYS}"
+            PRIVATE_KEY="''${KEYS}/${user}_${keyType}"
+            PUBLIC_KEY="''${PRIVATE_KEY}.pub"
+            if [ ! -e "''${PRIVATE_KEY}" ] || [ ! -e "''${PUBLIC_KEY}" ]; then
+                ${hostPkgs.coreutils}/bin/rm --force -- "''${PRIVATE_KEY}" "''${PUBLIC_KEY}"
+                ${hostPkgs.openssh}/bin/ssh-keygen -q -f "''${PRIVATE_KEY}" -t ${keyType} -N "" -C 'builder@localhost'
+            fi
+            if ! ${hostPkgs.diffutils}/bin/cmp "''${PUBLIC_KEY}" ${publicKey}; then
+              (set -x; sudo --reset-timestamp ${installCredentials} "''${KEYS}")
+            fi
+            KEYS="$(${hostPkgs.nix}/bin/nix-store --add "$KEYS")" ${lib.getExe config.system.build.vm}
+          ''
+        );
 
       in
       script.overrideAttrs (old: {
···
     '';
 
     virtualisation = {
-      diskSize = cfg.diskSize;
+      diskSize = lib.mkDefault (20 * 1024);
 
       memorySize = cfg.memorySize;
 
       forwardPorts = [
-        { from = "host"; guest.port = 22; host.port = cfg.hostPort; }
+        {
+          from = "host";
+          guest.port = 22;
+          host.port = cfg.hostPort;
+        }
       ];
 
       # Disable graphics for the builder since users will likely want to run it

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

···
 
   env =
     { NIX_REMOTE = "daemon";
-      SSL_CERT_FILE = "/etc/ssl/certs/ca-certificates.crt"; # Remove in 16.03
       PGPASSFILE = "${baseDir}/pgpass";
       NIX_REMOTE_SYSTEMS = lib.concatStringsSep ":" cfg.buildMachinesFiles;
     } // lib.optionalAttrs (cfg.smtpHost != null) {

nixos/modules/services/matrix/appservice-irc.nix

···
                     '';
                   };
                   ttlSeconds = lib.mkOption {
-                    type = ints.positive;
+                    type = ints.unsigned;
                     default = 3600;
+                    example = 0;
                     description = ''
                       Lifetime in seconds, that generated URLs stay valid.
+
+                      Set the lifetime to 0 to prevent URLs from becoming invalid.
                     '';
                   };
                   bindPort = lib.mkOption {

nixos/modules/system/boot/kexec.nix

···
               exit 1
             fi
             echo "Loading NixOS system via kexec."
-            exec kexec --load $p/kernel --initrd=$p/initrd --append="$(cat $p/kernel-params) init=$p/init"
+            exec kexec --load "$p/kernel" --initrd="$p/initrd" --append="$(cat "$p/kernel-params") init=$p/init"
           '';
       };
   };

nixos/modules/virtualisation/azure-image.nix

···
-{ config, lib, pkgs, ... }:
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}:
 
 with lib;
 let
   cfg = config.virtualisation.azureImage;
+  virtualisationOptions = import ./virtualisation-options.nix;
 in
 {
-  imports = [ ./azure-common.nix ];
+  imports = [
+    ./azure-common.nix
+    virtualisationOptions.diskSize
+    (lib.mkRenamedOptionModuleWith {
+      sinceRelease = 2411;
+      from = [
+        "virtualisation"
+        "azureImage"
+        "diskSize"
+      ];
+      to = [
+        "virtualisation"
+        "diskSize"
+      ];
+    })
+  ];
 
   options.virtualisation.azureImage = {
-    diskSize = mkOption {
-      type = with types; either (enum [ "auto" ]) int;
-      default = "auto";
-      example = 2048;
-      description = ''
-        Size of disk image. Unit is MB.
-      '';
-    };
-
     bootSize = mkOption {
       type = types.int;
       default = 256;
···
     };
 
     vmGeneration = mkOption {
-      type = with types; enum [ "v1" "v2" ];
+      type =
+        with types;
+        enum [
+          "v1"
+          "v2"
+        ];
       default = "v1";
       description = ''
         VM Generation to use.
···
       bootSize = "${toString cfg.bootSize}M";
       partitionTableType = if cfg.vmGeneration == "v2" then "efi" else "legacy";
 
-      inherit (cfg) diskSize contents;
+      inherit (cfg) contents;
+      inherit (config.virtualisation) diskSize;
       inherit config lib pkgs;
     };
   };

nixos/modules/virtualisation/digital-ocean-image.nix

···
-{ config, lib, pkgs, ... }:
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}:
 
 with lib;
 let
   cfg = config.virtualisation.digitalOceanImage;
+  virtualisationOptions = import ./virtualisation-options.nix;
 in
 {
 
-  imports = [ ./digital-ocean-config.nix ];
+  imports = [
+    ./digital-ocean-config.nix
+    virtualisationOptions.diskSize
+    (lib.mkRenamedOptionModuleWith {
+      sinceRelease = 2411;
+      from = [
+        "virtualisation"
+        "digitialOceanImage"
+        "diskSize"
+      ];
+      to = [
+        "virtualisation"
+        "diskSize"
+      ];
+    })
+  ];
 
   options = {
-    virtualisation.digitalOceanImage.diskSize = mkOption {
-      type = with types; either (enum [ "auto" ]) int;
-      default = "auto";
-      example = 4096;
-      description = ''
-        Size of disk image. Unit is MB.
-      '';
-    };
-
     virtualisation.digitalOceanImage.configFile = mkOption {
       type = with types; nullOr path;
       default = null;
···
     };
 
     virtualisation.digitalOceanImage.compressionMethod = mkOption {
-      type = types.enum [ "gzip" "bzip2" ];
+      type = types.enum [
+        "gzip"
+        "bzip2"
+      ];
       default = "gzip";
       example = "bzip2";
       description = ''
···
 
   #### implementation
   config = {
-
     system.build.digitalOceanImage = import ../../lib/make-disk-image.nix {
       name = "digital-ocean-image";
       format = "qcow2";
-      postVM = let
-        compress = {
-          "gzip" = "${pkgs.gzip}/bin/gzip";
-          "bzip2" = "${pkgs.bzip2}/bin/bzip2";
-        }.${cfg.compressionMethod};
-      in ''
-        ${compress} $diskImage
-      '';
-      configFile = if cfg.configFile == null
-        then config.virtualisation.digitalOcean.defaultConfigFile
-        else cfg.configFile;
-      inherit (cfg) diskSize;
+      postVM =
+        let
+          compress =
+            {
+              "gzip" = "${pkgs.gzip}/bin/gzip";
+              "bzip2" = "${pkgs.bzip2}/bin/bzip2";
+            }
+            .${cfg.compressionMethod};
+        in
+        ''
+          ${compress} $diskImage
+        '';
+      configFile =
+        if cfg.configFile == null then
+          config.virtualisation.digitalOcean.defaultConfigFile
+        else
+          cfg.configFile;
+      inherit (config.virtualisation) diskSize;
       inherit config lib pkgs;
     };
 
   };
 
-  meta.maintainers = with maintainers; [ arianvp eamsden ];
+  meta.maintainers = with maintainers; [
+    arianvp
+    eamsden
+  ];
 
 }

nixos/modules/virtualisation/google-compute-image.nix

···
-{ config, lib, pkgs, ... }:
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}:
 
 with lib;
 let
···
       ];
     }
   '';
+  virtualisationOptions = import ./virtualisation-options.nix;
 in
 {
 
-  imports = [ ./google-compute-config.nix ];
+  imports = [
+    ./google-compute-config.nix
+    virtualisationOptions.diskSize
+    (lib.mkRenamedOptionModuleWith {
+      sinceRelease = 2411;
+      from = [
+        "virtualisation"
+        "googleComputeImage"
+        "diskSize"
+      ];
+      to = [
+        "virtualisation"
+        "diskSize"
+      ];
+    })
+  ];
 
   options = {
-    virtualisation.googleComputeImage.diskSize = mkOption {
-      type = with types; either (enum [ "auto" ]) int;
-      default = "auto";
-      example = 1536;
-      description = ''
-        Size of disk image. Unit is MB.
-      '';
-    };
-
     virtualisation.googleComputeImage.configFile = mkOption {
       type = with types; nullOr str;
       default = null;
···
     system.build.googleComputeImage = import ../../lib/make-disk-image.nix {
       name = "google-compute-image";
       postVM = ''
-        PATH=$PATH:${with pkgs; lib.makeBinPath [ gnutar gzip ]}
+        PATH=$PATH:${
+          with pkgs;
+          lib.makeBinPath [
+            gnutar
+            gzip
+          ]
+        }
         pushd $out
         mv $diskImage disk.raw
         tar -Sc disk.raw | gzip -${toString cfg.compressionLevel} > \
···
       format = "raw";
       configFile = if cfg.configFile == null then defaultConfigFile else cfg.configFile;
       partitionTableType = if cfg.efi then "efi" else "legacy";
-      inherit (cfg) diskSize;
+      inherit (config.virtualisation) diskSize;
       inherit config lib pkgs;
     };
 

nixos/modules/virtualisation/hyperv-image.nix

···
-{ config, pkgs, lib, ... }:
+{
+  config,
+  pkgs,
+  lib,
+  ...
+}:
 
 with lib;
 
 let
   cfg = config.hyperv;
+  virtualisationOptions = import ./virtualisation-options.nix;
 
-in {
+in
+{
+
+  imports = [
+    virtualisationOptions.diskSize
+    (lib.mkRenamedOptionModuleWith {
+      sinceRelease = 2411;
+      from = [
+        "virtualisation"
+        "hyperv"
+        "baseImageSize"
+      ];
+      to = [
+        "virtualisation"
+        "diskSize"
+      ];
+    })
+  ];
+
   options = {
     hyperv = {
-      baseImageSize = mkOption {
-        type = with types; either (enum [ "auto" ]) int;
-        default = "auto";
-        example = 2048;
-        description = ''
-          The size of the hyper-v base image in MiB.
-        '';
-      };
       vmDerivationName = mkOption {
         type = types.str;
         default = "nixos-hyperv-${config.system.nixos.label}-${pkgs.stdenv.hostPlatform.system}";
···
   };
 
   config = {
+    virtualisation.diskSize = lib.mkDefault (4 * 1024);
+
     system.build.hypervImage = import ../../lib/make-disk-image.nix {
       name = cfg.vmDerivationName;
       postVM = ''
···
         rm $diskImage
       '';
       format = "raw";
-      diskSize = cfg.baseImageSize;
+      inherit (config.virtualisation) diskSize;
       partitionTableType = "efi";
       inherit config lib pkgs;
     };

nixos/modules/virtualisation/linode-image.nix

···
-{ config, lib, pkgs, ... }:
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}:
 
 with lib;
 let
···
       ];
     }
   '';
+  virtualisationOptions = import ./virtualisation-options.nix;
 in
 {
-  imports = [ ./linode-config.nix ];
+  imports = [
+    ./linode-config.nix
+    virtualisationOptions.diskSize
+    (lib.mkRenamedOptionModuleWith {
+      sinceRelease = 2411;
+      from = [
+        "virtualisation"
+        "linodeImage"
+        "diskSize"
+      ];
+      to = [
+        "virtualisation"
+        "diskSize"
+      ];
+    })
+  ];
 
   options = {
-    virtualisation.linodeImage.diskSize = mkOption {
-      type = with types; either (enum (singleton "auto")) ints.positive;
-      default = "auto";
-      example = 1536;
-      description = ''
-        Size of disk image in MB.
-      '';
-    };
 
     virtualisation.linodeImage.configFile = mkOption {
       type = with types; nullOr str;
···
       format = "raw";
       partitionTableType = "none";
       configFile = if cfg.configFile == null then defaultConfigFile else cfg.configFile;
-      inherit (cfg) diskSize;
+      inherit (config.virtualisation) diskSize;
       inherit config lib pkgs;
     };
   };

nixos/modules/virtualisation/oci-image.nix

···
-{ config, lib, pkgs, ... }:
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}:
 
 let
   cfg = config.oci;
···
   imports = [ ./oci-common.nix ];
 
   config = {
+    virtualisation.diskSize = lib.mkDefault (8 * 1024);
+    virtualisation.diskSizeAutoSupported = false;
+
     system.build.OCIImage = import ../../lib/make-disk-image.nix {
       inherit config lib pkgs;
-      inherit (cfg) diskSize;
+      inherit (config.virtualisation) diskSize;
       name = "oci-image";
       configFile = ./oci-config-user.nix;
       format = "qcow2";
···
       after = [ "network-online.target" ];
       wants = [ "network-online.target" ];
 
-      path  = [ pkgs.coreutils pkgs.curl ];
+      path = [
+        pkgs.coreutils
+        pkgs.curl
+      ];
       script = ''
         mkdir -m 0700 -p /root/.ssh
         if [ -f /root/.ssh/authorized_keys ]; then

nixos/modules/virtualisation/oci-options.nix

···
-{ config, lib, pkgs, ... }:
+{
+  lib,
+  ...
+}:
+let
+  virtualisationOptions = import ./virtualisation-options.nix;
+in
 {
+  imports = [
+    virtualisationOptions.diskSize
+    (lib.mkRenamedOptionModuleWith {
+      sinceRelease = 2411;
+      from = [
+        "virtualisation"
+        "oci"
+        "diskSize"
+      ];
+      to = [
+        "virtualisation"
+        "diskSize"
+      ];
+    })
+  ];
+
   options = {
     oci = {
       efi = lib.mkOption {
···
         description = ''
           Whether the OCI instance is using EFI.
         '';
-      };
-      diskSize = lib.mkOption {
-        type = lib.types.int;
-        default = 8192;
-        description = "Size of the disk image created in MB.";
-        example = "diskSize = 12 * 1024; # 12GiB";
       };
     };
   };

nixos/modules/virtualisation/proxmox-image.nix

···
-{ config, pkgs, lib, ... }:
+{
+  config,
+  pkgs,
+  lib,
+  ...
+}:
 
 with lib;
-
+let
+  virtualisationOptions = import ./virtualisation-options.nix;
+in
 {
+  imports = [
+    virtualisationOptions.diskSize
+    (lib.mkRenamedOptionModuleWith {
+      sinceRelease = 2411;
+      from = [
+        "virtualisation"
+        "proxmoxImage"
+        "diskSize"
+      ];
+      to = [
+        "virtualisation"
+        "diskSize"
+      ];
+    })
+  ];
+
   options.proxmox = {
     qemuConf = {
       # essential configs
···
         '';
       };
       bios = mkOption {
-        type = types.enum [ "seabios" "ovmf" ];
+        type = types.enum [
+          "seabios"
+          "ovmf"
+        ];
         default = "seabios";
         description = ''
           Select BIOS implementation (seabios = Legacy BIOS, ovmf = UEFI).
···
         description = ''
           Size of the boot partition. Is only used if partitionTableType is
           either "efi" or "hybrid".
-        '';
-      };
-      diskSize = mkOption {
-        type = types.str;
-        default = "auto";
-        example = "20480";
-        description = ''
-          The size of the disk, in megabytes.
-          if "auto" size is calculated based on the contents copied to it and
-          additionalSpace is taken into account.
         '';
       };
       net0 = mkOption {
···
       };
     };
     qemuExtraConf = mkOption {
-      type = with types; attrsOf (oneOf [ str int ]);
-      default = {};
+      type =
+        with types;
+        attrsOf (oneOf [
+          str
+          int
+        ]);
+      default = { };
       example = literalExpression ''
         {
           cpu = "host";
···
       '';
     };
     partitionTableType = mkOption {
-      type = types.enum [ "efi" "hybrid" "legacy" "legacy+gpt" ];
+      type = types.enum [
+        "efi"
+        "hybrid"
+        "legacy"
+        "legacy+gpt"
+      ];
       description = ''
         Partition table type to use. See make-disk-image.nix partitionTableType for details.
         Defaults to 'legacy' for 'proxmox.qemuConf.bios="seabios"' (default), other bios values defaults to 'efi'.
···
     };
   };
 
-  config = let
-    cfg = config.proxmox;
-    cfgLine = name: value: ''
-      ${name}: ${builtins.toString value}
-    '';
-    virtio0Storage = builtins.head (builtins.split ":" cfg.qemuConf.virtio0);
-    cfgFile = fileName: properties: pkgs.writeTextDir fileName ''
-      # generated by NixOS
-      ${lib.concatStrings (lib.mapAttrsToList cfgLine properties)}
-      #qmdump#map:virtio0:drive-virtio0:${virtio0Storage}:raw:
-    '';
-    inherit (cfg) partitionTableType;
-    supportEfi = partitionTableType == "efi" || partitionTableType == "hybrid";
-    supportBios = partitionTableType == "legacy" || partitionTableType == "hybrid" || partitionTableType == "legacy+gpt";
-    hasBootPartition = partitionTableType == "efi" || partitionTableType == "hybrid";
-    hasNoFsPartition = partitionTableType == "hybrid" || partitionTableType == "legacy+gpt";
-  in {
-    assertions = [
-      {
-        assertion = config.boot.loader.systemd-boot.enable -> config.proxmox.qemuConf.bios == "ovmf";
-        message = "systemd-boot requires 'ovmf' bios";
-      }
-      {
-        assertion = partitionTableType == "efi" -> config.proxmox.qemuConf.bios == "ovmf";
-        message = "'efi' disk partitioning requires 'ovmf' bios";
-      }
-      {
-        assertion = partitionTableType == "legacy" -> config.proxmox.qemuConf.bios == "seabios";
-        message = "'legacy' disk partitioning requires 'seabios' bios";
-      }
-      {
-        assertion = partitionTableType == "legacy+gpt" -> config.proxmox.qemuConf.bios == "seabios";
-        message = "'legacy+gpt' disk partitioning requires 'seabios' bios";
-      }
-    ];
-    system.build.VMA = import ../../lib/make-disk-image.nix {
-      name = "proxmox-${cfg.filenameSuffix}";
+  config =
+    let
+      cfg = config.proxmox;
+      cfgLine = name: value: ''
+        ${name}: ${builtins.toString value}
+      '';
+      virtio0Storage = builtins.head (builtins.split ":" cfg.qemuConf.virtio0);
+      cfgFile =
+        fileName: properties:
+        pkgs.writeTextDir fileName ''
+          # generated by NixOS
+          ${lib.concatStrings (lib.mapAttrsToList cfgLine properties)}
+          #qmdump#map:virtio0:drive-virtio0:${virtio0Storage}:raw:
+        '';
       inherit (cfg) partitionTableType;
-      postVM = let
-        # Build qemu with PVE's patch that adds support for the VMA format
-        vma = (pkgs.qemu_kvm.override {
-          alsaSupport = false;
-          pulseSupport = false;
-          sdlSupport = false;
-          jackSupport = false;
-          gtkSupport = false;
-          vncSupport = false;
-          smartcardSupport = false;
-          spiceSupport = false;
-          ncursesSupport = false;
-          libiscsiSupport = false;
-          tpmSupport = false;
-          numaSupport = false;
-          seccompSupport = false;
-          guestAgentSupport = false;
-        }).overrideAttrs ( super: rec {
-          # Check https://github.com/proxmox/pve-qemu/tree/master for the version
-          # of qemu and patch to use
-          version = "9.0.0";
-          src = pkgs.fetchurl {
-            url = "https://download.qemu.org/qemu-${version}.tar.xz";
-            hash = "sha256-MnCKxmww2MiSYz6paMdxwcdtWX1w3erSGg0izPOG2mk=";
-          };
-          patches = [
-            # Proxmox' VMA tool is published as a particular patch upon QEMU
-            "${pkgs.fetchFromGitHub {
-              owner = "proxmox";
-              repo = "pve-qemu";
-              rev = "14afbdd55f04d250bd679ca1ad55d3f47cd9d4c8";
-              hash = "sha256-lSJQA5SHIHfxJvMLIID2drv2H43crTPMNIlIT37w9Nc=";
-            }}/debian/patches/pve/0027-PVE-Backup-add-vma-backup-format-code.patch"
-          ];
+      supportEfi = partitionTableType == "efi" || partitionTableType == "hybrid";
+      supportBios =
+        partitionTableType == "legacy"
+        || partitionTableType == "hybrid"
+        || partitionTableType == "legacy+gpt";
+      hasBootPartition = partitionTableType == "efi" || partitionTableType == "hybrid";
+      hasNoFsPartition = partitionTableType == "hybrid" || partitionTableType == "legacy+gpt";
+    in
+    {
+      assertions = [
+        {
+          assertion = config.boot.loader.systemd-boot.enable -> config.proxmox.qemuConf.bios == "ovmf";
+          message = "systemd-boot requires 'ovmf' bios";
+        }
+        {
+          assertion = partitionTableType == "efi" -> config.proxmox.qemuConf.bios == "ovmf";
+          message = "'efi' disk partitioning requires 'ovmf' bios";
+        }
+        {
+          assertion = partitionTableType == "legacy" -> config.proxmox.qemuConf.bios == "seabios";
+          message = "'legacy' disk partitioning requires 'seabios' bios";
+        }
+        {
+          assertion = partitionTableType == "legacy+gpt" -> config.proxmox.qemuConf.bios == "seabios";
+          message = "'legacy+gpt' disk partitioning requires 'seabios' bios";
+        }
+      ];
+      system.build.VMA = import ../../lib/make-disk-image.nix {
+        name = "proxmox-${cfg.filenameSuffix}";
+        inherit (cfg) partitionTableType;
+        postVM =
+          let
+            # Build qemu with PVE's patch that adds support for the VMA format
+            vma =
+              (pkgs.qemu_kvm.override {
+                alsaSupport = false;
+                pulseSupport = false;
+                sdlSupport = false;
+                jackSupport = false;
+                gtkSupport = false;
+                vncSupport = false;
+                smartcardSupport = false;
+                spiceSupport = false;
+                ncursesSupport = false;
+                libiscsiSupport = false;
+                tpmSupport = false;
+                numaSupport = false;
+                seccompSupport = false;
+                guestAgentSupport = false;
+              }).overrideAttrs
+                (super: rec {
+                  # Check https://github.com/proxmox/pve-qemu/tree/master for the version
+                  # of qemu and patch to use
+                  version = "9.0.0";
+                  src = pkgs.fetchurl {
+                    url = "https://download.qemu.org/qemu-${version}.tar.xz";
+                    hash = "sha256-MnCKxmww2MiSYz6paMdxwcdtWX1w3erSGg0izPOG2mk=";
+                  };
+                  patches = [
+                    # Proxmox' VMA tool is published as a particular patch upon QEMU
+                    "${
+                      pkgs.fetchFromGitHub {
+                        owner = "proxmox";
+                        repo = "pve-qemu";
+                        rev = "14afbdd55f04d250bd679ca1ad55d3f47cd9d4c8";
+                        hash = "sha256-lSJQA5SHIHfxJvMLIID2drv2H43crTPMNIlIT37w9Nc=";
+                      }
+                    }/debian/patches/pve/0027-PVE-Backup-add-vma-backup-format-code.patch"
+                  ];
 
-          buildInputs = super.buildInputs ++ [ pkgs.libuuid ];
-          nativeBuildInputs = super.nativeBuildInputs ++ [ pkgs.perl ];
+                  buildInputs = super.buildInputs ++ [ pkgs.libuuid ];
+                  nativeBuildInputs = super.nativeBuildInputs ++ [ pkgs.perl ];
 
-        });
-      in
-      ''
-        ${vma}/bin/vma create "vzdump-qemu-${cfg.filenameSuffix}.vma" \
-          -c ${cfgFile "qemu-server.conf" (cfg.qemuConf // cfg.qemuExtraConf)}/qemu-server.conf drive-virtio0=$diskImage
-        rm $diskImage
-        ${pkgs.zstd}/bin/zstd "vzdump-qemu-${cfg.filenameSuffix}.vma"
-        mv "vzdump-qemu-${cfg.filenameSuffix}.vma.zst" $out/
+                });
+          in
+          ''
+            ${vma}/bin/vma create "vzdump-qemu-${cfg.filenameSuffix}.vma" \
+              -c ${
+                cfgFile "qemu-server.conf" (cfg.qemuConf // cfg.qemuExtraConf)
+              }/qemu-server.conf drive-virtio0=$diskImage
+            rm $diskImage
+            ${pkgs.zstd}/bin/zstd "vzdump-qemu-${cfg.filenameSuffix}.vma"
+            mv "vzdump-qemu-${cfg.filenameSuffix}.vma.zst" $out/
 
-        mkdir -p $out/nix-support
-        echo "file vma $out/vzdump-qemu-${cfg.filenameSuffix}.vma.zst" > $out/nix-support/hydra-build-products
-      '';
-      inherit (cfg.qemuConf) additionalSpace diskSize bootSize;
-      format = "raw";
-      inherit config lib pkgs;
-    };
-
-    boot = {
-      growPartition = true;
-      kernelParams = [ "console=ttyS0" ];
-      loader.grub = {
-        device = lib.mkDefault (if (hasNoFsPartition || supportBios) then
-          # Even if there is a separate no-fs partition ("/dev/disk/by-partlabel/no-fs" i.e. "/dev/vda2"),
-          # which will be used the bootloader, do not set it as loader.grub.device.
-          # GRUB installation fails, unless the whole disk is selected.
-          "/dev/vda"
-        else
-          "nodev");
-        efiSupport = lib.mkDefault supportEfi;
-        efiInstallAsRemovable = lib.mkDefault supportEfi;
+            mkdir -p $out/nix-support
+            echo "file vma $out/vzdump-qemu-${cfg.filenameSuffix}.vma.zst" > $out/nix-support/hydra-build-products
+          '';
+        inherit (cfg.qemuConf) additionalSpace bootSize;
+        inherit (config.virtualisation) diskSize;
+        format = "raw";
+        inherit config lib pkgs;
       };
 
-      loader.timeout = 0;
-      initrd.availableKernelModules = [ "uas" "virtio_blk" "virtio_pci" ];
-    };
+      boot = {
+        growPartition = true;
+        kernelParams = [ "console=ttyS0" ];
+        loader.grub = {
+          device = lib.mkDefault (
+            if (hasNoFsPartition || supportBios) then
+              # Even if there is a separate no-fs partition ("/dev/disk/by-partlabel/no-fs" i.e. "/dev/vda2"),
+              # which will be used the bootloader, do not set it as loader.grub.device.
+              # GRUB installation fails, unless the whole disk is selected.
+              "/dev/vda"
+            else
+              "nodev"
+          );
+          efiSupport = lib.mkDefault supportEfi;
+          efiInstallAsRemovable = lib.mkDefault supportEfi;
+        };
 
-    fileSystems."/" = {
-      device = "/dev/disk/by-label/nixos";
-      autoResize = true;
-      fsType = "ext4";
-    };
-    fileSystems."/boot" = lib.mkIf hasBootPartition {
-      device = "/dev/disk/by-label/ESP";
-      fsType = "vfat";
-    };
+        loader.timeout = 0;
+        initrd.availableKernelModules = [
+          "uas"
+          "virtio_blk"
+          "virtio_pci"
+        ];
+      };
+
+      fileSystems."/" = {
+        device = "/dev/disk/by-label/nixos";
+        autoResize = true;
+        fsType = "ext4";
+      };
+      fileSystems."/boot" = lib.mkIf hasBootPartition {
+        device = "/dev/disk/by-label/ESP";
+        fsType = "vfat";
+      };
 
-    networking = mkIf cfg.cloudInit.enable {
-      hostName = mkForce "";
-      useDHCP = false;
-    };
+      networking = mkIf cfg.cloudInit.enable {
+        hostName = mkForce "";
+        useDHCP = false;
+      };
 
-    services = {
-      cloud-init = mkIf cfg.cloudInit.enable {
-        enable = true;
-        network.enable = true;
+      services = {
+        cloud-init = mkIf cfg.cloudInit.enable {
+          enable = true;
+          network.enable = true;
+        };
+        sshd.enable = mkDefault true;
+        qemuGuest.enable = true;
       };
-      sshd.enable = mkDefault true;
-      qemuGuest.enable = true;
+
+      proxmox.qemuExtraConf.${cfg.cloudInit.device} = "${cfg.cloudInit.defaultStorage}:vm-9999-cloudinit,media=cdrom";
     };
-
-    proxmox.qemuExtraConf.${cfg.cloudInit.device} = "${cfg.cloudInit.defaultStorage}:vm-9999-cloudinit,media=cdrom";
-  };
 }

nixos/modules/virtualisation/qemu-vm.nix

···
 # `config'. By default, the Nix store is shared read-only with the
 # host, which makes (re)building VMs very efficient.
 
-{ config, lib, pkgs, options, ... }:
+{
+  config,
+  lib,
+  pkgs,
+  options,
+  ...
+}:
 
 with lib;
 
···
 
   consoles = lib.concatMapStringsSep " " (c: "console=${c}") cfg.qemu.consoles;
 
-  driveOpts = { ... }: {
+  driveOpts =
+    { ... }:
+    {
 
-    options = {
+      options = {
 
-      file = mkOption {
-        type = types.str;
-        description = "The file image used for this drive.";
-      };
+        file = mkOption {
+          type = types.str;
+          description = "The file image used for this drive.";
+        };
 
-      driveExtraOpts = mkOption {
-        type = types.attrsOf types.str;
-        default = {};
-        description = "Extra options passed to drive flag.";
-      };
+        driveExtraOpts = mkOption {
+          type = types.attrsOf types.str;
+          default = { };
+          description = "Extra options passed to drive flag.";
+        };
 
-      deviceExtraOpts = mkOption {
-        type = types.attrsOf types.str;
-        default = {};
-        description = "Extra options passed to device flag.";
-      };
+        deviceExtraOpts = mkOption {
+          type = types.attrsOf types.str;
+          default = { };
+          description = "Extra options passed to device flag.";
+        };
+
+        name = mkOption {
+          type = types.nullOr types.str;
+          default = null;
+          description = "A name for the drive. Must be unique in the drives list. Not passed to qemu.";
+        };
 
-      name = mkOption {
-        type = types.nullOr types.str;
-        default = null;
-        description = "A name for the drive. Must be unique in the drives list. Not passed to qemu.";
       };
 
     };
 
-  };
+  selectPartitionTableLayout =
+    { useEFIBoot, useDefaultFilesystems }:
+    if useDefaultFilesystems then if useEFIBoot then "efi" else "legacy" else "none";
 
-  selectPartitionTableLayout = { useEFIBoot, useDefaultFilesystems }:
-  if useDefaultFilesystems then
-    if useEFIBoot then "efi" else "legacy"
-  else "none";
-
-  driveCmdline = idx: { file, driveExtraOpts, deviceExtraOpts, ... }:
+  driveCmdline =
+    idx:
+    {
+      file,
+      driveExtraOpts,
+      deviceExtraOpts,
+      ...
+    }:
     let
       drvId = "drive${toString idx}";
-      mkKeyValue = generators.mkKeyValueDefault {} "=";
+      mkKeyValue = generators.mkKeyValueDefault { } "=";
       mkOpts = opts: concatStringsSep "," (mapAttrsToList mkKeyValue opts);
-      driveOpts = mkOpts (driveExtraOpts // {
-        index = idx;
-        id = drvId;
-        "if" = "none";
-        inherit file;
-      });
-      deviceOpts = mkOpts (deviceExtraOpts // {
-        drive = drvId;
-      });
+      driveOpts = mkOpts (
+        driveExtraOpts
+        // {
+          index = idx;
+          id = drvId;
+          "if" = "none";
+          inherit file;
+        }
+      );
+      deviceOpts = mkOpts (
+        deviceExtraOpts
+        // {
+          drive = drvId;
+        }
+      );
       device =
         if cfg.qemu.diskInterface == "scsi" then
           "-device lsi53c895a -device scsi-hd,${deviceOpts}"
         else
           "-device virtio-blk-pci,${deviceOpts}";
     in
-      "-drive ${driveOpts} ${device}";
+    "-drive ${driveOpts} ${device}";
 
   drivesCmdLine = drives: concatStringsSep "\\\n    " (imap1 driveCmdline drives);
 
   # Shell script to start the VM.
-  startVM =
-    ''
-      #! ${hostPkgs.runtimeShell}
+  startVM = ''
+    #! ${hostPkgs.runtimeShell}
 
-      export PATH=${makeBinPath [ hostPkgs.coreutils ]}''${PATH:+:}$PATH
-
-      set -e
+    export PATH=${makeBinPath [ hostPkgs.coreutils ]}''${PATH:+:}$PATH
 
-      # Create an empty ext4 filesystem image. A filesystem image does not
-      # contain a partition table but just a filesystem.
-      createEmptyFilesystemImage() {
-        local name=$1
-        local size=$2
-        local temp=$(mktemp)
-        ${qemu}/bin/qemu-img create -f raw "$temp" "$size"
-        ${hostPkgs.e2fsprogs}/bin/mkfs.ext4 -L ${rootFilesystemLabel} "$temp"
-        ${qemu}/bin/qemu-img convert -f raw -O qcow2 "$temp" "$name"
-        rm "$temp"
-      }
+    set -e
 
-      NIX_DISK_IMAGE=$(readlink -f "''${NIX_DISK_IMAGE:-${toString config.virtualisation.diskImage}}") || test -z "$NIX_DISK_IMAGE"
+    # Create an empty ext4 filesystem image. A filesystem image does not
+    # contain a partition table but just a filesystem.
+    createEmptyFilesystemImage() {
+      local name=$1
+      local size=$2
+      local temp=$(mktemp)
+      ${qemu}/bin/qemu-img create -f raw "$temp" "$size"
+      ${hostPkgs.e2fsprogs}/bin/mkfs.ext4 -L ${rootFilesystemLabel} "$temp"
+      ${qemu}/bin/qemu-img convert -f raw -O qcow2 "$temp" "$name"
+      rm "$temp"
+    }
 
-      if test -n "$NIX_DISK_IMAGE" && ! test -e "$NIX_DISK_IMAGE"; then
-          echo "Disk image do not exist, creating the virtualisation disk image..."
+    NIX_DISK_IMAGE=$(readlink -f "''${NIX_DISK_IMAGE:-${toString config.virtualisation.diskImage}}") || test -z "$NIX_DISK_IMAGE"
 
-          ${if (cfg.useBootLoader && cfg.useDefaultFilesystems) then ''
-            # Create a writable qcow2 image using the systemImage as a backing
-            # image.
+    if test -n "$NIX_DISK_IMAGE" && ! test -e "$NIX_DISK_IMAGE"; then
+        echo "Disk image do not exist, creating the virtualisation disk image..."
 
-            # CoW prevent size to be attributed to an image.
-            # FIXME: raise this issue to upstream.
-            ${qemu}/bin/qemu-img create \
-              -f qcow2 \
-              -b ${systemImage}/nixos.qcow2 \
-              -F qcow2 \
-              "$NIX_DISK_IMAGE"
-          '' else if cfg.useDefaultFilesystems then ''
-            createEmptyFilesystemImage "$NIX_DISK_IMAGE" "${toString cfg.diskSize}M"
-          '' else ''
-            # Create an empty disk image without a filesystem.
-            ${qemu}/bin/qemu-img create -f qcow2 "$NIX_DISK_IMAGE" "${toString cfg.diskSize}M"
-          ''
-          }
-          echo "Virtualisation disk image created."
-      fi
+        ${
+          if (cfg.useBootLoader && cfg.useDefaultFilesystems) then
+            ''
+              # Create a writable qcow2 image using the systemImage as a backing
+              # image.
 
-      # Create a directory for storing temporary data of the running VM.
-      if [ -z "$TMPDIR" ] || [ -z "$USE_TMPDIR" ]; then
-          TMPDIR=$(mktemp -d nix-vm.XXXXXXXXXX --tmpdir)
-      fi
+              # CoW prevent size to be attributed to an image.
+              # FIXME: raise this issue to upstream.
+              ${qemu}/bin/qemu-img create \
+                -f qcow2 \
+                -b ${systemImage}/nixos.qcow2 \
+                -F qcow2 \
+                "$NIX_DISK_IMAGE"
+            ''
+          else if cfg.useDefaultFilesystems then
+            ''
+              createEmptyFilesystemImage "$NIX_DISK_IMAGE" "${toString cfg.diskSize}M"
+            ''
+          else
+            ''
+              # Create an empty disk image without a filesystem.
+              ${qemu}/bin/qemu-img create -f qcow2 "$NIX_DISK_IMAGE" "${toString cfg.diskSize}M"
+            ''
+        }
+        echo "Virtualisation disk image created."
+    fi
 
-      ${lib.optionalString (cfg.useNixStoreImage) ''
-        echo "Creating Nix store image..."
+    # Create a directory for storing temporary data of the running VM.
+    if [ -z "$TMPDIR" ] || [ -z "$USE_TMPDIR" ]; then
+        TMPDIR=$(mktemp -d nix-vm.XXXXXXXXXX --tmpdir)
+    fi
 
-        ${hostPkgs.gnutar}/bin/tar --create \
-          --absolute-names \
-          --verbatim-files-from \
-          --transform 'flags=rSh;s|/nix/store/||' \
-          --files-from ${hostPkgs.closureInfo { rootPaths = [ config.system.build.toplevel regInfo ]; }}/store-paths \
-          | ${hostPkgs.erofs-utils}/bin/mkfs.erofs \
-            --quiet \
-            --force-uid=0 \
-            --force-gid=0 \
-            -L ${nixStoreFilesystemLabel} \
-            -U eb176051-bd15-49b7-9e6b-462e0b467019 \
-            -T 0 \
-            --tar=f \
-            "$TMPDIR"/store.img
+    ${lib.optionalString (cfg.useNixStoreImage) ''
+      echo "Creating Nix store image..."
 
-        echo "Created Nix store image."
-      ''
-      }
+      ${hostPkgs.gnutar}/bin/tar --create \
+        --absolute-names \
+        --verbatim-files-from \
+        --transform 'flags=rSh;s|/nix/store/||' \
+        --files-from ${
+          hostPkgs.closureInfo {
+            rootPaths = [
+              config.system.build.toplevel
+              regInfo
+            ];
+          }
+        }/store-paths \
+        | ${hostPkgs.erofs-utils}/bin/mkfs.erofs \
+          --quiet \
+          --force-uid=0 \
+          --force-gid=0 \
+          -L ${nixStoreFilesystemLabel} \
+          -U eb176051-bd15-49b7-9e6b-462e0b467019 \
+          -T 0 \
+          --tar=f \
+          "$TMPDIR"/store.img
 
-      # Create a directory for exchanging data with the VM.
-      mkdir -p "$TMPDIR/xchg"
+      echo "Created Nix store image."
+    ''}
 
-      ${lib.optionalString cfg.useHostCerts
-      ''
-        mkdir -p "$TMPDIR/certs"
-        if [ -e "$NIX_SSL_CERT_FILE" ]; then
-          cp -L "$NIX_SSL_CERT_FILE" "$TMPDIR"/certs/ca-certificates.crt
-        else
-          echo \$NIX_SSL_CERT_FILE should point to a valid file if virtualisation.useHostCerts is enabled.
-        fi
-      ''}
+    # Create a directory for exchanging data with the VM.
+    mkdir -p "$TMPDIR/xchg"
 
-      ${lib.optionalString cfg.useEFIBoot
-      ''
-        # Expose EFI variables, it's useful even when we are not using a bootloader (!).
-        # We might be interested in having EFI variable storage present even if we aren't booting via UEFI, hence
-        # no guard against `useBootLoader`.  Examples:
-        # - testing PXE boot or other EFI applications
-        # - directbooting LinuxBoot, which `kexec()s` into a UEFI environment that can boot e.g. Windows
-        NIX_EFI_VARS=$(readlink -f "''${NIX_EFI_VARS:-${config.system.name}-efi-vars.fd}")
-        # VM needs writable EFI vars
-        if ! test -e "$NIX_EFI_VARS"; then
-        ${if cfg.efi.keepVariables then
-            # We still need the EFI var from the make-disk-image derivation
-            # because our "switch-to-configuration" process might
-            # write into it and we want to keep this data.
-            ''cp ${systemImage}/efi-vars.fd "$NIX_EFI_VARS"''
-            else
-            ''cp ${cfg.efi.variables} "$NIX_EFI_VARS"''
-          }
-          chmod 0644 "$NIX_EFI_VARS"
-        fi
-      ''}
+    ${lib.optionalString cfg.useHostCerts ''
+      mkdir -p "$TMPDIR/certs"
+      if [ -e "$NIX_SSL_CERT_FILE" ]; then
+        cp -L "$NIX_SSL_CERT_FILE" "$TMPDIR"/certs/ca-certificates.crt
+      else
+        echo \$NIX_SSL_CERT_FILE should point to a valid file if virtualisation.useHostCerts is enabled.
+      fi
+    ''}
 
-      ${lib.optionalString cfg.tpm.enable ''
-        NIX_SWTPM_DIR=$(readlink -f "''${NIX_SWTPM_DIR:-${config.system.name}-swtpm}")
-        mkdir -p "$NIX_SWTPM_DIR"
-        ${lib.getExe cfg.tpm.package} \
-          socket \
-          --tpmstate dir="$NIX_SWTPM_DIR" \
-          --ctrl type=unixio,path="$NIX_SWTPM_DIR"/socket,terminate \
-          --pid file="$NIX_SWTPM_DIR"/pid --daemon \
-          --tpm2 \
-          --log file="$NIX_SWTPM_DIR"/stdout,level=6
+    ${lib.optionalString cfg.useEFIBoot ''
+      # Expose EFI variables, it's useful even when we are not using a bootloader (!).
+      # We might be interested in having EFI variable storage present even if we aren't booting via UEFI, hence
+      # no guard against `useBootLoader`.  Examples:
+      # - testing PXE boot or other EFI applications
+      # - directbooting LinuxBoot, which `kexec()s` into a UEFI environment that can boot e.g. Windows
+      NIX_EFI_VARS=$(readlink -f "''${NIX_EFI_VARS:-${config.system.name}-efi-vars.fd}")
+      # VM needs writable EFI vars
+      if ! test -e "$NIX_EFI_VARS"; then
+      ${
+        if cfg.efi.keepVariables then
+          # We still need the EFI var from the make-disk-image derivation
+          # because our "switch-to-configuration" process might
+          # write into it and we want to keep this data.
+          ''cp ${systemImage}/efi-vars.fd "$NIX_EFI_VARS"''
+        else
+          ''cp ${cfg.efi.variables} "$NIX_EFI_VARS"''
+      }
+        chmod 0644 "$NIX_EFI_VARS"
+      fi
+    ''}
 
-        # Enable `fdflags` builtin in Bash
-        # We will need it to perform surgical modification of the file descriptor
-        # passed in the coprocess to remove `FD_CLOEXEC`, i.e. close the file descriptor
-        # on exec.
-        # If let alone, it will trigger the coprocess to read EOF when QEMU is `exec`
-        # at the end of this script. To work around that, we will just clear
-        # the `FD_CLOEXEC` bits as a first step.
-        enable -f ${hostPkgs.bash}/lib/bash/fdflags fdflags
-        # leave a dangling subprocess because the swtpm ctrl socket has
-        # "terminate" when the last connection disconnects, it stops swtpm.
-        # When qemu stops, or if the main shell process ends, the coproc will
-        # get signaled by virtue of the pipe between main and coproc ending.
-        # Which in turns triggers a socat connect-disconnect to swtpm which
-        # will stop it.
-        coproc waitingswtpm {
-          read || :
-          echo "" | ${lib.getExe hostPkgs.socat} STDIO UNIX-CONNECT:"$NIX_SWTPM_DIR"/socket
-        }
-        # Clear `FD_CLOEXEC` on the coprocess' file descriptor stdin.
-        fdflags -s-cloexec ''${waitingswtpm[1]}
-      ''}
+    ${lib.optionalString cfg.tpm.enable ''
+      NIX_SWTPM_DIR=$(readlink -f "''${NIX_SWTPM_DIR:-${config.system.name}-swtpm}")
+      mkdir -p "$NIX_SWTPM_DIR"
+      ${lib.getExe cfg.tpm.package} \
+        socket \
+        --tpmstate dir="$NIX_SWTPM_DIR" \
+        --ctrl type=unixio,path="$NIX_SWTPM_DIR"/socket,terminate \
+        --pid file="$NIX_SWTPM_DIR"/pid --daemon \
+        --tpm2 \
+        --log file="$NIX_SWTPM_DIR"/stdout,level=6
 
-      cd "$TMPDIR"
+      # Enable `fdflags` builtin in Bash
+      # We will need it to perform surgical modification of the file descriptor
+      # passed in the coprocess to remove `FD_CLOEXEC`, i.e. close the file descriptor
+      # on exec.
+      # If let alone, it will trigger the coprocess to read EOF when QEMU is `exec`
+      # at the end of this script. To work around that, we will just clear
+      # the `FD_CLOEXEC` bits as a first step.
+      enable -f ${hostPkgs.bash}/lib/bash/fdflags fdflags
+      # leave a dangling subprocess because the swtpm ctrl socket has
+      # "terminate" when the last connection disconnects, it stops swtpm.
+      # When qemu stops, or if the main shell process ends, the coproc will
+      # get signaled by virtue of the pipe between main and coproc ending.
+      # Which in turns triggers a socat connect-disconnect to swtpm which
+      # will stop it.
+      coproc waitingswtpm {
+        read || :
+        echo "" | ${lib.getExe hostPkgs.socat} STDIO UNIX-CONNECT:"$NIX_SWTPM_DIR"/socket
+      }
+      # Clear `FD_CLOEXEC` on the coprocess' file descriptor stdin.
+      fdflags -s-cloexec ''${waitingswtpm[1]}
+    ''}
 
-      ${lib.optionalString (cfg.emptyDiskImages != []) "idx=0"}
-      ${flip concatMapStrings cfg.emptyDiskImages (size: ''
-        if ! test -e "empty$idx.qcow2"; then
-            ${qemu}/bin/qemu-img create -f qcow2 "empty$idx.qcow2" "${toString size}M"
-        fi
-        idx=$((idx + 1))
-      '')}
+    cd "$TMPDIR"
 
-      # Start QEMU.
-      exec ${qemu-common.qemuBinary qemu} \
-          -name ${config.system.name} \
-          -m ${toString config.virtualisation.memorySize} \
-          -smp ${toString config.virtualisation.cores} \
-          -device virtio-rng-pci \
-          ${concatStringsSep " " config.virtualisation.qemu.networkingOptions} \
-          ${concatStringsSep " \\\n    "
-            (mapAttrsToList
-              (tag: share: "-virtfs local,path=${share.source},security_model=${share.securityModel},mount_tag=${tag}")
-              config.virtualisation.sharedDirectories)} \
-          ${drivesCmdLine config.virtualisation.qemu.drives} \
-          ${concatStringsSep " \\\n    " config.virtualisation.qemu.options} \
-          $QEMU_OPTS \
-          "$@"
-    '';
+    ${lib.optionalString (cfg.emptyDiskImages != [ ]) "idx=0"}
+    ${flip concatMapStrings cfg.emptyDiskImages (size: ''
+      if ! test -e "empty$idx.qcow2"; then
+          ${qemu}/bin/qemu-img create -f qcow2 "empty$idx.qcow2" "${toString size}M"
+      fi
+      idx=$((idx + 1))
+    '')}
 
+    # Start QEMU.
+    exec ${qemu-common.qemuBinary qemu} \
+        -name ${config.system.name} \
+        -m ${toString config.virtualisation.memorySize} \
+        -smp ${toString config.virtualisation.cores} \
+        -device virtio-rng-pci \
+        ${concatStringsSep " " config.virtualisation.qemu.networkingOptions} \
+        ${
+          concatStringsSep " \\\n    " (
+            mapAttrsToList (
+              tag: share:
+              "-virtfs local,path=${share.source},security_model=${share.securityModel},mount_tag=${tag}"
+            ) config.virtualisation.sharedDirectories
+          )
+        } \
+        ${drivesCmdLine config.virtualisation.qemu.drives} \
+        ${concatStringsSep " \\\n    " config.virtualisation.qemu.options} \
+        $QEMU_OPTS \
+        "$@"
+  '';
 
   regInfo = hostPkgs.closureInfo { rootPaths = config.virtualisation.additionalPaths; };
 
···
     OVMF = cfg.efi.OVMF;
   };
 
+  virtualisationOptions = import ./virtualisation-options.nix;
+
 in
 
 {
   imports = [
+    ./virtualisation-options.nix
     ../profiles/qemu-guest.nix
-    (mkRenamedOptionModule [ "virtualisation" "pathsInNixDB" ] [ "virtualisation" "additionalPaths" ])
-    (mkRemovedOptionModule [ "virtualisation" "bootDevice" ] "This option was renamed to `virtualisation.rootDevice`, as it was incorrectly named and misleading. Take the time to review what you want to do and look at the new options like `virtualisation.{bootLoaderDevice, bootPartition}`, open an issue in case of issues.")
-    (mkRemovedOptionModule [ "virtualisation" "efiVars" ] "This option was removed, it is possible to provide a template UEFI variable with `virtualisation.efi.variables` ; if this option is important to you, open an issue")
-    (mkRemovedOptionModule [ "virtualisation" "persistBootDevice" ] "Boot device is always persisted if you use a bootloader through the root disk image ; if this does not work for your usecase, please examine carefully what `virtualisation.{bootDevice, rootDevice, bootPartition}` options offer you and open an issue explaining your need.`")
+    virtualisationOptions.diskSize
+    (mkRenamedOptionModule
+      [
+        "virtualisation"
+        "pathsInNixDB"
+      ]
+      [
+        "virtualisation"
+        "additionalPaths"
+      ]
+    )
+    (mkRemovedOptionModule
+      [
+        "virtualisation"
+        "bootDevice"
+      ]
+      "This option was renamed to `virtualisation.rootDevice`, as it was incorrectly named and misleading. Take the time to review what you want to do and look at the new options like `virtualisation.{bootLoaderDevice, bootPartition}`, open an issue in case of issues."
+    )
+    (mkRemovedOptionModule
+      [
+        "virtualisation"
+        "efiVars"
+      ]
+      "This option was removed, it is possible to provide a template UEFI variable with `virtualisation.efi.variables` ; if this option is important to you, open an issue"
+    )
+    (mkRemovedOptionModule
+      [
+        "virtualisation"
+        "persistBootDevice"
+      ]
+      "Boot device is always persisted if you use a bootloader through the root disk image ; if this does not work for your usecase, please examine carefully what `virtualisation.{bootDevice, rootDevice, bootPartition}` options offer you and open an issue explaining your need.`"
+    )
   ];
 
   options = {
 
     virtualisation.fileSystems = options.fileSystems;
 
-    virtualisation.memorySize =
-      mkOption {
-        type = types.ints.positive;
-        default = 1024;
-        description = ''
-            The memory size in megabytes of the virtual machine.
-          '';
-      };
+    virtualisation.memorySize = mkOption {
+      type = types.ints.positive;
+      default = 1024;
+      description = ''
+        The memory size in megabytes of the virtual machine.
+      '';
+    };
 
-    virtualisation.msize =
-      mkOption {
-        type = types.ints.positive;
-        default = 16384;
-        description = ''
-            The msize (maximum packet size) option passed to 9p file systems, in
-            bytes. Increasing this should increase performance significantly,
-            at the cost of higher RAM usage.
-          '';
-      };
+    virtualisation.msize = mkOption {
+      type = types.ints.positive;
+      default = 16384;
+      description = ''
+        The msize (maximum packet size) option passed to 9p file systems, in
+        bytes. Increasing this should increase performance significantly,
+        at the cost of higher RAM usage.
+      '';
+    };
 
-    virtualisation.diskSize =
-      mkOption {
-        type = types.ints.positive;
-        default = 1024;
-        description = ''
-            The disk size in megabytes of the virtual machine.
-          '';
-      };
+    virtualisation.diskImage = mkOption {
+      type = types.nullOr types.str;
+      default = "./${config.system.name}.qcow2";
+      defaultText = literalExpression ''"./''${config.system.name}.qcow2"'';
+      description = ''
+        Path to the disk image containing the root filesystem.
+        The image will be created on startup if it does not
+        exist.
 
-    virtualisation.diskImage =
-      mkOption {
-        type = types.nullOr types.str;
-        default = "./${config.system.name}.qcow2";
-        defaultText = literalExpression ''"./''${config.system.name}.qcow2"'';
-        description = ''
-            Path to the disk image containing the root filesystem.
-            The image will be created on startup if it does not
-            exist.
+        If null, a tmpfs will be used as the root filesystem and
+        the VM's state will not be persistent.
+      '';
+    };
 
-            If null, a tmpfs will be used as the root filesystem and
-            the VM's state will not be persistent.
-          '';
-      };
-
-    virtualisation.bootLoaderDevice =
-      mkOption {
-        type = types.path;
-        default = "/dev/disk/by-id/virtio-${rootDriveSerialAttr}";
-        defaultText = literalExpression ''/dev/disk/by-id/virtio-${rootDriveSerialAttr}'';
-        example = "/dev/disk/by-id/virtio-boot-loader-device";
-        description = ''
-            The path (inside th VM) to the device to boot from when legacy booting.
-          '';
-        };
+    virtualisation.bootLoaderDevice = mkOption {
+      type = types.path;
+      default = "/dev/disk/by-id/virtio-${rootDriveSerialAttr}";
+      defaultText = literalExpression ''/dev/disk/by-id/virtio-${rootDriveSerialAttr}'';
+      example = "/dev/disk/by-id/virtio-boot-loader-device";
+      description = ''
+        The path (inside th VM) to the device to boot from when legacy booting.
+      '';
+    };
 
-    virtualisation.bootPartition =
-      mkOption {
-        type = types.nullOr types.path;
-        default = if cfg.useEFIBoot then "/dev/disk/by-label/${espFilesystemLabel}" else null;
-        defaultText = literalExpression ''if cfg.useEFIBoot then "/dev/disk/by-label/${espFilesystemLabel}" else null'';
-        example = "/dev/disk/by-label/esp";
-        description = ''
-            The path (inside the VM) to the device containing the EFI System Partition (ESP).
+    virtualisation.bootPartition = mkOption {
+      type = types.nullOr types.path;
+      default = if cfg.useEFIBoot then "/dev/disk/by-label/${espFilesystemLabel}" else null;
+      defaultText = literalExpression ''if cfg.useEFIBoot then "/dev/disk/by-label/${espFilesystemLabel}" else null'';
+      example = "/dev/disk/by-label/esp";
+      description = ''
+        The path (inside the VM) to the device containing the EFI System Partition (ESP).
 
-            If you are *not* booting from a UEFI firmware, this value is, by
-            default, `null`. The ESP is mounted to `boot.loader.efi.efiSysMountpoint`.
-          '';
-      };
+        If you are *not* booting from a UEFI firmware, this value is, by
+        default, `null`. The ESP is mounted to `boot.loader.efi.efiSysMountpoint`.
+      '';
+    };
 
-    virtualisation.rootDevice =
-      mkOption {
-        type = types.nullOr types.path;
-        default = "/dev/disk/by-label/${rootFilesystemLabel}";
-        defaultText = literalExpression ''/dev/disk/by-label/${rootFilesystemLabel}'';
-        example = "/dev/disk/by-label/nixos";
-        description = ''
-            The path (inside the VM) to the device containing the root filesystem.
-          '';
-      };
+    virtualisation.rootDevice = mkOption {
+      type = types.nullOr types.path;
+      default = "/dev/disk/by-label/${rootFilesystemLabel}";
+      defaultText = literalExpression ''/dev/disk/by-label/${rootFilesystemLabel}'';
+      example = "/dev/disk/by-label/nixos";
+      description = ''
+        The path (inside the VM) to the device containing the root filesystem.
+      '';
+    };
 
-    virtualisation.emptyDiskImages =
-      mkOption {
-        type = types.listOf types.ints.positive;
-        default = [];
-        description = ''
-            Additional disk images to provide to the VM. The value is
-            a list of size in megabytes of each disk. These disks are
-            writeable by the VM.
-          '';
-      };
+    virtualisation.emptyDiskImages = mkOption {
+      type = types.listOf types.ints.positive;
+      default = [ ];
+      description = ''
+        Additional disk images to provide to the VM. The value is
+        a list of size in megabytes of each disk. These disks are
+        writeable by the VM.
+      '';
+    };
 
-    virtualisation.graphics =
-      mkOption {
-        type = types.bool;
-        default = true;
-        description = ''
-            Whether to run QEMU with a graphics window, or in nographic mode.
-            Serial console will be enabled on both settings, but this will
-            change the preferred console.
-            '';
-      };
+    virtualisation.graphics = mkOption {
+      type = types.bool;
+      default = true;
+      description = ''
+        Whether to run QEMU with a graphics window, or in nographic mode.
+        Serial console will be enabled on both settings, but this will
+        change the preferred console.
+      '';
+    };
 
-    virtualisation.resolution =
-      mkOption {
-        type = options.services.xserver.resolutions.type.nestedTypes.elemType;
-        default = { x = 1024; y = 768; };
-        description = ''
-            The resolution of the virtual machine display.
-          '';
+    virtualisation.resolution = mkOption {
+      type = options.services.xserver.resolutions.type.nestedTypes.elemType;
+      default = {
+        x = 1024;
+        y = 768;
       };
+      description = ''
+        The resolution of the virtual machine display.
+      '';
+    };
 
-    virtualisation.cores =
-      mkOption {
-        type = types.ints.positive;
-        default = 1;
-        description = ''
-            Specify the number of cores the guest is permitted to use.
-            The number can be higher than the available cores on the
-            host system.
-          '';
-      };
+    virtualisation.cores = mkOption {
+      type = types.ints.positive;
+      default = 1;
+      description = ''
+        Specify the number of cores the guest is permitted to use.
+        The number can be higher than the available cores on the
+        host system.
+      '';
+    };
 
-    virtualisation.sharedDirectories =
-      mkOption {
-        type = types.attrsOf
-          (types.submodule {
-            options.source = mkOption {
-              type = types.str;
-              description = "The path of the directory to share, can be a shell variable";
-            };
-            options.target = mkOption {
-              type = types.path;
-              description = "The mount point of the directory inside the virtual machine";
-            };
-            options.securityModel = mkOption {
-              type = types.enum [ "passthrough" "mapped-xattr" "mapped-file" "none" ];
-              default = "mapped-xattr";
-              description = ''
-                The security model to use for this share:
+    virtualisation.sharedDirectories = mkOption {
+      type = types.attrsOf (
+        types.submodule {
+          options.source = mkOption {
+            type = types.str;
+            description = "The path of the directory to share, can be a shell variable";
+          };
+          options.target = mkOption {
+            type = types.path;
+            description = "The mount point of the directory inside the virtual machine";
+          };
+          options.securityModel = mkOption {
+            type = types.enum [
+              "passthrough"
+              "mapped-xattr"
+              "mapped-file"
+              "none"
+            ];
+            default = "mapped-xattr";
+            description = ''
+              The security model to use for this share:
 
-                - `passthrough`: files are stored using the same credentials as they are created on the guest (this requires QEMU to run as root)
-                - `mapped-xattr`: some of the file attributes like uid, gid, mode bits and link target are stored as file attributes
-                - `mapped-file`: the attributes are stored in the hidden .virtfs_metadata directory. Directories exported by this security model cannot interact with other unix tools
-                - `none`: same as "passthrough" except the sever won't report failures if it fails to set file attributes like ownership
-              '';
-            };
-          });
-        default = { };
-        example = {
-          my-share = { source = "/path/to/be/shared"; target = "/mnt/shared"; };
+              - `passthrough`: files are stored using the same credentials as they are created on the guest (this requires QEMU to run as root)
+              - `mapped-xattr`: some of the file attributes like uid, gid, mode bits and link target are stored as file attributes
+              - `mapped-file`: the attributes are stored in the hidden .virtfs_metadata directory. Directories exported by this security model cannot interact with other unix tools
+              - `none`: same as "passthrough" except the sever won't report failures if it fails to set file attributes like ownership
+            '';
+          };
+        }
+      );
+      default = { };
+      example = {
+        my-share = {
+          source = "/path/to/be/shared";
+          target = "/mnt/shared";
         };
-        description = ''
-            An attributes set of directories that will be shared with the
-            virtual machine using VirtFS (9P filesystem over VirtIO).
-            The attribute name will be used as the 9P mount tag.
-          '';
       };
+      description = ''
+        An attributes set of directories that will be shared with the
+        virtual machine using VirtFS (9P filesystem over VirtIO).
+        The attribute name will be used as the 9P mount tag.
+      '';
+    };
 
-    virtualisation.additionalPaths =
-      mkOption {
-        type = types.listOf types.path;
-        default = [];
-        description = ''
-            A list of paths whose closure should be made available to
-            the VM.
+    virtualisation.additionalPaths = mkOption {
+      type = types.listOf types.path;
+      default = [ ];
+      description = ''
+        A list of paths whose closure should be made available to
+        the VM.
 
-            When 9p is used, the closure is registered in the Nix
-            database in the VM. All other paths in the host Nix store
-            appear in the guest Nix store as well, but are considered
-            garbage (because they are not registered in the Nix
-            database of the guest).
+        When 9p is used, the closure is registered in the Nix
+        database in the VM. All other paths in the host Nix store
+        appear in the guest Nix store as well, but are considered
+        garbage (because they are not registered in the Nix
+        database of the guest).
 
-            When {option}`virtualisation.useNixStoreImage` is
-            set, the closure is copied to the Nix store image.
-          '';
-      };
+        When {option}`virtualisation.useNixStoreImage` is
+        set, the closure is copied to the Nix store image.
+      '';
+    };
 
     virtualisation.forwardPorts = mkOption {
-      type = types.listOf
-        (types.submodule {
+      type = types.listOf (
+        types.submodule {
           options.from = mkOption {
-            type = types.enum [ "host" "guest" ];
+            type = types.enum [
+              "host"
+              "guest"
+            ];
             default = "host";
             description = ''
-                Controls the direction in which the ports are mapped:
+              Controls the direction in which the ports are mapped:
 
-                - `"host"` means traffic from the host ports
-                  is forwarded to the given guest port.
-                - `"guest"` means traffic from the guest ports
-                  is forwarded to the given host port.
-              '';
+              - `"host"` means traffic from the host ports
+                is forwarded to the given guest port.
+              - `"guest"` means traffic from the guest ports
+                is forwarded to the given host port.
+            '';
           };
           options.proto = mkOption {
-            type = types.enum [ "tcp" "udp" ];
+            type = types.enum [
+              "tcp"
+              "udp"
+            ];
             default = "tcp";
             description = "The protocol to forward.";
           };
···
             type = types.port;
             description = "The guest port to be mapped.";
           };
-        });
-      default = [];
-      example = lib.literalExpression
-        ''
+        }
+      );
+      default = [ ];
+      example = lib.literalExpression ''
         [ # forward local port 2222 -> 22, to ssh into the VM
           { from = "host"; host.port = 2222; guest.port = 22; }
 
···
             host.address = "127.0.0.1"; host.port = 80;
           }
         ]
-        '';
+      '';
       description = ''
-          When using the SLiRP user networking (default), this option allows to
-          forward ports to/from the host/guest.
+        When using the SLiRP user networking (default), this option allows to
+        forward ports to/from the host/guest.
 
-          ::: {.warning}
-          If the NixOS firewall on the virtual machine is enabled, you also
-          have to open the guest ports to enable the traffic between host and
-          guest.
-          :::
+        ::: {.warning}
+        If the NixOS firewall on the virtual machine is enabled, you also
+        have to open the guest ports to enable the traffic between host and
+        guest.
+        :::
 
-          ::: {.note}
-          Currently QEMU supports only IPv4 forwarding.
-          :::
-        '';
+        ::: {.note}
+        Currently QEMU supports only IPv4 forwarding.
+        :::
+      '';
     };
 
-    virtualisation.restrictNetwork =
-      mkOption {
-        type = types.bool;
-        default = false;
-        example = true;
-        description = ''
-            If this option is enabled, the guest will be isolated, i.e. it will
-            not be able to contact the host and no guest IP packets will be
-            routed over the host to the outside. This option does not affect
-            any explicitly set forwarding rules.
-          '';
-      };
+    virtualisation.restrictNetwork = mkOption {
+      type = types.bool;
+      default = false;
+      example = true;
+      description = ''
+        If this option is enabled, the guest will be isolated, i.e. it will
+        not be able to contact the host and no guest IP packets will be
+        routed over the host to the outside. This option does not affect
+        any explicitly set forwarding rules.
+      '';
+    };
 
-    virtualisation.vlans =
-      mkOption {
-        type = types.listOf types.ints.unsigned;
-        default = if config.virtualisation.interfaces == {} then [ 1 ] else [ ];
-        defaultText = lib.literalExpression ''if config.virtualisation.interfaces == {} then [ 1 ] else [ ]'';
-        example = [ 1 2 ];
-        description = ''
-            Virtual networks to which the VM is connected.  Each
-            number «N» in this list causes
-            the VM to have a virtual Ethernet interface attached to a
-            separate virtual network on which it will be assigned IP
-            address
-            `192.168.«N».«M»`,
-            where «M» is the index of this VM
-            in the list of VMs.
-          '';
-      };
+    virtualisation.vlans = mkOption {
+      type = types.listOf types.ints.unsigned;
+      default = if config.virtualisation.interfaces == { } then [ 1 ] else [ ];
+      defaultText = lib.literalExpression ''if config.virtualisation.interfaces == {} then [ 1 ] else [ ]'';
+      example = [
+        1
+        2
+      ];
+      description = ''
+        Virtual networks to which the VM is connected.  Each
+        number «N» in this list causes
+        the VM to have a virtual Ethernet interface attached to a
+        separate virtual network on which it will be assigned IP
+        address
+        `192.168.«N».«M»`,
+        where «M» is the index of this VM
+        in the list of VMs.
+      '';
+    };
 
     virtualisation.interfaces = mkOption {
-      default = {};
+      default = { };
       example = {
         enp1s0.vlan = 1;
       };
       description = ''
         Network interfaces to add to the VM.
       '';
-      type = with types; attrsOf (submodule {
-        options = {
-          vlan = mkOption {
-            type = types.ints.unsigned;
-            description = ''
-              VLAN to which the network interface is connected.
-            '';
-          };
+      type =
+        with types;
+        attrsOf (submodule {
+          options = {
+            vlan = mkOption {
+              type = types.ints.unsigned;
+              description = ''
+                VLAN to which the network interface is connected.
+              '';
+            };
 
-          assignIP = mkOption {
-            type = types.bool;
-            default = false;
-            description = ''
-              Automatically assign an IP address to the network interface using the same scheme as
-              virtualisation.vlans.
-            '';
+            assignIP = mkOption {
+              type = types.bool;
+              default = false;
+              description = ''
+                Automatically assign an IP address to the network interface using the same scheme as
+                virtualisation.vlans.
+              '';
+            };
           };
-        };
-      });
+        });
     };
 
-    virtualisation.writableStore =
-      mkOption {
-        type = types.bool;
-        default = cfg.mountHostNixStore;
-        defaultText = literalExpression "cfg.mountHostNixStore";
-        description = ''
-            If enabled, the Nix store in the VM is made writable by
-            layering an overlay filesystem on top of the host's Nix
-            store.
+    virtualisation.writableStore = mkOption {
+      type = types.bool;
+      default = cfg.mountHostNixStore;
+      defaultText = literalExpression "cfg.mountHostNixStore";
+      description = ''
+        If enabled, the Nix store in the VM is made writable by
+        layering an overlay filesystem on top of the host's Nix
+        store.
 
-            By default, this is enabled if you mount a host Nix store.
-          '';
-      };
+        By default, this is enabled if you mount a host Nix store.
+      '';
+    };
 
-    virtualisation.writableStoreUseTmpfs =
-      mkOption {
-        type = types.bool;
-        default = true;
-        description = ''
-            Use a tmpfs for the writable store instead of writing to the VM's
-            own filesystem.
-          '';
-      };
+    virtualisation.writableStoreUseTmpfs = mkOption {
+      type = types.bool;
+      default = true;
+      description = ''
+        Use a tmpfs for the writable store instead of writing to the VM's
+        own filesystem.
+      '';
+    };
 
-    networking.primaryIPAddress =
-      mkOption {
-        type = types.str;
-        default = "";
-        internal = true;
-        description = "Primary IP address used in /etc/hosts.";
-      };
+    networking.primaryIPAddress = mkOption {
+      type = types.str;
+      default = "";
+      internal = true;
+      description = "Primary IP address used in /etc/hosts.";
+    };
 
-    networking.primaryIPv6Address =
-      mkOption {
-        type = types.str;
-        default = "";
-        internal = true;
-        description = "Primary IPv6 address used in /etc/hosts.";
-      };
+    networking.primaryIPv6Address = mkOption {
+      type = types.str;
+      default = "";
+      internal = true;
+      description = "Primary IPv6 address used in /etc/hosts.";
+    };
 
     virtualisation.host.pkgs = mkOption {
       type = options.nixpkgs.pkgs.type;
···
     };
 
     virtualisation.qemu = {
-      package =
-        mkOption {
-          type = types.package;
-          default = if hostPkgs.stdenv.hostPlatform.qemuArch == pkgs.stdenv.hostPlatform.qemuArch then hostPkgs.qemu_kvm else hostPkgs.qemu;
-          defaultText = literalExpression "if hostPkgs.stdenv.hostPlatform.qemuArch == pkgs.stdenv.hostPlatform.qemuArch then config.virtualisation.host.pkgs.qemu_kvm else config.virtualisation.host.pkgs.qemu";
-          example = literalExpression "pkgs.qemu_test";
-          description = "QEMU package to use.";
-        };
+      package = mkOption {
+        type = types.package;
+        default =
+          if hostPkgs.stdenv.hostPlatform.qemuArch == pkgs.stdenv.hostPlatform.qemuArch then
+            hostPkgs.qemu_kvm
+          else
+            hostPkgs.qemu;
+        defaultText = literalExpression "if hostPkgs.stdenv.hostPlatform.qemuArch == pkgs.stdenv.hostPlatform.qemuArch then config.virtualisation.host.pkgs.qemu_kvm else config.virtualisation.host.pkgs.qemu";
+        example = literalExpression "pkgs.qemu_test";
+        description = "QEMU package to use.";
+      };
 
-      options =
-        mkOption {
-          type = types.listOf types.str;
-          default = [];
-          example = [ "-vga std" ];
-          description = ''
-            Options passed to QEMU.
-            See [QEMU User Documentation](https://www.qemu.org/docs/master/system/qemu-manpage) for a complete list.
-          '';
-        };
+      options = mkOption {
+        type = types.listOf types.str;
+        default = [ ];
+        example = [ "-vga std" ];
+        description = ''
+          Options passed to QEMU.
+          See [QEMU User Documentation](https://www.qemu.org/docs/master/system/qemu-manpage) for a complete list.
+        '';
+      };
 
       consoles = mkOption {
         type = types.listOf types.str;
-        default = let
-          consoles = [ "${qemu-common.qemuSerialDevice},115200n8" "tty0" ];
-        in if cfg.graphics then consoles else reverseList consoles;
+        default =
+          let
+            consoles = [
+              "${qemu-common.qemuSerialDevice},115200n8"
+              "tty0"
+            ];
+          in
+          if cfg.graphics then consoles else reverseList consoles;
         example = [ "console=tty1" ];
         description = ''
           The output console devices to pass to the kernel command line via the
···
         '';
       };
 
-      networkingOptions =
-        mkOption {
-          type = types.listOf types.str;
-          default = [ ];
-          example = [
-            "-net nic,netdev=user.0,model=virtio"
-            "-netdev user,id=user.0,\${QEMU_NET_OPTS:+,$QEMU_NET_OPTS}"
-          ];
-          description = ''
-            Networking-related command-line options that should be passed to qemu.
-            The default is to use userspace networking (SLiRP).
-            See the [QEMU Wiki on Networking](https://wiki.qemu.org/Documentation/Networking) for details.
+      networkingOptions = mkOption {
+        type = types.listOf types.str;
+        default = [ ];
+        example = [
+          "-net nic,netdev=user.0,model=virtio"
+          "-netdev user,id=user.0,\${QEMU_NET_OPTS:+,$QEMU_NET_OPTS}"
+        ];
+        description = ''
+          Networking-related command-line options that should be passed to qemu.
+          The default is to use userspace networking (SLiRP).
+          See the [QEMU Wiki on Networking](https://wiki.qemu.org/Documentation/Networking) for details.
 
-            If you override this option, be advised to keep
-            `''${QEMU_NET_OPTS:+,$QEMU_NET_OPTS}` (as seen in the example)
-            to keep the default runtime behaviour.
-          '';
-        };
-
-      drives =
-        mkOption {
-          type = types.listOf (types.submodule driveOpts);
-          description = "Drives passed to qemu.";
-        };
-
-      diskInterface =
-        mkOption {
-          type = types.enum [ "virtio" "scsi" "ide" ];
-          default = "virtio";
-          example = "scsi";
-          description = "The interface used for the virtual hard disks.";
-        };
+          If you override this option, be advised to keep
+          `''${QEMU_NET_OPTS:+,$QEMU_NET_OPTS}` (as seen in the example)
+          to keep the default runtime behaviour.
+        '';
+      };
 
-      guestAgent.enable =
-        mkOption {
-          type = types.bool;
-          default = true;
-          description = ''
-            Enable the Qemu guest agent.
-          '';
-        };
+      drives = mkOption {
+        type = types.listOf (types.submodule driveOpts);
+        description = "Drives passed to qemu.";
+      };
 
-      virtioKeyboard =
-        mkOption {
-          type = types.bool;
-          default = true;
-          description = ''
-            Enable the virtio-keyboard device.
-          '';
-        };
-    };
+      diskInterface = mkOption {
+        type = types.enum [
+          "virtio"
+          "scsi"
+          "ide"
+        ];
+        default = "virtio";
+        example = "scsi";
+        description = "The interface used for the virtual hard disks.";
+      };
 
-    virtualisation.useNixStoreImage =
-      mkOption {
+      guestAgent.enable = mkOption {
         type = types.bool;
-        default = false;
+        default = true;
         description = ''
-          Build and use a disk image for the Nix store, instead of
-          accessing the host's one through 9p.
-
-          For applications which do a lot of reads from the store,
-          this can drastically improve performance, but at the cost of
-          disk space and image build time.
-
-          The Nix store image is built just-in-time right before the VM is
-          started. Because it does not produce another derivation, the image is
-          not cached between invocations and never lands in the store or binary
-          cache.
-
-          If you want a full disk image with a partition table and a root
-          filesystem instead of only a store image, enable
-          {option}`virtualisation.useBootLoader` instead.
+          Enable the Qemu guest agent.
         '';
       };
 
-    virtualisation.mountHostNixStore =
-      mkOption {
+      virtioKeyboard = mkOption {
         type = types.bool;
-        default = !cfg.useNixStoreImage && !cfg.useBootLoader;
-        defaultText = literalExpression "!cfg.useNixStoreImage && !cfg.useBootLoader";
+        default = true;
         description = ''
-          Mount the host Nix store as a 9p mount.
+          Enable the virtio-keyboard device.
         '';
       };
+    };
 
-    virtualisation.directBoot = {
-      enable =
-        mkOption {
-          type = types.bool;
-          default = !cfg.useBootLoader;
-          defaultText = "!cfg.useBootLoader";
-          description = ''
-              If enabled, the virtual machine will boot directly into the kernel instead of through a bootloader.
-              Read more about this feature in the [QEMU documentation on Direct Linux Boot](https://qemu-project.gitlab.io/qemu/system/linuxboot.html)
+    virtualisation.useNixStoreImage = mkOption {
+      type = types.bool;
+      default = false;
+      description = ''
+        Build and use a disk image for the Nix store, instead of
+        accessing the host's one through 9p.
 
-              This is enabled by default.
-              If you want to test netboot, consider disabling this option.
-              Enable a bootloader with {option}`virtualisation.useBootLoader` if you need.
+        For applications which do a lot of reads from the store,
+        this can drastically improve performance, but at the cost of
+        disk space and image build time.
 
-              Relevant parameters such as those set in `boot.initrd` and `boot.kernelParams` are also passed to QEMU.
-              Additional parameters can be supplied on invocation through the environment variable `$QEMU_KERNEL_PARAMS`.
-              They are added to the `-append` option, see [QEMU User Documentation](https://www.qemu.org/docs/master/system/qemu-manpage) for details
-              For example, to let QEMU use the parent terminal as the serial console, set `QEMU_KERNEL_PARAMS="console=ttyS0"`.
+        The Nix store image is built just-in-time right before the VM is
+        started. Because it does not produce another derivation, the image is
+        not cached between invocations and never lands in the store or binary
+        cache.
 
-              This will not (re-)boot correctly into a system that has switched to a different configuration on disk.
-            '';
-        };
-      initrd =
-        mkOption {
-          type = types.str;
-          default = "${config.system.build.initialRamdisk}/${config.system.boot.loader.initrdFile}";
-          defaultText = "\${config.system.build.initialRamdisk}/\${config.system.boot.loader.initrdFile}";
-          description = ''
-              In direct boot situations, you may want to influence the initrd to load
-              to use your own customized payload.
+        If you want a full disk image with a partition table and a root
+        filesystem instead of only a store image, enable
+        {option}`virtualisation.useBootLoader` instead.
+      '';
+    };
 
-              This is useful if you want to test the netboot image without
-              testing the firmware or the loading part.
-            '';
-        };
+    virtualisation.mountHostNixStore = mkOption {
+      type = types.bool;
+      default = !cfg.useNixStoreImage && !cfg.useBootLoader;
+      defaultText = literalExpression "!cfg.useNixStoreImage && !cfg.useBootLoader";
+      description = ''
+        Mount the host Nix store as a 9p mount.
+      '';
     };
 
-    virtualisation.useBootLoader =
-      mkOption {
+    virtualisation.directBoot = {
+      enable = mkOption {
         type = types.bool;
-        default = false;
+        default = !cfg.useBootLoader;
+        defaultText = "!cfg.useBootLoader";
         description = ''
-            Use a boot loader to boot the system.
-            This allows, among other things, testing the boot loader.
+          If enabled, the virtual machine will boot directly into the kernel instead of through a bootloader.
+          Read more about this feature in the [QEMU documentation on Direct Linux Boot](https://qemu-project.gitlab.io/qemu/system/linuxboot.html)
 
-            If disabled, the kernel and initrd are directly booted,
-            forgoing any bootloader.
+          This is enabled by default.
+          If you want to test netboot, consider disabling this option.
+          Enable a bootloader with {option}`virtualisation.useBootLoader` if you need.
 
-            Check the documentation on {option}`virtualisation.directBoot.enable` for details.
-          '';
+          Relevant parameters such as those set in `boot.initrd` and `boot.kernelParams` are also passed to QEMU.
+          Additional parameters can be supplied on invocation through the environment variable `$QEMU_KERNEL_PARAMS`.
+          They are added to the `-append` option, see [QEMU User Documentation](https://www.qemu.org/docs/master/system/qemu-manpage) for details
+          For example, to let QEMU use the parent terminal as the serial console, set `QEMU_KERNEL_PARAMS="console=ttyS0"`.
+
+          This will not (re-)boot correctly into a system that has switched to a different configuration on disk.
+        '';
+      };
+      initrd = mkOption {
+        type = types.str;
+        default = "${config.system.build.initialRamdisk}/${config.system.boot.loader.initrdFile}";
+        defaultText = "\${config.system.build.initialRamdisk}/\${config.system.boot.loader.initrdFile}";
+        description = ''
+          In direct boot situations, you may want to influence the initrd to load
+          to use your own customized payload.
+
+          This is useful if you want to test the netboot image without
+          testing the firmware or the loading part.
+        '';
       };
+    };
 
-    virtualisation.useEFIBoot =
-      mkOption {
-        type = types.bool;
-        default = false;
-        description = ''
-            If enabled, the virtual machine will provide a EFI boot
-            manager.
-            useEFIBoot is ignored if useBootLoader == false.
-          '';
-        };
+    virtualisation.useBootLoader = mkOption {
+      type = types.bool;
+      default = false;
+      description = ''
+        Use a boot loader to boot the system.
+        This allows, among other things, testing the boot loader.
+
+        If disabled, the kernel and initrd are directly booted,
+        forgoing any bootloader.
+
+        Check the documentation on {option}`virtualisation.directBoot.enable` for details.
+      '';
+    };
+
+    virtualisation.useEFIBoot = mkOption {
+      type = types.bool;
+      default = false;
+      description = ''
+        If enabled, the virtual machine will provide a EFI boot
+        manager.
+        useEFIBoot is ignored if useBootLoader == false.
+      '';
+    };
 
     virtualisation.efi = {
       OVMF = mkOption {
         type = types.package;
-        default = (pkgs.OVMF.override {
-          secureBoot = cfg.useSecureBoot;
-        }).fd;
-        defaultText = ''(pkgs.OVMF.override {
-          secureBoot = cfg.useSecureBoot;
-        }).fd'';
+        default =
+          (pkgs.OVMF.override {
+            secureBoot = cfg.useSecureBoot;
+          }).fd;
+        defaultText = ''
+          (pkgs.OVMF.override {
+                    secureBoot = cfg.useSecureBoot;
+                  }).fd'';
         description = "OVMF firmware package, defaults to OVMF configured with secure boot if needed.";
       };
 
···
         default = cfg.efi.OVMF.firmware;
         defaultText = literalExpression "cfg.efi.OVMF.firmware";
         description = ''
-            Firmware binary for EFI implementation, defaults to OVMF.
-          '';
+          Firmware binary for EFI implementation, defaults to OVMF.
+        '';
       };
 
       variables = mkOption {
···
         default = cfg.efi.OVMF.variables;
         defaultText = literalExpression "cfg.efi.OVMF.variables";
         description = ''
-            Platform-specific flash binary for EFI variables, implementation-dependent to the EFI firmware.
-            Defaults to OVMF.
-          '';
+          Platform-specific flash binary for EFI variables, implementation-dependent to the EFI firmware.
+          Defaults to OVMF.
+        '';
       };
 
       keepVariables = mkOption {
···
 
       deviceModel = mkOption {
         type = types.str;
-        default = ({
-          "i686-linux" = "tpm-tis";
-          "x86_64-linux" = "tpm-tis";
-          "ppc64-linux" = "tpm-spapr";
-          "armv7-linux" = "tpm-tis-device";
-          "aarch64-linux" = "tpm-tis-device";
-        }.${pkgs.stdenv.hostPlatform.system} or (throw "Unsupported system for TPM2 emulation in QEMU"));
+        default = (
+          {
+            "i686-linux" = "tpm-tis";
+            "x86_64-linux" = "tpm-tis";
+            "ppc64-linux" = "tpm-spapr";
+            "armv7-linux" = "tpm-tis-device";
+            "aarch64-linux" = "tpm-tis-device";
+          }
+          .${pkgs.stdenv.hostPlatform.system} or (throw "Unsupported system for TPM2 emulation in QEMU")
+        );
         defaultText = ''
           Based on the guest platform Linux system:
 
···
       };
     };
 
-    virtualisation.useDefaultFilesystems =
-      mkOption {
-        type = types.bool;
-        default = true;
-        description = ''
-            If enabled, the boot disk of the virtual machine will be
-            formatted and mounted with the default filesystems for
-            testing. Swap devices and LUKS will be disabled.
+    virtualisation.useDefaultFilesystems = mkOption {
+      type = types.bool;
+      default = true;
+      description = ''
+        If enabled, the boot disk of the virtual machine will be
+        formatted and mounted with the default filesystems for
+        testing. Swap devices and LUKS will be disabled.
 
-            If disabled, a root filesystem has to be specified and
-            formatted (for example in the initial ramdisk).
-          '';
-      };
+        If disabled, a root filesystem has to be specified and
+        formatted (for example in the initial ramdisk).
+      '';
+    };
 
-    virtualisation.useSecureBoot =
-      mkOption {
-        type = types.bool;
-        default = false;
-        description = ''
-            Enable Secure Boot support in the EFI firmware.
-          '';
-      };
+    virtualisation.useSecureBoot = mkOption {
+      type = types.bool;
+      default = false;
+      description = ''
+        Enable Secure Boot support in the EFI firmware.
+      '';
+    };
 
-    virtualisation.bios =
-      mkOption {
-        type = types.nullOr types.package;
-        default = null;
-        description = ''
-            An alternate BIOS (such as `qboot`) with which to start the VM.
-            Should contain a file named `bios.bin`.
-            If `null`, QEMU's builtin SeaBIOS will be used.
-          '';
-      };
+    virtualisation.bios = mkOption {
+      type = types.nullOr types.package;
+      default = null;
+      description = ''
+        An alternate BIOS (such as `qboot`) with which to start the VM.
+        Should contain a file named `bios.bin`.
+        If `null`, QEMU's builtin SeaBIOS will be used.
+      '';
+    };
 
-    virtualisation.useHostCerts =
-      mkOption {
-        type = types.bool;
-        default = false;
-        description = ''
-            If enabled, when `NIX_SSL_CERT_FILE` is set on the host,
-            pass the CA certificates from the host to the VM.
-          '';
-      };
+    virtualisation.useHostCerts = mkOption {
+      type = types.bool;
+      default = false;
+      description = ''
+        If enabled, when `NIX_SSL_CERT_FILE` is set on the host,
+        pass the CA certificates from the host to the VM.
+      '';
+    };
 
   };
 
   config = {
 
     assertions =
-      lib.concatLists (lib.flip lib.imap cfg.forwardPorts (i: rule:
-        [
-          { assertion = rule.from == "guest" -> rule.proto == "tcp";
-            message =
-              ''
+      lib.concatLists (
+        lib.flip lib.imap cfg.forwardPorts (
+          i: rule: [
+            {
+              assertion = rule.from == "guest" -> rule.proto == "tcp";
+              message = ''
                 Invalid virtualisation.forwardPorts.<entry ${toString i}>.proto:
                   Guest forwarding supports only TCP connections.
               '';
-          }
-          { assertion = rule.from == "guest" -> lib.hasPrefix "10.0.2." rule.guest.address;
-            message =
-              ''
+            }
+            {
+              assertion = rule.from == "guest" -> lib.hasPrefix "10.0.2." rule.guest.address;
+              message = ''
                 Invalid virtualisation.forwardPorts.<entry ${toString i}>.guest.address:
                   The address must be in the default VLAN (10.0.2.0/24).
               '';
-          }
-        ])) ++ [
-          { assertion = pkgs.stdenv.hostPlatform.is32bit -> cfg.memorySize < 2047;
-            message = ''
-              virtualisation.memorySize is above 2047, but qemu is only able to allocate 2047MB RAM on 32bit max.
-            '';
-          }
-          { assertion = cfg.directBoot.enable || cfg.directBoot.initrd == options.virtualisation.directBoot.initrd.default;
-            message =
-              ''
-                You changed the default of `virtualisation.directBoot.initrd` but you are not
-                using QEMU direct boot. This initrd will not be used in your current
-                boot configuration.
+            }
+          ]
+        )
+      )
+      ++ [
+        {
+          assertion = pkgs.stdenv.hostPlatform.is32bit -> cfg.memorySize < 2047;
+          message = ''
+            virtualisation.memorySize is above 2047, but qemu is only able to allocate 2047MB RAM on 32bit max.
+          '';
+        }
+        {
+          assertion =
+            cfg.directBoot.enable || cfg.directBoot.initrd == options.virtualisation.directBoot.initrd.default;
+          message = ''
+            You changed the default of `virtualisation.directBoot.initrd` but you are not
+            using QEMU direct boot. This initrd will not be used in your current
+            boot configuration.
 
-                Either do not mutate `virtualisation.directBoot.initrd` or enable direct boot.
+            Either do not mutate `virtualisation.directBoot.initrd` or enable direct boot.
 
-                If you have a more advanced usecase, please open an issue or a pull request.
-              '';
-          }
-        ];
+            If you have a more advanced usecase, please open an issue or a pull request.
+          '';
+        }
+      ];
 
-    warnings =
-      optional (cfg.directBoot.enable && cfg.useBootLoader)
-        ''
-          You enabled direct boot and a bootloader, QEMU will not boot your bootloader, rendering
-          `useBootLoader` useless. You might want to disable one of those options.
-        '';
+    warnings = optional (cfg.directBoot.enable && cfg.useBootLoader) ''
+      You enabled direct boot and a bootloader, QEMU will not boot your bootloader, rendering
+      `useBootLoader` useless. You might want to disable one of those options.
+    '';
 
     # In UEFI boot, we use a EFI-only partition table layout, thus GRUB will fail when trying to install
     # legacy and UEFI. In order to avoid this, we have to put "nodev" to force UEFI-only installs.
···
     # allow `system.build.toplevel' to be included.  (If we had a direct
     # reference to ${regInfo} here, then we would get a cyclic
     # dependency.)
-    boot.postBootCommands = lib.mkIf config.nix.enable
-      ''
-        if [[ "$(cat /proc/cmdline)" =~ regInfo=([^ ]*) ]]; then
-          ${config.nix.package.out}/bin/nix-store --load-db < ''${BASH_REMATCH[1]}
-        fi
-      '';
+    boot.postBootCommands = lib.mkIf config.nix.enable ''
+      if [[ "$(cat /proc/cmdline)" =~ regInfo=([^ ]*) ]]; then
+        ${config.nix.package.out}/bin/nix-store --load-db < ''${BASH_REMATCH[1]}
+      fi
+    '';
 
     boot.initrd.availableKernelModules =
       optional (cfg.qemu.diskInterface == "scsi") "sym53c8xx"
···
 
     virtualisation.qemu.networkingOptions =
       let
-        forwardingOptions = flip concatMapStrings cfg.forwardPorts
-          ({ proto, from, host, guest }:
-            if from == "host"
-              then "hostfwd=${proto}:${host.address}:${toString host.port}-" +
-                   "${guest.address}:${toString guest.port},"
-              else "'guestfwd=${proto}:${guest.address}:${toString guest.port}-" +
-                   "cmd:${pkgs.netcat}/bin/nc ${host.address} ${toString host.port}',"
-          );
+        forwardingOptions = flip concatMapStrings cfg.forwardPorts (
+          {
+            proto,
+            from,
+            host,
+            guest,
+          }:
+          if from == "host" then
+            "hostfwd=${proto}:${host.address}:${toString host.port}-"
+            + "${guest.address}:${toString guest.port},"
+          else
+            "'guestfwd=${proto}:${guest.address}:${toString guest.port}-"
+            + "cmd:${pkgs.netcat}/bin/nc ${host.address} ${toString host.port}',"
+        );
         restrictNetworkOption = lib.optionalString cfg.restrictNetwork "restrict=on,";
       in
       [
···
         "-device virtio-keyboard"
       ])
       (mkIf pkgs.stdenv.hostPlatform.isx86 [
-        "-usb" "-device usb-tablet,bus=usb-bus.0"
+        "-usb"
+        "-device usb-tablet,bus=usb-bus.0"
       ])
       (mkIf pkgs.stdenv.hostPlatform.isAarch [
-        "-device virtio-gpu-pci" "-device usb-ehci,id=usb0" "-device usb-kbd" "-device usb-tablet"
+        "-device virtio-gpu-pci"
+        "-device usb-ehci,id=usb0"
+        "-device usb-kbd"
+        "-device usb-tablet"
       ])
-      (let
-        alphaNumericChars = lowerChars ++ upperChars ++ (map toString (range 0 9));
-        # Replace all non-alphanumeric characters with underscores
-        sanitizeShellIdent = s: concatMapStrings (c: if builtins.elem c alphaNumericChars then c else "_") (stringToCharacters s);
-      in mkIf cfg.directBoot.enable [
-        "-kernel \${NIXPKGS_QEMU_KERNEL_${sanitizeShellIdent config.system.name}:-${config.system.build.toplevel}/kernel}"
-        "-initrd ${cfg.directBoot.initrd}"
-        ''-append "$(cat ${config.system.build.toplevel}/kernel-params) init=${config.system.build.toplevel}/init regInfo=${regInfo}/registration ${consoles} $QEMU_KERNEL_PARAMS"''
-      ])
+      (
+        let
+          alphaNumericChars = lowerChars ++ upperChars ++ (map toString (range 0 9));
+          # Replace all non-alphanumeric characters with underscores
+          sanitizeShellIdent =
+            s:
+            concatMapStrings (c: if builtins.elem c alphaNumericChars then c else "_") (stringToCharacters s);
+        in
+        mkIf cfg.directBoot.enable [
+          "-kernel \${NIXPKGS_QEMU_KERNEL_${sanitizeShellIdent config.system.name}:-${config.system.build.toplevel}/kernel}"
+          "-initrd ${cfg.directBoot.initrd}"
+          ''-append "$(cat ${config.system.build.toplevel}/kernel-params) init=${config.system.build.toplevel}/init regInfo=${regInfo}/registration ${consoles} $QEMU_KERNEL_PARAMS"''
+        ]
+      )
       (mkIf cfg.useEFIBoot [
         "-drive if=pflash,format=raw,unit=0,readonly=on,file=${cfg.efi.firmware}"
         "-drive if=pflash,format=raw,unit=1,readonly=off,file=$NIX_EFI_VARS"
···
         "-device ${cfg.tpm.deviceModel},tpmdev=tpm_dev_0"
       ])
       (mkIf (pkgs.stdenv.hostPlatform.isx86 && cfg.efi.OVMF.systemManagementModeRequired) [
-        "-machine" "q35,smm=on"
-        "-global" "driver=cfi.pflash01,property=secure,value=on"
+        "-machine"
+        "q35,smm=on"
+        "-global"
+        "driver=cfi.pflash01,property=secure,value=on"
       ])
     ];
 
     virtualisation.qemu.drives = mkMerge [
-      (mkIf (cfg.diskImage != null) [{
-        name = "root";
-        file = ''"$NIX_DISK_IMAGE"'';
-        driveExtraOpts.cache = "writeback";
-        driveExtraOpts.werror = "report";
-        deviceExtraOpts.bootindex = "1";
-        deviceExtraOpts.serial = rootDriveSerialAttr;
-      }])
-      (mkIf cfg.useNixStoreImage [{
-        name = "nix-store";
-        file = ''"$TMPDIR"/store.img'';
-        deviceExtraOpts.bootindex = "2";
-        driveExtraOpts.format = "raw";
-      }])
+      (mkIf (cfg.diskImage != null) [
+        {
+          name = "root";
+          file = ''"$NIX_DISK_IMAGE"'';
+          driveExtraOpts.cache = "writeback";
+          driveExtraOpts.werror = "report";
+          deviceExtraOpts.bootindex = "1";
+          deviceExtraOpts.serial = rootDriveSerialAttr;
+        }
+      ])
+      (mkIf cfg.useNixStoreImage [
+        {
+          name = "nix-store";
+          file = ''"$TMPDIR"/store.img'';
+          deviceExtraOpts.bootindex = "2";
+          driveExtraOpts.format = "raw";
+        }
+      ])
       (imap0 (idx: _: {
         file = "$(pwd)/empty${toString idx}.qcow2";
         driveExtraOpts.werror = "report";
···
     # override by setting `virtualisation.fileSystems = lib.mkForce { };`.
     fileSystems = lib.mkIf (cfg.fileSystems != { }) (mkVMOverride cfg.fileSystems);
 
-    virtualisation.fileSystems = let
-      mkSharedDir = tag: share:
-        {
+    virtualisation.diskSizeAutoSupported = false;
+
+    virtualisation.fileSystems =
+      let
+        mkSharedDir = tag: share: {
           name = share.target;
           value.device = tag;
           value.fsType = "9p";
           value.neededForBoot = true;
-          value.options =
-            [ "trans=virtio" "version=9p2000.L"  "msize=${toString cfg.msize}" ]
-            ++ lib.optional (tag == "nix-store") "cache=loose";
+          value.options = [
+            "trans=virtio"
+            "version=9p2000.L"
+            "msize=${toString cfg.msize}"
+          ] ++ lib.optional (tag == "nix-store") "cache=loose";
         };
-    in lib.mkMerge [
-      (lib.mapAttrs' mkSharedDir cfg.sharedDirectories)
-      {
-        "/" = lib.mkIf cfg.useDefaultFilesystems (if cfg.diskImage == null then {
-          device = "tmpfs";
-          fsType = "tmpfs";
-        } else {
-          device = cfg.rootDevice;
-          fsType = "ext4";
-        });
-        "/tmp" = lib.mkIf config.boot.tmp.useTmpfs {
-          device = "tmpfs";
-          fsType = "tmpfs";
-          neededForBoot = true;
-          # Sync with systemd's tmp.mount;
-          options = [ "mode=1777" "strictatime" "nosuid" "nodev" "size=${toString config.boot.tmp.tmpfsSize}" ];
-        };
-        "/nix/store" = lib.mkIf (cfg.useNixStoreImage || cfg.mountHostNixStore) (if cfg.writableStore then {
-          overlay = {
-            lowerdir = [ "/nix/.ro-store" ];
-            upperdir = "/nix/.rw-store/upper";
-            workdir = "/nix/.rw-store/work";
+      in
+      lib.mkMerge [
+        (lib.mapAttrs' mkSharedDir cfg.sharedDirectories)
+        {
+          "/" = lib.mkIf cfg.useDefaultFilesystems (
+            if cfg.diskImage == null then
+              {
+                device = "tmpfs";
+                fsType = "tmpfs";
+              }
+            else
+              {
+                device = cfg.rootDevice;
+                fsType = "ext4";
+              }
+          );
+          "/tmp" = lib.mkIf config.boot.tmp.useTmpfs {
+            device = "tmpfs";
+            fsType = "tmpfs";
+            neededForBoot = true;
+            # Sync with systemd's tmp.mount;
+            options = [
+              "mode=1777"
+              "strictatime"
+              "nosuid"
+              "nodev"
+              "size=${toString config.boot.tmp.tmpfsSize}"
+            ];
+          };
+          "/nix/store" = lib.mkIf (cfg.useNixStoreImage || cfg.mountHostNixStore) (
+            if cfg.writableStore then
+              {
+                overlay = {
+                  lowerdir = [ "/nix/.ro-store" ];
+                  upperdir = "/nix/.rw-store/upper";
+                  workdir = "/nix/.rw-store/work";
+                };
+              }
+            else
+              {
+                device = "/nix/.ro-store";
+                options = [ "bind" ];
+              }
+          );
+          "/nix/.ro-store" = lib.mkIf cfg.useNixStoreImage {
+            device = "/dev/disk/by-label/${nixStoreFilesystemLabel}";
+            fsType = "erofs";
+            neededForBoot = true;
+            options = [ "ro" ];
+          };
+          "/nix/.rw-store" = lib.mkIf (cfg.writableStore && cfg.writableStoreUseTmpfs) {
+            fsType = "tmpfs";
+            options = [ "mode=0755" ];
+            neededForBoot = true;
           };
-        } else {
-          device = "/nix/.ro-store";
-          options = [ "bind" ];
-        });
-        "/nix/.ro-store" = lib.mkIf cfg.useNixStoreImage {
-          device = "/dev/disk/by-label/${nixStoreFilesystemLabel}";
-          fsType = "erofs";
-          neededForBoot = true;
-          options = [ "ro" ];
-        };
-        "/nix/.rw-store" = lib.mkIf (cfg.writableStore && cfg.writableStoreUseTmpfs) {
-          fsType = "tmpfs";
-          options = [ "mode=0755" ];
-          neededForBoot = true;
-        };
-        "${config.boot.loader.efi.efiSysMountPoint}" = lib.mkIf (cfg.useBootLoader && cfg.bootPartition != null) {
-          device = cfg.bootPartition;
-          fsType = "vfat";
-        };
-      }
-    ];
+          "${config.boot.loader.efi.efiSysMountPoint}" =
+            lib.mkIf (cfg.useBootLoader && cfg.bootPartition != null)
+              {
+                device = cfg.bootPartition;
+                fsType = "vfat";
+              };
+        }
+      ];
 
     swapDevices = (if cfg.useDefaultFilesystems then mkVMOverride else mkDefault) [ ];
-    boot.initrd.luks.devices = (if cfg.useDefaultFilesystems then mkVMOverride else mkDefault) {};
+    boot.initrd.luks.devices = (if cfg.useDefaultFilesystems then mkVMOverride else mkDefault) { };
 
     # Don't run ntpd in the guest.  It should get the correct time from KVM.
     services.timesyncd.enable = false;
 
     services.qemuGuest.enable = cfg.qemu.guestAgent.enable;
 
-    system.build.vm = hostPkgs.runCommand "nixos-vm" {
-      preferLocalBuild = true;
-      meta.mainProgram = "run-${config.system.name}-vm";
-    }
-      ''
-        mkdir -p $out/bin
-        ln -s ${config.system.build.toplevel} $out/system
-        ln -s ${hostPkgs.writeScript "run-nixos-vm" startVM} $out/bin/run-${config.system.name}-vm
-      '';
+    system.build.vm =
+      hostPkgs.runCommand "nixos-vm"
+        {
+          preferLocalBuild = true;
+          meta.mainProgram = "run-${config.system.name}-vm";
+        }
+        ''
+          mkdir -p $out/bin
+          ln -s ${config.system.build.toplevel} $out/system
+          ln -s ${hostPkgs.writeScript "run-nixos-vm" startVM} $out/bin/run-${config.system.name}-vm
+        '';
 
     # When building a regular system configuration, override whatever
     # video driver the host uses.
     services.xserver.videoDrivers = mkVMOverride [ "modesetting" ];
     services.xserver.defaultDepth = mkVMOverride 0;
     services.xserver.resolutions = mkVMOverride [ cfg.resolution ];
-    services.xserver.monitorSection =
-      ''
-        # Set a higher refresh rate so that resolutions > 800x600 work.
-        HorizSync 30-140
-        VertRefresh 50-160
-      '';
+    services.xserver.monitorSection = ''
+      # Set a higher refresh rate so that resolutions > 800x600 work.
+      HorizSync 30-140
+      VertRefresh 50-160
+    '';
 
     # Wireless won't work in the VM.
     networking.wireless.enable = mkVMOverride false;
···
 
     networking.usePredictableInterfaceNames = false;
 
-    system.requiredKernelConfig = with config.lib.kernelConfig;
-      [ (isEnabled "VIRTIO_BLK")
+    system.requiredKernelConfig =
+      with config.lib.kernelConfig;
+      [
+        (isEnabled "VIRTIO_BLK")
         (isEnabled "VIRTIO_PCI")
         (isEnabled "VIRTIO_NET")
         (isEnabled "EXT4_FS")
···
         (isYes "NET_CORE")
         (isYes "INET")
         (isYes "NETWORK_FILESYSTEMS")
-      ] ++ optionals (!cfg.graphics) [
+      ]
+      ++ optionals (!cfg.graphics) [
         (isYes "SERIAL_8250_CONSOLE")
         (isYes "SERIAL_8250")
-      ] ++ optionals (cfg.writableStore) [
+      ]
+      ++ optionals (cfg.writableStore) [
         (isEnabled "OVERLAY_FS")
       ];
 

nixos/modules/virtualisation/virtualbox-image.nix

···
-{ config, lib, pkgs, ... }:
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}:
 
 with lib;
 
 let
 
   cfg = config.virtualbox;
+  virtualisationOptions = import ./virtualisation-options.nix;
 
-in {
+in
+{
+  imports = [
+    virtualisationOptions.diskSize
+    (lib.mkRenamedOptionModuleWith {
+      sinceRelease = 2411;
+      from = [
+        "virtualisation"
+        "virtualbox"
+        "baseImageSize"
+      ];
+      to = [
+        "virtualisation"
+        "diskSize"
+      ];
+    })
+  ];
 
   options = {
     virtualbox = {
-      baseImageSize = mkOption {
-        type = with types; either (enum [ "auto" ]) int;
-        default = "auto";
-        example = 50 * 1024;
-        description = ''
-          The size of the VirtualBox base image in MiB.
-        '';
-      };
       baseImageFreeSpace = mkOption {
         type = with types; int;
         default = 30 * 1024;
···
         '';
       };
       params = mkOption {
-        type = with types; attrsOf (oneOf [ str int bool (listOf str) ]);
+        type =
+          with types;
+          attrsOf (oneOf [
+            str
+            int
+            bool
+            (listOf str)
+          ]);
         example = {
           audio = "alsa";
           rtcuseutc = "on";
···
         '';
       };
       exportParams = mkOption {
-        type = with types; listOf (oneOf [ str int bool (listOf str) ]);
+        type =
+          with types;
+          listOf (oneOf [
+            str
+            int
+            bool
+            (listOf str)
+          ]);
         example = [
-          "--vsys" "0" "--vendor" "ACME Inc."
+          "--vsys"
+          "0"
+          "--vendor"
+          "ACME Inc."
         ];
-        default = [];
+        default = [ ];
         description = ''
           Parameters passed to the Virtualbox export command.
 
···
           mountPoint = "/home/demo/storage";
           size = 100 * 1024;
         };
-        type = types.nullOr (types.submodule {
-          options = {
-            size = mkOption {
-              type = types.int;
-              description = "Size in MiB";
-            };
-            label = mkOption {
-              type = types.str;
-              default = "vm-extra-storage";
-              description = "Label for the disk partition";
-            };
-            mountPoint = mkOption {
-              type = types.str;
-              description = "Path where to mount this disk.";
+        type = types.nullOr (
+          types.submodule {
+            options = {
+              size = mkOption {
+                type = types.int;
+                description = "Size in MiB";
+              };
+              label = mkOption {
+                type = types.str;
+                default = "vm-extra-storage";
+                description = "Label for the disk partition";
+              };
+              mountPoint = mkOption {
+                type = types.str;
+                description = "Path where to mount this disk.";
+              };
             };
-          };
-        });
+          }
+        );
       };
       postExportCommands = mkOption {
         type = types.lines;
···
         '';
       };
       storageController = mkOption {
-        type = with types; attrsOf (oneOf [ str int bool (listOf str) ]);
+        type =
+          with types;
+          attrsOf (oneOf [
+            str
+            int
+            bool
+            (listOf str)
+          ]);
         example = {
           name = "SCSI";
           add = "scsi";
···
 
   config = {
 
+    virtualisation.diskSize = lib.mkDefault (50 * 1024);
+
     virtualbox.params = mkMerge [
       (mapAttrs (name: mkDefault) {
         acpi = "on";
···
 
       inherit pkgs lib config;
       partitionTableType = "legacy";
-      diskSize = cfg.baseImageSize;
+      inherit (config.virtualisation) diskSize;
       additionalSpace = "${toString cfg.baseImageFreeSpace}M";
 
-      postVM =
-        ''
-          export HOME=$PWD
-          export PATH=${pkgs.virtualbox}/bin:$PATH
+      postVM = ''
+        export HOME=$PWD
+        export PATH=${pkgs.virtualbox}/bin:$PATH
 
-          echo "converting image to VirtualBox format..."
-          VBoxManage convertfromraw $diskImage disk.vdi
+        echo "converting image to VirtualBox format..."
+        VBoxManage convertfromraw $diskImage disk.vdi
 
-          ${optionalString (cfg.extraDisk != null) ''
-            echo "creating extra disk: data-disk.raw"
-            dataDiskImage=data-disk.raw
-            truncate -s ${toString cfg.extraDisk.size}M $dataDiskImage
+        ${optionalString (cfg.extraDisk != null) ''
+          echo "creating extra disk: data-disk.raw"
+          dataDiskImage=data-disk.raw
+          truncate -s ${toString cfg.extraDisk.size}M $dataDiskImage
 
-            parted --script $dataDiskImage -- \
-              mklabel msdos \
-              mkpart primary ext4 1MiB -1
-            eval $(partx $dataDiskImage -o START,SECTORS --nr 1 --pairs)
-            mkfs.ext4 -F -L ${cfg.extraDisk.label} $dataDiskImage -E offset=$(sectorsToBytes $START) $(sectorsToKilobytes $SECTORS)K
-            echo "creating extra disk: data-disk.vdi"
-            VBoxManage convertfromraw $dataDiskImage data-disk.vdi
-          ''}
+          parted --script $dataDiskImage -- \
+            mklabel msdos \
+            mkpart primary ext4 1MiB -1
+          eval $(partx $dataDiskImage -o START,SECTORS --nr 1 --pairs)
+          mkfs.ext4 -F -L ${cfg.extraDisk.label} $dataDiskImage -E offset=$(sectorsToBytes $START) $(sectorsToKilobytes $SECTORS)K
+          echo "creating extra disk: data-disk.vdi"
+          VBoxManage convertfromraw $dataDiskImage data-disk.vdi
+        ''}
 
-          echo "creating VirtualBox VM..."
-          vmName="${cfg.vmName}";
-          VBoxManage createvm --name "$vmName" --register \
-            --ostype ${if pkgs.stdenv.hostPlatform.system == "x86_64-linux" then "Linux26_64" else "Linux26"}
-          VBoxManage modifyvm "$vmName" \
-            --memory ${toString cfg.memorySize} \
-            ${lib.cli.toGNUCommandLineShell { } cfg.params}
-          VBoxManage storagectl "$vmName" ${lib.cli.toGNUCommandLineShell { } cfg.storageController}
-          VBoxManage storageattach "$vmName" --storagectl ${cfg.storageController.name} --port 0 --device 0 --type hdd \
-            --medium disk.vdi
-          ${optionalString (cfg.extraDisk != null) ''
-            VBoxManage storageattach "$vmName" --storagectl ${cfg.storageController.name} --port 1 --device 0 --type hdd \
-            --medium data-disk.vdi
-          ''}
+        echo "creating VirtualBox VM..."
+        vmName="${cfg.vmName}";
+        VBoxManage createvm --name "$vmName" --register \
+          --ostype ${if pkgs.stdenv.hostPlatform.system == "x86_64-linux" then "Linux26_64" else "Linux26"}
+        VBoxManage modifyvm "$vmName" \
+          --memory ${toString cfg.memorySize} \
+          ${lib.cli.toGNUCommandLineShell { } cfg.params}
+        VBoxManage storagectl "$vmName" ${lib.cli.toGNUCommandLineShell { } cfg.storageController}
+        VBoxManage storageattach "$vmName" --storagectl ${cfg.storageController.name} --port 0 --device 0 --type hdd \
+          --medium disk.vdi
+        ${optionalString (cfg.extraDisk != null) ''
+          VBoxManage storageattach "$vmName" --storagectl ${cfg.storageController.name} --port 1 --device 0 --type hdd \
+          --medium data-disk.vdi
+        ''}
 
-          echo "exporting VirtualBox VM..."
-          mkdir -p $out
-          fn="$out/${cfg.vmFileName}"
-          VBoxManage export "$vmName" --output "$fn" --options manifest ${escapeShellArgs cfg.exportParams}
-          ${cfg.postExportCommands}
+        echo "exporting VirtualBox VM..."
+        mkdir -p $out
+        fn="$out/${cfg.vmFileName}"
+        VBoxManage export "$vmName" --output "$fn" --options manifest ${escapeShellArgs cfg.exportParams}
+        ${cfg.postExportCommands}
 
-          rm -v $diskImage
+        rm -v $diskImage
 
-          mkdir -p $out/nix-support
-          echo "file ova $fn" >> $out/nix-support/hydra-build-products
-        '';
+        mkdir -p $out/nix-support
+        echo "file ova $fn" >> $out/nix-support/hydra-build-products
+      '';
     };
 
-    fileSystems = {
-      "/" = {
-        device = "/dev/disk/by-label/nixos";
-        autoResize = true;
-        fsType = "ext4";
-      };
-    } // (lib.optionalAttrs (cfg.extraDisk != null) {
-      ${cfg.extraDisk.mountPoint} = {
-        device = "/dev/disk/by-label/" + cfg.extraDisk.label;
-        autoResize = true;
-        fsType = "ext4";
-      };
-    });
+    fileSystems =
+      {
+        "/" = {
+          device = "/dev/disk/by-label/nixos";
+          autoResize = true;
+          fsType = "ext4";
+        };
+      }
+      // (lib.optionalAttrs (cfg.extraDisk != null) {
+        ${cfg.extraDisk.mountPoint} = {
+          device = "/dev/disk/by-label/" + cfg.extraDisk.label;
+          autoResize = true;
+          fsType = "ext4";
+        };
+      });
 
     boot.growPartition = true;
     boot.loader.grub.device = "/dev/sda";
 
-    swapDevices = [{
-      device = "/var/swap";
-      size = 2048;
-    }];
+    swapDevices = [
+      {
+        device = "/var/swap";
+        size = 2048;
+      }
+    ];
 
     virtualisation.virtualbox.guest.enable = true;
 

nixos/modules/virtualisation/virtualisation-options.nix

···
+# This modules declares shared options for virtual machines,
+# containers and anything else in `virtualisation`.
+#
+# This is useful to declare e.g. defaults for
+# `virtualisation.diskSize` once, while building multiple
+# different image formats of a NixOS configuration.
+#
+# Additional options can be migrated over time from
+# `modules/virtualisation/qemu-vm.nix` and others.
+# Please keep defaults and descriptions here generic
+# and independent of i.e. hypervisor-specific notes
+# and defaults where.
+# Those can be added in the consuming modules where needed.
+# needed.
+let
+  _file = ./virtualisation-options.nix;
+  key = _file;
+in
+{
+  diskSize =
+    { lib, config, ... }:
+    let
+      t = lib.types;
+    in
+    {
+      inherit _file key;
+
+      options = {
+        virtualisation.diskSizeAutoSupported = lib.mkOption {
+          type = t.bool;
+          default = true;
+          description = ''
+            Whether the current image builder or vm runner supports `virtualisation.diskSize = "auto".`
+          '';
+          internal = true;
+        };
+
+        virtualisation.diskSize = lib.mkOption {
+          type = t.either (t.enum [ "auto" ]) t.ints.positive;
+          default = "auto";
+          description = ''
+            The disk size in megabytes of the virtual machine.
+          '';
+        };
+      };
+
+      config =
+        let
+          inherit (config.virtualisation) diskSize diskSizeAutoSupported;
+        in
+        {
+          assertions = [
+            {
+              assertion = diskSize != "auto" || diskSizeAutoSupported;
+              message = "Setting virtualisation.diskSize to `auto` is not supported by the current image build or vm runner; use an explicit size.";
+            }
+          ];
+        };
+    };
+}

nixos/release.nix

···
         [ configuration
           versionModule
           ./maintainers/scripts/ec2/amazon-image.nix
-          ({ ... }: { amazonImage.sizeMB = "auto"; })
+          ({ ... }: { amazonImage.virtualisation.diskSize = "auto"; })
         ];
     }).config.system.build.amazonImage)
 

nixos/tests/matrix/appservice-irc.nix

···
                   aliasTemplate = "#irc_$CHANNEL";
                 };
               };
-              mediaProxy.publicUrl = "http://localhost:11111/media";
+              mediaProxy = {
+                publicUrl = "http://localhost:11111/media";
+                ttl = 0;
+              };
             };
           };
         };

pkgs/applications/audio/praat/default.nix

···
 
 stdenv.mkDerivation (finalAttrs: {
   pname = "praat";
-  version = "6.4.14";
+  version = "6.4.19";
 
   src = fetchFromGitHub {
     owner = "praat";
     repo = "praat";
     rev = "v${finalAttrs.version}";
-    hash = "sha256-AY/OSoCWlWSjtLcve16nL72HidPlJqJgAOvUubMqvj0=";
+    hash = "sha256-dK1rCfyTIASMGWEWQomdbazpI6faBvlrRpyGDuSoW5g=";
   };
 
   nativeBuildInputs = [

pkgs/applications/audio/roomeqwizard/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "roomeqwizard";
-  version = "5.31.2";
+  version = "5.31.3";
 
   src = fetchurl {
     url = "https://www.roomeqwizard.com/installers/REW_linux_no_jre_${lib.replaceStrings [ "." ] [ "_" ] version}.sh";
-    sha256 = "sha256-B4qP+qNNPMB/EkW/C2kfcx+h9YH8Md1lM9yUh5YT13s=";
+    sha256 = "sha256-qaGkKVoiBJ2UWVKAMqbuqNFi6FGcblMxAbYwhf/71CY=";
   };
 
   dontUnpack = true;

pkgs/applications/audio/seq66/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "seq66";
-  version = "0.99.13";
+  version = "0.99.14";
 
   src = fetchFromGitHub {
     owner = "ahlstromcj";
     repo = "seq66";
     rev = version;
-    hash = "sha256-hR8kEt3tKnH96JmmkMuY0WWxxp9YTcSvsJvICKNjvyQ=";
+    hash = "sha256-0xexKu8qQd0HzEHYKMomeoBE1s/tC5T1jzUl+AkhTqY=";
   };
 
   nativeBuildInputs = [ autoreconfHook pkg-config qttools which wrapQtAppsHook ];

pkgs/applications/blockchains/haven-cli/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "haven-cli";
-  version = "4.0.2";
+  version = "4.1.0";
 
   src = fetchFromGitHub {
     owner = "haven-protocol-org";
     repo = "haven-main";
     rev = "v${version}";
-    hash = "sha256-XjRxpUW7NC12T5G7fol4avWLJDOOawxJbAHOp5eZ0Fk=";
+    hash = "sha256-UPDhvARXatqvxwsuSfxdasVcLbjkXOpK8yY7GoEPxxw=";
     fetchSubmodules = true;
   };
 

pkgs/applications/editors/lapce/Cargo.lock

···
 [[package]]
 name = "floem"
 version = "0.1.1"
-source = "git+https://github.com/lapce/floem?rev=54f0d1bcf0e1a91d82492ee7300a526adb60eb5c#54f0d1bcf0e1a91d82492ee7300a526adb60eb5c"
+source = "git+https://github.com/lapce/floem?rev=157631a49d6ba13a3467dcb994eb46a98c52eb76#157631a49d6ba13a3467dcb994eb46a98c52eb76"
 dependencies = [
  "bitflags 2.6.0",
  "copypasta",
···
  "image",
  "indexmap",
  "lapce-xi-rope",
- "once_cell",
  "parking_lot",
  "peniko",
  "raw-window-handle 0.6.0",
···
 [[package]]
 name = "floem-editor-core"
 version = "0.1.1"
-source = "git+https://github.com/lapce/floem?rev=54f0d1bcf0e1a91d82492ee7300a526adb60eb5c#54f0d1bcf0e1a91d82492ee7300a526adb60eb5c"
+source = "git+https://github.com/lapce/floem?rev=157631a49d6ba13a3467dcb994eb46a98c52eb76#157631a49d6ba13a3467dcb994eb46a98c52eb76"
 dependencies = [
  "bitflags 2.6.0",
  "itertools 0.12.1",
  "lapce-xi-rope",
  "memchr",
- "once_cell",
  "serde",
  "strum",
  "strum_macros",
···
 [[package]]
 name = "floem_reactive"
 version = "0.1.1"
-source = "git+https://github.com/lapce/floem?rev=54f0d1bcf0e1a91d82492ee7300a526adb60eb5c#54f0d1bcf0e1a91d82492ee7300a526adb60eb5c"
+source = "git+https://github.com/lapce/floem?rev=157631a49d6ba13a3467dcb994eb46a98c52eb76#157631a49d6ba13a3467dcb994eb46a98c52eb76"
 dependencies = [
  "smallvec",
 ]
···
 [[package]]
 name = "floem_renderer"
 version = "0.1.1"
-source = "git+https://github.com/lapce/floem?rev=54f0d1bcf0e1a91d82492ee7300a526adb60eb5c#54f0d1bcf0e1a91d82492ee7300a526adb60eb5c"
+source = "git+https://github.com/lapce/floem?rev=157631a49d6ba13a3467dcb994eb46a98c52eb76#157631a49d6ba13a3467dcb994eb46a98c52eb76"
 dependencies = [
  "cosmic-text",
  "image",
···
 [[package]]
 name = "floem_tiny_skia_renderer"
 version = "0.1.1"
-source = "git+https://github.com/lapce/floem?rev=54f0d1bcf0e1a91d82492ee7300a526adb60eb5c#54f0d1bcf0e1a91d82492ee7300a526adb60eb5c"
+source = "git+https://github.com/lapce/floem?rev=157631a49d6ba13a3467dcb994eb46a98c52eb76#157631a49d6ba13a3467dcb994eb46a98c52eb76"
 dependencies = [
  "anyhow",
  "bytemuck",
···
 [[package]]
 name = "floem_vger_renderer"
 version = "0.1.1"
-source = "git+https://github.com/lapce/floem?rev=54f0d1bcf0e1a91d82492ee7300a526adb60eb5c#54f0d1bcf0e1a91d82492ee7300a526adb60eb5c"
+source = "git+https://github.com/lapce/floem?rev=157631a49d6ba13a3467dcb994eb46a98c52eb76#157631a49d6ba13a3467dcb994eb46a98c52eb76"
 dependencies = [
  "anyhow",
  "floem-vger",
···
 
 [[package]]
 name = "lapce"
-version = "0.4.1"
+version = "0.4.2"
 dependencies = [
  "lapce-app",
  "lapce-proxy",
···
 
 [[package]]
 name = "lapce-app"
-version = "0.4.1"
+version = "0.4.2"
 dependencies = [
  "Inflector",
  "alacritty_terminal",
···
 
 [[package]]
 name = "lapce-core"
-version = "0.4.1"
+version = "0.4.2"
 dependencies = [
  "ahash",
  "anyhow",
···
 
 [[package]]
 name = "lapce-proxy"
-version = "0.4.1"
+version = "0.4.2"
 dependencies = [
  "alacritty_terminal",
  "anyhow",
···
 
 [[package]]
 name = "lapce-rpc"
-version = "0.4.1"
+version = "0.4.2"
 dependencies = [
  "anyhow",
  "crossbeam-channel",

pkgs/applications/editors/lapce/default.nix

···
 in
 rustPlatform.buildRustPackage rec {
   pname = "lapce";
-  version = "0.4.1";
+  version = "0.4.2";
 
   src = fetchFromGitHub {
     owner = "lapce";
     repo = "lapce";
     rev = "refs/tags/v${version}";
-    sha256 = "sha256-Bwo6twEi9m3T5OybWkWGAyTRumusCWW7mkx/OAJkfXs=";
+    sha256 = "sha256-vBBYNHgZiW5JfGeUG6YZObf4oK0hHxTbsZNTfnIX95Y=";
   };
 
   cargoLock = {
     lockFile = ./Cargo.lock;
     outputHashes = {
       "alacritty_terminal-0.24.1-dev" = "sha256-aVB1CNOLjNh6AtvdbomODNrk00Md8yz8QzldzvDo1LI=";
-      "floem-0.1.1" = "sha256-zV2nk3cvmw8lzqL4Xx5SCTX156tiN6sUAEdfy0dJvDY=";
+      "floem-0.1.1" = "sha256-/4Y38VXx7wFVVEzjqZ2D6+jiXCXPfzK44rDiNOR1lAk=";
       "human-sort-0.2.2" = "sha256-tebgIJGXOY7pwWRukboKAzXY47l4Cn//0xMKQTaGu8w=";
       "locale_config-0.3.1-alpha.0" = "sha256-cCEO+dmU05TKkpH6wVK6tiH94b7k2686xyGxlhkcmAM=";
       "lsp-types-0.95.1" = "sha256-+tWqDBM5x/gvQOG7V3m2tFBZB7smgnnZHikf9ja2FfE=";

pkgs/applications/editors/vim/plugins/generated.nix

···
     meta.homepage = "https://github.com/nvim-lua/diagnostic-nvim/";
   };
 
+  diagram-nvim = buildVimPlugin {
+    pname = "diagram.nvim";
+    version = "2024-08-30";
+    src = fetchFromGitHub {
+      owner = "3rd";
+      repo = "diagram.nvim";
+      rev = "d19b9bb2ca162facc242c357c2802b8cfab6b55c";
+      sha256 = "0scgbhjcq0ivlys0a813gwcvw2ckkykyhhjqni6l81gghcc9qgjr";
+    };
+    meta.homepage = "https://github.com/3rd/diagram.nvim/";
+  };
+
   dial-nvim = buildVimPlugin {
     pname = "dial.nvim";
     version = "2024-07-15";

pkgs/applications/editors/vim/plugins/overrides.nix

···
     };
   };
 
+  diagram-nvim = super.diagram-nvim.overrideAttrs {
+    dependencies = with self; [ image-nvim ];
+  };
+
   diffview-nvim = super.diffview-nvim.overrideAttrs {
     dependencies = with self; [ plenary-nvim ];
 

pkgs/applications/editors/vim/plugins/vim-plugin-names

···
 https://github.com/vmchale/dhall-vim/,,
 https://github.com/onsails/diaglist.nvim/,,
 https://github.com/nvim-lua/diagnostic-nvim/,,
+https://github.com/3rd/diagram.nvim/,HEAD,
 https://github.com/monaqa/dial.nvim/,HEAD,
 https://github.com/sindrets/diffview.nvim/,,
 https://github.com/elihunter173/dirbuf.nvim/,HEAD,

pkgs/applications/editors/vscode/extensions/ms-toolsai.jupyter/default.nix

···
   mktplcRef = {
     name = "jupyter";
     publisher = "ms-toolsai";
-    version = "2024.7.0";
-    hash = "sha256-hf6Y1SjKfLGe5LQ9swbPzbOCtohQ43DzHXMZwRt2d90=";
+    version = "2024.8.0";
+    hash = "sha256-aEDgIDlQfQNcyrgm7MjJjCc6aKWfBNwfKu/t43+VQZk=";
   };
 
   nativeBuildInputs = [

pkgs/applications/graphics/hydrus/default.nix

···
 
 python3Packages.buildPythonPackage rec {
   pname = "hydrus";
-  version = "581";
+  version = "588";
   format = "other";
 
   src = fetchFromGitHub {
     owner = "hydrusnetwork";
     repo = "hydrus";
     rev = "refs/tags/v${version}";
-    hash = "sha256-Q/EdqwIMCjeDtFAPlYd04NMpEgC6xUDGK5LwxDCiI9Y=";
+    hash = "sha256-0uRoOgpz3FSDedzx728jAPhrCAReVygkb5tZTTUxNEY=";
   };
 
   nativeBuildInputs = [

pkgs/applications/graphics/komikku/default.nix

···
 
 python3.pkgs.buildPythonApplication rec {
   pname = "komikku";
-  version = "1.52.0";
+  version = "1.57.0";
 
   format = "other";
 
···
     owner = "valos";
     repo = "Komikku";
     rev = "v${version}";
-    hash = "sha256-Ls8haijbd5rPQwnJCYjLbA1KAVZhPk0aRRe2TtzmTCs=";
+    hash = "sha256-b2XoywPnrYnuehR6xHH8BvhbMZFB1AeBN0khFfaLGn0=";
   };
 
   nativeBuildInputs = [

pkgs/applications/graphics/mandelbulber/default.nix

···
 
 mkDerivation rec {
   pname = "mandelbulber";
-  version = "2.31-1";
+  version = "2.32";
 
   src = fetchFromGitHub {
     owner = "buddhi1980";
     repo = "mandelbulber2";
     rev = version;
-    sha256 = "sha256-nyIFvFe86C2ciBDSNWn1yrBYTCm1dR7sZ5RFGoTPqvQ=";
+    sha256 = "sha256-amNNRuuk7qtcyXUVLEW71yEETExgKw48HeQQyxbi8BE=";
   };
 
   nativeBuildInputs = [

pkgs/applications/logging/sosreport/default.nix

···
 
 buildPythonPackage rec {
   pname = "sosreport";
-  version = "4.7.2";
+  version = "4.8.0";
 
   src = fetchFromGitHub {
     owner = "sosreport";
     repo = "sos";
     rev = "refs/tags/${version}";
-    sha256 = "sha256-67YRmD3kaJbRR7g3w57EwFg7duhcI6zov7gQ4H1MkR8=";
+    sha256 = "sha256-8laOHFBvlSo70filTd84vMiivcZ9hE8rgFThVVrMwtE=";
   };
 
   nativeBuildInputs = [

pkgs/applications/misc/fluidd/default.nix

···
 
 stdenvNoCC.mkDerivation rec {
   pname = "fluidd";
-  version = "1.30.1";
+  version = "1.30.3";
 
   src = fetchurl {
     name = "fluidd-v${version}.zip";
     url = "https://github.com/cadriel/fluidd/releases/download/v${version}/fluidd.zip";
-    sha256 = "sha256-R8lCAZkClmCFkiNPf9KGlzj2td3KxCx/7UkdTJgDtwY=";
+    sha256 = "sha256-wkrWmP5GeodM7wWaEkxT8JsUIc/jhRNHAP1gnLjZ7W4=";
   };
 
   nativeBuildInputs = [ unzip ];

pkgs/applications/misc/keepassxc/default.nix

···
     '';
     homepage = "https://keepassxc.org/";
     license = licenses.gpl2Plus;
-    maintainers = with maintainers; [ jonafato blankparticle ];
+    maintainers = with maintainers; [ blankparticle ];
     platforms = platforms.linux ++ platforms.darwin;
   };
 }

pkgs/applications/misc/notesnook/default.nix

···
 
 let
   pname = "notesnook";
-  version = "3.0.11";
+  version = "3.0.16";
 
   inherit (stdenv.hostPlatform) system;
   throwSystem = throw "Unsupported system: ${system}";
···
   src = fetchurl {
     url = "https://github.com/streetwriters/notesnook/releases/download/v${version}/notesnook_${suffix}";
     hash = {
-      x86_64-linux = "sha256-QnjfeN6CoLiyZvJY4mAZFJ58LxHhe/QUzpI4Fbz5Etg=";
-      x86_64-darwin = "sha256-uT4xo4LT70jq7bHmiYu4FL8Fldppc2ai8yEZzGMzM6Q=";
-      aarch64-darwin = "sha256-D5KIXHhzXXBOEcoOn2QKKUbVGMWhRW+L7fgxRxLpX/0=";
+      x86_64-linux = "sha256-HywWk3MAWdRVaQyimlQJCFsgydXdE0VSLWliZT7f8w0=";
+      x86_64-darwin = "sha256-GgZVVt1Gm95/kyI/q99fZ9BIN+5kpxumcSJ9BexfARc=";
+      aarch64-darwin = "sha256-ldg+bVROm/XzACCmiMapMQf3f6le9FHzt18QcaH8TxA=";
     }.${system} or throwSystem;
   };
 

pkgs/applications/misc/pdfsam-basic/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "pdfsam-basic";
-  version = "5.2.4";
+  version = "5.2.6";
 
   src = fetchurl {
     url = "https://github.com/torakiki/pdfsam/releases/download/v${version}/pdfsam_${version}-1_amd64.deb";
-    hash = "sha256-xtkp5OCxzLx0ZNeYlwLQWudzsILErlrAHacuq4hOL8E=";
+    hash = "sha256-u9ldHJkY3/VfykBFgVY8Ah/uYNpTIkLyvPY7zfLWN38=";
   };
 
   unpackPhase = ''

pkgs/applications/misc/terminal-parrot/default.nix

···
 
 buildGoModule rec {
   pname = "terminal-parrot";
-  version = "1.1.1";
+  version = "1.2.0";
 
   src = fetchFromGitHub {
     owner = "jmhobbs";
     repo = "terminal-parrot";
     rev = version;
-    hash = "sha256-Qhy5nCbuC9MmegXA48LFCDk4Lm1T5MBmcXfeHzTJm6w=";
+    hash = "sha256-LI67DDcK3M084r9JPx8NcBWthaiBOCEL4lQJhuUJSok=";
   };
 
-  vendorHash = "sha256-DJEoJjItusN1LTOOX1Ep+frF03yF/QmB/L66gSG0VOE=";
+  vendorHash = "sha256-EhnmOpT+rx4RVpmqgEQ4qO+Uca1W9uhx4fcExXG9LOI=";
 
   doCheck = false;
 

pkgs/applications/networking/browsers/polypane/default.nix

···
 
 let
   pname = "polypane";
-  version = "20.1.2";
+  version = "21.1.0";
 
   src = fetchurl {
     url = "https://github.com/firstversionist/${pname}/releases/download/v${version}/${pname}-${version}.AppImage";
     name = "${pname}-${version}.AppImage";
-    sha256 = "sha256-rdbx0ffI8MDGXArniFnqTpuLLMlihtXXQiZnxw5vq+c=";
+    sha256 = "sha256-MVBxKJeqIFAkSOajo1q/062BGBF6Fm2sUA6GYZIBoKQ=";
   };
 
   appimageContents = appimageTools.extractType2 {

pkgs/applications/networking/cluster/cloudfoundry-cli/default.nix

···
 
 buildGoModule rec {
   pname = "cloudfoundry-cli";
-  version = "8.7.11";
+  version = "8.8.0";
 
   src = fetchFromGitHub {
     owner = "cloudfoundry";
     repo = "cli";
     rev = "v${version}";
-    sha256 = "sha256-7FYIJf9vNHK9u8r7HVpPtGGWwRA5cdrB9f1Vz1iTFjI=";
+    sha256 = "sha256-H969ZL+b62YidZ14TfGmwBVjSF/JRu64nOMUtIdFWKc=";
   };
-  vendorHash = "sha256-9SpmMXmocwaZH4fqqETzmRP6wvI2NV/LL6M0Ld4lvso=";
+  vendorHash = "sha256-2vUS7oENbUENaEnSzJ4gfQr3lKZ3jKH4QAO9KP0rQGs=";
 
   subPackages = [ "." ];
 

pkgs/applications/networking/cluster/istioctl/default.nix

···
 
 buildGoModule rec {
   pname = "istioctl";
-  version = "1.22.3";
+  version = "1.22.4";
 
   src = fetchFromGitHub {
     owner = "istio";
     repo = "istio";
     rev = version;
-    hash = "sha256-rtvuGIcjarIc4PmBXM3s/XbMQp/wlU1FhHb1lmXE2go=";
+    hash = "sha256-yot7HSKM5unfKsBdFAgm1nx/pr3jYnVEJ6Phq4MicZw=";
   };
-  vendorHash = "sha256-0F4GIOT/YUzLLhD9HzNJpGSgfMALiEPAb4vtmLmI+Qs=";
+  vendorHash = "sha256-PrbYJ+Pz6Z1PO+dOuIV/9Y/1ipr0mFrfcFFmnMaHcTM=";
 
   nativeBuildInputs = [ installShellFiles ];
 

pkgs/applications/networking/cluster/kubebuilder/default.nix

···
 
 buildGoModule rec {
   pname = "kubebuilder";
-  version = "4.1.1";
+  version = "4.2.0";
 
   src = fetchFromGitHub {
     owner = "kubernetes-sigs";
     repo = "kubebuilder";
     rev = "v${version}";
-    hash = "sha256-1/X8HuhzizrkiOyCZ7F6rq6G33oqVaf4uW9Sr94ogL8=";
+    hash = "sha256-iWu3HnfjT9hiDyl9Ni0xJa/e+E9fbh3bnfrdE1ChaWc=";
   };
 
-  vendorHash = "sha256-2b/c6t9RkHbBe894DPOETLMf4MpsTjXMtEoVG4FMo24=";
+  vendorHash = "sha256-dMzDKYjPBAiNFwzaBML76tMylHtBs9Tb2Ulj/WovVJ4=";
 
   subPackages = ["cmd"];
 

pkgs/applications/networking/cluster/kubeshark/default.nix

···
 
 buildGoModule rec {
   pname = "kubeshark";
-  version = "52.3.78";
+  version = "52.3.79";
 
   src = fetchFromGitHub {
     owner = "kubeshark";
     repo = "kubeshark";
     rev = "v${version}";
-    hash = "sha256-tv0yBm10bUCepa03GUQlok6cP0bIuG7sgunX8iAUjO4=";
+    hash = "sha256-FpuBb/DoZXdQ/xCMC1dgVslYxLzowjv9ULktNKCIBjw=";
   };
 
-  vendorHash = "sha256-b3Aq3970E19jOJPjw/e0ly1W9x9HiDN+bfuB4uP09BY=";
+  vendorHash = "sha256-fjkuDX6SC23An0zZW0ocoFJ/K6JKsyVUQdxzfHCUFJs=";
 
   ldflags = let t = "github.com/kubeshark/kubeshark"; in [
    "-s" "-w"

pkgs/applications/networking/instant-messengers/alfaview/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "alfaview";
-  version = "9.13.0";
+  version = "9.14.0";
 
   src = fetchurl {
     url = "https://assets.alfaview.com/stable/linux/deb/${pname}_${version}.deb";
-    hash = "sha256-ENd3ozRi47vszgHZIX63nQu7wZz6Zf4HdmCsNvkcLOo=";
+    hash = "sha256-YBC6zjcxSnOOY3RSo0X1ixTY1to2vEEkj1/9rItLzNA=";
   };
 
   nativeBuildInputs = [

pkgs/applications/networking/instant-messengers/rocketchat-desktop/default.nix

···
 in
 stdenv.mkDerivation rec {
   pname = "rocketchat-desktop";
-  version = "4.0.1";
+  version = "4.0.2";
 
   src = fetchurl {
     url = "https://github.com/RocketChat/Rocket.Chat.Electron/releases/download/${version}/rocketchat-${version}-linux-amd64.deb";
-    hash = "sha256-GWU2qGeQB8bou0+Ja6Cs4bQM1stAL+dlKC3QNTA0EIY=";
+    hash = "sha256-E2bIFv0oO9mZ90iTHdB3jczr+FEJBCV5r1ucsd6ulGE=";
   };
 
   nativeBuildInputs = [

pkgs/applications/networking/instant-messengers/session-desktop/default.nix

···
 }:
 
 let
-  version = "1.12.5";
+  version = "1.13.2";
   pname = "session-desktop";
 
   src = fetchurl {
     url = "https://github.com/oxen-io/session-desktop/releases/download/v${version}/session-desktop-linux-x86_64-${version}.AppImage";
-    hash = "sha256-5lE2jab9AK40j2rKYE8zFJr3a+drwCKnVmIZoihhJv8=";
+    hash = "sha256-71v6CvlKa4m1LPG07eGhPqkpK60X4VrafCQyfjQR3rs=";
   };
   appimage = appimageTools.wrapType2 { inherit version pname src; };
   appimage-contents = appimageTools.extractType2 { inherit version pname src; };
···
     mainProgram = "session-desktop";
     homepage = "https://getsession.org/";
     license = licenses.gpl3Only;
-    maintainers = with maintainers; [ alexnortung ];
+    maintainers = with maintainers; [
+      alexnortung
+      cyewashish
+    ];
     platforms = [ "x86_64-linux" ];
     sourceProvenance = with sourceTypes; [ binaryNativeCode ];
   };

pkgs/applications/networking/instant-messengers/signal-cli/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "signal-cli";
-  version = "0.13.5";
+  version = "0.13.6";
 
   # Building from source would be preferred, but is much more involved.
   src = fetchurl {
     url = "https://github.com/AsamK/signal-cli/releases/download/v${version}/signal-cli-${version}.tar.gz";
-    hash = "sha256-MWQz/+eusZpXUlpPemLf8Y2nOsh2lv0+Ilf/w+7na+k=";
+    hash = "sha256-OTKXLcLktWiSdRhGe7ioL2ViJQQcCjR1+2LlGoMnSgE=";
   };
 
   buildInputs = lib.optionals stdenv.isLinux [ libmatthew_java dbus dbus_java ];

pkgs/applications/networking/instant-messengers/zulip/default.nix

···
     description = "Desktop client for Zulip Chat";
     homepage = "https://zulip.com";
     license = licenses.asl20;
-    maintainers = with maintainers; [ andersk jonafato ];
+    maintainers = with maintainers; [ andersk ];
     platforms = [ "x86_64-linux" ];
     mainProgram = "zulip";
   };

pkgs/applications/networking/iroh/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "iroh";
-  version = "0.23.0";
+  version = "0.24.0";
 
   src = fetchFromGitHub {
     owner = "n0-computer";
     repo = pname;
     rev = "v${version}";
-    hash = "sha256-kXKA0gDmxruoHLTB9zJ36ydqqwaeyQm/Icqgv6API0k=";
+    hash = "sha256-ZHBgsR17U0hWnRZ79S1/TXoOATofvlf3UloHQh1p8Oo=";
   };
 
-  cargoHash = "sha256-XUokfLMXIYfiN4A2/aYYhq0N7H2vsZL1uvKg498M3yA=";
+  cargoHash = "sha256-j/Trm6Y64cOxBdHfP172E+YiORZ8B9ukJOpzrLTGI7k=";
 
   buildInputs = lib.optionals stdenv.isDarwin (
     with darwin.apple_sdk.frameworks; [

pkgs/applications/networking/mailreaders/tutanota-desktop/default.nix

···
 
 appimageTools.wrapType2 rec {
   pname = "tutanota-desktop";
-  version = "235.240712.0";
+  version = "235.240718.0";
 
   src = fetchurl {
     url = "https://github.com/tutao/tutanota/releases/download/tutanota-desktop-release-${version}/tutanota-desktop-linux.AppImage";
-    hash = "sha256-IhGfpHzK853b21oqhlfvXVrS1gl/4xgrZeWvBCIL1qg=";
+    hash = "sha256-Pycz05cwse2SUvJlaCXMA1/Trdt6ZGOJK3NRSPb6/VM=";
   };
 
   extraPkgs = pkgs: [ pkgs.libsecret ];

pkgs/applications/networking/synology-drive-client/default.nix

···
 let
   pname = "synology-drive-client";
   baseUrl = "https://global.synologydownload.com/download/Utility/SynologyDriveClient";
-  version = "3.5.0-16084";
+  version = "3.5.1-16101";
   buildNumber = lib.last (lib.splitString "-" version);
   meta = with lib; {
     description = "Desktop application to synchronize files and folders between the computer and the Synology Drive server";
···
 
     src = fetchurl {
       url = "${baseUrl}/${version}/Ubuntu/Installer/synology-drive-client-${buildNumber}.x86_64.deb";
-      sha256 = "sha256-Spl6DC+wf+JaXjwH2ecraySo1VtA+EiI3/TWw9UOSA8=";
+      sha256 = "sha256-VeS5bPcMM4JDCSH5GXkl4OgQjrPKaNDh5PfX28/zqaU=";
     };
 
     nativeBuildInputs = [ autoPatchelfHook dpkg ];
···
 
     src = fetchurl {
       url = "${baseUrl}/${version}/Mac/Installer/synology-drive-client-${buildNumber}.dmg";
-      sha256 = "sha256-NDYxUhWtAVUtpCf1WemqShZCFHGgLGwrkX6HldxOlH0=";
+      sha256 = "sha256-VyhROpQCeVHNxxYgPUZdAlng15aJ1/IYadz30FThlsw=";
     };
 
     nativeBuildInputs = [ cpio xar undmg ];

pkgs/applications/science/biology/iqtree/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "iqtree";
-  version = "2.3.5";
+  version = "2.3.6";
 
   src = fetchFromGitHub {
     owner = "iqtree";
     repo = "iqtree2";
     rev = "v${version}";
-    hash = "sha256-ld+9vPJRVHMEe5/igqRr6RkISY2ipfGkJFHDOSZuAmg=";
+    hash = "sha256-8d5zqZIevv3bnq7z7Iyo/x8i445y1RAFtRMeK8s/ieQ=";
     fetchSubmodules = true;
   };
 

pkgs/applications/science/electronics/digital/default.nix

···
 let
   pname = "digital";
   pkgDescription = "A digital logic designer and circuit simulator.";
-  version = "0.30";
-  buildDate = "2023-02-03T08:00:56+01:00"; # v0.30 commit date
+  version = "0.31";
+  buildDate = "2024-09-03T14:02:31+02:00"; # v0.31 commit date
 
   desktopItem = makeDesktopItem {
     type = "Application";
···
     owner = "hneemann";
     repo = "Digital";
     rev = "v${version}";
-    hash = "sha256-cDykYlcFvDLFBy9UnX07iCR2LCq28SNU+h9vRT/AoJM=";
+    hash = "sha256-6XaM3U1x/yvoCrkJ2nMtBmj972gCFlWn3F4DM7TLWgw=";
   };
 
   inherit mvnParameters;
···
     description = pkgDescription;
     mainProgram = "digital";
     license = licenses.gpl3Only;
-    platforms = [ "x86_64-linux" "x86_64-darwin" ];
+    platforms = platforms.all;
     maintainers = with maintainers; [ Dettorer ];
   };
 }

pkgs/applications/science/electronics/kicad/versions.nix

···
 {
   "kicad" = {
     kicadVersion = {
-      version =			"8.0.4";
+      version =			"8.0.5";
       src = {
-        rev =			"5609722002776982320b6a8fbe6d096bbccf469b";
-        sha256 =		"03971przr1kzmkr302qzx30mmp92mkwg29dwjvzayc522iskxcbx";
+        rev =			"1413b8bfab256aa09ae3f23027b9ffe278161ca6";
+        sha256 =		"1g0w3g1gq6p72gg0jikdrh5mczcv5y16jmqi79bkp6nfl8gbx4l5";
       };
     };
     libVersion = {
-      version =			"8.0.4";
+      version =			"8.0.5";
       libSources = {
-        symbols.rev =		"967a2828636d21f90ccc28dcfdc0e48508101c9d";
-        symbols.sha256 =	"1s8mkxb3ncb0w8z5q8jzhryb0yri7g51vx29qykqwv4ksra1f07i";
-        templates.rev =		"9c51a73b2e2fc4ea75d8b8be0a78bc9fb1785433";
+        symbols.rev =		"3bd95a02b135941ba00e5e4671e7c3ebc7672db4";
+        symbols.sha256 =	"12v8g48fgbalp0xrlgn3vm3ld79ymmwccv5aib6jz2qycdjxmznf";
+        templates.rev =		"4644b7570ba73dfe03a06a674c98d3fe2a7fe1e4";
         templates.sha256 =	"03idwrk3vj9h2az8j8lqpbdbnfxdbkzh4db68kq3644yj3cnlcza";
-        footprints.rev =	"a2aa9b5aea64c0efad9a31bc9ca88d48c0203752";
-        footprints.sha256 =	"1aqdb7mamz8xzz1qrw3qnvnaj97asb8z37w1cjz6y06sjcznlihn";
-        packages3d.rev =	"5430edd57b3a66fe69288aa8fda714f9732a7f52";
-        packages3d.sha256 =	"0vixdcldvnl8lr8bq3rc748q3vhx1lr2a0i071w914xyn983z9vz";
+        footprints.rev =	"4d2be8bf917b9c31f0510fa953532b88ef8b8be8";
+        footprints.sha256 =	"0ixfiraahi09gvszzxsdz21mdr9wsxyby5qp3n57pzid42gs35a1";
+        packages3d.rev =	"2f3ea516116cc553c9d488424fbb196f4e65ef29";
+        packages3d.sha256 =	"03yicqv36zx0wrb0njpkk45l4ysvv3dlsjlpi4j8j75gla060mai";
       };
     };
   };

pkgs/applications/science/misc/snakemake/default.nix

···
 { lib
-, fetchFromGitHub
+, fetchPypi
+, fetchpatch
 , python3
 , runtimeShell
+, stress
 }:
 
 python3.pkgs.buildPythonApplication rec {
   pname = "snakemake";
-  version = "8.14.0";
+  version = "8.20.1";
   format = "setuptools";
 
-  src = fetchFromGitHub {
-    owner = "snakemake";
-    repo = pname;
-    rev = "refs/tags/v${version}";
-    hash = "sha256-6oguN4u4OUDXpDsbueSBNwtWgLCaKmgq3w/d/MsMh7Y=";
-    # https://github.com/python-versioneer/python-versioneer/issues/217
-    postFetch = ''
-      sed -i "$out"/snakemake/_version.py -e 's#git_refnames = ".*"#git_refnames = " (tag: v${version})"#'
-    '';
+  src = fetchPypi {
+    inherit pname version;
+    hash = "sha256-adNwIA1z/TwWsa0gQb4hAsUvHInjd30sm1dYKXvvXy8=";
   };
 
   postPatch = ''
     patchShebangs --build tests/
-    patchShebangs --host snakemake/executors/jobscript.sh
-    substituteInPlace snakemake/shell.py \
-      --replace "/bin/sh" "${runtimeShell}"
+    substituteInPlace tests/common.py \
+      --replace-fail 'os.environ["PYTHONPATH"] = os.getcwd()' "pass" \
+      --replace-fail 'del os.environ["PYTHONPATH"]' "pass"
+    substituteInPlace snakemake/unit_tests/__init__.py \
+      --replace-fail '"unit_tests/templates"' '"'"$PWD"'/snakemake/unit_tests/templates"'
   '';
 
   propagatedBuildInputs = with python3.pkgs; [
···
     nbformat
     psutil
     pulp
+    pygments
     pyyaml
     requests
     reretry
···
     numpy
     pandas
     pytestCheckHook
+    pytest-mock
     requests-mock
     snakemake-executor-plugin-cluster-generic
+    snakemake-storage-plugin-fs
+    stress
   ];
 
-  disabledTestPaths = [
-    "tests/test_conda_python_3_7_script/test_script.py"
+  pytestFlagsArray = [
+    "tests/tests.py"
+    "tests/test_expand.py"
+    "tests/test_io.py"
+    "tests/test_schema.py"
+    "tests/test_executor_test_suite.py"
+    "tests/test_api.py"
   ];
 
+  # Some will be disabled via https://github.com/snakemake/snakemake/pull/3074
   disabledTests = [
+    # requires graphviz
+    "test_filegraph"
+    # requires s3
+    "test_storage"
+    "test_default_storage"
+    "test_output_file_cache_storage"
+    # requires peppy and eido
+    "test_pep"
+    "test_modules_peppy"
+    # requires perl
+    "test_shadow"
+    # requires snakemake-storage-plugin-http
+    "test_ancient"
+    "test_modules_prefix"
+    # requires snakemake-storage-plugin-s3
     "test_deploy_sources"
+    # requires modules
+    "test_env_modules"
+    # issue with locating template file
+    "test_generate_unit_tests"
+    # weird
+    "test_strict_mode"
+    "test_issue1256"
+    "test_issue2574"
+    "test_github_issue1384"
+    # future-proofing
+    "conda"
+    "singularity"
+    "apptainer"
+    "container"
   ];
 
   pythonImportsCheck = [

pkgs/applications/version-management/gh/default.nix

···
 
 buildGoModule rec {
   pname = "gh";
-  version = "2.55.0";
+  version = "2.56.0";
 
   src = fetchFromGitHub {
     owner = "cli";
     repo = "cli";
     rev = "v${version}";
-    hash = "sha256-Ty74t+FwyRHed4V/OoJkq/4It5KpLLa4Xxti+93rjCs=";
+    hash = "sha256-PDw2u+2hMiPmQe1lnJXnZk8JVsti/j7Nq5Uv3b7RIk4=";
   };
 
-  vendorHash = "sha256-K4KKgfjbopYEMJZCDt2x9l6EO7MwVBZ2HrdzvF/oetw=";
+  vendorHash = "sha256-rMJWUm79/wBBdVvNdIQc7jqzxfDXphBvGYU3wD/BITk=";
 
   nativeBuildInputs = [ installShellFiles ];
 

pkgs/applications/version-management/git-branchless/default.nix

···
     "--skip=test_switch_pty"
     "--skip=test_next_ambiguous_interactive"
     "--skip=test_switch_auto_switch_interactive"
-    "--skip=test_amend_undo"
-    "--skip=test_switch_pty"
-    "--skip=test_next_ambiguous_interactive"
-    "--skip=test_switch_auto_switch_interactive"
-    "--skip=test_move_branch_on_merge_conflict_resolution"
-    "--skip=test_move_branches_after_move"
-    "--skip=test_move_delete_checked_out_branch"
-    "--skip=test_move_no_reapply_squashed_commits"
-    "--skip=test_move_orphaned_root"
-    "--skip=test_restore_snapshot_basic"
-    "--skip=test_restore_snapshot_delete_file_only_in_index"
-    "--skip=test_restore_snapshot_deleted_files"
-    "--skip=test_sync_basic"
-    "--skip=test_sync_no_delete_main_branch"
-    "--skip=test_undo_doesnt_make_working_dir_dirty"
-    "--skip=test_undo_move_refs"
-    "--skip=test_undo_noninteractive"
   ];
 
   meta = with lib; {

pkgs/applications/version-management/git-mit/default.nix

···
 }:
 
 let
-  version = "5.13.28";
+  version = "5.13.29";
 in
 rustPlatform.buildRustPackage {
   pname = "git-mit";
···
     owner = "PurpleBooth";
     repo = "git-mit";
     rev = "v${version}";
-    hash = "sha256-zw1yY/vCrxklmIXGHO5cMOQ9L3xfHD24f2JN7ibF/I8=";
+    hash = "sha256-8XUpUpsd2q/1N28ZAPt7rW0pJu0WzE6oVSOwdJxhSBk=";
   };
 
-  cargoHash = "sha256-pnSp6XCVSxCY7b1LHeQM9/KsjG6sGQoMCPcL8Bby4A4=";
+  cargoHash = "sha256-KtdbYzXHpdg0Rf4ENrWpP0+vG3+HlLVi7MLeXp9HoVw=";
 
   nativeBuildInputs = [ pkg-config ];
 

pkgs/applications/version-management/ungit/default.nix

···
 
 buildNpmPackage rec {
   pname = "ungit";
-  version = "1.5.26";
+  version = "1.5.27";
 
   src = fetchFromGitHub {
     owner = "FredrikNoren";
     repo = "ungit";
     rev = "v${version}";
-    hash = "sha256-HTo0z/y7thUrDm6ofHiUtv1UDuqGN+kpMFLuIvxyxZQ=";
+    hash = "sha256-UYY8AJWeGAcb83bmr7KX8ocxz8oQqUaXEXwwoVlwvoc=";
   };
 
-  npmDepsHash = "sha256-f/CtNYoy5ZOgdVTG2ZdBpXOSNUKSG5wCy0eIl4ov80U=";
+  npmDepsHash = "sha256-AE0V+IoO9Yz80y81ayR08us4gyjjvshRVYPq6thpMr8=";
 
   env = {
     ELECTRON_SKIP_BINARY_DOWNLOAD = true;

pkgs/applications/virtualization/ddev/default.nix

···
 
 buildGoModule rec {
   pname = "ddev";
-  version = "1.23.3";
+  version = "1.23.4";
 
   src = fetchFromGitHub {
     owner = "ddev";
     repo = "ddev";
     rev = "v${version}";
-    hash = "sha256-+DQEXJcW0nKBvw+pWZnFJfO/7R9IjbhAl9WZvorO9Io=";
+    hash = "sha256-+Ou9YbFwUVu6AqR041ngnVb9TpiO1UMph2w1zsbEMEM=";
   };
 
   vendorHash = null;

pkgs/applications/virtualization/ecs-agent/default.nix

···
 
 buildGoModule rec {
   pname = "amazon-ecs-agent";
-  version = "1.85.1";
+  version = "1.86.3";
 
   src = fetchFromGitHub {
     rev = "v${version}";
     owner = "aws";
     repo = pname;
-    hash = "sha256-TrfFJ6N1DreO3NcznXBcNZziESAMxWa4FR+KzDjRDmM=";
+    hash = "sha256-YygvAYoqbWVmtBgHNrP0Xp1zSgCv2PsnWARWyo3K8rM=";
   };
 
   vendorHash = null;

pkgs/by-name/an/ansel/package.nix

···
 in
 stdenv.mkDerivation {
   pname = "ansel";
-  version = "0-unstable-2024-07-09";
+  version = "0-unstable-2024-08-13";
 
   src = fetchFromGitHub {
     owner = "aurelienpierreeng";
     repo = "ansel";
-    rev = "55761cfc7a6aacdc483dadacbf3fadcd89108e27";
-    hash = "sha256-5L/d5R2qQ/GFrJcDPKdqhhMQwEg050CmmDh3BLmETRQ=";
+    rev = "85f2b8b15fe2081634c6f2c3f96b5d430e045bf0";
+    hash = "sha256-w2DziVBoCy1NpH4AoIFmKdjqufopqUeYjAwqkOhxHBc=";
     fetchSubmodules = true;
   };
 

pkgs/by-name/as/asfa/package.nix

···
   installShellFiles,
 }:
 let
-  version = "0.10.0";
+  version = "0.10.0-1";
   src = fetchFromGitHub {
     owner = "obreitwi";
     repo = "asfa";
     rev = "v${version}";
-    hash = "sha256-MnhnwtZmPFhOuiqNiaxJnPu88JOdlpvyVy0YGphblBc=";
+    hash = "sha256-ARdUlACxmbjmOTuNW2oiVUcfd5agR4rcp9aMQYUAYsw=";
   };
 in
 rustPlatform.buildRustPackage {
   pname = "asfa";
   inherit version src;
 
-  cargoHash = "sha256-/bRBP/NzcNOXl/nANeOYouUAo3NNbtbV9fxIJrNajYQ=";
+  cargoHash = "sha256-pzCTqVUo3LEpR3hmTPKDwvgtUJZ+tsArbi0HDlY2Cy8=";
 
   outputs = [
     "out"

pkgs/by-name/be/bevelbar/package.nix

···
 
 stdenv.mkDerivation (finalAttrs: {
   pname = "bevelbar";
-  version = "24.06";
+  version = "24.07";
 
   src = fetchurl {
     url = "https://www.uninformativ.de/git/bevelbar/archives/bevelbar-v${finalAttrs.version}.tar.gz";
-    hash = "sha256-A7nrpMty4uxbiLzW83cmxlhQh8et1qo/n0mwBXNLJOc=";
+    hash = "sha256-PUYgbJCII0JecetoY3dMBUgrtaVhlLKeaJY27JJ78RQ=";
   };
 
   nativeBuildInputs = [ pkg-config ];

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

···
 
 buildDotnetModule rec {
   pname = "Boogie";
-  version = "3.2.3";
+  version = "3.2.4";
 
   src = fetchFromGitHub {
     owner = "boogie-org";
     repo = "boogie";
     rev = "v${version}";
-    sha256 = "sha256-dMJ6A2ggBb20vuHL1g/Zx3pl9tXE8oayMGOqpChcg2U=";
+    sha256 = "sha256-wpMENrhfD8+bt66gd29xkfLANcMbPpkzDacj0KPuXT4=";
   };
 
   projectFile = [ "Source/Boogie.sln" ];

pkgs/by-name/ch/chawan/package.nix

···
 
 stdenv.mkDerivation {
   pname = "chawan";
-  version = "0-unstable-2024-08-03";
+  version = "0-unstable-2024-09-03";
 
   src = fetchFromSourcehut {
     owner = "~bptato";
     repo = "chawan";
-    rev = "4c64687290c908cd791a058dede9bd4f2a1c7757";
-    hash = "sha256-o0GMRNl5GiW0cJdaQYsL2JVp0CPs5VxQF8s0XEh/f7o=";
+    rev = "298684d174be90be57967f15c2f1bf0d24ba2446";
+    hash = "sha256-R/+qLoyewqoOfi264GvZUvpZbN5FX8LtGikQ3FxJEvw=";
     fetchSubmodules = true;
   };
 

pkgs/by-name/cl/clash-nyanpasu/package.nix

···
 }:
 appimageTools.wrapType2 rec {
   pname = "clash-nyanpasu";
-  version = "1.5.1";
+  version = "1.6.0";
 
   src = fetchurl {
     url = "https://github.com/LibNyanpasu/clash-nyanpasu/releases/download/v${version}/clash-nyanpasu_${version}_amd64.AppImage";
-    hash = "sha256-uUWs7yfSrqe/6kTb4iMA9ty6j/Wi9qGYX65VzTG5nkc=";
+    hash = "sha256-Xl6FRwYDXztirDZEr8Xn13BNZBW54TdwsK8H0rnLEgU=";
   };
 
   extraInstallCommands =

pkgs/by-name/de/deltachat-desktop/package.nix

···
 in
 buildNpmPackage rec {
   pname = "deltachat-desktop";
-  version = "1.46.7";
+  version = "1.46.8";
 
   src = fetchFromGitHub {
     owner = "deltachat";
     repo = "deltachat-desktop";
     rev = "v${version}";
-    hash = "sha256-gsgw075YitYgx5WkNdPnh96w58FJaa2r8wOJyUsSAu0=";
+    hash = "sha256-17JhaanYEySoDuLYFMc4vB3wVlCucMh3Jk2Uu9PqUdQ=";
   };
 
-  npmDepsHash = "sha256-Va/Aber3uwTFTy/XnYILkU3s66/xQAvGDFh2p/ZYYUo=";
+  npmDepsHash = "sha256-+74koym1lL2rk5n06i7JgcXmX+yW4zgqRfdH6ryXe0s=";
 
   nativeBuildInputs = [
     jq

pkgs/by-name/de/departure-mono/package.nix

···
 
 stdenvNoCC.mkDerivation (finalAttrs: {
   pname = "departure-mono";
-  version = "1.346";
+  version = "1.350";
 
   src = fetchzip {
-    url = "https://departuremono.com/assets/DepartureMono-${finalAttrs.version}.zip";
+    url = "https://github.com/rektdeckard/departure-mono/releases/download/v${finalAttrs.version}/DepartureMono-${finalAttrs.version}.zip";
     stripRoot = false;
-    hash = "sha256-xJVVtLnukcWQKVC3QiHvrfIA3W9EYt/iiphbLYT1iMg=";
+    hash = "sha256-MMmS1yjhy50fgMK5h0526YKRfQJuOcEAHqxn9rhUwCc=";
   };
 
   installPhase = ''
···
   '';
 
   meta = {
+    changelog = "https://github.com/rektdeckard/departure-mono/releases/tag/v${finalAttrs.version}";
     description = "Departure Mono is a monospaced pixel font with a lo-fi technical vibe";
     homepage = "https://departuremono.com/";
     license = lib.licenses.ofl;

pkgs/by-name/di/discover-overlay/package.nix

···
 { lib, python3, fetchFromGitHub, gtk3, gobject-introspection, gtk-layer-shell, wrapGAppsHook3 }:
 python3.pkgs.buildPythonApplication rec {
   pname = "discover-overlay";
-  version = "0.7.4";
+  version = "0.7.8";
   pyproject = true;
 
   src = fetchFromGitHub {
     owner = "trigg";
     repo = "Discover";
     rev = "refs/tags/v${version}";
-    hash = "sha256-qA+gvgKQlTjcm0JPUmJp47Ttvm+69CW4lOngnueLVpo=";
+    hash = "sha256-0b0uZDa9Q3pQ6X65C+E31dMpdTPt4vvHDEqFEtRoedg=";
   };
 
   buildInputs = [ gtk3 gtk-layer-shell ];

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

···
 }:
 appimageTools.wrapType2 rec {
   pname = "dopamine";
-  version = "3.0.0-preview.31";
+  version = "3.0.0-preview.32";
 
   src = fetchurl {
     url = "https://github.com/digimezzo/dopamine/releases/download/v${version}/Dopamine-${version}.AppImage";
-    hash = "sha256-NWDk4OOaven1FgSkvKCNY078xkwR+Tp4kUASh/rIbzo=";
+    hash = "sha256-1gn/oD9UL6+xjEwQIAhvJjHJybI0tY2We3QF1biHDgg=";
   };
 
   extraInstallCommands =

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

···
 
 rustPlatform.buildRustPackage rec {
   pname = "dumbpipe";
-  version = "0.13.0";
+  version = "0.16.0";
 
   src = fetchFromGitHub {
     owner = "n0-computer";
     repo = pname;
     rev = "v${version}";
-    hash = "sha256-n/gmkOtCO07paWLKHSNtoTRCgdynMi5cG6johjsuDbU=";
+    hash = "sha256-gv6V5I9LPNfXyuopo8BaYRELxzTfNhTG1EBWoZ/4cpc=";
   };
 
-  cargoHash = "sha256-YfieNhhqvW8nU6GZFgWa0oBuCfUSr2AhxpFOFusIYCY=";
+  cargoHash = "sha256-t6w2XrMSm5g6dmYQ5gX+w8M3pPzWDytGY9uSuXYgnDA=";
 
   buildInputs = lib.optionals stdenv.isDarwin (
     with darwin.apple_sdk.frameworks; [

pkgs/by-name/ho/home-manager/package.nix

···
 
 stdenvNoCC.mkDerivation (finalAttrs: {
   pname = "home-manager";
-  version = "0-unstable-2024-08-23";
+  version = "0-unstable-2024-09-09";
 
   src = fetchFromGitHub {
     name = "home-manager-source";
     owner = "nix-community";
     repo = "home-manager";
-    rev = "c2cd2a52e02f1dfa1c88f95abeb89298d46023be";
-    hash = "sha256-UNky3lJNGQtUEXT2OY8gMxejakSWPTfWKvpFkpFlAfM=";
+    rev = "10541f19c584fe9633c921903d8c095d5411e041";
+    hash = "sha256-fj2LxTZAncL/s5NrtXe1nLfO0XDvRixtCu3kmV9jDPw=";
   };
 
   nativeBuildInputs = [

pkgs/by-name/ht/httm/package.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "httm";
-  version = "0.42.0";
+  version = "0.42.4";
 
   src = fetchFromGitHub {
     owner = "kimono-koans";
     repo = pname;
     rev = version;
-    hash = "sha256-2NvTo+EDw7GcDbND7epHWnHehcVBo11QyuZ0PoJf7Nc=";
+    hash = "sha256-NX4cDq9bByfpGiXmLCwE97W2KLIXyPczbBNRRkSGTqs=";
   };
 
-  cargoHash = "sha256-YSpYg10IeuqUAmjIQzrA59IT7r86/q8DtEKnazjo9rQ=";
+  cargoHash = "sha256-kIpzwQhhCt5V2ZueYZNirv+QOLXDtHtoYjrD3FI7DQU=";
 
   nativeBuildInputs = [ installShellFiles ];
 

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

···
 
   configureFlags = [ "--with-docbook-xsl=${docbook_xsl}/xml/xsl/docbook" ];
 
-  env.NIX_CFLAGS_COMPILE = "-pthread";
-
-  OPENLDAP_ROOT = openldap;
+  env = {
+    NIX_CFLAGS_COMPILE = "-pthread";
+    OPENLDAP_ROOT = openldap;
+  };
 
   shellHook = ''
     PATH=$(pwd)/src/script:$(pwd)/src/hydra-eval-jobs:$(pwd)/src/hydra-queue-runner:$(pwd)/src/hydra-evaluator:$PATH

pkgs/by-name/ig/igir/package.nix

···
 
 buildNpmPackage rec {
   pname = "igir";
-  version = "2.9.2";
+  version = "2.11.0";
 
   src = fetchFromGitHub {
     owner = "emmercm";
     repo = "igir";
     rev = "v${version}";
-    hash = "sha256-3lEU3uK/Wp09TOhVJVNslOCx9vTVp0gBTbkQXB13i9Y=";
+    hash = "sha256-NG0ZP8LOm7fZVecErTuLOfbp1yvXwHnwPkWTBzUJXWE=";
   };
 
-  npmDepsHash = "sha256-gJvJwostQgEq14zDmMOatfWmkEYNAqGCL9MJPrv5kwk=";
+  npmDepsHash = "sha256-ADIEzr6PkGaJz27GKSVyTsrbz5zbud7BUb+OXPtP1Vo=";
 
   # I have no clue why I have to do this
   postPatch = ''

pkgs/by-name/ir/irpf/package.nix

···
 
 stdenvNoCC.mkDerivation (finalAttrs: {
   pname = "irpf";
-  version = "2024-1.3";
+  version = "2024-1.4";
 
   # https://www.gov.br/receitafederal/pt-br/centrais-de-conteudo/download/pgd/dirpf
   # Para outros sistemas operacionais -> Multi
···
     year = lib.head (lib.splitVersion finalAttrs.version);
   in fetchzip {
     url = "https://downloadirpf.receita.fazenda.gov.br/irpf/${year}/irpf/arquivos/IRPF${finalAttrs.version}.zip";
-    hash = "sha256-UMzoQSSlmOi7TIqPF0vfeelum5JSa6ne4c7ZFREuDr8=";
+    hash = "sha256-223PZyGlLSK5GzR143IlGzhmJlXmvtBdscC2roPiQhc=";
   };
 
   passthru.updateScript = writeScript "update-irpf" ''

pkgs/by-name/ja/jan/package.nix

···
 
 let
   pname = "jan";
-  version = "0.5.1";
+  version = "0.5.3";
   src = fetchurl {
     url = "https://github.com/janhq/jan/releases/download/v${version}/jan-linux-x86_64-${version}.AppImage";
-    hash = "sha256-6AbV7rly4dLNX5xMKxitt5kli3xs5Hx0Vy+/HPsyEPc=";
+    hash = "sha256-lfN5ant3oS7uschxyCxmiKNLJUJiqWVZLaJ8djqNKzQ=";
   };
 
   appimageContents = appimageTools.extractType2 { inherit pname version src; };

pkgs/by-name/ko/kokkos/package.nix

···
 
 stdenv.mkDerivation (finalAttrs: {
   pname = "kokkos";
-  version = "4.3.01";
+  version = "4.4.00";
 
   src = fetchFromGitHub {
     owner = "kokkos";
     repo = "kokkos";
     rev = finalAttrs.version;
-    hash = "sha256-x496DKEBMNUUZ2rBNT2MPBV8Obi5aUKQuHwjLiNPMhk=";
+    hash = "sha256-cEHGFmnYp5tPQ9BzRKopS78kAEBH+nNMRGJuWmpoHc0=";
   };
 
   nativeBuildInputs = [

pkgs/by-name/li/libdeltachat/Cargo.lock

···
 
 [[package]]
 name = "deltachat"
-version = "1.142.11"
+version = "1.142.12"
 dependencies = [
  "ansi_term",
  "anyhow",
···
 
 [[package]]
 name = "deltachat-jsonrpc"
-version = "1.142.11"
+version = "1.142.12"
 dependencies = [
  "anyhow",
  "async-channel 2.3.1",
···
 
 [[package]]
 name = "deltachat-repl"
-version = "1.142.11"
+version = "1.142.12"
 dependencies = [
  "ansi_term",
  "anyhow",
···
 
 [[package]]
 name = "deltachat-rpc-server"
-version = "1.142.11"
+version = "1.142.12"
 dependencies = [
  "anyhow",
  "deltachat",
···
 
 [[package]]
 name = "deltachat_ffi"
-version = "1.142.11"
+version = "1.142.12"
 dependencies = [
  "anyhow",
  "deltachat",

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

···
   };
 in stdenv.mkDerivation rec {
   pname = "libdeltachat";
-  version = "1.142.11";
+  version = "1.142.12";
 
   src = fetchFromGitHub {
     owner = "deltachat";
     repo = "deltachat-core-rust";
     rev = "v${version}";
-    hash = "sha256-60RkdwfLl2oncRKdAP0GD50WkrCBcrJ5Pkkue+UUJ0g=";
+    hash = "sha256-WjzmRRHdi31Eg3UAy4rD2xrx1LVew9Y4bb50Zyv+8JA=";
   };
 
   patches = [

pkgs/by-name/me/mercure/package.nix

···
 
 buildGoModule rec {
   pname = "mercure";
-  version = "0.16.2";
+  version = "0.16.3";
 
   src = fetchFromGitHub {
     owner = "dunglas";
     repo = "mercure";
     rev = "v${version}";
-    hash = "sha256-HqeF/Wr5ngf6hpFrZAL8kdHcMuxUslWsjtlOq4+C48s=";
+    hash = "sha256-mRBnjX9jXo2yoftDo8F6kNZeddFkFyUQ6eWxWoxzk2w=";
   };
 
   sourceRoot = "${src.name}/caddy";
 
-  vendorHash = "sha256-mRyzih46M635uQ9kIQ1vIe/ToN92xlvUcxQ7Bw/Qxiw=";
+  vendorHash = "sha256-ylPHBb/3lX9vwszyf7QzGPxGXE/Jt3cLKhsfmGMG8WM=";
 
   subPackages = [ "mercure" ];
   excludedPackages = [ "../cmd/mercure" ];

pkgs/by-name/me/mev-boost/package.nix

···
 
 buildGoModule rec {
   pname = "mev-boost";
-  version = "1.7.1";
+  version = "1.8";
   src = fetchFromGitHub {
       owner = "flashbots";
       repo = "mev-boost";
       rev = "v${version}";
-      hash = "sha256-4Vxs1Jo7rkw9l0pXfi+J7YmzQawt7tc19I1MdHQgjBA=";
+      hash = "sha256-EFPVBSSIef3cTrYp3X1xCEOtYcGpuW/GZXHXX+0wGd8=";
   };
 
-  vendorHash = "sha256-yfWDGVfgCfsmzI5oxEmhHXKCUAHe6wWTkaMkBN5kQMw=";
+  vendorHash = "sha256-xkncfaqNfgPt5LEQ3JyYXHHq6slOUchomzqwkZCgCOM=";
 
   meta = with lib; {
     description = "Ethereum block-building middleware";

pkgs/by-name/mo/monophony/package.nix

···
 }:
 python3Packages.buildPythonApplication rec {
   pname = "monophony";
-  version = "2.11.0";
+  version = "2.15.0";
   pyproject = false;
 
   sourceRoot = "${src.name}/source";
···
     owner = "zehkira";
     repo = "monophony";
     rev = "v${version}";
-    hash = "sha256-OGUj1NNJNerYx/nBtg4g9xMbz6u4YSqKO6HeMNeYpE8=";
+    hash = "sha256-fC+XXOGBpG5pIQW1tCNtQaptBCyLM+YGgsZLjWrMoDA=";
   };
 
   pythonPath = with python3Packages; [

pkgs/by-name/my/mystmd/package.nix

···
 
 buildNpmPackage rec {
   pname = "mystmd";
-  version = "1.3.4";
+  version = "1.3.6";
 
   src = fetchFromGitHub {
     owner = "executablebooks";
     repo = "mystmd";
     rev = "mystmd@${version}";
-    hash = "sha256-aZUDIQs4n2s842tq23pU/ZUW+1fF4XXEmgnapdZH8wQ=";
+    hash = "sha256-xcmiWJIeOW+0h2Fd7uAYyrD4+K/tLCWbyyeumD+4MMQ=";
   };
 
-  npmDepsHash = "sha256-IXdmzuQaBEbwjXssYaDLvxyTl+i2U/JTalg8lSGvuR0=";
+  npmDepsHash = "sha256-X4198iURcZDODA/mrpPwobA/1PG4M9k9G4tClB3qVQ0=";
 
   dontNpmInstall = true;
 

pkgs/by-name/nn/nncp/package.nix

···
 , fetchurl
 , lib
 , genericUpdater
-, go_1_21
+, go
 , perl
 , stdenv
 , writeShellScript
···
 
 stdenv.mkDerivation (finalAttrs: {
   pname = "nncp";
-  version = "8.10.0";
+  version = "8.11.0";
   outputs = [ "out" "doc" "info" ];
 
   src = fetchurl {
     url = "http://www.nncpgo.org/download/nncp-${finalAttrs.version}.tar.xz";
-    sha256 = "154e13ba15c0ea93f54525793b0699e496b2db7281e1555f08d785a528f3f7fc";
+    sha256 = "7EEUvNkYSqh4HzjbqjqgQlXfu6nDU2v3WWnma8M0r/I=";
   };
 
   nativeBuildInputs = [
-    go_1_21
+    go
   ];
 
   # Build parameters

pkgs/by-name/om/omekasy/package.nix

···
 }:
 rustPlatform.buildRustPackage rec {
   pname = "omekasy";
-  version = "1.2.3";
+  version = "1.3.1";
 
   src = fetchFromGitHub {
     owner = "ikanago";
     repo = "omekasy";
     rev = "v${version}";
-    hash = "sha256-oPhO+gRWrwgABc+gGXnIC519F5XVvewUHo2y54RoE4U=";
+    hash = "sha256-wI+xN6pyNoP4xknjHHDydHq275Gb1nyp7YtqmABlTBA=";
   };
 
-  cargoHash = "sha256-6GjNn7FAcAihqNhPD18sUFe40ZQwXmFEQmoZNZL2trQ=";
+  cargoHash = "sha256-6CU2ff4o7Y3CmZSf/xs2SSGco2mu4oRLJYIciCld8zo=";
 
   buildNoDefaultFeatures = stdenv.targetPlatform.isWasi;
 

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

···
 
 buildDotnetModule rec {
   pname = "pupdate";
-  version = "3.12.0";
+  version = "3.13.0";
 
   src = fetchFromGitHub {
     owner = "mattpannella";
     repo = "pupdate";
     rev = "${version}";
-    hash = "sha256-55tFnkF+zjvrGbG5AzBGc4nLqbPPMZ8+/muzav4dnsQ=";
+    hash = "sha256-czQU5O0z87v8p2GWYkRkhB5te/lub/yW4bMDd5EkVOQ=";
   };
 
   buildInputs = [

pkgs/by-name/qd/qdrant-web-ui/package.nix

···
 }:
 buildNpmPackage rec {
   pname = "qdrant-web-ui";
-  version = "0.1.30";
+  version = "0.1.31";
 
   src = fetchFromGitHub {
     owner = "qdrant";
     repo = "qdrant-web-ui";
     rev = "refs/tags/v${version}";
-    hash = "sha256-bHE/ZBc1PvjnIXhkh9BFS0x3Urnh4LOHH4MoKgqVVJ4=";
+    hash = "sha256-NNX//0ZkXYMaP14TI4BLMQI4jN+Mxc7uZu4rDZTXHG8=";
   };
 
-  npmDepsHash = "sha256-3w3imfe9XbK3eSh6kOd2G/ei75+Ub08L/hBej1iy9R4=";
+  npmDepsHash = "sha256-ZCHsVIbtnfrksBmXbYkZLv4WH+DBNazHCOtsgi+PKPc=";
 
   npmBuildScript = "build-qdrant";
 

pkgs/by-name/qt/qtractor/package.nix

···
 
 stdenv.mkDerivation rec {
   pname = "qtractor";
-  version = "1.0.0";
+  version = "1.1.1";
 
   src = fetchurl {
     url = "mirror://sourceforge/qtractor/qtractor-${version}.tar.gz";
-    hash = "sha256-yoVxRUXUhZrIzJVWLKA6G4hBf52dvJdr7FlfM+ZHUeo=";
+    hash = "sha256-Q/6AS9mZwsG+wF/h0xt77s8qpuLwcO1CjoVaX9ta9Qc=";
   };
 
   nativeBuildInputs = [

pkgs/by-name/sn/snipe-it/package.nix

···
 
 php.buildComposerProject (finalAttrs: {
   pname = "snipe-it";
-  version = "7.0.7";
+  version = "7.0.11";
 
   src = fetchFromGitHub {
     owner = "snipe";
     repo = "snipe-it";
     rev = "v${finalAttrs.version}";
-    hash = "sha256-cka3ZczRYXmzeokiUg2WarArvW507AVsCIadPlVUYWo=";
+    hash = "sha256-XMsLK6IKbnlYZk7tPYq++prv+28FefEbahOqmeEAAiY=";
   };
 
-  vendorHash = "sha256-nwzPmelTvInx055lyuhiTioWyF0JSCjNa2Ky8yQXwtc=";
+  vendorHash = "sha256-8YZD6Q1Mb5VUGL/KQnYTtXKL3aziPfAmwvVthDdyBYY=";
 
   postInstall = ''
     snipe_it_out="$out/share/php/snipe-it"

pkgs/by-name/vs/vscode-js-debug/package.nix

···
 
 buildNpmPackage rec {
   pname = "vscode-js-debug";
-  version = "1.91.0";
+  version = "1.93.0";
 
   src = fetchFromGitHub {
     owner = "microsoft";
     repo = "vscode-js-debug";
     rev = "v${version}";
-    hash = "sha256-3SZIIBHv599qLaW419CA0Nr7F6R7GB9wqUnOqbV4jKc=";
+    hash = "sha256-8+ZoTddzgwLwPUduT+G5zVgt/ZxLWKojz1PKvOxLX6o=";
   };
 
-  npmDepsHash = "sha256-kZ5wCcmdpYtT6dqtV3i8R9LKFs20sq0rZC1W1w00XJQ=";
+  npmDepsHash = "sha256-4GTZevbQg1LhxVw6WQYGvWHVuaWTwpCf50gMZWAHE7c=";
 
   nativeBuildInputs = [
     pkg-config

pkgs/by-name/xl/xlights/package.nix

···
 
 appimageTools.wrapType2 rec {
   pname = "xlights";
-  version = "2024.14";
+  version = "2024.15";
 
   src = fetchurl {
     url = "https://github.com/smeighan/xLights/releases/download/${version}/xLights-${version}-x86_64.AppImage";
-    hash = "sha256-WqLPesH6KaOAj7gYycyrmzG2NIkKs3cjUm+K83rvha0=";
+    hash = "sha256-/KUcBr5Z8xITeEL3g/5UFQ483lUY/fvf8VtlnSOcqu0=";
   };
 
   meta = {

pkgs/by-name/yo/yourkit-java/package.nix

···
 let
   vPath = v: lib.elemAt (lib.splitString "-" v) 0;
 
-  version = "2024.3-b157";
+  version = "2024.3-b161";
 
   arches = {
     aarch64-linux = "arm64";
···
     arches.${stdenvNoCC.targetPlatform.system} or (throw "Unsupported system");
 
   hashes = {
-    arm64 = "sha256-0a9maZhgtXH21Ph0o3Rb+rCPhAmZRxjZCRyDmTvusLk=";
-    x64 = "sha256-nLaOOkPG2QEHkHd0S2AYLT2IpkMchGw9adyUDLCNQFg=";
+    arm64 = "sha256-Qm/+KQ4nZr1IIyo+i8Gp8K2PEU844tuigiopWEibaAE=";
+    x64 = "sha256-yxbPS5UrYq6FgPlqfWjO9tPI/rjA/400JnS3kKHgMV0=";
   };
 
   desktopItem = makeDesktopItem {

pkgs/by-name/zx/zxtune/package.nix

···
     ++ lib.optional withQt (if (supportWayland) then qt5.qtwayland else qt5.qtbase);
 in stdenv.mkDerivation rec {
   pname = "zxtune";
-  version = "5071";
+  version = "5072";
 
   outputs = [ "out" ];
 
···
     owner = "zxtune";
     repo = "zxtune";
     rev = "r${version}";
-    hash = "sha256-qb06c0/Td6/6U033uYUkFq5JhCqlWCx6IhQ//PMeGUY=";
+    hash = "sha256-cbSz5fi2HYE7ScYFhopXcp9Ct4dMFughF2TKkY1K4uQ=";
   };
 
   passthru.updateScript = nix-update-script {

pkgs/data/documentation/zeal/default.nix

···
 , fetchFromGitHub
 , cmake
 , extra-cmake-modules
-, fetchpatch2
 , pkg-config
+, httplib
 , qtbase
 , qtimageformats
 , qtwebengine
···
 in
 stdenv.mkDerivation (finalAttrs: {
   pname = "zeal";
-  version = "0.7.1";
+  version = "0.7.2";
 
   src = fetchFromGitHub {
     owner = "zealdocs";
     repo = "zeal";
     rev = "v${finalAttrs.version}";
-    hash = "sha256-918hWy5be5mHINLbFJPiE29wlL1kRUD4MS3AjML/6fs=";
+    hash = "sha256-9tlo7+namWNWrWVQNqaOvtK4NQIdb0p8qvFrrbUamOo=";
   };
 
-  patches = [
-    # https://github.com/zealdocs/zeal/pull/1644
-    (fetchpatch2 {
-      name = "fix-qtconcurrent-component.patch";
-      url = "https://github.com/zealdocs/zeal/commit/c432a0ac22b59ed44bdcec8819c030d993177883.patch";
-      hash = "sha256-DW7rBRMnXm7r+jps1/3RTXA1PpwEUCprW9qrHMRii84=";
-    })
-  ];
-
   nativeBuildInputs = [
     cmake
     extra-cmake-modules
···
   ];
 
   buildInputs = [
+    httplib
     libXdmcp
     libarchive
     libpthreadstubs

pkgs/data/fonts/iosevka/bin.nix

···
 in
 stdenv.mkDerivation rec {
   pname = "${name}-bin";
-  version = "30.3.3";
+  version = "31.4.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 = "0mma97rhjpfq20mq6dji50mxbdgaz72ccfqhrqim6hj5x5pkc2w2";
-  IosevkaAile = "1frmm1q57xqsxqvz1vmz5fzammpgkgk2lspnkilb1adavla5a5j6";
-  IosevkaCurly = "0zq07z1nx6b52mxh9kqr880p9aw10whjs0qgwzlyyij7jnk4mx2l";
-  IosevkaCurlySlab = "0g6p9gpjqmdan81cv9rg2bppcdg7s8iiyn8whxqmxf0prbsyxcw6";
-  IosevkaEtoile = "1sh3d69m0p8glr8szjd1cyxzsi66qsbmasjlmkwc1fhbw9w5kb5c";
-  IosevkaSlab = "0sk90cq1zl4d0yjh0p78idjpi2hmr0hy4c4650xls9js0nzszjyj";
-  IosevkaSS01 = "10f63fkyfcr0mngjql69zsfmy2wffbdzxkacw5jwlcnnpw6lwrz2";
-  IosevkaSS02 = "0ydmp0mp5n6rh9s48pixrk41vdai3ys4q2wz60rpp8pl2sl7l58f";
-  IosevkaSS03 = "0k2k54jh2w1pf2hhdx5m1bkk4pj9p541ddnvkw8jxdc30ab9pg0x";
-  IosevkaSS04 = "12j2d7h1hp1m16m893rn79v56a13kvsz2vabp395fdhjswffpjly";
-  IosevkaSS05 = "1cvl4hg058675h9amvvjw2qkjk7fs9zs3prdqvllpch77fkznbv3";
-  IosevkaSS06 = "19cvfxrgqwyaan8xdyfrz1wsnr7cd43szcq0ijwsjxv0afvadp03";
-  IosevkaSS07 = "1kd3s41nqiihl2wf0944mw7x1gq7xa5jfgis0z23snb9p25gyzli";
-  IosevkaSS08 = "02yd5s4gvvl2xg68cznj00giqzngmdhmjz290q5d7kkzgzf8v6d4";
-  IosevkaSS09 = "13hd8f38b0882paqr4pw2wx6raqr9m5d9ndphs8fvyadhsh70xaf";
-  IosevkaSS10 = "1j0lbwvzqx0lmj3irf01aywqny94sidz8m06xl8vrljczhhz619w";
-  IosevkaSS11 = "19kndxn9lynx3ambah3gn63d8fdqq5p7i5yxjlsn7g0d5vgvaa9h";
-  IosevkaSS12 = "0jbsmsh6c2kzrn4kbkj4klc2pk1z54c1pf3c7y1vr8xyqkg43bjs";
-  IosevkaSS13 = "0jgf400xl1hnd78vi3vdvxmax415rq475v1shfrf0ms3hm0kbrp0";
-  IosevkaSS14 = "0acrv8frx88292iw55944mfp814iskafyknymiayxnpmmppn078g";
-  IosevkaSS15 = "18jzzd5jsb9yvv5gcybnn8gcp03x7rhl2z40d16ln9cx150336sx";
-  IosevkaSS16 = "0405qngdwkxxzyjxx9qy18p37jz1sc5f32ynaiiif0zg0c8bbsrb";
-  IosevkaSS17 = "0f8is0b4rvy8n2fnydc9f2g958y9xnrww44fhb28vglgwil6pvya";
-  IosevkaSS18 = "12hz34zfvdlw0dxni23j5knsxcrkvnpvankidkd0y500zisx4i46";
-  SGr-Iosevka = "1izcklbrm8f993vhdqvyiy9c33d7aykvj4vv2sqwvwid2mv0rvdn";
-  SGr-IosevkaCurly = "1r7cy3scf8gjp7hp3q80xf28d3px9vmsis8g0a8nr0vrg7wvc0p7";
-  SGr-IosevkaCurlySlab = "0ja6i81fnz8kvzlfasvm5gx5c7l2hkvl1qfdan9knj6p5390rp25";
-  SGr-IosevkaFixed = "1gcd6jms5z6pgclr8lgb0ip6z0y6vx9c79wvf0w7ixjcyafb1aq4";
-  SGr-IosevkaFixedCurly = "1q415xikr2ihrxl3xvpfj7ix1kn1sva089abpjf0yp76rjfx5v9x";
-  SGr-IosevkaFixedCurlySlab = "1cfii72ci508m7lrv701hsz5bzphjswdpcaccyhzkjqyjbajgvj4";
-  SGr-IosevkaFixedSlab = "128rcxi2zjaxcbi7a6w739lvxcbaw6ph8q6a1gy20pgapna1l9xf";
-  SGr-IosevkaFixedSS01 = "0pbv1x4mm7h43sz4r7rb0hkhsm6g7i4pkpi0lbnx2awiafzzlg3s";
-  SGr-IosevkaFixedSS02 = "11d0si4bmgvz3pl43qbpszj9h9x4g53r29359y2mi5rmw5jym01l";
-  SGr-IosevkaFixedSS03 = "1nmw3g30hm2rgy0lji0lbihi08iphy943pkrs5fl2c36yf9qxl0d";
-  SGr-IosevkaFixedSS04 = "18jhd61d4vrmq9ck3wass07ph8frxnq8knl0cdpgqx6izk3fk0ss";
-  SGr-IosevkaFixedSS05 = "0x9q7jvzsrs71frx662cb4872z9alc2y0r7cjaxpaifc420826z6";
-  SGr-IosevkaFixedSS06 = "17f9c4cwi46c5jlrj6r6xw6gwjq2cmkjm4832cyjw9fqh4kpb0ih";
-  SGr-IosevkaFixedSS07 = "1x3j7lp88zrxkmak3fnglin2sp450lmlyv92n56dz2a7gvw0nbs9";
-  SGr-IosevkaFixedSS08 = "03m7wmwlajhjw3ifhmxl4cxkjjfyldw0bbybhk4cdsw9qni0cbhi";
-  SGr-IosevkaFixedSS09 = "127466bq6m3k7is2jh45j9c3iik2ckgajhrkhgmhk3fr272ip00z";
-  SGr-IosevkaFixedSS10 = "1qczqa9lv0hlqjhh5n3j32ampflriwyhp7cvk8vraxp8w01f20vv";
-  SGr-IosevkaFixedSS11 = "0pm10asyl566l9s00hxb1r43yvhb24hqn3z5akirfxxp5klp9hf3";
-  SGr-IosevkaFixedSS12 = "0lsy3097aid17hqxljkxj9lpswxvlmk5gv047dh7m6m8vxm3dzcy";
-  SGr-IosevkaFixedSS13 = "1h5bv9c6yvbvfslx3wm5657f982f17pb2q8j2hl5c50114dbkdib";
-  SGr-IosevkaFixedSS14 = "1lglsqhcy22hf4zbczpwc7pkmyaglknqpkv9bgckphpzaqgmavln";
-  SGr-IosevkaFixedSS15 = "18hc5kfj4m57k8p90jc2fnr89ji6q34q6v3b1xkyb0lv9bagq2nl";
-  SGr-IosevkaFixedSS16 = "0k4nrdqnh6jg40q5xvkrm1jx0iplwybhxy8bn3q7k461d3rn9smv";
-  SGr-IosevkaFixedSS17 = "02higr5lxiyi6z8b916pkgch2dq0si7m7bf0vxb86daplgljbrna";
-  SGr-IosevkaFixedSS18 = "0b4ljypil31n0861k43k0dxrmj9djgy8qffwy5vv856lcrdipy8h";
-  SGr-IosevkaSlab = "18y0j05jjkdkavidrn2bpfd1319yzxp7m0zyhn08394d4m74m8w2";
-  SGr-IosevkaSS01 = "0k9l74q9lijhxq1slxxkq7wb71nsrdv2bkqsbdxxb5gypqjh136y";
-  SGr-IosevkaSS02 = "1gzjf6j6ljxnqi3xzcs1q1qzazyzw9d4az4l1nmsbkk5nfw3skbi";
-  SGr-IosevkaSS03 = "1d8ihwf8m47lvlyyar4wd2xqjn4g5qmy1pp81dd2p999j47fzz84";
-  SGr-IosevkaSS04 = "0dwhmlsv4x3z2xmnqwdciys0j22z25vcwqrb7wmy7c5sdhfkd4pn";
-  SGr-IosevkaSS05 = "02nid5vi8q71lcaxwllyaa7j2qdb8hycw5k3b9fiw9bvliip7bwl";
-  SGr-IosevkaSS06 = "1vx6nqv2m1f32xqgv6px2r0rr60rb8rns6f2y2dmnz1b55j4ap84";
-  SGr-IosevkaSS07 = "0rgk9z2mrz990szq1m5664x1jq3056df9warjpj0nnr0d3a8406q";
-  SGr-IosevkaSS08 = "1sv09fsd3xwwjdkiw93v7pvs3a1r7mbxqgyw73l4v8k5c8f16q14";
-  SGr-IosevkaSS09 = "1hrk9pn407f57bx6zjc9mxzr7286vz2llyrkn808q1dlvisp3gc9";
-  SGr-IosevkaSS10 = "1sk339gl5r004pd52daclk2zl5zybcfra2hdafvrmc81fkd2pz7b";
-  SGr-IosevkaSS11 = "0rp7488skw396qdw8lyv69fgkz3b5i5nbjzkbrlfjasp2sgyg1i9";
-  SGr-IosevkaSS12 = "04446s3bjdpvk25361n88xmcc3ylh9frabb11wgs79brm2i8qf57";
-  SGr-IosevkaSS13 = "1xsdp07272bmp6fj68ky40hs53lhsm9y9c6fpk2cqvm25mv5w7fn";
-  SGr-IosevkaSS14 = "1r3d7g4kqrj6zwpivzsjvhvv9q4gysb6a8s0m1fvaarsxhcrvkf1";
-  SGr-IosevkaSS15 = "0cy8jg4g95zxbcq8y6bksmjbfz5dbp3c7qv16z533n2b5fn5h912";
-  SGr-IosevkaSS16 = "05rs3hkv92h2s3p3v4v33jrfx5b6vk5v5d8kbwg989y8azzsj52m";
-  SGr-IosevkaSS17 = "1i28qsazi4q51x1rk9p6h6zvk6pbbm9g5fs567a5wwlhagjha2cd";
-  SGr-IosevkaSS18 = "0ghs5b6zg1jmibgypqwgnl8vpvzhj5c8di4izp5rgw8lzsi5n9yb";
-  SGr-IosevkaTerm = "1vxs9sxc8q54cg4ydln1zqqwj8rs7x87xn3yz7nhgswk2zdyfxnr";
-  SGr-IosevkaTermCurly = "1v4hwghycmlzi57m7qnp60v618x4wkqg3pbzpvm80v528lvrsrsh";
-  SGr-IosevkaTermCurlySlab = "0z2z117saryawik1xnklzn8schgy4q10yqax1ypl1sj0lq80b6dm";
-  SGr-IosevkaTermSlab = "04qbdia36haqisrm8z4waknpfvgrxb2cymjk6pwdqgk4jbfd6yh8";
-  SGr-IosevkaTermSS01 = "1y3ggssvk39kv4igli2q7qy35spj5vddngsn4izh089a4irr7462";
-  SGr-IosevkaTermSS02 = "06ddjjfj2h83ya4hw4yla6fzd3kpv3q6fnscx2aydxc4qjryqws7";
-  SGr-IosevkaTermSS03 = "03jjlllq4x9h6pkg67vfivvc3p0swawah94yi10ar1hbgaljqhn4";
-  SGr-IosevkaTermSS04 = "0n36y3pz660j0rv1zhyjrahcz87a65fw59s9x320aix502msaqn2";
-  SGr-IosevkaTermSS05 = "0h71560ln3my53giyw75mq9cynjnnj6dkvdd4anbkvyw2j133497";
-  SGr-IosevkaTermSS06 = "0fhmzjzxy8hjcdk3rjl9igykfmlgji7v5lyzm1p04fs4wa289bh6";
-  SGr-IosevkaTermSS07 = "0girzhdwgwsjqqrhz0bky81rrqj62hxgkqy3sklr1w55snhq9yb4";
-  SGr-IosevkaTermSS08 = "08rz3bjimxmn6xp4dqv9177bhyyqv10rdfxz697fkajq0wxvy4xc";
-  SGr-IosevkaTermSS09 = "095bzk8ir4zxmrikr48fbfhsdhhnrcwg3xrkvqxhqancgqj4rzsz";
-  SGr-IosevkaTermSS10 = "0kb3nhdy1pilhvdyfb3igaalf888qx55vhigvail05dnkp23iyaw";
-  SGr-IosevkaTermSS11 = "1sxihqvswi66pbjnixfv1f4gv08x6n28qfzyj03lzw1d7sz3m1gp";
-  SGr-IosevkaTermSS12 = "0w2sh563azjam2fcdbpxh466ddlc4h6vpc2xlawl78w5n63wsnys";
-  SGr-IosevkaTermSS13 = "00h1kq3a2kbippqcy49jiagh6zl01qb40489njdg1vpd6s04x50c";
-  SGr-IosevkaTermSS14 = "0k97x43appi5azlnghinwmyq13h5fqkj0p2rysnz28v5r6razikm";
-  SGr-IosevkaTermSS15 = "1ziqhmp9af9b0djm9mhh2yy5f85rwwk82xhwsd84y9bl3mwil5cr";
-  SGr-IosevkaTermSS16 = "00lyihlkv7h5pr2w74rb56kwzjqwh1kh7cp7dfzhwhwicy5bxc50";
-  SGr-IosevkaTermSS17 = "03zgm0qsw5p8i1567ghslgb3cqwxznc9rbwnx9xiwv4972lbad6w";
-  SGr-IosevkaTermSS18 = "1dmvvn1ny1bym8k32nvp2qzrzmy0qy4l6w1clfza4g6c23k6d4dd";
+  Iosevka = "16pyffwwyq9vlwd3xjnfpr5sgcai9kdiz9vsrjws5wr8qr85rc93";
+  IosevkaAile = "1s1gy1h6xwgn2bkh8z7ghgvr9qccahr36jqbbyksj1lms4sl6zsp";
+  IosevkaCurly = "0h062xhdskxa0kwj4h73r6ihllmxqkq4qazghf689lkbrklcq9rz";
+  IosevkaCurlySlab = "053xvjkghbk9s6x492bj9ykx7fn1kz7k7hg55gnmppw0hi8ajfxx";
+  IosevkaEtoile = "1dinagfkb3vfh2y4bbyk2kgvw1rgw71fyqwb72zd20ygrnwwq4hc";
+  IosevkaSlab = "0xxz7gr71bry054d6va1kijdk1bh6l9h9cifyfvdyf9h4rrpidjk";
+  IosevkaSS01 = "0w333v4i7y949cqczp47x36435f8d010bmkmzbf17zf1fwny8bsp";
+  IosevkaSS02 = "0b75cvfnvrzdbiqvb58xgd6wsmdlm187nj08rs3102gyc0crwzbd";
+  IosevkaSS03 = "15f3qadgd0xrqr95vbmway0gzwjbwjzz7xf92ql2nhhbxnkfsra4";
+  IosevkaSS04 = "1xvkmzpzx71c9m615252y1643brlagh04kn1m3c7xx6idxg3fshc";
+  IosevkaSS05 = "1apwlfggxj98rvz7ndrrs3wszx1sw9mwbqd0khxq1qrr1mq2x07h";
+  IosevkaSS06 = "0k5g7d87r4jlq55gd07v319v06vmvdcz0qw4kfy5p87r5m1wyv4k";
+  IosevkaSS07 = "1hd4nxjvasb562qr61nrj1h7mj06r6fdjadjs7jx0ph3qfc2p4rj";
+  IosevkaSS08 = "0licrfyizc1f5dfb8sfnjzxxxjx6zfxp1fjjwwr7j6vxaxx6pvp1";
+  IosevkaSS09 = "1qpll64150yrhafgif9fw6nl5mhm8gkdjrzysdfd4vkabzzg21l7";
+  IosevkaSS10 = "1n7jnwzg0kcpzg13wac0m269z8qsci24jwlsc6i3v94ksil34p3n";
+  IosevkaSS11 = "0f8gprgcpm56bwmiwa1h2bbgxh3fagcv0gfbwbhnkjmkdr2gp9x6";
+  IosevkaSS12 = "1vj0lanm0kh5ndsqwvh1hb70hxmy834gbsqx5afr2bqfdv2lbl4k";
+  IosevkaSS13 = "0n0wvgah0zraqvff68kwvw8m6fzahblp27sag370pk7v0wr4k0wb";
+  IosevkaSS14 = "0r5x3y8nh9j7nzxcffgkxiyd7hfzi8r95bvbdq7lh6nvaa3a22fy";
+  IosevkaSS15 = "0ga9jkd4plr3wjmjxl60qaw0w5zdz6w75v065fzpg1q0yxixipd6";
+  IosevkaSS16 = "0j4mi3yfw6y7863fa413jlyi9yb4j5cgrcibjqbp139282j7bnqk";
+  IosevkaSS17 = "17m05d2d7d7pvdypzwnsy8yxvsiflm73788msgr7xrvn8l527v1h";
+  IosevkaSS18 = "1y7a6k9wm59r76w5l9zf1xz4k8w0k19p74d3x0xzfzbrd1swgii1";
+  SGr-Iosevka = "17ccw94vi1gx2hs61w52zih8l249yw7mwldgpiqcvhfgs3gl2mba";
+  SGr-IosevkaCurly = "1i1vf0sndib8bfbvzfyr4cb98w1jn961gj58g0qsnrgidhsgrwmi";
+  SGr-IosevkaCurlySlab = "1danjyxaqs32ln9mq1ns1991d2z9rv64qpvxg2n92j7hmd2ifsay";
+  SGr-IosevkaFixed = "1aa5905i8rkndgk0dxn7vxzycg7v9ynf8xwznp1wddqmxhfi6n7r";
+  SGr-IosevkaFixedCurly = "1s5c9f0is4bi9hsp7z74k5l5yc1qibvlx4vzhmphlns3ykyb14f9";
+  SGr-IosevkaFixedCurlySlab = "1xf8cp3x5al5zc6dn9zf8l5vkcnlmn9g2xk4p244l9d0h3bws7nf";
+  SGr-IosevkaFixedSlab = "0wdjyy4dvbbh6m5i1lwc4khrjydwkimw98yisfyn9dm81f9y3scn";
+  SGr-IosevkaFixedSS01 = "0rk6mynlyni6jcf35ppw6iki116j0s5n747lsmqssmr127kdygn5";
+  SGr-IosevkaFixedSS02 = "0jx6254nyz4c3d0rz19bskxyk0azhqm4qmkph9053r4glysjc2xm";
+  SGr-IosevkaFixedSS03 = "0y1vavp6h3s1xggd62ar9zbqvnl6dl9fmw7vv4nl5xd08i4mc8wf";
+  SGr-IosevkaFixedSS04 = "1q1g2psx93x8rf3mcwgh6c0gjzmi965c1nrd3hz4a4zk8h1n6981";
+  SGr-IosevkaFixedSS05 = "1lbgr8b1904k0i89ad1zkk7xc8ind5hqnjvsg8m88na3wry3gz37";
+  SGr-IosevkaFixedSS06 = "09ddjb0y02g9l4brn33li3sssll5g9njnqqi05nzdvjsbc3ls3qq";
+  SGr-IosevkaFixedSS07 = "03aivfwh0bf3c8khpjgds6ajdff2h3q7nvn6b5c86wg30wi024r3";
+  SGr-IosevkaFixedSS08 = "0skf9nrd3hgxkgjw3rjx5nd3r476jxy083wpzvvvd4ffkjdglcn6";
+  SGr-IosevkaFixedSS09 = "13vymxhgms68d56ni8arfl8n53r4nlpcv39khgymp28rq8snqh32";
+  SGr-IosevkaFixedSS10 = "1mlwilxy4k936v6ck9gif18cq9xbwv3da9nbqlaq91nhwpwfhvjw";
+  SGr-IosevkaFixedSS11 = "0nxgm82w4m58bz7pixbkskvphzcrw3xshnphjb53n1sng7xcdvk4";
+  SGr-IosevkaFixedSS12 = "1pghgii73y9r5c960a0dg2hqvfpf45z737i8fjnda1a5msrr8as6";
+  SGr-IosevkaFixedSS13 = "0aab838ah1qjcqmp5d7ys8qxjws4pk5zrmhildisfhappcddmzn9";
+  SGr-IosevkaFixedSS14 = "0xrz5alr2ll2kq61crlb1jw5c1v80hn4wblj245y96jgj6nckpa4";
+  SGr-IosevkaFixedSS15 = "0sr1wv00pb85pdkhj4xjnmzgk84ks8h75bmjhn4sm8bahxbss056";
+  SGr-IosevkaFixedSS16 = "0nap7ckvq23gqn5kr6asm7jjb2l6wmf53k30wvwmrwarqc9nlv1h";
+  SGr-IosevkaFixedSS17 = "19124ya7j56lxhjmvw4cvqpim4y0j501nkvpnzdlyclbakmg6f6r";
+  SGr-IosevkaFixedSS18 = "1f2kgpwflqi2fck1qcfidmq9r10arsp26gycj4dkgb71ddasb020";
+  SGr-IosevkaSlab = "1fzvnivlj4f9k8vgwq1bp1bqh92d069qyymrfq2ki9p6if0jvf79";
+  SGr-IosevkaSS01 = "0gjbpb7vv4nvvx913kqrkh2l0145l3xlqk589cfa0hdpc5jvc79k";
+  SGr-IosevkaSS02 = "05dv0n7ziwyyv9rm8vsz71qki632cggcxb5qdrz51a03jhykxx10";
+  SGr-IosevkaSS03 = "16jb0kf933pkvlkvvj8j6av608x8vyb0v3rmd6y67wb47prk6bh9";
+  SGr-IosevkaSS04 = "1nyahbag9fkfhv0rw129dcni6iqq8jji7p468rd9diqz05ainlc9";
+  SGr-IosevkaSS05 = "0cvqcvvqgq0s8mpk9lpypqglvh69ksfyv57r6dilaf329adfp1sw";
+  SGr-IosevkaSS06 = "13y7aw7xwsbx1igmlvmlw25cq742lwgr40r02scpx39i65lk9baz";
+  SGr-IosevkaSS07 = "13x8frvbxzzl0rf12n3xpgg66yjrwbavhrb9kix9ngbznahk85qm";
+  SGr-IosevkaSS08 = "06gsrb3d17672ci8gwj1wmlj3nm1v2qkgjx3gblsh0ykgqqyxqv7";
+  SGr-IosevkaSS09 = "1xy8wsxlcly3xf7swis4pdm4v5vp684lrsy8z8kn7j2f0l7cy82m";
+  SGr-IosevkaSS10 = "11bngjjm22lah21xzazn7yfpi433bllwcl3shxpbscm5xcx2hf04";
+  SGr-IosevkaSS11 = "1z9vkcld1ywnwcg5am5zl30dsrjmvbi14f6gsihxcalncpwzwyhz";
+  SGr-IosevkaSS12 = "05ivbrf0h7h9g64pbz3xy62v5m97fwpib2l3zg3x9s3xln7r93sd";
+  SGr-IosevkaSS13 = "0fkv6szha00wlwp1sks0ywdxgzn4y7j1ny5934rllz47s4574vd0";
+  SGr-IosevkaSS14 = "1r4yzc304ds056d8cxjjfr5hrbf3a0cxaspw9a1hb1d5mr0409v1";
+  SGr-IosevkaSS15 = "0krz2mscxrzv2gl789ssgz09pmnixg6z0pa8jhsgkws67d0y6m60";
+  SGr-IosevkaSS16 = "0c20bvzvbrbm1q0nzp5az8jh5zfd5kk4syhpyp0f7fycjzalygxi";
+  SGr-IosevkaSS17 = "17a4svm25kzmszm6lz3i1ldyphpd98rn6yc2fys1mfblmg7l0jmj";
+  SGr-IosevkaSS18 = "0lsyvqy4z6zp8bc5sq3gg33lwxpa6vfxc2ajlayc8xvcjyf70lza";
+  SGr-IosevkaTerm = "023ksvd5d9b6an8vja67b5f2h80gnjmhbab4pqsafm2xrmc6cdpx";
+  SGr-IosevkaTermCurly = "0ga2vfhpgv9kwg25vcgddsa2rs8hcidbjcqywd8g9yp3jykdkfhm";
+  SGr-IosevkaTermCurlySlab = "1kkks8n0giwid9f5xfq8b00xzvbpgp9416q1rlnyc91cr7bz3x2m";
+  SGr-IosevkaTermSlab = "149xqag9sfg5w4cmbagn93mk2088b8r60nal1l4l4dlfm3vnbr61";
+  SGr-IosevkaTermSS01 = "151vk6abvlmyygk9dd7f7adf7a6279yi90dh1dagzrpfbwx5955g";
+  SGr-IosevkaTermSS02 = "1qa3vp67jwb7ns44i4i0cdakwpi5pvwqw2ij8zp4iw0229hyz2q9";
+  SGr-IosevkaTermSS03 = "0mk1bc306mf3j3xh8l7bxa5yq3lida30d5xlbhifks7v1wynh2j5";
+  SGr-IosevkaTermSS04 = "0r6msfh14s0kmv9y0hyda8ln5iarv2fd2fs8gkwrpyd64nb0bjdg";
+  SGr-IosevkaTermSS05 = "0qkamr3p0li05ifc1rcsrdsiq5imr30g1y36xj2g1ci6g8biilq1";
+  SGr-IosevkaTermSS06 = "1gvqqydblfgbb5dm4p6g5rs80669xhic7qz5r5vchg6s1nbyyqq0";
+  SGr-IosevkaTermSS07 = "08s2zafv9rjq1wbqh7nb7n5x21zgpzxgvkg7fa8dkhsdjdmw4n85";
+  SGr-IosevkaTermSS08 = "0rp7nckqnfpha17ca7fjy6l3fdfbxxnag8czb859akfcfbqbq5h0";
+  SGr-IosevkaTermSS09 = "0ry6m079n52xw8im3ifwngzr7ny85rbj5nvvrh5dpnf6mpv878nn";
+  SGr-IosevkaTermSS10 = "1l2jyjb2whg75gyzsjk52m9489nqqpd5mg95kmkc77na4brix769";
+  SGr-IosevkaTermSS11 = "117nhhi2nzy2k9fjficqy837frkb03fl17s3ncij6b6d0yrd50jj";
+  SGr-IosevkaTermSS12 = "1wf1ypnzsxa00akhl5a6c9awdzg7b201ana4im2rii141b85l3d1";
+  SGr-IosevkaTermSS13 = "1xsxfpxjmcf0fxw5xp8cairplinjb14y6mrfdvj2zh01xbnjryvr";
+  SGr-IosevkaTermSS14 = "0s4q9wnk734xfa06qvlm8689ilvzjaxfbpnmqv8irqwp4s5pdsyl";
+  SGr-IosevkaTermSS15 = "0k6sida5ziwq7rn7x6561zcyynki1nlmxp4qwjc20bmym8wi55wf";
+  SGr-IosevkaTermSS16 = "1vnqsd44zgx1hzp4zjccph5jh8chv7fnijfxnr9cncslmq03y6yn";
+  SGr-IosevkaTermSS17 = "0cx1dh1icc1h3i4al6rlkzbi70xvq1mzywjzl96r2pa9x4fj71gy";
+  SGr-IosevkaTermSS18 = "09f9zy9khg4r3qymcki85k26529nn3pgpm4ra5c5zw8bl56yxxhp";
 }

pkgs/desktops/gnome/extensions/icon-hider/default.nix

···
   meta = with lib; {
     description = "Icon Hider is a GNOME Shell extension for managing status area items";
     license = licenses.bsd3;
-    maintainers = with maintainers; [ jonafato ];
+    maintainers = with maintainers; [ ];
     platforms = gnome-shell.meta.platforms;
     homepage = "https://github.com/ikalnytskyi/gnome-shell-extension-icon-hider";
     broken = versionAtLeast gnome-shell.version "3.32"; # Doesn't support 3.34

pkgs/desktops/gnome/extensions/no-title-bar/default.nix

···
     description = "Integrates maximized windows with the top panel";
     homepage = "https://github.com/poehlerj/no-title-bar";
     license = licenses.gpl2;
-    maintainers = with maintainers; [ jonafato svsdep ];
+    maintainers = with maintainers; [ svsdep ];
     platforms = platforms.linux;
   };
 }

pkgs/desktops/gnome/extensions/taskwhisperer/default.nix

···
   meta = with lib; {
     description = "GNOME Shell TaskWarrior GUI";
     license = licenses.gpl3Plus;
-    maintainers = with maintainers; [ jonafato ];
+    maintainers = with maintainers; [ ];
     homepage = "https://github.com/cinatic/taskwhisperer";
   };
 }

pkgs/development/beam-modules/erlfmt/default.nix

···
 
 rebar3Relx rec {
   pname = "erlfmt";
-  version = "1.3.0";
+  version = "1.5.0";
   releaseType = "escript";
   src = fetchFromGitHub {
     owner = "WhatsApp";
     repo = "erlfmt";
-    sha256 = "sha256-fVjEVmCnoofnfcxwBk0HI4adO0M6QOshP3uZrecZ9vM=";
+    sha256 = "sha256-TtOHcXiXl13KSGarMBdvvDjv1YQJjDVFtDLC0LDz9Bc=";
     rev = "v${version}";
   };
   meta = with lib; {

pkgs/development/libraries/libzdb/default.nix

···
 
 stdenv.mkDerivation rec
 {
-  version = "3.2.3";
+  version = "3.4.0";
   pname = "libzdb";
 
   src = fetchurl
   {
     url = "https://www.tildeslash.com/libzdb/dist/libzdb-${version}.tar.gz";
-    sha256 = "sha256-oZV4Jvq3clSE/Ft0eApqfQ2Lf14uVNJuEGs5ngqGvrA=";
+    sha256 = "sha256-q9Z1cZvL3eQwqk7hOXW5gNVdKry1zCKAgqMDIKa7nw8=";
   };
 
   buildInputs = [ sqlite ];

pkgs/development/libraries/mlt/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "mlt";
-  version = "7.24.0";
+  version = "7.26.0";
 
   src = fetchFromGitHub {
     owner = "mltframework";
     repo = "mlt";
     rev = "v${version}";
-    hash = "sha256-rs02V6+9jMF0S78rCCXcDn3gzghqnOtWEHMo/491JxA=";
+    hash = "sha256-MC7D7bgguDFZi8Dyip1wAa2zxxkpLupl05xFiDc8Byw=";
     # The submodule contains glaxnimate code, since MLT uses internally some functions defined in glaxnimate.
     # Since glaxnimate is not available as a library upstream, we cannot remove for now this dependency on
     # submodules until upstream exports glaxnimate as a library: https://gitlab.com/mattbas/glaxnimate/-/issues/545

pkgs/development/ocaml-modules/terml/default.nix

···
+{
+  buildDunePackage,
+  fetchFromGitHub,
+  lib,
+  uutf,
+}:
+
+buildDunePackage rec {
+  pname = "terml";
+  version = "0.0.1";
+
+  src = fetchFromGitHub {
+    owner = "wllfaria";
+    repo = "terml";
+    rev = "${version}";
+    hash = "sha256-2ifMfUaYYsCFOACgXgJ5IuoSEicHyIqumLpun2ZqcDc=";
+  };
+
+  propagatedBuildInputs = [ uutf ];
+
+  minimalOCamlVersion = "4.13";
+
+  meta = {
+    changelog = "https://github.com/wllfaria/terml/blob/${version}/CHANGES.md";
+    description = "Terminal manipulation library in pure Ocaml";
+    homepage = "https://github.com/wllfaria/terml";
+    license = lib.licenses.mit;
+    maintainers = [ lib.maintainers.PhilVoel ];
+  };
+}

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

···
   buildPythonPackage,
   fetchPypi,
   autoconf,
-  cython_0,
+  automake,
+  cython,
+  pkg-config,
   setuptools,
 }:
 
 buildPythonPackage rec {
   pname = "dtlssocket";
-  version = "0.1.19";
-
-  format = "pyproject";
+  version = "0.2.2";
+  pyproject = true;
 
   src = fetchPypi {
-    pname = "DTLSSocket";
-    inherit version;
-    hash = "sha256-hKwWkQ/K+FTgn2Gs8Pynz/ihuVeO8grqekPPbGK5eDI=";
+    inherit pname version;
+    hash = "sha256-TnbXFXJuDEbcCeNdqbZxewY8I4mwbBcj3sw7o4tzh/Q=";
   };
 
+  build-system = [
+    cython
+    setuptools
+  ];
+
   nativeBuildInputs = [
     autoconf
-    cython_0
-    setuptools
+    automake
+    pkg-config
   ];
 
   # no tests on PyPI, no tags on GitLab

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

···
 
 buildPythonPackage rec {
   pname = "fastcore";
-  version = "1.7.4";
+  version = "1.7.5";
   pyproject = true;
 
   disabled = pythonOlder "3.8";
···
     owner = "fastai";
     repo = "fastcore";
     rev = "refs/tags/${version}";
-    hash = "sha256-pm/8YRefobh7urVWiAlb05COQbaBrXB70buDmuKY/qc=";
+    hash = "sha256-4u1vjuUANWgJXQ4iG3Md2oIDxlz/6TOcDOYjlnsgqnU=";
   };
 
   build-system = [ setuptools ];

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

···
 {
   lib,
+  stdenv,
   buildPythonPackage,
   fetchFromGitHub,
   pythonOlder,
···
     changelog = "https://github.com/pytorch/ignite/releases/tag/v${version}";
     license = lib.licenses.bsd3;
     maintainers = [ lib.maintainers.bcdarwin ];
+    # ModuleNotFoundError: No module named 'torch._C._distributed_c10d'; 'torch._C' is not a package
+    broken = stdenv.isDarwin;
   };
 }

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

···
 
 buildPythonPackage rec {
   pname = "litellm";
-  version = "1.44.7";
+  version = "1.44.22";
   pyproject = true;
 
   disabled = pythonOlder "3.8";
···
     owner = "BerriAI";
     repo = "litellm";
     rev = "refs/tags/v${version}";
-    hash = "sha256-qEO5QWaW3Nd/zKNjZ31e5y5hNc55qZGDYCD66z+ftUk=";
+    hash = "sha256-0F972vEW6ebbbaJ6c0db3cDtFJIRUN81Gp0OMo0fgqY=";
   };
 
   build-system = [ poetry-core ];

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

···
     };
   };
 
-  withPlugins =
-    plugins:
-    buildPythonApplication {
-      inherit (llm) pname version;
-      format = "other";
-
-      disabled = pythonOlder "3.8";
-
-      dontUnpack = true;
-      dontBuild = true;
-      doCheck = false;
-
-      nativeBuildInputs = [ makeWrapper ];
-
-      installPhase = ''
-        makeWrapper ${llm}/bin/llm $out/bin/llm \
-          --prefix PYTHONPATH : "${llm}/${python.sitePackages}:$PYTHONPATH"
-        ln -sfv ${llm}/lib $out/lib
-      '';
-
-      propagatedBuildInputs = llm.propagatedBuildInputs ++ plugins;
-
-      passthru = llm.passthru // {
-        withPlugins = morePlugins: withPlugins (morePlugins ++ plugins);
-      };
+  withPlugins = throw ''
+    llm.withPlugins was confusing to use and has been removed.
+    Please migrate to using python3.withPackages(ps: [ ps.llm ]) instead.
 
-      inherit (llm) meta;
-    };
+    See https://nixos.org/manual/nixpkgs/stable/#python.withpackages-function for more usage examples.
+  '';
 in
 llm

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

···
 
 buildPythonPackage rec {
   pname = "marimo";
-  version = "0.8.11";
+  version = "0.8.13";
   pyproject = true;
 
   disabled = pythonOlder "3.8";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-JHlzyQS7zleHUF6NW8oQ2fULdGuI+Y+vuWfiUO/YCm8=";
+    hash = "sha256-x1f71IaFO/LVNmgCS/eKa/Ia/KETToGexLK1FD3gWZM=";
   };
 
   build-system = [ setuptools ];

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

···
 
 buildPythonPackage rec {
   pname = "nextdns";
-  version = "3.2.0";
+  version = "3.3.0";
   pyproject = true;
 
   disabled = pythonOlder "3.11";
···
     owner = "bieniu";
     repo = "nextdns";
     rev = "refs/tags/${version}";
-    hash = "sha256-/gBNJYCkDQ5SeM4q/4rWdsSldrMeo5GdUBaG57NiEIY=";
+    hash = "sha256-WNdS8sAW7Ci8w8diYIsrVADvpgMSDuM0NLBTw7irzKg=";
   };
 
   build-system = [ setuptools ];

pkgs/development/python-modules/snakemake-storage-plugin-fs/default.nix

···
+{
+  lib,
+  buildPythonPackage,
+  fetchFromGitHub,
+  poetry-core,
+  snakemake,
+  snakemake-interface-storage-plugins,
+  snakemake-interface-common,
+  sysrsync,
+}:
+
+buildPythonPackage rec {
+  pname = "snakemake-storage-plugin-fs";
+  version = "1.0.6";
+  pyproject = true;
+
+  src = fetchFromGitHub {
+    owner = "snakemake";
+    repo = pname;
+    rev = "refs/tags/v${version}";
+    hash = "sha256-9A2W+V0d9K1Ei4WXqIZfIcOYsWgpGVP7P/ANy8jOGu0=";
+  };
+
+  build-system = [ poetry-core ];
+
+  dependencies = [
+    snakemake-interface-storage-plugins
+    snakemake-interface-common
+    sysrsync
+  ];
+
+  # The current tests are not worth dealing with cyclic dependency on snakemake
+  doCheck = false;
+
+  # Use nothing due to a cyclic dependency on snakemake
+  pythonImportsCheck = [ ];
+
+  meta = with lib; {
+    description = "A Snakemake storage plugin that reads and writes from a locally mounted filesystem using rsync";
+    homepage = "https://github.com/snakemake/snakemake-storage-plugin-fs";
+    license = licenses.mit;
+    maintainers = with maintainers; [ veprbl ];
+  };
+}

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

···
+{
+  lib,
+  buildPythonPackage,
+  fetchFromGitHub,
+  poetry-core,
+  setuptools,
+  rsync,
+  toml,
+}:
+
+buildPythonPackage rec {
+  pname = "sysrsync";
+  version = "1.1.1";
+  pyproject = true;
+
+  src = fetchFromGitHub {
+    owner = "gchamon";
+    repo = pname;
+    rev = "refs/tags/${version}";
+    hash = "sha256-2Sz3JrNmIGOnad+qjRzbAgsFEzDtwBT0KLEFyQKZra4=";
+  };
+
+  postPatch = ''
+    substituteInPlace sysrsync/command_maker.py \
+      --replace-fail "'rsync'" "'${rsync}/bin/rsync'"
+  '';
+
+  build-system = [
+    poetry-core
+    setuptools
+  ];
+
+  dependencies = [
+    toml
+  ];
+
+  pythonImportsCheck = [ "sysrsync" ];
+
+  meta = with lib; {
+    description = "Simple and safe system's rsync wrapper for Python";
+    homepage = "https://github.com/gchamon/sysrsync";
+    license = licenses.mit;
+    maintainers = with maintainers; [ veprbl ];
+  };
+}

pkgs/development/tools/analysis/checkstyle/default.nix

···
 { lib, stdenvNoCC, fetchurl, makeBinaryWrapper, jre }:
 
 stdenvNoCC.mkDerivation rec {
-  version = "10.17.0";
+  version = "10.18.1";
   pname = "checkstyle";
 
   src = fetchurl {
     url = "https://github.com/checkstyle/checkstyle/releases/download/checkstyle-${version}/checkstyle-${version}-all.jar";
-    sha256 = "sha256-UcNNc4UgwTidcZmKmrDm2r4NfPJiFJ8+AacpRJYGLkI=";
+    sha256 = "sha256-2nOh+jvi6CksU69cidNTVjOOIZTRQttpCOuf+KrILoM=";
   };
 
   nativeBuildInputs = [ makeBinaryWrapper ];

pkgs/development/tools/analysis/stylelint/default.nix

···
 
 buildNpmPackage rec {
   pname = "stylelint";
-  version = "16.8.1";
+  version = "16.9.0";
 
   src = fetchFromGitHub {
     owner = "stylelint";
     repo = "stylelint";
     rev = version;
-    hash = "sha256-LhLA1JxaTtdoXfylaDLiyW2gi0xy2l5Rm3B67+z1Wdc=";
+    hash = "sha256-yMj6X3VI/CKw1VdRXV+7FVJQ6rdZ4E4v069wJZq3+dg=";
   };
 
-  npmDepsHash = "sha256-xi6we8XOGaLqwTLrF0Enpx7jQgbHOSItuqzlvvNNBWQ=";
+  npmDepsHash = "sha256-Ylkx4FPsfEZTy1y2Be0RURHooAev0Z8ew3MJ2wOXjO4=";
 
   dontNpmBuild = true;
 

pkgs/development/tools/bundletool/default.nix

···
 
 stdenvNoCC.mkDerivation rec {
   pname = "bundletool";
-  version = "1.17.0";
+  version = "1.17.1";
 
   src = fetchurl {
     url = "https://github.com/google/bundletool/releases/download/${version}/bundletool-all-${version}.jar";
-    sha256 = "sha256-VOvuHx3oNn2a0mtGcr+yl2sLEhQuFdaD/HuOJU/GzBs=";
+    sha256 = "sha256-RYgerRM4iHLYLEJVsZVIi3/DPyysWpqXewr8XpI2dZI=";
   };
 
   dontUnpack = true;

pkgs/development/tools/container2wasm/default.nix

···
 
 buildGoModule rec {
   pname = "container2wasm";
-  version = "0.6.4";
+  version = "0.6.5";
 
   src = fetchFromGitHub {
     owner = "ktock";
     repo = "container2wasm";
     rev = "refs/tags/v${version}";
-    hash = "sha256-/E65h2kyzjtAnh72+zyxXf8OvxlUvXT/M25CPteUamE=";
+    hash = "sha256-PFgaqzl6uc6vHzcZ9+FpugAOFSBKhxAsoSvmYHxUmLs=";
   };
 
-  vendorHash = "sha256-/V2n9SpBtJVQwERJhSugvAvIoOGuZNnhaaf8k9hh04k=";
+  vendorHash = "sha256-j6oqYpFcfZy4Lz4C9wbJGI2RdJsAxQxBqcLNWgKk/UU=";
 
   ldflags = [
     "-s"

pkgs/development/tools/continuous-integration/jenkins/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "jenkins";
-  version = "2.462.1";
+  version = "2.462.2";
 
   src = fetchurl {
     url = "https://get.jenkins.io/war-stable/${version}/jenkins.war";
-    hash = "sha256-DyHCX9b6+0NfG1TTlTuiCoQl6ZWaNaeoQD6KARksDfw=";
+    hash = "sha256-DkyU06S9QFdtZ5HBJkzaZuRGjjeSnnxcs+Vs+lCANHQ=";
   };
 
   nativeBuildInputs = [ makeWrapper ];

pkgs/development/tools/djlint/default.nix

···
 
 python3.pkgs.buildPythonApplication rec {
   pname = "djlint";
-  version = "1.34.1";
+  version = "1.35.2";
   pyproject = true;
 
   src = fetchFromGitHub {
     owner = "Riverside-Healthcare";
     repo = "djlint";
     rev = "refs/tags/v${version}";
-    hash = "sha256-p9RIzX9zoZxBrhiNaIeCX9OgfQm/lXNwYsh6IcsnIVk=";
+    hash = "sha256-KdIK6SgOQiNc13Nzg6MI38BdkBdEClnMn1RcWvngP+A=";
   };
 
   build-system = with python3.pkgs; [

pkgs/development/tools/doctl/default.nix

···
 
 buildGoModule rec {
   pname = "doctl";
-  version = "1.109.1";
+  version = "1.112.0";
 
   vendorHash = null;
 
···
     owner = "digitalocean";
     repo = "doctl";
     rev = "v${version}";
-    sha256 = "sha256-K27K79OAQERREu5doQGhy87XV5Fz4uZWctsZj+GiON0=";
+    sha256 = "sha256-+s5kxP79ZWpJsm6yk26jLGSPJ3GkToPXfl2tX+a1A1U=";
   };
 
   meta = with lib; {

pkgs/development/tools/karate/default.nix

···
 
 stdenvNoCC.mkDerivation rec {
   pname = "karate";
-  version = "1.4.1";
+  version = "1.5.0";
 
   src = fetchurl {
     url = "https://github.com/karatelabs/karate/releases/download/v${version}/karate-${version}.jar";
-    sha256 = "sha256-3gNoXUchrfGkZC6UAfw2TXorzSlqnOZCe0gnuUHIIb4=";
+    sha256 = "sha256-3uz51dQvyvK7gcmRoUjfszghBaPfVc/SJaKSEWkfgr8=";
   };
   dontUnpack = true;
 

pkgs/development/tools/language-servers/jsonnet-language-server/default.nix

···
 
 buildGoModule rec {
   pname = "jsonnet-language-server";
-  version = "0.14.0";
+  version = "0.14.1";
 
   src = fetchFromGitHub {
     owner = "grafana";
     repo = "jsonnet-language-server";
     rev = "refs/tags/v${version}";
-    hash = "sha256-W9xfbZWM6KK8UTwP0SaeywIlUku0+64vjEyUFJFFS5M=";
+    hash = "sha256-GR5EjVd1Tje9FLyP0pfNT6hMUGYkfPnsT8M72H713D4=";
   };
 
   vendorHash = "sha256-rh+b089fr+z0YzgvzivzELnSbNDiNczGCRwFrIYR250=";

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

···
 
 buildGoModule rec {
   pname = "terramate";
-  version = "0.10.0";
+  version = "0.10.2";
 
   src = fetchFromGitHub {
     owner = "terramate-io";
     repo = "terramate";
     rev = "v${version}";
-    hash = "sha256-SAMtEo84P5sxQ3JFU4evt2ycL1tg2yrLoWipWi4KObE=";
+    hash = "sha256-z7G0oj6aJRUXVitj9f2hGTLOFPo0LcQyADKvMFsk9t0=";
   };
 
   vendorHash = "sha256-TOntPPtynr333rX0wlb2pIeEwcNzyWP3wFqPoMz6LK0=";

pkgs/development/tools/misc/universal-ctags/default.nix

···
     patchShebangs misc/*
   '';
 
+  # some tools like 'zoekt' want an unambiguous binary name, so give it to them
+  postInstall = ''
+    ln -s $out/bin/ctags $out/bin/universal-ctags
+  '';
+
   doCheck = true;
 
   checkFlags = [

pkgs/development/tools/summon/default.nix

···
 
 buildGoModule rec {
   pname = "summon";
-  version = "0.10.0";
+  version = "0.10.1";
 
   src = fetchFromGitHub {
     owner = "cyberark";
     repo = "summon";
     rev = "v${version}";
-    hash = "sha256-98dgsO/33tJ4hBwCwAdJBJCzWwnpbrSZPbqa5NSNmXM=";
+    hash = "sha256-Y61lVqsKZiHLJF0X4DIq6U7eRXJ0+6I/dBPwXYb2GmQ=";
   };
 
   vendorHash = "sha256-StcJvUtMfBh7p1sD8ucvHNJ572whRfqz3id6XsFoXtk=";

pkgs/development/tools/twilio-cli/default.nix

···
 
 stdenvNoCC.mkDerivation (finalAttrs: {
   pname = "twilio-cli";
-  version = "5.21.1";
+  version = "5.22.0";
 
   src = fetchzip {
     url = "https://twilio-cli-prod.s3.amazonaws.com/twilio-v${finalAttrs.version}/twilio-v${finalAttrs.version}.tar.gz";
-    hash = "sha256-0hriMtxmqjQrR/gAdOk8RfyPQp2ZYCdyt/sMTUqC1/4=";
+    hash = "sha256-6VGxfbo/44iOuG5VG1uevgeRrgP0ThyrNts1iR5VLCk=";
   };
 
   buildInputs = [ nodejs-slim ];

pkgs/games/crawl/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "crawl${lib.optionalString tileMode "-tiles"}";
-  version = "0.31.0";
+  version = "0.32.0";
 
   src = fetchFromGitHub {
     owner = "crawl";
     repo = "crawl";
     rev = version;
-    hash = "sha256-06tVEduk3Y2VDsoOuI4nGjN8p+wGZT7wEU80nBSg+UU=";
+    hash = "sha256-OHdFGSvDfpdachdnmvjhsUvuemBXINwls0Id7qwY9sA=";
   };
 
   # Patch hard-coded paths and remove force library builds

pkgs/games/doom-ports/dhewm3/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "dhewm3";
-  version = "1.5.3";
+  version = "1.5.4";
 
   src = fetchFromGitHub {
     owner = "dhewm";
     repo = "dhewm3";
     rev = version;
-    sha256 = "sha256-BFVadzN8qhdXTUqFVM7EIqHuW2yx1x+TSWC9+myGfP0=";
+    sha256 = "sha256-losqnxnjRPOczjrRPyyOxCeg9TNScXLcXADgo9Bxm5k=";
   };
 
   # Add libGLU libGL linking

pkgs/games/gemrb/default.nix

···
 in
 stdenv.mkDerivation rec {
   pname = "gemrb";
-  version = "0.9.2";
+  version = "0.9.3";
 
   src = fetchFromGitHub {
     owner = "gemrb";
     repo = "gemrb";
     rev = "v${version}";
-    hash = "sha256-riea48Jc9zYb19mf5sBunTp5l27PGRFd/B5KdCUWr6Y=";
+    hash = "sha256-n01Q/27iYXahBbUDFHW1Q3lPqCtTvhstUBgownZbKtg=";
   };
 
   buildInputs = [

pkgs/games/runelite/default.nix

···
 
 maven.buildMavenPackage rec {
   pname = "runelite";
-  version = "2.7.1";
+  version = "2.7.2";
 
   src = fetchFromGitHub {
     owner = "runelite";
     repo = "launcher";
     rev = version;
-    hash = "sha256-7T9n23qMl4IJQL7yWLXKvRzYcMeXDUwkY8MBFc2t3Rw=";
+    hash = "sha256-ckeZ/7rACyZ5j+zzC5hv1NaXTi9q/KvOzMPTDd1crHQ=";
   };
 
   mvnJdk = jdk17;

pkgs/games/space-station-14-launcher/deps.nix

···
 # Please dont edit it manually, your changes might get overwritten!
 
 { fetchNuGet }: [
-  (fetchNuGet { pname = "Avalonia"; version = "11.0.5"; sha256 = "1l8vpw7dmkgll197i42r98ikkl0g08469wkl1kxkcv8f0allgah6"; })
-  (fetchNuGet { pname = "Avalonia.Angle.Windows.Natives"; version = "2.1.0.2023020321"; sha256 = "1az4s1g22ipak9a3xfh55z2h3rm6lpqh7svbpw6ag4ysrgsjjsjd"; })
-  (fetchNuGet { pname = "Avalonia.BuildServices"; version = "0.0.29"; sha256 = "05mm7f0jssih3gbzqfgjnfq5cnqa85ihsg0z1897ciihv8qd3waq"; })
-  (fetchNuGet { pname = "Avalonia.Controls.ColorPicker"; version = "11.0.5"; sha256 = "0w1909yjg1s1h6zzxbfw1dazvlknpgk9v7d03ik7ihd14lxzr1i2"; })
-  (fetchNuGet { pname = "Avalonia.Controls.DataGrid"; version = "11.0.5"; sha256 = "14nr767zhxcqwis901sn5s9qala0wf2ip4pic3ncdvkhyhq6w9fs"; })
-  (fetchNuGet { pname = "Avalonia.Desktop"; version = "11.0.5"; sha256 = "1zqp8whkvm95zxhjpwska7rhkbxjfkv2fz3821pn782931pn59ah"; })
-  (fetchNuGet { pname = "Avalonia.Diagnostics"; version = "11.0.5"; sha256 = "1plr03dgq24gjlcx39qlbcg2ywh7in58yfkkq9snvnagh8yk3ifi"; })
-  (fetchNuGet { pname = "Avalonia.FreeDesktop"; version = "11.0.5"; sha256 = "0sn6c3mqvc62vhy8ssmz515wbcaq418qfrck67zysp2qzw5iyv9v"; })
-  (fetchNuGet { pname = "Avalonia.Native"; version = "11.0.5"; sha256 = "1n41g1z36sgvhfl7bdavc3j7ccr3qkbqjc4znimqazzyfifh0m99"; })
-  (fetchNuGet { pname = "Avalonia.ReactiveUI"; version = "11.0.5"; sha256 = "0dgycvkd53lnvx3g9s1w3yhgjg0hmph63za68issni0g1p48plgj"; })
-  (fetchNuGet { pname = "Avalonia.Remote.Protocol"; version = "11.0.5"; sha256 = "0a6a8lbpna3z5bcall7a953r3xjibcl90ic21gimwhipyp29sfn1"; })
-  (fetchNuGet { pname = "Avalonia.Skia"; version = "11.0.5"; sha256 = "008pqpim91i6mya0nfn3g9gclh0dw5mqmhi2fdalbh62sa8a18xc"; })
-  (fetchNuGet { pname = "Avalonia.Themes.Simple"; version = "11.0.5"; sha256 = "1i6xpihpw32i9mywzzhw0nyc2gkifmri6ylila21y8xb0jdazdyv"; })
-  (fetchNuGet { pname = "Avalonia.Win32"; version = "11.0.5"; sha256 = "03rbx4msnl8jvw1017wi88rxvgg8iz7idy7wajp3nzk9m0c4pilx"; })
-  (fetchNuGet { pname = "Avalonia.X11"; version = "11.0.5"; sha256 = "1bixdr5yzd9spyjc4n2kf1bwg52q3p5akj9xsr25xp310j3kgyxf"; })
-  (fetchNuGet { pname = "CodeHollow.FeedReader"; version = "1.2.6"; sha256 = "1ac98diww07cfs3cv142nlwzi9w3n2s5w7m60mkc0rpzg0vpq3mv"; })
-  (fetchNuGet { pname = "Dapper"; version = "2.0.123"; sha256 = "15hxrchfgiqnmgf8fqhrf4pb4c8l9igg5qnkw9yk3rkagcqfkk91"; })
-  (fetchNuGet { pname = "DynamicData"; version = "7.13.1"; sha256 = "0hy2ba2nkhgp23glkinhfx3v892fkkf4cr9m41daaahnl2r2l8y1"; })
-  (fetchNuGet { pname = "Fody"; version = "6.6.4"; sha256 = "1hhdwj0ska7dvak9hki8cnyfmmw5r8yw8w24gzsdwhqx68dnrvsx"; })
-  (fetchNuGet { pname = "HarfBuzzSharp"; version = "2.8.2.3"; sha256 = "115aybicqs9ijjlcv6k6r5v0agkjm1bm1nkd0rj3jglv8s0xvmp2"; })
-  (fetchNuGet { pname = "HarfBuzzSharp.NativeAssets.Linux"; version = "2.8.2.3"; sha256 = "1f18ahwkaginrg0vwsi6s56lvnqvvxv7pzklfs5lnknasxy1a76z"; })
-  (fetchNuGet { pname = "HarfBuzzSharp.NativeAssets.macOS"; version = "2.8.2.3"; sha256 = "052d8frpkj4ijs6fm6xp55xbv95b1s9biqwa0w8zp3rgm88m9236"; })
-  (fetchNuGet { pname = "HarfBuzzSharp.NativeAssets.WebAssembly"; version = "2.8.2.3"; sha256 = "043hv36bg5240znbm8x5la7py17m4jfzy57q3ka32f6zjld83j36"; })
-  (fetchNuGet { pname = "HarfBuzzSharp.NativeAssets.Win32"; version = "2.8.2.3"; sha256 = "08khd2jqm8sw58ljz5srangzfm2sz3gd2q1jzc5fr80lj8rv6r74"; })
-  (fetchNuGet { pname = "JetBrains.Annotations"; version = "2023.2.0-eap3"; sha256 = "12fkafmx2h1h4av04lc5d8x4v3vw3pnva5vw872r3w8w6ws85r5k"; })
-  (fetchNuGet { pname = "libsodium"; version = "1.0.18.2"; sha256 = "02xd4phd6wfixhdq48ma92c166absqw41vdq5kvjch8p0vc9cdl2"; })
-  (fetchNuGet { pname = "Linguini.Bundle"; version = "0.8.1"; sha256 = "1p7nn56yd4v4rx5k3x352vdsbvkvyn9lb1739dj111z3jpmw2aja"; })
-  (fetchNuGet { pname = "Linguini.Shared"; version = "0.8.0"; sha256 = "08q0p5wz6lf7ab7m18yj5wvwks10c9v3d83f6262wbvkmnms0w06"; })
-  (fetchNuGet { pname = "Linguini.Syntax"; version = "0.8.0"; sha256 = "0gfl8j9kdjxgz0iaxs35y801pxflk50kzlf0qq4z42jmh9swi4y7"; })
-  (fetchNuGet { pname = "MicroCom.Runtime"; version = "0.11.0"; sha256 = "0p9c3m0zk59x9dcqw077hzd2yk60myisbacvm36mnwpcjwzjkp2m"; })
-  (fetchNuGet { pname = "Microsoft.CodeAnalysis.Analyzers"; version = "3.0.0"; sha256 = "0bbl0jpqywqmzz2gagld1p2gvdfldjfjmm25hil9wj2nq1zc4di8"; })
-  (fetchNuGet { pname = "Microsoft.CodeAnalysis.Common"; version = "3.8.0"; sha256 = "12n7rvr39bzkf2maw7zplw8rwpxpxss4ich3bb2pw770rx4nyvyw"; })
-  (fetchNuGet { pname = "Microsoft.CodeAnalysis.CSharp"; version = "3.8.0"; sha256 = "1kmry65csvfn72zzc16vj1nfbfwam28wcmlrk3m5rzb8ydbzgylb"; })
-  (fetchNuGet { pname = "Microsoft.CodeAnalysis.CSharp.Scripting"; version = "3.8.0"; sha256 = "0w0yx0lpg54iw5jazqk46h48gx43ij32gwac8iywdj6kxfxm03vw"; })
-  (fetchNuGet { pname = "Microsoft.CodeAnalysis.Scripting.Common"; version = "3.8.0"; sha256 = "0hjgxcsj5zy27lqk0986m59n5dbplx2vjjla2lsvg4bwg8qa7bpk"; })
-  (fetchNuGet { pname = "Microsoft.CSharp"; version = "4.3.0"; sha256 = "0gw297dgkh0al1zxvgvncqs0j15lsna9l1wpqas4rflmys440xvb"; })
-  (fetchNuGet { pname = "Microsoft.Data.Sqlite.Core"; version = "7.0.4"; sha256 = "0mhfj8bj8dlc01y20ihq6j9r59f67cry6yd6qi6rg9zh93m43jpv"; })
-  (fetchNuGet { pname = "Microsoft.NET.ILLink.Tasks"; version = "8.0.0"; sha256 = "13y3bilk9rrrgsk9abks7xvpwp12zw150xcyi0diig2hqswys1h4"; })
-  (fetchNuGet { pname = "Microsoft.NETCore.Platforms"; version = "1.1.0"; sha256 = "08vh1r12g6ykjygq5d3vq09zylgb84l63k49jc4v8faw9g93iqqm"; })
-  (fetchNuGet { pname = "Microsoft.NETCore.Platforms"; version = "2.1.2"; sha256 = "1507hnpr9my3z4w1r6xk5n0s1j3y6a2c2cnynj76za7cphxi1141"; })
-  (fetchNuGet { pname = "Microsoft.NETCore.Targets"; version = "1.1.0"; sha256 = "193xwf33fbm0ni3idxzbr5fdq3i2dlfgihsac9jj7whj0gd902nh"; })
-  (fetchNuGet { pname = "Microsoft.Toolkit.Mvvm"; version = "7.1.2"; sha256 = "0hrlgjr41hlpp3hb697i0513x2cm4ysbl0wj4bj67md604cmkv14"; })
-  (fetchNuGet { pname = "Microsoft.Win32.SystemEvents"; version = "6.0.0"; sha256 = "0c6pcj088g1yd1vs529q3ybgsd2vjlk5y1ic6dkmbhvrp5jibl9p"; })
-  (fetchNuGet { pname = "Mono.Posix.NETStandard"; version = "1.0.0"; sha256 = "0xlja36hwpjm837haq15mjh2prcf68lyrmn72nvgpz8qnf9vappw"; })
-  (fetchNuGet { pname = "NSec.Cryptography"; version = "22.4.0"; sha256 = "0v89wyvl58ia8r74wn3shajs1ia0rgx1p60nlr87g7ys6lq7ql2d"; })
-  (fetchNuGet { pname = "ReactiveUI"; version = "18.4.26"; sha256 = "0xhj4vk64smjfw7sr2gqxvradqbgky6jgfryq8q85h1hz10r7xaa"; })
-  (fetchNuGet { pname = "ReactiveUI.Fody"; version = "18.4.26"; sha256 = "0i79ajjmibg10cardpq9qh5wy1b4ngvb2v33fr4c5pf1y65xzhmr"; })
-  (fetchNuGet { pname = "Robust.Natives"; version = "0.1.1"; sha256 = "1spfaxk8nsx368zncdcj0b3kg7gj7h14mjji19xrraf8ij0dnczw"; })
-  (fetchNuGet { pname = "Robust.Natives.Angle"; version = "0.1.1-chromium4758"; sha256 = "0awydljd6psr0w661p9q73pg2aa29lfb4i0arkpszl0ra33mhrah"; })
-  (fetchNuGet { pname = "Robust.Natives.Fluidsynth"; version = "0.1.0"; sha256 = "00nkww5sjixs1dmn979niq0hrhplcpabrp18bmpm240wl53ay72x"; })
-  (fetchNuGet { pname = "Robust.Natives.Freetype"; version = "0.1.0"; sha256 = "0skrj5bj5vlxvmp8wg8ar8n393w1vv1bs64hwas7svxf2adwgrw2"; })
-  (fetchNuGet { pname = "Robust.Natives.Glfw"; version = "0.1.0"; sha256 = "0xfak1d76jmr4ajfzclarna0x1c19xf4c3zfzhjn4vqmkk1znck0"; })
-  (fetchNuGet { pname = "Robust.Natives.OpenAL"; version = "0.1.0"; sha256 = "06waksj5rmc50xas4a2nmlj8v01kpwh5k367pcq2yjn0ld22klnx"; })
-  (fetchNuGet { pname = "Robust.Natives.Swnfd"; version = "0.1.0"; sha256 = "1ssnl6zasf2cdaffib4pzyfd1w962y1zmcsivyalgpsh6p4g9as1"; })
-  (fetchNuGet { pname = "Robust.Shared.AuthLib"; version = "0.1.2"; sha256 = "1vn19d81n8jdyy75ryrlajyxr0kp7pwjdlbyqcn8gcid5plrzmh0"; })
-  (fetchNuGet { pname = "runtime.any.System.Collections"; version = "4.3.0"; sha256 = "0bv5qgm6vr47ynxqbnkc7i797fdi8gbjjxii173syrx14nmrkwg0"; })
-  (fetchNuGet { pname = "runtime.any.System.Globalization"; version = "4.3.0"; sha256 = "1daqf33hssad94lamzg01y49xwndy2q97i2lrb7mgn28656qia1x"; })
-  (fetchNuGet { pname = "runtime.any.System.IO"; version = "4.3.0"; sha256 = "0l8xz8zn46w4d10bcn3l4yyn4vhb3lrj2zw8llvz7jk14k4zps5x"; })
-  (fetchNuGet { pname = "runtime.any.System.Reflection"; version = "4.3.0"; sha256 = "02c9h3y35pylc0zfq3wcsvc5nqci95nrkq0mszifc0sjx7xrzkly"; })
-  (fetchNuGet { pname = "runtime.any.System.Reflection.Extensions"; version = "4.3.0"; sha256 = "0zyri97dfc5vyaz9ba65hjj1zbcrzaffhsdlpxc9bh09wy22fq33"; })
-  (fetchNuGet { pname = "runtime.any.System.Reflection.Primitives"; version = "4.3.0"; sha256 = "0x1mm8c6iy8rlxm8w9vqw7gb7s1ljadrn049fmf70cyh42vdfhrf"; })
-  (fetchNuGet { pname = "runtime.any.System.Resources.ResourceManager"; version = "4.3.0"; sha256 = "03kickal0iiby82wa5flar18kyv82s9s6d4xhk5h4bi5kfcyfjzl"; })
-  (fetchNuGet { pname = "runtime.any.System.Runtime"; version = "4.3.0"; sha256 = "1cqh1sv3h5j7ixyb7axxbdkqx6cxy00p4np4j91kpm492rf4s25b"; })
-  (fetchNuGet { pname = "runtime.any.System.Runtime.Handles"; version = "4.3.0"; sha256 = "0bh5bi25nk9w9xi8z23ws45q5yia6k7dg3i4axhfqlnj145l011x"; })
-  (fetchNuGet { pname = "runtime.any.System.Runtime.InteropServices"; version = "4.3.0"; sha256 = "0c3g3g3jmhlhw4klrc86ka9fjbl7i59ds1fadsb2l8nqf8z3kb19"; })
-  (fetchNuGet { pname = "runtime.any.System.Text.Encoding"; version = "4.3.0"; sha256 = "0aqqi1v4wx51h51mk956y783wzags13wa7mgqyclacmsmpv02ps3"; })
-  (fetchNuGet { pname = "runtime.any.System.Threading.Tasks"; version = "4.3.0"; sha256 = "03mnvkhskbzxddz4hm113zsch1jyzh2cs450dk3rgfjp8crlw1va"; })
-  (fetchNuGet { pname = "runtime.debian.8-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "16rnxzpk5dpbbl1x354yrlsbvwylrq456xzpsha1n9y3glnhyx9d"; })
-  (fetchNuGet { pname = "runtime.fedora.23-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "0hkg03sgm2wyq8nqk6dbm9jh5vcq57ry42lkqdmfklrw89lsmr59"; })
-  (fetchNuGet { pname = "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "0c2p354hjx58xhhz7wv6div8xpi90sc6ibdm40qin21bvi7ymcaa"; })
-  (fetchNuGet { pname = "runtime.native.System"; version = "4.3.0"; sha256 = "15hgf6zaq9b8br2wi1i3x0zvmk410nlmsmva9p0bbg73v6hml5k4"; })
-  (fetchNuGet { pname = "runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "18pzfdlwsg2nb1jjjjzyb5qlgy6xjxzmhnfaijq5s2jw3cm3ab97"; })
-  (fetchNuGet { pname = "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "0qyynf9nz5i7pc26cwhgi8j62ps27sqmf78ijcfgzab50z9g8ay3"; })
-  (fetchNuGet { pname = "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "1klrs545awhayryma6l7g2pvnp9xy4z0r1i40r80zb45q3i9nbyf"; })
-  (fetchNuGet { pname = "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "0zcxjv5pckplvkg0r6mw3asggm7aqzbdjimhvsasb0cgm59x09l3"; })
-  (fetchNuGet { pname = "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "0vhynn79ih7hw7cwjazn87rm9z9fj0rvxgzlab36jybgcpcgphsn"; })
-  (fetchNuGet { pname = "runtime.ubuntu.14.04-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "160p68l2c7cqmyqjwxydcvgw7lvl1cr0znkw8fp24d1by9mqc8p3"; })
-  (fetchNuGet { pname = "runtime.ubuntu.16.04-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "15zrc8fgd8zx28hdghcj5f5i34wf3l6bq5177075m2bc2j34jrqy"; })
-  (fetchNuGet { pname = "runtime.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "1p4dgxax6p7rlgj4q73k73rslcnz4wdcv8q2flg1s8ygwcm58ld5"; })
-  (fetchNuGet { pname = "runtime.unix.System.Diagnostics.Debug"; version = "4.3.0"; sha256 = "1lps7fbnw34bnh3lm31gs5c0g0dh7548wfmb8zz62v0zqz71msj5"; })
-  (fetchNuGet { pname = "runtime.unix.System.Private.Uri"; version = "4.3.0"; sha256 = "1jx02q6kiwlvfksq1q9qr17fj78y5v6mwsszav4qcz9z25d5g6vk"; })
-  (fetchNuGet { pname = "runtime.unix.System.Runtime.Extensions"; version = "4.3.0"; sha256 = "0pnxxmm8whx38dp6yvwgmh22smknxmqs5n513fc7m4wxvs1bvi4p"; })
-  (fetchNuGet { pname = "Serilog"; version = "2.12.0"; sha256 = "0lqxpc96qcjkv9pr1rln7mi4y7n7jdi4vb36c2fv3845w1vswgr4"; })
-  (fetchNuGet { pname = "Serilog.Sinks.Console"; version = "4.1.0"; sha256 = "1rpkphmqfh3bv3m7v1zwz88wz4sirj4xqyff9ga0c6bqhblj6wii"; })
-  (fetchNuGet { pname = "Serilog.Sinks.File"; version = "5.0.0"; sha256 = "097rngmgcrdfy7jy8j7dq3xaq2qky8ijwg0ws6bfv5lx0f3vvb0q"; })
-  (fetchNuGet { pname = "SharpZstd.Interop"; version = "1.5.2-beta2"; sha256 = "1145jlprsgll8ixwib0i8phc6jsv6nm4yki4wi1bkxx2bgf9yjay"; })
-  (fetchNuGet { pname = "SkiaSharp"; version = "2.88.6"; sha256 = "0xs11zjw9ha68maw3l825kfwlrid43qwy0mswljxhpjh0y1k6k6b"; })
-  (fetchNuGet { pname = "SkiaSharp.NativeAssets.Linux"; version = "2.88.6"; sha256 = "0cg38xgddww1y93xrnbfn40sin63yl39j5zm7gm5pdgp5si0cf2n"; })
-  (fetchNuGet { pname = "SkiaSharp.NativeAssets.macOS"; version = "2.88.6"; sha256 = "1fp9h8c8k6sbsh48b69dc6461isd4dajq7yw5i7j6fhkas78q4zf"; })
-  (fetchNuGet { pname = "SkiaSharp.NativeAssets.WebAssembly"; version = "2.88.6"; sha256 = "02wpxwqwknhdhkl00in766samqfzi7r6jmhxs4d047v0fmygv1h8"; })
-  (fetchNuGet { pname = "SkiaSharp.NativeAssets.Win32"; version = "2.88.6"; sha256 = "1w2mwcwkqvrg4x4ybc4674xnkqwh1n2ihg520gqgpnqfc11ghc4n"; })
-  (fetchNuGet { pname = "SpaceWizards.Sodium"; version = "0.2.1"; sha256 = "059slmfg8diivd7hv53cp24vvrzfviqp6fyg8135azynyxk787fp"; })
-  (fetchNuGet { pname = "SpaceWizards.Sodium.Interop"; version = "1.0.18-beta4"; sha256 = "1w59i27z2xdvdflfbnq2braas5f4gpkq9m1xcmc1961hm97z1wvn"; })
-  (fetchNuGet { pname = "Splat"; version = "14.6.8"; sha256 = "1nj0bsqcr93n8jdyb1all8l35gydlgih67kr7cs1bc12l18fwx2w"; })
-  (fetchNuGet { pname = "SQLitePCLRaw.bundle_e_sqlite3"; version = "2.1.4"; sha256 = "0shdspl9cm71wwqg9103s44r0l01r3sgnpxr523y4a0wlgac50g0"; })
-  (fetchNuGet { pname = "SQLitePCLRaw.core"; version = "2.1.4"; sha256 = "09akxz92qipr1cj8mk2hw99i0b81wwbwx26gpk21471zh543f8ld"; })
-  (fetchNuGet { pname = "SQLitePCLRaw.lib.e_sqlite3"; version = "2.1.4"; sha256 = "11l85ksv1ck46j8z08fyf0c3l572zmp9ynb7p5chm5iyrh8xwkkn"; })
-  (fetchNuGet { pname = "SQLitePCLRaw.provider.e_sqlite3"; version = "2.1.4"; sha256 = "0b8f51nrjkq0pmfzjaqk5rp7r0cp2lbdm2whynj3xsjklppzmn35"; })
-  (fetchNuGet { pname = "System.Collections"; version = "4.3.0"; sha256 = "19r4y64dqyrq6k4706dnyhhw7fs24kpp3awak7whzss39dakpxk9"; })
-  (fetchNuGet { pname = "System.Collections.Immutable"; version = "5.0.0"; sha256 = "1kvcllagxz2q92g81zkz81djkn2lid25ayjfgjalncyc68i15p0r"; })
-  (fetchNuGet { pname = "System.ComponentModel.Annotations"; version = "4.5.0"; sha256 = "1jj6f6g87k0iwsgmg3xmnn67a14mq88np0l1ys5zkxhkvbc8976p"; })
-  (fetchNuGet { pname = "System.Diagnostics.Debug"; version = "4.3.0"; sha256 = "00yjlf19wjydyr6cfviaph3vsjzg3d5nvnya26i2fvfg53sknh3y"; })
-  (fetchNuGet { pname = "System.Drawing.Common"; version = "6.0.0"; sha256 = "02n8rzm58dac2np8b3xw8ychbvylja4nh6938l5k2fhyn40imlgz"; })
-  (fetchNuGet { pname = "System.Dynamic.Runtime"; version = "4.3.0"; sha256 = "1d951hrvrpndk7insiag80qxjbf2y0y39y8h5hnq9612ws661glk"; })
-  (fetchNuGet { pname = "System.Globalization"; version = "4.3.0"; sha256 = "1cp68vv683n6ic2zqh2s1fn4c2sd87g5hpp6l4d4nj4536jz98ki"; })
-  (fetchNuGet { pname = "System.IO"; version = "4.3.0"; sha256 = "05l9qdrzhm4s5dixmx68kxwif4l99ll5gqmh7rqgw554fx0agv5f"; })
-  (fetchNuGet { pname = "System.IO.Pipelines"; version = "6.0.0"; sha256 = "08211lvckdsdbd67xz4f6cyk76cli565j0dby1grlc4k9bhwby65"; })
-  (fetchNuGet { pname = "System.Linq"; version = "4.3.0"; sha256 = "1w0gmba695rbr80l1k2h4mrwzbzsyfl2z4klmpbsvsg5pm4a56s7"; })
-  (fetchNuGet { pname = "System.Linq.Expressions"; version = "4.3.0"; sha256 = "0ky2nrcvh70rqq88m9a5yqabsl4fyd17bpr63iy2mbivjs2nyypv"; })
-  (fetchNuGet { pname = "System.Memory"; version = "4.5.3"; sha256 = "0naqahm3wljxb5a911d37mwjqjdxv9l0b49p5dmfyijvni2ppy8a"; })
-  (fetchNuGet { pname = "System.Memory"; version = "4.5.4"; sha256 = "14gbbs22mcxwggn0fcfs1b062521azb9fbb7c113x0mq6dzq9h6y"; })
-  (fetchNuGet { pname = "System.Net.Http.WinHttpHandler"; version = "8.0.0"; sha256 = "0lqg9zfqcz18r34sgz7x50dsxbikh0lp8pdkb1y3m55gslmbj8n1"; })
-  (fetchNuGet { pname = "System.Numerics.Vectors"; version = "4.5.0"; sha256 = "1kzrj37yzawf1b19jq0253rcs8hsq1l2q8g69d7ipnhzb0h97m59"; })
-  (fetchNuGet { pname = "System.ObjectModel"; version = "4.3.0"; sha256 = "191p63zy5rpqx7dnrb3h7prvgixmk168fhvvkkvhlazncf8r3nc2"; })
-  (fetchNuGet { pname = "System.Private.Uri"; version = "4.3.0"; sha256 = "04r1lkdnsznin0fj4ya1zikxiqr0h6r6a1ww2dsm60gqhdrf0mvx"; })
-  (fetchNuGet { pname = "System.Reactive"; version = "5.0.0"; sha256 = "1lafmpnadhiwxyd543kraxa3jfdpm6ipblxrjlibym9b1ykpr5ik"; })
-  (fetchNuGet { pname = "System.Reflection"; version = "4.3.0"; sha256 = "0xl55k0mw8cd8ra6dxzh974nxif58s3k1rjv1vbd7gjbjr39j11m"; })
-  (fetchNuGet { pname = "System.Reflection.Emit"; version = "4.3.0"; sha256 = "11f8y3qfysfcrscjpjym9msk7lsfxkk4fmz9qq95kn3jd0769f74"; })
-  (fetchNuGet { pname = "System.Reflection.Emit.ILGeneration"; version = "4.3.0"; sha256 = "0w1n67glpv8241vnpz1kl14sy7zlnw414aqwj4hcx5nd86f6994q"; })
-  (fetchNuGet { pname = "System.Reflection.Emit.Lightweight"; version = "4.3.0"; sha256 = "0ql7lcakycrvzgi9kxz1b3lljd990az1x6c4jsiwcacrvimpib5c"; })
-  (fetchNuGet { pname = "System.Reflection.Extensions"; version = "4.3.0"; sha256 = "02bly8bdc98gs22lqsfx9xicblszr2yan7v2mmw3g7hy6miq5hwq"; })
-  (fetchNuGet { pname = "System.Reflection.Metadata"; version = "5.0.0"; sha256 = "17qsl5nanlqk9iz0l5wijdn6ka632fs1m1fvx18dfgswm258r3ss"; })
-  (fetchNuGet { pname = "System.Reflection.Primitives"; version = "4.3.0"; sha256 = "04xqa33bld78yv5r93a8n76shvc8wwcdgr1qvvjh959g3rc31276"; })
-  (fetchNuGet { pname = "System.Reflection.TypeExtensions"; version = "4.3.0"; sha256 = "0y2ssg08d817p0vdag98vn238gyrrynjdj4181hdg780sif3ykp1"; })
-  (fetchNuGet { pname = "System.Resources.ResourceManager"; version = "4.3.0"; sha256 = "0sjqlzsryb0mg4y4xzf35xi523s4is4hz9q4qgdvlvgivl7qxn49"; })
-  (fetchNuGet { pname = "System.Runtime"; version = "4.3.0"; sha256 = "066ixvgbf2c929kgknshcxqj6539ax7b9m570cp8n179cpfkapz7"; })
-  (fetchNuGet { pname = "System.Runtime.CompilerServices.Unsafe"; version = "4.7.1"; sha256 = "119br3pd85lq8zcgh4f60jzmv1g976q1kdgi3hvqdlhfbw6siz2j"; })
-  (fetchNuGet { pname = "System.Runtime.Extensions"; version = "4.3.0"; sha256 = "1ykp3dnhwvm48nap8q23893hagf665k0kn3cbgsqpwzbijdcgc60"; })
-  (fetchNuGet { pname = "System.Runtime.Handles"; version = "4.3.0"; sha256 = "0sw2gfj2xr7sw9qjn0j3l9yw07x73lcs97p8xfc9w1x9h5g5m7i8"; })
-  (fetchNuGet { pname = "System.Runtime.InteropServices"; version = "4.3.0"; sha256 = "00hywrn4g7hva1b2qri2s6rabzwgxnbpw9zfxmz28z09cpwwgh7j"; })
-  (fetchNuGet { pname = "System.Text.Encoding"; version = "4.3.0"; sha256 = "1f04lkir4iladpp51sdgmis9dj4y8v08cka0mbmsy0frc9a4gjqr"; })
-  (fetchNuGet { pname = "System.Text.Encoding.CodePages"; version = "4.5.1"; sha256 = "1z21qyfs6sg76rp68qdx0c9iy57naan89pg7p6i3qpj8kyzn921w"; })
-  (fetchNuGet { pname = "System.Threading"; version = "4.3.0"; sha256 = "0rw9wfamvhayp5zh3j7p1yfmx9b5khbf4q50d8k5rk993rskfd34"; })
-  (fetchNuGet { pname = "System.Threading.Tasks"; version = "4.3.0"; sha256 = "134z3v9abw3a6jsw17xl3f6hqjpak5l682k2vz39spj4kmydg6k7"; })
-  (fetchNuGet { pname = "System.Threading.Tasks.Extensions"; version = "4.5.4"; sha256 = "0y6ncasgfcgnjrhynaf0lwpkpkmv4a07sswwkwbwb5h7riisj153"; })
-  (fetchNuGet { pname = "TerraFX.Interop.Windows"; version = "10.0.22621.1"; sha256 = "0qbiaczssgd28f1kb1zz1g0fqsizv36qr2lbjmdrd1lfsyp2a2nj"; })
-  (fetchNuGet { pname = "Tmds.DBus.Protocol"; version = "0.15.0"; sha256 = "0d99kcs7r9cp6gpyc7z230czkkyx4164x86dhy0mca73f2ykc2g2"; })
-  (fetchNuGet { pname = "YamlDotNet"; version = "13.0.2"; sha256 = "031pvc6idvjyrn1bfdn8zaljrndp5ch7fkcn82f06332gqs3n8k8"; })
+  (fetchNuGet { pname = "Avalonia"; version = "11.0.5"; hash = "sha256-BqpHqQIObTb7DHTyZAgCD9A5I0pZkHhSoPTN2g6/G9E="; })
+  (fetchNuGet { pname = "Avalonia.Angle.Windows.Natives"; version = "2.1.0.2023020321"; hash = "sha256-TWop9cvak6cMv2vrA/GlpuYBxS8Fuj5UmupGIV7Q5Ks="; })
+  (fetchNuGet { pname = "Avalonia.BuildServices"; version = "0.0.29"; hash = "sha256-WPHRMNowRnYSCh88DWNBCltWsLPyOfzXGzBqLYE7tRY="; })
+  (fetchNuGet { pname = "Avalonia.Controls.ColorPicker"; version = "11.0.5"; hash = "sha256-Iob8OyWhwXhmHKCdnea7dtL9VQvcrf6/gUGHJ30CKXA="; })
+  (fetchNuGet { pname = "Avalonia.Controls.DataGrid"; version = "11.0.5"; hash = "sha256-2iVuMPRw7sbsYPGSG4XjQFGFky5WB5B05Jh1+I852ZI="; })
+  (fetchNuGet { pname = "Avalonia.Desktop"; version = "11.0.5"; hash = "sha256-UKVibxhJoGNvEGh8J/Z0sq8J81FT8yth/yXVPSFHF/8="; })
+  (fetchNuGet { pname = "Avalonia.Diagnostics"; version = "11.0.5"; hash = "sha256-0cUxPYJP2W11wnM6j4qNB3IvHlsUp9EZlY8I/NoAmd4="; })
+  (fetchNuGet { pname = "Avalonia.FreeDesktop"; version = "11.0.5"; hash = "sha256-O20fC/9YXO3/MZNlh1EgWLHFSyi/ao083MKwjetgxmo="; })
+  (fetchNuGet { pname = "Avalonia.Native"; version = "11.0.5"; hash = "sha256-KVUAXXT+f4VrtJ8widfEIzN25GBbtXWog/tpM354gdg="; })
+  (fetchNuGet { pname = "Avalonia.ReactiveUI"; version = "11.0.5"; hash = "sha256-8tGLyA0PRKt1REb9YeCtEDz5oB886PRG35aO0uZm/jU="; })
+  (fetchNuGet { pname = "Avalonia.Remote.Protocol"; version = "11.0.5"; hash = "sha256-wTqdxPU3Ql7jC4JFkChbUfaRR0nqUKrYKn8oexdFyig="; })
+  (fetchNuGet { pname = "Avalonia.Skia"; version = "11.0.5"; hash = "sha256-rKOgkNLCwEVVcyLCimvhDUDKXnrDOguUryaGVOPFFwE="; })
+  (fetchNuGet { pname = "Avalonia.Themes.Simple"; version = "11.0.5"; hash = "sha256-27evmgSrIx+EopF6E3N1cT7BvAUc/s99TVEMfmG83cQ="; })
+  (fetchNuGet { pname = "Avalonia.Win32"; version = "11.0.5"; hash = "sha256-ncZLGKhpfjuuVPz4Fs+P6L3dM0KRnwAC3xJRqyvpKw8="; })
+  (fetchNuGet { pname = "Avalonia.X11"; version = "11.0.5"; hash = "sha256-rvs3hwRh3F5E1j3JqcodWJTHV3BTWMKkvzq170tuPa4="; })
+  (fetchNuGet { pname = "CodeHollow.FeedReader"; version = "1.2.6"; hash = "sha256-uw58N3j/ZsBmBaYeXrSwg6f4ObWChM2GduwAzmNDiak="; })
+  (fetchNuGet { pname = "Dapper"; version = "2.0.123"; hash = "sha256-Ic3pMHtq5jF94tPi8l5MFDGyLnEZYofcqxbH5yDLHZY="; })
+  (fetchNuGet { pname = "DynamicData"; version = "7.13.1"; hash = "sha256-wSMqsqAWKqVaIDVlRtycTiS0R3fQxknfEPfBaYVawkM="; })
+  (fetchNuGet { pname = "Fody"; version = "6.6.4"; hash = "sha256-Xe9sGzIdQ970f0RwxD3KhdfqvGUoTpim2u2oqYHkDcI="; })
+  (fetchNuGet { pname = "HarfBuzzSharp"; version = "2.8.2.3"; hash = "sha256-4tbdgUabPjlkBm3aUFeocj4Fdslmms2olDFpzOLyqoQ="; })
+  (fetchNuGet { pname = "HarfBuzzSharp.NativeAssets.Linux"; version = "2.8.2.3"; hash = "sha256-3xwVfNfKTkuLdnT+e3bfG9tNTdEmar7ByzY+NTlUKLg="; })
+  (fetchNuGet { pname = "HarfBuzzSharp.NativeAssets.macOS"; version = "2.8.2.3"; hash = "sha256-ZohUEaovj/sRB4rjuJIOq6S9eim3m+qMlpHIebNDTRQ="; })
+  (fetchNuGet { pname = "HarfBuzzSharp.NativeAssets.WebAssembly"; version = "2.8.2.3"; hash = "sha256-ZsiBGpXfODHUHPgU/50k9QR/j6Klo7rsB0SUt8zYcBA="; })
+  (fetchNuGet { pname = "HarfBuzzSharp.NativeAssets.Win32"; version = "2.8.2.3"; hash = "sha256-5GSzM5IUoOwK+zJg0d74WlT3n1VZly8pKlyjiqVocCI="; })
+  (fetchNuGet { pname = "JetBrains.Annotations"; version = "2023.2.0-eap3"; hash = "sha256-s+SCNDcc8ZHFQXwXte0dfI9NOmqFUQK2IjBA0atT04k="; })
+  (fetchNuGet { pname = "libsodium"; version = "1.0.18.2"; hash = "sha256-gjaW2AYXQSb3LLjtQDjWSxkTmEiqIoIb7NFx0+AlrQs="; })
+  (fetchNuGet { pname = "Linguini.Bundle"; version = "0.8.1"; hash = "sha256-SirB65XjhxBkS+OERZP1e+6l2xZl9DFLz2ST5k2x9tw="; })
+  (fetchNuGet { pname = "Linguini.Shared"; version = "0.8.0"; hash = "sha256-BnCgq61zLy6MMG6gNnZiIOjJNy/So1DPUsdR83m5ACM="; })
+  (fetchNuGet { pname = "Linguini.Syntax"; version = "0.8.0"; hash = "sha256-x5PIdYJVCvIJxsDRP0GZ1PUbAPJl6K4i+K/LNpNE1D0="; })
+  (fetchNuGet { pname = "MicroCom.Runtime"; version = "0.11.0"; hash = "sha256-VdwpP5fsclvNqJuppaOvwEwv2ofnAI5ZSz2V+UEdLF0="; })
+  (fetchNuGet { pname = "Microsoft.CodeAnalysis.Analyzers"; version = "3.0.0"; hash = "sha256-KDbCfsBWSJ5ohEXUKp1s1LX9xA2NPvXE/xVzj68EdC0="; })
+  (fetchNuGet { pname = "Microsoft.CodeAnalysis.Common"; version = "3.8.0"; hash = "sha256-3G9vSc/gHH7FWgOySLTut1+eEaf3H66qcPOvNPLOx4o="; })
+  (fetchNuGet { pname = "Microsoft.CodeAnalysis.CSharp"; version = "3.8.0"; hash = "sha256-i/r3V/No/VzqmJlWxpGoirvlbJDbBPa/ONZtzYrxuc4="; })
+  (fetchNuGet { pname = "Microsoft.CodeAnalysis.CSharp.Scripting"; version = "3.8.0"; hash = "sha256-fA9Qu+vTyMZ9REzxJ4aMg/SHCDRk4q9k4ZGUdynoHnA="; })
+  (fetchNuGet { pname = "Microsoft.CodeAnalysis.Scripting.Common"; version = "3.8.0"; hash = "sha256-866jMHp8kbc1FYpKuUWnd7ViU6kGJTAxPcL/IjXrT0I="; })
+  (fetchNuGet { pname = "Microsoft.CSharp"; version = "4.3.0"; hash = "sha256-a3dAiPaVuky0wpcHmpTVtAQJNGZ2v91/oArA+dpJgj8="; })
+  (fetchNuGet { pname = "Microsoft.Data.Sqlite.Core"; version = "7.0.4"; hash = "sha256-+8pB6kjwp5dNxKZ54zM7xqWSkzQYRiB8AIw2JBeSDlY="; })
+  (fetchNuGet { pname = "Microsoft.NET.ILLink.Tasks"; version = "8.0.0"; hash = "sha256-BAbtucZQvBgbiJ51UAL/Ilx+dz96LpWmfjnnNGlcw48="; })
+  (fetchNuGet { pname = "Microsoft.NETCore.Platforms"; version = "1.1.0"; hash = "sha256-FeM40ktcObQJk4nMYShB61H/E8B7tIKfl9ObJ0IOcCM="; })
+  (fetchNuGet { pname = "Microsoft.NETCore.Platforms"; version = "2.1.2"; hash = "sha256-gYQQO7zsqG+OtN4ywYQyfsiggS2zmxw4+cPXlK+FB5Q="; })
+  (fetchNuGet { pname = "Microsoft.NETCore.Targets"; version = "1.1.0"; hash = "sha256-0AqQ2gMS8iNlYkrD+BxtIg7cXMnr9xZHtKAuN4bjfaQ="; })
+  (fetchNuGet { pname = "Microsoft.Toolkit.Mvvm"; version = "7.1.2"; hash = "sha256-JOxZGQGm1WPkIpIDurQnlYk+QgHxJLPguJfCQLJ8NEM="; })
+  (fetchNuGet { pname = "Microsoft.Win32.SystemEvents"; version = "6.0.0"; hash = "sha256-N9EVZbl5w1VnMywGXyaVWzT9lh84iaJ3aD48hIBk1zA="; })
+  (fetchNuGet { pname = "Mono.Posix.NETStandard"; version = "1.0.0"; hash = "sha256-/F61k7MY/fu2FcfW7CkyjuUroKwlYAXPQFVeDs1QknY="; })
+  (fetchNuGet { pname = "NSec.Cryptography"; version = "22.4.0"; hash = "sha256-TVB8MDXan3dQphaYG/rLQMWgpYJ6WE5ORiqiQrfnCW0="; })
+  (fetchNuGet { pname = "ReactiveUI"; version = "18.4.26"; hash = "sha256-SvWTQfgwwIIwwj67J42fb+Gm8u74iawPd7JqYuYmEnY="; })
+  (fetchNuGet { pname = "ReactiveUI.Fody"; version = "18.4.26"; hash = "sha256-ucLfi/HB3cJIdmNssfazZAXPC8QJ35YVA+GtWKVU6UQ="; })
+  (fetchNuGet { pname = "Robust.Natives"; version = "0.1.1"; hash = "sha256-/DPbgIzIqZx7ClHKSgI88p03xwKSNWY/MqNri2ZX7uo="; })
+  (fetchNuGet { pname = "Robust.Natives.Angle"; version = "0.1.1-chromium4758"; hash = "sha256-UGVYx1AZ0K/vzApEshxNQinx7jg43WAMB1lf0yRtnis="; })
+  (fetchNuGet { pname = "Robust.Natives.Fluidsynth"; version = "0.1.0"; hash = "sha256-XRyvRqEcEFFvXSjcvNRl9MIMAY42nWRrC7pHqQvn0wI="; })
+  (fetchNuGet { pname = "Robust.Natives.Freetype"; version = "0.1.0"; hash = "sha256-gufHmxKub3204pAYvcLegY80LMoKPY5u3Z3uIleReWo="; })
+  (fetchNuGet { pname = "Robust.Natives.Glfw"; version = "0.1.0"; hash = "sha256-YDL7w5wVb2Il/O4PRlxPgYUOlM2Ksu+kIrlKc1qYynU="; })
+  (fetchNuGet { pname = "Robust.Natives.OpenAL"; version = "0.1.0"; hash = "sha256-3dIpRKPASi8wu8eMWSC/M4CNJK1WKKJVB4XVXKSeihs="; })
+  (fetchNuGet { pname = "Robust.Natives.Swnfd"; version = "0.1.0"; hash = "sha256-Qav0yDVQ30eV31Gz+oMXJvHQnP+XrOicakw4rb6hVus="; })
+  (fetchNuGet { pname = "Robust.Shared.AuthLib"; version = "0.1.2"; hash = "sha256-ANaf6S0tsocsw37RJvk9d4LcvVQ0+1yO900iG1BLwe4="; })
+  (fetchNuGet { pname = "runtime.any.System.Collections"; version = "4.3.0"; hash = "sha256-4PGZqyWhZ6/HCTF2KddDsbmTTjxs2oW79YfkberDZS8="; })
+  (fetchNuGet { pname = "runtime.any.System.Globalization"; version = "4.3.0"; hash = "sha256-PaiITTFI2FfPylTEk7DwzfKeiA/g/aooSU1pDcdwWLU="; })
+  (fetchNuGet { pname = "runtime.any.System.IO"; version = "4.3.0"; hash = "sha256-vej7ySRhyvM3pYh/ITMdC25ivSd0WLZAaIQbYj/6HVE="; })
+  (fetchNuGet { pname = "runtime.any.System.Reflection"; version = "4.3.0"; hash = "sha256-ns6f++lSA+bi1xXgmW1JkWFb2NaMD+w+YNTfMvyAiQk="; })
+  (fetchNuGet { pname = "runtime.any.System.Reflection.Extensions"; version = "4.3.0"; hash = "sha256-Y2AnhOcJwJVYv7Rp6Jz6ma0fpITFqJW+8rsw106K2X8="; })
+  (fetchNuGet { pname = "runtime.any.System.Reflection.Primitives"; version = "4.3.0"; hash = "sha256-LkPXtiDQM3BcdYkAm5uSNOiz3uF4J45qpxn5aBiqNXQ="; })
+  (fetchNuGet { pname = "runtime.any.System.Resources.ResourceManager"; version = "4.3.0"; hash = "sha256-9EvnmZslLgLLhJ00o5MWaPuJQlbUFcUF8itGQNVkcQ4="; })
+  (fetchNuGet { pname = "runtime.any.System.Runtime"; version = "4.3.0"; hash = "sha256-qwhNXBaJ1DtDkuRacgHwnZmOZ1u9q7N8j0cWOLYOELM="; })
+  (fetchNuGet { pname = "runtime.any.System.Runtime.Handles"; version = "4.3.0"; hash = "sha256-PQRACwnSUuxgVySO1840KvqCC9F8iI9iTzxNW0RcBS4="; })
+  (fetchNuGet { pname = "runtime.any.System.Runtime.InteropServices"; version = "4.3.0"; hash = "sha256-Kaw5PnLYIiqWbsoF3VKJhy7pkpoGsUwn4ZDCKscbbzA="; })
+  (fetchNuGet { pname = "runtime.any.System.Text.Encoding"; version = "4.3.0"; hash = "sha256-Q18B9q26MkWZx68exUfQT30+0PGmpFlDgaF0TnaIGCs="; })
+  (fetchNuGet { pname = "runtime.any.System.Threading.Tasks"; version = "4.3.0"; hash = "sha256-agdOM0NXupfHbKAQzQT8XgbI9B8hVEh+a/2vqeHctg4="; })
+  (fetchNuGet { pname = "runtime.debian.8-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; hash = "sha256-LXUPLX3DJxsU1Pd3UwjO1PO9NM2elNEDXeu2Mu/vNps="; })
+  (fetchNuGet { pname = "runtime.fedora.23-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; hash = "sha256-qeSqaUI80+lqw5MK4vMpmO0CZaqrmYktwp6L+vQAb0I="; })
+  (fetchNuGet { pname = "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; hash = "sha256-SrHqT9wrCBsxILWtaJgGKd6Odmxm8/Mh7Kh0CUkZVzA="; })
+  (fetchNuGet { pname = "runtime.native.System"; version = "4.3.0"; hash = "sha256-ZBZaodnjvLXATWpXXakFgcy6P+gjhshFXmglrL5xD5Y="; })
+  (fetchNuGet { pname = "runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; hash = "sha256-Jy01KhtcCl2wjMpZWH+X3fhHcVn+SyllWFY8zWlz/6I="; })
+  (fetchNuGet { pname = "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; hash = "sha256-wyv00gdlqf8ckxEdV7E+Ql9hJIoPcmYEuyeWb5Oz3mM="; })
+  (fetchNuGet { pname = "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; hash = "sha256-zi+b4sCFrA9QBiSGDD7xPV27r3iHGlV99gpyVUjRmc4="; })
+  (fetchNuGet { pname = "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; hash = "sha256-gybQU6mPgaWV3rBG2dbH6tT3tBq8mgze3PROdsuWnX0="; })
+  (fetchNuGet { pname = "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; hash = "sha256-VsP72GVveWnGUvS/vjOQLv1U80H2K8nZ4fDAmI61Hm4="; })
+  (fetchNuGet { pname = "runtime.ubuntu.14.04-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; hash = "sha256-4yKGa/IrNCKuQ3zaDzILdNPD32bNdy6xr5gdJigyF5g="; })
+  (fetchNuGet { pname = "runtime.ubuntu.16.04-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; hash = "sha256-HmdJhhRsiVoOOCcUvAwdjpMRiyuSwdcgEv2j9hxi+Zc="; })
+  (fetchNuGet { pname = "runtime.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; hash = "sha256-pVFUKuPPIx0edQKjzRon3zKq8zhzHEzko/lc01V/jdw="; })
+  (fetchNuGet { pname = "runtime.unix.System.Diagnostics.Debug"; version = "4.3.0"; hash = "sha256-ReoazscfbGH+R6s6jkg5sIEHWNEvjEoHtIsMbpc7+tI="; })
+  (fetchNuGet { pname = "runtime.unix.System.Private.Uri"; version = "4.3.0"; hash = "sha256-c5tXWhE/fYbJVl9rXs0uHh3pTsg44YD1dJvyOA0WoMs="; })
+  (fetchNuGet { pname = "runtime.unix.System.Runtime.Extensions"; version = "4.3.0"; hash = "sha256-l8S9gt6dk3qYG6HYonHtdlYtBKyPb29uQ6NDjmrt3V4="; })
+  (fetchNuGet { pname = "Serilog"; version = "2.12.0"; hash = "sha256-JD+ud+CFoLGdYGasTWKTxx5PYj2W5pBv2lMybBK7HVM="; })
+  (fetchNuGet { pname = "Serilog.Sinks.Console"; version = "4.1.0"; hash = "sha256-MXIj6YJ4GQbUS8553InMUZPPEfr8h33q2GtAhyu88+Y="; })
+  (fetchNuGet { pname = "Serilog.Sinks.File"; version = "5.0.0"; hash = "sha256-GKy9hwOdlu2W0Rw8LiPyEwus+sDtSOTl8a5l9uqz+SQ="; })
+  (fetchNuGet { pname = "SharpZstd.Interop"; version = "1.5.2-beta2"; hash = "sha256-Xkmf3Fui97lC5CROT6o1W0vD4EURrMh7RJQ+nS+VhYQ="; })
+  (fetchNuGet { pname = "SkiaSharp"; version = "2.88.6"; hash = "sha256-y0wzgwdQXtgl5boCz/EgLWbK3SwC0cFVRUbBxOUPQXc="; })
+  (fetchNuGet { pname = "SkiaSharp.NativeAssets.Linux"; version = "2.88.6"; hash = "sha256-VjgGoi73tVvqO/UXmQb1w9ioAbFu2dxH8oHz1l5H4zE="; })
+  (fetchNuGet { pname = "SkiaSharp.NativeAssets.macOS"; version = "2.88.6"; hash = "sha256-7hOMjlYTOiNPLNwfLFUjTcdgiGEtmYUI1EubiRiC6bo="; })
+  (fetchNuGet { pname = "SkiaSharp.NativeAssets.WebAssembly"; version = "2.88.6"; hash = "sha256-CIb9fHVgHwIa0R1WafKJ3+GqtDHHRgDohA3ayTHvlws="; })
+  (fetchNuGet { pname = "SkiaSharp.NativeAssets.Win32"; version = "2.88.6"; hash = "sha256-ljD4QmAO2/vwA6I8GIUNkONpOzmGsOVJJy9vPDnjVfA="; })
+  (fetchNuGet { pname = "SpaceWizards.Sodium"; version = "0.2.1"; hash = "sha256-1x10ZvfWf1VGQM87c3Hc7ue9ibhslA1P2zE29FylOhU="; })
+  (fetchNuGet { pname = "SpaceWizards.Sodium.Interop"; version = "1.0.18-beta4"; hash = "sha256-dvPwT6owmBRYZT3UhOd9xBWtVF4C2+Woa7t18Y+IqfA="; })
+  (fetchNuGet { pname = "Splat"; version = "14.6.8"; hash = "sha256-XHTuUKAisBU0O3keA+Ojzb8yKKJUheWbRHakzLBeQNo="; })
+  (fetchNuGet { pname = "SQLitePCLRaw.bundle_e_sqlite3"; version = "2.1.4"; hash = "sha256-4IHC1KMcKOKHKLlf+/TIAVCQCdEDhPQw5+FUlujVDWo="; })
+  (fetchNuGet { pname = "SQLitePCLRaw.core"; version = "2.1.4"; hash = "sha256-jSI3SIE/HBLEvM+IzhfnAS0QU+JQzIokC/lGLNLvUyU="; })
+  (fetchNuGet { pname = "SQLitePCLRaw.lib.e_sqlite3"; version = "2.1.4"; hash = "sha256-dk7eEcw+lgpZuWdZn2794hQ6GHDeIfCRNGSysPUsiIY="; })
+  (fetchNuGet { pname = "SQLitePCLRaw.provider.e_sqlite3"; version = "2.1.4"; hash = "sha256-Zdj676VT6j6k9ZCL2hYVl4F8bi4TK/ldvQBPmW0oDi0="; })
+  (fetchNuGet { pname = "System.Collections"; version = "4.3.0"; hash = "sha256-afY7VUtD6w/5mYqrce8kQrvDIfS2GXDINDh73IjxJKc="; })
+  (fetchNuGet { pname = "System.Collections.Immutable"; version = "5.0.0"; hash = "sha256-GdwSIjLMM0uVfE56VUSLVNgpW0B//oCeSFj8/hSlbM8="; })
+  (fetchNuGet { pname = "System.ComponentModel.Annotations"; version = "4.5.0"; hash = "sha256-15yE2NoT9vmL9oGCaxHClQR1jLW1j1ef5hHMg55xRso="; })
+  (fetchNuGet { pname = "System.Diagnostics.Debug"; version = "4.3.0"; hash = "sha256-fkA79SjPbSeiEcrbbUsb70u9B7wqbsdM9s1LnoKj0gM="; })
+  (fetchNuGet { pname = "System.Drawing.Common"; version = "6.0.0"; hash = "sha256-/9EaAbEeOjELRSMZaImS1O8FmUe8j4WuFUw1VOrPyAo="; })
+  (fetchNuGet { pname = "System.Dynamic.Runtime"; version = "4.3.0"; hash = "sha256-k75gjOYimIQtLBD5NDzwwi3ZMUBPRW3jmc3evDMMJbU="; })
+  (fetchNuGet { pname = "System.Globalization"; version = "4.3.0"; hash = "sha256-caL0pRmFSEsaoeZeWN5BTQtGrAtaQPwFi8YOZPZG5rI="; })
+  (fetchNuGet { pname = "System.IO"; version = "4.3.0"; hash = "sha256-ruynQHekFP5wPrDiVyhNiRIXeZ/I9NpjK5pU+HPDiRY="; })
+  (fetchNuGet { pname = "System.IO.Pipelines"; version = "6.0.0"; hash = "sha256-xfjF4UqTMJpf8KsBWUyJlJkzPTOO/H5MW023yTYNQSA="; })
+  (fetchNuGet { pname = "System.Linq"; version = "4.3.0"; hash = "sha256-R5uiSL3l6a3XrXSSL6jz+q/PcyVQzEAByiuXZNSqD/A="; })
+  (fetchNuGet { pname = "System.Linq.Expressions"; version = "4.3.0"; hash = "sha256-+3pvhZY7rip8HCbfdULzjlC9FPZFpYoQxhkcuFm2wk8="; })
+  (fetchNuGet { pname = "System.Memory"; version = "4.5.3"; hash = "sha256-Cvl7RbRbRu9qKzeRBWjavUkseT2jhZBUWV1SPipUWFk="; })
+  (fetchNuGet { pname = "System.Memory"; version = "4.5.4"; hash = "sha256-3sCEfzO4gj5CYGctl9ZXQRRhwAraMQfse7yzKoRe65E="; })
+  (fetchNuGet { pname = "System.Net.Http.WinHttpHandler"; version = "8.0.0"; hash = "sha256-wSK5KtWvlDp8WLNddCmAM66uGyj9/KfJyCh8ht1PD1M="; })
+  (fetchNuGet { pname = "System.Numerics.Vectors"; version = "4.5.0"; hash = "sha256-qdSTIFgf2htPS+YhLGjAGiLN8igCYJnCCo6r78+Q+c8="; })
+  (fetchNuGet { pname = "System.ObjectModel"; version = "4.3.0"; hash = "sha256-gtmRkWP2Kwr3nHtDh0yYtce38z1wrGzb6fjm4v8wN6Q="; })
+  (fetchNuGet { pname = "System.Private.Uri"; version = "4.3.0"; hash = "sha256-fVfgcoP4AVN1E5wHZbKBIOPYZ/xBeSIdsNF+bdukIRM="; })
+  (fetchNuGet { pname = "System.Reactive"; version = "5.0.0"; hash = "sha256-M5Z8pw8rVb8ilbnTdaOptzk5VFd5DlKa7zzCpuytTtE="; })
+  (fetchNuGet { pname = "System.Reflection"; version = "4.3.0"; hash = "sha256-NQSZRpZLvtPWDlvmMIdGxcVuyUnw92ZURo0hXsEshXY="; })
+  (fetchNuGet { pname = "System.Reflection.Emit"; version = "4.3.0"; hash = "sha256-5LhkDmhy2FkSxulXR+bsTtMzdU3VyyuZzsxp7/DwyIU="; })
+  (fetchNuGet { pname = "System.Reflection.Emit.ILGeneration"; version = "4.3.0"; hash = "sha256-mKRknEHNls4gkRwrEgi39B+vSaAz/Gt3IALtS98xNnA="; })
+  (fetchNuGet { pname = "System.Reflection.Emit.Lightweight"; version = "4.3.0"; hash = "sha256-rKx4a9yZKcajloSZHr4CKTVJ6Vjh95ni+zszPxWjh2I="; })
+  (fetchNuGet { pname = "System.Reflection.Extensions"; version = "4.3.0"; hash = "sha256-mMOCYzUenjd4rWIfq7zIX9PFYk/daUyF0A8l1hbydAk="; })
+  (fetchNuGet { pname = "System.Reflection.Metadata"; version = "5.0.0"; hash = "sha256-Wo+MiqhcP9dQ6NuFGrQTw6hpbJORFwp+TBNTq2yhGp8="; })
+  (fetchNuGet { pname = "System.Reflection.Primitives"; version = "4.3.0"; hash = "sha256-5ogwWB4vlQTl3jjk1xjniG2ozbFIjZTL9ug0usZQuBM="; })
+  (fetchNuGet { pname = "System.Reflection.TypeExtensions"; version = "4.3.0"; hash = "sha256-4U4/XNQAnddgQIHIJq3P2T80hN0oPdU2uCeghsDTWng="; })
+  (fetchNuGet { pname = "System.Resources.ResourceManager"; version = "4.3.0"; hash = "sha256-idiOD93xbbrbwwSnD4mORA9RYi/D/U48eRUsn/WnWGo="; })
+  (fetchNuGet { pname = "System.Runtime"; version = "4.3.0"; hash = "sha256-51813WXpBIsuA6fUtE5XaRQjcWdQ2/lmEokJt97u0Rg="; })
+  (fetchNuGet { pname = "System.Runtime.CompilerServices.Unsafe"; version = "4.7.1"; hash = "sha256-UvyoDV8O0oY3HPG1GbA56YVdvwTGEfjYR5gW1O7IK4U="; })
+  (fetchNuGet { pname = "System.Runtime.Extensions"; version = "4.3.0"; hash = "sha256-wLDHmozr84v1W2zYCWYxxj0FR0JDYHSVRaRuDm0bd/o="; })
+  (fetchNuGet { pname = "System.Runtime.Handles"; version = "4.3.0"; hash = "sha256-KJ5aXoGpB56Y6+iepBkdpx/AfaJDAitx4vrkLqR7gms="; })
+  (fetchNuGet { pname = "System.Runtime.InteropServices"; version = "4.3.0"; hash = "sha256-8sDH+WUJfCR+7e4nfpftj/+lstEiZixWUBueR2zmHgI="; })
+  (fetchNuGet { pname = "System.Text.Encoding"; version = "4.3.0"; hash = "sha256-GctHVGLZAa/rqkBNhsBGnsiWdKyv6VDubYpGkuOkBLg="; })
+  (fetchNuGet { pname = "System.Text.Encoding.CodePages"; version = "4.5.1"; hash = "sha256-PIhkv59IXjyiuefdhKxS9hQfEwO9YWRuNudpo53HQfw="; })
+  (fetchNuGet { pname = "System.Threading"; version = "4.3.0"; hash = "sha256-ZDQ3dR4pzVwmaqBg4hacZaVenQ/3yAF/uV7BXZXjiWc="; })
+  (fetchNuGet { pname = "System.Threading.Tasks"; version = "4.3.0"; hash = "sha256-Z5rXfJ1EXp3G32IKZGiZ6koMjRu0n8C1NGrwpdIen4w="; })
+  (fetchNuGet { pname = "System.Threading.Tasks.Extensions"; version = "4.5.4"; hash = "sha256-owSpY8wHlsUXn5xrfYAiu847L6fAKethlvYx97Ri1ng="; })
+  (fetchNuGet { pname = "TerraFX.Interop.Windows"; version = "10.0.22621.1"; hash = "sha256-0golrteOhpZblYuKjM3YP2rswAv/hzWDQ6I9rT9TcWE="; })
+  (fetchNuGet { pname = "Tmds.DBus.Protocol"; version = "0.15.0"; hash = "sha256-4gk2vXDjKFaBh82gTkwg3c/5GRjiH+bvM5elfDSbKTU="; })
+  (fetchNuGet { pname = "YamlDotNet"; version = "13.0.2"; hash = "sha256-aCI7NH5iDAOcQJZNdyArt9ksqfrINreCzV7uFg3bNww="; })
 ]

pkgs/games/space-station-14-launcher/space-station-14-launcher.nix

···
 , gdk-pixbuf
 }:
 let
-  version = "0.28.0";
+  version = "0.28.1";
   pname = "space-station-14-launcher";
 in
 buildDotnetModule rec {
···
     owner = "space-wizards";
     repo = "SS14.Launcher";
     rev = "v${version}";
-    hash = "sha256-mBFTXwnxijXAP6i7DNQ/3bujualysCGjDDjmhe15s4I=";
+    hash = "sha256-5g/twJgQ7i6yQBYP7U6bn1UMU09WkJeolgCl+0pGT2Y=";
     fetchSubmodules = true;
   };
 

pkgs/games/steam/fhsenv.nix

···
   # bootstrap.tar.xz has 444 permissions, which means that simple deletes fail
   # and steam will not be able to start
   fixBootstrap = ''
-    if [ -r $HOME/.local/share/Steam/bootstrap.tar.xz ]; then
-      chmod +w $HOME/.local/share/Steam/bootstrap.tar.xz
+    if [ -r $HOME/.steam/steam/bootstrap.tar.xz ]; then
+      chmod +w $HOME/.steam/steam/bootstrap.tar.xz
     fi
   '';
 

pkgs/games/ultrastardx/default.nix

···
 
 in stdenv.mkDerivation rec {
   pname = "ultrastardx";
-  version = "2024.5.1";
+  version = "2024.8.0";
 
   src = fetchFromGitHub {
     owner = "UltraStar-Deluxe";
     repo = "USDX";
     rev = "v${version}";
-    hash = "sha256-HtvKy3uQwIO2BiLUqIcv9crf9Ngq0dmYOm6E8Gm2EHs=";
+    hash = "sha256-eji8lMrZbKAMYTqUk9d8tBIKkH083fbh4s01M0mPLpM=";
   };
 
   nativeBuildInputs = [ pkg-config autoreconfHook ];

pkgs/games/vassal/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "VASSAL";
-  version = "3.7.12";
+  version = "3.7.14";
 
   src = fetchzip {
     url = "https://github.com/vassalengine/vassal/releases/download/${version}/${pname}-${version}-linux.tar.bz2";
-    sha256 = "sha256-pNpDaGx/h3W+AsX965zu3zZ94kMYvh1pV8C8qYN0imc=";
+    sha256 = "sha256-3P3f6X2c5lF1AizEs9z59MhLy0Ntg203rkPAkv+SBtw=";
   };
 
   buildInputs = [

pkgs/misc/lilypond/unstable.nix

···
 { lib, fetchurl, lilypond }:
 
 lilypond.overrideAttrs (oldAttrs: rec {
-  version = "2.25.17";
+  version = "2.25.19";
   src = fetchurl {
     url = "https://lilypond.org/download/sources/v${lib.versions.majorMinor version}/lilypond-${version}.tar.gz";
-    hash = "sha256-AVGd/H2+lQxUYyXGB2dOBU4rpqR5LSkn3ishu5uqDYs=";
+    hash = "sha256-gGG4ObmY9PcO0JIKxAagquHS74Elc49SZ/8FDwFfZDU=";
   };
 
   passthru.updateScript = {

pkgs/os-specific/linux/xsos/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "xsos";
-  version = "0.7.19";
+  version = "0.7.33";
 
   src = fetchFromGitHub {
     owner = "ryran";
     repo = "xsos";
     rev = "v${version}";
-    sha256 = "11cc8z3pz4gl0mwl2fc701mn4cgx50fybygx0rvs9bhvb0jnphay";
+    sha256 = "sha256-VEOY422/+4veMlN9HOtPB/THDiFLNnRfbUJpKjc/cqE=";
   };
 
   nativeBuildInputs = [ makeWrapper installShellFiles ];

pkgs/servers/go-libp2p-daemon/default.nix

···
 
 buildGoModule rec {
   pname = "go-libp2p-daemon";
-  version = "0.9.0";
+  version = "0.9.1";
 
   src = fetchFromGitHub {
     owner = "libp2p";
     repo = "go-libp2p-daemon";
     rev = "v${version}";
-    hash = "sha256-1ZmtUrk5BO5tl5Brcyz6NCD9vdf5XXtbmophXVX05Tk=";
+    hash = "sha256-N/5V03HQTr7dIvMpIVRlIhEaV2f+aDF36esWMjT96HA=";
   };
 
-  vendorHash = "sha256-jT3t7m8wPKejbjCvQzx+PIAl9NYk0rAl6edywvR1FaE=";
+  vendorHash = "sha256-WOk06En90ys0pe5OZwhXCJJwry77t13eWg131fnQvpw=";
 
   doCheck = false;
 

pkgs/servers/monitoring/buildkite-agent-metrics/default.nix

···
 }:
 buildGoModule rec {
   pname = "buildkite-agent-metrics";
-  version = "5.9.7";
+  version = "5.9.8";
 
   outputs = [ "out" "lambda" ];
 
···
     owner = "buildkite";
     repo = "buildkite-agent-metrics";
     rev = "v${version}";
-    hash = "sha256-HHTPgrMNxaX2fbkf7oasrEopXg6ocMSwdymeNAIrckg=";
+    hash = "sha256-0WcjmX3SXRfx6ged2lfNTZBWfICYVtXznR+7J/ASAFQ=";
   };
 
   vendorHash = "sha256-i2+nefRE4BD93rG842oZj0/coamYVRMPxEHio80bdWk=";

pkgs/servers/nosql/neo4j/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "neo4j";
-  version = "5.21.0";
+  version = "5.22.0";
 
   src = fetchurl {
     url = "https://neo4j.com/artifact.php?name=neo4j-community-${version}-unix.tar.gz";
-    hash = "sha256-NFGoUqmG8VArQqx0p8qDUgvbtRnYbk1MYPSQ5CUFexg=";
+    hash = "sha256-gK5iNkGjs1Pjsryl5Jy28Nu3nYnVEoUMdRw1ahN4xEQ=";
   };
 
   nativeBuildInputs = [ makeWrapper ];

pkgs/servers/search/weaviate/default.nix

···
 
 buildGoModule rec {
   pname = "weaviate";
-  version = "1.25.9";
+  version = "1.26.4";
 
   src = fetchFromGitHub {
     owner = "weaviate";
     repo = "weaviate";
     rev = "v${version}";
-    hash = "sha256-liy3mw0+KJsac7AH1PEU6vk+MLo+ybEVCBeSU7MkoY0=";
+    hash = "sha256-JnzQ+B5zxbKZQ/jzOsD7r58f+TaCivN4BTJyNImi9xE=";
   };
 
-  vendorHash = "sha256-5kfXX+VqGY2ka/w79sdtVHS/0XlF7DyHcq5hvFFIHK0=";
+  vendorHash = "sha256-QwB97LNUFK8yuKK8JSy1uH2hu+8ZAlvc+9VlTIld83U=";
 
   subPackages = [ "cmd/weaviate-server" ];
 

pkgs/servers/sickbeard/sickgear.nix

···
   pythonEnv = python3.withPackages(ps: with ps; [ cheetah3 lxml ]);
 in stdenv.mkDerivation rec {
   pname = "sickgear";
-  version = "3.32.3";
+  version = "3.32.7";
 
   src = fetchFromGitHub {
     owner = "SickGear";
     repo = "SickGear";
     rev = "release_${version}";
-    hash = "sha256-Qqemee13V5+k56Q4hPOKjRsw6pmfALGRcKi4gHBj6eI=";
+    hash = "sha256-7kVT/aBL9EAx7oGeXEY9eL72dZGtuJUGlQ7bPyt/JZg=";
   };
 
   patches = [

pkgs/servers/sql/mssql/jdbc/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "mssql-jdbc";
-  version = "12.8.0";
+  version = "12.8.1";
 
   src = fetchurl {
     url = "https://github.com/Microsoft/mssql-jdbc/releases/download/v${version}/mssql-jdbc-${version}.jre8.jar";
-    sha256 = "sha256-mzSPFlv6MUtKNzZvRBy2khEa2YUEiH4xMR0EYXk3AHY=";
+    sha256 = "sha256-RPIXsdZ9IkQgAu4tHEq46GNYYGp4e5XutTAfI1SCoqs=";
   };
 
   dontUnpack = true;

pkgs/servers/sql/rqlite/default.nix

···
 
 buildGoModule rec {
   pname = "rqlite";
-  version = "8.28.0";
+  version = "8.30.0";
 
   src = fetchFromGitHub {
     owner = "rqlite";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-FhoD88j+uG1AvZ4ce1hwHCFH0cxvlsljf2iv7zAiXLQ=";
+    sha256 = "sha256-Q0Gt75SUhyezqikhBoDeLY4fw6utkhe1lJHsmBRFNWY=";
   };
 
-  vendorHash = "sha256-WQSdRPU8T02HdKTivLrvdd81XMhqFms0SA0zohicsjA=";
+  vendorHash = "sha256-waAhhbg02xyWRtj+hvzN9M0DLzz2NlkCmhmOLd3O2Sc=";
 
   subPackages = [ "cmd/rqlite" "cmd/rqlited" "cmd/rqbench" ];
 

pkgs/tools/games/steam-rom-manager/default.nix

···
 
 appimageTools.wrapType2 rec {
   name = "steam-rom-manager";
-  version = "2.5.17";
+  version = "2.5.22";
 
   src = fetchurl {
     url = "https://github.com/SteamGridDB/steam-rom-manager/releases/download/v${version}/Steam-ROM-Manager-${version}.AppImage";
-    sha256 = "sha256-2b9gL9gkQdTf+EBgjb+KFRJZjqNW/xeDusDJM1AO2U4=";
+    sha256 = "sha256-XC4earHVsDioQRJIrAFl5a+UFHjS7U5zt2PqfDxEg9s=";
   };
 
   extraInstallCommands = let

pkgs/tools/misc/convimg/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "convimg";
-  version = "9.3";
+  version = "9.4";
 
   src = fetchFromGitHub {
     owner = "mateoconlechuga";
     repo = pname;
     rev = "v${version}";
-    hash = "sha256-xnfMHlbQ7XG/mvnWoGkRHhxIK2u7kWJTVnLxd9c5oNU=";
+    hash = "sha256-5insJ391Usef8GF3Yh74PEqE534zitQg9udFRPcz69g=";
     fetchSubmodules = true;
   };
 

pkgs/tools/misc/easeprobe/default.nix

···
 
 buildGoModule rec {
   pname = "easeprobe";
-  version = "2.1.1";
+  version = "2.2.1";
 
   src = fetchFromGitHub {
     owner = "megaease";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-vdbzDwFpCYVgH9T8e62+1hnMyWsWrT7e6WPaAlBc2H0=";
+    sha256 = "sha256-XPbRtW3UIc6N1D1LKDYxgTHGVmiGDnam+r5Eg4uBa7w=";
   };
 
-  vendorHash = "sha256-ZB6q8XvDVSF5/kx2Avq0PYBkYqSoMD6YHhuXRrotFgk=";
+  vendorHash = "sha256-2iQJiRKt4/mBwwkjhohA1LeOfRart8WQT1bOIFuHbtA=";
 
   subPackages = [ "cmd/easeprobe" ];
 

pkgs/tools/misc/grizzly/default.nix

···
 
 buildGoModule rec {
   pname = "grizzly";
-  version = "0.4.3";
+  version = "0.4.5";
 
   src = fetchFromGitHub {
     owner = "grafana";
     repo = pname;
     rev = "v${version}";
-    hash = "sha256-f60zAE94jdJaGjn+SoO1qs3SgWRpK9pdbirRrsKKBJQ=";
+    hash = "sha256-cHPF+WHiUU0Cd30mEe+vMbkoG2mh2jMwlKhd851woH0=";
   };
 
   vendorHash = "sha256-lioFmaFzqaxN1wnYJaoHA54to1xGZjaLGaqAFIfTaTs=";

pkgs/tools/misc/instaloader/default.nix

···
 
 buildPythonPackage rec {
   pname = "instaloader";
-  version = "4.13";
+  version = "4.13.1";
   format = "pyproject";
 
   disabled = pythonOlder "3.6";
···
     owner = "instaloader";
     repo = "instaloader";
     rev = "refs/tags/v${version}";
-    sha256 = "sha256-nZNoxJnp8dBbgXWYLfzasTa9SsR03xA1mpl9NKppodE=";
+    sha256 = "sha256-eu2Hp3uomtPuMNjJGprcqK5HApKEjtXU9IQ5yT55cic=";
   };
 
   nativeBuildInputs = [

pkgs/tools/misc/sacad/default.nix

···
 
 python3Packages.buildPythonApplication rec {
   pname = "sacad";
-  version = "2.7.5";
+  version = "2.8.0";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-ZJPcxKc0G8V7x9nyzKXaXpfNpMB3/qRoX0d4lfBZTFY=";
+    hash = "sha256-/NyRnQSqDZv+LJ1bPO35T9icQ2PN9Oa+nSmrLkQimnQ=";
   };
 
   propagatedBuildInputs = with python3Packages; [

pkgs/tools/misc/scdl/default.nix

···
 
 python3Packages.buildPythonApplication rec {
   pname = "scdl";
-  version = "2.11.4";
+  version = "2.12.1";
   pyproject = true;
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-2hw9nVKShRAY6K0xXhVuce/dAu4w/BE2cKKKndzPJ3s=";
+    hash = "sha256-8BMO5/XJdAkz/E1ZDXavJudNSOiZdYLcZVMk1S8g9nU=";
   };
 
   build-system = [ python3Packages.setuptools ];

pkgs/tools/networking/rabtap/default.nix

···
 
 buildGoModule rec {
   pname = "rabtap";
-  version = "1.39.3";
+  version = "1.42";
 
   src = fetchFromGitHub {
     owner = "jandelgado";
     repo = "rabtap";
     rev = "v${version}";
-    sha256 = "sha256-5SX6Ma8AMpm642vCGUR1HI6fkKBui16sf7Fm0IpPK6M=";
+    sha256 = "sha256-+e8HHd2j8M2EJzfCQtohdlp+24JFZ1kA2/t+VSqFDAI=";
   };
 
-  vendorHash = "sha256-wZOkQjSPMZW3+ohZb+MlBWNU3WTL4/lqggAOJLrYFHc=";
+  vendorHash = "sha256-uRlFzhHtpZSie4Fmtj9YUPn+c7+Gvimlk1q8CcXFYmg=";
 
   meta = with lib; {
     description = "RabbitMQ wire tap and swiss army knife";

pkgs/tools/networking/zrok/default.nix

···
   }.${system} or throwSystem;
 
   hash = {
-    x86_64-linux = "sha256-8fEmiRKFOrF9v66OEfUGLUYK+DfZMkAXrCKu2DoGbLA=";
-    aarch64-linux = "sha256-p+YbWpyLfIgFdNvakQQFfi+P/9lhfVMM+Y0XynRJ/rY=";
-    armv7l-linux = "sha256-mMjtbAjylSjS+89T0qQoI4H/p316cqh+5fbgarFbv90=";
+    x86_64-linux = "sha256-EzMkl/XTtieAj/pg1L4BLTEuWNnQ5m18WYu/sqRZx/I=";
+    aarch64-linux = "sha256-D5FpJBRzvbsgrQmopJQpJZTIm9TroaGB6fkYX2UAaHM=";
+    armv7l-linux = "sha256-PQl/ZQxxkzQ4iTUPBO9tbCsswOnEQuupdzxul0/vKG4=";
   }.${system} or throwSystem;
 in
 stdenv.mkDerivation (finalAttrs: {
   pname = "zrok";
-  version = "0.4.34";
+  version = "0.4.39";
 
   src = fetchzip {
     url = "https://github.com/openziti/zrok/releases/download/v${finalAttrs.version}/zrok_${finalAttrs.version}_${plat}.tar.gz";

pkgs/tools/security/gotrue/supabase.nix

···
 
 buildGoModule rec {
   pname = "auth";
-  version = "2.155.6";
+  version = "2.159.2";
 
   src = fetchFromGitHub {
     owner = "supabase";
     repo = "auth";
     rev = "v${version}";
-    hash = "sha256-dldCFDiKGQU/XqtzkvzTdwtI8rDjFaaYJw9elYmDglM=";
+    hash = "sha256-5WRIDTbueAjAj9XhLltsFKk+9vul1WZ3htaasJLjhyw=";
   };
 
-  vendorHash = "sha256-ttdrHBA6Dybv+oNljIJpOlA2CZPwTIi9fI32w5Khp9Y=";
+  vendorHash = "sha256-cxLN9bdtpZmnhhP9tIYHQXW+KVmKvbS5+j+0gN6Ml3s=";
 
   ldflags = [
     "-s"

pkgs/tools/security/keybase/default.nix

···
 
 buildGoModule rec {
   pname = "keybase";
-  version = "6.3.1";
+  version = "6.4.0";
 
   modRoot = "go";
   subPackages = [ "kbnm" "keybase" ];
···
     owner = "keybase";
     repo = "client";
     rev = "v${version}";
-    hash = "sha256-kmKqVtHS0DaVa0of+QEUc2aEhWP1dNmzb/L01zaIoe8=";
+    hash = "sha256-hRqxA2gPL1UKbz9DwgfZfjE6e5pB7zenZqK+k1i8F2g=";
   };
   vendorHash = "sha256-KHahkGzkXr6xp0XY9MyEeeiHnmphaNYi9dPBQ476+us=";
 

pkgs/tools/security/osv-scanner/default.nix

···
 
 buildGoModule rec {
   pname = "osv-scanner";
-  version = "1.8.3";
+  version = "1.8.4";
 
   src = fetchFromGitHub {
     owner = "google";
     repo = "osv-scanner";
     rev = "refs/tags/v${version}";
-    hash = "sha256-RaTDhA9aowSCUFgH2JwkrV1TjYQW3P8o1Xd3e977AkM=";
+    hash = "sha256-e1a21zBxMa89PuNXPbeTpY3mHeO0TvxcoHcWRPUYwsM=";
   };
 
-  vendorHash = "sha256-mSBgnG7WJqrB/CAYi9wGtB7PL4/whsCv7WA3Im2/PZg=";
+  vendorHash = "sha256-ZmWgupPHZhv+MmNfFmuU1Cjin5liNcgkzdxw3Sf614c=";
 
   subPackages = [
     "cmd/osv-scanner"

pkgs/tools/system/java-service-wrapper/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "java-service-wrapper";
-  version = "3.5.58";
+  version = "3.5.59";
 
   src = fetchurl {
     url = "https://wrapper.tanukisoftware.com/download/${version}/wrapper_${version}_src.tar.gz";
-    hash = "sha256-mwfLCZfjAtKNfp9Cc8hkLAOKo6VfKD3l+IDiXDP2LV8=";
+    hash = "sha256-O0fn+s3RIIriVw6sMB2nSKAGtVF0Tz6Ns4Jb9OpcbgY=";
   };
 
   strictDeps = true;

pkgs/top-level/ocaml-packages.nix

···
 
     terminal_size = callPackage ../development/ocaml-modules/terminal_size { };
 
+    terml = callPackage ../development/ocaml-modules/terml { };
+
     tezos-base58 = callPackage ../development/ocaml-modules/tezos-base58 { };
 
     tezt = callPackage ../development/ocaml-modules/tezt { };

pkgs/top-level/python-packages.nix

···
 
   snakemake-interface-storage-plugins = callPackage ../development/python-modules/snakemake-interface-storage-plugins { };
 
+  snakemake-storage-plugin-fs = callPackage ../development/python-modules/snakemake-storage-plugin-fs { };
+
   snakemake-storage-plugin-s3 = callPackage ../development/python-modules/snakemake-storage-plugin-s3 { };
 
   snakemake-storage-plugin-xrootd = callPackage ../development/python-modules/snakemake-storage-plugin-xrootd { };
···
   synergy = callPackage ../development/python-modules/synergy { };
 
   syslog-rfc5424-formatter = callPackage ../development/python-modules/syslog-rfc5424-formatter { };
+
+  sysrsync = callPackage ../development/python-modules/sysrsync { };
 
   systembridge = callPackage ../development/python-modules/systembridge { };