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

.git-blame-ignore-revs

···
 
 # format files with nixfmt (#347275)
 adb9714bd909df283c66bbd641bd631ff50a4260
+
+# treewide: incus packages
+9ab59bb5fb943ad6740f64f5a79eae9642fb8211

CONTRIBUTING.md

···
 Here's a brief overview of the main Git branches and what channels they're used for:
 
 - `master`: The main branch, used for the unstable channels such as `nixpkgs-unstable`, `nixos-unstable` and `nixos-unstable-small`.
-- `release-YY.MM` (e.g. `release-24.11`): The NixOS release branches, used for the stable channels such as `nixos-24.11`, `nixos-24.11-small` and `nixpkgs-24.11-darwin`.
+- `release-YY.MM` (e.g. `release-25.05`): The NixOS release branches, used for the stable channels such as `nixos-25.05`, `nixos-25.05-small` and `nixpkgs-25.05-darwin`.
 
 When a channel is updated, a corresponding Git branch is also updated to point to the corresponding commit.
 So e.g. the [`nixpkgs-unstable` branch](https://github.com/nixos/nixpkgs/tree/nixpkgs-unstable) corresponds to the Git commit from the [`nixpkgs-unstable` channel](https://channels.nixos.org/nixpkgs-unstable).

README.md

···
 system, [Hydra](https://hydra.nixos.org/).
 
 * [Continuous package builds for unstable/master](https://hydra.nixos.org/jobset/nixos/trunk-combined)
-* [Continuous package builds for the NixOS 24.05 release](https://hydra.nixos.org/jobset/nixos/release-24.05)
+* [Continuous package builds for the NixOS 24.11 release](https://hydra.nixos.org/jobset/nixos/release-24.11)
 * [Tests for unstable/master](https://hydra.nixos.org/job/nixos/trunk-combined/tested#tabs-constituents)
-* [Tests for the NixOS 24.05 release](https://hydra.nixos.org/job/nixos/release-24.05/tested#tabs-constituents)
+* [Tests for the NixOS 24.11 release](https://hydra.nixos.org/job/nixos/release-24.11/tested#tabs-constituents)
 
 Artifacts successfully built with Hydra are published to cache at
 https://cache.nixos.org/. When successful build and test criteria are

maintainers/maintainer-list.nix

···
     githubId = 33826198;
     name = "Philipp Arras";
   };
+  parth = {
+    github = "parth";
+    githubId = 821972;
+    name = "Parth Mehrotra";
+  };
   pashashocky = {
     email = "[e-mail]";
     github = "pashashocky";

nixos/doc/manual/installation/upgrading.chapter.md

···
 automatically from NixOS's Git repository after certain tests have
 passed and all packages have been built. These channels are:
 
--   *Stable channels*, such as [`nixos-24.05`](https://channels.nixos.org/nixos-24.05).
+-   *Stable channels*, such as [`nixos-24.11`](https://channels.nixos.org/nixos-24.11).
     These only get conservative bug fixes and package upgrades. For
     instance, a channel update may cause the Linux kernel on your system
     to be upgraded from 4.19.34 to 4.19.38 (a minor bug fix), but not
···
     radical changes between channel updates. It's not recommended for
     production systems.
 
--   *Small channels*, such as [`nixos-24.05-small`](https://channels.nixos.org/nixos-24.05-small)
+-   *Small channels*, such as [`nixos-24.11-small`](https://channels.nixos.org/nixos-24.11-small)
     or [`nixos-unstable-small`](https://channels.nixos.org/nixos-unstable-small).
     These are identical to the stable and unstable channels described above,
     except that they contain fewer binary packages. This means they get updated
···
 
 When you first install NixOS, you're automatically subscribed to the
 NixOS channel that corresponds to your installation source. For
-instance, if you installed from a 24.05 ISO, you will be subscribed to
-the `nixos-24.05` channel. To see which NixOS channel you're subscribed
+instance, if you installed from a 24.11 ISO, you will be subscribed to
+the `nixos-24.11` channel. To see which NixOS channel you're subscribed
 to, run the following as root:
 
 ```ShellSession
···
 ```
 
 (Be sure to include the `nixos` parameter at the end.) For instance, to
-use the NixOS 24.05 stable channel:
+use the NixOS 24.11 stable channel:
 
 ```ShellSession
-# nix-channel --add https://channels.nixos.org/nixos-24.05 nixos
+# nix-channel --add https://channels.nixos.org/nixos-24.11 nixos
 ```
 
 If you have a server, you may want to use the "small" channel instead:
 
 ```ShellSession
-# nix-channel --add https://channels.nixos.org/nixos-24.05-small nixos
+# nix-channel --add https://channels.nixos.org/nixos-24.11-small nixos
 ```
 
 And if you want to live on the bleeding edge:
···
 
 ```nix
 {
-  system.autoUpgrade.channel = "https://channels.nixos.org/nixos-24.05";
+  system.autoUpgrade.channel = "https://channels.nixos.org/nixos-24.11";
 }
 ```

nixos/doc/manual/release-notes/rl-2411.section.md

···
-# Release 24.11 (“Vicuña”, 2024.11/??) {#sec-release-24.11}
+# Release 24.11 (“Vicuña”, 2024.11/28) {#sec-release-24.11}
 
 <!-- To avoid merge conflicts, consider adding your item at an arbitrary place in the list instead. -->
 

nixos/modules/programs/java.nix

···
     environment.systemPackages = [ cfg.package ];
 
     environment.shellInit = ''
-      test -e ${cfg.package}/nix-support/setup-hook && source ${cfg.package}/nix-support/setup-hook
+      test -e ${cfg.package}/nix-support/setup-hook && . ${cfg.package}/nix-support/setup-hook
     '';
 
   };

nixos/modules/services/networking/zapret.nix

···
   cfg = config.services.zapret;
 
   whitelist = lib.optionalString (
-    cfg.whitelist != null
+    (builtins.length cfg.whitelist) != 0
   ) "--hostlist ${pkgs.writeText "zapret-whitelist" (lib.concatStringsSep "\n" cfg.whitelist)}";
 
   blacklist =
-    lib.optionalString (cfg.blacklist != null)
+    lib.optionalString ((builtins.length cfg.blacklist) != 0)
       "--hostlist-exclude ${pkgs.writeText "zapret-blacklist" (lib.concatStringsSep "\n" cfg.blacklist)}";
 
-  ports = if cfg.httpSupport then "80,443" else "443";
+  params = lib.concatStringsSep " " cfg.params;
+
+  qnum = toString cfg.qnum;
 in
 {
   options.services.zapret = {
···
           "--dpi-desync=fake,disorder2"
           "--dpi-desync-ttl=1"
           "--dpi-desync-autottl=2"
-        ];
+        ]
       '';
       description = ''
         Specify the bypass parameters for Zapret binary.
···
       '';
     };
     whitelist = lib.mkOption {
-      default = null;
-      type = with lib.types; nullOr (listOf str);
+      default = [ ];
+      type = with lib.types; listOf str;
       example = ''
         [
           "youtube.com"
···
       '';
     };
     blacklist = lib.mkOption {
-      default = null;
-      type = with lib.types; nullOr (listOf str);
+      default = [ ];
+      type = with lib.types; listOf str;
       example = ''
         [
           "example.com"
···
         Http bypass rarely works and you might want to disable it if you don't utilise http connections.
       '';
     };
+    httpMode = lib.mkOption {
+      default = "first";
+      type = lib.types.enum [
+        "first"
+        "full"
+      ];
+      example = "full";
+      description = ''
+        By default this service only changes the first packet sent, which is enough in most cases.
+        But there are DPIs that monitor the whole traffic within a session.
+        That requires full processing of every packet, which increases the CPU usage.
+
+        Set the mode to `full` if http doesn't work.
+      '';
+    };
+    udpSupport = lib.mkOption {
+      default = false;
+      type = lib.types.bool;
+      description = ''
+        Enable UDP routing.
+        This requires you to specify `udpPorts` and `--dpi-desync-any-protocol` parameter.
+      '';
+    };
+    udpPorts = lib.mkOption {
+      default = [ ];
+      type = with lib.types; listOf str;
+      example = ''
+        [
+          "50000:50099"
+          "1234"
+        ]
+      '';
+      description = ''
+        List of UDP ports to route.
+        Port ranges are delimited with a colon like this "50000:50099".
+      '';
+    };
   };
 
   config = lib.mkIf cfg.enable (
···
       {
         assertions = [
           {
-            assertion = (cfg.whitelist == null) || (cfg.blacklist == null);
+            assertion = (builtins.length cfg.whitelist) == 0 || (builtins.length cfg.blacklist) == 0;
             message = "Can't specify both whitelist and blacklist.";
           }
           {
             assertion = (builtins.length cfg.params) != 0;
             message = "You have to specify zapret parameters. See the params option's description.";
           }
+          {
+            assertion = cfg.udpSupport -> (builtins.length cfg.udpPorts) != 0;
+            message = "You have to specify UDP ports or disable UDP support.";
+          }
+          {
+            assertion = !cfg.configureFirewall || !config.networking.nftables.enable;
+            message = "You need to manually configure you firewall for Zapret service when using nftables.";
+          }
         ];
 
         systemd.services.zapret = {
···
           wantedBy = [ "multi-user.target" ];
           after = [ "network.target" ];
           serviceConfig = {
-            ExecStart = "${cfg.package}/bin/nfqws --pidfile=/run/nfqws.pid ${lib.concatStringsSep " " cfg.params} ${whitelist} ${blacklist} --qnum=${toString cfg.qnum}";
+            ExecStart = "${cfg.package}/bin/nfqws --pidfile=/run/nfqws.pid ${params} ${whitelist} ${blacklist} --qnum=${qnum}";
             Type = "simple";
             PIDFile = "/run/nfqws.pid";
             Restart = "always";
-            RuntimeMaxSec = "1h"; # This service loves to crash silently or cause network slowdowns. It also restarts instantly. In my experience restarting it hourly provided the best experience.
+            RuntimeMaxSec = "1h"; # This service loves to crash silently or cause network slowdowns. It also restarts instantly. Restarting it at least hourly provided the best experience.
 
-            # hardening
+            # Hardening.
             DevicePolicy = "closed";
             KeyringMode = "private";
             PrivateTmp = true;
···
 
       # Route system traffic via service for specified ports.
       (lib.mkIf cfg.configureFirewall {
-        networking.firewall.extraCommands = ''
-          iptables -t mangle -I POSTROUTING -p tcp -m multiport --dports ${ports} -m connbytes --connbytes-dir=original --connbytes-mode=packets --connbytes 1:6 -m mark ! --mark 0x40000000/0x40000000 -j NFQUEUE --queue-num ${toString cfg.qnum} --queue-bypass
-        '';
+        networking.firewall.extraCommands =
+          let
+            httpParams = lib.optionalString (
+              cfg.httpMode == "first"
+            ) "-m connbytes --connbytes-dir=original --connbytes-mode=packets --connbytes 1:6";
+
+            udpPorts = lib.concatStringsSep "," cfg.udpPorts;
+          in
+          ''
+            ip46tables -t mangle -I POSTROUTING -p tcp --dport 443 -m connbytes --connbytes-dir=original --connbytes-mode=packets --connbytes 1:6 -m mark ! --mark 0x40000000/0x40000000 -j NFQUEUE --queue-num ${qnum} --queue-bypass
+          ''
+          + lib.optionalString (cfg.httpSupport) ''
+            ip46tables -t mangle -I POSTROUTING -p tcp --dport 80 ${httpParams} -m mark ! --mark 0x40000000/0x40000000 -j NFQUEUE --queue-num ${qnum} --queue-bypass
+          ''
+          + lib.optionalString (cfg.udpSupport) ''
+            ip46tables -t mangle -A POSTROUTING -p udp -m multiport --dports ${udpPorts} -m mark ! --mark 0x40000000/0x40000000 -j NFQUEUE --queue-num ${qnum} --queue-bypass
+          '';
       })
     ]
   );

nixos/modules/services/web-apps/moodle.nix

···
   mysqlLocal = cfg.database.createLocally && cfg.database.type == "mysql";
   pgsqlLocal = cfg.database.createLocally && cfg.database.type == "pgsql";
 
-  phpExt = pkgs.php81.buildEnv {
+  phpExt = pkgs.php83.buildEnv {
     extensions = { all, ... }: with all; [ iconv mbstring curl openssl tokenizer soap ctype zip gd simplexml dom intl sqlite3 pgsql pdo_sqlite pdo_pgsql pdo_odbc pdo_mysql pdo mysqli session zlib xmlreader fileinfo filter opcache exif sodium ];
     extraConfig = "max_input_vars = 5000";
   };

nixos/modules/virtualisation/lxc-image-metadata.nix

···
-{ lib, config, pkgs, ... }:
+{
+  lib,
+  config,
+  pkgs,
+  ...
+}:
 
 let
-  templateSubmodule = {...}: {
-    options = {
-      enable = lib.mkEnableOption "this template";
+  templateSubmodule =
+    { ... }:
+    {
+      options = {
+        enable = lib.mkEnableOption "this template";
 
-      target = lib.mkOption {
-        description = "Path in the container";
-        type = lib.types.path;
-      };
-      template = lib.mkOption {
-        description = ".tpl file for rendering the target";
-        type = lib.types.path;
-      };
-      when = lib.mkOption {
-        description = "Events which trigger a rewrite (create, copy)";
-        type = lib.types.listOf (lib.types.str);
-      };
-      properties = lib.mkOption {
-        description = "Additional properties";
-        type = lib.types.attrs;
-        default = {};
+        target = lib.mkOption {
+          description = "Path in the container";
+          type = lib.types.path;
+        };
+        template = lib.mkOption {
+          description = ".tpl file for rendering the target";
+          type = lib.types.path;
+        };
+        when = lib.mkOption {
+          description = "Events which trigger a rewrite (create, copy)";
+          type = lib.types.listOf (lib.types.str);
+        };
+        properties = lib.mkOption {
+          description = "Additional properties";
+          type = lib.types.attrs;
+          default = { };
+        };
       };
     };
-  };
 
-  toYAML = name: data: pkgs.writeText name (lib.generators.toYAML {} data);
+  toYAML = name: data: pkgs.writeText name (lib.generators.toYAML { } data);
 
   cfg = config.virtualisation.lxc;
-  templates = if cfg.templates != {} then let
-    list = lib.mapAttrsToList (name: value: { inherit name; } // value)
-      (lib.filterAttrs (name: value: value.enable) cfg.templates);
-  in
-    {
-      files = map (tpl: {
-        source = tpl.template;
-        target = "/templates/${tpl.name}.tpl";
-      }) list;
-      properties = lib.listToAttrs (map (tpl: lib.nameValuePair tpl.target {
-        when = tpl.when;
-        template = "${tpl.name}.tpl";
-        properties = tpl.properties;
-      }) list);
-    }
-  else { files = []; properties = {}; };
+  templates =
+    if cfg.templates != { } then
+      let
+        list = lib.mapAttrsToList (name: value: { inherit name; } // value) (
+          lib.filterAttrs (name: value: value.enable) cfg.templates
+        );
+      in
+      {
+        files = map (tpl: {
+          source = tpl.template;
+          target = "/templates/${tpl.name}.tpl";
+        }) list;
+        properties = lib.listToAttrs (
+          map (
+            tpl:
+            lib.nameValuePair tpl.target {
+              when = tpl.when;
+              template = "${tpl.name}.tpl";
+              properties = tpl.properties;
+            }
+          ) list
+        );
+      }
+    else
+      {
+        files = [ ];
+        properties = { };
+      };
 
-in {
+in
+{
   imports = [
     ../image/file-options.nix
   ];
···
       templates = lib.mkOption {
         description = "Templates for LXD";
         type = lib.types.attrsOf (lib.types.submodule templateSubmodule);
-        default = {};
+        default = { };
         example = lib.literalExpression ''
           {
             # create /etc/hostname on container creation
···
   };
 
   config = {
-    system.nixos.tags = [ "lxc" "metadata" ];
+    system.nixos.tags = [
+      "lxc"
+      "metadata"
+    ];
     image.extension = "tar.xz";
     image.filePath = "tarball/${config.image.fileName}";
     system.build.image = config.system.build.metadata;
···
       contents = [
         {
           source = toYAML "metadata.yaml" {
-            architecture = builtins.elemAt (builtins.match "^([a-z0-9_]+).+" (toString pkgs.stdenv.hostPlatform.system)) 0;
+            architecture = builtins.elemAt (builtins.match "^([a-z0-9_]+).+" (
+              toString pkgs.stdenv.hostPlatform.system
+            )) 0;
             creation_date = 1;
             properties = {
               description = "${config.system.nixos.distroName} ${config.system.nixos.codeName} ${config.system.nixos.label} ${pkgs.stdenv.hostPlatform.system}";

nixos/modules/virtualisation/lxc-instance-common.nix

···
-{lib, ...}:
+{ lib, ... }:
 
 {
   meta = {

nixos/modules/virtualisation/lxc.nix

···
 # LXC Configuration
 
-{ config, lib, pkgs, ... }:
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}:
 
 let
   cfg = config.virtualisation.lxc;
···
   };
 
   options.virtualisation.lxc = {
-    enable =
-      lib.mkOption {
-        type = lib.types.bool;
-        default = false;
-        description = ''
-            This enables Linux Containers (LXC), which provides tools
-            for creating and managing system or application containers
-            on Linux.
-          '';
-      };
+    enable = lib.mkOption {
+      type = lib.types.bool;
+      default = false;
+      description = ''
+        This enables Linux Containers (LXC), which provides tools
+        for creating and managing system or application containers
+        on Linux.
+      '';
+    };
 
     unprivilegedContainers = lib.mkEnableOption "support for unprivileged users to launch containers";
 
-    systemConfig =
-      lib.mkOption {
-        type = lib.types.lines;
-        default = "";
-        description = ''
-            This is the system-wide LXC config. See
-            {manpage}`lxc.system.conf(5)`.
-          '';
-      };
+    systemConfig = lib.mkOption {
+      type = lib.types.lines;
+      default = "";
+      description = ''
+        This is the system-wide LXC config. See
+        {manpage}`lxc.system.conf(5)`.
+      '';
+    };
     package = lib.mkPackageOption pkgs "lxc" { };
 
-    defaultConfig =
-      lib.mkOption {
-        type = lib.types.lines;
-        default = "";
-        description = ''
-            Default config (default.conf) for new containers, i.e. for
-            network config. See {manpage}`lxc.container.conf(5)`.
-          '';
-      };
+    defaultConfig = lib.mkOption {
+      type = lib.types.lines;
+      default = "";
+      description = ''
+        Default config (default.conf) for new containers, i.e. for
+        network config. See {manpage}`lxc.container.conf(5)`.
+      '';
+    };
 
-    usernetConfig =
-      lib.mkOption {
-        type = lib.types.lines;
-        default = "";
-        description = ''
-            This is the config file for managing unprivileged user network
-            administration access in LXC. See {manpage}`lxc-usernet(5)`.
-          '';
-      };
+    usernetConfig = lib.mkOption {
+      type = lib.types.lines;
+      default = "";
+      description = ''
+        This is the config file for managing unprivileged user network
+        administration access in LXC. See {manpage}`lxc-usernet(5)`.
+      '';
+    };
 
-      bridgeConfig =
-        lib.mkOption {
-          type = lib.types.lines;
-          default = "";
-          description = ''
-              This is the config file for override lxc-net bridge default settings.
-            '';
-        };
+    bridgeConfig = lib.mkOption {
+      type = lib.types.lines;
+      default = "";
+      description = ''
+        This is the config file for override lxc-net bridge default settings.
+      '';
+    };
   };
 
   ###### implementation
···
     };
 
     # We don't need the `lxc-user` group, unless the unprivileged containers are enabled.
-    users.groups = lib.mkIf cfg.unprivilegedContainers { lxc-user = {}; };
+    users.groups = lib.mkIf cfg.unprivilegedContainers { lxc-user = { }; };
 
     # `lxc-user-nic` needs suid to attach to bridge for unpriv containers.
     security.wrappers = lib.mkIf cfg.unprivilegedContainers {
···
       lxc-net = {
         enable = true;
         wantedBy = [ "multi-user.target" ];
-        path = [ pkgs.iproute2 pkgs.iptables pkgs.getent pkgs.dnsmasq ];
+        path = [
+          pkgs.iproute2
+          pkgs.iptables
+          pkgs.getent
+          pkgs.dnsmasq
+        ];
       };
     };
   };

nixos/modules/virtualisation/lxcfs.nix

···
 # LXC Configuration
 
-{ config, lib, pkgs, ... }:
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}:
 
 let
   cfg = config.virtualisation.lxc.lxcfs;
-in {
+in
+{
   meta = {
     maintainers = lib.teams.lxc.members;
   };
 
   ###### interface
   options.virtualisation.lxc.lxcfs = {
-    enable =
-      lib.mkOption {
-        type = lib.types.bool;
-        default = false;
-        description = ''
-          This enables LXCFS, a FUSE filesystem for LXC.
-          To use lxcfs in include the following configuration in your
-          container configuration:
-          ```
-          virtualisation.lxc.defaultConfig = "lxc.include = ''${pkgs.lxcfs}/share/lxc/config/common.conf.d/00-lxcfs.conf";
-          ```
-        '';
-      };
+    enable = lib.mkOption {
+      type = lib.types.bool;
+      default = false;
+      description = ''
+        This enables LXCFS, a FUSE filesystem for LXC.
+        To use lxcfs in include the following configuration in your
+        container configuration:
+        ```
+        virtualisation.lxc.defaultConfig = "lxc.include = ''${pkgs.lxcfs}/share/lxc/config/common.conf.d/00-lxcfs.conf";
+        ```
+      '';
+    };
   };
 
   ###### implementation
···
       before = [ "lxc.service" ];
       restartIfChanged = false;
       serviceConfig = {
-        ExecStartPre="${pkgs.coreutils}/bin/mkdir -p /var/lib/lxcfs";
-        ExecStart="${pkgs.lxcfs}/bin/lxcfs /var/lib/lxcfs";
-        ExecStopPost="-${pkgs.fuse}/bin/fusermount -u /var/lib/lxcfs";
-        KillMode="process";
-        Restart="on-failure";
+        ExecStartPre = "${pkgs.coreutils}/bin/mkdir -p /var/lib/lxcfs";
+        ExecStart = "${pkgs.lxcfs}/bin/lxcfs /var/lib/lxcfs";
+        ExecStopPost = "-${pkgs.fuse}/bin/fusermount -u /var/lib/lxcfs";
+        KillMode = "process";
+        Restart = "on-failure";
       };
     };
   };

nixos/tests/incus/container.nix

···
-import ../make-test-python.nix ({ pkgs, lib, extra ? {}, name ? "incus-container", incus ? pkgs.incus-lts, ... } :
+import ../make-test-python.nix (
+  {
+    pkgs,
+    lib,
+    extra ? { },
+    name ? "incus-container",
+    incus ? pkgs.incus-lts,
+    ...
+  }:
 
-let
-  releases = import ../../release.nix {
-    configuration = lib.recursiveUpdate {
+  let
+    releases = import ../../release.nix {
+      configuration = lib.recursiveUpdate {
         # Building documentation makes the test unnecessarily take a longer time:
         documentation.enable = lib.mkForce false;
 
         boot.kernel.sysctl."net.ipv4.ip_forward" = "1";
-    }
-    extra;
-  };
+      } extra;
+    };
 
-  container-image-metadata = "${releases.incusContainerMeta.${pkgs.stdenv.hostPlatform.system}}/tarball/nixos-system-${pkgs.stdenv.hostPlatform.system}.tar.xz";
-  container-image-rootfs = "${releases.incusContainerImage.${pkgs.stdenv.hostPlatform.system}}/nixos-lxc-image-${pkgs.stdenv.hostPlatform.system}.squashfs";
-in
-{
-  inherit name;
+    container-image-metadata = "${
+      releases.incusContainerMeta.${pkgs.stdenv.hostPlatform.system}
+    }/tarball/nixos-image-lxc-*-${pkgs.stdenv.hostPlatform.system}.tar.xz";
+    container-image-rootfs = "${
+      releases.incusContainerImage.${pkgs.stdenv.hostPlatform.system}
+    }/nixos-lxc-image-${pkgs.stdenv.hostPlatform.system}.squashfs";
+  in
+  {
+    inherit name;
 
-  meta = {
-    maintainers = lib.teams.lxc.members;
-  };
+    meta = {
+      maintainers = lib.teams.lxc.members;
+    };
 
-  nodes.machine = { ... }: {
-    virtualisation = {
-      # Ensure test VM has enough resources for creating and managing guests
-      cores = 2;
-      memorySize = 1024;
-      diskSize = 4096;
+    nodes.machine =
+      { ... }:
+      {
+        virtualisation = {
+          # Ensure test VM has enough resources for creating and managing guests
+          cores = 2;
+          memorySize = 1024;
+          diskSize = 4096;
 
-      incus = {
-        enable = true;
-        package = incus;
+          incus = {
+            enable = true;
+            package = incus;
+          };
+        };
+        networking.nftables.enable = true;
       };
-    };
-    networking.nftables.enable = true;
-  };
 
-  testScript = # python
-  ''
-    def instance_is_up(_) -> bool:
-        status, _ = machine.execute("incus exec container --disable-stdin --force-interactive /run/current-system/sw/bin/systemctl -- is-system-running")
-        return status == 0
+    testScript = # python
+      ''
+        def instance_is_up(_) -> bool:
+            status, _ = machine.execute("incus exec container --disable-stdin --force-interactive /run/current-system/sw/bin/systemctl -- is-system-running")
+            return status == 0
 
-    def set_container(config):
-        machine.succeed(f"incus config set container {config}")
-        machine.succeed("incus restart container")
-        with machine.nested("Waiting for instance to start and be usable"):
-          retry(instance_is_up)
+        def set_container(config):
+            machine.succeed(f"incus config set container {config}")
+            machine.succeed("incus restart container")
+            with machine.nested("Waiting for instance to start and be usable"):
+              retry(instance_is_up)
 
-    def check_sysctl(instance):
-        with subtest("systemd sysctl settings are applied"):
-            machine.succeed(f"incus exec {instance} -- systemctl status systemd-sysctl")
-            sysctl = machine.succeed(f"incus exec {instance} -- sysctl net.ipv4.ip_forward").strip().split(" ")[-1]
-            assert "1" == sysctl, f"systemd-sysctl configuration not correctly applied, {sysctl} != 1"
+        def check_sysctl(instance):
+            with subtest("systemd sysctl settings are applied"):
+                machine.succeed(f"incus exec {instance} -- systemctl status systemd-sysctl")
+                sysctl = machine.succeed(f"incus exec {instance} -- sysctl net.ipv4.ip_forward").strip().split(" ")[-1]
+                assert "1" == sysctl, f"systemd-sysctl configuration not correctly applied, {sysctl} != 1"
 
-    machine.wait_for_unit("incus.service")
+        machine.wait_for_unit("incus.service")
 
-    # no preseed should mean no service
-    machine.fail("systemctl status incus-preseed.service")
+        # no preseed should mean no service
+        machine.fail("systemctl status incus-preseed.service")
 
-    machine.succeed("incus admin init --minimal")
+        machine.succeed("incus admin init --minimal")
 
-    with subtest("Container image can be imported"):
-        machine.succeed("incus image import ${container-image-metadata} ${container-image-rootfs} --alias nixos")
+        with subtest("Container image can be imported"):
+            machine.succeed("incus image import ${container-image-metadata} ${container-image-rootfs} --alias nixos")
 
-    with subtest("Container can be launched and managed"):
-        machine.succeed("incus launch nixos container")
-        with machine.nested("Waiting for instance to start and be usable"):
-          retry(instance_is_up)
-        machine.succeed("echo true | incus exec container /run/current-system/sw/bin/bash -")
+        with subtest("Container can be launched and managed"):
+            machine.succeed("incus launch nixos container")
+            with machine.nested("Waiting for instance to start and be usable"):
+              retry(instance_is_up)
+            machine.succeed("echo true | incus exec container /run/current-system/sw/bin/bash -")
 
-    with subtest("Container mounts lxcfs overlays"):
-        machine.succeed("incus exec container mount | grep 'lxcfs on /proc/cpuinfo type fuse.lxcfs'")
-        machine.succeed("incus exec container mount | grep 'lxcfs on /proc/meminfo type fuse.lxcfs'")
+        with subtest("Container mounts lxcfs overlays"):
+            machine.succeed("incus exec container mount | grep 'lxcfs on /proc/cpuinfo type fuse.lxcfs'")
+            machine.succeed("incus exec container mount | grep 'lxcfs on /proc/meminfo type fuse.lxcfs'")
 
-    with subtest("resource limits"):
-        with subtest("Container CPU limits can be managed"):
-            set_container("limits.cpu 1")
-            cpuinfo = machine.succeed("incus exec container grep -- -c ^processor /proc/cpuinfo").strip()
-            assert cpuinfo == "1", f"Wrong number of CPUs reported from /proc/cpuinfo, want: 1, got: {cpuinfo}"
+        with subtest("resource limits"):
+            with subtest("Container CPU limits can be managed"):
+                set_container("limits.cpu 1")
+                cpuinfo = machine.succeed("incus exec container grep -- -c ^processor /proc/cpuinfo").strip()
+                assert cpuinfo == "1", f"Wrong number of CPUs reported from /proc/cpuinfo, want: 1, got: {cpuinfo}"
 
-            set_container("limits.cpu 2")
-            cpuinfo = machine.succeed("incus exec container grep -- -c ^processor /proc/cpuinfo").strip()
-            assert cpuinfo == "2", f"Wrong number of CPUs reported from /proc/cpuinfo, want: 2, got: {cpuinfo}"
+                set_container("limits.cpu 2")
+                cpuinfo = machine.succeed("incus exec container grep -- -c ^processor /proc/cpuinfo").strip()
+                assert cpuinfo == "2", f"Wrong number of CPUs reported from /proc/cpuinfo, want: 2, got: {cpuinfo}"
 
-        with subtest("Container memory limits can be managed"):
-            set_container("limits.memory 64MB")
-            meminfo = machine.succeed("incus exec container grep -- MemTotal /proc/meminfo").strip()
-            meminfo_bytes = " ".join(meminfo.split(' ')[-2:])
-            assert meminfo_bytes == "62500 kB", f"Wrong amount of memory reported from /proc/meminfo, want: '62500 kB', got: '{meminfo_bytes}'"
+            with subtest("Container memory limits can be managed"):
+                set_container("limits.memory 64MB")
+                meminfo = machine.succeed("incus exec container grep -- MemTotal /proc/meminfo").strip()
+                meminfo_bytes = " ".join(meminfo.split(' ')[-2:])
+                assert meminfo_bytes == "62500 kB", f"Wrong amount of memory reported from /proc/meminfo, want: '62500 kB', got: '{meminfo_bytes}'"
 
-            set_container("limits.memory 128MB")
-            meminfo = machine.succeed("incus exec container grep -- MemTotal /proc/meminfo").strip()
-            meminfo_bytes = " ".join(meminfo.split(' ')[-2:])
-            assert meminfo_bytes == "125000 kB", f"Wrong amount of memory reported from /proc/meminfo, want: '125000 kB', got: '{meminfo_bytes}'"
+                set_container("limits.memory 128MB")
+                meminfo = machine.succeed("incus exec container grep -- MemTotal /proc/meminfo").strip()
+                meminfo_bytes = " ".join(meminfo.split(' ')[-2:])
+                assert meminfo_bytes == "125000 kB", f"Wrong amount of memory reported from /proc/meminfo, want: '125000 kB', got: '{meminfo_bytes}'"
 
-    with subtest("virtual tpm can be configured"):
-        machine.succeed("incus config device add container vtpm tpm path=/dev/tpm0 pathrm=/dev/tpmrm0")
-        machine.succeed("incus exec container -- test -e /dev/tpm0")
-        machine.succeed("incus exec container -- test -e /dev/tpmrm0")
-        machine.succeed("incus config device remove container vtpm")
-        machine.fail("incus exec container -- test -e /dev/tpm0")
+        with subtest("virtual tpm can be configured"):
+            machine.succeed("incus config device add container vtpm tpm path=/dev/tpm0 pathrm=/dev/tpmrm0")
+            machine.succeed("incus exec container -- test -e /dev/tpm0")
+            machine.succeed("incus exec container -- test -e /dev/tpmrm0")
+            machine.succeed("incus config device remove container vtpm")
+            machine.fail("incus exec container -- test -e /dev/tpm0")
 
-    with subtest("lxc-generator"):
-        with subtest("lxc-container generator configures plain container"):
-            # reuse the existing container to save some time
-            machine.succeed("incus exec container test -- -e /run/systemd/system/service.d/zzz-lxc-service.conf")
-            check_sysctl("container")
+        with subtest("lxc-generator"):
+            with subtest("lxc-container generator configures plain container"):
+                # reuse the existing container to save some time
+                machine.succeed("incus exec container test -- -e /run/systemd/system/service.d/zzz-lxc-service.conf")
+                check_sysctl("container")
 
-        with subtest("lxc-container generator configures nested container"):
-            machine.execute("incus delete --force container")
-            machine.succeed("incus launch nixos container --config security.nesting=true")
-            with machine.nested("Waiting for instance to start and be usable"):
-              retry(instance_is_up)
+            with subtest("lxc-container generator configures nested container"):
+                machine.execute("incus delete --force container")
+                machine.succeed("incus launch nixos container --config security.nesting=true")
+                with machine.nested("Waiting for instance to start and be usable"):
+                  retry(instance_is_up)
 
-            machine.fail("incus exec container test -- -e /run/systemd/system/service.d/zzz-lxc-service.conf")
-            target = machine.succeed("incus exec container readlink -- -f /run/systemd/system/systemd-binfmt.service").strip()
-            assert target == "/dev/null", "lxc generator did not correctly mask /run/systemd/system/systemd-binfmt.service"
+                machine.fail("incus exec container test -- -e /run/systemd/system/service.d/zzz-lxc-service.conf")
+                target = machine.succeed("incus exec container readlink -- -f /run/systemd/system/systemd-binfmt.service").strip()
+                assert target == "/dev/null", "lxc generator did not correctly mask /run/systemd/system/systemd-binfmt.service"
 
-            check_sysctl("container")
+                check_sysctl("container")
 
-        with subtest("lxc-container generator configures privileged container"):
-            machine.execute("incus delete --force container")
-            machine.succeed("incus launch nixos container --config security.privileged=true")
-            with machine.nested("Waiting for instance to start and be usable"):
-              retry(instance_is_up)
+            with subtest("lxc-container generator configures privileged container"):
+                machine.execute("incus delete --force container")
+                machine.succeed("incus launch nixos container --config security.privileged=true")
+                with machine.nested("Waiting for instance to start and be usable"):
+                  retry(instance_is_up)
 
-            machine.succeed("incus exec container test -- -e /run/systemd/system/service.d/zzz-lxc-service.conf")
+                machine.succeed("incus exec container test -- -e /run/systemd/system/service.d/zzz-lxc-service.conf")
 
-            check_sysctl("container")
+                check_sysctl("container")
 
-    with subtest("softDaemonRestart"):
-        with subtest("Instance remains running when softDaemonRestart is enabled and services is stopped"):
-            pid = machine.succeed("incus info container | grep 'PID'").split(":")[1].strip()
-            machine.succeed(f"ps {pid}")
-            machine.succeed("systemctl stop incus")
-            machine.succeed(f"ps {pid}")
-  '';
-})
+        with subtest("softDaemonRestart"):
+            with subtest("Instance remains running when softDaemonRestart is enabled and services is stopped"):
+                pid = machine.succeed("incus info container | grep 'PID'").split(":")[1].strip()
+                machine.succeed(f"ps {pid}")
+                machine.succeed("systemctl stop incus")
+                machine.succeed(f"ps {pid}")
+      '';
+  }
+)

nixos/tests/incus/openvswitch.nix

···
-import ../make-test-python.nix ({ pkgs, lib, incus ? pkgs.incus-lts, ... } :
+import ../make-test-python.nix (
+  {
+    pkgs,
+    lib,
+    incus ? pkgs.incus-lts,
+    ...
+  }:
 
-{
-  name = "incus-openvswitch";
+  {
+    name = "incus-openvswitch";
 
-  meta = {
-    maintainers = lib.teams.lxc.members;
-  };
+    meta = {
+      maintainers = lib.teams.lxc.members;
+    };
 
-  nodes.machine = { lib, ... }: {
-    virtualisation = {
-      incus = {
-        enable = true;
-        package = incus;
-      };
+    nodes.machine =
+      { lib, ... }:
+      {
+        virtualisation = {
+          incus = {
+            enable = true;
+            package = incus;
+          };
 
-      vswitch.enable = true;
-      incus.preseed = {
-        networks = [
-          {
-            name = "nixostestbr0";
-            type = "bridge";
-            config = {
-              "bridge.driver" = "openvswitch";
-              "ipv4.address" = "10.0.100.1/24";
-              "ipv4.nat" = "true";
-            };
-          }
-        ];
-        profiles = [
-          {
-            name = "nixostest_default";
-            devices = {
-              eth0 = {
-                name = "eth0";
-                network = "nixostestbr0";
-                type = "nic";
-              };
-              root = {
-                path = "/";
-                pool = "default";
-                size = "35GiB";
-                type = "disk";
-              };
-            };
-          }
-        ];
-        storage_pools = [
-          {
-            name = "nixostest_pool";
-            driver = "dir";
-          }
-        ];
+          vswitch.enable = true;
+          incus.preseed = {
+            networks = [
+              {
+                name = "nixostestbr0";
+                type = "bridge";
+                config = {
+                  "bridge.driver" = "openvswitch";
+                  "ipv4.address" = "10.0.100.1/24";
+                  "ipv4.nat" = "true";
+                };
+              }
+            ];
+            profiles = [
+              {
+                name = "nixostest_default";
+                devices = {
+                  eth0 = {
+                    name = "eth0";
+                    network = "nixostestbr0";
+                    type = "nic";
+                  };
+                  root = {
+                    path = "/";
+                    pool = "default";
+                    size = "35GiB";
+                    type = "disk";
+                  };
+                };
+              }
+            ];
+            storage_pools = [
+              {
+                name = "nixostest_pool";
+                driver = "dir";
+              }
+            ];
+          };
+        };
+        networking.nftables.enable = true;
       };
-    };
-    networking.nftables.enable = true;
-  };
 
-  testScript = ''
-    machine.wait_for_unit("incus.service")
-    machine.wait_for_unit("incus-preseed.service")
+    testScript = ''
+      machine.wait_for_unit("incus.service")
+      machine.wait_for_unit("incus-preseed.service")
 
-    with subtest("Verify openvswitch bridge"):
-      machine.succeed("incus network info nixostestbr0")
+      with subtest("Verify openvswitch bridge"):
+        machine.succeed("incus network info nixostestbr0")
 
-    with subtest("Verify openvswitch bridge"):
-      machine.succeed("ovs-vsctl br-exists nixostestbr0")
-  '';
-})
+      with subtest("Verify openvswitch bridge"):
+        machine.succeed("ovs-vsctl br-exists nixostestbr0")
+    '';
+  }
+)

nixos/tests/incus/socket-activated.nix

···
-import ../make-test-python.nix ({ pkgs, lib, incus ? pkgs.incus-lts, ... } :
+import ../make-test-python.nix (
+  {
+    pkgs,
+    lib,
+    incus ? pkgs.incus-lts,
+    ...
+  }:
 
-{
-  name = "incus-socket-activated";
+  {
+    name = "incus-socket-activated";
 
-  meta = {
-    maintainers = lib.teams.lxc.members;
-  };
+    meta = {
+      maintainers = lib.teams.lxc.members;
+    };
 
-  nodes.machine = { lib, ... }: {
-    virtualisation = {
-      incus = {
-        enable = true;
-        package = incus;
-        socketActivation = true;
+    nodes.machine =
+      { lib, ... }:
+      {
+        virtualisation = {
+          incus = {
+            enable = true;
+            package = incus;
+            socketActivation = true;
+          };
+        };
+        networking.nftables.enable = true;
       };
-    };
-    networking.nftables.enable = true;
-  };
 
-  testScript = ''
-    machine.wait_for_unit("incus.socket")
+    testScript = ''
+      machine.wait_for_unit("incus.socket")
 
-    # ensure service is not running by default
-    machine.fail("systemctl is-active incus.service")
-    machine.fail("systemctl is-active incus-preseed.service")
+      # ensure service is not running by default
+      machine.fail("systemctl is-active incus.service")
+      machine.fail("systemctl is-active incus-preseed.service")
 
-    # access the socket and ensure the service starts
-    machine.succeed("incus list")
-    machine.wait_for_unit("incus.service")
-  '';
-})
+      # access the socket and ensure the service starts
+      machine.succeed("incus list")
+      machine.wait_for_unit("incus.service")
+    '';
+  }
+)

nixos/tests/incus/ui.nix

···
-import ../make-test-python.nix ({ pkgs, lib, incus ? pkgs.incus-lts, ... }: {
-  name = "incus-ui";
+import ../make-test-python.nix (
+  {
+    pkgs,
+    lib,
+    incus ? pkgs.incus-lts,
+    ...
+  }:
+  {
+    name = "incus-ui";
 
-  meta = {
-    maintainers = lib.teams.lxc.members;
-  };
-
-  nodes.machine = { lib, ... }: {
-    virtualisation = {
-      incus = {
-        enable = true;
-        package = incus;
-      };
-      incus.ui.enable = true;
+    meta = {
+      maintainers = lib.teams.lxc.members;
     };
-    networking.nftables.enable = true;
 
-    environment.systemPackages =
-      let
-        seleniumScript = pkgs.writers.writePython3Bin "selenium-script"
-          {
-            libraries = with pkgs.python3Packages; [ selenium ];
-          } ''
-          from selenium import webdriver
-          from selenium.webdriver.common.by import By
-          from selenium.webdriver.firefox.options import Options
-          from selenium.webdriver.support.ui import WebDriverWait
+    nodes.machine =
+      { lib, ... }:
+      {
+        virtualisation = {
+          incus = {
+            enable = true;
+            package = incus;
+          };
+          incus.ui.enable = true;
+        };
+        networking.nftables.enable = true;
 
-          options = Options()
-          options.add_argument("--headless")
-          service = webdriver.FirefoxService(executable_path="${lib.getExe pkgs.geckodriver}")  # noqa: E501
+        environment.systemPackages =
+          let
+            seleniumScript =
+              pkgs.writers.writePython3Bin "selenium-script"
+                {
+                  libraries = with pkgs.python3Packages; [ selenium ];
+                }
+                ''
+                  from selenium import webdriver
+                  from selenium.webdriver.common.by import By
+                  from selenium.webdriver.firefox.options import Options
+                  from selenium.webdriver.support.ui import WebDriverWait
 
-          driver = webdriver.Firefox(options=options, service=service)
-          driver.implicitly_wait(10)
-          driver.get("https://localhost:8443/ui")
+                  options = Options()
+                  options.add_argument("--headless")
+                  service = webdriver.FirefoxService(executable_path="${lib.getExe pkgs.geckodriver}")  # noqa: E501
 
-          wait = WebDriverWait(driver, 60)
+                  driver = webdriver.Firefox(options=options, service=service)
+                  driver.implicitly_wait(10)
+                  driver.get("https://localhost:8443/ui")
 
-          assert len(driver.find_elements(By.CLASS_NAME, "l-application")) > 0
-          assert len(driver.find_elements(By.CLASS_NAME, "l-navigation__drawer")) > 0
+                  wait = WebDriverWait(driver, 60)
 
-          driver.close()
-        '';
-      in
-      with pkgs; [ curl firefox-unwrapped geckodriver seleniumScript ];
-  };
+                  assert len(driver.find_elements(By.CLASS_NAME, "l-application")) > 0
+                  assert len(driver.find_elements(By.CLASS_NAME, "l-navigation__drawer")) > 0
 
+                  driver.close()
+                '';
+          in
+          with pkgs;
+          [
+            curl
+            firefox-unwrapped
+            geckodriver
+            seleniumScript
+          ];
+      };
 
-  testScript = ''
-    machine.wait_for_unit("sockets.target")
-    machine.wait_for_unit("incus.service")
-    machine.wait_for_file("/var/lib/incus/unix.socket")
+    testScript = ''
+      machine.wait_for_unit("sockets.target")
+      machine.wait_for_unit("incus.service")
+      machine.wait_for_file("/var/lib/incus/unix.socket")
 
-    # Configure incus listen address
-    machine.succeed("incus config set core.https_address :8443")
-    machine.succeed("systemctl restart incus")
+      # Configure incus listen address
+      machine.succeed("incus config set core.https_address :8443")
+      machine.succeed("systemctl restart incus")
 
-    # Check that the INCUS_UI environment variable is populated in the systemd unit
-    machine.succeed("cat /etc/systemd/system/incus.service | grep 'INCUS_UI'")
+      # Check that the INCUS_UI environment variable is populated in the systemd unit
+      machine.succeed("cat /etc/systemd/system/incus.service | grep 'INCUS_UI'")
 
-    # Ensure the endpoint returns an HTML page with 'Incus UI' in the title
-    machine.succeed("curl -kLs https://localhost:8443/ui | grep '<title>Incus UI</title>'")
+      # Ensure the endpoint returns an HTML page with 'Incus UI' in the title
+      machine.succeed("curl -kLs https://localhost:8443/ui | grep '<title>Incus UI</title>'")
 
-    # Ensure the application is actually rendered by the Javascript
-    machine.succeed("PYTHONUNBUFFERED=1 selenium-script")
-  '';
-})
+      # Ensure the application is actually rendered by the Javascript
+      machine.succeed("PYTHONUNBUFFERED=1 selenium-script")
+    '';
+  }
+)

nixos/tests/incus/virtual-machine.nix

···
-import ../make-test-python.nix ({ pkgs, lib, incus ? pkgs.incus-lts, ... }:
+import ../make-test-python.nix (
+  {
+    pkgs,
+    lib,
+    incus ? pkgs.incus-lts,
+    ...
+  }:
 
-let
-  releases = import ../../release.nix {
-    configuration = {
-      # Building documentation makes the test unnecessarily take a longer time:
-      documentation.enable = lib.mkForce false;
+  let
+    releases = import ../../release.nix {
+      configuration = {
+        # Building documentation makes the test unnecessarily take a longer time:
+        documentation.enable = lib.mkForce false;
 
-      # Our tests require `grep` & friends:
-      environment.systemPackages = with pkgs; [busybox];
+        # Our tests require `grep` & friends:
+        environment.systemPackages = with pkgs; [ busybox ];
+      };
     };
-  };
 
-  vm-image-metadata = releases.incusVirtualMachineImageMeta.${pkgs.stdenv.hostPlatform.system};
-  vm-image-disk = releases.incusVirtualMachineImage.${pkgs.stdenv.hostPlatform.system};
+    vm-image-metadata = releases.incusVirtualMachineImageMeta.${pkgs.stdenv.hostPlatform.system};
+    vm-image-disk = releases.incusVirtualMachineImage.${pkgs.stdenv.hostPlatform.system};
 
-  instance-name = "instance1";
-in
-{
-  name = "incus-virtual-machine";
+    instance-name = "instance1";
+  in
+  {
+    name = "incus-virtual-machine";
 
-  meta = {
-    maintainers = lib.teams.lxc.members;
-  };
+    meta = {
+      maintainers = lib.teams.lxc.members;
+    };
 
-  nodes.machine = {...}: {
-    virtualisation = {
-      # Ensure test VM has enough resources for creating and managing guests
-      cores = 2;
-      memorySize = 1024;
-      diskSize = 4096;
+    nodes.machine =
+      { ... }:
+      {
+        virtualisation = {
+          # Ensure test VM has enough resources for creating and managing guests
+          cores = 2;
+          memorySize = 1024;
+          diskSize = 4096;
 
-      incus = {
-        enable = true;
-        package = incus;
+          incus = {
+            enable = true;
+            package = incus;
+          };
+        };
+        networking.nftables.enable = true;
       };
-    };
-    networking.nftables.enable = true;
-  };
 
-  testScript = # python
-  ''
-    def instance_is_up(_) -> bool:
-      status, _ = machine.execute("incus exec ${instance-name} --disable-stdin --force-interactive /run/current-system/sw/bin/systemctl -- is-system-running")
-      return status == 0
+    testScript = # python
+      ''
+        def instance_is_up(_) -> bool:
+          status, _ = machine.execute("incus exec ${instance-name} --disable-stdin --force-interactive /run/current-system/sw/bin/systemctl -- is-system-running")
+          return status == 0
 
-    machine.wait_for_unit("incus.service")
+        machine.wait_for_unit("incus.service")
 
-    machine.succeed("incus admin init --minimal")
+        machine.succeed("incus admin init --minimal")
 
-    with subtest("virtual-machine image can be imported"):
-        machine.succeed("incus image import ${vm-image-metadata}/*/*.tar.xz ${vm-image-disk}/nixos.qcow2 --alias nixos")
+        with subtest("virtual-machine image can be imported"):
+            machine.succeed("incus image import ${vm-image-metadata}/*/*.tar.xz ${vm-image-disk}/nixos.qcow2 --alias nixos")
 
-    with subtest("virtual-machine can be created"):
-        machine.succeed("incus create nixos ${instance-name} --vm --config limits.memory=512MB --config security.secureboot=false")
+        with subtest("virtual-machine can be created"):
+            machine.succeed("incus create nixos ${instance-name} --vm --config limits.memory=512MB --config security.secureboot=false")
 
-    with subtest("virtual tpm can be configured"):
-        machine.succeed("incus config device add ${instance-name} vtpm tpm path=/dev/tpm0")
+        with subtest("virtual tpm can be configured"):
+            machine.succeed("incus config device add ${instance-name} vtpm tpm path=/dev/tpm0")
 
-    with subtest("virtual-machine can be launched and become available"):
-        machine.succeed("incus start ${instance-name}")
-        with machine.nested("Waiting for instance to start and be usable"):
-          retry(instance_is_up)
+        with subtest("virtual-machine can be launched and become available"):
+            machine.succeed("incus start ${instance-name}")
+            with machine.nested("Waiting for instance to start and be usable"):
+              retry(instance_is_up)
 
-    with subtest("incus-agent is started"):
-        machine.succeed("incus exec ${instance-name} systemctl is-active incus-agent")
+        with subtest("incus-agent is started"):
+            machine.succeed("incus exec ${instance-name} systemctl is-active incus-agent")
 
-    with subtest("incus-agent has a valid path"):
-        machine.succeed("incus exec ${instance-name} -- bash -c 'true'")
+        with subtest("incus-agent has a valid path"):
+            machine.succeed("incus exec ${instance-name} -- bash -c 'true'")
 
-    with subtest("guest supports cpu hotplug"):
-        machine.succeed("incus config set ${instance-name} limits.cpu=1")
-        count = int(machine.succeed("incus exec ${instance-name} -- nproc").strip())
-        assert count == 1, f"Wrong number of CPUs reported, want: 1, got: {count}"
+        with subtest("guest supports cpu hotplug"):
+            machine.succeed("incus config set ${instance-name} limits.cpu=1")
+            count = int(machine.succeed("incus exec ${instance-name} -- nproc").strip())
+            assert count == 1, f"Wrong number of CPUs reported, want: 1, got: {count}"
 
-        machine.succeed("incus config set ${instance-name} limits.cpu=2")
-        count = int(machine.succeed("incus exec ${instance-name} -- nproc").strip())
-        assert count == 2, f"Wrong number of CPUs reported, want: 2, got: {count}"
+            machine.succeed("incus config set ${instance-name} limits.cpu=2")
+            count = int(machine.succeed("incus exec ${instance-name} -- nproc").strip())
+            assert count == 2, f"Wrong number of CPUs reported, want: 2, got: {count}"
 
-    with subtest("Instance remains running when softDaemonRestart is enabled and services is stopped"):
-        pid = machine.succeed("incus info ${instance-name} | grep 'PID'").split(":")[1].strip()
-        machine.succeed(f"ps {pid}")
-        machine.succeed("systemctl stop incus")
-        machine.succeed(f"ps {pid}")
-  '';
-})
+        with subtest("Instance remains running when softDaemonRestart is enabled and services is stopped"):
+            pid = machine.succeed("incus info ${instance-name} | grep 'PID'").split(":")[1].strip()
+            machine.succeed(f"ps {pid}")
+            machine.succeed("systemctl stop incus")
+            machine.succeed(f"ps {pid}")
+      '';
+  }
+)

nixos/tests/networking/networkd-and-scripted.nix

···
               };
               bridges.bridge.interfaces = [ "greTunnel" "eth1" ];
               interfaces.eth1.ipv4.addresses = lib.mkOverride 0 [];
+              interfaces.eth1.ipv6.addresses = lib.mkOverride 0 [];
               interfaces.bridge.ipv4.addresses = lib.mkOverride 0 [
                 { address = "192.168.1.1"; prefixLength = 24; }
               ];
···
               };
               bridges.bridge.interfaces = [ "greTunnel" "eth2" ];
               interfaces.eth2.ipv4.addresses = lib.mkOverride 0 [];
+              interfaces.eth2.ipv6.addresses = lib.mkOverride 0 [];
               interfaces.bridge.ipv4.addresses = lib.mkOverride 0 [
                 { address = "192.168.1.2"; prefixLength = 24; }
               ];

nixos/tests/vscodium.nix

···
     wayland = { pkgs, ... }: {
       imports = [ ./common/wayland-cage.nix ];
 
-      services.cage.program = "${pkgs.vscodium}/bin/codium";
+      # We scale vscodium to help OCR find the small "Untitled" text.
+      services.cage.program = "${pkgs.vscodium}/bin/codium --force-device-scale-factor=2";
 
       environment.variables.NIXOS_OZONE_WL = "1";
       environment.variables.DISPLAY = "do not use";
···
       virtualisation.memorySize = 2047;
       services.xserver.enable = true;
       services.xserver.displayManager.sessionCommands = ''
-        ${pkgs.vscodium}/bin/codium
+        ${pkgs.vscodium}/bin/codium --force-device-scale-factor=2
       '';
       test-support.displayManager.auto.user = "alice";
     };
···
         codium_running.wait() # type: ignore[union-attr]
         with codium_running: # type: ignore[union-attr]
             # Wait until vscodium is visible. "File" is in the menu bar.
-            machine.wait_for_text('Welcome')
+            machine.wait_for_text('Get Started with')
             machine.screenshot('start_screen')
 
             test_string = 'testfile'

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

···
     meta.homepage = "https://github.com/chrisbra/csv.vim/";
   };
 
+  csvview-nvim = buildVimPlugin {
+    pname = "csvview.nvim";
+    version = "2024-11-18";
+    src = fetchFromGitHub {
+      owner = "hat0uma";
+      repo = "csvview.nvim";
+      rev = "63b6585fc22bba2060e6dd4600bd2dd0b77dd446";
+      sha256 = "0615vjdiwij5j6qxa5hfvylq9swp0z6lm5xc38yk6yxhjrkcdvyg";
+    };
+    meta.homepage = "https://github.com/hat0uma/csvview.nvim/";
+  };
+
   ctrlp-cmatcher = buildVimPlugin {
     pname = "ctrlp-cmatcher";
     version = "2015-10-15";
···
       sha256 = "1p6cn0m47l367i0qv94rgcx66y0p7sf7nnzk80qdasvyqij5rjg1";
     };
     meta.homepage = "https://github.com/NTBBloodbath/doom-one.nvim/";
+  };
+
+  dotnet-nvim = buildVimPlugin {
+    pname = "dotnet.nvim";
+    version = "2024-10-21";
+    src = fetchFromGitHub {
+      owner = "MoaidHathot";
+      repo = "dotnet.nvim";
+      rev = "f5c52f9f52a3d8ca8dff6916c2228fb41a075274";
+      sha256 = "1ysqh2aj3iy2q0cl7i642c03jb7cakqhgbqslcfd7dfvibidd2a2";
+    };
+    meta.homepage = "https://github.com/MoaidHathot/dotnet.nvim/";
   };
 
   dracula-nvim = buildVimPlugin {
···
       sha256 = "0ik9jnd561ipdclmxpbc0b1b4qykhkaqmmc2wr9iw4gmszjskhf1";
     };
     meta.homepage = "https://github.com/leoluz/nvim-dap-go/";
+  };
+
+  nvim-dap-lldb = buildVimPlugin {
+    pname = "nvim-dap-lldb";
+    version = "2024-06-09";
+    src = fetchFromGitHub {
+      owner = "julianolf";
+      repo = "nvim-dap-lldb";
+      rev = "81273514fdb5107b79090364b57a3ff5570bea21";
+      sha256 = "18ds6kkrip0m2zanmzfqcr31qnw1whara1mvsnmx30z6iwgdp92w";
+    };
+    meta.homepage = "https://github.com/julianolf/nvim-dap-lldb/";
   };
 
   nvim-dap-python = buildVimPlugin {

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

···
       '';
   });
 
+  dotnet-nvim = super.dotnet-nvim.overrideAttrs {
+    dependencies = with self; [
+      telescope-nvim
+      plenary-nvim
+    ];
+  };
+
   efmls-configs-nvim = super.efmls-configs-nvim.overrideAttrs {
     dependencies = [ self.nvim-lspconfig ];
   };
···
 
   nvim-fzf-commands = super.nvim-fzf-commands.overrideAttrs {
     dependencies = [ self.nvim-fzf ];
+  };
+
+  nvim-dap-lldb = super.nvim-dap-lldb.overrideAttrs {
+    dependencies = [ self.nvim-dap ];
   };
 
   nvim-dap-python = super.nvim-dap-python.overrideAttrs {

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

···
 https://github.com/godlygeek/csapprox/,,
 https://github.com/Decodetalkers/csharpls-extended-lsp.nvim/,HEAD,
 https://github.com/chrisbra/csv.vim/,,
+https://github.com/hat0uma/csvview.nvim/,HEAD,
 https://github.com/JazzCore/ctrlp-cmatcher/,,
 https://github.com/FelikZ/ctrlp-py-matcher/,,
 https://github.com/amiorin/ctrlp-z/,,
···
 https://github.com/chipsenkbeil/distant.nvim/,HEAD,
 https://github.com/doki-theme/doki-theme-vim/,,
 https://github.com/NTBBloodbath/doom-one.nvim/,,
+https://github.com/MoaidHathot/dotnet.nvim/,HEAD,
 https://github.com/dracula/vim/,,dracula-vim
 https://github.com/Mofiqul/dracula.nvim/,HEAD,
 https://github.com/stevearc/dressing.nvim/,,
···
 https://github.com/yamatsum/nvim-cursorline/,,
 https://github.com/mfussenegger/nvim-dap/,,
 https://github.com/leoluz/nvim-dap-go/,HEAD,
+https://github.com/julianolf/nvim-dap-lldb/,HEAD,
 https://github.com/mfussenegger/nvim-dap-python/,HEAD,
 https://github.com/rinx/nvim-dap-rego/,HEAD,
 https://github.com/jonboh/nvim-dap-rr/,HEAD,

pkgs/applications/networking/mullvad-vpn/default.nix pkgs/by-name/mu/mullvad-vpn/package.nix

···
-{ stdenv
-, lib
-, fetchurl
-, dpkg
-, alsa-lib
-, atk
-, cairo
-, cups
-, dbus
-, expat
-, fontconfig
-, freetype
-, gdk-pixbuf
-, glib
-, pango
-, nspr
-, nss
-, gtk3
-, mesa
-, libGL
-, wayland
-, xorg
-, autoPatchelfHook
-, systemd
-, libnotify
-, libappindicator
-, makeWrapper
-, coreutils
-, gnugrep
+{
+  stdenv,
+  lib,
+  fetchurl,
+  dpkg,
+  alsa-lib,
+  atk,
+  cairo,
+  cups,
+  dbus,
+  expat,
+  fontconfig,
+  freetype,
+  gdk-pixbuf,
+  glib,
+  pango,
+  nspr,
+  nss,
+  gtk3,
+  mesa,
+  libGL,
+  wayland,
+  xorg,
+  autoPatchelfHook,
+  systemd,
+  libnotify,
+  libappindicator,
+  makeWrapper,
+  coreutils,
+  gnugrep,
+
+  versionCheckHook,
 }:
 
 let
···
     systemd
   ];
 
-  version = "2024.6";
+  version = "2024.7";
 
-  selectSystem = attrs: attrs.${stdenv.hostPlatform.system} or (throw "Unsupported system: ${stdenv.hostPlatform.system}");
+  selectSystem =
+    attrs:
+    attrs.${stdenv.hostPlatform.system} or (throw "Unsupported system: ${stdenv.hostPlatform.system}");
 
   platform = selectSystem {
     x86_64-linux = "amd64";
···
   };
 
   hash = selectSystem {
-    x86_64-linux = "sha256-paP9W23AbA9O4MiTdF5r7N50GgT4xu2vb9ktfBdPqDM=";
-    aarch64-linux = "sha256-5FRPjiLyWDe7RNlhkiF4NUaCxVkfXZbxeoQxNAAls/I=";
+    x86_64-linux = "sha256-l6uWrOzMzn8bF5iZzfa/xffLIvAPsCaLwzcRPRW3t0o=";
+    aarch64-linux = "sha256-/RLTjhkiH9WdYO56njnxQyJ0nSaAq/awrkm0NhctFZY=";
   };
 in
 
···
   dontBuild = true;
   dontConfigure = true;
 
-  runtimeDependencies = [ (lib.getLib systemd) libGL libnotify libappindicator wayland ];
+  runtimeDependencies = [
+    (lib.getLib systemd)
+    libGL
+    libnotify
+    libappindicator
+    wayland
+  ];
 
   installPhase = ''
     runHook preInstall
···
 
     wrapProgram $out/bin/mullvad-vpn \
       --set MULLVAD_DISABLE_UPDATE_NOTIFICATION 1 \
-      --prefix PATH : ${lib.makeBinPath [ coreutils gnugrep ]}
+      --prefix PATH : ${
+        lib.makeBinPath [
+          coreutils
+          gnugrep
+        ]
+      }
 
     wrapProgram $out/bin/mullvad-daemon \
         --set-default MULLVAD_RESOURCE_DIR "$out/share/mullvad/resources"
···
     runHook postInstall
   '';
 
+  nativeInstallCheckInputs = [
+    versionCheckHook
+  ];
+  versionCheckProgramArg = [ "--version" ];
+  doInstallCheck = true;
+
   passthru.updateScript = ./update.sh;
 
-  meta = with lib; {
+  meta = {
     homepage = "https://github.com/mullvad/mullvadvpn-app";
     description = "Client for Mullvad VPN";
     changelog = "https://github.com/mullvad/mullvadvpn-app/blob/${version}/CHANGELOG.md";
-    sourceProvenance = with sourceTypes; [ binaryNativeCode ];
-    license = licenses.gpl3Only;
-    platforms = [ "x86_64-linux" "aarch64-linux" ];
-    maintainers = with maintainers; [ Br1ght0ne ymarkus ataraxiasjel ];
+    sourceProvenance = with lib.sourceTypes; [ binaryNativeCode ];
+    license = lib.licenses.gpl3Only;
+    platforms = lib.platforms.unix;
+    badPlatforms = [ lib.systems.inspect.patterns.isDarwin ];
+    maintainers = with lib.maintainers; [
+      Br1ght0ne
+      ymarkus
+      ataraxiasjel
+    ];
   };
-
 }

pkgs/applications/radio/gqrx/default.nix

···
 
 gnuradioMinimal.pkgs.mkDerivation rec {
   pname = "gqrx";
-  version = "2.17.5";
+  version = "2.17.6";
 
   src = fetchFromGitHub {
     owner = "gqrx-sdr";
     repo = "gqrx";
     rev = "v${version}";
-    hash = "sha256-9VePsl/vaSTZ1TMyIeaGoZNrZv+O/7BxQ3ubD5S2EjY=";
+    hash = "sha256-/ykKcwOotu8kn+EpJI+EUeqSkHZ2IrSh+o7lBGeHrZ0=";
   };
 
   nativeBuildInputs = [

pkgs/applications/video/mpv/scripts/mpv-image-viewer.nix

···
     let
       self = {
         inherit pname;
-        version = "0-unstable-2023-03-03";
+        version = "0-unstable-2024-11-23";
         src = fetchFromGitHub {
           owner = "occivink";
           repo = "mpv-image-viewer";
-          rev = "efc82147cba4809f22e9afae6ed7a41ad9794ffd";
-          hash = "sha256-H7uBwrIb5uNEr3m+rHED/hO2CHypGu7hbcRpC30am2Q=";
+          rev = "128b498e3e57a14deea5ca9bbf662f8c1ca79e8d";
+          hash = "sha256-VwIL1529CW9MLK4N9jHHddSSZD5RsJ5bWGWqGJ751C0=";
         };
 
         sourceRoot = "source/scripts";

pkgs/build-support/build-fhsenv-bubblewrap/buildFHSEnv.nix

···
 
   allPaths = paths ++ paths32;
 
-  rootfs-builder = pkgs.rustPlatform.buildRustPackage {
+  rootfs-builder = pkgs.buildPackages.rustPlatform.buildRustPackage {
     name = "fhs-rootfs-bulder";
     src = ./rootfs-builder;
     cargoLock.lockFile = ./rootfs-builder/Cargo.lock;

pkgs/build-support/vm/default.nix

···
           set -- $(IFS==; echo $o)
           command=$2
           ;;
-        out=*)
-          set -- $(IFS==; echo $o)
-          export out=$2
-          ;;
       esac
     done
 
···
     mkdir -p /fs${storeDir}
     mount -t 9p store /fs${storeDir} -o trans=virtio,version=9p2000.L,cache=loose,msize=131072
 
-    echo "mounting host's build directory..."
-    mkdir -p /fs/build
-    mount -t 9p sa /fs/build -o trans=virtio,version=9p2000.L,cache=loose,msize=131072
-
     mkdir -p /fs/tmp /fs/run /fs/var
     mount -t tmpfs -o "mode=1777" none /fs/tmp
     mount -t tmpfs -o "mode=755" none /fs/run
     ln -sfn /run /fs/var/run
 
+    echo "mounting host's temporary directory..."
+    mkdir -p /fs/tmp/xchg
+    mount -t 9p xchg /fs/tmp/xchg -o trans=virtio,version=9p2000.L,msize=131072
+
     mkdir -p /fs/proc
     mount -t proc none /fs/proc
 
···
     fi
 
     echo "starting stage 2 ($command)"
-    exec switch_root /fs $command $out
+    exec switch_root /fs $command
   '';
 
 
···
   stage2Init = writeScript "vm-run-stage2" ''
     #! ${bash}/bin/sh
     set -euo pipefail
-    source /build/xchg/saved-env
-    if [ -f "''${NIX_ATTRS_SH_FILE-}" ]; then
-      source "$NIX_ATTRS_SH_FILE"
+    source /tmp/xchg/saved-env
+    if [ -f /tmp/xchg/.attrs.sh ]; then
+      source /tmp/xchg/.attrs.sh
+      export NIX_ATTRS_JSON_FILE=/tmp/xchg/.attrs.json
+      export NIX_ATTRS_SH_FILE=/tmp/xchg/.attrs.sh
     fi
-    source $stdenv/setup
 
     export NIX_STORE=${storeDir}
     export NIX_BUILD_TOP=/tmp
     export TMPDIR=/tmp
     export PATH=/empty
     cd "$NIX_BUILD_TOP"
+
+    source $stdenv/setup
 
     if ! test -e /bin/sh; then
       ${coreutils}/bin/mkdir -p /bin
···
       declare -a argsArray=()
       concatTo argsArray origArgs
       "$origBuilder" "''${argsArray[@]}"
-      echo $? > /build/xchg/in-vm-exit
+      echo $? > /tmp/xchg/in-vm-exit
 
       ${busybox}/bin/mount -o remount,ro dummy /
 
···
       -nographic -no-reboot \
       -device virtio-rng-pci \
       -virtfs local,path=${storeDir},security_model=none,mount_tag=store \
-      -virtfs local,path=/build,security_model=none,mount_tag=sa \
-      -virtfs local,path=$TMPDIR/xchg,security_model=none,mount_tag=xchg \
+      -virtfs local,path=xchg,security_model=none,mount_tag=xchg \
       ''${diskImage:+-drive file=$diskImage,if=virtio,cache=unsafe,werror=report} \
       -kernel ${kernel}/${img} \
       -initrd ${initrd}/initrd \
···
 
 
   vmRunCommand = qemuCommand: writeText "vm-run" ''
+    ${coreutils}/bin/mkdir xchg
+    export > xchg/saved-env
+    PATH=${coreutils}/bin
+
     if [ -f "''${NIX_ATTRS_SH_FILE-}" ]; then
+      cp $NIX_ATTRS_JSON_FILE $NIX_ATTRS_SH_FILE xchg
       source "$NIX_ATTRS_SH_FILE"
     fi
     source $stdenv/setup
-    export > saved-env
-
-    PATH=${coreutils}/bin
-    mkdir xchg
-    mv saved-env xchg/
 
     eval "$preVM"
 
···
     cat > ./run-vm <<EOF
     #! ${bash}/bin/sh
     ''${diskImage:+diskImage=$diskImage}
-    TMPDIR=$TMPDIR
-    cd $TMPDIR
     ${qemuCommand}
     EOF
 

pkgs/build-support/vm/test.nix

···
   buildPatchelfInVM = runInLinuxVM patchelf;
 
   buildHelloInVM = runInLinuxVM hello;
+  buildStructuredAttrsHelloInVM = runInLinuxVM (hello.overrideAttrs { __structuredAttrs = true; });
 
   buildPcmanrmInVM = runInLinuxVM (pcmanfm.overrideAttrs (old: {
     # goes out-of-memory with many cores

pkgs/by-name/ap/apt/package.nix

···
 
 stdenv.mkDerivation (finalAttrs: {
   pname = "apt";
-  version = "2.9.8";
+  version = "2.9.16";
 
   src = fetchurl {
     url = "mirror://debian/pool/main/a/apt/apt_${finalAttrs.version}.tar.xz";
-    hash = "sha256-VPt7NL25PqIIESOrNfiTwm/g8+gApU6Onsy18+LslxA=";
+    hash = "sha256-9ncx162Jm4WZBYFPvtO03ic8/rhcGEUEPxR4x1LsnvQ=";
   };
 
   # cycle detection; lib can't be split

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

···
     hash = "sha256-m5TGZmAu//e/QC7M5wbDR/OMOctjSY+dOWJoYeVkbiA=";
   };
 
-  nativeBuildInputs = lib.optionals withAtopgpu [
+  nativeBuildInputs = [
+    pkg-config
+  ] ++ lib.optionals withAtopgpu [
     python3.pkgs.wrapPython
   ];
 
···
     glib
     zlib
     ncurses
-    pkg-config
   ] ++ lib.optionals withAtopgpu [
     python3
   ];

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

···
     {
       x86_64-linux = {
         name = "BombSquad_Linux_x86_64";
-        hash = "sha256-jrExsqaM6uhnKMGPkJJTsKt2Imek+YDI2soSP/kfPj0=";
+        hash = "sha256-aujLYzFcKaW0ff7sRdyJ6SvSQowafWVbmwycQfDQUYY=";
       };
       aarch-64-linux = {
         name = "BombSquad_Linux_Arm64";
-        hash = "sha256-o1Yg0C5k07NZzc9jQrHXR+kkQl8HZ55U9/fqcpe3Iyw=";
+        hash = "sha256-pPP7QZzToTOQtSxzF7Q3ZzlDjUjQWMBM/y79d6Yf38I=";
       };
     }
     .${stdenv.targetPlatform.system} or (throw "${stdenv.targetPlatform.system} is unsupported.");

pkgs/by-name/ca/caligula/package.nix

···
 { lib
 , rustPlatform
 , fetchFromGitHub
-, llvmPackages
-, stdenv
-, darwin
 }:
 
 rustPlatform.buildRustPackage rec {
···
 
   cargoHash = "sha256-ma7JVbWSiKfkCXCDwA8DFm2+KPrWR+8nSdgGSqehNg8=";
 
-  env = {
-     LIBCLANG_PATH = "${lib.getLib llvmPackages.libclang}/lib";
-   };
-
-
-  buildInputs = lib.optionals stdenv.hostPlatform.isDarwin (
-    with darwin.apple_sdk.frameworks; [
-      Cocoa
-      IOKit
-      Foundation
-      DiskArbitration
-    ]
-  );
+  nativeBuildInputs = [
+    rustPlatform.bindgenHook
+  ];
 
   RUSTFLAGS = "--cfg tracing_unstable";
 

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

···
 
 rustPlatform.buildRustPackage rec {
   pname = "chainsaw";
-  version = "2.9.2";
+  version = "2.10.1";
 
   src = fetchFromGitHub {
     owner = "WithSecureLabs";
     repo = "chainsaw";
     rev = "refs/tags/v${version}";
-    hash = "sha256-oKlLFKCZNBcHURVvT0i8Hfym6r30ikndV30uuxjYgDM=";
+    hash = "sha256-ErDIfLhzCiFm3dZzr6ThjYCplfDKbALAqcu8c0gREH4=";
   };
 
-  cargoHash = "sha256-1w3DYP69aOphoqbsZIF9aX56Lftg2niKClmImLTa5DE=";
+  cargoHash = "sha256-WuPfYxI61wsQyOKqPF7/a3Hx9vMBCkTkoXsZczgeKpg=";
 
   buildInputs = lib.optionals stdenv.hostPlatform.isDarwin [
     darwin.apple_sdk.frameworks.CoreFoundation

pkgs/by-name/di/distrobuilder/generator.nix

···
-{ stdenvNoCC, lib, src, version, makeWrapper, coreutils, findutils, gnugrep, systemd }:
+{
+  stdenvNoCC,
+  lib,
+  src,
+  version,
+  makeWrapper,
+  coreutils,
+  findutils,
+  gnugrep,
+  systemd,
+}:
 
 stdenvNoCC.mkDerivation {
   name = "distrobuilder-nixos-generator";
···
 
   installPhase = ''
     install -D -m 0555 distrobuilder/lxc.generator $out/lib/systemd/system-generators/lxc
-    wrapProgram $out/lib/systemd/system-generators/lxc --prefix PATH : ${lib.makeBinPath [coreutils findutils gnugrep systemd]}:${systemd}/lib/systemd
+    wrapProgram $out/lib/systemd/system-generators/lxc --prefix PATH : ${
+      lib.makeBinPath [
+        coreutils
+        findutils
+        gnugrep
+        systemd
+      ]
+    }:${systemd}/lib/systemd
   '';
 }

pkgs/by-name/di/distrobuilder/package.nix

···
-{ lib
-, buildGoModule
-, callPackage
-, cdrkit
-, coreutils
-, debootstrap
-, fetchFromGitHub
-, gnupg
-, gnutar
-, hivex
-, makeWrapper
-, nixosTests
-, pkg-config
-, squashfsTools
-, stdenv
-, wimlib
+{
+  lib,
+  buildGoModule,
+  callPackage,
+  cdrkit,
+  coreutils,
+  debootstrap,
+  fetchFromGitHub,
+  gnupg,
+  gnutar,
+  hivex,
+  makeWrapper,
+  nixosTests,
+  pkg-config,
+  squashfsTools,
+  stdenv,
+  wimlib,
 }:
 
 let
-  bins = [
-    coreutils
-    debootstrap
-    gnupg
-    gnutar
-    squashfsTools
-  ] ++ lib.optionals stdenv.hostPlatform.isx86_64 [
-    # repack-windows deps
-    cdrkit
-    hivex
-    wimlib
-  ];
+  bins =
+    [
+      coreutils
+      debootstrap
+      gnupg
+      gnutar
+      squashfsTools
+    ]
+    ++ lib.optionals stdenv.hostPlatform.isx86_64 [
+      # repack-windows deps
+      cdrkit
+      hivex
+      wimlib
+    ];
 in
 buildGoModule rec {
   pname = "distrobuilder";
···
   };
 
   buildInputs = bins;
-
 
   # tests require a local keyserver (mkg20001/nixpkgs branch distrobuilder-with-tests) but gpg is currently broken in tests
   doCheck = false;

pkgs/by-name/dm/dmarc-metrics-exporter/package.nix

···
 
 python3.pkgs.buildPythonApplication rec {
   pname = "dmarc-metrics-exporter";
-  version = "1.1.0";
+  version = "1.2.0";
 
   pyproject = true;
 
···
     owner = "jgosmann";
     repo = "dmarc-metrics-exporter";
     rev = "refs/tags/v${version}";
-    hash = "sha256-xzIYlOZ1HeW+jbVDVlUPTIooFraQ0cJltsDoCzVMNsA=";
+    hash = "sha256-cIsI4TNYuLK0fpUg9lnbl5KSBtzQoT/pTByI9hiy/7o=";
   };
 
   pythonRelaxDeps = true;

pkgs/by-name/et/etesync-dav/package.nix

···
 , nixosTests
 , python3
 , fetchFromGitHub
-, radicale3
+, radicale
 }:
 
 python3.pkgs.buildPythonApplication {
···
     flask-wtf
     msgpack
     setuptools
-    (python.pkgs.toPythonModule (radicale3.override { python3 = python; }))
+    (python.pkgs.toPythonModule (radicale.override { python3 = python; }))
     requests
     types-setuptools
   ] ++ requests.optional-dependencies.socks;

pkgs/by-name/et/etlegacy-assets/package.nix

···
 
 stdenv.mkDerivation {
   pname = "etlegacy-assets";
-  version = "2.82.0";
+  version = "2.83.1";
 
   srcs = let
     fetchAsset = { asset, hash }: fetchurl {

pkgs/by-name/et/etlegacy-unwrapped/package.nix

···
 , zlib
 }:
 let
-  version = "2.82.1";
+  version = "2.83.1";
   fakeGit = writeShellApplication {
     name = "git";
 
···
     owner = "etlegacy";
     repo = "etlegacy";
     rev = "refs/tags/v${version}";
-    hash = "sha256-DA5tudbehXIU+4hX3ggcxWZ7AAOa8LUkIvUHbgMgDY8=";
+    hash = "sha256-k1H3irA9UVOICY3keKGVJMtBczW/b5ObyNvB7fGAcFA=";
   };
 
   nativeBuildInputs = [

pkgs/by-name/et/etlegacy/package.nix

···
 
 symlinkJoin {
   name = "etlegacy";
-  version = "2.82.1";
+  version = "2.83.1";
   paths = [
     etlegacy-assets
     etlegacy-unwrapped

pkgs/by-name/ev/evcc/package.nix

···
 
 buildGoModule rec {
   pname = "evcc";
-  version = "0.131.6";
+  version = "0.131.8";
 
   src = fetchFromGitHub {
     owner = "evcc-io";
     repo = "evcc";
     rev = version;
-    hash = "sha256-r9GaihxC9ZQtTzKqfJ3LLDMzDEXeud7vTFEMOf0whFU=";
+    hash = "sha256-W04iXqABwp5fDesOZf633mS6caEsGv0lHEyCzqEv1WA=";
   };
 
   vendorHash = "sha256-x0EWFsR/O2Ztg39DL+yZx2ZDzJHADo2aPAeg/i+5KqM=";
 
   npmDeps = fetchNpmDeps {
     inherit src;
-    hash = "sha256-4pQYv5UKoz3Gu5OS0zoYrjrFYD796MDb7ofWbTv3HlU=";
+    hash = "sha256-MjmqVyIj/foI6FFMydpbZA3wL09qs02eAq7Tk872JKM=";
   };
 
   nativeBuildInputs = [

pkgs/by-name/fe/fedimint/package.nix

···
 { lib
 , buildPackages
-, clang
 , fetchFromGitHub
-, libclang
-, libiconv
-, llvmPackages_12
 , openssl
 , pkg-config
 , protobuf
 , rustPlatform
-, stdenv
-, Security
-, SystemConfiguration
 }:
-let
-  # Rust rocksdb bindings have C++ compilation/linking errors on Darwin when using newer clang
-  # Forcing it to clang 12 fixes the issue.
-  buildRustPackage =
-    if stdenv.hostPlatform.isDarwin then
-      rustPlatform.buildRustPackage.override { stdenv = llvmPackages_12.stdenv; }
-    else
-      rustPlatform.buildRustPackage;
-in
-buildRustPackage rec {
+
+rustPlatform.buildRustPackage rec {
   pname = "fedimint";
   version = "0.4.4";
 
···
   nativeBuildInputs = [
     protobuf
     pkg-config
-    clang
-    (lib.getLib libclang)
+    rustPlatform.bindgenHook
   ];
 
   buildInputs = [
     openssl
-  ] ++ lib.optionals stdenv.hostPlatform.isDarwin [
-    Security
-    libiconv
-    Security
-    SystemConfiguration
   ];
 
   outputs = [ "out" "fedimintCli" "fedimint" "gateway" "gatewayCli" "devimint" ];
···
   PROTOC = "${buildPackages.protobuf}/bin/protoc";
   PROTOC_INCLUDE = "${protobuf}/include";
   OPENSSL_DIR = openssl.dev;
-  LIBCLANG_PATH = "${lib.getLib libclang}/lib";
 
   FEDIMINT_BUILD_FORCE_GIT_HASH = "0000000000000000000000000000000000000000";
 

pkgs/by-name/ga/gapless/package.nix

···
 }:
 stdenv.mkDerivation (finalAttrs: {
   pname = "gapless";
-  version = "4.0";
+  version = "4.2";
 
   src = fetchFromGitLab {
     domain = "gitlab.gnome.org";
     owner = "neithern";
     repo = "g4music";
     rev = "v${finalAttrs.version}";
-    hash = "sha256-t9YthW8HZz2kXYPvidVRy7GVB2cRGEOCrXZtIpW65MA=";
+    hash = "sha256-lH3bogDbUjfNC6rC1UG2MiLRmc8YDaP0+STNKzg54dQ=";
   };
 
   nativeBuildInputs = [

pkgs/by-name/gc/gcov2lcov/package.nix

···
 
 buildGoModule rec {
   pname = "gcov2lcov";
-  version = "1.1.0";
+  version = "1.1.1";
 
   src = fetchFromGitHub {
     owner = "jandelgado";
     repo = "gcov2lcov";
     rev = "v${version}";
-    hash = "sha256-E8TPxaKJTd+5OP9e5S1FD5aZP42nJvjiqqNs4xP9gm4=";
+    hash = "sha256-ifXpT5jGNaStqvzP5Rq6Hf6PFhpiKMRC+eSYOZfzt+s=";
   };
 
   vendorHash = "sha256-/2OIBWXbNch6lmw0C1jkyJfNefJXOVG9/jNW8CYHTsc=";

pkgs/by-name/ge/gerrit/package.nix

···
-{ lib, stdenv, fetchurl, nixosTests }:
+{
+  lib,
+  stdenv,
+  fetchurl,
+  nixosTests,
+}:
 
 stdenv.mkDerivation rec {
   pname = "gerrit";
-  version = "3.10.2";
+  version = "3.10.3";
 
   src = fetchurl {
     url = "https://gerrit-releases.storage.googleapis.com/gerrit-${version}.war";
-    hash = "sha256-jsyL7j4ENzHVi07Uii0ouWXF3hkoGrq3NJi8fB1kj8o=";
+    hash = "sha256-pVI5YZihvJNuaboh2dLe/Aw371rNPiGbaLUd0ALpANQ=";
   };
 
   buildCommand = ''
···
     license = licenses.asl20;
     description = "Web based code review and repository management for the git version control system";
     sourceProvenance = with sourceTypes; [ binaryBytecode ];
-    maintainers = with maintainers; [ flokli zimbatm ];
+    maintainers = with maintainers; [
+      flokli
+      zimbatm
+    ];
     platforms = platforms.unix;
   };
 }

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

···
 
 buildGo123Module rec {
   pname = "glab";
-  version = "1.49.0";
+  version = "1.50.0";
 
   src = fetchFromGitLab {
     owner = "gitlab-org";
     repo = "cli";
     rev = "v${version}";
-    hash = "sha256-G9z9lISalj3ZXlvDY+qA+0NB6F7flBd1cTcGfxrM91U=";
+    hash = "sha256-WQO+9Fmlzj21UPJ9cdFc6JC8mbkzOWxz077JR+11BXA=";
   };
 
-  vendorHash = "sha256-SsWZO77KqDPzyEK57WaK4NpnDWUtZPP0qur2EvEoiL0=";
+  vendorHash = "sha256-nwHY0221nacHk4M+RKA8BEJLCoJJdIKwP0ZPjhYxc7Q=";
 
   ldflags = [
     "-s"

pkgs/by-name/go/goodvibes/package.nix

···
 { lib
 , stdenv
 , fetchFromGitLab
-, fetchpatch
 , meson
 , ninja
 , pkg-config
···
 
 stdenv.mkDerivation rec {
   pname = "goodvibes";
-  version = "0.8.0";
+  version = "0.8.1";
 
   src = fetchFromGitLab {
     owner = pname;
     repo = pname;
     rev = "v${version}";
-    hash = "sha256-KflLEc6BFA3pBY9HukEm5NluGi2igFNP6joOMdmZ0Ds=";
+    hash = "sha256-zqJbtCqdwKXy13WWoAwSRYVhAOJsHqOF0DriSDEigbI=";
   };
-  patches = [
-    # Fixes a compilation error
-    (fetchpatch {
-      url = "https://gitlab.com/goodvibes/goodvibes/-/commit/e332f831b91ee068a1a58846d7607b30ab010116.patch";
-      hash = "sha256-PzbTltbD0xWJAytCGg1TAwBLrICP+9QZbCbG1QQ8Qmw=";
-    })
-  ];
 
   nativeBuildInputs = [
     meson

pkgs/by-name/gr/grpcui/package.nix

···
 
 buildGoModule rec {
   pname = "grpcui";
-  version = "1.4.1";
+  version = "1.4.2";
 
   src = fetchFromGitHub {
     owner = "fullstorydev";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-OIwfLuWY7Y0t85v+P/0F55vEe0hNohlqMl16Omr8AF0=";
+    sha256 = "sha256-yk9SgQMUga7htP7XTKFk2JGzixxBV3y3PrnkzsiAMbw=";
   };
 
-  vendorHash = "sha256-dEek7q8OjFgCn+f/qyiQL/5qu8RJp38vZk3OrBREHx4=";
+  vendorHash = "sha256-uP5jtFji2E6GqpzjD7X5p59TXu7KQVBgEX+Gh0BIclM=";
 
   doCheck = false;
 

pkgs/by-name/in/incus/ui.nix

···
-{ lib
-, stdenv
-, fetchFromGitHub
-, fetchYarnDeps
-, nodejs
-, fixup-yarn-lock
-, yarn
-, nixosTests
-, git
+{
+  lib,
+  stdenv,
+  fetchFromGitHub,
+  fetchYarnDeps,
+  nodejs,
+  fixup-yarn-lock,
+  yarn,
+  nixosTests,
+  git,
 }:
 
 stdenv.mkDerivation rec {

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

···
 
 python3.pkgs.buildPythonApplication rec {
   pname = "komikku";
-  version = "1.63.0";
+  version = "1.64.0";
 
   format = "other";
 
···
     owner = "valos";
     repo = "Komikku";
     rev = "v${version}";
-    hash = "sha256-+p5iTB98jpCqodvSEZ9Y8SM9W3M57Lpoh9jAzN3OmRs=";
+    hash = "sha256-EpKLez5gTHCSJYGvDqmzj6YO1dIugZKrEP4zE2G5TxA=";
   };
 
   nativeBuildInputs = [

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

···
 
 buildGoModule rec {
   pname = "kube-bench";
-  version = "0.9.0";
+  version = "0.9.2";
 
   src = fetchFromGitHub {
     owner = "aquasecurity";
     repo = pname;
     rev = "refs/tags/v${version}";
-    hash = "sha256-x6xCrxePB/TR7BP1kLiVFjv4pLUJu9JVh5/Y0ebOjvY=";
+    hash = "sha256-wRY40yNXTcixCUYWFMQsfkI7MPE4RuxCEHBoedDpW9Y=";
   };
 
-  vendorHash = "sha256-d6GhZBHDSRgMVeglw8rhq5QF7gRH4hQOzTn0DZjvhiA=";
+  vendorHash = "sha256-bTpE8zJ6dCMimTowexehxnWPq3tXd0H9ZduJvCVqAlI=";
 
   nativeBuildInputs = [ installShellFiles ];
 

pkgs/by-name/ku/kubecfg/package.nix

···
 
 buildGoModule rec {
   pname = "kubecfg";
-  version = "0.35.0";
+  version = "0.35.1";
 
   src = fetchFromGitHub {
     owner = "kubecfg";
     repo = "kubecfg";
     rev = "v${version}";
-    hash = "sha256-/xfZcykOGYOnCkKQDUJ9k4xh+bwrDmy2iSNFPVLkjew=";
+    hash = "sha256-5xs9iE6sfFzoTq24DTNKOj4D+A5ezBKN1lfIdJCt+pk=";
   };
 
   vendorHash = "sha256-K2IyljE5QS/SZ6EXV42q/a5ru+0UXZ69oLNi94XKxw4=";

pkgs/by-name/la/lact/package.nix

···
   '';
 
   meta = {
-    description = "Linux AMDGPU Controller";
+    description = "Linux GPU Configuration Tool for AMD and NVIDIA";
     homepage = "https://github.com/ilya-zlobintsev/LACT";
     license = lib.licenses.mit;
     maintainers = with lib.maintainers; [ figsoda atemu ];

pkgs/by-name/le/legcord/package.nix

···
 }:
 stdenv.mkDerivation rec {
   pname = "legcord";
-  version = "1.0.4";
+  version = "1.0.5";
 
   src = fetchFromGitHub {
     owner = "Legcord";
     repo = "Legcord";
     rev = "v${version}";
-    hash = "sha256-1nM0v8cjLcctvRcGHGtbyGxaqonIY8wM9s413NxTo+I=";
+    hash = "sha256-9CicqDZDetxElD36OLizyVNxkqz3rQOjAtUNTGWVwss=";
   };
 
   nativeBuildInputs = [ pnpm.configHook nodejs makeWrapper copyDesktopItems ];
 
   pnpmDeps = pnpm.fetchDeps {
     inherit pname version src;
-    hash = "sha256-E1kT3WiCYkLwrfHa11P1Z6e0fVnZSpXEQStr1NPjEJU=";
+    hash = "sha256-5GE/I2xLmu2Wu9mjzZMk1YZvtS5PgpwgXnxuY+4nimQ=";
   };
 
   ELECTRON_SKIP_BINARY_DOWNLOAD = "1";

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

···
 , pipewire
 , virglrenderer
 , libkrunfw
-, llvmPackages
 , rustc
 , withGpu ? false
 , withSound ? false
···
   };
 
   nativeBuildInputs = [
-    llvmPackages.clang
     rustPlatform.cargoSetupHook
+    rustPlatform.bindgenHook
     cargo
     rustc
   ] ++ lib.optional (sevVariant || withGpu) pkg-config;
···
   ] ++ lib.optionals withGpu [ libepoxy libdrm virglrenderer ]
     ++ lib.optional withSound pipewire
     ++ lib.optional sevVariant openssl;
-
-  env.LIBCLANG_PATH = "${lib.getLib llvmPackages.clang-unwrapped}/lib/libclang.so";
 
   makeFlags = [
     "PREFIX=${placeholder "out"}"

pkgs/by-name/lo/lockbook/package.nix

···
+{
+  lib,
+  stdenv,
+  rustPlatform,
+  fetchFromGitHub,
+  installShellFiles,
+}:
+rustPlatform.buildRustPackage rec {
+  pname = "lockbook";
+  version = "0.9.15";
+
+  src = fetchFromGitHub {
+    owner = "lockbook";
+    repo = "lockbook";
+    rev = "refs/tags/${version}";
+    hash = "sha256-hqBjA/6MWlhVjV4m+cIcnoRTApHuzbPzivMsaQHfRcc=";
+  };
+
+  useFetchCargoVendor = true;
+  cargoHash = "sha256-+M+wL26KDbLKhcujPyWAsTlXwLrQVCUbTnnu/7sXul4=";
+
+  doCheck = false; # there are no cli tests
+  cargoBuildFlags = [
+    "--package"
+    "lockbook-cli"
+  ];
+
+  nativeBuildInputs = [ installShellFiles ];
+  postInstall = lib.optionalString (stdenv.buildPlatform.canExecute stdenv.hostPlatform) ''
+    installShellCompletion --bash --name lockbook.bash <($out/bin/lockbook completions bash)
+    installShellCompletion --zsh --name _lockbook <($out/bin/lockbook completions zsh)
+    installShellCompletion --fish --name lockbook.fish <($out/bin/lockbook completions fish)
+  '';
+
+  meta = {
+    description = "Private, polished note-taking platform";
+    longDescription = ''
+      Write notes, sketch ideas, and store files in one secure place.
+      Share seamlessly, keep data synced, and access it on any
+      platform—even offline. Lockbook encrypts files so even we
+      can’t see them, but don’t take our word for it:
+      Lockbook is 100% open-source.
+    '';
+    homepage = "https://lockbook.net";
+    license = lib.licenses.unlicense;
+    platforms = lib.platforms.all;
+    changelog = "https://github.com/lockbook/lockbook/releases";
+    maintainers = [ lib.maintainers.parth ];
+  };
+}

pkgs/by-name/lx/lxcfs/package.nix

···
 
   postInstall = ''
     # `mount` hook requires access to the `mount` command from `util-linux` and `readlink` from `coreutils`:
-    wrapProgram "$out/share/lxcfs/lxc.mount.hook" --prefix PATH : ${lib.makeBinPath [ coreutils util-linux ]}
+    wrapProgram "$out/share/lxcfs/lxc.mount.hook" --prefix PATH : ${
+      lib.makeBinPath [
+        coreutils
+        util-linux
+      ]
+    }
   '';
 
   postFixup = ''

pkgs/by-name/mi/microsoft-identity-broker/package.nix

···
-{ stdenv
-, lib
-, fetchurl
-, dpkg
-, openjdk11
-, jnr-posix
-, makeWrapper
-, openjfx17
-, zip
-, nixosTests
-, bash
+{
+  stdenv,
+  lib,
+  fetchurl,
+  dpkg,
+  openjdk11,
+  jnr-posix,
+  makeWrapper,
+  openjfx17,
+  zip,
+  nixosTests,
+  bash,
 }:
 stdenv.mkDerivation rec {
   pname = "microsoft-identity-broker";
···
 
   src = fetchurl {
     url = "https://packages.microsoft.com/ubuntu/22.04/prod/pool/main/m/microsoft-identity-broker/microsoft-identity-broker_${version}_amd64.deb";
-    hash = "sha256-I4Q6ucT6ps8/QGiQTNbMXcKxq6UMcuwJ0Prcqvov56M=";
+    hash = "sha256-v/FxtdvRaUHYqvFSkJIZyicIdcyxQ8lPpY5rb9smnqA=";
   };
 
-  nativeBuildInputs = [ dpkg makeWrapper openjdk11 zip ];
+  nativeBuildInputs = [
+    dpkg
+    makeWrapper
+    openjdk11
+    zip
+  ];
 
   buildPhase = ''
     runHook preBuild
···
     tests = { inherit (nixosTests) intune; };
   };
 
-  meta = with lib; {
+  meta = {
     description = "Microsoft Authentication Broker for Linux";
     homepage = "https://www.microsoft.com/";
-    license = licenses.unfree;
-    sourceProvenance = with sourceTypes; [ binaryNativeCode ];
+    license = lib.licenses.unfree;
+    sourceProvenance = with lib.sourceTypes; [ binaryNativeCode ];
     platforms = [ "x86_64-linux" ];
     maintainers = with lib.maintainers; [ rhysmdnz ];
   };

pkgs/by-name/ml/mlx42/package.nix

···
 
 stdenv.mkDerivation (finalAttrs: {
   pname = "mlx42";
-  version = "2.4.0";
+  version = "2.4.1";
 
   src = fetchFromGitHub {
     owner = "codam-coding-college";
     repo = "MLX42";
     rev = "refs/tags/v${finalAttrs.version}";
-    hash = "sha256-jYcBvvx0Xfc/wDWSUROfQeRvn+tWvSS0ymKO1iuzg8w=";
+    hash = "sha256-/HCP6F7N+J97n4orlLxg/4agEoq4+rJdpeW/3q+DI1I=";
   };
 
   postPatch =

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

···
+{
+  lib,
+  buildGoModule,
+  fetchFromGitHub,
+}:
+
+buildGoModule rec {
+  pname = "morf";
+  version = "1.0.0";
+
+  src = fetchFromGitHub {
+    owner = "amrudesh1";
+    repo = "morf";
+    rev = "refs/tags/v${version}";
+    hash = "sha256-3PJ+YtKSH6HHAXBSHO8iMP2HFiuW1RQ0N8iUjQD7NBw=";
+  };
+
+  vendorHash = "sha256-tK58UGCI7CuJsFSM7htRQT98tzunAOXyYAxhCkdTJdU=";
+
+  ldflags = [
+    "-s"
+    "-w"
+  ];
+
+  meta = {
+    description = "Offensive mobile security tool designed to identify and address sensitive information";
+    homepage = "https://github.com/amrudesh1/morf";
+    changelog = "https://github.com/amrudesh1/morf/releases/tag/v${version}";
+    license = lib.licenses.asl20;
+    maintainers = with lib.maintainers; [ fab ];
+    mainProgram = "morf";
+  };
+}

pkgs/by-name/mq/mqtt-randompub/package.nix

···
 
 python3.pkgs.buildPythonApplication rec {
   pname = "mqtt-randompub";
-  version = "0.2.2";
+  version = "0.3.0";
   pyproject = true;
 
   src = fetchFromGitHub {
     owner = "fabaff";
     repo = "mqtt-randompub";
     rev = "refs/tags/${version}";
-    hash = "sha256-vAFEVlw9reRP+4Qwywv+cP27SU1c3seL3Z+b/YfUdl8=";
+    hash = "sha256-X9gITmzyUNtYW8IMTcBiubPscBEO5OGjdxot9wRD/BY=";
   };
 
   build-system = with python3.pkgs; [ setuptools ];

pkgs/by-name/mx/mxt-app/package.nix

···
 { lib, stdenv, fetchFromGitHub, autoreconfHook, libtool }:
 
 stdenv.mkDerivation rec {
-  version="1.40";
+  version="1.41";
   pname = "mxt-app";
 
   src = fetchFromGitHub {
     owner = "atmel-maxtouch";
     repo = "mxt-app";
     rev = "v${version}";
-    sha256 = "sha256-ZquD1aZu/TJQdr7QwKHTbCwSCFxt4drVBm4D1FLlzF0=";
+    sha256 = "sha256-Sn83k04ctwyVH90wnPIFuH91epPgLt1mWY+07r5eKpk=";
   };
 
   nativeBuildInputs = [ autoreconfHook ];

pkgs/by-name/nc/nchat/package.nix

···
 
 stdenv.mkDerivation rec {
   pname = "nchat";
-  version = "5.2.11";
+  version = "5.3.5";
 
   src = fetchFromGitHub {
     owner = "d99kris";
     repo = "nchat";
     rev = "refs/tags/v${version}";
-    hash = "sha256-LcTVftLKlzHstSaJjdtqoEmQ7kiqft9dbXRXoYjbaus=";
+    hash = "sha256-Nnu2Bk11Crk2vhvQqlDFo42duDqkNRCwDq4xCKIXwLQ=";
   };
 
   postPatch = ''

pkgs/by-name/ne/neothesia/package.nix

···
 , alsa-lib
 , wayland
 , makeWrapper
-, llvmPackages
 , libxkbcommon
 , vulkan-loader
 , xorg
···
 
   nativeBuildInputs = [
     pkg-config
-    llvmPackages.clang
     makeWrapper
+    rustPlatform.bindgenHook
   ];
 
   cargoLock = {
···
     install -Dm 644 flatpak/com.github.polymeilex.neothesia.desktop $out/share/applications/com.github.polymeilex.neothesia.desktop
     install -Dm 644 flatpak/com.github.polymeilex.neothesia.png $out/share/icons/hicolor/256x256/apps/com.github.polymeilex.neothesia.png
   '';
-
-  env = {
-    LIBCLANG_PATH = "${lib.getLib llvmPackages.libclang}/lib";
-  };
 
   meta = {
     description = "Flashy Synthesia Like Software For Linux, Windows and macOS";

pkgs/by-name/ni/nixos-rebuild-ng/src/nixos_rebuild/__init__.py

···
                 path_to_config = nix.nixos_build_flake(
                     "toplevel",
                     flake,
-                    keep_going=True,
                     dry_run=dry_run,
                     **flake_build_flags,
                 )
···
                     "system",
                     args.attr,
                     args.file,
-                    keep_going=True,
                     dry_run=dry_run,
                     **build_flags,
                 )
···
                 path_to_config = nix.nixos_build_flake(
                     attr,
                     flake,
-                    keep_going=True,
                     **flake_build_flags,
                 )
             else:
···
                     attr,
                     args.attr,
                     args.file,
-                    keep_going=True,
                     **build_flags,
                 )
             vm_path = next(path_to_config.glob("bin/run-*-vm"), "./result/bin/run-*-vm")

pkgs/by-name/nu/nufmt/package.nix

···
   fetchFromGitHub,
   rustPlatform,
   apple-sdk_11,
-  llvmPackages,
   nix-update-script,
-  ...
 }:
+
 rustPlatform.buildRustPackage {
   pname = "nufmt";
-  version = "0-unstable-2024-10-20";
+  version = "0-unstable-2024-11-21";
 
   src = fetchFromGitHub {
     owner = "nushell";
     repo = "nufmt";
-    rev = "decc88ef8e11a14081c2dd86c6ea0c94d6d2861d";
-    hash = "sha256-AurQGIZDYOkMMyAEXP01QziISQcSME3GFtvqjCDoeiw=";
+    rev = "628a3b73ea637c96f2c191ae066cf1cecadeafa3";
+    hash = "sha256-ideILLOawU6BNawmr4lqt2LGkf29wvlwQe9gqgdYRiI=";
   };
 
+  nativeBuildInputs = [
+    rustPlatform.bindgenHook
+  ];
+
   buildInputs = lib.optionals stdenv.hostPlatform.isDarwin [
     apple-sdk_11
   ];
 
-  env.LIBCLANG_PATH = lib.optionalString stdenv.cc.isClang "${lib.getLib llvmPackages.libclang}/lib";
-
-  cargoHash = "sha256-5DS6pTYGOQ4qay6+YiUstInRX17n3RViNxKXtFZ6J3k=";
+  cargoHash = "sha256-MHZlXmHAYIiaB6Isutqjrh45jppRzTZRSE3VqzpFBBA=";
 
   passthru.updateScript = nix-update-script { extraArgs = [ "--version=branch" ]; };
 

pkgs/by-name/op/opentabletdriver/deps.nix

···
+# This file was automatically generated by passthru.fetch-deps.
+# Please dont edit it manually, your changes might get overwritten!
+
+{ fetchNuGet }:
+[
+  (fetchNuGet {
+    pname = "AtkSharp";
+    version = "3.24.24.34";
+    hash = "sha256-GrOzO4YDMKJNHAnqLF+c44iGYlvazGTOuRLUnuLbwco=";
+  })
+  (fetchNuGet {
+    pname = "CairoSharp";
+    version = "3.24.24.34";
+    hash = "sha256-/80xbYSPU8+6twoXRjES8PtV7dKB6fQoe6EqBmawzV8=";
+  })
+  (fetchNuGet {
+    pname = "Castle.Core";
+    version = "4.4.0";
+    hash = "sha256-7hLBAHnB+drr2yU4w3o05eMX2ADy/rXN3XRPBn1d7GY=";
+  })
+  (fetchNuGet {
+    pname = "coverlet.collector";
+    version = "3.0.2";
+    hash = "sha256-b8LCEIZCLJdYcJXQqI3TGDmkLrmLhz84eoTq+qP5xvU=";
+  })
+  (fetchNuGet {
+    pname = "Eto.Forms";
+    version = "2.5.10";
+    hash = "sha256-51NkW/COGLiGl/+niLJaPJY+ypG1a1OXw65HMunj4bQ=";
+  })
+  (fetchNuGet {
+    pname = "Eto.Forms";
+    version = "2.5.11";
+    hash = "sha256-enxjfLwl+KEl//rG9pJ4VaQtAAycjHWP1Hp4ngKTBkE=";
+  })
+  (fetchNuGet {
+    pname = "Eto.Platform.Gtk";
+    version = "2.5.11";
+    hash = "sha256-sqRlx0itUTncAfLaExymb2hdtoqLnkj/yvD9RM+XNuk=";
+  })
+  (fetchNuGet {
+    pname = "GdkSharp";
+    version = "3.24.24.34";
+    hash = "sha256-pQOp2jft19vVN+gSjD0tHfNGucss7ruy1xyys6IHHWQ=";
+  })
+  (fetchNuGet {
+    pname = "GioSharp";
+    version = "3.24.24.34";
+    hash = "sha256-/fZBfaKXlrdBuNh1/h0s1++5Ek4OnznXvzJx0uTbHQo=";
+  })
+  (fetchNuGet {
+    pname = "GLibSharp";
+    version = "3.24.24.34";
+    hash = "sha256-eAYUYNHF37nIJnk7aRffzBj8b/rluqXERYy358YAd08=";
+  })
+  (fetchNuGet {
+    pname = "GtkSharp";
+    version = "3.24.24.34";
+    hash = "sha256-i0XZfzUt9GNaZD1uXNd8x+pb1mPJqYrxQd15XOuHSAA=";
+  })
+  (fetchNuGet {
+    pname = "HidSharpCore";
+    version = "1.2.1.1";
+    hash = "sha256-lM4o3FYBon8eQIMt4uiJAs8M0t4MW+joykiDX+lrdv4=";
+  })
+  (fetchNuGet {
+    pname = "MessagePack";
+    version = "2.1.194";
+    hash = "sha256-QKq/zQKI3P9TBhhnnktaaeRr4f/12U+huxeaplPzT+w=";
+  })
+  (fetchNuGet {
+    pname = "MessagePack.Annotations";
+    version = "2.1.194";
+    hash = "sha256-YCHelFO/hXW7Q3rkV/fQ32aZliSXUO7133kRH+HAcMo=";
+  })
+  (fetchNuGet {
+    pname = "Microsoft.Bcl.AsyncInterfaces";
+    version = "1.1.1";
+    hash = "sha256-fAcX4sxE0veWM1CZBtXR/Unky+6sE33yrV7ohrWGKig=";
+  })
+  (fetchNuGet {
+    pname = "Microsoft.CodeCoverage";
+    version = "16.9.4";
+    hash = "sha256-90oZu7wror4PMfy9VL4O7WzxNHt0+KqS0mG+6Yf3kYc=";
+  })
+  (fetchNuGet {
+    pname = "Microsoft.CSharp";
+    version = "4.0.1";
+    hash = "sha256-0huoqR2CJ3Z9Q2peaKD09TV3E6saYSqDGZ290K8CrH8=";
+  })
+  (fetchNuGet {
+    pname = "Microsoft.Extensions.DependencyInjection";
+    version = "6.0.0-rc.1.21451.13";
+    hash = "sha256-zJQsAVTfA46hUV5q67BslsVn9yehYBclD06wg2UhyWQ=";
+  })
+  (fetchNuGet {
+    pname = "Microsoft.Extensions.DependencyInjection.Abstractions";
+    version = "6.0.0-rc.1.21451.13";
+    hash = "sha256-oTYhI+lMwaQ7l9CfDHeNMBAdfofv4kHC0vqBZ7oJr4U=";
+  })
+  (fetchNuGet {
+    pname = "Microsoft.NET.Test.Sdk";
+    version = "16.9.4";
+    hash = "sha256-ROXDqgp87j/In0UyGWygrCwMgn982Of60UHiXH8Bvck=";
+  })
+  (fetchNuGet {
+    pname = "Microsoft.NETCore.Platforms";
+    version = "1.0.1";
+    hash = "sha256-mZotlGZqtrqDSoBrZhsxFe6fuOv5/BIo0w2Z2x0zVAU=";
+  })
+  (fetchNuGet {
+    pname = "Microsoft.NETCore.Platforms";
+    version = "1.1.0";
+    hash = "sha256-FeM40ktcObQJk4nMYShB61H/E8B7tIKfl9ObJ0IOcCM=";
+  })
+  (fetchNuGet {
+    pname = "Microsoft.NETCore.Platforms";
+    version = "1.1.1";
+    hash = "sha256-8hLiUKvy/YirCWlFwzdejD2Db3DaXhHxT7GSZx/znJg=";
+  })
+  (fetchNuGet {
+    pname = "Microsoft.NETCore.Platforms";
+    version = "3.0.0";
+    hash = "sha256-ocB+U+mMvi/xVwII7bGsIfAqSXiKVSnEMLHCODLJaK4=";
+  })
+  (fetchNuGet {
+    pname = "Microsoft.NETCore.Targets";
+    version = "1.0.1";
+    hash = "sha256-lxxw/Gy32xHi0fLgFWNj4YTFBSBkjx5l6ucmbTyf7V4=";
+  })
+  (fetchNuGet {
+    pname = "Microsoft.NETCore.Targets";
+    version = "1.1.0";
+    hash = "sha256-0AqQ2gMS8iNlYkrD+BxtIg7cXMnr9xZHtKAuN4bjfaQ=";
+  })
+  (fetchNuGet {
+    pname = "Microsoft.TestPlatform.ObjectModel";
+    version = "16.9.4";
+    hash = "sha256-JvLvmGmaT9I5Sz2QMCEv8lQk34kzCcg+MPuSavOaP8o=";
+  })
+  (fetchNuGet {
+    pname = "Microsoft.TestPlatform.TestHost";
+    version = "16.9.4";
+    hash = "sha256-3VRVjK5XrR5+SNuMQnLbD1ji6sHXjr65FydfXz8GIZA=";
+  })
+  (fetchNuGet {
+    pname = "Microsoft.VisualStudio.Threading";
+    version = "16.7.56";
+    hash = "sha256-V2HB/0j+I/3iUT7mEVyeF11P/61cSpYcZQa1LnXuoI8=";
+  })
+  (fetchNuGet {
+    pname = "Microsoft.VisualStudio.Threading.Analyzers";
+    version = "16.7.56";
+    hash = "sha256-4lsL6hg1mposZ62buQWBud1B4raV8Pl+BkyvM4FraRM=";
+  })
+  (fetchNuGet {
+    pname = "Microsoft.VisualStudio.Validation";
+    version = "15.5.31";
+    hash = "sha256-/NWbGyad7wejY8QyxK8YWTgiRiUGjimaBgoLkWxOCao=";
+  })
+  (fetchNuGet {
+    pname = "Microsoft.Win32.Primitives";
+    version = "4.3.0";
+    hash = "sha256-mBNDmPXNTW54XLnPAUwBRvkIORFM7/j0D0I2SyQPDEg=";
+  })
+  (fetchNuGet {
+    pname = "Microsoft.Win32.Registry";
+    version = "4.6.0";
+    hash = "sha256-Wrj0Sc9srH5+ma0lCbgRYYP6gKgnlXcL6h7j7AU6nkQ=";
+  })
+  (fetchNuGet {
+    pname = "Moq";
+    version = "4.16.1";
+    hash = "sha256-9CCEY6246RbB4zaF5xwCDf2XuGoPDpZoJsjrB/riT9Q=";
+  })
+  (fetchNuGet {
+    pname = "Nerdbank.Streams";
+    version = "2.6.77";
+    hash = "sha256-rOBiYpZQ0rrM9wbWOjzCYIbxcWa3tCrdPt1rpDp3to0=";
+  })
+  (fetchNuGet {
+    pname = "NETStandard.Library";
+    version = "1.6.1";
+    hash = "sha256-iNan1ix7RtncGWC9AjAZ2sk70DoxOsmEOgQ10fXm4Pw=";
+  })
+  (fetchNuGet {
+    pname = "Newtonsoft.Json";
+    version = "12.0.2";
+    hash = "sha256-BW7sXT2LKpP3ylsCbTTZ1f6Mg1sR4yL68aJVHaJcTnA=";
+  })
+  (fetchNuGet {
+    pname = "Newtonsoft.Json";
+    version = "13.0.1";
+    hash = "sha256-K2tSVW4n4beRPzPu3rlVaBEMdGvWSv/3Q1fxaDh4Mjo=";
+  })
+  (fetchNuGet {
+    pname = "Newtonsoft.Json";
+    version = "13.0.3";
+    hash = "sha256-hy/BieY4qxBWVVsDqqOPaLy1QobiIapkbrESm6v2PHc=";
+  })
+  (fetchNuGet {
+    pname = "Newtonsoft.Json";
+    version = "9.0.1";
+    hash = "sha256-mYCBrgUhIJFzRuLLV9SIiIFHovzfR8Uuqfg6e08EnlU=";
+  })
+  (fetchNuGet {
+    pname = "Newtonsoft.Json.Schema";
+    version = "3.0.15";
+    hash = "sha256-l2r1pkQ9d+SbuMXkEbbsunDKpd2G9+uFG857dvtPrNo=";
+  })
+  (fetchNuGet {
+    pname = "NuGet.Frameworks";
+    version = "5.0.0";
+    hash = "sha256-WWLh+v9Y9as+WURW8tUPowQB8HWIiVJzbpKzEWTdMqI=";
+  })
+  (fetchNuGet {
+    pname = "Octokit";
+    version = "0.50.0";
+    hash = "sha256-GJ+9HkF8FNOB7O2d32fPvMrmUqYcAJ4xToEFZWKR9sU=";
+  })
+  (fetchNuGet {
+    pname = "PangoSharp";
+    version = "3.24.24.34";
+    hash = "sha256-/KdH3SA/11bkwPe/AXRph4v4a2cjbUjDvo4+OhkJEOQ=";
+  })
+  (fetchNuGet {
+    pname = "runtime.any.System.Collections";
+    version = "4.3.0";
+    hash = "sha256-4PGZqyWhZ6/HCTF2KddDsbmTTjxs2oW79YfkberDZS8=";
+  })
+  (fetchNuGet {
+    pname = "runtime.any.System.Diagnostics.Tools";
+    version = "4.3.0";
+    hash = "sha256-8yLKFt2wQxkEf7fNfzB+cPUCjYn2qbqNgQ1+EeY2h/I=";
+  })
+  (fetchNuGet {
+    pname = "runtime.any.System.Diagnostics.Tracing";
+    version = "4.3.0";
+    hash = "sha256-dsmTLGvt8HqRkDWP8iKVXJCS+akAzENGXKPV18W2RgI=";
+  })
+  (fetchNuGet {
+    pname = "runtime.any.System.Globalization";
+    version = "4.3.0";
+    hash = "sha256-PaiITTFI2FfPylTEk7DwzfKeiA/g/aooSU1pDcdwWLU=";
+  })
+  (fetchNuGet {
+    pname = "runtime.any.System.Globalization.Calendars";
+    version = "4.3.0";
+    hash = "sha256-AYh39tgXJVFu8aLi9Y/4rK8yWMaza4S4eaxjfcuEEL4=";
+  })
+  (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.Text.Encoding.Extensions";
+    version = "4.3.0";
+    hash = "sha256-6MYj0RmLh4EVqMtO/MRqBi0HOn5iG4x9JimgCCJ+EFM=";
+  })
+  (fetchNuGet {
+    pname = "runtime.any.System.Threading.Tasks";
+    version = "4.3.0";
+    hash = "sha256-agdOM0NXupfHbKAQzQT8XgbI9B8hVEh+a/2vqeHctg4=";
+  })
+  (fetchNuGet {
+    pname = "runtime.any.System.Threading.Timer";
+    version = "4.3.0";
+    hash = "sha256-BgHxXCIbicVZtpgMimSXixhFC3V+p5ODqeljDjO8hCs=";
+  })
+  (fetchNuGet {
+    pname = "runtime.debian.8-x64.runtime.native.System.Security.Cryptography.OpenSsl";
+    version = "4.3.0";
+    hash = "sha256-LXUPLX3DJxsU1Pd3UwjO1PO9NM2elNEDXeu2Mu/vNps=";
+  })
+  (fetchNuGet {
+    pname = "runtime.debian.8-x64.runtime.native.System.Security.Cryptography.OpenSsl";
+    version = "4.3.2";
+    hash = "sha256-EbnOqPOrAgI9eNheXLR++VnY4pHzMsEKw1dFPJ/Fl2c=";
+  })
+  (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.23-x64.runtime.native.System.Security.Cryptography.OpenSsl";
+    version = "4.3.2";
+    hash = "sha256-mVg02TNvJc1BuHU03q3fH3M6cMgkKaQPBxraSHl/Btg=";
+  })
+  (fetchNuGet {
+    pname = "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography.OpenSsl";
+    version = "4.3.0";
+    hash = "sha256-SrHqT9wrCBsxILWtaJgGKd6Odmxm8/Mh7Kh0CUkZVzA=";
+  })
+  (fetchNuGet {
+    pname = "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography.OpenSsl";
+    version = "4.3.2";
+    hash = "sha256-g9Uiikrl+M40hYe0JMlGHe/lrR0+nN05YF64wzLmBBA=";
+  })
+  (fetchNuGet {
+    pname = "runtime.native.System";
+    version = "4.3.0";
+    hash = "sha256-ZBZaodnjvLXATWpXXakFgcy6P+gjhshFXmglrL5xD5Y=";
+  })
+  (fetchNuGet {
+    pname = "runtime.native.System.IO.Compression";
+    version = "4.3.0";
+    hash = "sha256-DWnXs4vlKoU6WxxvCArTJupV6sX3iBbZh8SbqfHace8=";
+  })
+  (fetchNuGet {
+    pname = "runtime.native.System.Net.Http";
+    version = "4.3.0";
+    hash = "sha256-c556PyheRwpYhweBjSfIwEyZHnAUB8jWioyKEcp/2dg=";
+  })
+  (fetchNuGet {
+    pname = "runtime.native.System.Security.Cryptography.Apple";
+    version = "4.3.0";
+    hash = "sha256-2IhBv0i6pTcOyr8FFIyfPEaaCHUmJZ8DYwLUwJ+5waw=";
+  })
+  (fetchNuGet {
+    pname = "runtime.native.System.Security.Cryptography.OpenSsl";
+    version = "4.3.0";
+    hash = "sha256-Jy01KhtcCl2wjMpZWH+X3fhHcVn+SyllWFY8zWlz/6I=";
+  })
+  (fetchNuGet {
+    pname = "runtime.native.System.Security.Cryptography.OpenSsl";
+    version = "4.3.2";
+    hash = "sha256-xqF6LbbtpzNC9n1Ua16PnYgXHU0LvblEROTfK4vIxX8=";
+  })
+  (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.13.2-x64.runtime.native.System.Security.Cryptography.OpenSsl";
+    version = "4.3.2";
+    hash = "sha256-aJBu6Frcg6webvzVcKNoUP1b462OAqReF2giTSyBzCQ=";
+  })
+  (fetchNuGet {
+    pname = "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography.OpenSsl";
+    version = "4.3.0";
+    hash = "sha256-zi+b4sCFrA9QBiSGDD7xPV27r3iHGlV99gpyVUjRmc4=";
+  })
+  (fetchNuGet {
+    pname = "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography.OpenSsl";
+    version = "4.3.2";
+    hash = "sha256-Mpt7KN2Kq51QYOEVesEjhWcCGTqWckuPf8HlQ110qLY=";
+  })
+  (fetchNuGet {
+    pname = "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.Apple";
+    version = "4.3.0";
+    hash = "sha256-serkd4A7F6eciPiPJtUyJyxzdAtupEcWIZQ9nptEzIM=";
+  })
+  (fetchNuGet {
+    pname = "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.OpenSsl";
+    version = "4.3.0";
+    hash = "sha256-gybQU6mPgaWV3rBG2dbH6tT3tBq8mgze3PROdsuWnX0=";
+  })
+  (fetchNuGet {
+    pname = "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.OpenSsl";
+    version = "4.3.2";
+    hash = "sha256-JvMltmfVC53mCZtKDHE69G3RT6Id28hnskntP9MMP9U=";
+  })
+  (fetchNuGet {
+    pname = "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography.OpenSsl";
+    version = "4.3.0";
+    hash = "sha256-VsP72GVveWnGUvS/vjOQLv1U80H2K8nZ4fDAmI61Hm4=";
+  })
+  (fetchNuGet {
+    pname = "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography.OpenSsl";
+    version = "4.3.2";
+    hash = "sha256-QfFxWTVRNBhN4Dm1XRbCf+soNQpy81PsZed3x6op/bI=";
+  })
+  (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.14.04-x64.runtime.native.System.Security.Cryptography.OpenSsl";
+    version = "4.3.2";
+    hash = "sha256-EaJHVc9aDZ6F7ltM2JwlIuiJvqM67CKRq682iVSo+pU=";
+  })
+  (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.04-x64.runtime.native.System.Security.Cryptography.OpenSsl";
+    version = "4.3.2";
+    hash = "sha256-PHR0+6rIjJswn89eoiWYY1DuU8u6xRJLrtjykAMuFmA=";
+  })
+  (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.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography.OpenSsl";
+    version = "4.3.2";
+    hash = "sha256-LFkh7ua7R4rI5w2KGjcHlGXLecsncCy6kDXLuy4qD/Q=";
+  })
+  (fetchNuGet {
+    pname = "runtime.unix.Microsoft.Win32.Primitives";
+    version = "4.3.0";
+    hash = "sha256-LZb23lRXzr26tRS5aA0xyB08JxiblPDoA7HBvn6awXg=";
+  })
+  (fetchNuGet {
+    pname = "runtime.unix.System.Console";
+    version = "4.3.0";
+    hash = "sha256-AHkdKShTRHttqfMjmi+lPpTuCrM5vd/WRy6Kbtie190=";
+  })
+  (fetchNuGet {
+    pname = "runtime.unix.System.Diagnostics.Debug";
+    version = "4.3.0";
+    hash = "sha256-ReoazscfbGH+R6s6jkg5sIEHWNEvjEoHtIsMbpc7+tI=";
+  })
+  (fetchNuGet {
+    pname = "runtime.unix.System.IO.FileSystem";
+    version = "4.3.0";
+    hash = "sha256-Pf4mRl6YDK2x2KMh0WdyNgv0VUNdSKVDLlHqozecy5I=";
+  })
+  (fetchNuGet {
+    pname = "runtime.unix.System.Net.Primitives";
+    version = "4.3.0";
+    hash = "sha256-pHJ+I6i16MV6m77uhTC6GPY6jWGReE3SSP3fVB59ti0=";
+  })
+  (fetchNuGet {
+    pname = "runtime.unix.System.Net.Sockets";
+    version = "4.3.0";
+    hash = "sha256-IvgOeA2JuBjKl5yAVGjPYMPDzs9phb3KANs95H9v1w4=";
+  })
+  (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 = "SharpZipLib";
+    version = "1.3.3";
+    hash = "sha256-HWEQTKh9Ktwg/zIl079dAiH+ob2ShWFAqLgG6XgIMr4=";
+  })
+  (fetchNuGet {
+    pname = "StreamJsonRpc";
+    version = "2.6.121";
+    hash = "sha256-5tSk90kVoj0YRbuS1YIohu+c5zvykNd+s1MLfsK8+3c=";
+  })
+  (fetchNuGet {
+    pname = "System.AppContext";
+    version = "4.3.0";
+    hash = "sha256-yg95LNQOwFlA1tWxXdQkVyJqT4AnoDc+ACmrNvzGiZg=";
+  })
+  (fetchNuGet {
+    pname = "System.Buffers";
+    version = "4.3.0";
+    hash = "sha256-XqZWb4Kd04960h4U9seivjKseGA/YEIpdplfHYHQ9jk=";
+  })
+  (fetchNuGet {
+    pname = "System.Collections";
+    version = "4.0.11";
+    hash = "sha256-puoFMkx4Z55C1XPxNw3np8nzNGjH+G24j43yTIsDRL0=";
+  })
+  (fetchNuGet {
+    pname = "System.Collections";
+    version = "4.3.0";
+    hash = "sha256-afY7VUtD6w/5mYqrce8kQrvDIfS2GXDINDh73IjxJKc=";
+  })
+  (fetchNuGet {
+    pname = "System.Collections.Concurrent";
+    version = "4.3.0";
+    hash = "sha256-KMY5DfJnDeIsa13DpqvyN8NkReZEMAFnlmNglVoFIXI=";
+  })
+  (fetchNuGet {
+    pname = "System.Collections.Immutable";
+    version = "1.7.1";
+    hash = "sha256-WMMAUqoxT3J1gW9DI8v31VAuhwqTc4Posose5jq1BNo=";
+  })
+  (fetchNuGet {
+    pname = "System.Collections.NonGeneric";
+    version = "4.3.0";
+    hash = "sha256-8/yZmD4jjvq7m68SPkJZLBQ79jOTOyT5lyzX4SCYAx8=";
+  })
+  (fetchNuGet {
+    pname = "System.Collections.Specialized";
+    version = "4.3.0";
+    hash = "sha256-QNg0JJNx+zXMQ26MJRPzH7THdtqjrNtGLUgaR1SdvOk=";
+  })
+  (fetchNuGet {
+    pname = "System.CommandLine";
+    version = "2.0.0-beta4.22272.1";
+    hash = "sha256-zSO+CYnMH8deBHDI9DHhCPj79Ce3GOzHCyH1/TiHxcc=";
+  })
+  (fetchNuGet {
+    pname = "System.ComponentModel";
+    version = "4.3.0";
+    hash = "sha256-i00uujMO4JEDIEPKLmdLY3QJ6vdSpw6Gh9oOzkFYBiU=";
+  })
+  (fetchNuGet {
+    pname = "System.ComponentModel.Annotations";
+    version = "4.7.0";
+    hash = "sha256-PxG9lvf2v/IAIs7LhO4Ur+EpX/L5nYbEs0D21gypoRs=";
+  })
+  (fetchNuGet {
+    pname = "System.ComponentModel.Annotations";
+    version = "5.0.0";
+    hash = "sha256-0pST1UHgpeE6xJrYf5R+U7AwIlH3rVC3SpguilI/MAg=";
+  })
+  (fetchNuGet {
+    pname = "System.ComponentModel.Primitives";
+    version = "4.3.0";
+    hash = "sha256-IOMJleuIBppmP4ECB3uftbdcgL7CCd56+oAD/Sqrbus=";
+  })
+  (fetchNuGet {
+    pname = "System.ComponentModel.TypeConverter";
+    version = "4.3.0";
+    hash = "sha256-PSDiPYt8PgTdTUBz+GH6lHCaM1YgfObneHnZsc8Fz54=";
+  })
+  (fetchNuGet {
+    pname = "System.Console";
+    version = "4.3.0";
+    hash = "sha256-Xh3PPBZr0pDbDaK8AEHbdGz7ePK6Yi1ZyRWI1JM6mbo=";
+  })
+  (fetchNuGet {
+    pname = "System.Diagnostics.Debug";
+    version = "4.0.11";
+    hash = "sha256-P+rSQJVoN6M56jQbs76kZ9G3mAWFdtF27P/RijN8sj4=";
+  })
+  (fetchNuGet {
+    pname = "System.Diagnostics.Debug";
+    version = "4.3.0";
+    hash = "sha256-fkA79SjPbSeiEcrbbUsb70u9B7wqbsdM9s1LnoKj0gM=";
+  })
+  (fetchNuGet {
+    pname = "System.Diagnostics.DiagnosticSource";
+    version = "4.3.0";
+    hash = "sha256-OFJRb0ygep0Z3yDBLwAgM/Tkfs4JCDtsNhwDH9cd1Xw=";
+  })
+  (fetchNuGet {
+    pname = "System.Diagnostics.Tools";
+    version = "4.0.1";
+    hash = "sha256-vSBqTbmWXylvRa37aWyktym+gOpsvH43mwr6A962k6U=";
+  })
+  (fetchNuGet {
+    pname = "System.Diagnostics.Tools";
+    version = "4.3.0";
+    hash = "sha256-gVOv1SK6Ape0FQhCVlNOd9cvQKBvMxRX9K0JPVi8w0Y=";
+  })
+  (fetchNuGet {
+    pname = "System.Diagnostics.TraceSource";
+    version = "4.3.0";
+    hash = "sha256-xpxwaXsRcgso8Gj0cqY4+Hvvz6vZkmEMh5/J204j3M8=";
+  })
+  (fetchNuGet {
+    pname = "System.Diagnostics.Tracing";
+    version = "4.3.0";
+    hash = "sha256-hCETZpHHGVhPYvb4C0fh4zs+8zv4GPoixagkLZjpa9Q=";
+  })
+  (fetchNuGet {
+    pname = "System.Dynamic.Runtime";
+    version = "4.0.11";
+    hash = "sha256-qWqFVxuXioesVftv2RVJZOnmojUvRjb7cS3Oh3oTit4=";
+  })
+  (fetchNuGet {
+    pname = "System.Dynamic.Runtime";
+    version = "4.3.0";
+    hash = "sha256-k75gjOYimIQtLBD5NDzwwi3ZMUBPRW3jmc3evDMMJbU=";
+  })
+  (fetchNuGet {
+    pname = "System.Globalization";
+    version = "4.0.11";
+    hash = "sha256-rbSgc2PIEc2c2rN6LK3qCREAX3DqA2Nq1WcLrZYsDBw=";
+  })
+  (fetchNuGet {
+    pname = "System.Globalization";
+    version = "4.3.0";
+    hash = "sha256-caL0pRmFSEsaoeZeWN5BTQtGrAtaQPwFi8YOZPZG5rI=";
+  })
+  (fetchNuGet {
+    pname = "System.Globalization.Calendars";
+    version = "4.3.0";
+    hash = "sha256-uNOD0EOVFgnS2fMKvMiEtI9aOw00+Pfy/H+qucAQlPc=";
+  })
+  (fetchNuGet {
+    pname = "System.Globalization.Extensions";
+    version = "4.3.0";
+    hash = "sha256-mmJWA27T0GRVuFP9/sj+4TrR4GJWrzNIk2PDrbr7RQk=";
+  })
+  (fetchNuGet {
+    pname = "System.IO";
+    version = "4.1.0";
+    hash = "sha256-V6oyQFwWb8NvGxAwvzWnhPxy9dKOfj/XBM3tEC5aHrw=";
+  })
+  (fetchNuGet {
+    pname = "System.IO";
+    version = "4.3.0";
+    hash = "sha256-ruynQHekFP5wPrDiVyhNiRIXeZ/I9NpjK5pU+HPDiRY=";
+  })
+  (fetchNuGet {
+    pname = "System.IO.Compression";
+    version = "4.3.0";
+    hash = "sha256-f5PrQlQgj5Xj2ZnHxXW8XiOivaBvfqDao9Sb6AVinyA=";
+  })
+  (fetchNuGet {
+    pname = "System.IO.Compression.ZipFile";
+    version = "4.3.0";
+    hash = "sha256-WQl+JgWs+GaRMeiahTFUbrhlXIHapzcpTFXbRvAtvvs=";
+  })
+  (fetchNuGet {
+    pname = "System.IO.FileSystem";
+    version = "4.0.1";
+    hash = "sha256-4VKXFgcGYCTWVXjAlniAVq0dO3o5s8KHylg2wg2/7k0=";
+  })
+  (fetchNuGet {
+    pname = "System.IO.FileSystem";
+    version = "4.3.0";
+    hash = "sha256-vNIYnvlayuVj0WfRfYKpDrhDptlhp1pN8CYmlVd2TXw=";
+  })
+  (fetchNuGet {
+    pname = "System.IO.FileSystem.Primitives";
+    version = "4.0.1";
+    hash = "sha256-IpigKMomqb6pmYWkrlf0ZdpILtRluX2cX5sOKVW0Feg=";
+  })
+  (fetchNuGet {
+    pname = "System.IO.FileSystem.Primitives";
+    version = "4.3.0";
+    hash = "sha256-LMnfg8Vwavs9cMnq9nNH8IWtAtSfk0/Fy4s4Rt9r1kg=";
+  })
+  (fetchNuGet {
+    pname = "System.IO.Pipelines";
+    version = "4.7.2";
+    hash = "sha256-yWlQwmzMX+4kVQbOd9WowP6bvZnjo4yddkycer3CZJs=";
+  })
+  (fetchNuGet {
+    pname = "System.Linq";
+    version = "4.1.0";
+    hash = "sha256-ZQpFtYw5N1F1aX0jUK3Tw+XvM5tnlnshkTCNtfVA794=";
+  })
+  (fetchNuGet {
+    pname = "System.Linq";
+    version = "4.3.0";
+    hash = "sha256-R5uiSL3l6a3XrXSSL6jz+q/PcyVQzEAByiuXZNSqD/A=";
+  })
+  (fetchNuGet {
+    pname = "System.Linq.Expressions";
+    version = "4.1.0";
+    hash = "sha256-7zqB+FXgkvhtlBzpcZyd81xczWP0D3uWssyAGw3t7b4=";
+  })
+  (fetchNuGet {
+    pname = "System.Linq.Expressions";
+    version = "4.3.0";
+    hash = "sha256-+3pvhZY7rip8HCbfdULzjlC9FPZFpYoQxhkcuFm2wk8=";
+  })
+  (fetchNuGet {
+    pname = "System.Memory";
+    version = "4.5.4";
+    hash = "sha256-3sCEfzO4gj5CYGctl9ZXQRRhwAraMQfse7yzKoRe65E=";
+  })
+  (fetchNuGet {
+    pname = "System.Net.Http";
+    version = "4.3.0";
+    hash = "sha256-UoBB7WPDp2Bne/fwxKF0nE8grJ6FzTMXdT/jfsphj8Q=";
+  })
+  (fetchNuGet {
+    pname = "System.Net.Http";
+    version = "4.3.4";
+    hash = "sha256-FMoU0K7nlPLxoDju0NL21Wjlga9GpnAoQjsFhFYYt00=";
+  })
+  (fetchNuGet {
+    pname = "System.Net.NameResolution";
+    version = "4.3.0";
+    hash = "sha256-eGZwCBExWsnirWBHyp2sSSSXp6g7I6v53qNmwPgtJ5c=";
+  })
+  (fetchNuGet {
+    pname = "System.Net.Primitives";
+    version = "4.3.0";
+    hash = "sha256-MY7Z6vOtFMbEKaLW9nOSZeAjcWpwCtdO7/W1mkGZBzE=";
+  })
+  (fetchNuGet {
+    pname = "System.Net.Sockets";
+    version = "4.3.0";
+    hash = "sha256-il7dr5VT/QWDg/0cuh+4Es2u8LY//+qqiY9BZmYxSus=";
+  })
+  (fetchNuGet {
+    pname = "System.Net.WebSockets";
+    version = "4.3.0";
+    hash = "sha256-l3h3cF1cCC9zMhWLKSDnZBZvFADUd0Afe2+iAwBA0r0=";
+  })
+  (fetchNuGet {
+    pname = "System.ObjectModel";
+    version = "4.0.12";
+    hash = "sha256-MudZ/KYcvYsn2cST3EE049mLikrNkmE7QoUoYKKby+s=";
+  })
+  (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.Reflection";
+    version = "4.1.0";
+    hash = "sha256-idZHGH2Yl/hha1CM4VzLhsaR8Ljo/rV7TYe7mwRJSMs=";
+  })
+  (fetchNuGet {
+    pname = "System.Reflection";
+    version = "4.3.0";
+    hash = "sha256-NQSZRpZLvtPWDlvmMIdGxcVuyUnw92ZURo0hXsEshXY=";
+  })
+  (fetchNuGet {
+    pname = "System.Reflection.Emit";
+    version = "4.0.1";
+    hash = "sha256-F1MvYoQWHCY89/O4JBwswogitqVvKuVfILFqA7dmuHk=";
+  })
+  (fetchNuGet {
+    pname = "System.Reflection.Emit";
+    version = "4.3.0";
+    hash = "sha256-5LhkDmhy2FkSxulXR+bsTtMzdU3VyyuZzsxp7/DwyIU=";
+  })
+  (fetchNuGet {
+    pname = "System.Reflection.Emit";
+    version = "4.7.0";
+    hash = "sha256-Fw/CSRD+wajH1MqfKS3Q/sIrUH7GN4K+F+Dx68UPNIg=";
+  })
+  (fetchNuGet {
+    pname = "System.Reflection.Emit.ILGeneration";
+    version = "4.0.1";
+    hash = "sha256-YG+eJBG5P+5adsHiw/lhJwvREnvdHw6CJyS8ZV4Ujd0=";
+  })
+  (fetchNuGet {
+    pname = "System.Reflection.Emit.ILGeneration";
+    version = "4.3.0";
+    hash = "sha256-mKRknEHNls4gkRwrEgi39B+vSaAz/Gt3IALtS98xNnA=";
+  })
+  (fetchNuGet {
+    pname = "System.Reflection.Emit.Lightweight";
+    version = "4.0.1";
+    hash = "sha256-uVvNOnL64CPqsgZP2OLqNmxdkZl6Q0fTmKmv9gcBi+g=";
+  })
+  (fetchNuGet {
+    pname = "System.Reflection.Emit.Lightweight";
+    version = "4.3.0";
+    hash = "sha256-rKx4a9yZKcajloSZHr4CKTVJ6Vjh95ni+zszPxWjh2I=";
+  })
+  (fetchNuGet {
+    pname = "System.Reflection.Emit.Lightweight";
+    version = "4.6.0";
+    hash = "sha256-913OIkt3v3N12Yke328IRxTtgYUQYNs/eSzOs8wUPkM=";
+  })
+  (fetchNuGet {
+    pname = "System.Reflection.Extensions";
+    version = "4.0.1";
+    hash = "sha256-NsfmzM9G/sN3H8X2cdnheTGRsh7zbRzvegnjDzDH/FQ=";
+  })
+  (fetchNuGet {
+    pname = "System.Reflection.Extensions";
+    version = "4.3.0";
+    hash = "sha256-mMOCYzUenjd4rWIfq7zIX9PFYk/daUyF0A8l1hbydAk=";
+  })
+  (fetchNuGet {
+    pname = "System.Reflection.Metadata";
+    version = "1.6.0";
+    hash = "sha256-JJfgaPav7UfEh4yRAQdGhLZF1brr0tUWPl6qmfNWq/E=";
+  })
+  (fetchNuGet {
+    pname = "System.Reflection.Primitives";
+    version = "4.0.1";
+    hash = "sha256-SFSfpWEyCBMAOerrMCOiKnpT+UAWTvRcmoRquJR6Vq0=";
+  })
+  (fetchNuGet {
+    pname = "System.Reflection.Primitives";
+    version = "4.3.0";
+    hash = "sha256-5ogwWB4vlQTl3jjk1xjniG2ozbFIjZTL9ug0usZQuBM=";
+  })
+  (fetchNuGet {
+    pname = "System.Reflection.TypeExtensions";
+    version = "4.1.0";
+    hash = "sha256-R0YZowmFda+xzKNR4kKg7neFoE30KfZwp/IwfRSKVK4=";
+  })
+  (fetchNuGet {
+    pname = "System.Reflection.TypeExtensions";
+    version = "4.3.0";
+    hash = "sha256-4U4/XNQAnddgQIHIJq3P2T80hN0oPdU2uCeghsDTWng=";
+  })
+  (fetchNuGet {
+    pname = "System.Resources.ResourceManager";
+    version = "4.0.1";
+    hash = "sha256-cZ2/3/fczLjEpn6j3xkgQV9ouOVjy4Kisgw5xWw9kSw=";
+  })
+  (fetchNuGet {
+    pname = "System.Resources.ResourceManager";
+    version = "4.3.0";
+    hash = "sha256-idiOD93xbbrbwwSnD4mORA9RYi/D/U48eRUsn/WnWGo=";
+  })
+  (fetchNuGet {
+    pname = "System.Runtime";
+    version = "4.1.0";
+    hash = "sha256-FViNGM/4oWtlP6w0JC0vJU+k9efLKZ+yaXrnEeabDQo=";
+  })
+  (fetchNuGet {
+    pname = "System.Runtime";
+    version = "4.3.0";
+    hash = "sha256-51813WXpBIsuA6fUtE5XaRQjcWdQ2/lmEokJt97u0Rg=";
+  })
+  (fetchNuGet {
+    pname = "System.Runtime.CompilerServices.Unsafe";
+    version = "4.5.2";
+    hash = "sha256-8eUXXGWO2LL7uATMZye2iCpQOETn2jCcjUhG6coR5O8=";
+  })
+  (fetchNuGet {
+    pname = "System.Runtime.CompilerServices.Unsafe";
+    version = "4.7.1";
+    hash = "sha256-UvyoDV8O0oY3HPG1GbA56YVdvwTGEfjYR5gW1O7IK4U=";
+  })
+  (fetchNuGet {
+    pname = "System.Runtime.CompilerServices.Unsafe";
+    version = "6.0.0-rc.1.21451.13";
+    hash = "sha256-BgiqR6Y555tJEBEqDT5+yHCyQy5Wv9bLKlKWcQFiq2w=";
+  })
+  (fetchNuGet {
+    pname = "System.Runtime.Extensions";
+    version = "4.1.0";
+    hash = "sha256-X7DZ5CbPY7jHs20YZ7bmcXs9B5Mxptu/HnBUvUnNhGc=";
+  })
+  (fetchNuGet {
+    pname = "System.Runtime.Extensions";
+    version = "4.3.0";
+    hash = "sha256-wLDHmozr84v1W2zYCWYxxj0FR0JDYHSVRaRuDm0bd/o=";
+  })
+  (fetchNuGet {
+    pname = "System.Runtime.Handles";
+    version = "4.0.1";
+    hash = "sha256-j2QgVO9ZOjv7D1het98CoFpjoYgxjupuIhuBUmLLH7w=";
+  })
+  (fetchNuGet {
+    pname = "System.Runtime.Handles";
+    version = "4.3.0";
+    hash = "sha256-KJ5aXoGpB56Y6+iepBkdpx/AfaJDAitx4vrkLqR7gms=";
+  })
+  (fetchNuGet {
+    pname = "System.Runtime.InteropServices";
+    version = "4.1.0";
+    hash = "sha256-QceAYlJvkPRJc/+5jR+wQpNNI3aqGySWWSO30e/FfQY=";
+  })
+  (fetchNuGet {
+    pname = "System.Runtime.InteropServices";
+    version = "4.3.0";
+    hash = "sha256-8sDH+WUJfCR+7e4nfpftj/+lstEiZixWUBueR2zmHgI=";
+  })
+  (fetchNuGet {
+    pname = "System.Runtime.InteropServices.RuntimeInformation";
+    version = "4.3.0";
+    hash = "sha256-MYpl6/ZyC6hjmzWRIe+iDoldOMW1mfbwXsduAnXIKGA=";
+  })
+  (fetchNuGet {
+    pname = "System.Runtime.Numerics";
+    version = "4.3.0";
+    hash = "sha256-P5jHCgMbgFMYiONvzmaKFeOqcAIDPu/U8bOVrNPYKqc=";
+  })
+  (fetchNuGet {
+    pname = "System.Runtime.Serialization.Primitives";
+    version = "4.1.1";
+    hash = "sha256-80B05oxJbPLGq2pGOSl6NlZvintX9A1CNpna2aN0WRA=";
+  })
+  (fetchNuGet {
+    pname = "System.Security.AccessControl";
+    version = "4.6.0";
+    hash = "sha256-rspJ63MbjNVDve0owXby0Pu2vHjQvR2uuhCDCJ9vgfI=";
+  })
+  (fetchNuGet {
+    pname = "System.Security.Claims";
+    version = "4.3.0";
+    hash = "sha256-Fua/rDwAqq4UByRVomAxMPmDBGd5eImRqHVQIeSxbks=";
+  })
+  (fetchNuGet {
+    pname = "System.Security.Cryptography.Algorithms";
+    version = "4.3.0";
+    hash = "sha256-tAJvNSlczYBJ3Ed24Ae27a55tq/n4D3fubNQdwcKWA8=";
+  })
+  (fetchNuGet {
+    pname = "System.Security.Cryptography.Cng";
+    version = "4.3.0";
+    hash = "sha256-u17vy6wNhqok91SrVLno2M1EzLHZm6VMca85xbVChsw=";
+  })
+  (fetchNuGet {
+    pname = "System.Security.Cryptography.Csp";
+    version = "4.3.0";
+    hash = "sha256-oefdTU/Z2PWU9nlat8uiRDGq/PGZoSPRgkML11pmvPQ=";
+  })
+  (fetchNuGet {
+    pname = "System.Security.Cryptography.Encoding";
+    version = "4.3.0";
+    hash = "sha256-Yuge89N6M+NcblcvXMeyHZ6kZDfwBv3LPMDiF8HhJss=";
+  })
+  (fetchNuGet {
+    pname = "System.Security.Cryptography.OpenSsl";
+    version = "4.3.0";
+    hash = "sha256-DL+D2sc2JrQiB4oAcUggTFyD8w3aLEjJfod5JPe+Oz4=";
+  })
+  (fetchNuGet {
+    pname = "System.Security.Cryptography.Primitives";
+    version = "4.3.0";
+    hash = "sha256-fnFi7B3SnVj5a+BbgXnbjnGNvWrCEU6Hp/wjsjWz318=";
+  })
+  (fetchNuGet {
+    pname = "System.Security.Cryptography.X509Certificates";
+    version = "4.3.0";
+    hash = "sha256-MG3V/owDh273GCUPsGGraNwaVpcydupl3EtPXj6TVG0=";
+  })
+  (fetchNuGet {
+    pname = "System.Security.Principal";
+    version = "4.3.0";
+    hash = "sha256-rjudVUHdo8pNJg2EVEn0XxxwNo5h2EaYo+QboPkXlYk=";
+  })
+  (fetchNuGet {
+    pname = "System.Security.Principal.Windows";
+    version = "4.3.0";
+    hash = "sha256-mbdLVUcEwe78p3ZnB6jYsizNEqxMaCAWI3tEQNhRQAE=";
+  })
+  (fetchNuGet {
+    pname = "System.Security.Principal.Windows";
+    version = "4.6.0";
+    hash = "sha256-lZeXm45RboVgqnPQVJ65y8b5b+9FSVr0MBciG777rso=";
+  })
+  (fetchNuGet {
+    pname = "System.Text.Encoding";
+    version = "4.0.11";
+    hash = "sha256-PEailOvG05CVgPTyKLtpAgRydlSHmtd5K0Y8GSHY2Lc=";
+  })
+  (fetchNuGet {
+    pname = "System.Text.Encoding";
+    version = "4.3.0";
+    hash = "sha256-GctHVGLZAa/rqkBNhsBGnsiWdKyv6VDubYpGkuOkBLg=";
+  })
+  (fetchNuGet {
+    pname = "System.Text.Encoding.Extensions";
+    version = "4.0.11";
+    hash = "sha256-+kf7J3dEhgCbnCM5vHYlsTm5/R/Ud0Jr6elpHm922iI=";
+  })
+  (fetchNuGet {
+    pname = "System.Text.Encoding.Extensions";
+    version = "4.3.0";
+    hash = "sha256-vufHXg8QAKxHlujPHHcrtGwAqFmsCD6HKjfDAiHyAYc=";
+  })
+  (fetchNuGet {
+    pname = "System.Text.RegularExpressions";
+    version = "4.1.0";
+    hash = "sha256-x6OQN6MCN7S0fJ6EFTfv4rczdUWjwuWE9QQ0P6fbh9c=";
+  })
+  (fetchNuGet {
+    pname = "System.Text.RegularExpressions";
+    version = "4.3.0";
+    hash = "sha256-VLCk1D1kcN2wbAe3d0YQM/PqCsPHOuqlBY1yd2Yo+K0=";
+  })
+  (fetchNuGet {
+    pname = "System.Threading";
+    version = "4.0.11";
+    hash = "sha256-mob1Zv3qLQhQ1/xOLXZmYqpniNUMCfn02n8ZkaAhqac=";
+  })
+  (fetchNuGet {
+    pname = "System.Threading";
+    version = "4.3.0";
+    hash = "sha256-ZDQ3dR4pzVwmaqBg4hacZaVenQ/3yAF/uV7BXZXjiWc=";
+  })
+  (fetchNuGet {
+    pname = "System.Threading.Tasks";
+    version = "4.0.11";
+    hash = "sha256-5SLxzFg1df6bTm2t09xeI01wa5qQglqUwwJNlQPJIVs=";
+  })
+  (fetchNuGet {
+    pname = "System.Threading.Tasks";
+    version = "4.3.0";
+    hash = "sha256-Z5rXfJ1EXp3G32IKZGiZ6koMjRu0n8C1NGrwpdIen4w=";
+  })
+  (fetchNuGet {
+    pname = "System.Threading.Tasks.Dataflow";
+    version = "4.11.1";
+    hash = "sha256-fIt5XouNaswWOvZWpIHbTItVzUJDCmz3XawHr6J2yyU=";
+  })
+  (fetchNuGet {
+    pname = "System.Threading.Tasks.Extensions";
+    version = "4.0.0";
+    hash = "sha256-+YdcPkMhZhRbMZHnfsDwpNbUkr31X7pQFGxXYcAPZbE=";
+  })
+  (fetchNuGet {
+    pname = "System.Threading.Tasks.Extensions";
+    version = "4.3.0";
+    hash = "sha256-X2hQ5j+fxcmnm88Le/kSavjiGOmkcumBGTZKBLvorPc=";
+  })
+  (fetchNuGet {
+    pname = "System.Threading.Tasks.Extensions";
+    version = "4.5.4";
+    hash = "sha256-owSpY8wHlsUXn5xrfYAiu847L6fAKethlvYx97Ri1ng=";
+  })
+  (fetchNuGet {
+    pname = "System.Threading.ThreadPool";
+    version = "4.3.0";
+    hash = "sha256-wW0QdvssRoaOfQLazTGSnwYTurE4R8FxDx70pYkL+gg=";
+  })
+  (fetchNuGet {
+    pname = "System.Threading.Timer";
+    version = "4.3.0";
+    hash = "sha256-pmhslmhQhP32TWbBzoITLZ4BoORBqYk25OWbru04p9s=";
+  })
+  (fetchNuGet {
+    pname = "System.Xml.ReaderWriter";
+    version = "4.0.11";
+    hash = "sha256-haZAFFQ9Sl2DhfvEbdx2YRqKEoxNMU5STaqpMmXw0zA=";
+  })
+  (fetchNuGet {
+    pname = "System.Xml.ReaderWriter";
+    version = "4.3.0";
+    hash = "sha256-QQ8KgU0lu4F5Unh+TbechO//zaAGZ4MfgvW72Cn1hzA=";
+  })
+  (fetchNuGet {
+    pname = "System.Xml.XDocument";
+    version = "4.0.11";
+    hash = "sha256-KPz1kxe0RUBM+aoktJ/f9p51GudMERU8Pmwm//HdlFg=";
+  })
+  (fetchNuGet {
+    pname = "System.Xml.XDocument";
+    version = "4.3.0";
+    hash = "sha256-rWtdcmcuElNOSzCehflyKwHkDRpiOhJJs8CeQ0l1CCI=";
+  })
+  (fetchNuGet {
+    pname = "System.Xml.XmlDocument";
+    version = "4.3.0";
+    hash = "sha256-kbuV4Y7rVJkfMp2Kgoi8Zvdatm9CZNmlKB3GZgANvy4=";
+  })
+  (fetchNuGet {
+    pname = "WaylandNET";
+    version = "0.2.0";
+    hash = "sha256-E2VXvSV4KkTz1tQgGXJpuvRQiPlVvSAJb7htBFTeV+I=";
+  })
+  (fetchNuGet {
+    pname = "xunit";
+    version = "2.4.1";
+    hash = "sha256-QGDuE0ZnsxyEJONP8GcJ80PmPeb+OawwdSW8y72aw3U=";
+  })
+  (fetchNuGet {
+    pname = "xunit.abstractions";
+    version = "2.0.3";
+    hash = "sha256-0D1y/C34iARI96gb3bAOG8tcGPMjx+fMabTPpydGlAM=";
+  })
+  (fetchNuGet {
+    pname = "xunit.analyzers";
+    version = "0.10.0";
+    hash = "sha256-8lRZhogXHYksa9ChnkFXpBnTMlLlYIvu3Av7qQYWwJY=";
+  })
+  (fetchNuGet {
+    pname = "xunit.assert";
+    version = "2.4.1";
+    hash = "sha256-hl1cMSakAlwkpFEchxCNMdvQie6PMJ1uFrhzgOC3vsY=";
+  })
+  (fetchNuGet {
+    pname = "xunit.core";
+    version = "2.4.1";
+    hash = "sha256-KgUgAIJIPHQ5VQ4FiB+i5u2JXSYxmvMCV8zXP4kcy9o=";
+  })
+  (fetchNuGet {
+    pname = "xunit.extensibility.core";
+    version = "2.4.1";
+    hash = "sha256-oACVOrvF4XmKFr+8ZqPVpjbopZgeRwaXveJGW2XUeIA=";
+  })
+  (fetchNuGet {
+    pname = "xunit.extensibility.execution";
+    version = "2.4.1";
+    hash = "sha256-KmKEdgsUq4zuQJ2saJA0YT1CIZ2AuhZL5V7cF2Cncd0=";
+  })
+  (fetchNuGet {
+    pname = "xunit.runner.visualstudio";
+    version = "2.4.3";
+    hash = "sha256-42axn0yDDiJWKV8UEYzYWgiKbpc6mHh9M/eeylYGLUg=";
+  })
+]

pkgs/by-name/op/opentabletdriver/update.sh

···
+#!/usr/bin/env nix-shell
+#!nix-shell -I nixpkgs=./. -i bash -p curl gnused jq common-updater-scripts nixfmt-rfc-style
+set -eo pipefail
+
+verlte() {
+    printf '%s\n' "$1" "$2" | sort -C -V
+}
+
+new_version="$(curl ${GITHUB_TOKEN:+" -u \":$GITHUB_TOKEN\""} -s "https://api.github.com/repos/OpenTabletDriver/OpenTabletDriver/releases" |
+    jq -r  'map(select(.prerelease == false)) | .[0].tag_name' |
+    cut -c2-)"
+old_version="$(nix --extra-experimental-features 'nix-command' eval --file default.nix opentabletdriver.version --raw)"
+
+if verlte "$new_version" "$old_version"; then
+  echo "Already up to date!"
+  [[ "${1}" != "--force" ]] && exit 0
+fi
+
+update-source-version opentabletdriver "$new_version"
+eval "$(nix-build -A opentabletdriver.fetch-deps --no-out-link)"
+
+cd "$(dirname "${BASH_SOURCE[0]}")"
+nixfmt deps.nix

pkgs/by-name/ox/ox/package.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "ox";
-  version = "0.7.1";
+  version = "0.7.2";
 
   src = fetchFromGitHub {
     owner = "curlpipe";
     repo = pname;
     rev = version;
-    hash = "sha256-7rP/h3MlrMZl9yd655uRrnv1aUB57LzdyKs66wHp33Y=";
+    hash = "sha256-yAToibHhvHAry7WVZ5uD84CbUTp06RyZ9J12/2deM1I=";
   };
 
-  cargoHash = "sha256-z9pyMnYQZfCCVdVEakj3q27SFLahMDWRuAopYye6RIY=";
+  cargoHash = "sha256-YAy5vCxcHUL0wM9+Y3GDqV/V1utL3V05heT92/zQ/X8=";
 
   passthru = {
     tests.version = testers.testVersion {

pkgs/by-name/pa/parca-agent/package.nix

···
+{
+  buildGoModule,
+  fetchFromGitHub,
+  lib,
+  stdenv,
+}:
+
+buildGoModule rec {
+  pname = "parca-agent";
+  version = "0.35.0";
+
+  src = fetchFromGitHub {
+    owner = "parca-dev";
+    repo = "parca-agent";
+    rev = "refs/tags/v${version}";
+    hash = "sha256-5MoHX47uUtQgszNuu9ImLJPYnaN2NKZKOPa60PMHDL0=";
+    fetchSubmodules = true;
+  };
+
+  proxyVendor = true;
+  vendorHash = "sha256-v2OnCuOI9inZ4WiU/3PbBwK6ZcvZX21MNsLhRWZ6sGY=";
+
+  buildInputs = [
+    stdenv.cc.libc.static
+  ];
+
+  ldflags = [
+    "-X=main.version=${version}"
+    "-X=main.commit=${src.rev}"
+    "-extldflags=-static"
+  ];
+
+  tags = [
+    "osusergo"
+    "netgo"
+  ];
+
+  meta = {
+    description = "eBPF based, always-on profiling agent";
+    homepage = "https://github.com/parca-dev/parca-agent";
+    changelog = "https://github.com/parca-dev/parca-agent/releases/tag/v${version}";
+    license = lib.licenses.asl20;
+    maintainers = with lib.maintainers; [ jnsgruk ];
+    platforms = lib.platforms.linux;
+    mainProgram = "parca-agent";
+  };
+}

pkgs/by-name/pa/parca-debuginfo/package.nix

···
+{
+  lib,
+  buildGoModule,
+  fetchFromGitHub,
+}:
+
+buildGoModule rec {
+  pname = "parca-debuginfo";
+  version = "0.11.0";
+
+  src = fetchFromGitHub {
+    owner = "parca-dev";
+    repo = "parca-debuginfo";
+    rev = "refs/tags/v${version}";
+    hash = "sha256-gL1BgDtEf2Q7yxzpoiTJY+nsRlsWv3zYzLVvaVijMDM=";
+  };
+
+  vendorHash = "sha256-xtKkKhKQmZcCIFTOH+oM5a2cPlAWlJPRNQWfrAl2948=";
+
+  ldflags = [
+    "-X=main.version=${version}"
+    "-X=main.commit=${src.rev}"
+  ];
+
+  meta = {
+    description = "Command line utility for handling debuginfos";
+    changelog = "https://github.com/parca-dev/parca-debuginfo/releases/tag/v${version}";
+    homepage = "https://github.com/parca-dev/parca-debuginfo";
+    license = lib.licenses.asl20;
+    maintainers = with lib.maintainers; [ jnsgruk ];
+    platforms = lib.platforms.unix;
+    mainProgram = "parca-debuginfo";
+  };
+}

pkgs/by-name/pg/pg-gvm/package.nix pkgs/servers/sql/postgresql/ext/pg-gvm.nix

···
 {
+  buildPostgresqlExtension,
   cmake,
   fetchFromGitHub,
   glib,
···
   pcre2,
   pkg-config,
   postgresql,
-  stdenv,
 }:
 
-stdenv.mkDerivation rec {
+buildPostgresqlExtension (finalAttrs: {
   pname = "pg-gvm";
   version = "22.6.5";
 
   src = fetchFromGitHub {
     owner = "greenbone";
     repo = "pg-gvm";
-    rev = "refs/tags/v${version}";
+    rev = "refs/tags/v${finalAttrs.version}";
     hash = "sha256-19ZmQdLjfwJwOMoO16rKJYKOnRyt7SQOdkYTxt8WQ2A=";
   };
 
   strictDeps = true;
 
-  configurePhase = ''
-    runHook preConfigure
-
-    cmake \
-      -DCMAKE_INSTALL_DEV_PREFIX=$out .
-
-    runHook postConfigure
-  '';
-
   nativeBuildInputs = [
     cmake
     pkg-config
···
     icu
     libical
     pcre2
-    postgresql
   ];
 
   meta = {
     description = "Greenbone Library for helper functions in PostgreSQL";
     homepage = "https://github.com/greenbone/pg-gvm";
-    changelog = "https://github.com/greenbone/pg-gvm/releases/tag/v${version}";
+    changelog = "https://github.com/greenbone/pg-gvm/releases/tag/v${finalAttrs.version}";
     license = lib.licenses.gpl3Only;
     maintainers = with lib.maintainers; [ tochiaha ];
     mainProgram = "pg-gvm";
-    platforms = lib.platforms.all;
+    platforms = postgresql.meta.platforms;
   };
-}
+})

pkgs/by-name/pg/pg_top/package.nix

···
-{ lib, stdenv, fetchurl, ncurses, postgresql }:
+{
+  cmake,
+  fetchurl,
+  lib,
+  libbsd,
+  libelf,
+  ncurses,
+  postgresql,
+  stdenv,
+}:
 
 stdenv.mkDerivation rec {
   pname = "pg_top";
-  version = "3.7.0";
+  version = "4.1.0";
 
   src = fetchurl {
-    url = "https://pgfoundry.org/frs/download.php/1781/pg_top-${version}.tar.gz";
-    sha256 = "17xrv0l58rv3an06gkajzw0gg6v810xx6vl137an1iykmhvfh7h2";
+    url = "https://pg_top.gitlab.io/source/pg_top-${version}.tar.xz";
+    sha256 = "sha256-WdSiQURJgtBCYoS/maImppcyM8wzUIJzLWmiSZPlx1Q=";
   };
 
-  buildInputs = [ ncurses postgresql ];
+  buildInputs = [
+    libbsd
+    libelf
+    ncurses
+    postgresql
+  ];
+
+  nativeBuildInputs = [ cmake ];
 
   meta = with lib; {
     description = "'top' like tool for PostgreSQL";
     longDescription = ''
       pg_top allows you to:
        * View currently running SQL statement of a process.
-       * View query plan of a currently running SQL statement.
+       * View query plan of a currently running SELECT statement.
        * View locks held by a process.
-       * View user table statistics.
-       * View user index statistics.
+       * View I/O statistics per process.
+       * View replication statistics for downstream nodes.
     '';
 
-    homepage = "http://ptop.projects.postgresql.org/";
+    homepage = "https://pg_top.gitlab.io";
+    changelog = "https://gitlab.com/pg_top/pg_top/-/blob/main/HISTORY.rst";
     platforms = platforms.linux;
-    license = licenses.free; # see commands.c
+    license = licenses.bsd3;
     mainProgram = "pg_top";
   };
 }

pkgs/by-name/pr/pragtical/package.nix

···
 
 stdenv.mkDerivation (finalAttrs: {
   pname = "pragtical";
-  version = "3.5.0";
+  version = "3.5.1";
   pluginManagerVersion = "1.2.9";
 
   src = fetchFromGitHub {
···
       find subprojects -type d -name .git -prune -execdir rm -r {} +
     '';
 
-    hash = "sha256-a9LnLKtJ33YHtlnhWmKBeW5dOjjwa7PmaZjYh0+Nx9g=";
+    hash = "sha256-o19akSgsWLRTyHT+dvmTeTS4HtNfzEyNXBhVot92OD4=";
   };
 
   nativeBuildInputs = [

pkgs/by-name/re/readarr/package.nix

···
     x86_64-darwin = "x64";
   }."${stdenv.hostPlatform.system}" or (throw "Unsupported system: ${stdenv.hostPlatform.system}");
   hash = {
-    x64-linux_hash = "sha256-VI0mdNGPyT45GUrp3hpBQVe1xx/BBbMWz7iJQvvrg9E=";
-    arm64-linux_hash = "sha256-4ahiRo13qOEUSzrwXFVRj26U0l5GblXfw7sjY8sCLxQ=";
-    x64-osx_hash = "sha256-1HtarF+eAU2d3dQiw3n/DCIFCbgN4GEUFMlYxy8uglA=";
+    x64-linux_hash = "sha256-48ZlBTr/lO1AAsYInu48fDB77RXH+b2hXjDPwWdeZW4=";
+    arm64-linux_hash = "sha256-vyNoI1ffqWyYCfH+3rRNtaECkku3pF3pD+2RBchD+6o=";
+    x64-osx_hash = "sha256-VeGq+kVuBLGqERcWyvPfcygAG0/262J9/RPr49X4jtE=";
   }."${arch}-${os}_hash";
 in stdenv.mkDerivation rec {
   pname = "readarr";
-  version = "0.4.3.2665";
+  version = "0.4.4.2686";
 
   src = fetchurl {
     url = "https://github.com/Readarr/Readarr/releases/download/v${version}/Readarr.develop.${version}.${os}-core-${arch}.tar.gz";

pkgs/by-name/re/restinio/package.nix

···
 
 stdenv.mkDerivation (finalAttrs: {
   pname = "restinio";
-  version = "0.7.2";
+  version = "0.7.3";
 
   src = fetchFromGitHub {
     owner = "Stiffstream";
     repo = "restinio";
     rev = "v.${finalAttrs.version}";
-    hash = "sha256-Nv/VVdHciCv+DsVu3MqfXeAa8Ef+qi6c1OaTAVrYUg0=";
+    hash = "sha256-heVdo0MtsWi/r9yse+/FZ55lhiunyEdwB3UkOOY5Vj0=";
   };
 
   strictDeps = true;

pkgs/by-name/rf/rfc/package.nix

···
 
 stdenvNoCC.mkDerivation rec {
   pname = "rfc";
-  version = "1.0.0";
+  version = "1.0.1";
 
   src = fetchFromGitHub {
     owner = "bfontaine";
     repo = "rfc";
     rev = "v${version}";
-    hash = "sha256-zN+MQtHh69PkzbrfceHFpBYCPmTg9qrOf/ML2efq6Xk=";
+    hash = "sha256-bCqgLkbZGQFcxhLwekVw+rUGinXTc7QJHlVRGtNf6Jc=";
   };
 
   nativeBuildInputs = [ installShellFiles makeWrapper ];

pkgs/by-name/ru/rustls-ffi/package.nix

···
 
 stdenv.mkDerivation (finalAttrs: {
   pname = "rustls-ffi";
-  version = "0.13.0";
+  version = "0.14.1";
 
   src = fetchFromGitHub {
     owner = "rustls";
     repo = "rustls-ffi";
     rev = "v${finalAttrs.version}";
-    hash = "sha256-Bc9bVZ2pDsG118l/SlElZpgh9F1JEgPF8LzBX7d4mhE=";
+    hash = "sha256-ZKAyKcKwhnPE6PrfBFjLJKkTlGbdLcmW1EP/xSv2cpM=";
   };
 
   cargoDeps = rustPlatform.fetchCargoTarball {
     src = finalAttrs.src;
     name = "${finalAttrs.pname}-${finalAttrs.version}";
-    hash = "sha256-gDQ9AFrJuV7SrzKCAHQBkKj6clXuPLO0DHhnvcBqRLs=";
+    hash = "sha256-IaOhQfDEgLhGmes0xzhLVym29aP691TY0EXdOIgXEMA=";
   };
 
   propagatedBuildInputs = lib.optionals stdenv.hostPlatform.isDarwin [ libiconv darwin.apple_sdk.frameworks.Security ];
···
 
   passthru.tests = {
     curl = curl.override { opensslSupport = false; rustlsSupport = true; rustls-ffi = finalAttrs.finalPackage; };
-    apacheHttpd = apacheHttpd.override { modTlsSupport = true; rustls-ffi = finalAttrs.finalPackage; };
     pkg-config = testers.testMetaPkgConfig finalAttrs.finalPackage;
   };
 

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

···
     perl
     pkg-config
     python3
+    rustPlatform.bindgenHook
     taplo
     which
     yasm
···
     wrapProgram $out/bin/servo \
       --prefix LD_LIBRARY_PATH : ${runtimePaths}
   '';
-
-  LIBCLANG_PATH = "${lib.getLib llvmPackages.libclang}/lib";
 
   meta = {
     description = "The embeddable, independent, memory-safe, modular, parallel web rendering engine";

pkgs/by-name/sv/svd2rust/package.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "svd2rust";
-  version = "0.33.5";
+  version = "0.35.0";
 
   src = fetchCrate {
     inherit pname version;
-    hash = "sha256-wZfCk8jzTmltpmrp7QWU1uS5ct10iltNFdUCJvnrv98=";
+    hash = "sha256-KLwIwJtPBQ8Sa94/IEJhIGTx/n3oYQKINmNV5L5TJV0=";
   };
 
-  cargoHash = "sha256-5m3/5zwjDeDgPuUsTIknXwEMjQs0gtVoksQn4EdPnwM=";
+  cargoHash = "sha256-4a89Do57KFKu/RDTB4BxUxVlO46HL5aEhhHmnzLuZGo=";
 
   # error: linker `aarch64-linux-gnu-gcc` not found
   postPatch = ''

pkgs/by-name/tb/tbls/package.nix

···
 
 buildGoModule rec {
   pname = "tbls";
-  version = "1.78.0";
+  version = "1.79.4";
 
   src = fetchFromGitHub {
     owner = "k1LoW";
     repo = "tbls";
     rev = "v${version}";
-    hash = "sha256-vqt4IlVvqlUjDqvcdiRctt/VuEkZ5YzCXYHvHfc87Ew=";
+    hash = "sha256-o/ZhXoenK3xlflRMXS9NtnW23VBiDmDPSGlHtE3cNiM=";
   };
 
-  vendorHash = "sha256-cnACY+NIjsVe6BU7AjTO+yLDn0f1HO1gHnw5SgqKuy4=";
+  vendorHash = "sha256-SkddF8ZxvGRQ+/tWnmlcoaTs3MRfVgQWX4MZ05nZ9XA=";
 
   nativeBuildInputs = [ installShellFiles ];
 

pkgs/by-name/te/terraform-backend-git/package.nix

···
 
 buildGoModule rec {
   pname = "terraform-backend-git";
-  version = "0.1.7";
+  version = "0.1.8";
 
   src = fetchFromGitHub {
     owner = "plumber-cd";
     repo = "terraform-backend-git";
     rev = "v${version}";
-    hash = "sha256-mLgUA7f4enlVuQx4VM3QbNuaAq7FgDaRyiG0sbT31ng=";
+    hash = "sha256-mZbGMv5b9wK/gWqQB75sDJIVURrS6t/L7WBhTonaatQ=";
   };
 
   vendorHash = "sha256-vFx59dIdniLRP0xHcD3c22GidZOPdGZvmvg/BvxFBGI=";

pkgs/by-name/up/updatecli/package.nix

···
 
 buildGoModule rec {
   pname = "updatecli";
-  version = "0.82.0";
+  version = "0.88.0";
 
   src = fetchFromGitHub {
     owner = "updatecli";
     repo = "updatecli";
     rev = "v${version}";
-    hash = "sha256-kNc+Z+v4fvuWO/Ibr9VOekMDT39YEwA/fReP+e3C74U=";
+    hash = "sha256-qWggdLNF6iWrbcKgdR3Tr19bwK5wS5ffadS3kMFGp5E=";
   };
 
-  vendorHash = "sha256-fnx0EAGxau0+ktnuUb8ljolNAlwu2595FMjsDbM2MiY=";
+  vendorHash = "sha256-feBmzBrV6yoepU8CiqKaB/bCWIhuiDNhMTem0y1Lynw=";
 
   # tests require network access
   doCheck = false;

pkgs/by-name/ve/vencord/package.nix

···
 }:
 stdenv.mkDerivation (finalAttrs: {
   pname = "vencord";
-  version = "1.10.7";
+  version = "1.10.8";
 
   src = fetchFromGitHub {
     owner = "Vendicated";
     repo = "Vencord";
     rev = "v${finalAttrs.version}";
-    hash = "sha256-/CZzRIXD0shEok9H+Vx7s9BmzXTI6ly957jvS+nU2fI=";
+    hash = "sha256-2UOz8o+3jWppk6lWatbG0avcqBFpxHYSMEspCpFWWOk=";
   };
 
   pnpmDeps = pnpm.fetchDeps {

pkgs/by-name/xa/xautocfg/package.nix

···
+{
+  lib,
+  stdenv,
+  fetchFromGitHub,
+  libX11,
+  libXi,
+}:
+
+stdenv.mkDerivation (finalAttrs: {
+  pname = "xautocfg";
+  version = "1.2";
+
+  src = fetchFromGitHub {
+    owner = "SFTtech";
+    repo = "xautocfg";
+    rev = "refs/tags/v${finalAttrs.version}";
+    hash = "sha256-NxfuBknNRicmEAPBeMaNb57gpM0y0t+JmNMKpSNzlQM=";
+  };
+
+  buildInputs = [
+    libX11
+    libXi
+  ];
+
+  makeFlags = [
+    "PREFIX=${placeholder "out"}"
+    "MANPREFIX=${placeholder "out"}"
+  ];
+
+  meta = {
+    homepage = "https://github.com/SFTtech/xautocfg";
+    description = "Automatic keyboard repeat rate configuration for new keyboards";
+    license = lib.licenses.gpl3Only;
+    maintainers = with lib.maintainers; [ jceb ];
+    mainProgram = "xautocfg";
+    platforms = lib.platforms.linux;
+  };
+})

pkgs/development/compilers/binaryen/default.nix

···
 { lib, stdenv, cmake, python3, fetchFromGitHub, emscripten,
   gtest, lit, nodejs, filecheck
 }:
-
-stdenv.mkDerivation rec {
-  pname = "binaryen";
-  version = "118";
-
-  src = fetchFromGitHub {
+let
+  testsuite = fetchFromGitHub {
     owner = "WebAssembly";
-    repo = "binaryen";
-    rev = "version_${version}";
-    hash = "sha256-akMW3S2/qUyLK8F77EtnaXPDXvIMpkGfNB2jOD6hQho=";
+    repo = "testsuite";
+    rev = "e05365077e13a1d86ffe77acfb1a835b7aa78422";
+    hash = "sha256-yvZ5AZTPUA6nsD3xpFC0VLthiu2CxVto66RTXBXXeJM=";
   };
+in
+  stdenv.mkDerivation rec {
+    pname = "binaryen";
+    version = "119";
 
-  nativeBuildInputs = [ cmake python3 ];
+    src = fetchFromGitHub {
+      owner = "WebAssembly";
+      repo = "binaryen";
+      rev = "version_${version}";
+      hash = "sha256-JYXtN3CW4qm/nnjGRvv3GxQ0x9O9wHtNYQLqHIYTTOA=";
+    };
 
-  preConfigure = ''
-    if [ $doCheck -eq 1 ]; then
-      sed -i '/googletest/d' third_party/CMakeLists.txt
-    else
-      cmakeFlagsArray=($cmakeFlagsArray -DBUILD_TESTS=0)
-    fi
-  '';
+    nativeBuildInputs = [ cmake python3 ];
 
-  nativeCheckInputs = [ gtest lit nodejs filecheck ];
-  checkPhase = ''
-    LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$PWD/lib python3 ../check.py $tests
-  '';
+    preConfigure = ''
+      if [ $doCheck -eq 1 ]; then
+        sed -i '/googletest/d' third_party/CMakeLists.txt
+        rmdir test/spec/testsuite
+        ln -s ${testsuite} test/spec/testsuite
+      else
+        cmakeFlagsArray=($cmakeFlagsArray -DBUILD_TESTS=0)
+      fi
+    '';
 
-  tests = [
-    "version" "wasm-opt" "wasm-dis"
-    "crash" "dylink" "ctor-eval"
-    "wasm-metadce" "wasm-reduce" "spec"
-    "lld" "wasm2js" "validator"
-    "example" "unit"
-    # "binaryenjs" "binaryenjs_wasm" # not building this
-    "lit" "gtest"
-  ];
-  doCheck = stdenv.hostPlatform.isLinux;
+    nativeCheckInputs = [ gtest lit nodejs filecheck ];
+    checkPhase = ''
+      LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$PWD/lib python3 ../check.py $tests
+    '';
 
-  meta = with lib; {
-    homepage = "https://github.com/WebAssembly/binaryen";
-    description = "Compiler infrastructure and toolchain library for WebAssembly, in C++";
-    platforms = platforms.all;
-    maintainers = with maintainers; [ asppsa willcohen ];
-    license = licenses.asl20;
-  };
+    tests = [
+      "version" "wasm-opt" "wasm-dis"
+      "crash" "dylink" "ctor-eval"
+      "wasm-metadce" "wasm-reduce" "spec"
+      "lld" "wasm2js" "validator"
+      "example" "unit"
+      # "binaryenjs" "binaryenjs_wasm" # not building this
+      "lit" "gtest"
+    ];
+    doCheck = stdenv.isLinux;
 
-  passthru.tests = {
-    inherit emscripten;
-  };
-}
+    meta = with lib; {
+      homepage = "https://github.com/WebAssembly/binaryen";
+      description = "Compiler infrastructure and toolchain library for WebAssembly, in C++";
+      platforms = platforms.all;
+      maintainers = with maintainers; [ asppsa willcohen ];
+      license = licenses.asl20;
+    };
+    passthru.tests = {
+      inherit emscripten;
+    };
+  }

pkgs/development/compilers/emscripten/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "emscripten";
-  version = "3.1.64";
+  version = "3.1.73";
 
   llvmEnv = symlinkJoin {
     name = "emscripten-llvm-${version}";
···
     name = "emscripten-node-modules-${version}";
     inherit pname version src;
 
-    npmDepsHash = "sha256-2dsIuB6P+Z3wflIsn6QaZvjHeHHGzsFAI3GcP3SfiP4=";
+    npmDepsHash = "sha256-bqxUlxpIH1IAx9RbnaMq4dZW8fy+M/Q02Q7VrW/AKNQ=";
 
     dontBuild = true;
 
···
   src = fetchFromGitHub {
     owner = "emscripten-core";
     repo = "emscripten";
-    hash = "sha256-AbO1b4pxZ7I6n1dRzxhLC7DnXIUnaCK9SbLy96Qxqr0=";
+    hash = "sha256-QlC2k2rhF3/Pz+knnrlBDV8AfHHBSlGr7b9Ae6TNsxY=";
     rev = version;
   };
 
···
     runHook preBuild
 
     patchShebangs .
+
+    # emscripten 3.1.67 requires LLVM tip-of-tree instead of LLVM 18
+    sed -i -e "s/EXPECTED_LLVM_VERSION = 20/EXPECTED_LLVM_VERSION = 19/g" tools/shared.py
 
     # fixes cmake support
     sed -i -e "s/print \('emcc (Emscript.*\)/sys.stderr.write(\1); sys.stderr.flush()/g" emcc.py

pkgs/development/compilers/ghc/common-hadrian.nix

···
 
       patches =
         let
-          # Disable haddock generating pretty source listings to stay under 3GB on aarch64-linux
           enableHyperlinkedSource =
-            lib.versionAtLeast version "9.8" ||
-            !(stdenv.hostPlatform.isAarch64 && stdenv.hostPlatform.isLinux);
+            # Disable haddock generating pretty source listings to stay under 3GB on aarch64-linux
+            !(stdenv.hostPlatform.isAarch64 && stdenv.hostPlatform.isLinux)
+            # 9.8 and 9.10 don't run into this problem for some reason
+            || (lib.versionAtLeast version "9.8" && lib.versionOlder version "9.11");
         in
         [
           # Fix docs build with Sphinx >= 7 https://gitlab.haskell.org/ghc/ghc/-/issues/24129
···
            then ./Cabal-at-least-3.6-paths-fix-cycle-aarch64-darwin.patch
            else ./Cabal-3.12-paths-fix-cycle-aarch64-darwin.patch)
         ]
-        # Prevents passing --hyperlinked-source to haddock. This is a custom
-        # workaround as we wait for this to be configurable via userSettings or
-        # similar. https://gitlab.haskell.org/ghc/ghc/-/issues/23625
+        # Prevents passing --hyperlinked-source to haddock. Note that this can
+        # be configured via a user defined flavour now. Unfortunately, it is
+        # impossible to import an existing flavour in UserSettings, so patching
+        # the defaults is actually simpler and less maintenance intensive
+        # compared to keeping an entire flavour definition in sync with upstream
+        # manually. See also https://gitlab.haskell.org/ghc/ghc/-/issues/23625
         ++ lib.optionals (!enableHyperlinkedSource) [
-          # TODO(@sternenseemann): Doesn't apply for GHC >= 9.8
-          ../../tools/haskell/hadrian/disable-hyperlinked-source.patch
+          (if lib.versionOlder version "9.8"
+           then ../../tools/haskell/hadrian/disable-hyperlinked-source-pre-9.8.patch
+           else ../../tools/haskell/hadrian/disable-hyperlinked-source-extra-args.patch)
         ]
         # Incorrect bounds on Cabal in hadrian
         # https://gitlab.haskell.org/ghc/ghc/-/issues/24100

pkgs/development/haskell-modules/configuration-common.nix

···
   #######################################
 
   # All jailbreaks in this section due to: https://github.com/haskell/haskell-language-server/pull/4316#discussion_r1667684895
-  haskell-language-server = doJailbreak (dontCheck (super.haskell-language-server.overrideScope (lself: lsuper: {
-    # For most ghc versions, we overrideScope Cabal in the configuration-ghc-???.nix,
-    # because some packages, like ormolu, need a newer Cabal version.
-    # ghc-paths is special because it depends on Cabal for building
-    # its Setup.hs, and therefor declares a Cabal dependency, but does
-    # not actually use it as a build dependency.
-    # That means ghc-paths can just use the ghc included Cabal version,
-    # without causing package-db incoherence and we should do that because
-    # otherwise we have different versions of ghc-paths
-    # around which have the same abi-hash, which can lead to confusions and conflicts.
-    ghc-paths = lsuper.ghc-paths.override { Cabal = null; };
-  })));
+  haskell-language-server =
+    lib.pipe
+      (super.haskell-language-server.overrideScope (lself: lsuper: {
+        # For most ghc versions, we overrideScope Cabal in the configuration-ghc-???.nix,
+        # because some packages, like ormolu, need a newer Cabal version.
+        # ghc-paths is special because it depends on Cabal for building
+        # its Setup.hs, and therefor declares a Cabal dependency, but does
+        # not actually use it as a build dependency.
+        # That means ghc-paths can just use the ghc included Cabal version,
+        # without causing package-db incoherence and we should do that because
+        # otherwise we have different versions of ghc-paths
+        # around which have the same abi-hash, which can lead to confusions and conflicts.
+        ghc-paths = lsuper.ghc-paths.override { Cabal = null; };
+      }))
+      [
+        doJailbreak
+        dontCheck
+      ];
+
   hls-plugin-api = doJailbreak super.hls-plugin-api;
-  ghcide = doJailbreak super.ghcide;
+  ghcide = doJailbreak (appendPatch (pkgs.fetchpatch {
+    name = "ghcide-ghc-9.8.3.patch";
+    url = "https://github.com/haskell/haskell-language-server/commit/6d0a6f220226fe6c1cb5b6533177deb55e755b0b.patch";
+    sha256 = "1jwxldar9qzkg2z6vsx8f2yih3vkf4yjk9p3mryv0azn929qn3h1";
+    stripLen = 1;
+    excludes = [ "cabal.project" ];
+  }) super.ghcide);
 
   # For -f-auto see cabal.project in haskell-language-server.
   ghc-lib-parser-ex = addBuildDepend self.ghc-lib-parser (disableCabalFlag "auto" super.ghc-lib-parser-ex);

pkgs/development/haskell-modules/configuration-ghc-9.14.x.nix

···
+{ pkgs, haskellLib }:
+
+let
+  inherit (pkgs) lib;
+
+in
+
+self: super: {
+  llvmPackages = lib.dontRecurseIntoAttrs self.ghc.llvmPackages;
+
+  # Disable GHC core libraries
+  array = null;
+  base = null;
+  binary = null;
+  bytestring = null;
+  Cabal = null;
+  Cabal-syntax = null;
+  containers = null;
+  deepseq = null;
+  directory = null;
+  exceptions = null;
+  file-io = null;
+  filepath = null;
+  ghc-bignum = null;
+  ghc-boot = null;
+  ghc-boot-th = null;
+  ghc-compact = null;
+  ghc-experimental = null;
+  ghc-heap = null;
+  ghc-internal = null;
+  ghc-platform = null;
+  ghc-prim = null;
+  ghc-toolchain = null;
+  ghci = null;
+  haddock-api = null;
+  haddock-library = null;
+  haskeline = null;
+  hpc = null;
+  integer-gmp = null;
+  mtl = null;
+  os-string = null;
+  parsec = null;
+  pretty = null;
+  process = null;
+  rts = null;
+  semaphore-compat = null;
+  stm = null;
+  system-cxx-std-lib = null;
+  template-haskell = null;
+  # GHC only builds terminfo if it is a native compiler
+  terminfo =
+    if pkgs.stdenv.hostPlatform == pkgs.stdenv.buildPlatform then
+      null
+    else
+      haskellLib.doDistribute self.terminfo_0_4_1_6;
+  text = null;
+  time = null;
+  transformers = null;
+  unix = null;
+  xhtml = null;
+}

pkgs/development/julia-modules/default.nix

···
 runCommand "julia-${julia.version}-env" {
   nativeBuildInputs = [makeWrapper];
 
-  inherit julia;
-  inherit juliaWrapped;
-  meta = julia.meta;
+  passthru = {
+    inherit julia;
+    inherit juliaWrapped;
+    inherit (julia) pname version meta;
 
-  # Expose the steps we used along the way in case the user wants to use them, for example to build
-  # expressions and build them separately to avoid IFD.
-  inherit dependencies;
-  inherit closureYaml;
-  inherit dependencyUuidToInfoYaml;
-  inherit dependencyUuidToRepoYaml;
-  inherit minimalRegistry;
-  inherit artifactsNix;
-  inherit overridesJson;
-  inherit overridesToml;
-  inherit projectAndDepot;
+    # Expose the steps we used along the way in case the user wants to use them, for example to build
+    # expressions and build them separately to avoid IFD.
+    inherit dependencies;
+    inherit closureYaml;
+    inherit dependencyUuidToInfoYaml;
+    inherit dependencyUuidToRepoYaml;
+    inherit minimalRegistry;
+    inherit artifactsNix;
+    inherit overridesJson;
+    inherit overridesToml;
+    inherit projectAndDepot;
+  };
 } (''
   mkdir -p $out/bin
   makeWrapper ${juliaWrapped}/bin/julia $out/bin/julia \

pkgs/development/libraries/tk/generic.nix

···
   ''
   + lib.optionalString (stdenv.hostPlatform.isDarwin && lib.versionOlder stdenv.hostPlatform.darwinMinVersion "11") ''
     substituteInPlace unix/configure* \
-      --replace " -framework UniformTypeIdentifiers" ""
+      --replace-fail " -weak_framework UniformTypeIdentifiers" ""
   '';
 
   postInstall = ''

pkgs/development/php-packages/imagick/default.nix

···
 {
   buildPecl,
+  fetchpatch,
   lib,
   imagemagick,
   pkg-config,
   pcre2,
+  php,
 }:
 
 buildPecl {
···
   configureFlags = [ "--with-imagick=${imagemagick.dev}" ];
   nativeBuildInputs = [ pkg-config ];
   buildInputs = [ pcre2 ];
+
+  patches = lib.optionals (lib.versionAtLeast php.version "8.4") [
+    # PHP 8.4 compatibility patch based on https://github.com/Imagick/imagick/pull/690
+    # These is also an alternative https://github.com/Imagick/imagick/pull/704
+    # Which includes more changes but doesn't apply cleanly.
+    (fetchpatch {
+      url = "https://github.com/Imagick/imagick/commit/65e27f2bc02e7e8f1bf64e26e359e42a1331fca1.patch";
+      hash = "sha256-I0FwdqtQ/Y/QVkCl+nWPBIxsdQY6qcjdwiA/BaLNl7g=";
+    })
+  ];
 
   meta = with lib; {
     description = "Imagick is a native php extension to create and modify images using the ImageMagick API";

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

···
 
 buildPythonPackage rec {
   pname = "aiovlc";
-  version = "0.6.2";
+  version = "0.6.3";
   pyproject = true;
 
   disabled = pythonOlder "3.11";
···
     owner = "MartinHjelmare";
     repo = "aiovlc";
     rev = "refs/tags/v${version}";
-    hash = "sha256-tvMd7kydL4fx9JLTFQgCskBQCV0Zs/swDpPBxtSEvyM=";
+    hash = "sha256-b4QtTR/p2wmVk4LZdkWwzM1odx1cxjUF08pV/zunTx4=";
   };
 
   build-system = [ poetry-core ];

pkgs/development/python-modules/databricks-sdk/default.nix

···
 
 buildPythonPackage rec {
   pname = "databricks-sdk";
-  version = "0.35.0";
+  version = "0.38.0";
   pyproject = true;
 
   src = fetchFromGitHub {
     owner = "databricks";
     repo = "databricks-sdk-py";
     rev = "refs/tags/v${version}";
-    hash = "sha256-CEv/+3E7KWV9LXzFPvDQIL1v8iFgbsS3/cTS/4obWas=";
+    hash = "sha256-g00NRo0FSHujN2mCLZCc1hKGsBFiN7ztEneUMziuQpk=";
   };
 
   build-system = [

pkgs/development/python-modules/dbt-snowflake/default.nix

···
 
 buildPythonPackage rec {
   pname = "dbt-snowflake";
-  version = "1.8.3";
+  version = "1.8.4";
   pyproject = true;
 
   disabled = pythonOlder "3.7";
···
     owner = "dbt-labs";
     repo = "dbt-snowflake";
     rev = "refs/tags/v${version}";
-    hash = "sha256-jvhjf+Ce/oyHXFxMryz5Uy6Hq5Sx6vKgaGEJVAzqSdA=";
+    hash = "sha256-XUHXyxAoIBHXmH2xXOGrCO2+WMwwJ7oVYt4+m/fT/Ko=";
   };
 
   build-system = [ setuptools ];

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

···
 
 buildPythonPackage rec {
   pname = "eq3btsmart";
-  version = "1.2.0";
+  version = "1.4.1";
   pyproject = true;
 
   src = fetchFromGitHub {
     owner = "EuleMitKeule";
     repo = "eq3btsmart";
     rev = "refs/tags/${version}";
-    hash = "sha256-Z3GfUTh3qp5ICJAYsCO6ufw/Jd5FDjOaQE9SaD3H0IU=";
+    hash = "sha256-FRnCnSMtsiZ1AbZOMwO/I5UoFWP0xAFqRZsnrHG9WJA=";
   };
 
   build-system = [ poetry-core ];

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

···
 
 buildPythonPackage rec {
   pname = "fastcore";
-  version = "1.7.20";
+  version = "1.7.22";
   pyproject = true;
 
   disabled = pythonOlder "3.8";
···
     owner = "fastai";
     repo = "fastcore";
     rev = "refs/tags/${version}";
-    hash = "sha256-UGY6iSRF8pY5frZqarxpiNkGEQtgNdXY5mMQzbzMjhA=";
+    hash = "sha256-llD7hDZStgCUfp06byGLtLPgDqiK7BAMw9kLNzOGUec=";
   };
 
   build-system = [ setuptools ];

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

···
 
 buildPythonPackage rec {
   pname = "glances-api";
-  version = "0.8.0";
+  version = "0.9.0";
   pyproject = true;
 
   disabled = pythonOlder "3.11";
···
     owner = "home-assistant-ecosystem";
     repo = "python-glances-api";
     rev = "refs/tags/${version}";
-    hash = "sha256-QAnwFX53jf7yWWa308/XTARNw5Qeo9K2zfD+6+HiFuM=";
+    hash = "sha256-VLsNMFFt+kMxNw/81OMX4Fg/xCbQloCURmV0OxvClq8=";
   };
 
-  patches = [
-    (fetchpatch2 {
-      name = "pytest-httpx-compat.patch";
-      url = "https://github.com/home-assistant-ecosystem/python-glances-api/commit/f193472a25469e7e4b946f9a1c3a7a95949c6c04.patch";
-      hash = "sha256-hFeWv2WdbdeoaHgAOmwtBwWwPLjJzyurTZDV98qR7F8=";
-    })
-  ];
-
   build-system = [ poetry-core ];
 
   dependencies = [ httpx ];
···
     description = "Python API for interacting with Glances";
     homepage = "https://github.com/home-assistant-ecosystem/python-glances-api";
     changelog = "https://github.com/home-assistant-ecosystem/python-glances-api/releases/tag/${version}";
-    license = with licenses; [ mit ];
+    license = licenses.mit;
     maintainers = with maintainers; [ fab ];
   };
 }

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

···
 
 buildPythonPackage rec {
   pname = "herepy";
-  version = "3.6.4";
+  version = "3.6.5";
   pyproject = true;
 
   disabled = pythonOlder "3.8";
···
     owner = "abdullahselek";
     repo = "HerePy";
     rev = "refs/tags/${version}";
-    hash = "sha256-XefoRAaWq5sPQsrqek6kibRjKU+ZImQmt32jutfptNw=";
+    hash = "sha256-8DwzzC0sTrGnMpuADc55HCIeH/KyWacv8X+Ubh+n7ZM=";
   };
 
   build-system = [ setuptools ];

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

···
 
 buildPythonPackage rec {
   pname = "sapi-python-client";
-  version = "0.9.1";
+  version = "0.9.2";
   pyproject = true;
 
   disabled = pythonOlder "3.7";
···
     owner = "keboola";
     repo = "sapi-python-client";
     rev = "refs/tags/${version}";
-    hash = "sha256-4ykOwSQ1tM0ZviETkjU0ydg7FWjkGNysHQe+f9MS0MM=";
+    hash = "sha256-30bAw5pYEUj0jeZWiJxzZ7lDs/+63tlcoLaHrUmYCs8=";
   };
 
   postPatch = ''

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

···
 
 buildPythonPackage rec {
   pname = "latexrestricted";
-  version = "0.6.0";
+  version = "0.6.2";
   pyproject = true;
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-/N5eC32OVN6qxWZAwAUlCIrMV2ARitiX3gaCPiSCRHs=";
+    hash = "sha256-1R0hpBGXpYH/KcD4GFUfFvoOaJDe+Sl5msC952KnqmA=";
   };
 
   build-system = [ setuptools ];

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

···
 
 buildPythonPackage rec {
   pname = "libcst";
-  version = "1.5.0";
+  version = "1.5.1";
   pyproject = true;
 
   disabled = pythonOlder "3.9";
···
     owner = "Instagram";
     repo = "LibCST";
     rev = "refs/tags/v${version}";
-    hash = "sha256-0r2xQ8QVmA4I6eZHBWd/U1fQ8nK5rdblIoMACudOYPY=";
+    hash = "sha256-fveY4ah94pv9ImI36MNrrxTpZv/DtLb45pXm67L8/GA=";
   };
 
   cargoDeps = rustPlatform.fetchCargoTarball {
     inherit src;
     sourceRoot = "${src.name}/${cargoRoot}";
     name = "${pname}-${version}";
-    hash = "sha256-mexXuOsL1+F/GL2wMf/pwK7bJLFRgPtPSYE4W3E0VQ0=";
+    hash = "sha256-TcWGW1RF2se89BtvQHO+4BwnRMZ8ygqO3du9Q/gZi/Q=";
   };
 
   cargoRoot = "native";

pkgs/development/python-modules/llama-cpp-python/default.nix

···
+{
+  lib,
+  stdenv,
+  buildPythonPackage,
+  cmake,
+  fetchFromGitHub,
+  gitUpdater,
+  ninja,
+  pathspec,
+  pyproject-metadata,
+  pytestCheckHook,
+  pythonOlder,
+  scikit-build-core,
+  llama-cpp-python,
+
+  config,
+  cudaSupport ? config.cudaSupport,
+  cudaPackages ? { },
+
+  diskcache,
+  jinja2,
+  numpy,
+  typing-extensions,
+  scipy,
+  huggingface-hub,
+}:
+let
+  version = "0.3.1";
+in
+buildPythonPackage {
+  pname = "llama-cpp-python";
+  inherit version;
+  pyproject = true;
+
+  disabled = pythonOlder "3.7";
+
+  stdenv = if cudaSupport then cudaPackages.backendStdenv else stdenv;
+
+  src = fetchFromGitHub {
+    owner = "abetlen";
+    repo = "llama-cpp-python";
+    rev = "refs/tags/v${version}";
+    hash = "sha256-eO1zvNJZBE5BCnbgbh00tFIRWBCWor1lIsrLXs/HFds=";
+    fetchSubmodules = true;
+  };
+
+  dontUseCmakeConfigure = true;
+  SKBUILD_CMAKE_ARGS = lib.strings.concatStringsSep ";" (
+    lib.optionals cudaSupport [
+      "-DGGML_CUDA=on"
+      "-DCUDAToolkit_ROOT=${lib.getDev cudaPackages.cuda_nvcc}"
+      "-DCMAKE_CUDA_COMPILER=${lib.getExe cudaPackages.cuda_nvcc}"
+    ]
+  );
+
+  nativeBuildInputs = [
+    cmake
+    ninja
+    pathspec
+    pyproject-metadata
+    scikit-build-core
+  ];
+
+  buildInputs = lib.optionals cudaSupport (
+    with cudaPackages;
+    [
+      cuda_cudart # cuda_runtime.h
+      cuda_cccl # <thrust/*>
+      libcublas # cublas_v2.h
+    ]
+  );
+
+  propagatedBuildInputs = [
+    diskcache
+    jinja2
+    numpy
+    typing-extensions
+  ];
+
+  nativeCheckInputs = [
+    pytestCheckHook
+    scipy
+    huggingface-hub
+  ];
+
+  disabledTests = [
+    # tries to download model from huggingface-hub
+    "test_real_model"
+    "test_real_llama"
+  ];
+
+  pythonImportsCheck = [ "llama_cpp" ];
+
+  passthru.updateScript = gitUpdater { rev-prefix = "v"; };
+  passthru.tests.llama-cpp-python = llama-cpp-python.override { cudaSupport = true; };
+
+  meta = {
+    description = "Python bindings for llama.cpp";
+    homepage = "https://github.com/abetlen/llama-cpp-python";
+    license = lib.licenses.mit;
+    maintainers = with lib.maintainers; [ kirillrdy ];
+  };
+}

pkgs/development/python-modules/moderngl-window/default.nix

···
   stdenv,
   buildPythonPackage,
   fetchFromGitHub,
+
+  # build-system
   setuptools,
-  glfw,
-  mesa,
+
+  # dependencies
   moderngl,
   numpy,
   pillow,
+  pyglet,
+  pyglm,
+
+  # optional-dependencies
+  trimesh,
+  scipy,
+  glfw,
   pygame,
-  pyglet,
-  pyqt5,
-  pyrr,
   pysdl2,
   pyside2,
-  pythonOlder,
-  scipy,
-  trimesh,
+  pyqt5,
+
+  mesa,
 }:
 
 buildPythonPackage rec {
   pname = "moderngl-window";
-  version = "2.4.6";
+  version = "3.0.0";
   pyproject = true;
 
-  disabled = pythonOlder "3.8";
-
   src = fetchFromGitHub {
     owner = "moderngl";
     repo = "moderngl_window";
     rev = "refs/tags/${version}";
-    hash = "sha256-zTygSXU/vQZaFCuHbRBpO9/BYYA2UOid+wvhyc2bWMI=";
+    hash = "sha256-V6QQCQcSSEt11+Xv6HtWZSH+/nPFRZZK1ThQJipIT0M=";
   };
 
   pythonRelaxDeps = [
···
     setuptools
   ];
 
-  dependencies = [
+  propagatedBuildInputs = [
+    moderngl
     numpy
-    moderngl
+    pillow
     pyglet
-    pillow
-    pyrr
+    pyglm
   ];
 
   optional-dependencies = {
···
 
   pythonImportsCheck = [ "moderngl_window" ];
 
-  meta = with lib; {
+  meta = {
     description = "Cross platform helper library for ModernGL making window creation and resource loading simple";
     homepage = "https://github.com/moderngl/moderngl-window";
     changelog = "https://github.com/moderngl/moderngl-window/blob/${version}/CHANGELOG.md";
-    license = licenses.mit;
-    maintainers = with maintainers; [ c0deaddict ];
+    license = lib.licenses.mit;
+    maintainers = with lib.maintainers; [ c0deaddict ];
     inherit (mesa.meta) platforms;
     broken = stdenv.hostPlatform.isDarwin;
   };

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

···
 
 buildPythonPackage rec {
   pname = "opensearch-py";
-  version = "2.7.1";
+  version = "2.8.0";
   pyproject = true;
 
   src = fetchFromGitHub {
     owner = "opensearch-project";
     repo = "opensearch-py";
     rev = "refs/tags/v${version}";
-    hash = "sha256-GC0waXxHRiXVXjhTGbet3HvDKmUBKzoufu/J4fmrM+k=";
+    hash = "sha256-rPHpGKEIINAEUu2UkJwAM60i0hTzXd1ec6WD50RrgL8=";
   };
 
   nativeBuildInputs = [ setuptools ];

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

···
 
 buildPythonPackage rec {
   pname = "pyoverkiz";
-  version = "1.15.0";
+  version = "1.15.1";
   pyproject = true;
 
   disabled = pythonOlder "3.10";
···
     owner = "iMicknl";
     repo = "python-overkiz-api";
     rev = "refs/tags/v${version}";
-    hash = "sha256-nwRPIudrxsbK6UYLaGjQJBkGMI5cKEE7m8M0h3k6434=";
+    hash = "sha256-3j72zLBMm6tuQDWqNrkVEFvDAc45xyLnG19lEsJV1Mg=";
   };
 
   build-system = [ poetry-core ];

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

···
 
 buildPythonPackage rec {
   pname = "pystac-client";
-  version = "0.8.4";
+  version = "0.8.5";
   pyproject = true;
   disabled = pythonOlder "3.9";
 
···
     owner = "stac-utils";
     repo = "pystac-client";
     rev = "refs/tags/v${version}";
-    hash = "sha256-EetS0MD5DLBR+ht9YfD+oRdfHbVONuVHdSZj3FQ5Sm8=";
+    hash = "sha256-bryJCg0JqjxQi5tAvd5Y2f/hXmHoIGEFiHuSPCjqfYk=";
   };
 
   build-system = [ setuptools ];

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

···
 
 buildPythonPackage rec {
   pname = "python-gvm";
-  version = "24.8.0";
+  version = "24.11.0";
   pyproject = true;
 
   disabled = pythonOlder "3.9";
···
     owner = "greenbone";
     repo = "python-gvm";
     rev = "refs/tags/v${version}";
-    hash = "sha256-JyImC75Le6S2kQXSU/Ze4TNaitJSJ8LD9j/ny+xjoGA=";
+    hash = "sha256-n4Izhtqs6awEtnt4r915ZtyHQnM49ExbuAzqJw/CNa0=";
   };
 
   build-system = [ poetry-core ];

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

···
   grpcio,
 }:
 let
-  version = "0.15.14";
+  version = "0.16.8";
   optional-dependencies = {
     huggingflace = [
       langdetect
···
     owner = "Unstructured-IO";
     repo = "unstructured";
     rev = "refs/tags/${version}";
-    hash = "sha256-cIMKaSKG4T832rpiJeiwftqVrcMezD9ICfislGPV/TQ=";
+    hash = "sha256-TIJ1cfti+zF9sP0LrIIue9F8n8gRAy5+8hb4cIzHk2U=";
   };
 
   propagatedBuildInputs = [

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

···
   buildPythonPackage,
   fetchPypi,
   isPyPy,
-  python,
+  setuptools,
   python-dateutil,
+  pytz,
+  six,
+  pytestCheckHook,
 }:
 
 buildPythonPackage rec {
-  version = "0.9.7";
-  format = "setuptools";
+  version = "0.9.8";
   pname = "vobject";
+  pyproject = true;
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-q3J7+B3oiYStpcEfBm8eFkmQPT49fskfHOloFyr9UlY=";
+    hash = "sha256-2wCn9NtJOXFV3YpoceiioBdabrpaZUww6RD4KylRS1g=";
   };
 
   disabled = isPyPy;
 
-  propagatedBuildInputs = [ python-dateutil ];
+  build-system = [ setuptools ];
+
+  dependencies = [
+    python-dateutil
+    pytz
+    six
+  ];
+
+  pythonImportsCheck = [ "vobject" ];
+
+  nativeCheckInputs = [ pytestCheckHook ];
 
-  checkPhase = "${python.interpreter} tests.py";
+  pytestFlagsArray = [ "tests.py" ];
 
   meta = with lib; {
     description = "Module for reading vCard and vCalendar files";
-    homepage = "http://eventable.github.io/vobject/";
+    homepage = "https://github.com/py-vobject/vobject";
     license = licenses.asl20;
     maintainers = [ ];
   };

pkgs/development/r-modules/default.nix

···
     });
 
     Rhdf5lib = let
-      hdf5 = pkgs.hdf5_1_10.overrideAttrs (attrs: {configureFlags = attrs.configureFlags ++ [ "--enable-cxx" ];});
+      hdf5 = pkgs.hdf5_1_10;
     in old.Rhdf5lib.overrideAttrs (attrs: {
       propagatedBuildInputs = attrs.propagatedBuildInputs ++ [ hdf5.dev pkgs.libaec ];
       patches = [ ./patches/Rhdf5lib.patch ];

pkgs/development/tools/analysis/cargo-tarpaulin/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "cargo-tarpaulin";
-  version = "0.31.2";
+  version = "0.31.3";
 
   src = fetchFromGitHub {
     owner = "xd009642";
     repo = "tarpaulin";
     rev = version;
-    hash = "sha256-rYu8SsG2vEXMpwsLV/6TjC0iDJRsm6UEl4qXZwXRRpE=";
+    hash = "sha256-ROsoTXkNB6qlcKFXgylZYuKp+WTFcbcDfw6L5ZqiRiA=";
   };
 
-  cargoHash = "sha256-5zhsWliwPPXq+KUKW0N1qyueg8BD+qmUqeKUrVl/vZ8=";
+  cargoHash = "sha256-1ZyAyJvHJtf8qEW7VmrZLL8WeVjD+w5vkVUld6keL+s=";
 
   nativeBuildInputs = [
     pkg-config

pkgs/development/tools/haskell/hadrian/disable-hyperlinked-source-extra-args.patch

···
+diff --git a/hadrian/src/Settings/Default.hs b/hadrian/src/Settings/Default.hs
+index 0b743788ec..a7ff841609 100644
+--- a/hadrian/src/Settings/Default.hs
++++ b/hadrian/src/Settings/Default.hs
+@@ -249,7 +249,7 @@ defaultExtraArgs =
+ 
+ defaultHaddockExtraArgs :: Args
+ defaultHaddockExtraArgs = builder (Haddock BuildPackage) ?
+-  mconcat [ arg "--hyperlinked-source", arg "--hoogle", arg "--quickjump" ]
++  mconcat [ arg "--hoogle", arg "--quickjump" ]
+ 
+ 
+ -- | Default source arguments, e.g. optimisation settings.

pkgs/kde/misc/kirigami-addons/default.nix

···
 }:
 mkKdeDerivation rec {
   pname = "kirigami-addons";
-  version = "1.5.0";
+  version = "1.6.0";
 
   src = fetchurl {
     url = "mirror://kde/stable/kirigami-addons/kirigami-addons-${version}.tar.xz";
-    hash = "sha256-+d/RkQIrYz6jNI+Ecw1xWKFZ3+SWaNugqem9Z4rETlQ=";
+    hash = "sha256-N22ub8WsrH0JBc6f7zIRvgcFxuLfUruA394eqiD+G/o=";
   };
 
   extraBuildInputs = [ qtdeclarative ];

pkgs/os-specific/linux/scx/scx_rustscheds.nix

···
 
   nativeBuildInputs = [
     pkg-config
-    llvmPackages.clang
+    rustPlatform.bindgenHook
   ];
   buildInputs = [
     elfutils
···
   ];
 
   env = {
-    LIBCLANG_PATH = "${lib.getLib llvmPackages.libclang}/lib";
     BPF_CLANG = lib.getExe llvmPackages.clang;
     BPF_EXTRA_CFLAGS_PRE_INCL = lib.concatStringsSep " " [
       "-I${scx.cscheds.dev}/libbpf/src/usr/include"

pkgs/servers/http/apache-httpd/2.4.nix

···
 , nixosTests
 , proxySupport ? true
 , sslSupport ? true, openssl
-, modTlsSupport ? false, rustls-ffi, Foundation
 , http2Support ? true, nghttp2
 , ldapSupport ? true, openldap
 , libxml2Support ? true, libxml2
···
   buildInputs = [ perl libxcrypt zlib ] ++
     lib.optional brotliSupport brotli ++
     lib.optional sslSupport openssl ++
-    lib.optional modTlsSupport rustls-ffi ++
-    lib.optional (modTlsSupport && stdenv.hostPlatform.isDarwin) Foundation ++
     lib.optional ldapSupport openldap ++    # there is no --with-ldap flag
     lib.optional libxml2Support libxml2 ++
     lib.optional http2Support nghttp2 ++
···
     "--includedir=${placeholder "dev"}/include"
     (lib.enableFeature proxySupport "proxy")
     (lib.enableFeature sslSupport "ssl")
-    (lib.enableFeature modTlsSupport "tls")
     (lib.withFeatureAs libxml2Support "libxml2" "${libxml2.dev}/include/libxml2")
     "--docdir=$(doc)/share/doc"
 

pkgs/servers/radicale/2.x.nix

···
-{ lib, fetchFromGitHub, python3 }:
-
-python3.pkgs.buildPythonApplication rec {
-  pname = "Radicale";
-  version = "2.1.12";
-
-  # No tests in PyPI tarball
-  src = fetchFromGitHub {
-    owner = "Kozea";
-    repo = "Radicale";
-    rev = version;
-    sha256 = "14f9ql0fiwapaa4xaslwgk1ah9fzxxan2p1p2rxb4a5iqph1z0cl";
-  };
-
-  # We only want functional tests
-  postPatch = ''
-    sed -i "s/pytest-cov\|pytest-flake8\|pytest-isort//g" setup.py
-    sed -i "/^addopts/d" setup.cfg
-  '';
-
-  propagatedBuildInputs = with python3.pkgs; [
-    vobject
-    python-dateutil
-    passlib
-    setuptools
-  ];
-
-  nativeCheckInputs = with python3.pkgs; [
-    pytestCheckHook
-  ];
-
-  disabledTests = [
-    # uses unsupported crypt method
-    "test_htpasswd_crypt"
-  ];
-
-  meta = with lib; {
-    homepage = "https://radicale.org/v2.html";
-    description = "CalDAV CardDAV server";
-    mainProgram = "radicale";
-    longDescription = ''
-      The Radicale Project is a complete CalDAV (calendar) and CardDAV
-      (contact) server solution. Calendars and address books are available for
-      both local and remote access, possibly limited through authentication
-      policies. They can be viewed and edited by calendar and contact clients
-      on mobile phones or computers.
-    '';
-    license = licenses.gpl3Plus;
-    maintainers = with maintainers; [ edwtjo pSub ];
-  };
-}

pkgs/servers/sql/postgresql/ext/default.nix

···
 
     pg_net = super.callPackage ./pg_net.nix { };
 
+    pg-gvm = super.callPackage ./pg-gvm.nix { };
+
     pg-semver = super.callPackage ./pg-semver.nix { };
 
     pgtap = super.callPackage ./pgtap.nix { };

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

···
 { lib, stdenv, fetchurl, writeText, plugins ? [ ], nixosTests }:
 
 let
-  version = "4.4.1";
+  version = "4.4.3";
 
   versionParts = lib.take 2 (lib.splitVersion version);
   # 4.2 -> 402, 3.11 -> 311
···
 
   src = fetchurl {
     url = "https://download.moodle.org/download.php/direct/stable${stableVersion}/${pname}-${version}.tgz";
-    hash = "sha256-+pzDrSMm+V4pEze13mJ/eyhaxcvnmG/eno0csCRTisU=";
+    hash = "sha256-SFysVBGGJKQFzm3pV25+wHaF7R1trqAOFQ1BLBTIzWk=";
   };
 
   phpConfig = writeText "config.php" ''

pkgs/tools/X11/opentabletdriver/default.nix pkgs/by-name/op/opentabletdriver/package.nix

···
-{ lib
-, buildDotnetModule
-, fetchFromGitHub
-, gtk3
-, libX11
-, libXrandr
-, libappindicator
-, libevdev
-, libnotify
-, udev
-, copyDesktopItems
-, makeDesktopItem
-, nixosTests
-, wrapGAppsHook3
-, jq
-, coreutils
-, dotnetCorePackages
+{
+  lib,
+  buildDotnetModule,
+  copyDesktopItems,
+  coreutils,
+  dotnetCorePackages,
+  fetchFromGitHub,
+  gtk3,
+  jq,
+  libappindicator,
+  libevdev,
+  libnotify,
+  libX11,
+  libXrandr,
+  makeDesktopItem,
+  nixosTests,
+  udev,
+  wrapGAppsHook3,
 }:
 
 buildDotnetModule rec {
   pname = "OpenTabletDriver";
-  version = "0.6.4.0";
+  version = "0.6.4.0-unstable-2024-11-25";
 
   src = fetchFromGitHub {
     owner = "OpenTabletDriver";
     repo = "OpenTabletDriver";
-    rev = "v${version}";
-    hash = "sha256-zK+feU96JOXjmkTndM9VyUid3z+MZFxJGH+MXaB6kzk=";
+    rev = "8b88b8bdc5144391f10eb61ee77803ba0ee83718"; # 0.6.x branch
+    hash = "sha256-5JKkSqV9owkHgWXfjiyv5QRh86apDCPzpA6qha1i4D4=";
   };
 
-  patches = [
-    ./remove-git-from-generate-rules.patch
-  ];
+  dotnetInstallFlags = [ "--framework=net8.0" ];
 
-  dotnetInstallFlags = [ "--framework=net6.0" ];
+  dotnet-sdk = dotnetCorePackages.sdk_8_0;
+  dotnet-runtime = dotnetCorePackages.runtime_8_0;
 
-  dotnet-sdk = dotnetCorePackages.sdk_6_0;
-  projectFile = [ "OpenTabletDriver.Console" "OpenTabletDriver.Daemon" "OpenTabletDriver.UX.Gtk" ];
+  projectFile = [
+    "OpenTabletDriver.Console"
+    "OpenTabletDriver.Daemon"
+    "OpenTabletDriver.UX.Gtk"
+  ];
   nugetDeps = ./deps.nix;
 
-  executables = [ "OpenTabletDriver.Console" "OpenTabletDriver.Daemon" "OpenTabletDriver.UX.Gtk" ];
+  executables = [
+    "OpenTabletDriver.Console"
+    "OpenTabletDriver.Daemon"
+    "OpenTabletDriver.UX.Gtk"
+  ];
 
   nativeBuildInputs = [
     copyDesktopItems
···
 
   runtimeDeps = [
     gtk3
-    libX11
-    libXrandr
     libappindicator
     libevdev
     libnotify
+    libX11
+    libXrandr
     udev
   ];
 
···
 
   preBuild = ''
     patchShebangs generate-rules.sh
+    substituteInPlace generate-rules.sh \
+      --replace-fail '/usr/bin/env rm' '${lib.getExe' coreutils "rm"}'
   '';
 
   postFixup = ''
···
 
     install -Dm644 $src/OpenTabletDriver.UX/Assets/otd.png -t $out/share/pixmaps
 
+    # Generate udev rules from source
+    export OTD_CONFIGURATIONS="$src/OpenTabletDriver.Configurations/Configurations"
     mkdir -p $out/lib/udev/rules.d
-    ./generate-rules.sh \
-      | sed 's@/usr/bin/env rm@${lib.getExe' coreutils "rm"}@' \
-      > $out/lib/udev/rules.d/70-opentabletdriver.rules
+    ./generate-rules.sh > $out/lib/udev/rules.d/70-opentabletdriver.rules
   '';
 
   desktopItems = [
···
       name = "OpenTabletDriver";
       exec = "otd-gui";
       icon = "otd";
-      comment = meta.description;
+      comment = "Open source, cross-platform, user-mode tablet driver";
       categories = [ "Utility" ];
     })
   ];
···
     };
   };
 
-  meta = with lib; {
+  meta = {
     description = "Open source, cross-platform, user-mode tablet driver";
     homepage = "https://github.com/OpenTabletDriver/OpenTabletDriver";
-    license = licenses.lgpl3Plus;
-    maintainers = with maintainers; [ gepbird thiagokokada ];
-    platforms = [ "x86_64-linux" "aarch64-linux" ];
+    license = lib.licenses.lgpl3Plus;
+    maintainers = with lib.maintainers; [
+      gepbird
+      thiagokokada
+    ];
+    platforms = [
+      "x86_64-linux"
+      "aarch64-linux"
+    ];
     mainProgram = "otd";
   };
 }

pkgs/tools/X11/opentabletdriver/deps.nix

···
-# This file was automatically generated by passthru.fetch-deps.
-# Please dont edit it manually, your changes might get overwritten!
-
-{ fetchNuGet }: [
-  (fetchNuGet { pname = "AtkSharp"; version = "3.24.24.34"; sha256 = "1jn1vgi9xm0jp7769k6sbdi8d273kigjrsh93i6s4c03hqxv7cqs"; })
-  (fetchNuGet { pname = "CairoSharp"; version = "3.24.24.34"; sha256 = "0pydn1k0cam1gclg9sc1sbnmbyzh28qlc5qanyxcylwghink3kgz"; })
-  (fetchNuGet { pname = "Castle.Core"; version = "4.4.0"; sha256 = "0rpcbmyhckvlvp6vbzpj03c1gqz56ixc6f15vgmxmyf1g40c24pf"; })
-  (fetchNuGet { pname = "coverlet.collector"; version = "3.0.2"; sha256 = "1xf6z6izmsl4g8w3z1wbp4pa8f8qsf6sil4mf1c9fb22hq8c5hkg"; })
-  (fetchNuGet { pname = "Eto.Forms"; version = "2.5.10"; sha256 = "1d71wglk4ixfqfbm6sxmj753x5iwbar8i9zzjy3bh64fy1dn8lz7"; })
-  (fetchNuGet { pname = "Eto.Forms"; version = "2.5.11"; sha256 = "0h86jc19wy3ssj7pb34w1h02v92mg29gdipszwjs3y15piy66z3s"; })
-  (fetchNuGet { pname = "Eto.Platform.Gtk"; version = "2.5.11"; sha256 = "1s9njz7l9zghrbzli7lbiav5ss3glqf17npj07f3jldd933nb95j"; })
-  (fetchNuGet { pname = "GdkSharp"; version = "3.24.24.34"; sha256 = "0r0x0yib7chwsyrbpvicrfwldwqx5lyqq4p86zaxpmzd6zdaj0x5"; })
-  (fetchNuGet { pname = "GioSharp"; version = "3.24.24.34"; sha256 = "02hxvgjd4w9jpzbkk7qf9q9bkvyp5hfzwxfqp10vg5lpl9yl3xpx"; })
-  (fetchNuGet { pname = "GLibSharp"; version = "3.24.24.34"; sha256 = "0kvp033fgdwc8p2abfp5z9pzq66cvwbnjfvr4v4bkpy5s5h181kq"; })
-  (fetchNuGet { pname = "GtkSharp"; version = "3.24.24.34"; sha256 = "0028hzmmqyfx87qqmaf9cgb5psn7gkbmqvixcid67x1d6mzxjicb"; })
-  (fetchNuGet { pname = "HidSharpCore"; version = "1.2.1.1"; sha256 = "1zkndglmz0s8rblfhnqcvv90rkq2i7lf4bc380g7z8h1avf2ikll"; })
-  (fetchNuGet { pname = "MessagePack"; version = "2.1.194"; sha256 = "1v2gyd9sd6hppfhlzngmzzhnpr39b95rwrqq0r9zzp480b6vzaj0"; })
-  (fetchNuGet { pname = "MessagePack.Annotations"; version = "2.1.194"; sha256 = "1jkhq3hiy4brvzsywl4p4jb9jrnzs3vmgr3s8fxpb1dzafadw8b0"; })
-  (fetchNuGet { pname = "Microsoft.Bcl.AsyncInterfaces"; version = "1.1.1"; sha256 = "0a1ahssqds2ympr7s4xcxv5y8jgxs7ahd6ah6fbgglj4rki1f1vw"; })
-  (fetchNuGet { pname = "Microsoft.CodeCoverage"; version = "16.9.4"; sha256 = "11wiyy3ykgk1sa9amy3lgcsg2v7d1sz59ggw647vx8ibpjxijjpp"; })
-  (fetchNuGet { pname = "Microsoft.CSharp"; version = "4.0.1"; sha256 = "0zxc0apx1gcx361jlq8smc9pfdgmyjh6hpka8dypc9w23nlsh6yj"; })
-  (fetchNuGet { pname = "Microsoft.Extensions.DependencyInjection"; version = "6.0.0-rc.1.21451.13"; sha256 = "0r6945jq7c2f1wjifq514zvngicndjqfnsjya6hqw0yzah0jr56c"; })
-  (fetchNuGet { pname = "Microsoft.Extensions.DependencyInjection.Abstractions"; version = "6.0.0-rc.1.21451.13"; sha256 = "11dg16x6g0gssb143qpghxz1s41himvhr7yhjwxs9hacx4ij2dm1"; })
-  (fetchNuGet { pname = "Microsoft.NET.Test.Sdk"; version = "16.9.4"; sha256 = "1jdx05zmrqj1s7xfgn3wgy10qb5cl1n1jcj5kz43zvkw1amc7ra4"; })
-  (fetchNuGet { pname = "Microsoft.NETCore.Platforms"; version = "1.0.1"; sha256 = "01al6cfxp68dscl15z7rxfw9zvhm64dncsw09a1vmdkacsa2v6lr"; })
-  (fetchNuGet { pname = "Microsoft.NETCore.Platforms"; version = "1.1.0"; sha256 = "08vh1r12g6ykjygq5d3vq09zylgb84l63k49jc4v8faw9g93iqqm"; })
-  (fetchNuGet { pname = "Microsoft.NETCore.Platforms"; version = "1.1.1"; sha256 = "164wycgng4mi9zqi2pnsf1pq6gccbqvw6ib916mqizgjmd8f44pj"; })
-  (fetchNuGet { pname = "Microsoft.NETCore.Platforms"; version = "3.0.0"; sha256 = "1bk8r4r3ihmi6322jmcag14jmw11mjqys202azqjzglcx59pxh51"; })
-  (fetchNuGet { pname = "Microsoft.NETCore.Targets"; version = "1.0.1"; sha256 = "0ppdkwy6s9p7x9jix3v4402wb171cdiibq7js7i13nxpdky7074p"; })
-  (fetchNuGet { pname = "Microsoft.NETCore.Targets"; version = "1.1.0"; sha256 = "193xwf33fbm0ni3idxzbr5fdq3i2dlfgihsac9jj7whj0gd902nh"; })
-  (fetchNuGet { pname = "Microsoft.TestPlatform.ObjectModel"; version = "16.9.4"; sha256 = "1jizkbrnm4pv60zch29ki7gj8m7j5whk141x9cwx4kwsd6cfzwi6"; })
-  (fetchNuGet { pname = "Microsoft.TestPlatform.TestHost"; version = "16.9.4"; sha256 = "14110qzmypr72ywvx3npq7mf4n0gvdr4536v91z1xbapms65am6x"; })
-  (fetchNuGet { pname = "Microsoft.VisualStudio.Threading"; version = "16.7.56"; sha256 = "13x0xrsjxd86clf9cjjwmpzlyp8pkrf13riya7igs8zy93zw2qap"; })
-  (fetchNuGet { pname = "Microsoft.VisualStudio.Threading.Analyzers"; version = "16.7.56"; sha256 = "04v9df0k7bsc0rzgkw4mnvi43pdrh42vk6xdcwn9m6im33m0nnz2"; })
-  (fetchNuGet { pname = "Microsoft.VisualStudio.Validation"; version = "15.5.31"; sha256 = "1ah99rn922qa0sd2k3h64m324f2r32pw8cn4cfihgvwx4qdrpmgw"; })
-  (fetchNuGet { pname = "Microsoft.Win32.Primitives"; version = "4.3.0"; sha256 = "0j0c1wj4ndj21zsgivsc24whiya605603kxrbiw6wkfdync464wq"; })
-  (fetchNuGet { pname = "Microsoft.Win32.Registry"; version = "4.6.0"; sha256 = "0i4y782yrqqyx85pg597m20gm0v126w0j9ddk5z7xb3crx4z9f2s"; })
-  (fetchNuGet { pname = "Moq"; version = "4.16.1"; sha256 = "1m2gwbx0gsy84rl9c3hgdaw9gz8d08ffg19nwg0idsdqmmiq887l"; })
-  (fetchNuGet { pname = "Nerdbank.Streams"; version = "2.6.77"; sha256 = "13dnfwxa8syx7vfjmd5pcrqz31k0q8y3mmh6yz6bmljhjri65q5c"; })
-  (fetchNuGet { pname = "NETStandard.Library"; version = "1.6.1"; sha256 = "1z70wvsx2d847a2cjfii7b83pjfs34q05gb037fdjikv5kbagml8"; })
-  (fetchNuGet { pname = "Newtonsoft.Json"; version = "12.0.2"; sha256 = "0w2fbji1smd2y7x25qqibf1qrznmv4s6s0jvrbvr6alb7mfyqvh5"; })
-  (fetchNuGet { pname = "Newtonsoft.Json"; version = "13.0.1"; sha256 = "0fijg0w6iwap8gvzyjnndds0q4b8anwxxvik7y8vgq97dram4srb"; })
-  (fetchNuGet { pname = "Newtonsoft.Json"; version = "13.0.3"; sha256 = "0xrwysmrn4midrjal8g2hr1bbg38iyisl0svamb11arqws4w2bw7"; })
-  (fetchNuGet { pname = "Newtonsoft.Json"; version = "9.0.1"; sha256 = "0mcy0i7pnfpqm4pcaiyzzji4g0c8i3a5gjz28rrr28110np8304r"; })
-  (fetchNuGet { pname = "Newtonsoft.Json.Schema"; version = "3.0.15"; sha256 = "1nmc9zxpcyyf3f2ypxw6vnjwlw5sxjv13r65p2dy8xrx8jkgaslp"; })
-  (fetchNuGet { pname = "NuGet.Frameworks"; version = "5.0.0"; sha256 = "18ijvmj13cwjdrrm52c8fpq021531zaz4mj4b4zapxaqzzxf2qjr"; })
-  (fetchNuGet { pname = "Octokit"; version = "0.50.0"; sha256 = "1ignj5i6a1c19qqrw00wlr9fdjmwrxkxz7gdxj0x653w84gbv7qq"; })
-  (fetchNuGet { pname = "PangoSharp"; version = "3.24.24.34"; sha256 = "1r0h14cklglfpv1lhv93cxmzi2w7d5s03gzpq3j5dmrz43flg9zw"; })
-  (fetchNuGet { pname = "runtime.any.System.Collections"; version = "4.3.0"; sha256 = "0bv5qgm6vr47ynxqbnkc7i797fdi8gbjjxii173syrx14nmrkwg0"; })
-  (fetchNuGet { pname = "runtime.any.System.Diagnostics.Tools"; version = "4.3.0"; sha256 = "1wl76vk12zhdh66vmagni66h5xbhgqq7zkdpgw21jhxhvlbcl8pk"; })
-  (fetchNuGet { pname = "runtime.any.System.Diagnostics.Tracing"; version = "4.3.0"; sha256 = "00j6nv2xgmd3bi347k00m7wr542wjlig53rmj28pmw7ddcn97jbn"; })
-  (fetchNuGet { pname = "runtime.any.System.Globalization"; version = "4.3.0"; sha256 = "1daqf33hssad94lamzg01y49xwndy2q97i2lrb7mgn28656qia1x"; })
-  (fetchNuGet { pname = "runtime.any.System.Globalization.Calendars"; version = "4.3.0"; sha256 = "1ghhhk5psqxcg6w88sxkqrc35bxcz27zbqm2y5p5298pv3v7g201"; })
-  (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.Text.Encoding.Extensions"; version = "4.3.0"; sha256 = "0lqhgqi0i8194ryqq6v2gqx0fb86db2gqknbm0aq31wb378j7ip8"; })
-  (fetchNuGet { pname = "runtime.any.System.Threading.Tasks"; version = "4.3.0"; sha256 = "03mnvkhskbzxddz4hm113zsch1jyzh2cs450dk3rgfjp8crlw1va"; })
-  (fetchNuGet { pname = "runtime.any.System.Threading.Timer"; version = "4.3.0"; sha256 = "0aw4phrhwqz9m61r79vyfl5la64bjxj8l34qnrcwb28v49fg2086"; })
-  (fetchNuGet { pname = "runtime.debian.8-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "16rnxzpk5dpbbl1x354yrlsbvwylrq456xzpsha1n9y3glnhyx9d"; })
-  (fetchNuGet { pname = "runtime.debian.8-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.2"; sha256 = "0rwpqngkqiapqc5c2cpkj7idhngrgss5qpnqg0yh40mbyflcxf8i"; })
-  (fetchNuGet { pname = "runtime.fedora.23-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "0hkg03sgm2wyq8nqk6dbm9jh5vcq57ry42lkqdmfklrw89lsmr59"; })
-  (fetchNuGet { pname = "runtime.fedora.23-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.2"; sha256 = "1n06gxwlinhs0w7s8a94r1q3lwqzvynxwd3mp10ws9bg6gck8n4r"; })
-  (fetchNuGet { pname = "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "0c2p354hjx58xhhz7wv6div8xpi90sc6ibdm40qin21bvi7ymcaa"; })
-  (fetchNuGet { pname = "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.2"; sha256 = "0404wqrc7f2yc0wxv71y3nnybvqx8v4j9d47hlscxy759a525mc3"; })
-  (fetchNuGet { pname = "runtime.native.System"; version = "4.3.0"; sha256 = "15hgf6zaq9b8br2wi1i3x0zvmk410nlmsmva9p0bbg73v6hml5k4"; })
-  (fetchNuGet { pname = "runtime.native.System.IO.Compression"; version = "4.3.0"; sha256 = "1vvivbqsk6y4hzcid27pqpm5bsi6sc50hvqwbcx8aap5ifrxfs8d"; })
-  (fetchNuGet { pname = "runtime.native.System.Net.Http"; version = "4.3.0"; sha256 = "1n6rgz5132lcibbch1qlf0g9jk60r0kqv087hxc0lisy50zpm7kk"; })
-  (fetchNuGet { pname = "runtime.native.System.Security.Cryptography.Apple"; version = "4.3.0"; sha256 = "1b61p6gw1m02cc1ry996fl49liiwky6181dzr873g9ds92zl326q"; })
-  (fetchNuGet { pname = "runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "18pzfdlwsg2nb1jjjjzyb5qlgy6xjxzmhnfaijq5s2jw3cm3ab97"; })
-  (fetchNuGet { pname = "runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.2"; sha256 = "0zy5r25jppz48i2bkg8b9lfig24xixg6nm3xyr1379zdnqnpm8f6"; })
-  (fetchNuGet { pname = "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "0qyynf9nz5i7pc26cwhgi8j62ps27sqmf78ijcfgzab50z9g8ay3"; })
-  (fetchNuGet { pname = "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.2"; sha256 = "096ch4n4s8k82xga80lfmpimpzahd2ip1mgwdqgar0ywbbl6x438"; })
-  (fetchNuGet { pname = "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "1klrs545awhayryma6l7g2pvnp9xy4z0r1i40r80zb45q3i9nbyf"; })
-  (fetchNuGet { pname = "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.2"; sha256 = "1dm8fifl7rf1gy7lnwln78ch4rw54g0pl5g1c189vawavll7p6rj"; })
-  (fetchNuGet { pname = "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.Apple"; version = "4.3.0"; sha256 = "10yc8jdrwgcl44b4g93f1ds76b176bajd3zqi2faf5rvh1vy9smi"; })
-  (fetchNuGet { pname = "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "0zcxjv5pckplvkg0r6mw3asggm7aqzbdjimhvsasb0cgm59x09l3"; })
-  (fetchNuGet { pname = "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.2"; sha256 = "1m9z1k9kzva9n9kwinqxl97x2vgl79qhqjlv17k9s2ymcyv2bwr6"; })
-  (fetchNuGet { pname = "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "0vhynn79ih7hw7cwjazn87rm9z9fj0rvxgzlab36jybgcpcgphsn"; })
-  (fetchNuGet { pname = "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.2"; sha256 = "1cpx56mcfxz7cpn57wvj18sjisvzq8b5vd9rw16ihd2i6mcp3wa1"; })
-  (fetchNuGet { pname = "runtime.ubuntu.14.04-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "160p68l2c7cqmyqjwxydcvgw7lvl1cr0znkw8fp24d1by9mqc8p3"; })
-  (fetchNuGet { pname = "runtime.ubuntu.14.04-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.2"; sha256 = "15gsm1a8jdmgmf8j5v1slfz8ks124nfdhk2vxs2rw3asrxalg8hi"; })
-  (fetchNuGet { pname = "runtime.ubuntu.16.04-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "15zrc8fgd8zx28hdghcj5f5i34wf3l6bq5177075m2bc2j34jrqy"; })
-  (fetchNuGet { pname = "runtime.ubuntu.16.04-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.2"; sha256 = "0q0n5q1r1wnqmr5i5idsrd9ywl33k0js4pngkwq9p368mbxp8x1w"; })
-  (fetchNuGet { pname = "runtime.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "1p4dgxax6p7rlgj4q73k73rslcnz4wdcv8q2flg1s8ygwcm58ld5"; })
-  (fetchNuGet { pname = "runtime.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography.OpenSsl"; version = "4.3.2"; sha256 = "1x0g58pbpjrmj2x2qw17rdwwnrcl0wvim2hdwz48lixvwvp22n9c"; })
-  (fetchNuGet { pname = "runtime.unix.Microsoft.Win32.Primitives"; version = "4.3.0"; sha256 = "0y61k9zbxhdi0glg154v30kkq7f8646nif8lnnxbvkjpakggd5id"; })
-  (fetchNuGet { pname = "runtime.unix.System.Console"; version = "4.3.0"; sha256 = "1pfpkvc6x2if8zbdzg9rnc5fx51yllprl8zkm5npni2k50lisy80"; })
-  (fetchNuGet { pname = "runtime.unix.System.Diagnostics.Debug"; version = "4.3.0"; sha256 = "1lps7fbnw34bnh3lm31gs5c0g0dh7548wfmb8zz62v0zqz71msj5"; })
-  (fetchNuGet { pname = "runtime.unix.System.IO.FileSystem"; version = "4.3.0"; sha256 = "14nbkhvs7sji5r1saj2x8daz82rnf9kx28d3v2qss34qbr32dzix"; })
-  (fetchNuGet { pname = "runtime.unix.System.Net.Primitives"; version = "4.3.0"; sha256 = "0bdnglg59pzx9394sy4ic66kmxhqp8q8bvmykdxcbs5mm0ipwwm4"; })
-  (fetchNuGet { pname = "runtime.unix.System.Net.Sockets"; version = "4.3.0"; sha256 = "03npdxzy8gfv035bv1b9rz7c7hv0rxl5904wjz51if491mw0xy12"; })
-  (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 = "SharpZipLib"; version = "1.3.3"; sha256 = "1gij11wfj1mqm10631cjpnhzw882bnzx699jzwhdqakxm1610q8x"; })
-  (fetchNuGet { pname = "StreamJsonRpc"; version = "2.6.121"; sha256 = "0xzvpk17w2skndzdg47j7gkrrvw6521db4mv8lc3v8hm97vs9m76"; })
-  (fetchNuGet { pname = "System.AppContext"; version = "4.3.0"; sha256 = "1649qvy3dar900z3g817h17nl8jp4ka5vcfmsr05kh0fshn7j3ya"; })
-  (fetchNuGet { pname = "System.Buffers"; version = "4.3.0"; sha256 = "0fgns20ispwrfqll4q1zc1waqcmylb3zc50ys9x8zlwxh9pmd9jy"; })
-  (fetchNuGet { pname = "System.Collections"; version = "4.0.11"; sha256 = "1ga40f5lrwldiyw6vy67d0sg7jd7ww6kgwbksm19wrvq9hr0bsm6"; })
-  (fetchNuGet { pname = "System.Collections"; version = "4.3.0"; sha256 = "19r4y64dqyrq6k4706dnyhhw7fs24kpp3awak7whzss39dakpxk9"; })
-  (fetchNuGet { pname = "System.Collections.Concurrent"; version = "4.3.0"; sha256 = "0wi10md9aq33jrkh2c24wr2n9hrpyamsdhsxdcnf43b7y86kkii8"; })
-  (fetchNuGet { pname = "System.Collections.Immutable"; version = "1.7.1"; sha256 = "1nh4nlxfc7lbnbl86wwk1a3jwl6myz5j6hvgh5sp4krim9901hsq"; })
-  (fetchNuGet { pname = "System.Collections.NonGeneric"; version = "4.3.0"; sha256 = "07q3k0hf3mrcjzwj8fwk6gv3n51cb513w4mgkfxzm3i37sc9kz7k"; })
-  (fetchNuGet { pname = "System.Collections.Specialized"; version = "4.3.0"; sha256 = "1sdwkma4f6j85m3dpb53v9vcgd0zyc9jb33f8g63byvijcj39n20"; })
-  (fetchNuGet { pname = "System.CommandLine"; version = "2.0.0-beta4.22272.1"; sha256 = "1iy5hwwgvx911g3yq65p4zsgpy08w4qz9j3h0igcf7yci44vw8yd"; })
-  (fetchNuGet { pname = "System.ComponentModel"; version = "4.3.0"; sha256 = "0986b10ww3nshy30x9sjyzm0jx339dkjxjj3401r3q0f6fx2wkcb"; })
-  (fetchNuGet { pname = "System.ComponentModel.Annotations"; version = "4.7.0"; sha256 = "06x1m46ddxj0ng28d7gry9gjkqdg2kp89jyf480g5gznyybbs49z"; })
-  (fetchNuGet { pname = "System.ComponentModel.Annotations"; version = "5.0.0"; sha256 = "021h7x98lblq9avm1bgpa4i31c2kgsa7zn4sqhxf39g087ar756j"; })
-  (fetchNuGet { pname = "System.ComponentModel.Primitives"; version = "4.3.0"; sha256 = "1svfmcmgs0w0z9xdw2f2ps05rdxmkxxhf0l17xk9l1l8xfahkqr0"; })
-  (fetchNuGet { pname = "System.ComponentModel.TypeConverter"; version = "4.3.0"; sha256 = "17ng0p7v3nbrg3kycz10aqrrlw4lz9hzhws09pfh8gkwicyy481x"; })
-  (fetchNuGet { pname = "System.Console"; version = "4.3.0"; sha256 = "1flr7a9x920mr5cjsqmsy9wgnv3lvd0h1g521pdr1lkb2qycy7ay"; })
-  (fetchNuGet { pname = "System.Diagnostics.Debug"; version = "4.0.11"; sha256 = "0gmjghrqmlgzxivd2xl50ncbglb7ljzb66rlx8ws6dv8jm0d5siz"; })
-  (fetchNuGet { pname = "System.Diagnostics.Debug"; version = "4.3.0"; sha256 = "00yjlf19wjydyr6cfviaph3vsjzg3d5nvnya26i2fvfg53sknh3y"; })
-  (fetchNuGet { pname = "System.Diagnostics.DiagnosticSource"; version = "4.3.0"; sha256 = "0z6m3pbiy0qw6rn3n209rrzf9x1k4002zh90vwcrsym09ipm2liq"; })
-  (fetchNuGet { pname = "System.Diagnostics.Tools"; version = "4.0.1"; sha256 = "19cknvg07yhakcvpxg3cxa0bwadplin6kyxd8mpjjpwnp56nl85x"; })
-  (fetchNuGet { pname = "System.Diagnostics.Tools"; version = "4.3.0"; sha256 = "0in3pic3s2ddyibi8cvgl102zmvp9r9mchh82ns9f0ms4basylw1"; })
-  (fetchNuGet { pname = "System.Diagnostics.TraceSource"; version = "4.3.0"; sha256 = "1kyw4d7dpjczhw6634nrmg7yyyzq72k75x38y0l0nwhigdlp1766"; })
-  (fetchNuGet { pname = "System.Diagnostics.Tracing"; version = "4.3.0"; sha256 = "1m3bx6c2s958qligl67q7grkwfz3w53hpy7nc97mh6f7j5k168c4"; })
-  (fetchNuGet { pname = "System.Dynamic.Runtime"; version = "4.0.11"; sha256 = "1pla2dx8gkidf7xkciig6nifdsb494axjvzvann8g2lp3dbqasm9"; })
-  (fetchNuGet { pname = "System.Dynamic.Runtime"; version = "4.3.0"; sha256 = "1d951hrvrpndk7insiag80qxjbf2y0y39y8h5hnq9612ws661glk"; })
-  (fetchNuGet { pname = "System.Globalization"; version = "4.0.11"; sha256 = "070c5jbas2v7smm660zaf1gh0489xanjqymkvafcs4f8cdrs1d5d"; })
-  (fetchNuGet { pname = "System.Globalization"; version = "4.3.0"; sha256 = "1cp68vv683n6ic2zqh2s1fn4c2sd87g5hpp6l4d4nj4536jz98ki"; })
-  (fetchNuGet { pname = "System.Globalization.Calendars"; version = "4.3.0"; sha256 = "1xwl230bkakzzkrggy1l1lxmm3xlhk4bq2pkv790j5lm8g887lxq"; })
-  (fetchNuGet { pname = "System.Globalization.Extensions"; version = "4.3.0"; sha256 = "02a5zfxavhv3jd437bsncbhd2fp1zv4gxzakp1an9l6kdq1mcqls"; })
-  (fetchNuGet { pname = "System.IO"; version = "4.1.0"; sha256 = "1g0yb8p11vfd0kbkyzlfsbsp5z44lwsvyc0h3dpw6vqnbi035ajp"; })
-  (fetchNuGet { pname = "System.IO"; version = "4.3.0"; sha256 = "05l9qdrzhm4s5dixmx68kxwif4l99ll5gqmh7rqgw554fx0agv5f"; })
-  (fetchNuGet { pname = "System.IO.Compression"; version = "4.3.0"; sha256 = "084zc82yi6yllgda0zkgl2ys48sypiswbiwrv7irb3r0ai1fp4vz"; })
-  (fetchNuGet { pname = "System.IO.Compression.ZipFile"; version = "4.3.0"; sha256 = "1yxy5pq4dnsm9hlkg9ysh5f6bf3fahqqb6p8668ndy5c0lk7w2ar"; })
-  (fetchNuGet { pname = "System.IO.FileSystem"; version = "4.0.1"; sha256 = "0kgfpw6w4djqra3w5crrg8xivbanh1w9dh3qapb28q060wb9flp1"; })
-  (fetchNuGet { pname = "System.IO.FileSystem"; version = "4.3.0"; sha256 = "0z2dfrbra9i6y16mm9v1v6k47f0fm617vlb7s5iybjjsz6g1ilmw"; })
-  (fetchNuGet { pname = "System.IO.FileSystem.Primitives"; version = "4.0.1"; sha256 = "1s0mniajj3lvbyf7vfb5shp4ink5yibsx945k6lvxa96r8la1612"; })
-  (fetchNuGet { pname = "System.IO.FileSystem.Primitives"; version = "4.3.0"; sha256 = "0j6ndgglcf4brg2lz4wzsh1av1gh8xrzdsn9f0yznskhqn1xzj9c"; })
-  (fetchNuGet { pname = "System.IO.Pipelines"; version = "4.7.2"; sha256 = "16v4qaypm72cfsfqr8z3k6yrpzn0m3apgkh6aljfwpycdk150sf9"; })
-  (fetchNuGet { pname = "System.Linq"; version = "4.1.0"; sha256 = "1ppg83svb39hj4hpp5k7kcryzrf3sfnm08vxd5sm2drrijsla2k5"; })
-  (fetchNuGet { pname = "System.Linq"; version = "4.3.0"; sha256 = "1w0gmba695rbr80l1k2h4mrwzbzsyfl2z4klmpbsvsg5pm4a56s7"; })
-  (fetchNuGet { pname = "System.Linq.Expressions"; version = "4.1.0"; sha256 = "1gpdxl6ip06cnab7n3zlcg6mqp7kknf73s8wjinzi4p0apw82fpg"; })
-  (fetchNuGet { pname = "System.Linq.Expressions"; version = "4.3.0"; sha256 = "0ky2nrcvh70rqq88m9a5yqabsl4fyd17bpr63iy2mbivjs2nyypv"; })
-  (fetchNuGet { pname = "System.Memory"; version = "4.5.4"; sha256 = "14gbbs22mcxwggn0fcfs1b062521azb9fbb7c113x0mq6dzq9h6y"; })
-  (fetchNuGet { pname = "System.Net.Http"; version = "4.3.0"; sha256 = "1i4gc757xqrzflbk7kc5ksn20kwwfjhw9w7pgdkn19y3cgnl302j"; })
-  (fetchNuGet { pname = "System.Net.Http"; version = "4.3.4"; sha256 = "0kdp31b8819v88l719j6my0yas6myv9d1viql3qz5577mv819jhl"; })
-  (fetchNuGet { pname = "System.Net.NameResolution"; version = "4.3.0"; sha256 = "15r75pwc0rm3vvwsn8rvm2krf929mjfwliv0mpicjnii24470rkq"; })
-  (fetchNuGet { pname = "System.Net.Primitives"; version = "4.3.0"; sha256 = "0c87k50rmdgmxx7df2khd9qj7q35j9rzdmm2572cc55dygmdk3ii"; })
-  (fetchNuGet { pname = "System.Net.Sockets"; version = "4.3.0"; sha256 = "1ssa65k6chcgi6mfmzrznvqaxk8jp0gvl77xhf1hbzakjnpxspla"; })
-  (fetchNuGet { pname = "System.Net.WebSockets"; version = "4.3.0"; sha256 = "1gfj800078kggcgl0xyl00a6y5k4wwh2k2qm69rjy22wbmq7fy4p"; })
-  (fetchNuGet { pname = "System.ObjectModel"; version = "4.0.12"; sha256 = "1sybkfi60a4588xn34nd9a58png36i0xr4y4v4kqpg8wlvy5krrj"; })
-  (fetchNuGet { pname = "System.ObjectModel"; version = "4.3.0"; sha256 = "191p63zy5rpqx7dnrb3h7prvgixmk168fhvvkkvhlazncf8r3nc2"; })
-  (fetchNuGet { pname = "System.Private.Uri"; version = "4.3.0"; sha256 = "04r1lkdnsznin0fj4ya1zikxiqr0h6r6a1ww2dsm60gqhdrf0mvx"; })
-  (fetchNuGet { pname = "System.Reflection"; version = "4.1.0"; sha256 = "1js89429pfw79mxvbzp8p3q93il6rdff332hddhzi5wqglc4gml9"; })
-  (fetchNuGet { pname = "System.Reflection"; version = "4.3.0"; sha256 = "0xl55k0mw8cd8ra6dxzh974nxif58s3k1rjv1vbd7gjbjr39j11m"; })
-  (fetchNuGet { pname = "System.Reflection.Emit"; version = "4.0.1"; sha256 = "0ydqcsvh6smi41gyaakglnv252625hf29f7kywy2c70nhii2ylqp"; })
-  (fetchNuGet { pname = "System.Reflection.Emit"; version = "4.3.0"; sha256 = "11f8y3qfysfcrscjpjym9msk7lsfxkk4fmz9qq95kn3jd0769f74"; })
-  (fetchNuGet { pname = "System.Reflection.Emit"; version = "4.7.0"; sha256 = "121l1z2ypwg02yz84dy6gr82phpys0njk7yask3sihgy214w43qp"; })
-  (fetchNuGet { pname = "System.Reflection.Emit.ILGeneration"; version = "4.0.1"; sha256 = "1pcd2ig6bg144y10w7yxgc9d22r7c7ww7qn1frdfwgxr24j9wvv0"; })
-  (fetchNuGet { pname = "System.Reflection.Emit.ILGeneration"; version = "4.3.0"; sha256 = "0w1n67glpv8241vnpz1kl14sy7zlnw414aqwj4hcx5nd86f6994q"; })
-  (fetchNuGet { pname = "System.Reflection.Emit.Lightweight"; version = "4.0.1"; sha256 = "1s4b043zdbx9k39lfhvsk68msv1nxbidhkq6nbm27q7sf8xcsnxr"; })
-  (fetchNuGet { pname = "System.Reflection.Emit.Lightweight"; version = "4.3.0"; sha256 = "0ql7lcakycrvzgi9kxz1b3lljd990az1x6c4jsiwcacrvimpib5c"; })
-  (fetchNuGet { pname = "System.Reflection.Emit.Lightweight"; version = "4.6.0"; sha256 = "0hry2k6b7kicg4zxnq0hhn0ys52711pxy7l9v5sp7gvp9cicwpgp"; })
-  (fetchNuGet { pname = "System.Reflection.Extensions"; version = "4.0.1"; sha256 = "0m7wqwq0zqq9gbpiqvgk3sr92cbrw7cp3xn53xvw7zj6rz6fdirn"; })
-  (fetchNuGet { pname = "System.Reflection.Extensions"; version = "4.3.0"; sha256 = "02bly8bdc98gs22lqsfx9xicblszr2yan7v2mmw3g7hy6miq5hwq"; })
-  (fetchNuGet { pname = "System.Reflection.Metadata"; version = "1.6.0"; sha256 = "1wdbavrrkajy7qbdblpbpbalbdl48q3h34cchz24gvdgyrlf15r4"; })
-  (fetchNuGet { pname = "System.Reflection.Primitives"; version = "4.0.1"; sha256 = "1bangaabhsl4k9fg8khn83wm6yial8ik1sza7401621jc6jrym28"; })
-  (fetchNuGet { pname = "System.Reflection.Primitives"; version = "4.3.0"; sha256 = "04xqa33bld78yv5r93a8n76shvc8wwcdgr1qvvjh959g3rc31276"; })
-  (fetchNuGet { pname = "System.Reflection.TypeExtensions"; version = "4.1.0"; sha256 = "1bjli8a7sc7jlxqgcagl9nh8axzfl11f4ld3rjqsyxc516iijij7"; })
-  (fetchNuGet { pname = "System.Reflection.TypeExtensions"; version = "4.3.0"; sha256 = "0y2ssg08d817p0vdag98vn238gyrrynjdj4181hdg780sif3ykp1"; })
-  (fetchNuGet { pname = "System.Resources.ResourceManager"; version = "4.0.1"; sha256 = "0b4i7mncaf8cnai85jv3wnw6hps140cxz8vylv2bik6wyzgvz7bi"; })
-  (fetchNuGet { pname = "System.Resources.ResourceManager"; version = "4.3.0"; sha256 = "0sjqlzsryb0mg4y4xzf35xi523s4is4hz9q4qgdvlvgivl7qxn49"; })
-  (fetchNuGet { pname = "System.Runtime"; version = "4.1.0"; sha256 = "02hdkgk13rvsd6r9yafbwzss8kr55wnj8d5c7xjnp8gqrwc8sn0m"; })
-  (fetchNuGet { pname = "System.Runtime"; version = "4.3.0"; sha256 = "066ixvgbf2c929kgknshcxqj6539ax7b9m570cp8n179cpfkapz7"; })
-  (fetchNuGet { pname = "System.Runtime.CompilerServices.Unsafe"; version = "4.5.2"; sha256 = "1vz4275fjij8inf31np78hw50al8nqkngk04p3xv5n4fcmf1grgi"; })
-  (fetchNuGet { pname = "System.Runtime.CompilerServices.Unsafe"; version = "4.7.1"; sha256 = "119br3pd85lq8zcgh4f60jzmv1g976q1kdgi3hvqdlhfbw6siz2j"; })
-  (fetchNuGet { pname = "System.Runtime.CompilerServices.Unsafe"; version = "6.0.0-rc.1.21451.13"; sha256 = "0v5bc80p35jj5b5xdgsn5r1v4w68gqz0sahi214rprrrlr3sl206"; })
-  (fetchNuGet { pname = "System.Runtime.Extensions"; version = "4.1.0"; sha256 = "0rw4rm4vsm3h3szxp9iijc3ksyviwsv6f63dng3vhqyg4vjdkc2z"; })
-  (fetchNuGet { pname = "System.Runtime.Extensions"; version = "4.3.0"; sha256 = "1ykp3dnhwvm48nap8q23893hagf665k0kn3cbgsqpwzbijdcgc60"; })
-  (fetchNuGet { pname = "System.Runtime.Handles"; version = "4.0.1"; sha256 = "1g0zrdi5508v49pfm3iii2hn6nm00bgvfpjq1zxknfjrxxa20r4g"; })
-  (fetchNuGet { pname = "System.Runtime.Handles"; version = "4.3.0"; sha256 = "0sw2gfj2xr7sw9qjn0j3l9yw07x73lcs97p8xfc9w1x9h5g5m7i8"; })
-  (fetchNuGet { pname = "System.Runtime.InteropServices"; version = "4.1.0"; sha256 = "01kxqppx3dr3b6b286xafqilv4s2n0gqvfgzfd4z943ga9i81is1"; })
-  (fetchNuGet { pname = "System.Runtime.InteropServices"; version = "4.3.0"; sha256 = "00hywrn4g7hva1b2qri2s6rabzwgxnbpw9zfxmz28z09cpwwgh7j"; })
-  (fetchNuGet { pname = "System.Runtime.InteropServices.RuntimeInformation"; version = "4.3.0"; sha256 = "0q18r1sh4vn7bvqgd6dmqlw5v28flbpj349mkdish2vjyvmnb2ii"; })
-  (fetchNuGet { pname = "System.Runtime.Numerics"; version = "4.3.0"; sha256 = "19rav39sr5dky7afygh309qamqqmi9kcwvz3i0c5700v0c5cg61z"; })
-  (fetchNuGet { pname = "System.Runtime.Serialization.Primitives"; version = "4.1.1"; sha256 = "042rfjixknlr6r10vx2pgf56yming8lkjikamg3g4v29ikk78h7k"; })
-  (fetchNuGet { pname = "System.Security.AccessControl"; version = "4.6.0"; sha256 = "1wl1dyghi0qhpap1vgfhg2ybdyyhy9vc2a7dpm1xb30vfgmlkjmf"; })
-  (fetchNuGet { pname = "System.Security.Claims"; version = "4.3.0"; sha256 = "0jvfn7j22l3mm28qjy3rcw287y9h65ha4m940waaxah07jnbzrhn"; })
-  (fetchNuGet { pname = "System.Security.Cryptography.Algorithms"; version = "4.3.0"; sha256 = "03sq183pfl5kp7gkvq77myv7kbpdnq3y0xj7vi4q1kaw54sny0ml"; })
-  (fetchNuGet { pname = "System.Security.Cryptography.Cng"; version = "4.3.0"; sha256 = "1k468aswafdgf56ab6yrn7649kfqx2wm9aslywjam1hdmk5yypmv"; })
-  (fetchNuGet { pname = "System.Security.Cryptography.Csp"; version = "4.3.0"; sha256 = "1x5wcrddf2s3hb8j78cry7yalca4lb5vfnkrysagbn6r9x6xvrx1"; })
-  (fetchNuGet { pname = "System.Security.Cryptography.Encoding"; version = "4.3.0"; sha256 = "1jr6w70igqn07k5zs1ph6xja97hxnb3mqbspdrff6cvssgrixs32"; })
-  (fetchNuGet { pname = "System.Security.Cryptography.OpenSsl"; version = "4.3.0"; sha256 = "0givpvvj8yc7gv4lhb6s1prq6p2c4147204a0wib89inqzd87gqc"; })
-  (fetchNuGet { pname = "System.Security.Cryptography.Primitives"; version = "4.3.0"; sha256 = "0pyzncsv48zwly3lw4f2dayqswcfvdwq2nz0dgwmi7fj3pn64wby"; })
-  (fetchNuGet { pname = "System.Security.Cryptography.X509Certificates"; version = "4.3.0"; sha256 = "0valjcz5wksbvijylxijjxb1mp38mdhv03r533vnx1q3ikzdav9h"; })
-  (fetchNuGet { pname = "System.Security.Principal"; version = "4.3.0"; sha256 = "12cm2zws06z4lfc4dn31iqv7072zyi4m910d4r6wm8yx85arsfxf"; })
-  (fetchNuGet { pname = "System.Security.Principal.Windows"; version = "4.3.0"; sha256 = "00a0a7c40i3v4cb20s2cmh9csb5jv2l0frvnlzyfxh848xalpdwr"; })
-  (fetchNuGet { pname = "System.Security.Principal.Windows"; version = "4.6.0"; sha256 = "1jmfzfz1n8hp63s5lja5xxpzkinbp6g59l3km9h8avjiisdrg5wm"; })
-  (fetchNuGet { pname = "System.Text.Encoding"; version = "4.0.11"; sha256 = "1dyqv0hijg265dwxg6l7aiv74102d6xjiwplh2ar1ly6xfaa4iiw"; })
-  (fetchNuGet { pname = "System.Text.Encoding"; version = "4.3.0"; sha256 = "1f04lkir4iladpp51sdgmis9dj4y8v08cka0mbmsy0frc9a4gjqr"; })
-  (fetchNuGet { pname = "System.Text.Encoding.Extensions"; version = "4.0.11"; sha256 = "08nsfrpiwsg9x5ml4xyl3zyvjfdi4mvbqf93kjdh11j4fwkznizs"; })
-  (fetchNuGet { pname = "System.Text.Encoding.Extensions"; version = "4.3.0"; sha256 = "11q1y8hh5hrp5a3kw25cb6l00v5l5dvirkz8jr3sq00h1xgcgrxy"; })
-  (fetchNuGet { pname = "System.Text.RegularExpressions"; version = "4.1.0"; sha256 = "1mw7vfkkyd04yn2fbhm38msk7dz2xwvib14ygjsb8dq2lcvr18y7"; })
-  (fetchNuGet { pname = "System.Text.RegularExpressions"; version = "4.3.0"; sha256 = "1bgq51k7fwld0njylfn7qc5fmwrk2137gdq7djqdsw347paa9c2l"; })
-  (fetchNuGet { pname = "System.Threading"; version = "4.0.11"; sha256 = "19x946h926bzvbsgj28csn46gak2crv2skpwsx80hbgazmkgb1ls"; })
-  (fetchNuGet { pname = "System.Threading"; version = "4.3.0"; sha256 = "0rw9wfamvhayp5zh3j7p1yfmx9b5khbf4q50d8k5rk993rskfd34"; })
-  (fetchNuGet { pname = "System.Threading.Tasks"; version = "4.0.11"; sha256 = "0nr1r41rak82qfa5m0lhk9mp0k93bvfd7bbd9sdzwx9mb36g28p5"; })
-  (fetchNuGet { pname = "System.Threading.Tasks"; version = "4.3.0"; sha256 = "134z3v9abw3a6jsw17xl3f6hqjpak5l682k2vz39spj4kmydg6k7"; })
-  (fetchNuGet { pname = "System.Threading.Tasks.Dataflow"; version = "4.11.1"; sha256 = "09fbfsiay1xcbpvnq2j38b6mb2scvf0s8mpn78bcqsldidg7k2vw"; })
-  (fetchNuGet { pname = "System.Threading.Tasks.Extensions"; version = "4.0.0"; sha256 = "1cb51z062mvc2i8blpzmpn9d9mm4y307xrwi65di8ri18cz5r1zr"; })
-  (fetchNuGet { pname = "System.Threading.Tasks.Extensions"; version = "4.3.0"; sha256 = "1xxcx2xh8jin360yjwm4x4cf5y3a2bwpn2ygkfkwkicz7zk50s2z"; })
-  (fetchNuGet { pname = "System.Threading.Tasks.Extensions"; version = "4.5.4"; sha256 = "0y6ncasgfcgnjrhynaf0lwpkpkmv4a07sswwkwbwb5h7riisj153"; })
-  (fetchNuGet { pname = "System.Threading.ThreadPool"; version = "4.3.0"; sha256 = "027s1f4sbx0y1xqw2irqn6x161lzj8qwvnh2gn78ciiczdv10vf1"; })
-  (fetchNuGet { pname = "System.Threading.Timer"; version = "4.3.0"; sha256 = "1nx773nsx6z5whv8kaa1wjh037id2f1cxhb69pvgv12hd2b6qs56"; })
-  (fetchNuGet { pname = "System.Xml.ReaderWriter"; version = "4.0.11"; sha256 = "0c6ky1jk5ada9m94wcadih98l6k1fvf6vi7vhn1msjixaha419l5"; })
-  (fetchNuGet { pname = "System.Xml.ReaderWriter"; version = "4.3.0"; sha256 = "0c47yllxifzmh8gq6rq6l36zzvw4kjvlszkqa9wq3fr59n0hl3s1"; })
-  (fetchNuGet { pname = "System.Xml.XDocument"; version = "4.0.11"; sha256 = "0n4lvpqzy9kc7qy1a4acwwd7b7pnvygv895az5640idl2y9zbz18"; })
-  (fetchNuGet { pname = "System.Xml.XDocument"; version = "4.3.0"; sha256 = "08h8fm4l77n0nd4i4fk2386y809bfbwqb7ih9d7564ifcxr5ssxd"; })
-  (fetchNuGet { pname = "System.Xml.XmlDocument"; version = "4.3.0"; sha256 = "0bmz1l06dihx52jxjr22dyv5mxv6pj4852lx68grjm7bivhrbfwi"; })
-  (fetchNuGet { pname = "WaylandNET"; version = "0.2.0"; sha256 = "1qjpvra08vdqdw4j1gamz6451x5sd5r1j86lsvrl8akq4nymfr8k"; })
-  (fetchNuGet { pname = "xunit"; version = "2.4.1"; sha256 = "0xf3kaywpg15flqaqfgywqyychzk15kz0kz34j21rcv78q9ywq20"; })
-  (fetchNuGet { pname = "xunit.abstractions"; version = "2.0.3"; sha256 = "00wl8qksgkxld76fgir3ycc5rjqv1sqds6x8yx40927q5py74gfh"; })
-  (fetchNuGet { pname = "xunit.analyzers"; version = "0.10.0"; sha256 = "15n02q3akyqbvkp8nq75a8rd66d4ax0rx8fhdcn8j78pi235jm7j"; })
-  (fetchNuGet { pname = "xunit.assert"; version = "2.4.1"; sha256 = "1imynzh80wxq2rp9sc4gxs4x1nriil88f72ilhj5q0m44qqmqpc6"; })
-  (fetchNuGet { pname = "xunit.core"; version = "2.4.1"; sha256 = "1nnb3j4kzmycaw1g76ii4rfqkvg6l8gqh18falwp8g28h802019a"; })
-  (fetchNuGet { pname = "xunit.extensibility.core"; version = "2.4.1"; sha256 = "103qsijmnip2pnbhciqyk2jyhdm6snindg5z2s57kqf5pcx9a050"; })
-  (fetchNuGet { pname = "xunit.extensibility.execution"; version = "2.4.1"; sha256 = "1pbilxh1gp2ywm5idfl0klhl4gb16j86ib4x83p8raql1dv88qia"; })
-  (fetchNuGet { pname = "xunit.runner.visualstudio"; version = "2.4.3"; sha256 = "0j1d0rbcm7pp6dypi61sjxp8l22sv261252z55b243l39jgv2rp3"; })
-]

pkgs/tools/X11/opentabletdriver/remove-git-from-generate-rules.patch

···
-diff --git a/generate-rules.sh b/generate-rules.sh
-index ce6c3f3d..a0266612 100755
---- a/generate-rules.sh
-+++ b/generate-rules.sh
-@@ -8,7 +8,7 @@ print_help() {
-   echo "  -h, --help                              Print this help message"
- }
- 
--for c in git jq tr awk sed; do
-+for c in jq tr awk sed; do
-   command -v $c > /dev/null
-   if [[ $? > 0 ]]; then
-     echo "Error: Command $c not found in \$PATH." >&2
-@@ -23,7 +23,7 @@ tohex() {
- shopt -s globstar
- set -eu
- 
--OTD_CONFIGURATIONS="${OTD_CONFIGURATIONS:="$(git rev-parse --show-toplevel)/OpenTabletDriver.Configurations/Configurations"}"
-+OTD_CONFIGURATIONS="${OTD_CONFIGURATIONS:="$src/OpenTabletDriver.Configurations/Configurations"}"
- 
- while [ $# -gt 0 ]; do
-   case "$1" in

pkgs/tools/X11/opentabletdriver/update.sh

···
-#!/usr/bin/env nix-shell
-#!nix-shell -I nixpkgs=./. -i bash -p curl gnused jq common-updater-scripts
-set -eo pipefail
-cd "$(dirname "${BASH_SOURCE[0]}")"
-
-new_version="$(curl ${GITHUB_TOKEN:+" -u \":$GITHUB_TOKEN\""} -s "https://api.github.com/repos/OpenTabletDriver/OpenTabletDriver/releases" | jq -r  'map(select(.prerelease == false)) | .[0].tag_name' | cut -c2-)"
-old_version="$(sed -nE 's/\s*version = "(.*)".*/\1/p' ./default.nix)"
-
-if [[ "$new_version" == "$old_version" ]]; then
-  echo "Already up to date!"
-  [[ "${1}" != "--force" ]] && exit 0
-fi
-
-# Updating the hash of deb package manually since there seems to be no way to do it automatically
-oldDebPkgUrl="https://github.com/OpenTabletDriver/OpenTabletDriver/releases/download/v${old_version}/OpenTabletDriver.deb";
-newDebPkgUrl="https://github.com/OpenTabletDriver/OpenTabletDriver/releases/download/v${new_version}/OpenTabletDriver.deb";
-oldDebSha256=$(nix-prefetch-url "$oldDebPkgUrl")
-newDebSha256=$(nix-prefetch-url "$newDebPkgUrl")
-echo "oldDebSha256: $oldDebSha256 newDebSha256: $newDebSha256"
-sed -i ./default.nix -re "s|\"$oldDebSha256\"|\"$newDebSha256\"|"
-
-pushd ../../../..
-update-source-version opentabletdriver "$new_version"
-$(nix-build -A opentabletdriver.fetch-deps --no-out-link)

pkgs/tools/misc/hdf5/1.10.nix

···
 , stdenv
 , fetchurl
 , removeReferencesTo
+, cppSupport ? true
 , zlibSupport ? true
 , zlib
 , enableShared ? !stdenv.hostPlatform.isStatic
···
   propagatedBuildInputs = optional zlibSupport zlib;
 
   configureFlags = optional enableShared "--enable-shared"
-    ++ optional javaSupport "--enable-java";
+    ++ optional javaSupport "--enable-java"
+    ++ optional cppSupport "--enable-cxx";
 
   patches = [ ];
 
···
       applications for managing, manipulating, viewing, and analyzing data in the HDF5 format.
     '';
     license = lib.licenses.bsd3; # Lawrence Berkeley National Labs BSD 3-Clause variant
+    maintainers = with lib.maintainers; [ stephen-huan ];
     homepage = "https://www.hdfgroup.org/HDF5/";
     platforms = lib.platforms.unix;
   };

pkgs/tools/networking/openssh/common.nix

···
     tests = {
       borgbackup-integration = nixosTests.borgbackup;
       nixosTest = nixosTests.openssh;
+      initrd-network-openssh = nixosTests.initrd-network-ssh;
       openssh = finalAttrs.finalPackage.overrideAttrs (previousAttrs: {
         pname = previousAttrs.pname + "-test";
         doCheck = true;

pkgs/top-level/aliases.nix

···
   perldevel = throw "'perldevel' has been dropped due to lack of updates in nixpkgs and lack of consistent support for devel versions by 'perl-cross' releases, use 'perl' instead";
   perldevelPackages = perldevel;
   petrinizer = throw "'petrinizer' has been removed, as it was broken and unmaintained"; # added 2024-05-09
+  pg-gvm = throw "pg-gvm has been moved to postgresql.pkgs.pg-gvm to make it work with all versions of PostgreSQL"; # added 2024-11-30
   pgadmin = pgadmin4;
   pharo-spur64 = pharo; # Added 2022-08-03
   picom-next = picom; # Added 2024-02-13
···
 
   rabbitvcs = throw "rabbitvcs has been removed from nixpkgs, because it was broken"; # Added 2024-07-15
   radare2-cutter = throw "'radare2-cutter' has been renamed to/replaced by 'cutter'"; # Converted to throw 2024-10-17
+  radicale2 = throw "'radicale2' was removed because it was broken. Use 'radicale' (version 3) instead"; # Added 2024-11-29
+  radicale3 = radicale; # Added 2024-11-29
   radicle-cli = throw "'radicle-cli' was removed in favor of 'radicle-node'"; # Added 2024-05-04
   radicle-upstream = throw "'radicle-upstream' was sunset, see <https://community.radworks.org/t/2962>"; # Added 2024-05-04
   railway-travel = diebahn; # Added 2024-04-01

pkgs/top-level/all-packages.nix

···
 
   fdroidcl = pkgs.callPackage ../development/mobile/fdroidcl { };
 
-  fedimint = callPackage ../by-name/fe/fedimint/package.nix {
-    inherit (darwin.apple_sdk.frameworks) Security SystemConfiguration;
-  };
-
   flowgger = callPackage ../tools/misc/flowgger {
     inherit (darwin.apple_sdk.frameworks) CoreServices;
   };
···
 
   alerta-server = callPackage ../servers/monitoring/alerta { };
 
-  apacheHttpd_2_4 = callPackage ../servers/http/apache-httpd/2.4.nix {
-    inherit (darwin.apple_sdk.frameworks) Foundation;
-  };
+  apacheHttpd_2_4 = callPackage ../servers/http/apache-httpd/2.4.nix { };
   apacheHttpd = apacheHttpd_2_4;
 
   apacheHttpdPackagesFor = apacheHttpd: self: let callPackage = newScope self; in {
···
 
   inherit (callPackage ../applications/networking/mullvad { })
     mullvad;
-
-  mullvad-vpn = callPackage ../applications/networking/mullvad-vpn { };
 
   mullvad-closest = with python3Packages; toPythonApplication mullvad-closest;
 
···
     erlang = erlang_27;
     elixir = pkgs.elixir.override { inherit erlang; };
   };
-
-  radicale2 = callPackage ../servers/radicale/2.x.nix { };
-  radicale3 = radicale;
 
   qcal = callPackage ../tools/networking/qcal/default.nix { };
 
···
   opentimestamps-client = python3Packages.callPackage ../tools/misc/opentimestamps-client { };
 
   opentoonz = libsForQt5.callPackage ../applications/graphics/opentoonz { };
-
-  opentabletdriver = callPackage ../tools/X11/opentabletdriver { };
 
   opentx = libsForQt5.callPackage ../applications/misc/opentx { };
 

pkgs/top-level/haskell-packages.nix

···
     ghc910 = compiler.ghc9101;
     ghcHEAD = callPackage ../development/compilers/ghc/head.nix {
       bootPkgs =
-        # For GHC 9.6 no armv7l bindists are available.
-        if stdenv.buildPlatform.isAarch32 then
-          bb.packages.ghc963
-        else if stdenv.buildPlatform.isPower64 && stdenv.buildPlatform.isLittleEndian then
-          bb.packages.ghc963
-        else
-          bb.packages.ghc963Binary;
+        # No suitable bindist packaged yet
+        bb.packages.ghc9101;
       inherit (buildPackages.python3Packages) sphinx;
       # Need to use apple's patched xattr until
       # https://github.com/xattr/xattr/issues/44 and
···
     ghcHEAD = callPackage ../development/haskell-modules {
       buildHaskellPackages = bh.packages.ghcHEAD;
       ghc = bh.compiler.ghcHEAD;
-      compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-9.12.x.nix { };
+      compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-9.14.x.nix { };
     };
 
     ghcjs = packages.ghcjs810;

pkgs/top-level/python-packages.nix

···
 
   lizard = callPackage ../development/python-modules/lizard { };
 
+  llama-cpp-python = callPackage ../development/python-modules/llama-cpp-python { };
+
   llama-cloud = callPackage ../development/python-modules/llama-cloud { };
 
   llama-index = callPackage ../development/python-modules/llama-index { };