Merge staging-next into staging

maintainers/scripts/haskell/test-configurations.nix

···
     if !builtins.isList files then [ files ] else files
   );
 
+  packageSetsWithVersionedHead = pkgs.haskell.packages // (
+    let
+      headSet = pkgs.haskell.packages.ghcHEAD;
+      # Determine the next GHC release version following GHC HEAD.
+      # GHC HEAD always has an uneven, tentative version number, e.g. 9.7.
+      # GHC releases always have even numbers, i.e. GHC 9.8 is branched off from
+      # GHC HEAD 9.7. Since we use the to be release number for GHC HEAD's
+      # configuration file, we need to calculate this here.
+      headVersion = lib.pipe headSet.ghc.version [
+        lib.versions.splitVersion
+        (lib.take 2)
+        lib.concatStrings
+        lib.strings.toInt
+        (builtins.add 1)
+        toString
+      ];
+    in
+    {
+      "ghc${headVersion}" = headSet;
+    }
+  );
+
   setsForFile = fileName:
     let
       # extract the unique part of the config's file name
···
         builtins.match "ghc-([0-9]+).([0-9]+).x" configName
       );
       # return all package sets under haskell.packages matching the version components
-      setsForVersion =  builtins.map (name: pkgs.haskell.packages.${name}) (
+      setsForVersion =  builtins.map (name: packageSetsWithVersionedHead.${name}) (
         builtins.filter (setName:
           lib.hasPrefix "ghc${configVersion}" setName
           && (skipBinaryGHCs -> !(lib.hasInfix "Binary" setName))
         ) (
-          builtins.attrNames pkgs.haskell.packages
+          builtins.attrNames packageSetsWithVersionedHead
         )
       );
 

maintainers/scripts/haskell/update-stackage.sh

···
     -e '/ lsp-test /d' \
     -e '/ hie-bios /d' \
     -e '/ ShellCheck /d' \
+    -e '/ Agda /d' \
     < "${tmpfile_new}" >> $stackage_config
 # Explanations:
 # cabal2nix, distribution-nixpkgs, jailbreak-cabal, language-nix: These are our packages and we know what we are doing.
 # lsp, lsp-types, lsp-test, hie-bios: These are tightly coupled to hls which is not in stackage. They have no rdeps in stackage.
 # ShellCheck: latest version of command-line dev tool.
+# Agda: The Agda community is fast-moving; we strive to always include the newest versions of Agda and the Agda packages in nixpkgs.
 
 if [[ "${1:-}" == "--do-commit" ]]; then
 git add $stackage_config

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

···
 
 - [atuin](https://github.com/ellie/atuin), a sync server for shell history. Available as [services.atuin](#opt-services.atuin.enable).
 
+- [networkd-dispatcher](https://gitlab.com/craftyguy/networkd-dispatcher), a dispatcher service for systemd-networkd connection status changes. Available as [services.networkd-dispatcher](#opt-services.networkd-dispatcher.enable).
+
 - [mmsd](https://gitlab.com/kop316/mmsd), a lower level daemon that transmits and recieves MMSes. Available as [services.mmsd](#opt-services.mmsd.enable).
 
 - [QDMR](https://dm3mat.darc.de/qdmr/), a GUI application and command line tool for programming DMR radios [programs.qdmr](#opt-programs.qdmr.enable)

nixos/modules/module-list.nix

···
   ./services/networking/ndppd.nix
   ./services/networking/nebula.nix
   ./services/networking/netbird.nix
+  ./services/networking/networkd-dispatcher.nix
   ./services/networking/networkmanager.nix
   ./services/networking/nextdns.nix
   ./services/networking/nftables.nix

nixos/modules/services/networking/networkd-dispatcher.nix

···
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+let
+  cfg = config.services.networkd-dispatcher;
+in {
+  options = {
+    services.networkd-dispatcher = {
+
+      enable = mkEnableOption (mdDoc ''
+        Networkd-dispatcher service for systemd-networkd connection status
+        change. See [https://gitlab.com/craftyguy/networkd-dispatcher](upstream instructions)
+        for usage.
+      '');
+
+      scriptDir = mkOption {
+        type = types.path;
+        default = "/var/lib/networkd-dispatcher";
+        description = mdDoc ''
+          This directory is used for keeping various scripts read and run by
+          networkd-dispatcher. See [https://gitlab.com/craftyguy/networkd-dispatcher](upstream instructions)
+          for directory structure and script usage.
+        '';
+      };
+
+    };
+  };
+
+  config = mkIf cfg.enable {
+
+    systemd = {
+
+      packages = [ pkgs.networkd-dispatcher ];
+      services.networkd-dispatcher = {
+        wantedBy = [ "multi-user.target" ];
+        # Override existing ExecStart definition
+        serviceConfig.ExecStart = [
+          ""
+          "${pkgs.networkd-dispatcher}/bin/networkd-dispatcher -v --script-dir ${cfg.scriptDir} $networkd_dispatcher_args"
+        ];
+      };
+
+      # Directory structure required according to upstream instructions
+      # https://gitlab.com/craftyguy/networkd-dispatcher
+      tmpfiles.rules = [
+        "d '${cfg.scriptDir}'               0750 root root - -"
+        "d '${cfg.scriptDir}/routable.d'    0750 root root - -"
+        "d '${cfg.scriptDir}/dormant.d'     0750 root root - -"
+        "d '${cfg.scriptDir}/no-carrier.d'  0750 root root - -"
+        "d '${cfg.scriptDir}/off.d'         0750 root root - -"
+        "d '${cfg.scriptDir}/carrier.d'     0750 root root - -"
+        "d '${cfg.scriptDir}/degraded.d'    0750 root root - -"
+        "d '${cfg.scriptDir}/configuring.d' 0750 root root - -"
+        "d '${cfg.scriptDir}/configured.d'  0750 root root - -"
+      ];
+
+    };
+
+
+  };
+}
+

nixos/modules/services/networking/v2raya.nix

···
   config = mkIf config.services.v2raya.enable {
     environment.systemPackages = [ pkgs.v2raya ];
 
-    systemd.services.v2raya = {
-      unitConfig = {
-        Description = "v2rayA service";
-        Documentation = "https://github.com/v2rayA/v2rayA/wiki";
-        After = [ "network.target" "nss-lookup.target" "iptables.service" "ip6tables.service" ];
-        Wants = [ "network.target" ];
-      };
+    systemd.services.v2raya =
+      let
+        nftablesEnabled = config.networking.nftables.enable;
+        iptablesServices = [
+          "iptables.service"
+        ] ++ optional config.networking.enableIPv6 "ip6tables.service";
+        tableServices = if nftablesEnabled then [ "nftables.service" ] else iptablesServices;
+      in
+      {
+        unitConfig = {
+          Description = "v2rayA service";
+          Documentation = "https://github.com/v2rayA/v2rayA/wiki";
+          After = [
+            "network.target"
+            "nss-lookup.target"
+          ] ++ tableServices;
+          Wants = [ "network.target" ];
+        };
+
+        serviceConfig = {
+          User = "root";
+          ExecStart = "${getExe pkgs.v2raya} --log-disable-timestamp";
+          Environment = [ "V2RAYA_LOG_FILE=/var/log/v2raya/v2raya.log" ];
+          LimitNPROC = 500;
+          LimitNOFILE = 1000000;
+          Restart = "on-failure";
+          Type = "simple";
+        };
 
-      serviceConfig = {
-        User = "root";
-        ExecStart = "${getExe pkgs.v2raya} --log-disable-timestamp";
-        Environment = [ "V2RAYA_LOG_FILE=/var/log/v2raya/v2raya.log" ];
-        LimitNPROC = 500;
-        LimitNOFILE = 1000000;
-        Restart = "on-failure";
-        Type = "simple";
+        wantedBy = [ "multi-user.target" ];
+        path = with pkgs; [ iptables bash iproute2 ]; # required by v2rayA TProxy functionality
       };
-
-      wantedBy = [ "multi-user.target" ];
-      path = with pkgs; [ iptables bash iproute2 ]; # required by v2rayA TProxy functionality
-    };
   };
 
   meta.maintainers = with maintainers; [ elliot ];

pkgs/applications/audio/gwc/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "gwc";
-  version = "0.22-05";
+  version = "0.22-06";
 
   src = fetchFromGitHub {
     owner = "AlisterH";
     repo = pname;
     rev = version;
-    sha256 = "sha256-FHKu5qAyRyMxXdWYTCeAc6Q4J+NOaU1SGgoTbe0PiFE=";
+    sha256 = "sha256-hRwy++gZiW/olIIeiVTpdIjPLIHgvgVUGEaUX9tpFbY=";
   };
 
   nativeBuildInputs = [
···
   meta = with lib; {
     description = "GUI application for removing noise (hiss, pops and clicks) from audio files";
     homepage = "https://github.com/AlisterH/gwc/";
+    changelog = "https://github.com/AlisterH/gwc/blob/${version}/Changelog";
     license = licenses.gpl2Plus;
     maintainers = with maintainers; [ magnetophon ];
     platforms = platforms.linux;

pkgs/applications/misc/iptsd/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "iptsd";
-  version = "1.0.1";
+  version = "1.1.0";
 
   src = fetchFromGitHub {
     owner = "linux-surface";
     repo = pname;
     rev = "v${version}";
-    hash = "sha256-B5d1OjrRB164BYtFzZoZ3I4elZSKpHg0PCBiwXPnqLs=";
+    hash = "sha256-PpnMslZ1AKT1OEWXh23uH83FnZGLTrgIc2jZspJa8sk=";
   };
 
   nativeBuildInputs = [

pkgs/applications/networking/browsers/firefox-bin/default.nix

···
   # update with:
   # $ nix-shell maintainers/scripts/update.nix --argstr package firefox-bin-unwrapped
   passthru.updateScript = import ./update.nix {
-    inherit pname channel writeScript xidel coreutils gnused gnugrep gnupg curl runtimeShell;
+    inherit pname channel lib writeScript xidel coreutils gnused gnugrep gnupg curl runtimeShell;
     baseUrl =
       if channel == "devedition"
         then "https://archive.mozilla.org/pub/devedition/releases/"

pkgs/applications/networking/browsers/firefox-bin/update.nix

···
 { pname
 , channel
+, lib
 , writeScript
 , xidel
 , coreutils
···
            grep "^[0-9]" | \
            sort --version-sort | \
            grep -v "funnelcake" | \
-           grep -e "${lib.optionalString isBeta "b"}\([[:digit:]]\|[[:digit:]][[:digit:]]\)$" | ${lib.optionalString (not isBeta) "grep -v \"b\" |"} \
+           grep -e "${lib.optionalString isBeta "b"}\([[:digit:]]\|[[:digit:]][[:digit:]]\)$" | ${lib.optionalString (!isBeta) "grep -v \"b\" |"} \
            tail -1`
 
   curl --silent -o $HOME/shasums "$url$version/SHA256SUMS"

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

···
 
 buildGoModule rec {
   pname = "kubecfg";
-  version = "0.28.1";
+  version = "0.29.0";
 
   src = fetchFromGitHub {
     owner = "kubecfg";
     repo = "kubecfg";
     rev = "v${version}";
-    hash = "sha256-5IaF7q9Ue+tHkThxYgpkrnEH7xpKBx6cqKf2Zw2mjN4=";
+    hash = "sha256-41hctulZdFSBc+Yw4p2haR2VNIpa0bwntPCz3WUJyZg=";
   };
 
-  vendorHash = "sha256-Fh8QlXZ7I3XORjRhf5DIQmqA35LmgWVTN+iZDGaYHD8=";
+  vendorHash = "sha256-VGLGa1/8sdVC3H4hxpvF/t2YgbRlbeNTJMJb5zwknPw=";
 
   ldflags = [
     "-s"

pkgs/applications/networking/mailreaders/thunderbird-bin/default.nix

···
     '';
 
   passthru.updateScript = import ./../../browsers/firefox-bin/update.nix {
-    inherit writeScript xidel coreutils gnused gnugrep curl gnupg runtimeShell;
+    inherit lib writeScript xidel coreutils gnused gnugrep curl gnupg runtimeShell;
     pname = "thunderbird-bin";
     baseName = "thunderbird";
     channel = "release";

pkgs/applications/networking/mailreaders/thunderbird-bin/release_sources.nix

···
 {
-  version = "102.7.1";
+  version = "102.8.0";
   sources = [
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/af/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/af/thunderbird-102.8.0.tar.bz2";
       locale = "af";
       arch = "linux-x86_64";
-      sha256 = "f9c8f7fa943232b5e89a6200587c7b5294b216f581712e55936aa7354b0397a1";
+      sha256 = "ba2ede548ebecf34dbb9064fa40ffebd1b04c75fe49a9b75e0381b6d1863e448";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/ar/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/ar/thunderbird-102.8.0.tar.bz2";
       locale = "ar";
       arch = "linux-x86_64";
-      sha256 = "47cb5d16d4d3f4efe335a4d699e0dbd2b2e56c86d114aee36a0ef7a3187579e2";
+      sha256 = "6ce47dbc702e0557ed4ac1898a18e3aa17af0b7e9f9958410084aba1b765e3f6";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/ast/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/ast/thunderbird-102.8.0.tar.bz2";
       locale = "ast";
       arch = "linux-x86_64";
-      sha256 = "3b958523d341048b0a29262d767139399904d2ee7c7de05a49ddd9974af81fad";
+      sha256 = "0aa0ceb9067c91ad548edd7f3603fbc61a25b3ef0aba2ec669bf02ddabbd29d0";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/be/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/be/thunderbird-102.8.0.tar.bz2";
       locale = "be";
       arch = "linux-x86_64";
-      sha256 = "38eb2f42f730ce040619cb71272a947820fa65a2ef8ffd24bf98c8dbf7796657";
+      sha256 = "4ff2f25a296dc9737a68180b4594ee367d5499189948aa0f03ba273f6c3ce08c";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/bg/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/bg/thunderbird-102.8.0.tar.bz2";
       locale = "bg";
       arch = "linux-x86_64";
-      sha256 = "2b73de9089e1a61145b085e49c86c59ff9dc1069b81f9636755c606132df2169";
+      sha256 = "5100741120ee268ffd7c47fb96130f58d32e4f817e461589216b7613c58fca2f";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/br/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/br/thunderbird-102.8.0.tar.bz2";
       locale = "br";
       arch = "linux-x86_64";
-      sha256 = "a9da8b7c88b7c588c1cbc3622fd02a263cd9655a46df5adb64149ef30ba8274c";
+      sha256 = "0b957c10107762463559825bc8ec31b69782cc31254f712515f6e25612acbcce";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/ca/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/ca/thunderbird-102.8.0.tar.bz2";
       locale = "ca";
       arch = "linux-x86_64";
-      sha256 = "51552344dd81b36d06994232e04ff15b3f06657a9acb678fe1b187521074f65f";
+      sha256 = "2c51198833e5f177d3637e965c0d69435abbf26cc75347817c9b2aa1793083cf";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/cak/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/cak/thunderbird-102.8.0.tar.bz2";
       locale = "cak";
       arch = "linux-x86_64";
-      sha256 = "5f67ae6e0697e2142f20adc6016c1bab8f418d4ff155b4ac2bc35b5ce93b0f97";
+      sha256 = "d9bec543aacbbd68a5da25d331488639eb9808a38978ecb70c33b014d1883d2f";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/cs/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/cs/thunderbird-102.8.0.tar.bz2";
       locale = "cs";
       arch = "linux-x86_64";
-      sha256 = "b96b1a2dfbd4489710863fce3315b46d6a08ef94639a45b72e8304a22de93fba";
+      sha256 = "cd0c0eea3b9962366d6356f78d0f9add27a124b40306d9fd9dca55e38f6a3880";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/cy/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/cy/thunderbird-102.8.0.tar.bz2";
       locale = "cy";
       arch = "linux-x86_64";
-      sha256 = "113d5a113db16cf247d313c927229bbeb905d7e234f36b023b0d5bfbb70a53bd";
+      sha256 = "dce2c89acf985f25f3f3c8be5f4c99078215d7786140ea53ae1436e552c0db6f";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/da/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/da/thunderbird-102.8.0.tar.bz2";
       locale = "da";
       arch = "linux-x86_64";
-      sha256 = "05d4ac5b3cc699ab0b1ce05310fdc855eb6914d163ce52f0dd136abb6d3f129c";
+      sha256 = "b770cd13cb0d4016d594552e953dd64822eee279f780f3c430f2df2edcfffd69";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/de/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/de/thunderbird-102.8.0.tar.bz2";
       locale = "de";
       arch = "linux-x86_64";
-      sha256 = "9cd6557e6b12b6697b0adc9211aee9210854a2b346d93e492b59cabecc51b072";
+      sha256 = "b236aaac3efa2141254c604c031bbfc7b111f74aa4eeff195c2b45029a0d9b67";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/dsb/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/dsb/thunderbird-102.8.0.tar.bz2";
       locale = "dsb";
       arch = "linux-x86_64";
-      sha256 = "d10d1d4acbd505f9432d8e3ea1710020ef7e0859f9f31a54c9cf14d7f91bc383";
+      sha256 = "82ace3dc15970a1257cd6dbb2b884a5059ea0e413e78e3a97d6778da2dab13fd";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/el/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/el/thunderbird-102.8.0.tar.bz2";
       locale = "el";
       arch = "linux-x86_64";
-      sha256 = "651a6e1f5e49569ad65af74de39186629bb878d8a530286bcbe77feb55d5e89f";
+      sha256 = "70738ccfcdab51cbd6369656f424a38e497a35fc6a74a4eb6f33bf79db774d49";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/en-CA/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/en-CA/thunderbird-102.8.0.tar.bz2";
       locale = "en-CA";
       arch = "linux-x86_64";
-      sha256 = "ac29efcadcdbb2e90c3fd93ab1583968753861e64ad76c929635c61c60b7d862";
+      sha256 = "9b5011ce3c43f404ddf9b3d2d6b931cce9b39423ac44503fd52015bd20e217aa";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/en-GB/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/en-GB/thunderbird-102.8.0.tar.bz2";
       locale = "en-GB";
       arch = "linux-x86_64";
-      sha256 = "d312ca0e8549ab802d5e1f8ffcbaa67fefdf100745959d0eb3c28a9245386e60";
+      sha256 = "cb943b6e9fe2562ca5867f559459ae741be0b0a5758988e77de3e5895f33ff7f";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/en-US/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/en-US/thunderbird-102.8.0.tar.bz2";
       locale = "en-US";
       arch = "linux-x86_64";
-      sha256 = "a78cc228245bef172c7c75b884d4e4cc01858ff781e8c98d7f5f58c538d1dadf";
+      sha256 = "bba8cee22cab7a5134b4478a48117f5e2fff0dd2c7357920010e7f4e4df55728";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/es-AR/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/es-AR/thunderbird-102.8.0.tar.bz2";
       locale = "es-AR";
       arch = "linux-x86_64";
-      sha256 = "857ce86bce565f1c6c5a3191a3307d3cf4ea961eb46c8caca778adbadbf1b1ff";
+      sha256 = "1346bc8d7d6806f1d7d3fba08954d62d823fa8a645588e1edcbdcb582adb4c6a";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/es-ES/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/es-ES/thunderbird-102.8.0.tar.bz2";
       locale = "es-ES";
       arch = "linux-x86_64";
-      sha256 = "acc10ed435a63062ff3087663afe013bd1b9dfd1e5b01507ffec5ae714dc66be";
+      sha256 = "414829e3819c3c9c608d6d4ada7e3619326ddab645afec5b87e1c3f9eff308d5";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/es-MX/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/es-MX/thunderbird-102.8.0.tar.bz2";
       locale = "es-MX";
       arch = "linux-x86_64";
-      sha256 = "ddbece82bfbe3a87c5c464ae095ab85b751a8a273e959bb72673641a54379737";
+      sha256 = "258d9884194c73d91346c49be97e80379f330ad11c8b16c7a3a804ed44bb8b01";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/et/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/et/thunderbird-102.8.0.tar.bz2";
       locale = "et";
       arch = "linux-x86_64";
-      sha256 = "b5daa1beeaf2bfcc752c72146b2a1825a423c3c4b77ae27dcb2f3f0a6f1f456d";
+      sha256 = "e01ea9daab81222ce424ecf498fab0fbefb4ebae8f8f3420a3b324898bfc09be";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/eu/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/eu/thunderbird-102.8.0.tar.bz2";
       locale = "eu";
       arch = "linux-x86_64";
-      sha256 = "0cd04b7cbfa63c6dde7d878167aaaa2910374362f30612c465d7057026588673";
+      sha256 = "1f53f007d559496a66e7466f86bdbea375d879b760882d1a1df77560c26d204d";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/fi/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/fi/thunderbird-102.8.0.tar.bz2";
       locale = "fi";
       arch = "linux-x86_64";
-      sha256 = "151af6da31e71c79c225b8b7ecd5be43bfe9ebcbac4a4f854b20d19f0b1778a5";
+      sha256 = "55d8c2cee9fc9da86bba621a6e79aa2f7645f4ec83cf309444c7a3c09c1122a4";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/fr/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/fr/thunderbird-102.8.0.tar.bz2";
       locale = "fr";
       arch = "linux-x86_64";
-      sha256 = "4f9ec3fa67bd4ae618d31f6554d921ed2488e2b0f072142e528e06c0e4aa33f4";
+      sha256 = "ef26719a3a616f6e9e597cd110aa05ffaf832a63bc966ed9897a1b0bb6ee818a";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/fy-NL/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/fy-NL/thunderbird-102.8.0.tar.bz2";
       locale = "fy-NL";
       arch = "linux-x86_64";
-      sha256 = "ef432088a17e039e817d3a11dcced4ed1b561145683348a7c124542be6871c4c";
+      sha256 = "c9e30388ef4d54a5e8557668775460b32e6db213eb2beacc96338c5b883653ac";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/ga-IE/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/ga-IE/thunderbird-102.8.0.tar.bz2";
       locale = "ga-IE";
       arch = "linux-x86_64";
-      sha256 = "dafc4777f7649bc2cf42989be7454ca40904480ff43ccca1b85b01a7fac2d5da";
+      sha256 = "84ddd0d3646c31ef1da02f9a5e1cf48ec5dc459668fe36435db5f490eba40502";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/gd/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/gd/thunderbird-102.8.0.tar.bz2";
       locale = "gd";
       arch = "linux-x86_64";
-      sha256 = "860895c8660f356bc4c881a6c51e79b67eeb69cba94f1fe1532af226cc8d4bda";
+      sha256 = "11befd31b721e7c2a7e02b1d56099553b76dd9a870f7bf045041a353fbaf3fb2";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/gl/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/gl/thunderbird-102.8.0.tar.bz2";
       locale = "gl";
       arch = "linux-x86_64";
-      sha256 = "1e5bd20d59beb8fe1ceecbd6ca51f5772ab3241a35a085af9a8c8c5dad280844";
+      sha256 = "fab4badae04fcee3473937498d4e0672da9b94e1b1c09c4a21c6cbbab42c4a47";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/he/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/he/thunderbird-102.8.0.tar.bz2";
       locale = "he";
       arch = "linux-x86_64";
-      sha256 = "2d068ad6b002363499b8ba9e3c9196cba421887509f0e3c2d975b6b0f4ee6f9c";
+      sha256 = "d45c0d8f4da3d5e4786aee3ca3f909429838533dfebe52f1cdbff453d891ffd9";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/hr/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/hr/thunderbird-102.8.0.tar.bz2";
       locale = "hr";
       arch = "linux-x86_64";
-      sha256 = "f49a4449183e0c3f105ceb95e42761354f6a51a30da7b95178e78991077cc2f6";
+      sha256 = "a2d1d496ccb94502e4bbe5168709c0c547ee7e45100c7276d5efadc7bf0e8e3b";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/hsb/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/hsb/thunderbird-102.8.0.tar.bz2";
       locale = "hsb";
       arch = "linux-x86_64";
-      sha256 = "c4ecca8fdc1604488b4c0a7f3b171b16da1d32a3d1098da2de99e2010645696f";
+      sha256 = "cc74e62df0255e1f4c89d639851c1984ee19aa1f7eafbfdaf32cae6ed27127ab";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/hu/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/hu/thunderbird-102.8.0.tar.bz2";
       locale = "hu";
       arch = "linux-x86_64";
-      sha256 = "1c565300c297a3f734d02a02d0e5804eedf18ff319ddc2d831a50e9f1f8681c0";
+      sha256 = "13522a168cadd0ddc06392634745867928116b4fc6fecfd908fee1cf79155f7f";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/hy-AM/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/hy-AM/thunderbird-102.8.0.tar.bz2";
       locale = "hy-AM";
       arch = "linux-x86_64";
-      sha256 = "08269187570c64b9b7f8e121e7aafdb7546b4c9a9ff127e8d2287ddd977f00b8";
+      sha256 = "e79f42377015d42d861c1519d0767ca12ff1ea019884e8f9f6afb56a7f8513ae";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/id/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/id/thunderbird-102.8.0.tar.bz2";
       locale = "id";
       arch = "linux-x86_64";
-      sha256 = "c3ac21a8843631d24e69e6f28409cb609811130ea3454f1b2d72d8fe0008f02d";
+      sha256 = "39cddf34e49330204a2926f8aca2b50d88020a0bbd7b2520b5ae1429fc9983ad";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/is/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/is/thunderbird-102.8.0.tar.bz2";
       locale = "is";
       arch = "linux-x86_64";
-      sha256 = "959722f9ba38954ae7b6b7f746646492fb44274f1add7a15f324ddea632008fd";
+      sha256 = "2c73156fa3c4b242dc9d409b7b5d911b8b150425d554fb1e3ca8f149705281e8";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/it/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/it/thunderbird-102.8.0.tar.bz2";
       locale = "it";
       arch = "linux-x86_64";
-      sha256 = "fdea9f2b4496396211cbfb82c37e8a4ba8417df9d41a06a16d8bedfb5c004183";
+      sha256 = "41974d06b1553751ddae9e6d6d6b4439e0163964b5fa1cae7324ea2a3949ac70";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/ja/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/ja/thunderbird-102.8.0.tar.bz2";
       locale = "ja";
       arch = "linux-x86_64";
-      sha256 = "cb8e2152dc44dd0311c1fc26427be109c652edd666e50ce64228083b45aae1f7";
+      sha256 = "42500186b681a7ef81f7d71c864ca515497f3b705f7474d104ee75454ffa8a03";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/ka/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/ka/thunderbird-102.8.0.tar.bz2";
       locale = "ka";
       arch = "linux-x86_64";
-      sha256 = "5cf0d73fbf3010631d47edefd8fc61bacc0afc5dfc70b10e8f15ea1acb9d01b6";
+      sha256 = "bec232ad6c9f1cf1fc38edd0e9210336a56bf20ea8f61dafd113c8bff9da5117";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/kab/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/kab/thunderbird-102.8.0.tar.bz2";
       locale = "kab";
       arch = "linux-x86_64";
-      sha256 = "a7fd302122033f17395682a938a4f4568769e78da5c65497efd9bcfe8f1ad55a";
+      sha256 = "e27ce311cc367d4f76b2fc632bb7454569346cb715b50235f4952c8a4aad4931";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/kk/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/kk/thunderbird-102.8.0.tar.bz2";
       locale = "kk";
       arch = "linux-x86_64";
-      sha256 = "4904675ec60a76be7520ce049c3ed20f65aa536706197134982d7f8f06354fa8";
+      sha256 = "711c93de3db1fdca7583a6fe715816eb3fbc24d2024a49e9ed0968b86008ae53";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/ko/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/ko/thunderbird-102.8.0.tar.bz2";
       locale = "ko";
       arch = "linux-x86_64";
-      sha256 = "5d68318f86e9b454a7e91c3a633ceeea4622c822c16cf195a15a98e5c283b8e7";
+      sha256 = "4b02afd65cb37438fd6470e39015a4aee0fb526c640b24c9dda43860740554d6";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/lt/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/lt/thunderbird-102.8.0.tar.bz2";
       locale = "lt";
       arch = "linux-x86_64";
-      sha256 = "653a51abc8d653986327971267045ec39dadb87ce2d45db07c89f7af6d071ae8";
+      sha256 = "38a1ee1acfae532a477f917e977d784ca8e5b8861d1f8b77c769a6a0e75c106c";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/lv/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/lv/thunderbird-102.8.0.tar.bz2";
       locale = "lv";
       arch = "linux-x86_64";
-      sha256 = "baff4993f6342633b78c91b89c6310797fc2e47ff4eb1fde42944600928c24d1";
+      sha256 = "26e4095f76e63044b12f578382092ca1e8e540cd808f13f57e6b75ac24900d57";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/ms/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/ms/thunderbird-102.8.0.tar.bz2";
       locale = "ms";
       arch = "linux-x86_64";
-      sha256 = "84bc6e45f468fa2502ab724b1e83646517e2317336859ef511416cf1f816c99c";
+      sha256 = "762b0646a9ca93291ae76951b789b1a23b6fe5b023bf47b3567ab28c118147d0";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/nb-NO/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/nb-NO/thunderbird-102.8.0.tar.bz2";
       locale = "nb-NO";
       arch = "linux-x86_64";
-      sha256 = "f27e36fc612a6371d909d59b8b8d890d253d6377c73c688a88d3d91bb28e6fd9";
+      sha256 = "5f8d639afa6bccce81a9d475ea3e5db2a9799f325314d8f2ace366e7c919391c";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/nl/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/nl/thunderbird-102.8.0.tar.bz2";
       locale = "nl";
       arch = "linux-x86_64";
-      sha256 = "08b7fd31958fb59a79805ebef8750444e9611153b51ef629f7346f093668b0cd";
+      sha256 = "0cc441bf7aa9fede1a6b87e58c4a0eee6881196b68308ddd870215c6f93a3b16";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/nn-NO/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/nn-NO/thunderbird-102.8.0.tar.bz2";
       locale = "nn-NO";
       arch = "linux-x86_64";
-      sha256 = "e8acc09fa7461276a4d0e0b1cffbb6a6957abc258f5cde21cd60a12b0fa4a699";
+      sha256 = "8cc81b524082efe23ee865583cddadce33ae8367d4bfc97cb631bd1599deec14";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/pa-IN/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/pa-IN/thunderbird-102.8.0.tar.bz2";
       locale = "pa-IN";
       arch = "linux-x86_64";
-      sha256 = "dbc65a49363f155806bbe224e2f53f711fdf87fa187eec0b853edb4c247142cb";
+      sha256 = "d2db7a51cc627f60d645bc6c2f3bc01971d4358b99187c27e1ab97a803a465f4";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/pl/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/pl/thunderbird-102.8.0.tar.bz2";
       locale = "pl";
       arch = "linux-x86_64";
-      sha256 = "bd59abc1773c3f4d14fe01fe0e4d02e6cdf47bddfdf2fedafa379852dc73ce2e";
+      sha256 = "97ab876eb3321de7acd899b4d637dd1ba1fbe1ca39a4cb5933b3f27a374848e2";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/pt-BR/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/pt-BR/thunderbird-102.8.0.tar.bz2";
       locale = "pt-BR";
       arch = "linux-x86_64";
-      sha256 = "7f53b244392fe8623712039afcbf5e48733eda8c30ded65dde32e4fb943dcbb3";
+      sha256 = "d4107a7fa690926e27c031164a8686d48b7ec85f87e759877b1b611899acd2dd";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/pt-PT/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/pt-PT/thunderbird-102.8.0.tar.bz2";
       locale = "pt-PT";
       arch = "linux-x86_64";
-      sha256 = "f28fd3208ef49e51f5facd75c070c1752a3d98b7918664ea5f990f5dc691a26e";
+      sha256 = "8fd0180fc900ac146bc027d0684c32628adf7fed1c3d6ba629d2ce860eba7365";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/rm/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/rm/thunderbird-102.8.0.tar.bz2";
       locale = "rm";
       arch = "linux-x86_64";
-      sha256 = "ca914636f9f8039b6b009d703874894dd1a9baa9a8ab689646a27ea5ec19335b";
+      sha256 = "67d9639e25d18f3a87fb46837cdd5a5c02a8750288f1ce3c8a9966bd8a27ccd6";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/ro/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/ro/thunderbird-102.8.0.tar.bz2";
       locale = "ro";
       arch = "linux-x86_64";
-      sha256 = "6773c7b4cf3d08573b561184a4791e0d8df6ef7471e575d67ab3714471eb7d6d";
+      sha256 = "a6647805b9d150e2b122acbd1b68e615685ccc71ffac30969c844a47e8d53871";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/ru/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/ru/thunderbird-102.8.0.tar.bz2";
       locale = "ru";
       arch = "linux-x86_64";
-      sha256 = "83a0fc3af145e4a8977fad8fefa8c61dea05da241968a402163390dc51783405";
+      sha256 = "49f80efa92dc62e030a77a591767a59dcf79a555a38ea529904779bddd51ed3a";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/sk/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/sk/thunderbird-102.8.0.tar.bz2";
       locale = "sk";
       arch = "linux-x86_64";
-      sha256 = "aa1f6583a8b67cf82020add4af9b036430d9dd4c098329ffef838aa17f438283";
+      sha256 = "d0f1eba84c00b072b041cb47f3ad9c743eb9fdb5cf24f2800aaafd1673174ec4";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/sl/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/sl/thunderbird-102.8.0.tar.bz2";
       locale = "sl";
       arch = "linux-x86_64";
-      sha256 = "7d56a2519b6b42b7415c5e2a08542acd4deae999b9da8d050d9d569d2090891a";
+      sha256 = "79be6e3e6bf71677ebe697629dddab4e626a057d569f54174b4226a5b89c3fb1";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/sq/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/sq/thunderbird-102.8.0.tar.bz2";
       locale = "sq";
       arch = "linux-x86_64";
-      sha256 = "de0301f1146de978731630f4a409123c3632a5f28f969343b3a9174b4682f54a";
+      sha256 = "e038fd9cff2bb4d3b5e4732276de7741e081a9a0c5867025bad0e0f9ea95a34f";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/sr/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/sr/thunderbird-102.8.0.tar.bz2";
       locale = "sr";
       arch = "linux-x86_64";
-      sha256 = "66bf3ab91904a380a489461ea8b291fee3c85a042adebdc6e444776b6421dd93";
+      sha256 = "400246f1cc4d75b9792e48043dd38b908281a3a1f6bf1f59b3d5c9653f65ad87";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/sv-SE/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/sv-SE/thunderbird-102.8.0.tar.bz2";
       locale = "sv-SE";
       arch = "linux-x86_64";
-      sha256 = "69b274c1142959d2a8a246a37cd5ff6c6942cfff94395d19a8d01ec4a4115629";
+      sha256 = "f820013501e8110dc7b7e23516e7fe3888072c45f392424d3dab3441c3c2075b";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/th/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/th/thunderbird-102.8.0.tar.bz2";
       locale = "th";
       arch = "linux-x86_64";
-      sha256 = "9fdd24e43f32722026728ab5673dc29bbce95415be580e75417e5769ad9ad154";
+      sha256 = "71c8986491d336851a6eca7e4aa033e749349936321de1811847ebf9e0ccebb5";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/tr/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/tr/thunderbird-102.8.0.tar.bz2";
       locale = "tr";
       arch = "linux-x86_64";
-      sha256 = "480221e013d98ba46271b1448057da4c405831fba518d8266d1502759fcace1a";
+      sha256 = "019156e1d394fd052e7f2d7fcd96058801eb14e4ff61d9e9f907569b129aa2bf";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/uk/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/uk/thunderbird-102.8.0.tar.bz2";
       locale = "uk";
       arch = "linux-x86_64";
-      sha256 = "2e43643374b2ebae4b882c8fabdbffbe75351679711b8c07edb3f81bbff99e18";
+      sha256 = "e37cadef887a0fce4459e91c90d63361115f86d8cc7cb841107771ed378443db";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/uz/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/uz/thunderbird-102.8.0.tar.bz2";
       locale = "uz";
       arch = "linux-x86_64";
-      sha256 = "ce9f9ae3a6750863dbd88a54964d28bef949fefdd00de91ca149fc73c3780929";
+      sha256 = "60a4946bc07b76d76f92332234f2d87f70d7b3c4e7f15530a61e602a358e64b5";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/vi/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/vi/thunderbird-102.8.0.tar.bz2";
       locale = "vi";
       arch = "linux-x86_64";
-      sha256 = "6913bfd4043cbeb8adc1b60b54958b4b45ea581ed32430496cc3c6e368da0432";
+      sha256 = "05ed2df59ea6d9265d9133c6bab1858cfb324cb58fdbc9997749bccae653b539";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/zh-CN/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/zh-CN/thunderbird-102.8.0.tar.bz2";
       locale = "zh-CN";
       arch = "linux-x86_64";
-      sha256 = "bed56c6e8c86919cea51fbb8b945cdfc8b1470a350bc30a81f090da873e0dc3c";
+      sha256 = "c7a01ce36f53cc45d706f6607459807044f098c1d9a3316bad13b834d53fa2eb";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-x86_64/zh-TW/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-x86_64/zh-TW/thunderbird-102.8.0.tar.bz2";
       locale = "zh-TW";
       arch = "linux-x86_64";
-      sha256 = "e88b4af743a6a4f3351d84faa299c24398efd4e0a885744e972f48c842664231";
+      sha256 = "7d85ee85882a0c50ae25a338db564eb404df7eaefce93726a0bf15e6c6988811";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/af/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/af/thunderbird-102.8.0.tar.bz2";
       locale = "af";
       arch = "linux-i686";
-      sha256 = "77a1191878ba739e961c585972e09667f71fafa910d1b88e3b1d4f2cf3b57c98";
+      sha256 = "96f298579a357caff8b69aa1c1c485201640ffe05ab6e3adf5cec5f4268250c2";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/ar/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/ar/thunderbird-102.8.0.tar.bz2";
       locale = "ar";
       arch = "linux-i686";
-      sha256 = "fdb2b78af9e5f88dd1cc553fa49f79fbb1992ec68a39534a62a4059e3c90c8a4";
+      sha256 = "b382d9665457bf9dda8c5aa38d657e92e534795f4d1a4d42b5a07625e40d02c7";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/ast/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/ast/thunderbird-102.8.0.tar.bz2";
       locale = "ast";
       arch = "linux-i686";
-      sha256 = "49f60ad48a7cb25072f51da1f0f1d9927054a0770e68615554e3fc252b7c01a1";
+      sha256 = "00b76108dfde73e07487f841e7167477e938bed167d95132536e9d92bd9ad3f7";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/be/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/be/thunderbird-102.8.0.tar.bz2";
       locale = "be";
       arch = "linux-i686";
-      sha256 = "d59942a904f325937566e776bf7f5ee0040237161bbea5c018b0e15e324e054c";
+      sha256 = "80b459c031c7d678c28e50ff8f0df864e6be3183551e5677bf280d749712689b";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/bg/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/bg/thunderbird-102.8.0.tar.bz2";
       locale = "bg";
       arch = "linux-i686";
-      sha256 = "cee56ce650ada3771572cbb8c5a66c9b199a09e8b5aaba4c39f50c7f625c2bc6";
+      sha256 = "1a98a96b8da3d6d6ae642c19a9ce5f29d6f0f9a68a016a60ce179ad080feb40d";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/br/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/br/thunderbird-102.8.0.tar.bz2";
       locale = "br";
       arch = "linux-i686";
-      sha256 = "75bb61c9af7eee854513c33c1691ec599a3a0f102a2d2c92f60166d29b00e518";
+      sha256 = "50f2bb8baa7db5f863f9a05569b45516c217a6454d48a5042442bd59237a79a2";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/ca/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/ca/thunderbird-102.8.0.tar.bz2";
       locale = "ca";
       arch = "linux-i686";
-      sha256 = "251f8a7c25fc836fdbe442d411b52e27a72fb959506b0024fc51998f88853888";
+      sha256 = "4ec8300f818e3e623dfd5bb84ba8e5682b1481acbcc24cc40c7c893f7843dad6";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/cak/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/cak/thunderbird-102.8.0.tar.bz2";
       locale = "cak";
       arch = "linux-i686";
-      sha256 = "e35db0bdaa032eb35da0e7c5f5434cb945ee2c76f3f22f4340beca77b1dc276d";
+      sha256 = "73e38bb0cc6c77563de93b763e082ec0799c37920b35fac6acc14091ad90bc91";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/cs/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/cs/thunderbird-102.8.0.tar.bz2";
       locale = "cs";
       arch = "linux-i686";
-      sha256 = "4bf3e15c819ef3eaeea8ee48637adcc3dea859295ed1efe48727198b8ec68286";
+      sha256 = "3cf10ca513bc83cb327d450ea66ea70d2ed891c7d22f7cbd4bb151d48265ba47";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/cy/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/cy/thunderbird-102.8.0.tar.bz2";
       locale = "cy";
       arch = "linux-i686";
-      sha256 = "ec4b2793bac062f91abea3d861f2347d5979bd7cd82ca90d207f42275ee45924";
+      sha256 = "dc530f8efe020b87e257de80e781e86c6b102114eead16e86642964df9d4e290";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/da/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/da/thunderbird-102.8.0.tar.bz2";
       locale = "da";
       arch = "linux-i686";
-      sha256 = "d8c3aa1d3725fd3b916b2b011e45d269efcd41884135b77007a3ab09b32b5790";
+      sha256 = "54bcabdff268df1a8f8e4aade54866283da0e031b62def9e535bb6eaa92cc97b";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/de/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/de/thunderbird-102.8.0.tar.bz2";
       locale = "de";
       arch = "linux-i686";
-      sha256 = "dfe4bb2548772f2216bf8f40e0e299f72a4623f8a3515322d6fef8479160eb65";
+      sha256 = "8045387afd1c74a2041be37ef67fa8bbdf0e0c05f66a0772d4828fd1ba889caf";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/dsb/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/dsb/thunderbird-102.8.0.tar.bz2";
       locale = "dsb";
       arch = "linux-i686";
-      sha256 = "bd6341d73b0e45f1652ae7e0edd521c6050da76ca74318a1c09c23ff578e7f64";
+      sha256 = "b9b708de0e810844bd3573951234a134c29cf122ebf239c0ff74fe51dc3e5a3c";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/el/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/el/thunderbird-102.8.0.tar.bz2";
       locale = "el";
       arch = "linux-i686";
-      sha256 = "519956e96b8a588bb9b7300241088b75936aa6cb867df750d755ef877ffc4113";
+      sha256 = "c0beca9e0e4e98c21908029c04b84b8c9e4a08a2f9aef8bf016c98b50410e126";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/en-CA/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/en-CA/thunderbird-102.8.0.tar.bz2";
       locale = "en-CA";
       arch = "linux-i686";
-      sha256 = "d5dcb62cf3afbbe51bf331f521c38c3fb42509966fab7cd3de4555cb01c8385f";
+      sha256 = "2b3a93b4194a29c38b41cf3ecab924303ff55f475b9a59395971a03a81e7af08";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/en-GB/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/en-GB/thunderbird-102.8.0.tar.bz2";
       locale = "en-GB";
       arch = "linux-i686";
-      sha256 = "33ac02dd0b28c0d3b3a371fa7d18b9dad9d50ba12b5b998cd8035a509bd9d0c9";
+      sha256 = "ae3cd3135dfce0be827e1a16f3be6a09301a95c976acbe382be9bb74115b4ad8";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/en-US/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/en-US/thunderbird-102.8.0.tar.bz2";
       locale = "en-US";
       arch = "linux-i686";
-      sha256 = "eba918d5d1945d5a2be98026c5cedfb8fc766bcc70e85b74a056ee6cb839e17e";
+      sha256 = "c6e2f9c987e9c5987bc555ea6b5647e5048543170d39123e14619b31a087fdad";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/es-AR/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/es-AR/thunderbird-102.8.0.tar.bz2";
       locale = "es-AR";
       arch = "linux-i686";
-      sha256 = "28d3585777d69e3923fc092a07f3792374bd94b4355e9158b412f61ba48260de";
+      sha256 = "a59fd6d68562ad3debb66c2253270edd1b6e87c0f060fc6b73ecb87849d2f965";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/es-ES/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/es-ES/thunderbird-102.8.0.tar.bz2";
       locale = "es-ES";
       arch = "linux-i686";
-      sha256 = "a548a4a7f1ac802dab608bec15d3102f60985d4f72d7ed3ce5b4af6019dad3bd";
+      sha256 = "5bc63628e1c4b2735ababbc9732a25f1cfe14137753b547024ca6e4286b71db8";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/es-MX/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/es-MX/thunderbird-102.8.0.tar.bz2";
       locale = "es-MX";
       arch = "linux-i686";
-      sha256 = "c521d75f86ec69e520be6782b0f8ae50ee11781fbb65efde907788c0f780d13a";
+      sha256 = "894aa1d22f69f270657f9dd8448950bf9301e369e28313179bc4708b66b6f014";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/et/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/et/thunderbird-102.8.0.tar.bz2";
       locale = "et";
       arch = "linux-i686";
-      sha256 = "0ce40eedd20d47f10052380716afceaaeecfa1794654e0fe3d91c164369be7e7";
+      sha256 = "5249066b7d6d19e964c1bbb452749f0a79b11f5d462c208c123c10a7884cf69a";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/eu/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/eu/thunderbird-102.8.0.tar.bz2";
       locale = "eu";
       arch = "linux-i686";
-      sha256 = "fe0bc3bef267629b43aa9a30888b776c23823bc39d3b8de1669737d050d0c6d2";
+      sha256 = "aed52a4d32b18e95936610af1f2f5830c8c06159e62fbae124396e865deab7cc";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/fi/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/fi/thunderbird-102.8.0.tar.bz2";
       locale = "fi";
       arch = "linux-i686";
-      sha256 = "a7df2ae00cc2d6528d68d23dc6dd87d5ab888d4ff8bc8926fa1f260f3e941249";
+      sha256 = "e848d5d478f57e0213be2a550aee1d15c3090b1683c0de28e6ff5c32c9b33753";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/fr/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/fr/thunderbird-102.8.0.tar.bz2";
       locale = "fr";
       arch = "linux-i686";
-      sha256 = "1ba6ee69c2e06b3e14257668a025949eb52427530303dea7f239b875622e2265";
+      sha256 = "7e22ca894d4f742b3555cf1057cd7e97f0968408bce07f21c655b7265026326a";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/fy-NL/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/fy-NL/thunderbird-102.8.0.tar.bz2";
       locale = "fy-NL";
       arch = "linux-i686";
-      sha256 = "5738e2f246aa21dcd65b7793930a6fff7f1df4a6e1a961647b9e5909751631b2";
+      sha256 = "5562b6fcf035387ef3f5369fe2edd406cdb6417786a2a044ba8e582fe33094b6";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/ga-IE/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/ga-IE/thunderbird-102.8.0.tar.bz2";
       locale = "ga-IE";
       arch = "linux-i686";
-      sha256 = "964250c97a1657e0be2336aa2b7396d687ed1b09eff3a78491494c3f1d1f6e6f";
+      sha256 = "eaa935bb3a977a10571268ef9c0e30a9560a273bf100dd8bcaf86333b39c4a74";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/gd/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/gd/thunderbird-102.8.0.tar.bz2";
       locale = "gd";
       arch = "linux-i686";
-      sha256 = "9edbd8aa70d19fb8c458cbb3150af7b493d56d9eef148e95062c98eb484b37c9";
+      sha256 = "b3c7eb3ddaeb76e1e3dd298962ded700717fb71a600f02c6275839875253a821";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/gl/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/gl/thunderbird-102.8.0.tar.bz2";
       locale = "gl";
       arch = "linux-i686";
-      sha256 = "7115f6a9d4ec73c67388705798fcc7fb66170327197797bb0e94ccbb8d1533df";
+      sha256 = "642af77ea5002d4d649369e08d55e866cb99fd2f991975a111a79a4b9108cb3e";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/he/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/he/thunderbird-102.8.0.tar.bz2";
       locale = "he";
       arch = "linux-i686";
-      sha256 = "694b96cc2ef17776114c5dfab1dd6986ea19eb915f1e2949643c50088a41d371";
+      sha256 = "d50515d49dc86d39715a8b673dd3e384eb5e4b2210ce62abaa6c5849fee8b29e";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/hr/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/hr/thunderbird-102.8.0.tar.bz2";
       locale = "hr";
       arch = "linux-i686";
-      sha256 = "cc8fbcf5f2a2140de52393a65b47c3dc3f8d0a3c5beff3c4b03146bcb3b22d01";
+      sha256 = "1fe0639429f6de5e6df096acbdbcb04ec9b83e971c1667cf008e4cfa3830062f";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/hsb/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/hsb/thunderbird-102.8.0.tar.bz2";
       locale = "hsb";
       arch = "linux-i686";
-      sha256 = "dd58e25c539fe156b77bd38cc605273fed8d2eb5539c258ded6c549bd77b62b3";
+      sha256 = "d9655265dd36ad5300e1d5daf471a7d9393e21fa94c8b7c12995c5f9cf955a02";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/hu/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/hu/thunderbird-102.8.0.tar.bz2";
       locale = "hu";
       arch = "linux-i686";
-      sha256 = "043699375afb74a87cc56745b7adea8a7e4277ead73fe955ec47edeba79fe376";
+      sha256 = "16f2cb8efce4333fda4daef686956622e24e828c6b8f0493b1025fb3581a6322";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/hy-AM/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/hy-AM/thunderbird-102.8.0.tar.bz2";
       locale = "hy-AM";
       arch = "linux-i686";
-      sha256 = "a3070020b912611f951627b4301b1b1731a12e9862c5abf6d84bfaec42d053f7";
+      sha256 = "cd31deaae27fca3afeb71ccd092c13b68a1f9afbfd3cf0bd8e569879d55a0da9";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/id/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/id/thunderbird-102.8.0.tar.bz2";
       locale = "id";
       arch = "linux-i686";
-      sha256 = "cce39d28bab265b125a2fb764286a6074c529c1a135a9fb8513dfe1e68610fe6";
+      sha256 = "3535fe394cb67f5047e78ae5cf75b8fb0a861fe2a5d942b8ab12961b0ee1ea6e";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/is/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/is/thunderbird-102.8.0.tar.bz2";
       locale = "is";
       arch = "linux-i686";
-      sha256 = "65d698c2be8159f86b7747a595035cd48cfd8894a1219aeea7ba533c63749bb8";
+      sha256 = "32066d8612387fc80375f4514b3a01dd7d74eeb7fca6769699f7344b6c8ab3cd";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/it/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/it/thunderbird-102.8.0.tar.bz2";
       locale = "it";
       arch = "linux-i686";
-      sha256 = "38c3e6dd5119036cad3747a756182509743c257ab91bc3a46c4f072f4215061f";
+      sha256 = "f602713708789fe391c638fd9049603b6a9e8303ba2608911569f4fce8c005eb";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/ja/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/ja/thunderbird-102.8.0.tar.bz2";
       locale = "ja";
       arch = "linux-i686";
-      sha256 = "e6f4afe7187bc11c4bc91dec7c389967b087b70d80d1b573b6b59b14a96f928a";
+      sha256 = "a95845637e8083a28a207554ac3400eb8fb19b3e31d4a2d1982b96154bdaf945";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/ka/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/ka/thunderbird-102.8.0.tar.bz2";
       locale = "ka";
       arch = "linux-i686";
-      sha256 = "e02c55859edc5b6b71c3f04b07f6a17c3eb47020d38e77c0dc197f89cff77280";
+      sha256 = "d8942afa3552a41fcc12b24295432e0f83721e4df210b1a43096535b3d5944f1";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/kab/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/kab/thunderbird-102.8.0.tar.bz2";
       locale = "kab";
       arch = "linux-i686";
-      sha256 = "7355fe55ef05aac5d1216e5dbeaf471840f8044a94dad10ee5d243355a64e490";
+      sha256 = "d06565f2512596a2b964cc7efc17d67061882966ece76ab1bc1a76991a3f629c";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/kk/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/kk/thunderbird-102.8.0.tar.bz2";
       locale = "kk";
       arch = "linux-i686";
-      sha256 = "0d941de8c8b07818e6a97f5548a018f62cf054095b3f5760dbc3e6bcad265295";
+      sha256 = "273258bf7fd75b25521bb79dcb4f9b5491a7fa8b76eebc6fe82b1f6a3554f9ae";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/ko/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/ko/thunderbird-102.8.0.tar.bz2";
       locale = "ko";
       arch = "linux-i686";
-      sha256 = "21fbbfb40b32f916e4954c1b9bd2f5a9dfff38b040472b217f9d5890e2addc9d";
+      sha256 = "9c6644f489f4b8e7f016df15d8d04d63931a4f47e6136ffd108c250d73494b67";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/lt/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/lt/thunderbird-102.8.0.tar.bz2";
       locale = "lt";
       arch = "linux-i686";
-      sha256 = "460cb7183c5f257e2059e50e3dcf14f9acdee91be7bc80c2b135c113daa5e818";
+      sha256 = "ac5a4b5da556278928fa795cc47e2db88a5336b2e12bc3a00f9db17e68c41365";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/lv/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/lv/thunderbird-102.8.0.tar.bz2";
       locale = "lv";
       arch = "linux-i686";
-      sha256 = "48312688f9473fc4295a3a53552f6905cd6b6976e4a0098d1efe7066de79d99a";
+      sha256 = "d00c5f721bccf20957eefeca50ed1a71251d1672d659e43c809465b303099da3";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/ms/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/ms/thunderbird-102.8.0.tar.bz2";
       locale = "ms";
       arch = "linux-i686";
-      sha256 = "af5a24aa0419353e8114cf5e680a33189991bc46ff96b1a7e29f92090698ffe8";
+      sha256 = "77a17b05cf63e0565c697c23889e84a548397b41f307f1f57d0ca965c1932b24";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/nb-NO/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/nb-NO/thunderbird-102.8.0.tar.bz2";
       locale = "nb-NO";
       arch = "linux-i686";
-      sha256 = "3366f4fcb3f59feab347401c1d54a53baeb7e2f02983f9a673474915dc0f2f90";
+      sha256 = "c4c7b9d061188db625ff7dd7a9f0552583625c9c5fbb77269d8c6018849ee1e8";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/nl/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/nl/thunderbird-102.8.0.tar.bz2";
       locale = "nl";
       arch = "linux-i686";
-      sha256 = "e1eb9ec9b93325b33870c2a748cbb0678c5a616bc2f32ec72f21bf7e4f8b1dd0";
+      sha256 = "474ca230c6749d0de8162268bd18b34f98b10da1aae91ef241f99aeb77f335b2";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/nn-NO/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/nn-NO/thunderbird-102.8.0.tar.bz2";
       locale = "nn-NO";
       arch = "linux-i686";
-      sha256 = "866ca87d6a1a77ee4781e2843a9dfade6a9d5c8c41dfa378b67c19579da8ba93";
+      sha256 = "39a215f35617f2b3ebe6b5215ca231edde9938c047f04928f69966786adb8eea";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/pa-IN/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/pa-IN/thunderbird-102.8.0.tar.bz2";
       locale = "pa-IN";
       arch = "linux-i686";
-      sha256 = "cde4426c3216a9864b8ab252c1217b82cb848f62dec9a26e05beda0326a349a5";
+      sha256 = "9f3bf27d34cea4c0409c6b0a7861f38650107a3458fc5b3a35806a3c49974fe2";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/pl/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/pl/thunderbird-102.8.0.tar.bz2";
       locale = "pl";
       arch = "linux-i686";
-      sha256 = "391ecdc9bfa27b41c09efcc2e9609ae2824f24d7f355951eef5c2bacec0ee023";
+      sha256 = "a25766f5c924bcc77499eb87f83ff91f3ac3cdd3a97416827fd0bf7f74b5761e";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/pt-BR/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/pt-BR/thunderbird-102.8.0.tar.bz2";
       locale = "pt-BR";
       arch = "linux-i686";
-      sha256 = "dd8c4daaf09b28c099f66066e1c09a1b7663bb88442091f288c30bc13a681d69";
+      sha256 = "6c5b0f5250b8fed7e5b53c8f3c4b55fa122d4c3360aeb4393d2af3c1f9b11f72";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/pt-PT/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/pt-PT/thunderbird-102.8.0.tar.bz2";
       locale = "pt-PT";
       arch = "linux-i686";
-      sha256 = "99939e63236d92365732da29fff66172b32817728eac3413bd8b36b642d71f78";
+      sha256 = "b0f99ef79a979e45764a59f5ba75a52bffd750586c18caccf44aa5e36c7a90d0";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/rm/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/rm/thunderbird-102.8.0.tar.bz2";
       locale = "rm";
       arch = "linux-i686";
-      sha256 = "cd7575f2e15668f18f47f025ebf72da6ef1a6f78cf1cae3857b378fb8f4a5bb5";
+      sha256 = "90225e33183ed0bae5e2dbe47c072f703dce5a1673e3b5f0c25acba0ea611af2";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/ro/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/ro/thunderbird-102.8.0.tar.bz2";
       locale = "ro";
       arch = "linux-i686";
-      sha256 = "0cc819fa94f6f24ff71a834df6377593ac9a5f3dafd5b6341f3f566e310626f7";
+      sha256 = "ca68f9b3fdd149067998240e42ce6d64066b32a4d3455b079e0847ed225d13e4";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/ru/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/ru/thunderbird-102.8.0.tar.bz2";
       locale = "ru";
       arch = "linux-i686";
-      sha256 = "3d10ea1e92cb98873dc281a1299209233d378d4dcd57e1e520e70f9d110fbea9";
+      sha256 = "880109a31e6d0fa7a66465a1b480e08311438193bb256a0c6d97dcf3788ecf9c";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/sk/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/sk/thunderbird-102.8.0.tar.bz2";
       locale = "sk";
       arch = "linux-i686";
-      sha256 = "4e08aad359fb2f50306057014c02998c277355260190da6feb80ed5dab79da48";
+      sha256 = "f30784a7b41c4e1d08331f366f390cdacd79542841b486cb84efbc0268ba1ea9";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/sl/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/sl/thunderbird-102.8.0.tar.bz2";
       locale = "sl";
       arch = "linux-i686";
-      sha256 = "c235916f09e170081f431ff4a9fbb65f269c6778018c48cbe723e932fa477461";
+      sha256 = "e94321812047fdf7015d38bb1001a7ac476e67ffc428451a3f361abe62a7bba5";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/sq/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/sq/thunderbird-102.8.0.tar.bz2";
       locale = "sq";
       arch = "linux-i686";
-      sha256 = "3d41b2d0069c8bda97cb517bb2edbfae9d545cff78fe72e5a211cf1b1d6a1d28";
+      sha256 = "0debbcc0772c8184ceb4b3dd8658a7808f1ac0e7c1b3b83b0229a4283c345223";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/sr/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/sr/thunderbird-102.8.0.tar.bz2";
       locale = "sr";
       arch = "linux-i686";
-      sha256 = "5c7e1077b4f6bacfc85c81372da06fffbf1b5a57339dda29d529fac709713e86";
+      sha256 = "db48cc5e315519b65cd36b67ed9652397a050fccbebf68e608f5ab64cea4300f";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/sv-SE/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/sv-SE/thunderbird-102.8.0.tar.bz2";
       locale = "sv-SE";
       arch = "linux-i686";
-      sha256 = "73a71fac92a39bea72b791e4cdb376fbee5a158d985baf55c02254377392c23f";
+      sha256 = "cbe5fc9e42a824c8bcc78d1dc20d519b7db4f380a3a897b98f8ef8cfad57cc41";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/th/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/th/thunderbird-102.8.0.tar.bz2";
       locale = "th";
       arch = "linux-i686";
-      sha256 = "362ace4cc7d2059c53b58b387c1ac8b19965f5bdba7e566f5b1392236567bdca";
+      sha256 = "0f72fb98688da2dd9b457b747504d7b937d4f8680192ac13e08220f6fb52a48c";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/tr/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/tr/thunderbird-102.8.0.tar.bz2";
       locale = "tr";
       arch = "linux-i686";
-      sha256 = "0c43d20819707c2e0facfe1d79cde5ed5c77022be74bec0d250ca1426917a462";
+      sha256 = "3ac2b0a3e8d65a2101a8a599a349d03250afe343ed82cd81b94f481edc3a5e04";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/uk/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/uk/thunderbird-102.8.0.tar.bz2";
       locale = "uk";
       arch = "linux-i686";
-      sha256 = "0c96f8bffd2e2c8c4acff92685b8a4d2d0f138950928d5795c8459c0c07e6a71";
+      sha256 = "30d6b00ddc305022e4dd9a6fe759be5d34df1968108b6ce9165ea3d14bc31dd4";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/uz/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/uz/thunderbird-102.8.0.tar.bz2";
       locale = "uz";
       arch = "linux-i686";
-      sha256 = "b555e4b71142757d42e72073392e8a1b6002728e08177e04793a2fba54dbd671";
+      sha256 = "946be925d11a5721d8c875ffed36f33d51ce46d2797899c0c385c4816cca38d1";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/vi/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/vi/thunderbird-102.8.0.tar.bz2";
       locale = "vi";
       arch = "linux-i686";
-      sha256 = "f47a1e2fcc3b30405a1320583a18984085a92fcbbb803a37054217d73d8bb585";
+      sha256 = "ad260c10d05b5656ff86e24b2ea5df7110840954b84caf388c1af8d55c38ebdc";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/zh-CN/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/zh-CN/thunderbird-102.8.0.tar.bz2";
       locale = "zh-CN";
       arch = "linux-i686";
-      sha256 = "d2c9a379863ef070f40cdba997eaf3a33d78ef3be05d44785cc5a7f91e815238";
+      sha256 = "20321d57e7ed909cf6ebdf9e349b6fbd91fb3d3ce4a4b6ba42d28693c3454644";
     }
-    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.7.1/linux-i686/zh-TW/thunderbird-102.7.1.tar.bz2";
+    { url = "http://archive.mozilla.org/pub/thunderbird/releases/102.8.0/linux-i686/zh-TW/thunderbird-102.8.0.tar.bz2";
       locale = "zh-TW";
       arch = "linux-i686";
-      sha256 = "4b355e48855b7a67ba7fd8fdd5a46ec17ab21eab1e971fb07199163966f72ea3";
+      sha256 = "4cab4bd41dc1424f442b141546b0d9b0122afd21fdf0decbee9b6151522bb48a";
     }
     ];
 }

pkgs/applications/networking/mailreaders/thunderbird/packages.nix

···
 
   thunderbird-102 = (buildMozillaMach rec {
     pname = "thunderbird";
-    version = "102.7.2";
+    version = "102.8.0";
     application = "comm/mail";
     applicationName = "Mozilla Thunderbird";
     binaryName = pname;
     src = fetchurl {
       url = "mirror://mozilla/thunderbird/releases/${version}/source/thunderbird-${version}.source.tar.xz";
-      sha512 = "7371079d59cceb47fdd0e9661f79eae7510ab0f5bf8e80c21952dfb5fed3db72279a4ac9d3a3de3617194fb36a9420ae814a69ee19a93ba242d2aa2b921e3010";
+      sha512 = "2431eb8799184b261609c96bed3c9368bec9035a831aa5f744fa89e48aedb130385b268dd90f03bbddfec449dc3e5fad1b5f8727fe9e11e1d1f123a81b97ddf8";
     };
     extraPatches = [
       # The file to be patched is different from firefox's `no-buildconfig-ffx90.patch`.

pkgs/applications/science/math/calc/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "calc";
-  version = "2.14.1.2";
+  version = "2.14.1.3";
 
   src = fetchurl {
     urls = [
       "https://github.com/lcn2/calc/releases/download/v${version}/${pname}-${version}.tar.bz2"
       "http://www.isthe.com/chongo/src/calc/${pname}-${version}.tar.bz2"
     ];
-    sha256 = "sha256-3o8jKmEYxNQtExOkjqTVU24mtSok+T/RnRw6goNzThM=";
+    sha256 = "sha256-5aAvYzjAkpLZGf9UE+Ta18Io9EwP769yYlVykiH4qd0=";
   };
 
   postPatch = ''

pkgs/build-support/agda/default.nix

···
           runHook postInstall
         '';
 
+        # As documented at https://github.com/NixOS/nixpkgs/issues/172752,
+        # we need to set LC_ALL to an UTF-8-supporting locale. However, on
+        # darwin, it seems that there is no standard such locale; luckily,
+        # the referenced issue doesn't seem to surface on darwin. Hence let's
+        # set this only on non-darwin.
+        LC_ALL = lib.optionalString (!stdenv.isDarwin) "C.UTF-8";
+
         meta = if meta.broken or false then meta // { hydraPlatforms = lib.platforms.none; } else meta;
 
         # Retrieve all packages from the finished package set that have the current package as a dependency and build them

pkgs/data/misc/hackage/pin.json

···
 {
-  "commit": "307653b893cc53ffa71d6931c33101d352e3ead1",
-  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/307653b893cc53ffa71d6931c33101d352e3ead1.tar.gz",
-  "sha256": "0mgmmzdlb9j4drkjjdrp2da8z4can7gg8zd007ya2jw17rz270hz",
-  "msg": "Update from Hackage at 2023-01-29T01:30:53Z"
+  "commit": "220fb2ad74640b02e543271393f21ba227bd2627",
+  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/220fb2ad74640b02e543271393f21ba227bd2627.tar.gz",
+  "sha256": "1hpbqw04i8p2h5w31a7rqlmhdjpj4r4v62kdqich57hm1cj2ml7h",
+  "msg": "Update from Hackage at 2023-02-13T17:53:53Z"
 }

pkgs/desktops/gnome/core/libgnome-keyring/default.nix

···
 , testers
 }:
 
-let
+stdenv.mkDerivation (finalAttrs: {
   pname = "libgnome-keyring";
   version = "3.12.0";
-in
-stdenv.mkDerivation (finalAttrs: {
-  name = "${pname}-${version}";
 
   src = fetchurl {
-    url = "mirror://gnome/sources/${pname}/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
+    url = "mirror://gnome/sources/libgnome-keyring/${lib.versions.majorMinor finalAttrs.version}/libgnome-keyring-${finalAttrs.version}.tar.xz";
     sha256 = "c4c178fbb05f72acc484d22ddb0568f7532c409b0a13e06513ff54b91e947783";
   };
 
···
     homepage = "https://wiki.gnome.org/Projects/GnomeKeyring";
     license = with lib.licenses; [ gpl2Plus lgpl2Plus ];
     pkgConfigModules = [ "gnome-keyring-1" ];
-    inherit (glib.meta) platforms maintainers;
+    platforms = lib.platforms.unix;
+    maintainers = [];
 
     longDescription = ''
       gnome-keyring is a program that keeps password and other secrets for

pkgs/development/compilers/ghc/9.2.6.nix

···
+{ lib, stdenv, pkgsBuildTarget, pkgsHostTarget, targetPackages
+
+# build-tools
+, bootPkgs
+, autoconf, automake, coreutils, fetchpatch, fetchurl, perl, python3, m4, sphinx
+, xattr, autoSignDarwinBinariesHook
+, bash
+
+, libiconv ? null, ncurses
+, glibcLocales ? null
+
+, # GHC can be built with system libffi or a bundled one.
+  libffi ? null
+
+, useLLVM ? !(stdenv.targetPlatform.isx86
+              || stdenv.targetPlatform.isPower
+              || stdenv.targetPlatform.isSparc
+              || (stdenv.targetPlatform.isAarch64 && stdenv.targetPlatform.isDarwin))
+, # LLVM is conceptually a run-time-only depedendency, but for
+  # non-x86, we need LLVM to bootstrap later stages, so it becomes a
+  # build-time dependency too.
+  buildTargetLlvmPackages, llvmPackages
+
+, # If enabled, GHC will be built with the GPL-free but slightly slower native
+  # bignum backend instead of the faster but GPLed gmp backend.
+  enableNativeBignum ? !(lib.meta.availableOn stdenv.hostPlatform gmp
+                         && lib.meta.availableOn stdenv.targetPlatform gmp)
+, gmp
+
+, # If enabled, use -fPIC when compiling static libs.
+  enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform
+
+  # aarch64 outputs otherwise exceed 2GB limit
+, enableProfiledLibs ? !stdenv.targetPlatform.isAarch64
+
+, # Whether to build dynamic libs for the standard library (on the target
+  # platform). Static libs are always built.
+  enableShared ? with stdenv.targetPlatform; !isWindows && !useiOSPrebuilt && !isStatic
+
+, # Whether to build terminfo.
+  enableTerminfo ? !stdenv.targetPlatform.isWindows
+
+, # What flavour to build. An empty string indicates no
+  # specific flavour and falls back to ghc default values.
+  ghcFlavour ? lib.optionalString (stdenv.targetPlatform != stdenv.hostPlatform)
+    (if useLLVM then "perf-cross" else "perf-cross-ncg")
+
+, #  Whether to build sphinx documentation.
+  enableDocs ? (
+    # Docs disabled for musl and cross because it's a large task to keep
+    # all `sphinx` dependencies building in those environments.
+    # `sphinx` pulls in among others:
+    # Ruby, Python, Perl, Rust, OpenGL, Xorg, gtk, LLVM.
+    (stdenv.targetPlatform == stdenv.hostPlatform)
+    && !stdenv.hostPlatform.isMusl
+  )
+
+, enableHaddockProgram ?
+    # Disabled for cross; see note [HADDOCK_DOCS].
+    (stdenv.targetPlatform == stdenv.hostPlatform)
+
+, # Whether to disable the large address space allocator
+  # necessary fix for iOS: https://www.reddit.com/r/haskell/comments/4ttdz1/building_an_osxi386_to_iosarm64_cross_compiler/d5qvd67/
+  disableLargeAddressSpace ? stdenv.targetPlatform.isiOS
+}:
+
+assert !enableNativeBignum -> gmp != null;
+
+# Cross cannot currently build the `haddock` program for silly reasons,
+# see note [HADDOCK_DOCS].
+assert (stdenv.targetPlatform != stdenv.hostPlatform) -> !enableHaddockProgram;
+
+let
+  inherit (stdenv) buildPlatform hostPlatform targetPlatform;
+
+  inherit (bootPkgs) ghc;
+
+  # TODO(@Ericson2314) Make unconditional
+  targetPrefix = lib.optionalString
+    (targetPlatform != hostPlatform)
+    "${targetPlatform.config}-";
+
+  buildMK = ''
+    BuildFlavour = ${ghcFlavour}
+    ifneq \"\$(BuildFlavour)\" \"\"
+    include mk/flavours/\$(BuildFlavour).mk
+    endif
+    BUILD_SPHINX_HTML = ${if enableDocs then "YES" else "NO"}
+    BUILD_SPHINX_PDF = NO
+  '' +
+  # Note [HADDOCK_DOCS]:
+  # Unfortunately currently `HADDOCK_DOCS` controls both whether the `haddock`
+  # program is built (which we generally always want to have a complete GHC install)
+  # and whether it is run on the GHC sources to generate hyperlinked source code
+  # (which is impossible for cross-compilation); see:
+  # https://gitlab.haskell.org/ghc/ghc/-/issues/20077
+  # This implies that currently a cross-compiled GHC will never have a `haddock`
+  # program, so it can never generate haddocks for any packages.
+  # If this is solved in the future, we'd like to unconditionally
+  # build the haddock program (removing the `enableHaddockProgram` option).
+  ''
+    HADDOCK_DOCS = ${if enableHaddockProgram then "YES" else "NO"}
+    # Build haddocks for boot packages with hyperlinking
+    EXTRA_HADDOCK_OPTS += --hyperlinked-source --quickjump
+
+    DYNAMIC_GHC_PROGRAMS = ${if enableShared then "YES" else "NO"}
+    BIGNUM_BACKEND = ${if enableNativeBignum then "native" else "gmp"}
+  '' + lib.optionalString (targetPlatform != hostPlatform) ''
+    Stage1Only = ${if targetPlatform.system == hostPlatform.system then "NO" else "YES"}
+    CrossCompilePrefix = ${targetPrefix}
+  '' + lib.optionalString (!enableProfiledLibs) ''
+    GhcLibWays = "v dyn"
+  '' +
+  # -fexternal-dynamic-refs apparently (because it's not clear from the documentation)
+  # makes the GHC RTS able to load static libraries, which may be needed for TemplateHaskell.
+  # This solution was described in https://www.tweag.io/blog/2020-09-30-bazel-static-haskell
+  lib.optionalString enableRelocatedStaticLibs ''
+    GhcLibHcOpts += -fPIC -fexternal-dynamic-refs
+    GhcRtsHcOpts += -fPIC -fexternal-dynamic-refs
+  '' + lib.optionalString targetPlatform.useAndroidPrebuilt ''
+    EXTRA_CC_OPTS += -std=gnu99
+  '';
+
+  # Splicer will pull out correct variations
+  libDeps = platform: lib.optional enableTerminfo ncurses
+    ++ [libffi]
+    ++ lib.optional (!enableNativeBignum) gmp
+    ++ lib.optional (platform.libc != "glibc" && !targetPlatform.isWindows) libiconv;
+
+  # TODO(@sternenseemann): is buildTarget LLVM unnecessary?
+  # GHC doesn't seem to have {LLC,OPT}_HOST
+  toolsForTarget = [
+    pkgsBuildTarget.targetPackages.stdenv.cc
+  ] ++ lib.optional useLLVM buildTargetLlvmPackages.llvm;
+
+  targetCC = builtins.head toolsForTarget;
+
+  # Sometimes we have to dispatch between the bintools wrapper and the unwrapped
+  # derivation for certain tools depending on the platform.
+  bintoolsFor = {
+    # GHC needs install_name_tool on all darwin platforms. On aarch64-darwin it is
+    # part of the bintools wrapper (due to codesigning requirements), but not on
+    # x86_64-darwin.
+    install_name_tool =
+      if stdenv.targetPlatform.isAarch64
+      then targetCC.bintools
+      else targetCC.bintools.bintools;
+    # Same goes for strip.
+    strip =
+      # TODO(@sternenseemann): also use wrapper if linker == "bfd" or "gold"
+      if stdenv.targetPlatform.isAarch64 && stdenv.targetPlatform.isDarwin
+      then targetCC.bintools
+      else targetCC.bintools.bintools;
+  };
+
+  # Use gold either following the default, or to avoid the BFD linker due to some bugs / perf issues.
+  # But we cannot avoid BFD when using musl libc due to https://sourceware.org/bugzilla/show_bug.cgi?id=23856
+  # see #84670 and #49071 for more background.
+  useLdGold = targetPlatform.linker == "gold" ||
+    (targetPlatform.linker == "bfd" && (targetCC.bintools.bintools.hasGold or false) && !targetPlatform.isMusl);
+
+  # Makes debugging easier to see which variant is at play in `nix-store -q --tree`.
+  variantSuffix = lib.concatStrings [
+    (lib.optionalString stdenv.hostPlatform.isMusl "-musl")
+    (lib.optionalString enableNativeBignum "-native-bignum")
+  ];
+
+in
+
+# C compiler, bintools and LLVM are used at build time, but will also leak into
+# the resulting GHC's settings file and used at runtime. This means that we are
+# currently only able to build GHC if hostPlatform == buildPlatform.
+assert targetCC == pkgsHostTarget.targetPackages.stdenv.cc;
+assert buildTargetLlvmPackages.llvm == llvmPackages.llvm;
+assert stdenv.targetPlatform.isDarwin -> buildTargetLlvmPackages.clang == llvmPackages.clang;
+
+stdenv.mkDerivation (rec {
+  version = "9.2.6";
+  pname = "${targetPrefix}ghc${variantSuffix}";
+
+  src = fetchurl {
+    url = "https://downloads.haskell.org/ghc/${version}/ghc-${version}-src.tar.xz";
+    sha256 = "7a54cf0398ad488b4ed219e15d1d1e64c0b6876c43a0564550dd11f0540d7305";
+  };
+
+  enableParallelBuilding = true;
+
+  outputs = [ "out" "doc" ];
+
+  patches = [
+    # fix hyperlinked haddock sources: https://github.com/haskell/haddock/pull/1482
+    (fetchpatch {
+      url = "https://patch-diff.githubusercontent.com/raw/haskell/haddock/pull/1482.patch";
+      sha256 = "sha256-8w8QUCsODaTvknCDGgTfFNZa8ZmvIKaKS+2ZJZ9foYk=";
+      extraPrefix = "utils/haddock/";
+      stripLen = 1;
+    })
+    # Don't generate code that doesn't compile when --enable-relocatable is passed to Setup.hs
+    # Can be removed if the Cabal library included with ghc backports the linked fix
+    (fetchpatch {
+      url = "https://github.com/haskell/cabal/commit/6c796218c92f93c95e94d5ec2d077f6956f68e98.patch";
+      stripLen = 1;
+      extraPrefix = "libraries/Cabal/";
+      sha256 = "sha256-yRQ6YmMiwBwiYseC5BsrEtDgFbWvst+maGgDtdD0vAY=";
+    })
+  ];
+
+  postPatch = "patchShebangs .";
+
+  # GHC needs the locale configured during the Haddock phase.
+  LANG = "en_US.UTF-8";
+
+  # GHC is a bit confused on its cross terminology.
+  # TODO(@sternenseemann): investigate coreutils dependencies and pass absolute paths
+  preConfigure = ''
+    for env in $(env | grep '^TARGET_' | sed -E 's|\+?=.*||'); do
+      export "''${env#TARGET_}=''${!env}"
+    done
+    # GHC is a bit confused on its cross terminology, as these would normally be
+    # the *host* tools.
+    export CC="${targetCC}/bin/${targetCC.targetPrefix}cc"
+    export CXX="${targetCC}/bin/${targetCC.targetPrefix}c++"
+    # Use gold to work around https://sourceware.org/bugzilla/show_bug.cgi?id=16177
+    export LD="${targetCC.bintools}/bin/${targetCC.bintools.targetPrefix}ld${lib.optionalString useLdGold ".gold"}"
+    export AS="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}as"
+    export AR="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ar"
+    export NM="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}nm"
+    export RANLIB="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ranlib"
+    export READELF="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}readelf"
+    export STRIP="${bintoolsFor.strip}/bin/${bintoolsFor.strip.targetPrefix}strip"
+  '' + lib.optionalString (stdenv.targetPlatform.linker == "cctools") ''
+    export OTOOL="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}otool"
+    export INSTALL_NAME_TOOL="${bintoolsFor.install_name_tool}/bin/${bintoolsFor.install_name_tool.targetPrefix}install_name_tool"
+  '' + lib.optionalString useLLVM ''
+    export LLC="${lib.getBin buildTargetLlvmPackages.llvm}/bin/llc"
+    export OPT="${lib.getBin buildTargetLlvmPackages.llvm}/bin/opt"
+  '' + lib.optionalString (useLLVM && stdenv.targetPlatform.isDarwin) ''
+    # LLVM backend on Darwin needs clang: https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/codegens.html#llvm-code-generator-fllvm
+    export CLANG="${buildTargetLlvmPackages.clang}/bin/${buildTargetLlvmPackages.clang.targetPrefix}clang"
+  '' + ''
+    echo -n "${buildMK}" > mk/build.mk
+  '' + lib.optionalString (stdenv.isLinux && hostPlatform.libc == "glibc") ''
+    export LOCALE_ARCHIVE="${glibcLocales}/lib/locale/locale-archive"
+  '' + lib.optionalString (!stdenv.isDarwin) ''
+    export NIX_LDFLAGS+=" -rpath $out/lib/ghc-${version}"
+  '' + lib.optionalString stdenv.isDarwin ''
+    export NIX_LDFLAGS+=" -no_dtrace_dof"
+
+    # GHC tries the host xattr /usr/bin/xattr by default which fails since it expects python to be 2.7
+    export XATTR=${lib.getBin xattr}/bin/xattr
+  '' + lib.optionalString targetPlatform.useAndroidPrebuilt ''
+    sed -i -e '5i ,("armv7a-unknown-linux-androideabi", ("e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64", "cortex-a8", ""))' llvm-targets
+  '' + lib.optionalString targetPlatform.isMusl ''
+      echo "patching llvm-targets for musl targets..."
+      echo "Cloning these existing '*-linux-gnu*' targets:"
+      grep linux-gnu llvm-targets | sed 's/^/  /'
+      echo "(go go gadget sed)"
+      sed -i 's,\(^.*linux-\)gnu\(.*\)$,\0\n\1musl\2,' llvm-targets
+      echo "llvm-targets now contains these '*-linux-musl*' targets:"
+      grep linux-musl llvm-targets | sed 's/^/  /'
+
+      echo "And now patching to preserve '-musleabi' as done with '-gnueabi'"
+      # (aclocal.m4 is actual source, but patch configure as well since we don't re-gen)
+      for x in configure aclocal.m4; do
+        substituteInPlace $x \
+          --replace '*-android*|*-gnueabi*)' \
+                    '*-android*|*-gnueabi*|*-musleabi*)'
+      done
+  '';
+
+  # TODO(@Ericson2314): Always pass "--target" and always prefix.
+  configurePlatforms = [ "build" "host" ]
+    ++ lib.optional (targetPlatform != hostPlatform) "target";
+
+  # `--with` flags for libraries needed for RTS linker
+  configureFlags = [
+    "--datadir=$doc/share/doc/ghc"
+    "--with-curses-includes=${ncurses.dev}/include" "--with-curses-libraries=${ncurses.out}/lib"
+  ] ++ lib.optionals (libffi != null) [
+    "--with-system-libffi"
+    "--with-ffi-includes=${targetPackages.libffi.dev}/include"
+    "--with-ffi-libraries=${targetPackages.libffi.out}/lib"
+  ] ++ lib.optionals (targetPlatform == hostPlatform && !enableNativeBignum) [
+    "--with-gmp-includes=${targetPackages.gmp.dev}/include"
+    "--with-gmp-libraries=${targetPackages.gmp.out}/lib"
+  ] ++ lib.optionals (targetPlatform == hostPlatform && hostPlatform.libc != "glibc" && !targetPlatform.isWindows) [
+    "--with-iconv-includes=${libiconv}/include"
+    "--with-iconv-libraries=${libiconv}/lib"
+  ] ++ lib.optionals (targetPlatform != hostPlatform) [
+    "--enable-bootstrap-with-devel-snapshot"
+  ] ++ lib.optionals useLdGold [
+    "CFLAGS=-fuse-ld=gold"
+    "CONF_GCC_LINKER_OPTS_STAGE1=-fuse-ld=gold"
+    "CONF_GCC_LINKER_OPTS_STAGE2=-fuse-ld=gold"
+  ] ++ lib.optionals (disableLargeAddressSpace) [
+    "--disable-large-address-space"
+  ];
+
+  # Make sure we never relax`$PATH` and hooks support for compatibility.
+  strictDeps = true;
+
+  # Don’t add -liconv to LDFLAGS automatically so that GHC will add it itself.
+  dontAddExtraLibs = true;
+
+  nativeBuildInputs = [
+    perl autoconf automake m4 python3
+    ghc bootPkgs.alex bootPkgs.happy bootPkgs.hscolour
+  ] ++ lib.optionals (stdenv.isDarwin && stdenv.isAarch64) [
+    autoSignDarwinBinariesHook
+  ] ++ lib.optionals enableDocs [
+    sphinx
+  ];
+
+  # For building runtime libs
+  depsBuildTarget = toolsForTarget;
+
+  buildInputs = [ perl bash ] ++ (libDeps hostPlatform);
+
+  depsTargetTarget = map lib.getDev (libDeps targetPlatform);
+  depsTargetTargetPropagated = map (lib.getOutput "out") (libDeps targetPlatform);
+
+  # required, because otherwise all symbols from HSffi.o are stripped, and
+  # that in turn causes GHCi to abort
+  stripDebugFlags = [ "-S" ] ++ lib.optional (!targetPlatform.isDarwin) "--keep-file-symbols";
+
+  checkTarget = "test";
+
+  hardeningDisable =
+    [ "format" ]
+    # In nixpkgs, musl based builds currently enable `pie` hardening by default
+    # (see `defaultHardeningFlags` in `make-derivation.nix`).
+    # But GHC cannot currently produce outputs that are ready for `-pie` linking.
+    # Thus, disable `pie` hardening, otherwise `recompile with -fPIE` errors appear.
+    # See:
+    # * https://github.com/NixOS/nixpkgs/issues/129247
+    # * https://gitlab.haskell.org/ghc/ghc/-/issues/19580
+    ++ lib.optional stdenv.targetPlatform.isMusl "pie";
+
+  # big-parallel allows us to build with more than 2 cores on
+  # Hydra which already warrants a significant speedup
+  requiredSystemFeatures = [ "big-parallel" ];
+
+  postInstall = ''
+    # Install the bash completion file.
+    install -D -m 444 utils/completion/ghc.bash $out/share/bash-completion/completions/${targetPrefix}ghc
+  '';
+
+  passthru = {
+    inherit bootPkgs targetPrefix;
+
+    inherit llvmPackages;
+    inherit enableShared;
+
+    # This is used by the haskell builder to query
+    # the presence of the haddock program.
+    hasHaddock = enableHaddockProgram;
+
+    # Our Cabal compiler name
+    haskellCompilerName = "ghc-${version}";
+  };
+
+  meta = {
+    homepage = "http://haskell.org/ghc";
+    description = "The Glasgow Haskell Compiler";
+    maintainers = with lib.maintainers; [
+      guibou
+    ] ++ lib.teams.haskell.members;
+    timeout = 24 * 3600;
+    inherit (ghc.meta) license platforms;
+  };
+
+} // lib.optionalAttrs targetPlatform.useAndroidPrebuilt {
+  dontStrip = true;
+  dontPatchELF = true;
+  noAuditTmpdir = true;
+})

pkgs/development/compilers/scala/bare.nix

···
 { lib, stdenv, fetchurl, makeWrapper, jre, ncurses }:
 
 stdenv.mkDerivation rec {
-  version = "3.2.0";
+  version = "3.2.2";
   pname = "scala-bare";
 
   src = fetchurl {
     url = "https://github.com/lampepfl/dotty/releases/download/${version}/scala3-${version}.tar.gz";
-    sha256 = "sha256-GUvQMICPb8feCDv9fHUjDXGa7cIPPLdWLcZdGLShcng=";
+    hash = "sha256-t8Xt70LozePoDXE3IHejWOTWCEYcOZytRDKz/QxgmZg=";
   };
 
   propagatedBuildInputs = [ jre ncurses.dev ] ;

pkgs/development/haskell-modules/cabal2nix-unstable.nix

···
 }:
 mkDerivation {
   pname = "cabal2nix";
-  version = "unstable-2023-01-06";
+  version = "unstable-2023-02-15";
   src = fetchzip {
-    url = "https://github.com/NixOS/cabal2nix/archive/d24f4eab2352468510fb81e276aab9d62e94b561.tar.gz";
-    sha256 = "16d3mf4d622gns1myx9mwx39sx0l9wndybxn5ik00x0pxnmh7f36";
+    url = "https://github.com/NixOS/cabal2nix/archive/5cd07f1df825084fd47cf49cf49f14569859a51c.tar.gz";
+    sha256 = "1zwl5h6xqadw7fw3mkr5jljczcyrbhvi6kas19mj1wiyx6bj34yw";
   };
   postUnpack = "sourceRoot+=/cabal2nix; echo source root reset to $sourceRoot";
   isLibrary = true;

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

···
 
 self: super: {
 
+  # cabal-install needs most recent versions of Cabal and Cabal-syntax,
+  # so we need to put some extra work for non-latest GHCs
+  inherit (
+    let
+      # !!! Use cself/csuper inside for the actual overrides
+      cabalInstallOverlay = cself: csuper:
+        lib.optionalAttrs (lib.versionOlder self.ghc.version "9.4") {
+          Cabal = cself.Cabal_3_8_1_0;
+          Cabal-syntax = cself.Cabal-syntax_3_8_1_0;
+        } // lib.optionalAttrs (lib.versionOlder self.ghc.version "9.2.5") {
+          # GHC 9.2.5 starts shipping 1.6.16.0
+          process = cself.process_1_6_16_0;
+        } // lib.optionalAttrs (lib.versions.majorMinor self.ghc.version == "8.10") {
+          # Prevent dependency on doctest which causes an inconsistent dependency
+          # due to depending on ghc-8.10.7 (with bundled process) vs. process 1.6.16.0
+          vector = dontCheck csuper.vector;
+        };
+    in
+    {
+      cabal-install = super.cabal-install.overrideScope cabalInstallOverlay;
+      cabal-install-solver = super.cabal-install-solver.overrideScope cabalInstallOverlay;
+
+      guardian = lib.pipe
+        # Needs cabal-install >= 3.8 /as well as/ matching Cabal
+        (super.guardian.overrideScope (self: super:
+          cabalInstallOverlay self super // {
+            # Needs at least path-io 1.8.0 due to canonicalizePath changes
+            path-io = self.path-io_1_8_0;
+          }
+        ))
+        [
+          # Tests need internet access (run stack)
+          dontCheck
+          # May as well…
+          (self.generateOptparseApplicativeCompletions [ "guardian" ])
+        ];
+    }
+  ) cabal-install
+    cabal-install-solver
+    guardian
+  ;
+
+
   # There are numerical tests on random data, that may fail occasionally
   lapack = dontCheck super.lapack;
 
···
   ghc-datasize = disableLibraryProfiling super.ghc-datasize;
   ghc-vis = disableLibraryProfiling super.ghc-vis;
 
+  # patat main branch has an unreleased commit that fixes the build by
+  # relaxing restrictive upper boundaries. This can be removed once there's a
+  # new release following version 0.8.8.0.
+  patat = appendPatch (fetchpatch {
+    url = "https://github.com/jaspervdj/patat/commit/be9e0fe5642ba6aa7b25705ba17950923e9951fa.patch";
+    sha256 = "sha256-Vxxi46qrkIyzYQZ+fe1vNTPldcQEI2rX2H40GvFJR2M=";
+    excludes = ["stack.yaml" "stack.yaml.lock"];
+  }) super.patat;
+
   # The latest release on hackage has an upper bound on containers which
   # breaks the build, though it works with the version of containers present
   # and the upper bound doesn't exist in code anymore:
···
   wai-cors = dontCheck super.wai-cors;
 
   # 2022-01-29: Tests fail: https://github.com/psibi/streamly-bytestring/issues/27
-  streamly-bytestring = dontCheck super.streamly-bytestring;
+  # 2022-02-14: Strict upper bound: https://github.com/psibi/streamly-bytestring/issues/30
+  streamly-bytestring = dontCheck (doJailbreak super.streamly-bytestring);
 
   # base bound
   digit = doJailbreak super.digit;
···
     testToolDepends = drv.testToolDepends or [] ++ [ pkgs.git ];
   }) (super.sensei.override {
     hspec = self.hspec_2_10_9;
-    hspec-wai = super.hspec-wai.override {
+    hspec-wai = self.hspec-wai.override {
       hspec = self.hspec_2_10_9;
     };
+    hspec-contrib = self.hspec-contrib.override {
+      hspec-core = self.hspec-core_2_10_9;
+    };
+    fsnotify = self.fsnotify_0_4_1_0;
   });
 
   # Depends on broken fluid.
···
   # https://github.com/hslua/hslua/issues/106
   hslua-core = if pkgs.stdenv.hostPlatform.isMusl then dontCheck super.hslua-core else super.hslua-core;
 
+  # Missing files required by the test suite.
+  # https://github.com/deemp/flakes/issues/4
+  lima = dontCheck super.lima;
+
   # The test suite runs for 20+ minutes on a very fast machine, which feels kinda disproportionate.
   prettyprinter = dontCheck super.prettyprinter;
 
···
   # Test suite requires database
   persistent-mysql = dontCheck super.persistent-mysql;
   persistent-postgresql =
+    # TODO: move this override to configuration-nix.nix
     overrideCabal
       (drv: {
         postPatch = drv.postPath or "" + ''
···
           sed -i test/PgInit.hs \
             -e s^'host=" <> host <> "'^^
         '';
-        # https://github.com/NixOS/nixpkgs/issues/198495
-        doCheck = pkgs.postgresql.doCheck;
+        doCheck =
+          # https://github.com/commercialhaskell/stackage/issues/6884
+          # persistent-postgresql-2.13.5.1 needs persistent-test >= 2.13.1.3 which
+          # is incompatible with the stackage version of persistent, so the tests
+          # are disabled temporarily.
+          false
+          # https://github.com/NixOS/nixpkgs/issues/198495
+          && pkgs.postgresql.doCheck;
         preCheck = drv.preCheck or "" + ''
           PGDATABASE=test
           PGUSER=test
···
         ];
       })
       super.persistent-postgresql;
+
+  # Test suite requires a later version of persistent-test which depends on persistent 2.14
+  # https://github.com/commercialhaskell/stackage/issues/6884
+  persistent-sqlite = dontCheck super.persistent-sqlite;
 
   # 2021-12-26: Too strict bounds on doctest
   polysemy-plugin = doJailbreak super.polysemy-plugin;
···
       relative = "llvm-hs-pure";
       excludes = [ "**/Triple.hs" ]; # doesn't exist in 9.0.0
     })
-  ] super.llvm-hs-pure;
+  ] (overrideCabal {
+    # Hackage Revision prevents patch from applying. Revision 1 does not allow
+    # bytestring-0.11.4 which is bundled with 9.2.6.
+    editedCabalFile = null;
+    revision = null;
+  } super.llvm-hs-pure);
 
   # * Fix build failure by picking patch from 8.5, we need
   #   this version of sbv for petrinizer
···
   # 2022-11-15: Needs newer witch package and brick 1.3 which in turn works with text-zipper 0.12
   # Other dependencies are resolved with doJailbreak for both swarm and brick_1_3
   swarm = doJailbreak (super.swarm.override {
-    brick = doJailbreak (dontCheck super.brick_1_3);
+    brick = doJailbreak (dontCheck super.brick_1_6);
   });
+
+  # Too strict upper bound on bytestring
+  # https://github.com/TravisWhitaker/rdf/issues/8
+  rdf = doJailbreak super.rdf;
 
   # random <1.2
   unfoldable = doJailbreak super.unfoldable;

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

···
     darwin.apple_sdk.frameworks.ApplicationServices
   ] super.apecs-physics;
 
+  # Framework deps are hidden behind a flag
+  hmidi = addExtraLibraries [
+    darwin.apple_sdk.frameworks.CoreFoundation
+    darwin.apple_sdk.frameworks.CoreAudio
+    darwin.apple_sdk.frameworks.CoreMIDI
+  ] super.hmidi;
+
   # "erf table" test fails on Darwin
   # https://github.com/bos/math-functions/issues/63
   math-functions = dontCheck super.math-functions;

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

···
   # still the case when updating: https://gitlab.haskell.org/ghc/ghc/-/blob/0198841877f6f04269d6050892b98b5c3807ce4c/ghc.mk#L463
   xhtml = if self.ghc.hasHaddock or true then null else self.xhtml_3000_2_2_1;
 
-  # cabal-install needs most recent versions of Cabal and Cabal-syntax
-  cabal-install = super.cabal-install.overrideScope (self: super: {
-    Cabal = self.Cabal_3_8_1_0;
-    Cabal-syntax = self.Cabal-syntax_3_8_1_0;
-    process = self.process_1_6_16_0;
-    # Prevent dependency on doctest which causes an inconsistent dependency
-    # due to depending on ghc-8.10.7 (with bundled process) vs. process 1.6.16.0
-    vector = dontCheck super.vector;
-  });
-  cabal-install-solver = super.cabal-install-solver.overrideScope (self: super: {
-    Cabal = self.Cabal_3_8_1_0;
-    Cabal-syntax = self.Cabal-syntax_3_8_1_0;
-    process = self.process_1_6_16_0;
-  });
-
   # Additionally depends on OneTuple for GHC < 9.0
   base-compat-batteries = addBuildDepend self.OneTuple super.base-compat-batteries;
 
···
   # ghc versions which don’t match the ghc-lib-parser-ex version need the
   # additional dependency to compile successfully.
   ghc-lib-parser-ex = addBuildDepend self.ghc-lib-parser super.ghc-lib-parser-ex;
+
+  # Needs to use ghc-lib due to incompatible GHC
+  ghc-tags = doDistribute (addBuildDepend self.ghc-lib self.ghc-tags_1_5);
 
   # Jailbreak to fix the build.
   base-noprelude = doJailbreak super.base-noprelude;

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

···
   # This build needs a newer version of Cabal.
   cabal2spec = super.cabal2spec.override { Cabal = self.Cabal_3_2_1_0; };
 
-  # cabal-install needs most recent versions of Cabal and Cabal-syntax
-  cabal-install = super.cabal-install.overrideScope (self: super: {
-    Cabal = self.Cabal_3_8_1_0;
-    Cabal-syntax = self.Cabal-syntax_3_8_1_0;
-    process = self.process_1_6_16_0;
-  });
-  cabal-install-solver = super.cabal-install-solver.overrideScope (self: super: {
-    Cabal = self.Cabal_3_8_1_0;
-    Cabal-syntax = self.Cabal-syntax_3_8_1_0;
-    process = self.process_1_6_16_0;
-  });
-
   # Additionally depends on OneTuple for GHC < 9.0
   base-compat-batteries = addBuildDepend self.OneTuple super.base-compat-batteries;
 
···
 
   hlint = self.hlint_3_2_8;
 
-  ghc-lib-parser = self.ghc-lib-parser_8_10_7_20220219;
+  ghc-lib-parser = doDistribute self.ghc-lib-parser_8_10_7_20220219;
+  ghc-lib = doDistribute self.ghc-lib_8_10_7_20220219;
 
   # ghc versions which don’t match the ghc-lib-parser-ex version need the
   # additional dependency to compile successfully.
-  ghc-lib-parser-ex = addBuildDepend self.ghc-lib-parser self.ghc-lib-parser-ex_8_10_0_24;
+  ghc-lib-parser-ex = doDistribute (addBuildDepend self.ghc-lib-parser self.ghc-lib-parser-ex_8_10_0_24);
 
   # has a restrictive lower bound on Cabal
   fourmolu = doJailbreak super.fourmolu;

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

···
   # still the case when updating: https://gitlab.haskell.org/ghc/ghc/-/blob/0198841877f6f04269d6050892b98b5c3807ce4c/ghc.mk#L463
   xhtml = if self.ghc.hasHaddock or true then null else self.xhtml_3000_2_2_1;
 
-  # cabal-install needs the latest/matching versions of Cabal-syntax and Cabal
-  cabal-install = super.cabal-install.overrideScope (self: super: {
-    Cabal = self.Cabal_3_8_1_0;
-    Cabal-syntax = self.Cabal-syntax_3_8_1_0;
-    process = self.process_1_6_16_0;
-  });
-  cabal-install-solver = super.cabal-install-solver.overrideScope (self: super: {
-    Cabal = self.Cabal_3_8_1_0;
-    Cabal-syntax = self.Cabal-syntax_3_8_1_0;
-    process = self.process_1_6_16_0;
-  });
-
   # Jailbreaks & Version Updates
 
   # This `doJailbreak` can be removed once the following PR is released to Hackage:
···
     # Apply this here and not in common, because other ghc versions offer different Cabal versions.
     Cabal = lself.Cabal_3_6_3_0;
   }));
+
+  # Needs to use ghc-lib due to incompatible GHC
+  ghc-tags = doDistribute (addBuildDepend self.ghc-lib self.ghc-tags_1_5);
 
   # This package is marked as unbuildable on GHC 9.2, so hackage2nix doesn't include any dependencies.
   # See https://github.com/NixOS/nixpkgs/pull/205902 for why we use `self.<package>.scope`

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

···
   # still the case when updating: https://gitlab.haskell.org/ghc/ghc/-/blob/0198841877f6f04269d6050892b98b5c3807ce4c/ghc.mk#L463
   xhtml = if self.ghc.hasHaddock or true then null else self.xhtml_3000_2_2_1;
 
-  # cabal-install needs most recent versions of Cabal and Cabal-syntax
-  cabal-install = super.cabal-install.overrideScope (self: super: {
-    Cabal = self.Cabal_3_8_1_0;
-    Cabal-syntax = self.Cabal-syntax_3_8_1_0;
-    process = self.process_1_6_16_0;
-  });
-  cabal-install-solver = super.cabal-install-solver.overrideScope (self: super: {
-    Cabal = self.Cabal_3_8_1_0;
-    Cabal-syntax = self.Cabal-syntax_3_8_1_0;
-    process = self.process_1_6_16_0;
-  });
-
   # weeder == 2.5.* requires GHC 9.4
   weeder = doDistribute self.weeder_2_4_1;
 
···
   # For -fghc-lib see cabal.project in haskell-language-server.
   stylish-haskell = enableCabalFlag "ghc-lib" super.stylish-haskell;
 
+  # Needs to match ghc version
+  ghc-tags = doDistribute self.ghc-tags_1_5;
+
   # For "ghc-lib" flag see https://github.com/haskell/haskell-language-server/issues/3185#issuecomment-1250264515
   hlint = enableCabalFlag "ghc-lib" super.hlint;
 
···
 
   # 2022-08-01: Tests are broken on ghc 9.2.4: https://github.com/wz1000/HieDb/issues/46
   hiedb = dontCheck super.hiedb;
+
+  # Too strict upper bound on bytestring, relevant for GHC 9.2.6 specifically
+  # https://github.com/protolude/protolude/issues/127#issuecomment-1428807874
+  protolude = doJailbreak super.protolude;
 
   # https://github.com/fpco/inline-c/pull/131
   inline-c-cpp =

pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml

···
   - bitx-bitcoin
   - bizzlelude-js
   - bkr
+  - blagda
   - blakesum
   - blas
   - blaze-html-hexpat
···
   - brick-dropdownmenu
   - brick-filetree
   - bricks-internal
+  - brick-tabular-list
   - brillig
   - brittany
   - broadcast-chan-tests
···
   - byline
   - by-other-names
   - bytearray-parsing
+  - bytepatch
   - bytestring-aeson-orphans
   - bytestring-arbitrary
   - bytestring-class
···
   - hquantlib-time
   - hquery
   - hR
+  - h-raylib
   - hreq-core
   - hRESP
   - h-reversi
···
   - hwhile
   - hw-json-demo
   - hw-json-lens
+  - hw-json-simd
   - hworker
   - hw-playground-linear
   - hw-prim-bits
···
   - LATS
   - launchdarkly-server-sdk
   - launchpad-control
+  - lawful-classes-hedgehog
   - lawless-concurrent-machines
   - layers
   - layout
···
   - ml-w
   - mm2
   - mmsyn2
+  - mmsyn4
   - mmsyn7l
   - mmsyn7ukr-array
+  - mmsyn7ukr-common
   - mmtf
   - mmtl
   - Mobile-Legends-Hack-Cheats
···
   - monoid-owns
   - monoidplus
   - monoids
+  - monoid-statistics
   - monopati
   - monus
   - monzo
···
   - PasswordGenerator
   - passwords
   - pasta
+  - pasta-curves
   - pastis
   - pasty
-  - patat
   - patches-vector
   - Pathfinder
   - pathfindingcore
···
   - process-leksah
   - process-listlike
   - processmemory
+  - process-sequential
   - procrastinating-variable
   - procstat
   - product-isomorphic
···
   - QuickAnnotate
   - quickbooks
   - quickcheck-arbitrary-template
+  - quickcheck-groups
   - quickcheck-monoid-subclasses
   - quickcheck-property-comb
   - quickcheck-property-monad
···
   - records
   - records-sop
   - record-wrangler
+  - recover-rtti
   - recursors
   - red-black-record
   - redis-glob
···
   - yoda
   - Yogurt
   - youtube
+  - yst
   - yu-auth
   - yu-core
   - yuiGrid

pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml

···
   - bower-json == 1.0.0.1               # 2022-05-21: Needed for spago 0.20.9
   - brick == 0.70.*                     # 2022-08-13: needed by matterhorn-50200.17.0
   - brick-skylighting < 1.0             # 2022-08-13: needed by matterhorn-50200.17.0 to match brick
-  - brick == 1.3                        # 2022-11-03: needed by swarm 0.2.0.0
   - brittany == 0.13.1.2                # 2022-09-20: needed for hls on ghc 8.8
   - cabal-install-parsers < 0.5         # 2022-08-31: required by haskell-ci 0.14.3
   - crackNum < 3.0                      # 2021-05-21: 3.0 removed the lib which sbv 7.13 uses
···
   - commonmark-extensions < 0.2.3.3     # 2022-12-17: required by emanote 1.0.0.0 (to avoid a bug in 0.2.3.3)
   - ShellCheck == 0.8.0                 # 2022-12-28: required by haskell-ci 0.14.3
   - retrie < 1.2.0.0                    # 2022-12-30: required for hls on ghc < 9.2
+  - ghc-tags == 1.5.*                   # 2023-02-18: preserve for ghc-lib == 9.2.*
 
 package-maintainers:
   abbradar:
···
     - wstunnel
   gridaphobe:
     - located-base
+  iblech:
+    - Agda
   ivanbrennan:
     - xmonad
     - xmonad-contrib

pkgs/development/haskell-modules/configuration-hackage2nix/stackage.yaml

···
-# Stackage LTS 20.8
+# Stackage LTS 20.11
 # This file is auto-generated by
 # maintainers/scripts/haskell/update-stackage.sh
 default-package-overrides:
···
   - acid-state ==0.16.1.1
   - action-permutations ==0.0.0.1
   - active ==0.2.0.16
-  - ad ==4.5.2
+  - ad ==4.5.3
   - ad-delcont ==0.3.0.0
   - adjunctions ==4.4.2
   - adler32 ==0.1.2.0
···
   - aeson-value-parser ==0.19.7
   - aeson-yak ==0.1.1.3
   - aeson-yaml ==1.1.0.1
-  - Agda ==2.6.2.2
   - agda2lagda ==0.2021.6.1
   - airship ==0.9.5
   - al ==0.1.4.2
···
   - aura ==3.2.9
   - authenticate ==1.3.5.1
   - authenticate-oauth ==1.7
-  - autodocodec ==0.2.0.2
+  - autodocodec ==0.2.0.3
   - autodocodec-openapi3 ==0.2.1.1
   - autodocodec-schema ==0.1.0.3
   - autodocodec-yaml ==0.2.0.3
···
   - cacophony ==0.10.1
   - cairo ==0.13.8.2
   - calendar-recycling ==0.0.0.1
-  - call-alloy ==0.4.0.1
+  - call-alloy ==0.4.0.2
   - calligraphy ==0.1.3
   - call-plantuml ==0.0.1.1
   - call-stack ==0.4.0
···
   - colour ==2.3.6
   - columnar ==1.0.0.0
   - combinatorial ==0.1.0.1
-  - comfort-array ==0.5.2
+  - comfort-array ==0.5.2.1
   - comfort-array-shape ==0.0
   - comfort-fftw ==0.0
   - comfort-graph ==0.0.3.2
···
   - convertible ==1.1.1.1
   - cookie ==0.4.6
   - copr-api ==0.1.0
-  - core-data ==0.3.8.0
-  - core-program ==0.6.1.1
-  - core-telemetry ==0.2.7.0
+  - core-data ==0.3.9.0
+  - core-program ==0.6.3.0
+  - core-telemetry ==0.2.7.3
   - core-text ==0.3.8.0
   - countable ==1.2
   - country ==0.2.3
···
   - cryptohash-md5 ==0.11.101.0
   - cryptohash-sha1 ==0.11.101.0
   - cryptohash-sha256 ==0.11.102.1
-  - cryptohash-sha512 ==0.11.101.0
+  - cryptohash-sha512 ==0.11.102.0
   - cryptonite ==0.30
   - cryptonite-conduit ==0.2.2
   - cryptonite-openssl ==0.7
···
   - deriving-aeson ==0.2.9
   - deriving-compat ==0.6.2
   - detour-via-sci ==1.0.0
-  - df1 ==0.4
+  - df1 ==0.4.1
   - dhall ==1.41.2
   - dhall-bash ==1.0.40
   - dhall-json ==1.7.11
···
   - dictionary-sharing ==0.1.0.0
   - di-df1 ==1.2.1
   - Diff ==0.4.1
-  - digest ==0.0.1.4
+  - digest ==0.0.1.5
   - digits ==0.3.1
   - di-handle ==1.0.1
   - dimensional ==1.5
···
   - doldol ==0.4.1.2
   - do-list ==1.0.1
   - domain ==0.1.1.4
-  - domain-aeson ==0.1
+  - domain-aeson ==0.1.1
   - domain-cereal ==0.1
   - domain-core ==0.1.0.3
   - domain-optics ==0.1.0.3
···
   - elf ==0.31
   - eliminators ==0.9
   - elm2nix ==0.3.0
-  - elm-bridge ==0.8.1
+  - elm-bridge ==0.8.2
   - elm-core-sources ==1.0.0
   - elm-export ==0.6.0.1
   - elynx ==0.7.1.0
···
   - fakepull ==0.3.0.2
   - faktory ==1.1.2.4
   - fasta ==0.10.4.2
-  - fast-logger ==3.1.1
+  - fast-logger ==3.1.2
   - fast-math ==1.0.2
   - fb ==2.1.1.1
   - fclabels ==2.0.5.1
···
   - generic-aeson ==0.2.0.14
   - generic-arbitrary ==1.0.1
   - generic-constraints ==1.1.1.1
-  - generic-data ==1.0.0.0
+  - generic-data ==1.0.0.1
   - generic-data-surgery ==0.3.0.0
   - generic-deriving ==1.14.2
   - generic-functor ==1.1.0.0
···
   - genvalidity-vector ==1.0.0.0
   - geodetics ==0.1.2
   - geojson ==4.1.0
-  - getopt-generics ==0.13.0.4
+  - getopt-generics ==0.13.1.0
   - ghc-bignum-orphans ==0.1.1
   - ghc-byteorder ==4.11.0.0.10
   - ghc-check ==0.5.0.8
···
   - ghci-hexcalc ==0.1.1.0
   - ghcjs-codemirror ==0.0.0.2
   - ghcjs-perch ==0.3.3.3
-  - ghc-lib ==9.2.5.20221107
-  - ghc-lib-parser ==9.2.5.20221107
+  - ghc-lib ==9.2.6.20230211
+  - ghc-lib-parser ==9.2.6.20230211
   - ghc-lib-parser-ex ==9.2.0.4
   - ghc-parser ==0.2.4.0
   - ghc-paths ==0.1.0.12
···
   - hamtsolo ==1.0.4
   - HandsomeSoup ==0.4.2
   - handwriting ==0.1.0.3
-  - happstack-hsp ==7.3.7.6
-  - happstack-jmacro ==7.0.12.4
+  - happstack-hsp ==7.3.7.7
+  - happstack-jmacro ==7.0.12.5
   - happstack-server ==7.7.2
   - happstack-server-tls ==7.2.1.3
-  - happy ==1.20.0
+  - happy ==1.20.1.1
   - happy-meta ==0.2.0.11
-  - harp ==0.4.3.5
+  - harp ==0.4.3.6
   - HasBigDecimal ==0.2.0.0
   - hasbolt ==0.1.6.2
   - hashable ==1.4.2.0
···
   - hasql-migration ==0.3.0
   - hasql-notifications ==0.2.0.3
   - hasql-optparse-applicative ==0.5
-  - hasql-pool ==0.8.0.6
+  - hasql-pool ==0.8.0.7
   - hasql-queue ==1.2.0.2
   - hasql-th ==0.4.0.18
   - hasql-transaction ==1.0.1.2
···
   - hourglass ==0.2.12
   - hourglass-orphans ==0.1.0.0
   - hp2pretty ==0.10
-  - hpack ==0.35.1
+  - hpack ==0.35.2
   - hpack-dhall ==0.5.7
   - hpc-codecov ==0.3.0.0
   - hpc-lcov ==1.1.0
···
   - hslua-packaging ==2.2.1
   - hsndfile ==0.8.0
   - hsndfile-vector ==0.5.2
-  - HsOpenSSL ==0.11.7.4
+  - HsOpenSSL ==0.11.7.5
   - HsOpenSSL-x509-system ==0.1.0.4
   - hsp ==0.10.0
   - hspec ==2.9.7
   - hspec-attoparsec ==0.1.0.2
   - hspec-checkers ==0.1.0.2
-  - hspec-contrib ==0.5.1.1
+  - hspec-contrib ==0.5.2
   - hspec-core ==2.9.7
   - hspec-discover ==2.9.7
   - hspec-expectations ==0.8.2
···
   - hstatistics ==0.3.1
   - HStringTemplate ==0.8.8
   - HSvm ==0.1.1.3.25
-  - hsx2hs ==0.14.1.10
+  - hsx2hs ==0.14.1.11
   - hsx-jmacro ==7.3.8.2
   - HsYAML ==0.2.1.1
   - HsYAML-aeson ==0.2.0.1
···
   - http-directory ==0.1.10
   - http-download ==0.2.0.0
   - httpd-shed ==0.4.1.1
-  - http-io-streams ==0.1.6.1
+  - http-io-streams ==0.1.6.2
   - http-link-header ==1.2.1
   - http-media ==0.8.0.0
   - http-query ==0.1.3
···
   - keep-alive ==0.2.1.0
   - keycode ==0.2.2
   - keys ==3.12.3
-  - ki ==1.0.0.1
+  - ki ==1.0.0.2
   - kind-apply ==0.3.2.1
   - kind-generics ==0.4.1.4
   - kind-generics-th ==0.2.2.3
   - ki-unlifted ==1.0.0.1
   - kleene ==0.1
   - kmeans ==0.1.3
-  - knob ==0.2.1
+  - knob ==0.2.2
   - koji ==0.0.2
   - l10n ==0.1.0.1
   - labels ==0.3.3
···
   - magic ==1.1
   - mainland-pretty ==0.7.1
   - main-tester ==0.2.0.1
-  - managed ==1.0.9
+  - managed ==1.0.10
   - mandrill ==0.5.6.0
   - map-syntax ==0.3
   - markdown ==0.1.17.5
···
   - mmark-cli ==0.0.5.1
   - mmark-ext ==0.2.1.5
   - mmorph ==1.2.0
-  - mnist-idx ==0.1.3.1
+  - mnist-idx ==0.1.3.2
   - mnist-idx-conduit ==0.4.0.0
   - mockery ==0.3.5
   - mock-time ==0.1.0
···
   - monad-journal ==0.8.1
   - monadlist ==0.0.2
   - monadloc ==0.7.1
-  - monad-logger ==0.3.37
-  - monad-logger-aeson ==0.4.0.2
+  - monad-logger ==0.3.39
+  - monad-logger-aeson ==0.4.0.3
   - monad-logger-json ==0.1.0.0
   - monad-logger-logstash ==0.2.0.2
   - monad-logger-prefix ==0.1.12
···
   - monoid-extras ==0.6.2
   - monoid-subclasses ==1.1.3
   - monoid-transformer ==0.0.4
-  - monomer ==1.5.0.0
+  - monomer ==1.5.1.0
   - mono-traversable ==1.0.15.3
   - mono-traversable-instances ==0.1.1.0
   - mono-traversable-keys ==0.2.0
···
   - NumInstances ==1.4
   - numtype-dk ==0.5.0.3
   - nuxeo ==0.3.2
-  - nvim-hs ==2.3.2.0
+  - nvim-hs ==2.3.2.1
   - nvim-hs-contrib ==2.0.0.1
   - nvim-hs-ghcid ==2.0.1.0
   - oauthenticated ==0.3.0.0
···
   - path-like ==0.2.0.2
   - path-pieces ==0.2.1
   - path-text-utf8 ==0.0.1.11
-  - pathtype ==0.8.1.1
+  - pathtype ==0.8.1.2
   - path-utils ==0.1.1.0
   - pathwalk ==0.3.1.2
   - pattern-arrows ==0.0.2
···
   - pcre2 ==2.1.1.1
   - pcre-heavy ==1.0.0.3
   - pcre-light ==0.4.1.0
-  - pcre-utils ==0.1.8.2
+  - pcre-utils ==0.1.9
   - pdc ==0.1.1
   - pdf-toolbox-content ==0.1.1
   - pdf-toolbox-core ==0.1.1
···
   - persistent-documentation ==0.1.0.4
   - persistent-iproute ==0.2.5
   - persistent-mongoDB ==2.13.0.1
-  - persistent-mysql ==2.13.1.3
+  - persistent-mysql ==2.13.1.4
   - persistent-pagination ==0.1.1.2
-  - persistent-postgresql ==2.13.5.0
+  - persistent-postgresql ==2.13.5.1
   - persistent-qq ==2.12.0.2
   - persistent-redis ==2.13.0.1
   - persistent-refs ==0.4
-  - persistent-sqlite ==2.13.1.0
+  - persistent-sqlite ==2.13.1.1
   - persistent-template ==2.12.0.0
   - persistent-test ==2.13.1.2
   - persistent-typed-db ==0.1.0.7
···
   - pretty-hex ==1.1
   - prettyprinter ==1.7.1
   - prettyprinter-ansi-terminal ==1.1.3
-  - prettyprinter-combinators ==0.1.1
+  - prettyprinter-combinators ==0.1.1.1
   - prettyprinter-compat-annotated-wl-pprint ==1.1
   - prettyprinter-compat-ansi-wl-pprint ==1.0.2
   - prettyprinter-compat-wl-pprint ==1.0.1
···
   - rcu ==0.2.6
   - rdtsc ==1.3.0.1
   - re2 ==0.3
-  - reactive-banana ==1.3.1.0
+  - reactive-banana ==1.3.2.0
   - read-editor ==0.1.0.2
   - read-env-var ==1.0.0.0
   - reanimate-svg ==0.13.0.1
···
   - reform ==0.2.7.5
   - reform-blaze ==0.2.4.4
   - reform-hamlet ==0.0.5.3
-  - reform-happstack ==0.2.5.5
+  - reform-happstack ==0.2.5.6
   - reform-hsp ==0.2.7.2
   - RefSerialize ==0.4.0
   - ref-tf ==0.5.0.1
···
   - registry-hedgehog-aeson ==0.2.0.0
   - registry-options ==0.1.0.0
   - reinterpret-cast ==0.1.0
-  - rel8 ==1.4.0.0
+  - rel8 ==1.4.1.0
   - relapse ==1.0.0.1
   - reliable-io ==0.0.2
   - relude ==1.1.0.0
···
   - servant-foreign ==0.15.4
   - servant-http-streams ==0.18.4
   - servant-JuicyPixels ==0.3.1.0
-  - servant-lucid ==0.9.0.5
+  - servant-lucid ==0.9.0.6
   - servant-machines ==0.15.1
   - servant-multipart ==0.12.1
   - servant-multipart-api ==0.12.1
···
   - shelltestrunner ==1.9
   - shell-utility ==0.1
   - shellwords ==0.1.3.1
-  - shelly ==1.10.0
+  - shelly ==1.10.0.1
   - shikensu ==0.4.1
   - should-not-typecheck ==2.1.0
   - show-combinators ==0.2.0.0
···
   - skein ==1.0.9.4
   - skews ==0.1.0.3
   - skip-var ==0.1.1.0
-  - skylighting ==0.13.2
-  - skylighting-core ==0.13.2
+  - skylighting ==0.13.2.1
+  - skylighting-core ==0.13.2.1
   - skylighting-format-ansi ==0.1
   - skylighting-format-blaze-html ==0.1.1
   - skylighting-format-context ==0.1.0.1
···
   - string-random ==0.1.4.3
   - stringsearch ==0.3.6.6
   - string-transform ==1.1.1
-  - stripe-concepts ==1.0.3.1
-  - stripe-scotty ==1.1.0.2
-  - stripe-signature ==1.0.0.14
-  - stripe-wreq ==1.0.1.14
+  - stripe-concepts ==1.0.3.2
+  - stripe-scotty ==1.1.0.3
+  - stripe-signature ==1.0.0.15
+  - stripe-wreq ==1.0.1.15
   - strive ==6.0.0.4
   - strongweak ==0.3.2
-  - structs ==0.1.6
+  - structs ==0.1.7
   - structured ==0.1.1
   - structured-cli ==2.7.0.1
   - stylish-haskell ==0.14.3.0
···
   - tcp-streams ==1.0.1.1
   - tdigest ==0.2.1.1
   - teardown ==0.5.0.1
-  - telegram-bot-simple ==0.6.1
+  - telegram-bot-simple ==0.6.2
   - template ==0.2.0.10
   - template-haskell-compat-v0208 ==0.1.9.1
   - temporary ==1.3
···
   - these-lens ==1.0.1.2
   - these-optics ==1.0.1.2
   - these-skinny ==0.7.5
-  - th-expand-syns ==0.4.10.0
+  - th-expand-syns ==0.4.11.0
   - th-extras ==0.0.0.6
   - th-lego ==0.3.0.2
   - th-lift ==0.8.2
···
   - transaction ==0.1.1.3
   - transformers-base ==0.4.6
   - transformers-compat ==0.7.2
-  - transformers-either ==0.1.2
+  - transformers-either ==0.1.3
   - transformers-fix ==1.0
   - transient ==0.7.0.0
   - traverse-with-class ==1.0.1.1
···
   - type-fun ==0.1.3
   - type-hint ==0.1
   - type-level-integers ==0.0.1
-  - type-level-kv-list ==2.0.0
+  - type-level-kv-list ==2.0.2.0
   - type-level-natural-number ==2.0
   - type-level-numbers ==0.1.1.2
   - type-map ==0.1.7.0
···
   - unix-time ==0.4.8
   - unjson ==0.15.4
   - unliftio ==0.2.23.0
-  - unliftio-core ==0.2.0.1
+  - unliftio-core ==0.2.1.0
   - unliftio-path ==0.0.2.0
   - unliftio-pool ==0.2.2.0
   - unliftio-streams ==0.1.1.1
···
   - webgear-server ==1.0.4
   - webpage ==0.0.5.1
   - web-plugins ==0.4.1
-  - web-routes ==0.27.14.4
-  - web-routes-boomerang ==0.28.4.3
-  - web-routes-happstack ==0.23.12.2
+  - web-routes ==0.27.15
+  - web-routes-boomerang ==0.28.4.4
+  - web-routes-happstack ==0.23.12.3
   - web-routes-hsp ==0.24.6.2
-  - web-routes-th ==0.22.7
+  - web-routes-th ==0.22.8.1
   - web-routes-wai ==0.24.3.2
   - webrtc-vad ==0.1.0.3
   - websockets ==0.12.7.3
···
   - writer-cps-mtl ==0.1.1.6
   - writer-cps-transformers ==0.5.6.1
   - wss-client ==0.3.0.0
-  - wuss ==2.0.0.2
+  - wuss ==2.0.1.0
   - X11 ==1.10.3
   - X11-xft ==0.3.4
   - x11-xim ==0.0.9.0
···
   - xor ==0.0.1.1
   - xss-sanitize ==0.3.7.1
   - xxhash-ffi ==0.2.0.0
-  - yaml ==0.11.8.0
+  - yaml ==0.11.10.0
   - yaml-unscrambler ==0.1.0.12
   - Yampa ==0.13.7
   - yarn-lock ==0.6.5
···
   - yesod-auth ==1.6.11
   - yesod-auth-basic ==0.1.0.3
   - yesod-auth-hashdb ==1.7.1.7
-  - yesod-auth-oauth2 ==0.7.0.2
+  - yesod-auth-oauth2 ==0.7.0.3
   - yesod-bin ==1.6.2.2
-  - yesod-core ==1.6.24.0
+  - yesod-core ==1.6.24.1
   - yesod-eventsource ==1.6.0.1
   - yesod-fb ==0.6.1
-  - yesod-form ==1.7.3
+  - yesod-form ==1.7.4
   - yesod-form-bootstrap4 ==3.0.1
   - yesod-gitrepo ==0.3.0
   - yesod-gitrev ==0.2.2

pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml

···
  - array-forth
  - arraylist
  - ascii-cows
- - ascii-superset_1_2_5_0
+ - ascii-superset_1_2_7_0
  - ascii-table
  - ascii-th_1_2_0_0
- - ascii_1_5_2_0
+ - ascii_1_5_4_0
  - asic
  - asil
  - assert4hs-hspec
···
  - dobutokO3
  - dobutokO4
  - doc-review
+ - domaindriven
  - dormouse-client
  - dovetail
  - dovetail-aeson
···
  - ghc-instances
  - ghc-mod
  - ghc-session
+ - ghc-tags-pipes
  - ghc-tags-plugin
  - ghci-pretty
  - ghcjs-dom-hello
···
  - gridbounds
  - gridland
  - grisette
+ - grisette-monad-coroutine
  - groot
  - gross
  - groundhog-converters
···
  - huzzy
  - hw-all
  - hw-aws-sqs-conduit
+ - hw-json
+ - hw-json-simple-cursor
+ - hw-json-standard-cursor
  - hw-uri
  - hworker-ses
  - hwormhole

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

···
     (overrideCabal { doCheck = pkgs.postgresql.doCheck; })
   ];
 
+  # Wants running postgresql database accessible over ip, so postgresqlTestHook
+  # won't work (or would need to patch test suite).
+  domaindriven-core = dontCheck super.domaindriven-core;
+
   cachix = super.cachix.override {
     nix = self.hercules-ci-cnix-store.passthru.nixPackage;
     fsnotify = dontCheck super.fsnotify_0_4_1_0;
···
 
   # Tries to access network
   aws-sns-verify = dontCheck super.aws-sns-verify;
+
+  # Test suite requires network access
+  minicurl = dontCheck super.minicurl;
 
   # procex relies on close_range which has been introduced in Linux 5.9,
   # the test suite seems to force the use of this feature (or the fallback
···
   hint = dontCheck super.hint;
 
   # Make sure that Cabal 3.8.* can be built as-is
-  Cabal_3_8_1_0 = doDistribute (super.Cabal_3_8_1_0.override {
+  Cabal_3_8_1_0 = doDistribute (super.Cabal_3_8_1_0.override ({
     Cabal-syntax = self.Cabal-syntax_3_8_1_0;
+  } // lib.optionalAttrs (lib.versionOlder self.ghc.version "9.2.5") {
+    # Use process core package when possible
     process = self.process_1_6_16_0;
-  });
+  }));
 
   # cabal-install switched to build type simple in 3.2.0.0
   # as a result, the cabal(1) man page is no longer installed

pkgs/development/haskell-modules/hackage-packages.nix

···
   "Agda" = callPackage
     ({ mkDerivation, aeson, alex, array, async, base, binary
      , blaze-html, boxes, bytestring, Cabal, case-insensitive
-     , containers, data-hash, deepseq, directory, edit-distance, emacs
-     , equivalence, exceptions, filepath, ghc-compact, gitrev, happy
-     , hashable, hashtables, haskeline, monad-control, mtl, murmur-hash
-     , parallel, pretty, process, regex-tdfa, split, stm, strict
-     , template-haskell, text, time, transformers, unordered-containers
-     , uri-encode, zlib
+     , containers, data-hash, deepseq, directory, dlist, edit-distance
+     , emacs, equivalence, exceptions, filepath, ghc-compact, gitrev
+     , happy, hashable, haskeline, monad-control, mtl, murmur-hash
+     , parallel, pretty, process, regex-tdfa, split, stm, STMonadTrans
+     , strict, text, time, time-compat, transformers
+     , unordered-containers, uri-encode, vector, vector-hashtables, zlib
      }:
      mkDerivation {
        pname = "Agda";
-       version = "2.6.2.2";
-       sha256 = "0yjjbhc593ylrm4mq4j01nkdvh7xqsg5in30wxj4y53vf5hkggp5";
-       revision = "2";
-       editedCabalFile = "0mas4lsd093rg4w6js12cjmnz8227q5g0jhkhyrnr25jglqjz75n";
+       version = "2.6.3";
+       sha256 = "05k0insn1c2dbpddl1slcdn972j8vgkzzy870yxl43j75j0ckb5y";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
        setupHaskellDepends = [ base Cabal directory filepath process ];
        libraryHaskellDepends = [
          aeson array async base binary blaze-html boxes bytestring
-         case-insensitive containers data-hash deepseq directory
+         case-insensitive containers data-hash deepseq directory dlist
          edit-distance equivalence exceptions filepath ghc-compact gitrev
-         hashable hashtables haskeline monad-control mtl murmur-hash
-         parallel pretty process regex-tdfa split stm strict
-         template-haskell text time transformers unordered-containers
-         uri-encode zlib
+         hashable haskeline monad-control mtl murmur-hash parallel pretty
+         process regex-tdfa split stm STMonadTrans strict text time
+         time-compat transformers unordered-containers uri-encode vector
+         vector-hashtables zlib
        ];
        libraryToolDepends = [ alex happy ];
        executableHaskellDepends = [ base directory filepath process ];
        executableToolDepends = [ emacs ];
        description = "A dependently typed functional programming language and proof assistant";
        license = "unknown";
-       maintainers = [ lib.maintainers.abbradar lib.maintainers.turion ];
+       maintainers = [
+         lib.maintainers.abbradar lib.maintainers.iblech
+         lib.maintainers.turion
+       ];
      }) {inherit (pkgs) emacs;};
 
   "Agda-executable" = callPackage
···
      }:
      mkDerivation {
        pname = "BlogLiterately";
-       version = "0.8.8.1";
-       sha256 = "1jj3daw8vr11v4dlvdkd7gddkpiy484mpk8dl9zgns2wnq5ibrkj";
+       version = "0.8.8.2";
+       sha256 = "1m4l5p8qg1mqg612x43gip5gp10x4avrm36b9iw2r2ny32rvwkdy";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "Cabal";
        version = "3.8.1.0";
        sha256 = "0236fddzhalsr2gjbjsk92rgh8866fks28r04g8fbmzkqbkcnr3l";
+       revision = "1";
+       editedCabalFile = "1bah5bdjy5zxpwnzsdqibf999nirm1np8j76vr34na5vg5knrlaq";
        setupHaskellDepends = [ mtl parsec ];
        libraryHaskellDepends = [
          array base bytestring Cabal-syntax containers deepseq directory
···
        pname = "Cabal-syntax";
        version = "3.8.1.0";
        sha256 = "03yfk3b2sjmqpxmvx3mj185nifiaqapvc8hmbx4825z0kyqxvs07";
-       revision = "2";
-       editedCabalFile = "1bzwjxj5mrsxxcgrfgisamx3f3ymz5bz085k6p83s7djh39ayaxx";
+       revision = "3";
+       editedCabalFile = "14zm8h7sfawysr9g37in8by8aj1p87fywj83hmshp8n6lrxr6bgd";
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq directory filepath
          mtl parsec pretty text time transformers unix
···
     ({ mkDerivation, array, base, HUnit, pretty, QuickCheck, random }:
      mkDerivation {
        pname = "Crypto";
-       version = "4.2.5.1";
-       sha256 = "0rmgl0a4k6ys2lc6d607g28c2p443a46dla903rz5aha7m9y1mba";
-       isLibrary = true;
-       isExecutable = true;
-       enableSeparateDataOutput = true;
-       libraryHaskellDepends = [
-         array base HUnit pretty QuickCheck random
-       ];
-       description = "Collects together existing Haskell cryptographic functions into a package";
-       license = "unknown";
+       version = "4.2.5.2";
+       sha256 = "0nsv3vvlik76vdncnh771ki95903gdfsg3iyfdinm3rkhybz30m6";
+       libraryHaskellDepends = [ array base pretty random ];
+       testHaskellDepends = [ base HUnit pretty QuickCheck ];
+       description = "Common Cryptographic Algorithms in Pure Haskell";
+       license = "BSD-3-Clause AND GPL-2.0-or-later";
      }) {};
 
   "CurryDB" = callPackage
···
      }:
      mkDerivation {
        pname = "HasCacBDD";
-       version = "0.1.0.3";
-       sha256 = "04kczdr702kkqa89pm5lc3glq4xqnjy0rszpq7ms1zlj1gwvgckz";
+       version = "0.1.0.4";
+       sha256 = "093qbknl2isl91446rvrvi53vbnpiny2m0h4gl8sr48bivhilqvx";
        setupHaskellDepends = [ base Cabal directory ];
        libraryHaskellDepends = [ base process QuickCheck ];
        librarySystemDepends = [ CacBDD ];
···
     ({ mkDerivation, base, bytestring, Cabal, network, openssl, time }:
      mkDerivation {
        pname = "HsOpenSSL";
-       version = "0.11.7.4";
-       sha256 = "0zxcfa8b0ng97v53vb8fvg2gss89b28xiz83rx38a0h4lsxpn2xf";
+       version = "0.11.7.5";
+       sha256 = "0y0l5nb0jsc8lm12w66a2n7nwcrgjxy1q2xdy8a788695az5xy71";
        setupHaskellDepends = [ base Cabal ];
        libraryHaskellDepends = [ base bytestring network time ];
        librarySystemDepends = [ openssl ];
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "JuicyPixels-extra_0_6_0" = callPackage
+    ({ mkDerivation, base, criterion, hspec, hspec-discover
+     , JuicyPixels
+     }:
+     mkDerivation {
+       pname = "JuicyPixels-extra";
+       version = "0.6.0";
+       sha256 = "0scjsdf2w91rlvkx0xn55p4jjy5g29hwb11jaxw52090p1vm0a7w";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [ base JuicyPixels ];
+       testHaskellDepends = [ base hspec JuicyPixels ];
+       testToolDepends = [ hspec-discover ];
+       benchmarkHaskellDepends = [ base criterion JuicyPixels ];
+       description = "Efficiently scale, crop, flip images with JuicyPixels";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "JuicyPixels-repa" = callPackage
     ({ mkDerivation, base, bytestring, JuicyPixels, repa, vector }:
      mkDerivation {
···
        pname = "ShellCheck";
        version = "0.9.0";
        sha256 = "071k2gc8rzpg9lwq9g10c9xx0zm1wcgsf8v4n1csj9fm56vy7gmb";
+       revision = "1";
+       editedCabalFile = "0gs8q9dijsxzz6chq1gwzn34b2l2iskh72j10n47qqf598dwbjgm";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "TCache";
-       version = "0.12.1";
-       sha256 = "1gdp78v359jf9hzwdkips7z99s9lvi21vw0l88dgl9yirmgv8d7i";
+       version = "0.13.3";
+       sha256 = "0d1lwp4mfvjlrn2k96h41ijl4rs7h46hrrwxyry1bw41vinifs5q";
        libraryHaskellDepends = [
          base bytestring containers directory hashtables mtl old-time
          RefSerialize stm text
        ];
+       testHaskellDepends = [
+         base bytestring containers directory hashtables mtl old-time
+         RefSerialize stm text
+       ];
        description = "A Transactional cache with user-defined persistence";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
···
     ({ mkDerivation, base, deepseq, random, simple-affine-space }:
      mkDerivation {
        pname = "Yampa";
-       version = "0.14";
-       sha256 = "14fhg7pkvm3rjcw6v5c0jxnq2l7v3rhw1bkb3a6g1s27alar9ynl";
+       version = "0.14.1";
+       sha256 = "0q2fgm2la2xyvnpfwl163md31g0m8kb0n2cxm26nfnljnbwq3a5b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "accelerate-llvm-native";
        version = "1.3.0.0";
        sha256 = "1x4wfbp83ppzknd98k2ad160a8kdqh96qqmyfzdqyvy44iskxcn6";
+       revision = "1";
+       editedCabalFile = "1w98zxyg5zr9xbx6wzglh1agc7pf25qlxbblvvvizf9niq84bw56";
        libraryHaskellDepends = [
          accelerate accelerate-llvm base bytestring cereal containers
          deepseq directory dlist filepath ghc ghc-prim hashable libffi
···
        pname = "acid-state";
        version = "0.16.1.1";
        sha256 = "05hcbk5dhwygc29b1jbyh2zzjrxybm44hj02wmv2bhz04b5wldca";
-       revision = "2";
-       editedCabalFile = "0q3z7mxahsv8wxlcm4wzqfd49im22j6lgxxd25mdrj59hzkfr6i7";
+       revision = "3";
+       editedCabalFile = "0ky6fsq5z9kd8wfri7fh7jzpf3d7l6r9574zpb4sc1wwvq0p45rr";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "ad";
-       version = "4.5.2";
-       sha256 = "08vcp760j6ay8k9zs4qzhvirf775vhni56923jbjzdxrs9mm5167";
-       libraryHaskellDepends = [
-         adjunctions array base comonad containers data-reify erf free nats
-         reflection semigroups transformers
-       ];
-       testHaskellDepends = [ base tasty tasty-hunit ];
-       benchmarkHaskellDepends = [ base criterion erf ];
-       description = "Automatic Differentiation";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "ad_4_5_3" = callPackage
-    ({ mkDerivation, adjunctions, array, base, comonad, containers
-     , criterion, data-reify, erf, free, nats, reflection, semigroups
-     , tasty, tasty-hunit, transformers
-     }:
-     mkDerivation {
-       pname = "ad";
        version = "4.5.3";
        sha256 = "1p4r70s9xslza7ag3ifnf69ji37mkkj2gabfi1lj0fyssm0jyy5y";
        libraryHaskellDepends = [
···
        benchmarkHaskellDepends = [ base criterion erf ];
        description = "Automatic Differentiation";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ad-delcont" = callPackage
···
      }:
      mkDerivation {
        pname = "arch-hs";
-       version = "0.10.2.0";
-       sha256 = "0z0ralwh0z1zx5nf83j7cli9fdf9c9gpl99r7kiqv167kb2wiw9x";
+       version = "0.11.0.0";
+       sha256 = "0zl9lsz9bhzyd4vd61q0rkawb7iyghk9cb5pzm4gm4y9d9hayw0p";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        broken = true;
      }) {inherit (pkgs) arpack;};
 
-  "array_0_5_4_0" = callPackage
+  "array_0_5_5_0" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "array";
-       version = "0.5.4.0";
-       sha256 = "1ixqnwxd36l2j3873hwnfip17k2nzncbvsx7pnprqzv9z59mf4rv";
-       revision = "1";
-       editedCabalFile = "0y6v6mfd0y5jzskp7b6jwg1ybfirpgrppvd4zri9xccd73v1xfaa";
+       version = "0.5.5.0";
+       sha256 = "06zmbd6zlim22zfxmdzzw947nzx9g2d6yx30min6spsk54r8vcqq";
        libraryHaskellDepends = [ base ];
        description = "Mutable and immutable arrays";
        license = lib.licenses.bsd3;
···
        license = lib.licenses.asl20;
      }) {};
 
-  "ascii_1_5_2_0" = callPackage
+  "ascii_1_5_4_0" = callPackage
     ({ mkDerivation, ascii-case, ascii-caseless, ascii-char
      , ascii-group, ascii-numbers, ascii-predicates, ascii-superset
      , ascii-th, base, bytestring, hspec, text
      }:
      mkDerivation {
        pname = "ascii";
-       version = "1.5.2.0";
-       sha256 = "0j5jj23rdv6if9bzindispq2yyn9y2dmbhvxw0dqs7fdcxa7npgq";
+       version = "1.5.4.0";
+       sha256 = "1lgmdhgby6kdvsl8xg2swqvw9vzlni7s53g42jidd13iappzkxkq";
        libraryHaskellDepends = [
          ascii-case ascii-caseless ascii-char ascii-group ascii-numbers
          ascii-predicates ascii-superset ascii-th base bytestring text
···
        license = lib.licenses.asl20;
      }) {};
 
-  "ascii-superset_1_2_5_0" = callPackage
+  "ascii-superset_1_2_7_0" = callPackage
     ({ mkDerivation, ascii-case, ascii-caseless, ascii-char, base
      , bytestring, hashable, hspec, text
      }:
      mkDerivation {
        pname = "ascii-superset";
-       version = "1.2.5.0";
-       sha256 = "00i662bwrsqj34g0d9awgik2vqxxlr8y2v1xyyrhhqh5fi3s0rwk";
+       version = "1.2.7.0";
+       sha256 = "140xdw3r9aj9yhjwbvhqyb4c4scad2rfdj9kf6yh1aqf4lqvh0kn";
        libraryHaskellDepends = [
          ascii-case ascii-caseless ascii-char base bytestring hashable text
        ];
···
      }:
      mkDerivation {
        pname = "autodocodec";
-       version = "0.2.0.2";
-       sha256 = "0mmh6zb660wafizf40a96f30pswv3xyry5r0i0n17w70p3jwa14k";
+       version = "0.2.0.3";
+       sha256 = "1ihyyxj4lbk172z7wnv11ryir3d00d5jrcprqiy0q7b4gkzsn3q6";
        libraryHaskellDepends = [
          aeson base bytestring containers hashable mtl scientific text time
          unordered-containers validity validity-scientific vector
···
        mainProgram = "autoexporter";
      }) {};
 
+  "autoexporter_2_0_0_7" = callPackage
+    ({ mkDerivation, base, Cabal-syntax, directory, filepath }:
+     mkDerivation {
+       pname = "autoexporter";
+       version = "2.0.0.7";
+       sha256 = "19h4i73r06p3blza9qfkvcqp9wg7nhyif8cff6a5ky40fbqqs3gf";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base Cabal-syntax directory filepath ];
+       executableHaskellDepends = [
+         base Cabal-syntax directory filepath
+       ];
+       description = "Automatically re-export modules";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "autoexporter";
+     }) {};
+
   "autom" = callPackage
     ({ mkDerivation, base, bytestring, colour, ghc-prim, gloss
      , JuicyPixels, random, vector
···
      }:
      mkDerivation {
        pname = "aws";
-       version = "0.23";
-       sha256 = "0kfdj9hxjvziq1y74xj9mm17zcgwywpvp9c0i6gfd5malf4qxgg0";
+       version = "0.24";
+       sha256 = "0phcpmq15fn62pq2ngr6lyylqaz3cq3qdp828rcbzvsrarscy519";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "aws-lambda-haskell-runtime";
-       version = "4.1.1";
-       sha256 = "0w4pdyagcs7m05kccdq0x3s1d4vbr2ihqjrbill0p0gn25q9h6cc";
+       version = "4.1.2";
+       sha256 = "1c5m9mmkcrgz5hd1swinfcrblkmc4yg142kzlfxfcxnyray3digm";
        libraryHaskellDepends = [
          aeson base bytestring case-insensitive exceptions hashable
          http-client http-types mtl path path-io safe-exceptions-checked
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "bifunctor-classes-compat" = callPackage
+    ({ mkDerivation, base, base-orphans, tagged, transformers }:
+     mkDerivation {
+       pname = "bifunctor-classes-compat";
+       version = "0.1";
+       sha256 = "0by738hg600sf5dcbjsn9flpqn3bgam72036znxbml17rcw6xj9p";
+       libraryHaskellDepends = [ base base-orphans tagged transformers ];
+       doHaddock = false;
+       description = "Compatibility package for the Bifunctor, Bifoldable, and Bitraversable classes";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "bifunctors" = callPackage
     ({ mkDerivation, base, base-orphans, comonad, containers, hspec
      , hspec-discover, QuickCheck, tagged, template-haskell
···
        ];
        description = "Shake frontend for Agda blogging";
        license = lib.licenses.agpl3Only;
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "blagda";
+       broken = true;
      }) {};
 
   "blake2" = callPackage
···
     ({ mkDerivation, base, memory, tasty, tasty-hunit }:
      mkDerivation {
        pname = "blake3";
-       version = "0.2";
-       sha256 = "1a6pfcsdnqwr116jypzla6nvl1wzny60r5ypi2yj4gjpmpbkj8b8";
+       version = "0.3";
+       sha256 = "12hm7bd4jqxw0gqmczb9vxn99lbwawr09xwp6y7xb0fzrr97ysls";
        libraryHaskellDepends = [ base memory ];
        testHaskellDepends = [ base memory tasty tasty-hunit ];
        description = "BLAKE3 hashing algorithm";
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "brick_1_3" = callPackage
-    ({ mkDerivation, base, bimap, bytestring, config-ini, containers
-     , contravariant, data-clist, deepseq, directory, exceptions
-     , filepath, microlens, microlens-mtl, microlens-th, mtl, QuickCheck
-     , stm, template-haskell, text, text-zipper, unix, vector, vty
-     , word-wrap
-     }:
-     mkDerivation {
-       pname = "brick";
-       version = "1.3";
-       sha256 = "0lpd6685ya0va0a6n7cw70f5b1s13y8ynzac0gkxyqb1ivzj0hsb";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         base bimap bytestring config-ini containers contravariant
-         data-clist deepseq directory exceptions filepath microlens
-         microlens-mtl microlens-th mtl stm template-haskell text
-         text-zipper unix vector vty word-wrap
-       ];
-       testHaskellDepends = [
-         base containers microlens QuickCheck vector vty
-       ];
-       description = "A declarative terminal user interface library";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-     }) {};
-
   "brick" = callPackage
     ({ mkDerivation, base, bimap, bytestring, config-ini, containers
      , contravariant, data-clist, deepseq, directory, exceptions
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "brick-tabular-list" = callPackage
+    ({ mkDerivation, base, brick, containers, generic-lens, microlens
+     , optics-core, vty
+     }:
+     mkDerivation {
+       pname = "brick-tabular-list";
+       version = "0.1.0.2";
+       sha256 = "1ldzbl9wnk6ghckbxlmqs3vf1qivh7qndgy5iryasiy9bil8h9fk";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base brick containers generic-lens microlens optics-core vty
+       ];
+       description = "Tabular list widgets for brick";
+       license = lib.licenses.bsd0;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "bricks" = callPackage
     ({ mkDerivation, base, bricks-internal, bricks-internal-test
      , bricks-parsec, bricks-rendering, bricks-syntax, containers
···
        pname = "brotli";
        version = "0.0.0.1";
        sha256 = "0fp8vhqzl6i1vvb4fw4zya6cgkzmj0yaaw94jdf2kggm3gn8zwfc";
+       revision = "1";
+       editedCabalFile = "1mp8fcczfaxk2rfmaakxyrc0w9cwglj1dv9fifl3spvp6g8zcr1n";
        libraryHaskellDepends = [ base bytestring transformers ];
        libraryPkgconfigDepends = [ brotli ];
        testHaskellDepends = [
···
        pname = "brotli-streams";
        version = "0.0.0.0";
        sha256 = "14jc1nhm50razsl99d95amdf4njf75dnzx8vqkihgrgp7qisyz3z";
-       revision = "5";
-       editedCabalFile = "0fp2ysmldmq8c1jlbprky1b7dxls3vgj4n1prnd84k2d01g7ff9m";
+       revision = "6";
+       editedCabalFile = "01w72wyvfyf8d5wb88ds1m8mrk7xik8y4kzj1025jxh45li2w4dr";
        libraryHaskellDepends = [ base brotli bytestring io-streams ];
        testHaskellDepends = [
          base bytestring HUnit io-streams QuickCheck test-framework
···
        license = lib.licenses.mit;
      }) {};
 
+  "burrito_2_0_1_3" = callPackage
+    ({ mkDerivation, base, bytestring, containers, hspec, parsec
+     , QuickCheck, template-haskell, text, transformers
+     }:
+     mkDerivation {
+       pname = "burrito";
+       version = "2.0.1.3";
+       sha256 = "001j2mvrqvlycf85d1k265vz89bqzx52hlmnbjzcd0x4y6lghgry";
+       libraryHaskellDepends = [
+         base bytestring containers parsec template-haskell text
+         transformers
+       ];
+       testHaskellDepends = [
+         base bytestring containers hspec parsec QuickCheck template-haskell
+         text transformers
+       ];
+       description = "Parse and render URI templates";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "burst-detection" = callPackage
     ({ mkDerivation, base, criterion, deepseq }:
      mkDerivation {
···
        description = "Patch byte-representable data in a bytestream";
        license = lib.licenses.mit;
        platforms = lib.platforms.x86;
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "bytepatch";
        maintainers = [ lib.maintainers.raehik ];
+       broken = true;
      }) {};
 
   "bytes" = callPackage
···
      }:
      mkDerivation {
        pname = "cab";
-       version = "0.2.19";
-       sha256 = "0rn8b8fydrm8ad0va0pg016y5ph3dc0xashg0rqfjhzv8kwzlkzk";
+       version = "0.2.20";
+       sha256 = "005vpmjpxrnj84pn7qjswjrb0vzmyhid2lr923q7m4rr3bi78ac1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
 
   "cabal-cache" = callPackage
     ({ mkDerivation, aeson, amazonka, amazonka-core, amazonka-s3
-     , antiope-core, antiope-optparse-applicative, antiope-s3, base
-     , bytestring, cabal-install-parsers, containers, cryptonite
-     , deepseq, directory, exceptions, filepath, generic-lens, hedgehog
-     , hspec, hspec-discover, http-client, http-client-tls, http-types
-     , hw-hspec-hedgehog, lens, mtl, network-uri, optparse-applicative
-     , process, raw-strings-qq, relation, resourcet, stm, stringsearch
-     , temporary, text, topograph, transformers, unliftio
+     , attoparsec, base, bytestring, cabal-install-parsers
+     , conduit-extra, containers, cryptonite, deepseq, directory
+     , exceptions, filepath, generic-lens, Glob, hedgehog
+     , hedgehog-extras, hspec, hspec-discover, http-client
+     , http-client-tls, http-types, hw-hspec-hedgehog, lens, mtl
+     , network-uri, oops, optparse-applicative, process, raw-strings-qq
+     , relation, resourcet, stm, stringsearch, temporary, text, time
+     , topograph, transformers, unliftio
      }:
      mkDerivation {
        pname = "cabal-cache";
-       version = "1.0.5.4";
-       sha256 = "15jg140ly7rska7v8ihvd383q9lj4i5c18rzjad4yi8f78jjciqb";
+       version = "1.0.6.0";
+       sha256 = "0jjybnj06f8w3fh44q3mq28fvyd1v7yfbh0rrkxsikdxnhi74z9j";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         aeson amazonka amazonka-core amazonka-s3 antiope-core antiope-s3
-         base bytestring containers cryptonite deepseq directory exceptions
+         aeson amazonka amazonka-core amazonka-s3 attoparsec base bytestring
+         conduit-extra containers cryptonite deepseq directory exceptions
          filepath generic-lens http-client http-client-tls http-types lens
-         mtl network-uri optparse-applicative process relation resourcet stm
-         text topograph transformers
+         mtl network-uri oops optparse-applicative process relation
+         resourcet stm text topograph transformers
        ];
        executableHaskellDepends = [
-         aeson amazonka amazonka-core antiope-core
-         antiope-optparse-applicative base bytestring cabal-install-parsers
-         containers directory exceptions filepath generic-lens http-types
-         lens mtl optparse-applicative resourcet stm stringsearch temporary
-         text unliftio
+         aeson amazonka amazonka-core base bytestring cabal-install-parsers
+         containers directory exceptions filepath generic-lens lens mtl
+         network-uri oops optparse-applicative resourcet stm stringsearch
+         temporary text unliftio
        ];
        testHaskellDepends = [
-         aeson antiope-core base bytestring filepath hedgehog hspec
-         http-types hw-hspec-hedgehog lens network-uri raw-strings-qq text
+         aeson amazonka base bytestring directory exceptions filepath Glob
+         hedgehog hedgehog-extras hspec http-types hw-hspec-hedgehog lens
+         mtl network-uri oops raw-strings-qq text time
        ];
        testToolDepends = [ hspec-discover ];
        description = "CI Assistant for Haskell projects";
···
      }:
      mkDerivation {
        pname = "cabal-install-parsers";
-       version = "0.5";
-       sha256 = "017q4cagx3w0ww9bpilji9hiscilmg78m10ggi9ih0997hjp4l50";
+       version = "0.6";
+       sha256 = "000gw1gxgn3rr95l05fv8yliqxjn9hpdafqz9r4kr9632cn93328";
        libraryHaskellDepends = [
          aeson base base16-bytestring binary binary-instances bytestring
          Cabal-syntax containers cryptohash-sha256 deepseq directory
···
        maintainers = [ lib.maintainers.peti ];
      }) {};
 
+  "cabal2spec_2_6_4" = callPackage
+    ({ mkDerivation, base, Cabal, filepath, optparse-applicative, tasty
+     , tasty-golden, time
+     }:
+     mkDerivation {
+       pname = "cabal2spec";
+       version = "2.6.4";
+       sha256 = "01h028nm4r149niwrc0pc0pgsvkwr0vqwazv21rlxw56ikbpd6j6";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base Cabal filepath time ];
+       executableHaskellDepends = [
+         base Cabal filepath optparse-applicative
+       ];
+       testHaskellDepends = [ base Cabal filepath tasty tasty-golden ];
+       description = "Convert Cabal files into rpm spec files";
+       license = lib.licenses.gpl3Only;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "cabal2spec";
+       maintainers = [ lib.maintainers.peti ];
+     }) {};
+
   "cabalQuery" = callPackage
     ({ mkDerivation, base, Cabal, containers, directory, MissingH
      , pretty
···
 
   "call-alloy" = callPackage
     ({ mkDerivation, async, base, bytestring, containers, directory
-     , extra, filepath, hspec, mtl, process, split, transformers
-     , trifecta, unix
+     , extra, filepath, hspec, mtl, process, split, string-interpolate
+     , transformers, trifecta, unix
      }:
      mkDerivation {
        pname = "call-alloy";
-       version = "0.4.0.1";
-       sha256 = "0xxrin8n2kk37jip5hacyn87sxhwz4bjk6crd90yw8f1sg8n354m";
+       version = "0.4.0.2";
+       sha256 = "0kazmpc2969640n5qnsks2ndw522ag71fiqp5anmzfb75mxfr5zv";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          async base bytestring containers directory extra filepath mtl
···
        ];
        testHaskellDepends = [
          async base bytestring containers directory extra filepath hspec mtl
-         process split transformers trifecta unix
+         process split string-interpolate transformers trifecta unix
        ];
        description = "A simple library to call Alloy given a specification";
        license = lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "capnp";
-       version = "0.16.0.0";
-       sha256 = "1pxg8l5lahx8j1wayq665s2as29zpfmjh0kn3962awxj376fhrwf";
+       version = "0.17.0.0";
+       sha256 = "0qs914mnka65qlji1jirgyrnr4qb08qb7mkacm9h09713dz91acw";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "cassava";
        version = "0.5.3.0";
        sha256 = "1gp954w05bj83z4i6isq2qxi1flqwppsgxxrp1f75mrs8cglbj5l";
+       revision = "1";
+       editedCabalFile = "1lavd2c7w2p2x4i7h35r8kgcgrrlhcql70zk5vgqv5ll04pp0niy";
        configureFlags = [ "-f-bytestring--lt-0_10_4" ];
        libraryHaskellDepends = [
          array attoparsec base bytestring containers deepseq hashable Only
···
      }:
      mkDerivation {
        pname = "cassava-conduit";
-       version = "0.6.0";
-       sha256 = "114ab0kxy7rj1hps1sy9i0mkj2lp046zjlpll2apmf3mxdminva0";
+       version = "0.6.1";
+       sha256 = "11nwn090x1b39vl0l9vbsphf5qlp4cxz6q1lrp0qqq1dvq9q1642";
        libraryHaskellDepends = [
          array base bifunctors bytestring cassava conduit containers mtl
          text
···
        testToolDepends = [ lima ];
        description = "Declaratively describe spreadsheets";
        license = lib.licenses.bsd3;
-     }) {inherit (pkgs) lima;};
+     }) {};
 
   "cless" = callPackage
     ({ mkDerivation, base, highlighting-kate, optparse-applicative
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "cli-arguments";
-       version = "0.6.0.0";
-       sha256 = "0vg5xmdg84bv6bab03iv9zj0i1vkp9xlfjbm1rpzjjhpihp8v5sg";
+       version = "0.7.0.0";
+       sha256 = "13l72n6n34zgv6cj9k7vimh3n0gc7vgrw12il7nvb87wg0cjm1wn";
        libraryHaskellDepends = [ base ];
        description = "A library to process command line arguments in some more convenient way";
        license = lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "codeworld-api";
-       version = "0.8.0";
-       sha256 = "0iaiw3gngpg2cwm0pgckn9vb0hjm7xm8szsii0k2s4d8fkl4k5rv";
+       version = "0.8.1";
+       sha256 = "1gpm33pv2c1cbvwi253f3ksrjaxlrhzwwsvlzp84x8834801lkl3";
        libraryHaskellDepends = [
          aeson base base64-bytestring blank-canvas bytestring cereal
          cereal-text containers deepseq dependent-sum ghc-prim hashable
···
        pname = "colonnade";
        version = "1.2.0.2";
        sha256 = "1asjx71gp26a15v7g3p8bfddb5nnzky6672c35xx35hq73mhykr4";
-       revision = "4";
-       editedCabalFile = "0425ag47i8llirh6jdy11mqilr6bdq0nzcx4yfha2n57qpx1gkjs";
+       revision = "5";
+       editedCabalFile = "1f4m7lqksb7lvzs3j5v8c04l2mmq7pq1d8w7p8y9chy595rrb1kn";
        libraryHaskellDepends = [
          base bytestring contravariant profunctors semigroups text vector
        ];
···
      }:
      mkDerivation {
        pname = "comfort-array";
-       version = "0.5.2";
-       sha256 = "0rpv9mn1jmkb9f89y02zfg2vwz4slzny31yjrvwcm43jhdyvzkwh";
+       version = "0.5.2.1";
+       sha256 = "01vijksddhqmypikk0kgsw02fqdp3anvxvvmhimw11kg87n5dy7v";
        libraryHaskellDepends = [
          base containers deepseq guarded-allocation non-empty prelude-compat
          primitive QuickCheck semigroups storable-record storablevector
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "containers_0_6_6" = callPackage
+  "containers_0_6_7" = callPackage
     ({ mkDerivation, array, base, deepseq, template-haskell }:
      mkDerivation {
        pname = "containers";
-       version = "0.6.6";
-       sha256 = "1s1a1d8hvlgarmajf3p8ars1cqxyaw1ncmw0793g7m82y78hw6dq";
+       version = "0.6.7";
+       sha256 = "0x684l54zpz2xh8jqyc1q107aggf9v3a5vz9cmgcx9l8bvyfy5l5";
        libraryHaskellDepends = [ array base deepseq template-haskell ];
        description = "Assorted concrete container types";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "core-data";
-       version = "0.3.8.0";
-       sha256 = "16gkll00awgb0l5mdpxd33f3szgvfsbwxlh3nkj1jsdkjrir4ggc";
+       version = "0.3.9.0";
+       sha256 = "126z21i4f7z7pf415jjqjd4ik6sb9kid1dgrlc2yzq2vd4wdi9gg";
        libraryHaskellDepends = [
          aeson base bytestring containers core-text hashable hourglass
          prettyprinter scientific text time unordered-containers uuid vector
···
        license = lib.licenses.mit;
      }) {};
 
-  "core-data_0_3_9_0" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, containers, core-text
-     , hashable, hourglass, prettyprinter, scientific, text, time
-     , unordered-containers, uuid, vector
+  "core-effect-effectful" = callPackage
+    ({ mkDerivation, base, core-data, core-program, core-text
+     , effectful-core
      }:
      mkDerivation {
-       pname = "core-data";
-       version = "0.3.9.0";
-       sha256 = "126z21i4f7z7pf415jjqjd4ik6sb9kid1dgrlc2yzq2vd4wdi9gg";
+       pname = "core-effect-effectful";
+       version = "0.0.0.4";
+       sha256 = "1an8x6kjxp00slxqhvizyh7j3i6irain0xbv4ic7y5csqj5lqy6f";
        libraryHaskellDepends = [
-         aeson base bytestring containers core-text hashable hourglass
-         prettyprinter scientific text time unordered-containers uuid vector
+         base core-data core-program core-text effectful-core
        ];
-       description = "Convenience wrappers around common data structures and encodings";
+       description = "Interoperability with the effectful effects system";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "core-haskell" = callPackage
···
      , exceptions, filepath, fsnotify, hashable, hourglass, mtl
      , prettyprinter, safe-exceptions, stm, template-haskell
      , terminal-size, text, text-short, transformers, typed-process
-     , unix
+     , unix, unliftio-core
      }:
      mkDerivation {
        pname = "core-program";
-       version = "0.6.1.1";
-       sha256 = "1qc9acs4jcrs80677fkd42h7nzwx8n7falrnxjsqpslh6i900hzc";
+       version = "0.6.3.0";
+       sha256 = "1jd1733f2yn9bsbj5p4y62gqjlzdykpj5yaisd82s28lijqrqi02";
        libraryHaskellDepends = [
          base bytestring core-data core-text directory exceptions filepath
          fsnotify hashable hourglass mtl prettyprinter safe-exceptions stm
          template-haskell terminal-size text text-short transformers
-         typed-process unix
+         typed-process unix unliftio-core
        ];
        description = "Opinionated Haskell Interoperability";
        license = lib.licenses.mit;
      }) {};
 
-  "core-program_0_6_2_1" = callPackage
+  "core-program_0_6_5_0" = callPackage
     ({ mkDerivation, base, bytestring, core-data, core-text, directory
      , exceptions, filepath, fsnotify, hashable, hourglass, mtl
      , prettyprinter, safe-exceptions, stm, template-haskell
···
      }:
      mkDerivation {
        pname = "core-program";
-       version = "0.6.2.1";
-       sha256 = "13dxd290479aam366g5dcwhqpp3mxxzdcmn86c85197m2darrkhv";
+       version = "0.6.5.0";
+       sha256 = "0xbvwivby27dky11nhs0szs9dbs5mlivspbkvrflja30kaa7lqam";
        libraryHaskellDepends = [
          base bytestring core-data core-text directory exceptions filepath
          fsnotify hashable hourglass mtl prettyprinter safe-exceptions stm
···
      }:
      mkDerivation {
        pname = "core-telemetry";
-       version = "0.2.7.0";
-       sha256 = "148ij7rdnjh4fl84b8r20vffm0564afj101zn7xkji653fv1ha0s";
+       version = "0.2.7.3";
+       sha256 = "1lini012vrpxn947l5aa7wjjqny9mxzvmhpzkmvpmc72cmqhfcjw";
        libraryHaskellDepends = [
          base bytestring core-data core-program core-text exceptions
          http-streams io-streams mtl network-info random safe-exceptions
···
     ({ mkDerivation, base, containers, directory, parallel }:
      mkDerivation {
        pname = "cpsa";
-       version = "4.4.1";
-       sha256 = "14g31626g72qljbrds08cpx670v2zgis05z3nkd5b7lim99ibhfh";
+       version = "4.4.2";
+       sha256 = "0yrrrwm69j3k0fwcdrhdzq49zin4jqn5xcl603dr9zfaxfrjw4js";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
      }:
      mkDerivation {
        pname = "cryptohash-sha512";
-       version = "0.11.101.0";
-       sha256 = "0a6sc5b6w0k47fyjhyrfm3p25jsbsqjknfq5mbj53p2p1qsfykc1";
-       revision = "1";
-       editedCabalFile = "1mjbn84bg9r3m1dcfpmmalck2wdfdm4i8wrqfi624mbaqs8a0fqs";
+       version = "0.11.102.0";
+       sha256 = "0b48qwgyn68rfbq4fh6fmsk1kc07n8qq95217n8gjnlzvsh2395z";
        libraryHaskellDepends = [ base bytestring ];
        testHaskellDepends = [
          base base16-bytestring bytestring SHA tasty tasty-hunit
···
      }:
      mkDerivation {
        pname = "deriving-trans";
-       version = "0.6.1.0";
-       sha256 = "0zkl41kyq7s6gm37y4cwjim7b65fa2vmxqxfsmm9p5r6pkrn46d7";
+       version = "0.8.0.0";
+       sha256 = "10i7lhpdpy68mi2ax5v445hy39m160jvvxqhz3hb4ixgzhibdi0h";
        libraryHaskellDepends = [
          base exceptions monad-control monad-control-identity mtl primitive
          random resourcet transformers transformers-base unliftio-core
···
      }:
      mkDerivation {
        pname = "df1";
-       version = "0.4";
-       sha256 = "0adsmfjfcxsg55y4pahw408b82bi7phyzq48vrf80p84nyxmmpsi";
+       version = "0.4.1";
+       sha256 = "0fz9krv450kn4qymgggcgfkmrxgzcsgcbwbbfw2cqa0rvslw71g8";
        libraryHaskellDepends = [
          attoparsec base bytestring containers text time
        ];
···
        pname = "dhall";
        version = "1.41.2";
        sha256 = "14m5rrvkid76qnvg0l14xw1mnqclhip3gjrz20g1lp4fd5p056ka";
-       revision = "4";
-       editedCabalFile = "0innb3cn98ynb8bd83jdyrm64ij7wcvajg5qcwzdwbyzpr62anfx";
+       revision = "5";
+       editedCabalFile = "0jhhwzzinlxyb2gxr2jcyr71mbdig7njkw2zi8znns1ik6ix0d4c";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
     ({ mkDerivation, base, bytestring, zlib }:
      mkDerivation {
        pname = "digest";
-       version = "0.0.1.4";
-       sha256 = "05pc5l4bwddszc6vy1hazwi1dnrxg323521gdkis9cvh7zs2a4gr";
-       revision = "1";
-       editedCabalFile = "1x9wr09q0rx0v4lc1f3a3mq2md412bq6zhhyvs5njffb7bi8mpdi";
-       libraryHaskellDepends = [ base bytestring ];
-       libraryPkgconfigDepends = [ zlib ];
-       description = "Various hashes for bytestrings; CRC32 and Adler32 for now";
-       license = lib.licenses.bsd3;
-     }) {inherit (pkgs) zlib;};
-
-  "digest_0_0_1_5" = callPackage
-    ({ mkDerivation, base, bytestring, zlib }:
-     mkDerivation {
-       pname = "digest";
        version = "0.0.1.5";
        sha256 = "1lpj16hazg8yh2rxspc1y7da9vgmz6jw9fx9qrvwv1hzmv8mvnvv";
        libraryHaskellDepends = [ base bytestring ];
        libraryPkgconfigDepends = [ zlib ];
        description = "Various hashes for bytestrings; CRC32 and Adler32 for now";
        license = lib.licenses.bsd2;
-       hydraPlatforms = lib.platforms.none;
      }) {inherit (pkgs) zlib;};
 
   "digest-pure" = callPackage
···
      }:
      mkDerivation {
        pname = "digraph";
-       version = "0.2.2";
-       sha256 = "1v7mayj3cjr1gl27d5fzgghrwk08d87da9ckyk5l7ksjqf6d4px7";
+       version = "0.3.0";
+       sha256 = "0p70978qy83xz14drzk874zghjh3jybgw9a4fp1cfrmpmbdms5df";
        libraryHaskellDepends = [
          base containers deepseq hashable massiv mwc-random streaming
          transformers unordered-containers
···
        mainProgram = "doctest";
      }) {};
 
+  "doctest_0_21_0" = callPackage
+    ({ mkDerivation, base, base-compat, code-page, deepseq, directory
+     , exceptions, filepath, ghc, ghc-paths, hspec, hspec-core
+     , hspec-discover, HUnit, mockery, process, QuickCheck, setenv
+     , silently, stringbuilder, syb, transformers
+     }:
+     mkDerivation {
+       pname = "doctest";
+       version = "0.21.0";
+       sha256 = "0jb4vjwx3xqmcm563g1j8fz1kp5irwwb141xp46c25x108wpnmay";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base base-compat code-page deepseq directory exceptions filepath
+         ghc ghc-paths process syb transformers
+       ];
+       executableHaskellDepends = [
+         base base-compat code-page deepseq directory exceptions filepath
+         ghc ghc-paths process syb transformers
+       ];
+       testHaskellDepends = [
+         base base-compat code-page deepseq directory exceptions filepath
+         ghc ghc-paths hspec hspec-core HUnit mockery process QuickCheck
+         setenv silently stringbuilder syb transformers
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Test interactive Haskell examples";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "doctest";
+     }) {};
+
   "doctest-discover" = callPackage
     ({ mkDerivation, aeson, base, bytestring, directory, doctest
      , filepath
···
        pname = "doctest-exitcode-stdio";
        version = "0.0";
        sha256 = "1g3c7yrqq2mwqbmvs8vkx1a3cf0p0x74b7fnn344dsk7bsfpgv0x";
-       revision = "1";
-       editedCabalFile = "1065s8bch6zhl6mc8nhvfpwd1irmjd04z7xgycbpihc14x4ijim3";
+       revision = "2";
+       editedCabalFile = "0gfnxkbm126m0d4pnqgl5ca6ab8x5p1vpbxjxgz1sxczablsmk5b";
        libraryHaskellDepends = [
          base doctest-lib QuickCheck semigroups transformers
        ];
···
        pname = "doctest-extract";
        version = "0.1";
        sha256 = "1ncrq67d6zcqw5al5m2g7q6ys8rxhsq8rrzbj1dlsyl4q63vyrms";
-       revision = "1";
-       editedCabalFile = "11b43xx6bmn7zbw9hxjcfcbmhjsm1jbnh08qnfxiw9i02j12mnlj";
+       revision = "3";
+       editedCabalFile = "1gmydr5gabjp7vnf8knxr8d97cx1wm85n2dmxj7529l05qhia9j6";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }) {};
 
   "domain-aeson" = callPackage
-    ({ mkDerivation, aeson, base, domain, domain-core, rerebase
-     , template-haskell, template-haskell-compat-v0208, text, th-lego
+    ({ mkDerivation, aeson, base, domain, domain-core
+     , generic-arbitrary, hspec, quickcheck-classes
+     , quickcheck-instances, rerebase, template-haskell
+     , template-haskell-compat-v0208, text, th-lego
      , unordered-containers, vector
      }:
      mkDerivation {
        pname = "domain-aeson";
-       version = "0.1";
-       sha256 = "08kc4j9bs2nmkd7ddnygw9rjm25z6js1y9fmhisc5kjhf26cbwm2";
+       version = "0.1.1";
+       sha256 = "1kfkxgqzyvbwlapi5dn7zzz4v7hcjqihhj9rw9hyrflvw2axvqkq";
        libraryHaskellDepends = [
          aeson base domain-core template-haskell
          template-haskell-compat-v0208 text th-lego unordered-containers
          vector
        ];
-       testHaskellDepends = [ domain rerebase ];
+       testHaskellDepends = [
+         domain generic-arbitrary hspec quickcheck-classes
+         quickcheck-instances rerebase
+       ];
        description = "Integration of domain with aeson";
        license = lib.licenses.mit;
      }) {};
···
        broken = true;
      }) {};
 
+  "domaindriven" = callPackage
+    ({ mkDerivation, aeson, async, base, bytestring, containers
+     , deepseq, domaindriven-core, exceptions, generic-lens, hspec
+     , http-client, http-types, microlens, mtl, openapi3
+     , postgresql-simple, QuickCheck, quickcheck-arbitrary-adt
+     , quickcheck-classes, random, servant-client, servant-server
+     , streamly, template-haskell, text, time, transformers, unliftio
+     , unliftio-pool, unordered-containers, uuid, vector, warp
+     }:
+     mkDerivation {
+       pname = "domaindriven";
+       version = "0.5.0";
+       sha256 = "1h0yy6alf30gza466nhz8zzfm3xjzqi4m157hz57qr295iqv9wcl";
+       libraryHaskellDepends = [
+         aeson async base bytestring containers deepseq domaindriven-core
+         exceptions generic-lens http-types microlens mtl openapi3
+         postgresql-simple random servant-server streamly template-haskell
+         text time transformers unliftio unliftio-pool unordered-containers
+         uuid vector
+       ];
+       testHaskellDepends = [
+         aeson async base containers deepseq domaindriven-core exceptions
+         hspec http-client mtl openapi3 QuickCheck quickcheck-arbitrary-adt
+         quickcheck-classes servant-client servant-server text warp
+       ];
+       description = "Batteries included event sourcing and CQRS";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "domaindriven-core" = callPackage
+    ({ mkDerivation, aeson, async, base, bytestring, containers
+     , deepseq, exceptions, generic-lens, hspec, http-types, microlens
+     , mtl, postgresql-simple, random, streamly, template-haskell, time
+     , transformers, unliftio, unliftio-pool, unordered-containers, uuid
+     , vector
+     }:
+     mkDerivation {
+       pname = "domaindriven-core";
+       version = "0.5.0";
+       sha256 = "177xb2kpq14g3dhs56lzjknx9vkzgzc4wxmlh9rqzbybqdn4ppx7";
+       libraryHaskellDepends = [
+         aeson async base bytestring containers deepseq exceptions
+         generic-lens http-types microlens mtl postgresql-simple random
+         streamly template-haskell time transformers unliftio unliftio-pool
+         unordered-containers uuid vector
+       ];
+       testHaskellDepends = [
+         aeson base hspec postgresql-simple streamly time unliftio-pool uuid
+       ];
+       description = "Batteries included event sourcing and CQRS";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "dominion" = callPackage
     ({ mkDerivation, base, containers, hspec, lens, mtl, random }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "ebml";
-       version = "0.1.0.0";
-       sha256 = "0v0mf7l3fmdyr5981r3n7k4g1mh3nanl9qnsm87zdwpwkfhik7hq";
+       version = "0.1.1.0";
+       sha256 = "1zp7chyyjs24jvckiw12ra7r0gyslfvnc5ksm47djja852j00v7s";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base binary bytestring containers text ];
···
      }:
      mkDerivation {
        pname = "elm-bridge";
-       version = "0.8.1";
-       sha256 = "0qhxjgjmbs2gr43rzxhzr6hjygkjr7fiqka93vsfi13hpv6bw2p7";
+       version = "0.8.2";
+       sha256 = "15nwxz2v678l26hapmphs1aqmnmx89r5j1mf3iys86n73qp3vfjl";
        libraryHaskellDepends = [ aeson base template-haskell ];
        testHaskellDepends = [
          aeson base containers hspec QuickCheck text
···
     ({ mkDerivation, aeson, aeson-extra, aeson-optics, async, base
      , blaze-html, bytestring, commonmark, commonmark-extensions
      , commonmark-pandoc, commonmark-simple, commonmark-wikilink
-     , containers, data-default, dependent-sum, directory, ema, filepath
-     , filepattern, fsnotify, hedgehog, heist, heist-extra, hspec
-     , hspec-hedgehog, ixset-typed, lvar, map-syntax, megaparsec
-     , monad-logger, monad-logger-extras, mtl, neat-interpolation
-     , optics-core, optics-th, optparse-applicative, pandoc
-     , pandoc-link-context, pandoc-types, parsec, path-tree
+     , containers, data-default, dependent-sum, deriving-aeson
+     , directory, ema, filepath, filepattern, fsnotify, hedgehog, heist
+     , heist-extra, hspec, hspec-hedgehog, ixset-typed, lvar, map-syntax
+     , megaparsec, monad-logger, monad-logger-extras, mtl
+     , neat-interpolation, optics-core, optics-th, optparse-applicative
+     , pandoc, pandoc-link-context, pandoc-types, parsec, path-tree
      , process-extras, profunctors, relude, shower, some, stm, tagged
      , tagtree, tailwind, text, time, tomland, unionmount, unliftio
      , unordered-containers, uri-encode, url-slug, uuid, which
···
      }:
      mkDerivation {
        pname = "emanote";
-       version = "1.0.0.0";
-       sha256 = "0yysrrcdgp06d0s50am86xzjp4d67d1in5ibwdpvbv9knxnk8w5v";
+       version = "1.0.2.0";
+       sha256 = "0g6mla1izms1i4l08kzg0js56gz54z87458k0k3w7fnj5f1576y7";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
          aeson aeson-extra aeson-optics async base blaze-html bytestring
          commonmark commonmark-extensions commonmark-pandoc
          commonmark-simple commonmark-wikilink containers data-default
-         dependent-sum directory ema filepath filepattern fsnotify hedgehog
-         heist heist-extra hspec hspec-hedgehog ixset-typed lvar map-syntax
-         megaparsec monad-logger monad-logger-extras mtl neat-interpolation
-         optics-core optics-th optparse-applicative pandoc
-         pandoc-link-context pandoc-types parsec path-tree process-extras
-         profunctors relude shower some stm tagged tagtree tailwind text
-         time tomland unionmount unliftio unordered-containers uri-encode
-         url-slug uuid which with-utf8 xmlhtml yaml
+         dependent-sum deriving-aeson directory ema filepath filepattern
+         fsnotify hedgehog heist heist-extra hspec hspec-hedgehog
+         ixset-typed lvar map-syntax megaparsec monad-logger
+         monad-logger-extras mtl neat-interpolation optics-core optics-th
+         optparse-applicative pandoc pandoc-link-context pandoc-types parsec
+         path-tree process-extras profunctors relude shower some stm tagged
+         tagtree tailwind text time tomland unionmount unliftio
+         unordered-containers uri-encode url-slug uuid which with-utf8
+         xmlhtml yaml
        ];
        executableHaskellDepends = [
          aeson aeson-extra aeson-optics async base blaze-html bytestring
          commonmark commonmark-extensions commonmark-pandoc
          commonmark-simple commonmark-wikilink containers data-default
-         dependent-sum directory ema filepath filepattern fsnotify hedgehog
-         heist heist-extra hspec hspec-hedgehog ixset-typed lvar map-syntax
-         megaparsec monad-logger monad-logger-extras mtl neat-interpolation
-         optics-core optics-th optparse-applicative pandoc
-         pandoc-link-context pandoc-types parsec path-tree process-extras
-         profunctors relude shower some stm tagged tagtree tailwind text
-         time tomland unionmount unliftio unordered-containers uri-encode
-         url-slug uuid which with-utf8 xmlhtml yaml
+         dependent-sum deriving-aeson directory ema filepath filepattern
+         fsnotify hedgehog heist heist-extra hspec hspec-hedgehog
+         ixset-typed lvar map-syntax megaparsec monad-logger
+         monad-logger-extras mtl neat-interpolation optics-core optics-th
+         optparse-applicative pandoc pandoc-link-context pandoc-types parsec
+         path-tree process-extras profunctors relude shower some stm tagged
+         tagtree tailwind text time tomland unionmount unliftio
+         unordered-containers uri-encode url-slug uuid which with-utf8
+         xmlhtml yaml
        ];
        testHaskellDepends = [
          aeson aeson-extra aeson-optics async base blaze-html bytestring
          commonmark commonmark-extensions commonmark-pandoc
          commonmark-simple commonmark-wikilink containers data-default
-         dependent-sum directory ema filepath filepattern fsnotify hedgehog
-         heist heist-extra hspec hspec-hedgehog ixset-typed lvar map-syntax
-         megaparsec monad-logger monad-logger-extras mtl neat-interpolation
-         optics-core optics-th optparse-applicative pandoc
-         pandoc-link-context pandoc-types parsec path-tree process-extras
-         profunctors relude shower some stm tagged tagtree tailwind text
-         time tomland unionmount unliftio unordered-containers uri-encode
-         url-slug uuid which with-utf8 xmlhtml yaml
+         dependent-sum deriving-aeson directory ema filepath filepattern
+         fsnotify hedgehog heist heist-extra hspec hspec-hedgehog
+         ixset-typed lvar map-syntax megaparsec monad-logger
+         monad-logger-extras mtl neat-interpolation optics-core optics-th
+         optparse-applicative pandoc pandoc-link-context pandoc-types parsec
+         path-tree process-extras profunctors relude shower some stm tagged
+         tagtree tailwind text time tomland unionmount unliftio
+         unordered-containers uri-encode url-slug uuid which with-utf8
+         xmlhtml yaml
        ];
        description = "Emanate a structured view of your plain-text notes";
        license = lib.licenses.agpl3Only;
···
      }:
      mkDerivation {
        pname = "fast-logger";
-       version = "3.1.1";
-       sha256 = "1rx866swvqq7lzngv4bx7qinnwmm3aa2la8caljvbfbi0xz6wps3";
-       revision = "1";
-       editedCabalFile = "012rrm13hnaz06ssy7m8z36l8aajayd9pbk19q042wrfwsvb7jjl";
+       version = "3.1.2";
+       sha256 = "1l0h4ddb17xm6qkjhn5gqyfz18szyqcq9wqq92fc24sp2zbd7rv5";
        libraryHaskellDepends = [
          array auto-update base bytestring directory easy-file filepath text
          unix-compat unix-time
···
        testToolDepends = [ hspec-discover ];
        description = "A fast logging system";
        license = lib.licenses.bsd3;
+       maintainers = [ lib.maintainers.sternenseemann ];
+     }) {};
+
+  "fast-logger_3_2_0" = callPackage
+    ({ mkDerivation, array, async, auto-update, base, bytestring
+     , directory, easy-file, filepath, hspec, hspec-discover, stm, text
+     , unix-compat, unix-time
+     }:
+     mkDerivation {
+       pname = "fast-logger";
+       version = "3.2.0";
+       sha256 = "1f0ac7b3irmc4967jrbjnkh8y89gdv57r6vv7m6fkbbjxyyp4nqp";
+       libraryHaskellDepends = [
+         array auto-update base bytestring directory easy-file filepath stm
+         text unix-compat unix-time
+       ];
+       testHaskellDepends = [ async base bytestring directory hspec ];
+       testToolDepends = [ hspec-discover ];
+       description = "A fast logging system";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
        maintainers = [ lib.maintainers.sternenseemann ];
      }) {};
 
···
        pname = "feed";
        version = "1.3.2.1";
        sha256 = "0marh7qmggq1z5339nid3gil7k786d3yk79b0rwfkxxaxmr41xd8";
+       revision = "1";
+       editedCabalFile = "032578cqdl7c7ibmbn92z6b72r8yvnwlhxwnr709pzdjc9qd4ghr";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base base-compat bytestring old-locale old-time safe text time
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "fgl_5_8_1_0" = callPackage
+  "fgl_5_8_1_1" = callPackage
     ({ mkDerivation, array, base, containers, deepseq, hspec
      , microbench, QuickCheck, transformers
      }:
      mkDerivation {
        pname = "fgl";
-       version = "5.8.1.0";
-       sha256 = "0s53kxz6a79jclvxlzpmzs2x98qx48xvgwswh6cal2f4rg2wp8av";
+       version = "5.8.1.1";
+       sha256 = "1bccd85756nk09hgv6h52k4vkxw2xdqbk5m20g8q6301rdpgs239";
        libraryHaskellDepends = [
          array base containers deepseq transformers
        ];
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "filters-basic";
-       version = "0.1.1.0";
-       sha256 = "09q6fb8cv7di67wb8zhky8qpbwivzax59xik1zbcjf3sp465a337";
+       version = "0.2.0.0";
+       sha256 = "18kn8m2fdib16kabs8fax0skac2ipwqwbf0xqzqnrfdjmvhsqbgq";
        libraryHaskellDepends = [ base ];
        description = "Allows to change the structure of the function output";
        license = lib.licenses.mit;
···
        license = lib.licenses.mit;
      }) {};
 
+  "flatparse_0_4_0_1" = callPackage
+    ({ mkDerivation, attoparsec, base, bytestring, containers, gauge
+     , hspec, HUnit, integer-gmp, megaparsec, parsec, primitive
+     , QuickCheck, quickcheck-instances, template-haskell, utf8-string
+     }:
+     mkDerivation {
+       pname = "flatparse";
+       version = "0.4.0.1";
+       sha256 = "0cv9ip5vh6sw039acpghcanlnyrvfrmd3av1ihbf66w7y0qv1h40";
+       libraryHaskellDepends = [
+         base bytestring containers integer-gmp template-haskell utf8-string
+       ];
+       testHaskellDepends = [
+         base bytestring hspec HUnit QuickCheck quickcheck-instances
+         utf8-string
+       ];
+       benchmarkHaskellDepends = [
+         attoparsec base bytestring gauge integer-gmp megaparsec parsec
+         primitive utf8-string
+       ];
+       description = "High-performance parsing from strict bytestrings";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "flay" = callPackage
     ({ mkDerivation, base, constraints, tasty, tasty-quickcheck
      , transformers
···
        license = lib.licenses.mit;
      }) {};
 
+  "flow_2_0_0_2" = callPackage
+    ({ mkDerivation, base, HUnit }:
+     mkDerivation {
+       pname = "flow";
+       version = "2.0.0.2";
+       sha256 = "15z2hl2mg0ifj0rpinwy0s9v1kbwgpp0m87w4sfyljqw34388rvq";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base HUnit ];
+       description = "Write more understandable Haskell";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "flow-er" = callPackage
     ({ mkDerivation, base, doctest, flow, QuickCheck }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "fontconfig-pure";
-       version = "0.1.0.0";
-       sha256 = "0rnx9s5kj5lr70gp4454qy3h4lfndf9f976h331jp0f4y47c2d42";
+       version = "0.1.1.1";
+       sha256 = "1fj74g8hpdd8gqf937l3spnkasqsbgc1qxw6zxmv1cfz86r4fmn4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "functor-combinators";
-       version = "0.4.1.0";
-       sha256 = "1b7324ia810i1rjn2z4q3h7rcbbvmfh3nl8vxswgnkglhrkcmg49";
+       version = "0.4.1.2";
+       sha256 = "18b7whmsy1bqmqpyva4wipaakjbg8c3zi30pxlh44jw2cwf91c7j";
        libraryHaskellDepends = [
          assoc base bifunctors comonad constraints containers contravariant
          deriving-compat free hashable invariant kan-extensions mmorph mtl
···
      , prettyprinter-ansi-terminal, process, process-extras, QuickCheck
      , random, regex-tdfa, srcloc, statistics, tasty, tasty-hunit
      , tasty-quickcheck, template-haskell, temporary, terminal-size
-     , text, time, transformers, vector, versions, zip-archive, zlib
+     , text, time, transformers, vector, versions, zlib
      }:
      mkDerivation {
        pname = "futhark";
-       version = "0.22.7";
-       sha256 = "0vld3wms8y3bzl7m8lvc6xlcxq80ipi7rfk1wkfjddzzqg5gmnl7";
+       version = "0.23.1";
+       sha256 = "0si4si74d8y9dgsqiixj6cfblpr2l02dwijbngwv5xdyfpbdfgq6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          neat-interpolation parallel prettyprinter
          prettyprinter-ansi-terminal process process-extras random
          regex-tdfa srcloc statistics template-haskell temporary
-         terminal-size text time transformers vector versions zip-archive
-         zlib
+         terminal-size text time transformers vector versions zlib
        ];
        libraryToolDepends = [ alex happy ];
        executableHaskellDepends = [ base ];
···
      }:
      mkDerivation {
        pname = "generic-data";
-       version = "1.0.0.0";
-       sha256 = "1cfax93wzb9w3lfhrp4lmyyqxj6cjvsjny8wv3qxjyfqs2w2380g";
+       version = "1.0.0.1";
+       sha256 = "0fz65k4sxn9c23rg5iv0vij2mksl5rkn6dl2f3i9d9d60b5wca9y";
        libraryHaskellDepends = [
          ap-normalize base base-orphans contravariant ghc-boot-th
          show-combinators
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "generic-persistence" = callPackage
+    ({ mkDerivation, base, bytestring, convertible, exceptions, ghc
+     , ghc-prim, HDBC, HDBC-sqlite3, hspec, hspec-discover, QuickCheck
+     , rio, syb, text, time, transformers
+     }:
+     mkDerivation {
+       pname = "generic-persistence";
+       version = "0.2.0.1";
+       sha256 = "1i50bdywfrlfqz1by8x3ci2nap5c1hl2bvhw5h2ych7szrp9mmp7";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring convertible exceptions ghc ghc-prim HDBC
+         HDBC-sqlite3 rio syb text time transformers
+       ];
+       executableHaskellDepends = [
+         base bytestring convertible exceptions ghc ghc-prim HDBC
+         HDBC-sqlite3 rio syb text time transformers
+       ];
+       testHaskellDepends = [
+         base bytestring convertible exceptions ghc ghc-prim HDBC
+         HDBC-sqlite3 hspec hspec-discover QuickCheck rio syb text time
+         transformers
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Database persistence using generics";
+       license = lib.licenses.bsd3;
+       mainProgram = "generic-persistence-demo";
+     }) {};
+
   "generic-pretty" = callPackage
     ({ mkDerivation, ansi-wl-pprint, base, bytestring, containers
      , tasty, tasty-hunit, text, vector
···
      }:
      mkDerivation {
        pname = "getopt-generics";
-       version = "0.13.0.4";
-       sha256 = "1rszkcn1rg38wf35538ljk5bbqjc57y9sb3a0al7qxm82gy8yigr";
-       libraryHaskellDepends = [
-         base base-compat base-orphans generics-sop tagged
-       ];
-       testHaskellDepends = [
-         base base-compat base-orphans filepath generics-sop hspec
-         QuickCheck safe silently tagged
-       ];
-       description = "Create command line interfaces with ease";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "getopt-generics_0_13_1_0" = callPackage
-    ({ mkDerivation, base, base-compat, base-orphans, filepath
-     , generics-sop, hspec, QuickCheck, safe, silently, tagged
-     }:
-     mkDerivation {
-       pname = "getopt-generics";
        version = "0.13.1.0";
        sha256 = "00xswyi9y49qab2fpkdx7isx40kfa93p3gfransivzgg9m3si37d";
        libraryHaskellDepends = [
···
        ];
        description = "Create command line interfaces with ease";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "getopt-simple" = callPackage
···
        pname = "ghc-byteorder";
        version = "4.11.0.0.10";
        sha256 = "1dhzd7ygwm7b3hsrlm48iq4p634laby4hf7c8i7xp0c1g64hmrc6";
-       revision = "3";
-       editedCabalFile = "088rz5c0pq2r1w3msy0y9hl4gca8s8nblpcz7w2f5sx5pajg8flj";
+       revision = "4";
+       editedCabalFile = "0jc4d4is49d6ddxpdkyqkpr464y80ydsb57shqndp08assplj93b";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base ];
        doHaddock = false;
···
      }:
      mkDerivation {
        pname = "ghc-lib";
-       version = "9.2.5.20221107";
-       sha256 = "0layv7zsjlah3dmr538g34pg7cwwiawg0xcihyjxdh2x5q5qi05s";
+       version = "9.2.6.20230211";
+       sha256 = "1f0sf922yh5n8057c14vs362pka7kq0c6h87kmarmrz8mjp19c37";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq directory
···
      }:
      mkDerivation {
        pname = "ghc-lib-parser";
-       version = "9.2.5.20221107";
-       sha256 = "1xh8rm5lwbh96g4v34whkcbb1yjsyvx3rwwycj30lrglhqk7f4c4";
+       version = "9.2.6.20230211";
+       sha256 = "0q0n9nsi8hxd9pjsrn7vdkwrjvsig8100dd1w5v7hka2dryffi6z";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq directory
···
        pname = "ghc-paths";
        version = "0.1.0.12";
        sha256 = "1164w9pqnf7rjm05mmfjznz7rrn415blrkk1kjc0gjvks1vfdjvf";
-       revision = "4";
-       editedCabalFile = "1d5za4k498q48wk6cz0jm3d68rh5ldz6adr8vp24nn7jv17g770w";
+       revision = "5";
+       editedCabalFile = "12y71qx0yjxxjjzvkpx12ld0fkmpkli8qxpfxp3xfnz8w0gxbv9c";
        setupHaskellDepends = [ base Cabal directory ];
        libraryHaskellDepends = [ base ];
        description = "Knowledge of GHC's installation directories";
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "ghc-tags" = callPackage
+  "ghc-tags_1_5" = callPackage
     ({ mkDerivation, aeson, async, attoparsec, base, bytestring
      , containers, deepseq, directory, filepath, ghc, ghc-boot
      , ghc-paths, optparse-applicative, process, stm, temporary, text
···
        ];
        description = "Utility for generating ctags and etags with GHC API";
        license = lib.licenses.mpl20;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "ghc-tags";
+     }) {};
+
+  "ghc-tags" = callPackage
+    ({ mkDerivation, aeson, async, attoparsec, base, bytestring
+     , containers, deepseq, directory, filepath, ghc-lib, ghc-paths
+     , optparse-applicative, process, stm, temporary, text, time, vector
+     , yaml
+     }:
+     mkDerivation {
+       pname = "ghc-tags";
+       version = "1.6";
+       sha256 = "0iiqapx4v4jz4d7ni4dcvpfl948ydx2a7kxvjsk2irdcknzymblw";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         aeson async attoparsec base bytestring containers deepseq directory
+         filepath ghc-lib ghc-paths optparse-applicative process stm
+         temporary text time vector yaml
+       ];
+       description = "Utility for generating ctags and etags with GHC API";
+       license = lib.licenses.mpl20;
        mainProgram = "ghc-tags";
      }) {};
 
   "ghc-tags-core" = callPackage
-    ({ mkDerivation, attoparsec, base, bytestring, containers
-     , criterion, deepseq, directory, filepath, filepath-bytestring, ghc
-     , lattices, mtl, pipes, pipes-attoparsec, pipes-bytestring
-     , QuickCheck, quickcheck-instances, tasty, tasty-golden
-     , tasty-quickcheck, text, transformers
+    ({ mkDerivation, attoparsec, base, bytestring, containers, deepseq
+     , filepath-bytestring, ghc, text
      }:
      mkDerivation {
        pname = "ghc-tags-core";
-       version = "0.4.2.2";
-       sha256 = "1mp1c5jvvbmypjh45nnvlkvqrj4hj55pcb9f42qwv5xw4yan86m1";
+       version = "0.5.0.0";
+       sha256 = "1qcxwqf8sqxsm8wnvs4518s4wxlbnsjbv10nbs5sv3kcsgjf67ws";
        libraryHaskellDepends = [
-         attoparsec base bytestring containers deepseq directory
-         filepath-bytestring ghc mtl pipes pipes-attoparsec pipes-bytestring
-         text transformers
-       ];
-       testHaskellDepends = [
-         attoparsec base bytestring directory filepath filepath-bytestring
-         lattices mtl pipes QuickCheck quickcheck-instances tasty
-         tasty-golden tasty-quickcheck text
-       ];
-       benchmarkHaskellDepends = [
-         base bytestring criterion deepseq filepath-bytestring mtl pipes
-         pipes-attoparsec pipes-bytestring text
+         attoparsec base bytestring containers deepseq filepath-bytestring
+         ghc text
        ];
        description = "a library to work with tags created from Haskell parsed tree";
        license = lib.licenses.mpl20;
···
        broken = true;
      }) {};
 
+  "ghc-tags-pipes" = callPackage
+    ({ mkDerivation, attoparsec, base, bytestring, filepath-bytestring
+     , ghc-tags-core, mtl, pipes, pipes-attoparsec, pipes-bytestring
+     , text
+     }:
+     mkDerivation {
+       pname = "ghc-tags-pipes";
+       version = "0.1.0.0";
+       sha256 = "1xyv0bh055xvcdv50mchyars505nq5g3xiv62kw701djch7jlvpf";
+       libraryHaskellDepends = [
+         attoparsec base bytestring filepath-bytestring ghc-tags-core mtl
+         pipes pipes-attoparsec pipes-bytestring text
+       ];
+       description = "Streaming interface for ghc-tags-core";
+       license = lib.licenses.mpl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "ghc-tags-plugin" = callPackage
     ({ mkDerivation, base, bytestring, directory, filepath
-     , filepath-bytestring, ghc, ghc-tags-core, lukko, mtl
-     , optparse-applicative, pipes, pipes-attoparsec, pipes-bytestring
-     , pipes-safe, text
+     , filepath-bytestring, ghc, ghc-tags-core, ghc-tags-pipes, lukko
+     , mtl, optparse-applicative, pipes, pipes-bytestring, pipes-safe
+     , text
      }:
      mkDerivation {
        pname = "ghc-tags-plugin";
-       version = "0.5.2.0";
-       sha256 = "1n8b3xsyji5p1w1wrpwscp71mhnh4y6i9v881wml4s49fp6rv3dj";
+       version = "0.5.3.0";
+       sha256 = "03s7f5x0s88dld85c51mbk0azs6cip0w55hkhidh5wwsvspr19h1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          base bytestring directory filepath filepath-bytestring ghc
-         ghc-tags-core lukko mtl optparse-applicative pipes pipes-attoparsec
+         ghc-tags-core ghc-tags-pipes lukko mtl optparse-applicative pipes
          pipes-bytestring pipes-safe text
        ];
        description = "A compiler plugin which generates tags file from GHC parsed syntax tree";
···
        mainProgram = "github-release";
      }) {};
 
+  "github-release_2_0_0_3" = callPackage
+    ({ mkDerivation, aeson, base, burrito, bytestring, http-client
+     , http-client-tls, http-types, mime-types, optparse-generic, text
+     , unordered-containers
+     }:
+     mkDerivation {
+       pname = "github-release";
+       version = "2.0.0.3";
+       sha256 = "065jrbdx7y5fcbanngs6b0p4iryywg7hccbnkhb9spn9gzych4mg";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base burrito bytestring http-client http-client-tls
+         http-types mime-types optparse-generic text unordered-containers
+       ];
+       executableHaskellDepends = [
+         aeson base burrito bytestring http-client http-client-tls
+         http-types mime-types optparse-generic text unordered-containers
+       ];
+       description = "Upload files to GitHub releases";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "github-release";
+     }) {};
+
   "github-rest" = callPackage
     ({ mkDerivation, aeson, aeson-qq, base, bytestring, http-client
      , http-client-tls, http-types, jwt, mtl, scientific, tasty
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "grisette-monad-coroutine" = callPackage
+    ({ mkDerivation, base, grisette, monad-coroutine, mtl, tasty
+     , tasty-hunit, tasty-quickcheck, tasty-test-reporter, transformers
+     }:
+     mkDerivation {
+       pname = "grisette-monad-coroutine";
+       version = "0.1.0.0";
+       sha256 = "0bz8126lwdcx22smxv89z1ipfmnhxdvjzi830j0hzgmxkzw6g0d5";
+       libraryHaskellDepends = [
+         base grisette monad-coroutine mtl transformers
+       ];
+       testHaskellDepends = [
+         base grisette monad-coroutine mtl tasty tasty-hunit
+         tasty-quickcheck tasty-test-reporter transformers
+       ];
+       description = "Support for monad-coroutine package with Grisette";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "grm" = callPackage
     ({ mkDerivation, base, Cabal, cmdargs, directory, filepath, happy
      , parsec, process, syb, wl-pprint
···
        pname = "grow-vector";
        version = "0.1.5.0";
        sha256 = "1dn6gabmndhi56v3nsapxm9qbf54dp2blhgn8ibza0lnv8hwn15b";
+       revision = "1";
+       editedCabalFile = "0rvx6gcm8rf2mfj8q8zbixcwnpw5zm9lg0h7hkk1vbdzijr5pggy";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [ base primitive vector ];
        testHaskellDepends = [
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "guardian" = callPackage
+    ({ mkDerivation, aeson, algebraic-graphs, array, base, bytestring
+     , Cabal, cabal-install, Cabal-syntax, containers, dlist
+     , generic-lens, githash, hashable, indexed-traversable
+     , indexed-traversable-instances, microlens, optparse-applicative
+     , path, path-io, rio, selective, semigroups, stack, tasty
+     , tasty-discover, tasty-hunit, template-haskell, text, transformers
+     , unordered-containers, validation-selective, vector, yaml
+     }:
+     mkDerivation {
+       pname = "guardian";
+       version = "0.4.0.0";
+       sha256 = "190b7jds9kngcmx6aqlkygv3rkgbn4kqwbkh0mr0fjvzyy16mg7k";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson algebraic-graphs array base Cabal cabal-install Cabal-syntax
+         containers dlist generic-lens githash hashable indexed-traversable
+         indexed-traversable-instances microlens optparse-applicative path
+         path-io rio selective semigroups stack template-haskell text
+         transformers unordered-containers validation-selective vector yaml
+       ];
+       executableHaskellDepends = [ base text ];
+       testHaskellDepends = [
+         algebraic-graphs base bytestring containers path path-io rio tasty
+         tasty-hunit text unordered-containers validation-selective
+       ];
+       testToolDepends = [ tasty-discover ];
+       description = "The border guardian for your package dependencies";
+       license = lib.licenses.bsd3;
+       mainProgram = "guardian";
+     }) {};
+
   "guess-combinator" = callPackage
     ({ mkDerivation, base, HList }:
      mkDerivation {
···
     ({ mkDerivation, base, directory, mmsyn3, process }:
      mkDerivation {
        pname = "gvti";
-       version = "0.2.0.1";
-       sha256 = "1bbkzp795h06xgsdfl5sssxi851l7h0ck8jfc5wdbqx9dpcv46x6";
+       version = "0.3.1.0";
+       sha256 = "0a6ck1lqzlv2sf0ywinm63v357h6lakzsj5lcwba13l649zacg52";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base directory mmsyn3 process ];
···
      }) {};
 
   "h-raylib" = callPackage
-    ({ mkDerivation, base, c, libGL, libX11, libXcursor, libXi
+    ({ mkDerivation, base, c, libGL, libX11, libXcursor, libXext, libXi
      , libXinerama, libXrandr
      }:
      mkDerivation {
        pname = "h-raylib";
-       version = "4.5.0.12";
-       sha256 = "1mm9g3vadp0fspfd7n3y7c7n1ryhwklqv31hrjm637h92a2zzn6x";
+       version = "4.5.1.0";
+       sha256 = "0l2z5lijmqdn483zah01d5vvlxxywd4wzxbffp3kcks6rcdwj6k3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
        librarySystemDepends = [
-         c libGL libX11 libXcursor libXi libXinerama libXrandr
+         c libGL libX11 libXcursor libXext libXi libXinerama libXrandr
        ];
        description = "Raylib bindings for Haskell";
        license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {c = null; inherit (pkgs) libGL; inherit (pkgs.xorg) libX11; 
-         inherit (pkgs.xorg) libXcursor; inherit (pkgs.xorg) libXi; 
-         inherit (pkgs.xorg) libXinerama; inherit (pkgs.xorg) libXrandr;};
+         inherit (pkgs.xorg) libXcursor; inherit (pkgs.xorg) libXext; 
+         inherit (pkgs.xorg) libXi; inherit (pkgs.xorg) libXinerama; 
+         inherit (pkgs.xorg) libXrandr;};
 
   "h-reversi" = callPackage
     ({ mkDerivation, base, blank-canvas, containers, hspec, QuickCheck
···
        pname = "hackage-cli";
        version = "0.1.0.0";
        sha256 = "0wl2gpbcpdfmmmi99dkxy68gi3mn1aj8f2xrm5c8w1bs4sdxdzdq";
+       revision = "1";
+       editedCabalFile = "0v63w3v46n5jc3q7ywsih3wyqxg6f61psskpq1wkfwm9mnyxfwla";
        isLibrary = false;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "hakyll";
        version = "4.15.1.1";
        sha256 = "0b3bw275q1xbx8qs9a6gzzs3c9z3qdj7skqhpp09jkchi5kdvhvi";
-       revision = "8";
-       editedCabalFile = "0mrgi1xjmvbjqasrchmjylp4gc63gw879flwl6r1v3nf9nv7ziwf";
+       revision = "9";
+       editedCabalFile = "11zdqxmmykw2nbd8isc638cj03vrz8nkicyv35sn7jdw2p690ybh";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        ];
        sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
        license = lib.licenses.bsd3;
-     }) {};
-
-       sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
-       sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
-       sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
-     }:
-     mkDerivation {
-       sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
-       sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
-       sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
-       libraryHaskellDepends = [
-       sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
-         utf8-string
-       ];
-       sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
        sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
···
        ];
        sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
        license = lib.licenses.bsd3;
-     }) {};
-
-       sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
-    ({ mkDerivation, base, base64-bytestring, bytestring, cereal
-       sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
-     , wl-pprint-text
-     }:
-     mkDerivation {
-       sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
-       sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
-       sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
-       libraryHaskellDepends = [
-       sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
-       sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
-       ];
-       sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
        sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
···
        sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
      mkDerivation {
        sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
-       sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
-       sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
-       revision = "1";
-       sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
+       version = "1.20.1.1";
+       sha256 = "06w8g3lfk2ynrfhqznhp1mnp8a5b64lj6qviixpndzf5lv2psklb";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
      }:
      mkDerivation {
        sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
-       version = "1.0.1.0";
-       sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
+       version = "1.0.3.1";
+       sha256 = "096f23kdrv8278mxqk3nws65v078j54zjhr0wa1nqay5vbs459sz";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
     ({ mkDerivation, base }:
      mkDerivation {
        sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
-       version = "0.4.3.5";
-       sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
-       libraryHaskellDepends = [ base ];
-       sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
-       license = lib.licenses.bsd3;
-     }) {};
-
-       sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
-    ({ mkDerivation, base }:
-     mkDerivation {
-       sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
        sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
        sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
        libraryHaskellDepends = [ base ];
        sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
        sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
···
 
        sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
     ({ mkDerivation, base, base16-bytestring, bytestring
-       sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
-       sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
+     , cryptohash-sha256, directory, filepath, gambler, mtl, pipes
+     , quaalude, resourcet, temporary
      }:
      mkDerivation {
        sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
-       version = "0.0.1.0";
-       sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
+       version = "0.2.0.1";
+       sha256 = "1j4zr63if21g208zyhdk2mz8v3pfp23s33mrqzig0rryw3f0kby7";
        libraryHaskellDepends = [
        sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
-       sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
+         filepath gambler mtl pipes quaalude resourcet temporary
        ];
        sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
        license = lib.licenses.asl20;
···
        sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
        sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
        sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
-       sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
+     , pipes, quaalude, resourcet, safe-exceptions, text, transformers
      , unordered-containers
      }:
      mkDerivation {
        sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
-       version = "2.0.0.0";
-       sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
+       version = "2.1.0.1";
+       sha256 = "07maanr9hdqgrz41brfk3cahyaays0c12l6w5hb85nsxyil9w4xd";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
        sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
-       sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
+         hash-addressed ini optparse-applicative pipes quaalude resourcet
        sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
        ];
        executableHaskellDepends = [
        sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
-       sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
+         hash-addressed ini optparse-applicative pipes quaalude resourcet
        sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
        ];
        sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
···
      }:
      mkDerivation {
        pname = "hasql-pool";
-       version = "0.8.0.6";
-       sha256 = "0scpgynr20j8qkhi5gjl0mh7iq713vz7r1zr4xa0jv0s2nd14j2v";
+       version = "0.8.0.7";
+       sha256 = "16s0k60ffa7bflj0n6diprs3rbm5ywfbfvv1qwv45zwhxlyd622x";
        libraryHaskellDepends = [ base hasql stm transformers ];
        testHaskellDepends = [ async hasql hspec rerebase stm ];
        description = "Pool of connections for Hasql";
···
        pname = "hedis";
        version = "0.15.1";
        sha256 = "1a09i21qmzjcx171452bm69cj188f1jha2gwj0yi7shimcqz3l8m";
+       revision = "1";
+       editedCabalFile = "1ppc8xygcqv9s9jf44s1hh7ndm9mrvjxjwhv5g2rfdkkbsfyr7r5";
        libraryHaskellDepends = [
          async base bytestring bytestring-lexing containers deepseq errors
          exceptions HTTP mtl network network-uri resource-pool scanner stm
···
      }:
      mkDerivation {
        pname = "heist";
-       version = "1.1.1.0";
-       sha256 = "17ba0jmzs4wk4303ydcr1p2k2kcjfs11mrhlglaz40z61z3vm1yl";
+       version = "1.1.1.1";
+       sha256 = "0s6ydncib0g4mdmx4vzwmp1cnbvxrb2pngvkd5jc5kn5vb3g929l";
        libraryHaskellDepends = [
          aeson attoparsec base blaze-builder blaze-html bytestring
          containers directory directory-tree dlist filepath hashable
···
      }:
      mkDerivation {
        pname = "horizon-gen-nix";
-       version = "0.5";
-       sha256 = "058m8mbrlq7jlgx1vxl1mdwb0ly7n9wwkb1jijgf5l4xil1vjmsv";
+       version = "0.6";
+       sha256 = "1dhd7w3zcw10migz5qfglqh9n6im3ip6af47vxlsib365vk02jl1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "horizon-spec";
-       version = "0.5";
-       sha256 = "0ming3s98g75j20bg3dy444711k1xc9c6246wlbq4y19zx5r8lxd";
+       version = "0.6";
+       sha256 = "0p62f79p3bpjjrxfgvvd4i7p54y9xdjxxqg3qxji88m3mgvs4sfw";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "hpack";
-       version = "0.35.1";
-       sha256 = "1hpc6bwx94v943p73l12nnncbs656f2fn7q3hb4qs13xrxygzl4g";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         aeson base bifunctors bytestring Cabal containers cryptonite
-         deepseq directory filepath Glob http-client http-client-tls
-         http-types infer-license pretty scientific text transformers
-         unordered-containers vector yaml
-       ];
-       executableHaskellDepends = [
-         aeson base bifunctors bytestring Cabal containers cryptonite
-         deepseq directory filepath Glob http-client http-client-tls
-         http-types infer-license pretty scientific text transformers
-         unordered-containers vector yaml
-       ];
-       testHaskellDepends = [
-         aeson base bifunctors bytestring Cabal containers cryptonite
-         deepseq directory filepath Glob hspec http-client http-client-tls
-         http-types HUnit infer-license interpolate mockery pretty
-         QuickCheck scientific template-haskell temporary text transformers
-         unordered-containers vector yaml
-       ];
-       testToolDepends = [ hspec-discover ];
-       description = "A modern format for Haskell packages";
-       license = lib.licenses.mit;
-       mainProgram = "hpack";
-     }) {};
-
-  "hpack_0_35_2" = callPackage
-    ({ mkDerivation, aeson, base, bifunctors, bytestring, Cabal
-     , containers, cryptonite, deepseq, directory, filepath, Glob, hspec
-     , hspec-discover, http-client, http-client-tls, http-types, HUnit
-     , infer-license, interpolate, mockery, pretty, QuickCheck
-     , scientific, template-haskell, temporary, text, transformers
-     , unordered-containers, vector, yaml
-     }:
-     mkDerivation {
-       pname = "hpack";
        version = "0.35.2";
        sha256 = "1v4h5dkbfwx8wlmbaq76av22ald9iyk80k8k7pz808nw30yh3dq3";
        isLibrary = true;
···
        testToolDepends = [ hspec-discover ];
        description = "A modern format for Haskell packages";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
        mainProgram = "hpack";
      }) {};
 
···
        broken = true;
      }) {inherit (pkgs) postgresql;};
 
-  "hpqtypes_1_11_0_0" = callPackage
+  "hpqtypes_1_11_1_0" = callPackage
     ({ mkDerivation, aeson, async, base, bytestring, containers
      , exceptions, HUnit, libpq, lifted-base, monad-control, mtl
      , QuickCheck, random, resource-pool, scientific, semigroups
···
      }:
      mkDerivation {
        pname = "hpqtypes";
-       version = "1.11.0.0";
-       sha256 = "14d01gi2bqqf5hcgaysc5m8c2s9h8bfsbg76vdvzksjz08nj5klr";
+       version = "1.11.1.0";
+       sha256 = "01k256bdcbp88s28bv9mr0pncgzxvwk80dblwwjs1bgnn7v7nvzk";
        libraryHaskellDepends = [
          aeson async base bytestring containers exceptions lifted-base
          monad-control mtl resource-pool semigroups text text-show time
···
        libraryPkgconfigDepends = [ libpq ];
        testHaskellDepends = [
          aeson base bytestring exceptions HUnit lifted-base monad-control
-         mtl QuickCheck random resource-pool scientific test-framework
+         mtl QuickCheck random scientific test-framework
          test-framework-hunit text text-show time transformers-base
          unordered-containers uuid-types vector
        ];
···
     ({ mkDerivation, base, time }:
      mkDerivation {
        pname = "hquantlib-time";
-       version = "0.0.5.1";
-       sha256 = "1jvcpcnss3hgnjp6isbpbmjml068gasrlj376sbv7diynh8a4rlf";
+       version = "0.0.5.2";
+       sha256 = "04gzlh3qcbxs1659fgl2l45j16g4m5c4gasd0vwrn2wpskr9w38k";
        libraryHaskellDepends = [ base time ];
        description = "HQuantLib Time is a business calendar functions extracted from HQuantLib";
        license = "LGPL";
···
        mainProgram = "hsc2hs";
      }) {};
 
+  "hsc2hs_0_68_9" = callPackage
+    ({ mkDerivation, base, containers, directory, filepath, HUnit
+     , process, test-framework, test-framework-hunit
+     }:
+     mkDerivation {
+       pname = "hsc2hs";
+       version = "0.68.9";
+       sha256 = "02mwsgad10dg640alay7br1zrkn9vhwdf62iwf01921c1g710ny9";
+       isLibrary = false;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       executableHaskellDepends = [
+         base containers directory filepath process
+       ];
+       testHaskellDepends = [
+         base HUnit test-framework test-framework-hunit
+       ];
+       description = "A preprocessor that helps with writing Haskell bindings to C code";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "hsc2hs";
+     }) {};
+
   "hsc3" = callPackage
     ({ mkDerivation, array, base, binary, bytestring, containers
      , data-binary-ieee754, data-ordlist, directory, filepath, hosc, mtl
···
      }) {};
 
   "hspec-contrib" = callPackage
-    ({ mkDerivation, base, hspec, hspec-core, hspec-discover, HUnit
-     , QuickCheck
+    ({ mkDerivation, base, call-stack, hspec, hspec-core
+     , hspec-discover, HUnit, QuickCheck
      }:
      mkDerivation {
        pname = "hspec-contrib";
-       version = "0.5.1.1";
-       sha256 = "1nyb5n2jiq920yyf3flzyxrs5xpfyppl3jn18zhviyysjjk5drpx";
-       libraryHaskellDepends = [ base hspec-core HUnit ];
-       testHaskellDepends = [ base hspec hspec-core HUnit QuickCheck ];
+       version = "0.5.2";
+       sha256 = "0002xzvyh790iwf1y33d4nflrbp5sxvpsp010srcfryf1n3qx2b0";
+       libraryHaskellDepends = [ base call-stack hspec-core HUnit ];
+       testHaskellDepends = [
+         base call-stack hspec hspec-core HUnit QuickCheck
+       ];
        testToolDepends = [ hspec-discover ];
        description = "Contributed functionality for Hspec";
        license = lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "hsx2hs";
-       version = "0.14.1.10";
-       sha256 = "04anp9jfr6y0f4dwzn6k051jkbvmnkdayjg980y2pjj6jqqxr00x";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         base bytestring haskell-src-exts haskell-src-meta mtl
-         template-haskell utf8-string
-       ];
-       executableHaskellDepends = [
-         base bytestring haskell-src-exts haskell-src-meta mtl
-         template-haskell utf8-string
-       ];
-       description = "HSX (Haskell Source with XML) allows literal XML syntax in Haskell source code";
-       license = lib.licenses.bsd3;
-       mainProgram = "hsx2hs";
-     }) {};
-
-  "hsx2hs_0_14_1_11" = callPackage
-    ({ mkDerivation, base, bytestring, haskell-src-exts
-     , haskell-src-meta, mtl, template-haskell, utf8-string
-     }:
-     mkDerivation {
-       pname = "hsx2hs";
        version = "0.14.1.11";
        sha256 = "1jpf3m7hcpl38p0a9wqpbaqffdxbqszyqisipgjwn0qmbh56jvas";
        isLibrary = true;
···
        ];
        description = "HSX (Haskell Source with XML) allows literal XML syntax in Haskell source code";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
        mainProgram = "hsx2hs";
      }) {};
 
···
      }) {};
 
   "http-io-streams" = callPackage
-    ({ mkDerivation, attoparsec, base, base64-bytestring, binary
-     , blaze-builder, brotli-streams, bytestring, case-insensitive
-     , containers, cryptohash-sha1, directory, HsOpenSSL, io-streams
-     , mtl, network, network-uri, openssl-streams, text, transformers
-     , xor
+    ({ mkDerivation, aeson, aeson-pretty, attoparsec, base
+     , base64-bytestring, binary, blaze-builder, brotli-streams
+     , bytestring, case-insensitive, containers, cryptohash-sha1
+     , directory, HsOpenSSL, hspec, hspec-expectations, HUnit
+     , io-streams, lifted-base, mtl, network, network-uri
+     , openssl-streams, snap, snap-core, snap-server, system-fileio
+     , system-filepath, text, transformers, unordered-containers, xor
      }:
      mkDerivation {
        pname = "http-io-streams";
-       version = "0.1.6.1";
-       sha256 = "09ggsf9g8gf28d3d5z0rcdnl63d34al35z5d6v68k0n7r229ffb1";
-       revision = "1";
-       editedCabalFile = "0v2xp9fhrw77vh4vz5qk9lip5mhbf9lz5nkdrfcvrilfjgg4s17b";
+       sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
+       sha256 = "0nil98dnw0y6g417mr9c9dan071ri3726dv0asgwwplq5mwy780q";
        libraryHaskellDepends = [
          attoparsec base base64-bytestring binary blaze-builder
          brotli-streams bytestring case-insensitive containers
          cryptohash-sha1 directory HsOpenSSL io-streams mtl network
          network-uri openssl-streams text transformers xor
+       ];
+       testHaskellDepends = [
+         aeson aeson-pretty attoparsec base base64-bytestring blaze-builder
+         bytestring case-insensitive containers directory HsOpenSSL hspec
+         hspec-expectations HUnit io-streams lifted-base mtl network
+         network-uri openssl-streams snap snap-core snap-server
+         system-fileio system-filepath text transformers
+         unordered-containers
        ];
        description = "HTTP and WebSocket client based on io-streams";
        license = "BSD-3-Clause AND GPL-2.0-or-later";
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "http2_4_0_0" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, array, async, base
+     , base16-bytestring, bytestring, case-insensitive, containers
+     , cryptonite, directory, filepath, gauge, Glob, hspec
+     , hspec-discover, http-types, network, network-byte-order
+     , network-run, psqueues, stm, text, time-manager, typed-process
+     , unix-time, unliftio, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "http2";
+       version = "4.0.0";
+       sha256 = "1gvr0kkx7giskjhm4aag7zz43wgnqk6c6ksljabq7i5fj037z6zb";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         array async base bytestring case-insensitive containers http-types
+         network network-byte-order psqueues stm time-manager unix-time
+         unliftio
+       ];
+       testHaskellDepends = [
+         aeson aeson-pretty async base base16-bytestring bytestring
+         cryptonite directory filepath Glob hspec http-types network
+         network-byte-order network-run text typed-process
+         unordered-containers vector
+       ];
+       testToolDepends = [ hspec-discover ];
+       benchmarkHaskellDepends = [
+         array base bytestring case-insensitive containers gauge
+         network-byte-order stm
+       ];
+       description = "HTTP/2 library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "http2-client" = callPackage
     ({ mkDerivation, async, base, bytestring, containers, deepseq
      , http2, lifted-async, lifted-base, mtl, network, stm, time, tls
···
      }:
      mkDerivation {
        pname = "http3";
-       version = "0.0.0";
-       sha256 = "12mkxhqhaxcmg2b8finpm5zlkzc614k004jzbacl6jrla3wvzmhw";
+       version = "0.0.1";
+       sha256 = "0p1rdcjzp5gpd8j64df9q8y9ag6sjzl0gfp68wx0s2xikh34lh98";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        doHaddock = false;
        description = "Memory efficient JSON parser";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "hw-json";
      }) {};
 
···
        testToolDepends = [ doctest-discover ];
        description = "SIMD-based JSON semi-indexer";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "hw-json-simd";
+       broken = true;
      }) {};
 
   "hw-json-simple-cursor" = callPackage
···
        ];
        description = "Memory efficient JSON parser";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "hw-json";
      }) {};
 
···
        ];
        description = "Memory efficient JSON parser";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "hw-json-standard-cursor";
      }) {};
 
···
      }:
      mkDerivation {
        pname = "ihp-hsx";
-       version = "0.20.0";
-       sha256 = "118bhsyn5r9p03b8six9g5xna4vrh2qsq3ka4mqlvzv4kp4d7dkb";
+       version = "1.0.0";
+       sha256 = "0ln4xgr3wamhjd34q8vvd0z8chh4prqq7javl9n4ljvriyky13p7";
        libraryHaskellDepends = [
          base blaze-html blaze-markup bytestring containers ghc megaparsec
          string-conversions template-haskell text
···
      }:
      mkDerivation {
        pname = "integer-types";
-       version = "0.0.0.1";
-       sha256 = "0s12gsa8k9b2pgd0705ji6qj4whl1vv0wpxjn129ppdb9dmji6gg";
+       version = "0.1.0.0";
+       sha256 = "0ydhb8sy8klaf0lgvckxcl15wc7b2l0kqr3q225xgkw0qz6qzbic";
        libraryHaskellDepends = [ base deepseq quaalude ];
        testHaskellDepends = [
          base deepseq exceptions hedgehog hspec hspec-hedgehog quaalude
···
      }:
      mkDerivation {
        pname = "interval-algebra";
-       version = "2.1.2";
-       sha256 = "114c8px57xhvvwzqjkmd0zw7xx8p4w4jhvfl8i1y5ybmaqad060f";
+       version = "2.1.3";
+       sha256 = "0dsy32n9s0d9i9479d9rhlwwnjl2grl4xg8jwg4mk91p34s8l05n";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
     ({ mkDerivation, base, Cabal, Cabal-syntax }:
      mkDerivation {
        pname = "jailbreak-cabal";
-       version = "1.3.6";
-       sha256 = "11vzq4yklsi7v04lch0540fgvbg6d5fnl4sdfdcg8n3ijkwqy49p";
+       version = "1.4";
+       sha256 = "0acl7v3m1hm0rdyzzh5w63d6i1z1pdn4767xy1437f4q614vaxjc";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base Cabal Cabal-syntax ];
···
        license = lib.licenses.mit;
      }) {};
 
+  "json-feed_2_0_0_5" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, filepath, hspec
+     , mime-types, network-uri, tagsoup, text, time
+     }:
+     mkDerivation {
+       pname = "json-feed";
+       version = "2.0.0.5";
+       sha256 = "1204g20x1b19ki3cycss2dpfjfg521d7s5fi8i9wzd8vs5i0vwkb";
+       libraryHaskellDepends = [
+         aeson base bytestring mime-types network-uri tagsoup text time
+       ];
+       testHaskellDepends = [
+         aeson base bytestring filepath hspec mime-types network-uri tagsoup
+         text time
+       ];
+       description = "JSON Feed";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "json-fu" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, bytestring, containers
      , hashable, hspec, mtl, syb, text, time, unordered-containers
···
     ({ mkDerivation, base, containers, stm, tasty, tasty-hunit }:
      mkDerivation {
        pname = "ki";
-       version = "1.0.0.1";
-       sha256 = "04wglc9ddf9g2amr2h9pdcv0pzn6gqsqg67hds5zwz1jjdbk52ad";
-       libraryHaskellDepends = [ base containers ];
-       testHaskellDepends = [ base stm tasty tasty-hunit ];
-       description = "A lightweight structured concurrency library";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "ki_1_0_0_2" = callPackage
-    ({ mkDerivation, base, containers, stm, tasty, tasty-hunit }:
-     mkDerivation {
-       pname = "ki";
        version = "1.0.0.2";
        sha256 = "1sxzgh8g9fahqwx7ky4f1g03fhy791hilfansx8kf39gfk646dcw";
        libraryHaskellDepends = [ base containers ];
        testHaskellDepends = [ base stm tasty tasty-hunit ];
        description = "A lightweight structured concurrency library";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ki-effectful" = callPackage
···
      }:
      mkDerivation {
        pname = "ki-effectful";
-       version = "0.1.0.0";
-       sha256 = "00r7f666kzjvx54hpvq3aiq09a9zqja0x22bff94l4pdzrpx8ch2";
+       version = "0.1.1.0";
+       sha256 = "0dnjfq4mxir4qr3rkkacjc6d5xlw1zbnsj889lj7bi70qsrjy182";
        libraryHaskellDepends = [ base effectful-core ki stm ];
        testHaskellDepends = [ base effectful-core stm tasty tasty-hunit ];
        description = "Adaptation of the ki library for the effectful ecosystem";
···
     ({ mkDerivation, base, bytestring, transformers }:
      mkDerivation {
        pname = "knob";
-       version = "0.2.1";
-       sha256 = "03q918gnm2d6jr57lydxz3i0mykvk7ghyq59cy2vavg395s4jrhy";
+       version = "0.2.2";
+       sha256 = "1sgfq0jkzzvhfwksjxk1z80z6mfgxniskjmqmxy5bq6ly42s3xhc";
        libraryHaskellDepends = [ base bytestring transformers ];
        description = "Memory-backed handles";
        license = lib.licenses.mit;
···
        testHaskellDepends = [ base hspec servant servant-foreign text ];
        description = "Generate Ruby clients from Servant APIs";
        license = lib.licenses.mit;
+     }) {};
+
+  "lackey_2_0_0_4" = callPackage
+    ({ mkDerivation, base, hspec, servant, servant-foreign, text }:
+     mkDerivation {
+       pname = "lackey";
+       version = "2.0.0.4";
+       sha256 = "0cqmrsir562p9xxvjawj7rvmzypigmj4rhi6pgf5s0gmpzrjcskn";
+       libraryHaskellDepends = [ base servant-foreign text ];
+       testHaskellDepends = [ base hspec servant servant-foreign text ];
+       description = "Generate Ruby clients from Servant APIs";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "lacroix" = callPackage
···
        license = lib.licenses.gpl3Only;
      }) {};
 
+  "language-docker_12_1_0" = callPackage
+    ({ mkDerivation, base, bytestring, containers, data-default
+     , data-default-class, hspec, hspec-megaparsec, HUnit, megaparsec
+     , prettyprinter, QuickCheck, split, text, time
+     }:
+     mkDerivation {
+       pname = "language-docker";
+       version = "12.1.0";
+       sha256 = "0wbck5a50d0sdmvr3vvjgz1bbmqvj5avn1slxrazpfyy9rdnr9l3";
+       libraryHaskellDepends = [
+         base bytestring containers data-default data-default-class
+         megaparsec prettyprinter split text time
+       ];
+       testHaskellDepends = [
+         base bytestring containers data-default data-default-class hspec
+         hspec-megaparsec HUnit megaparsec prettyprinter QuickCheck split
+         text time
+       ];
+       description = "Dockerfile parser, pretty-printer and embedded DSL";
+       license = lib.licenses.gpl3Only;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "language-dockerfile" = callPackage
     ({ mkDerivation, aeson, base, bytestring, directory, filepath, free
      , Glob, hspec, HUnit, mtl, parsec, pretty, process, QuickCheck
···
        libraryHaskellDepends = [ base ];
        description = "Assert the lawfulness of your typeclass instances";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "lawful-classes-hedgehog" = callPackage
+    ({ mkDerivation, base, hedgehog, lawful-classes-types, mtl, tasty
+     , tasty-expected-failure, tasty-hedgehog, transformers
+     }:
+     mkDerivation {
+       pname = "lawful-classes-hedgehog";
+       version = "0.1.2.1";
+       sha256 = "1x20xsphq9la8g1a6n3427ib0kqpakxirs1qn7qhwwzk3wdra8qq";
+       libraryHaskellDepends = [
+         base hedgehog lawful-classes-types tasty tasty-hedgehog
+         transformers
+       ];
+       testHaskellDepends = [
+         base hedgehog lawful-classes-types mtl tasty tasty-expected-failure
+         transformers
+       ];
+       description = "Hedgehog support for lawful-classes";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "lawful-classes-quickcheck" = callPackage
+    ({ mkDerivation, base, lawful-classes-types, mtl, QuickCheck, tasty
+     , tasty-expected-failure, tasty-quickcheck, transformers
+     }:
+     mkDerivation {
+       pname = "lawful-classes-quickcheck";
+       version = "0.1.2.1";
+       sha256 = "1xi8agnb0mbkvbjbqqnqizbnnjv4kkdc6mwlm8yvc4ipl72y45n6";
+       libraryHaskellDepends = [
+         base lawful-classes-types QuickCheck tasty tasty-quickcheck
+         transformers
+       ];
+       testHaskellDepends = [
+         base lawful-classes-types mtl QuickCheck tasty
+         tasty-expected-failure transformers
+       ];
+       description = "QuickCheck support for lawful-classes";
+       license = lib.licenses.asl20;
+     }) {};
+
+  "lawful-classes-types" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "lawful-classes-types";
+       version = "0.1.0.2";
+       sha256 = "0dza7qrq54k0p50bv7hj9y0c12kl3x51j6kh9k7aammfnl14hrri";
+       libraryHaskellDepends = [ base ];
+       description = "Types for lawful-classes";
+       license = lib.licenses.asl20;
      }) {};
 
   "lawless-concurrent-machines" = callPackage
···
      }) {};
 
   "lifetimes" = callPackage
-    ({ mkDerivation, base, containers, hspec, monad-stm
+    ({ mkDerivation, async, base, containers, hspec, monad-stm
      , safe-exceptions, stm, transformers, zenhack-prelude
      }:
      mkDerivation {
        pname = "lifetimes";
-       version = "0.1.0.0";
-       sha256 = "192bzz4nqqi2kdk9x4nxlwmx0mf0sshqdcnx1dgyjh5z9k29rww5";
+       version = "0.2.0.1";
+       sha256 = "15b7gs7y5cxh4wv4ypzwknrh25305db44kqh0v07v4j40gzfys07";
        libraryHaskellDepends = [
-         base containers monad-stm stm transformers zenhack-prelude
+         async base containers monad-stm stm transformers zenhack-prelude
        ];
        testHaskellDepends = [
-         base containers hspec monad-stm safe-exceptions stm transformers
-         zenhack-prelude
+         async base containers hspec monad-stm safe-exceptions stm
+         transformers zenhack-prelude
        ];
        description = "Flexible manual resource management";
        license = lib.licenses.asl20;
···
        broken = true;
      }) {};
 
+  "lima" = callPackage
+    ({ mkDerivation, aeson, base, data-default, optparse-applicative
+     , yaml
+     }:
+     mkDerivation {
+       pname = "lima";
+       version = "0.1.0.5";
+       sha256 = "10hanr88zbrx57c52rmzmvqqn35yhylpzms0j60j195zwxmaliq6";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base data-default optparse-applicative yaml
+       ];
+       executableHaskellDepends = [
+         aeson base data-default optparse-applicative yaml
+       ];
+       testHaskellDepends = [
+         aeson base data-default optparse-applicative yaml
+       ];
+       description = "(Haskell or Literate Haskell) <-> Markdown converter";
+       license = lib.licenses.mit;
+       mainProgram = "lima";
+     }) {};
+
   "limp" = callPackage
     ({ mkDerivation, base, containers, QuickCheck, tasty
      , tasty-quickcheck, tasty-th
···
      , directory, exceptions, extra, filepath, fingertree, free, ghc
      , ghc-boot, ghc-paths, ghc-prim, githash, gitrev, hashable
      , hscolour, liquid-fixpoint, megaparsec, mtl, optics
-     , optparse-applicative, optparse-simple, pretty, process
-     , recursion-schemes, split, stm, string-conv, syb, tagged, tasty
-     , tasty-ant-xml, tasty-golden, tasty-hunit, tasty-rerun
-     , template-haskell, temporary, text, th-compat, time, transformers
+     , optparse-applicative, pretty, process, recursion-schemes, split
+     , syb, tasty, tasty-ant-xml, tasty-hunit, template-haskell
+     , temporary, text, th-compat, time, transformers
      , unordered-containers, vector, z3
      }:
      mkDerivation {
        pname = "liquidhaskell";
-       version = "0.8.10.7";
-       sha256 = "02yaiwlq1xbdshmi655cwi8xnydrwpb3k1rsh00cdx6d8ab753kz";
+       version = "0.9.0.2.1";
+       sha256 = "174bazw76hrn3rlvcmsag87rv66r9vwm6008hw540gjvj2g1w0z4";
+       revision = "1";
+       editedCabalFile = "1ycl8vg7nzslkvsiimfv67fa095cgkzpzxila6wpnnsmf6d9m06z";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
          data-default data-fix deepseq Diff directory exceptions extra
          filepath fingertree free ghc ghc-boot ghc-paths ghc-prim githash
          gitrev hashable hscolour liquid-fixpoint megaparsec mtl optics
-         optparse-applicative optparse-simple pretty recursion-schemes split
-         syb template-haskell temporary text th-compat time transformers
+         optparse-applicative pretty recursion-schemes split syb
+         template-haskell temporary text th-compat time transformers
          unordered-containers vector
        ];
        executableHaskellDepends = [ base ];
        testHaskellDepends = [
-         base containers directory extra filepath ghc liquid-fixpoint
-         megaparsec mtl optparse-applicative process stm string-conv syb
-         tagged tasty tasty-ant-xml tasty-golden tasty-hunit tasty-rerun
-         text transformers
+         base directory extra filepath ghc liquid-fixpoint megaparsec
+         process syb tasty tasty-ant-xml tasty-hunit text
        ];
        testSystemDepends = [ z3 ];
        description = "Liquid Types for Haskell";
···
        pname = "llvm-hs-pure";
        version = "9.0.0";
        sha256 = "0pxb5ah8r5pzpz2ibqw3g9g1isigb4z7pbzfrwr8kmcjn74ab3kf";
+       revision = "1";
+       editedCabalFile = "14vn4yyzwg5kh6wx67ax0vd06n94x1y9rzqj6k2qr8liayhmbxhh";
        libraryHaskellDepends = [
          attoparsec base bytestring containers fail mtl template-haskell
          transformers unordered-containers
···
        pname = "log-base";
        version = "0.12.0.0";
        sha256 = "0z646qhyp636q24fxwkkpbg2z5f5vfyskkl04jrk9hpfvba3arsg";
+       revision = "1";
+       editedCabalFile = "1ivk7mm48hmw75ik7239rxr1c7ymc2bx1r78g3bz33sm500gms2h";
        libraryHaskellDepends = [
          aeson aeson-pretty base bytestring deepseq exceptions mmorph
          monad-control mtl semigroups stm text time transformers-base
···
      }:
      mkDerivation {
        pname = "log-elasticsearch";
-       version = "0.13.0.0";
-       sha256 = "1jc3891y71rxidwhyfqkkh4jf7kvfw8if622z2fbdl7wgr40saqj";
+       version = "0.13.0.1";
+       sha256 = "1l9p4zpf18rkwkv485swrlwyx2l3iqd332273mkz64ybjqllsdkx";
        libraryHaskellDepends = [
          aeson aeson-pretty base base64-bytestring bytestring deepseq
          http-client http-client-openssl http-types log-base network-uri
···
     ({ mkDerivation, base, transformers }:
      mkDerivation {
        pname = "managed";
-       version = "1.0.9";
-       sha256 = "0vx8aim8bcyyvxxnmi1xkbl3kwrvskjn99z3y8h458g7nsinsisd";
-       revision = "3";
-       editedCabalFile = "017h9533j7rlxlsf65ynxpva59yr0qwrdmvhp7if141i98ld4664";
+       version = "1.0.10";
+       sha256 = "0ngpk6zkpnc9hl9a46pgkc8ii4d7y06xci52birc5vy1a2fwl8is";
        libraryHaskellDepends = [ base transformers ];
        description = "A monad for managed values";
        license = lib.licenses.bsd3;
···
        pname = "map-syntax";
        version = "0.3";
        sha256 = "0b3ddi998saw5gi5r4bjbpid03rxlifn08zv15wf0b90ambhcc4k";
-       revision = "5";
-       editedCabalFile = "0vfrq4gbd07jaz656lrxx7yar8lbgimkvkij52sn6d403wak20cv";
+       revision = "6";
+       editedCabalFile = "1al0603ldi5vsqid0bdvw4jnasc888cv5qqix5ps711rz86wmrrd";
        libraryHaskellDepends = [ base containers mtl ];
        testHaskellDepends = [
          base containers deepseq hspec HUnit mtl QuickCheck transformers
···
      }) {};
 
   "melf" = callPackage
-    ({ mkDerivation, base, binary, bytestring, containers, directory
-     , exceptions, filepath, mtl, optparse-applicative, prettyprinter
+    ({ mkDerivation, base, binary, bytestring, directory, exceptions
+     , filepath, lens, mtl, optparse-applicative, prettyprinter
      , singletons, singletons-base, singletons-th, tasty, tasty-golden
      , tasty-hunit, template-haskell, unix
      }:
      mkDerivation {
        pname = "melf";
-       version = "1.1.0";
-       sha256 = "0d8rc67yirdj03i1gdcyip51q3qbzfghfblwqzdm85hlhp7vidic";
+       version = "1.2.0";
+       sha256 = "1zhxgmkbadnyapdq2pqg181fbs47pqcd0vwq8k12sbfs9h3rhlzr";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
-         base binary bytestring exceptions mtl prettyprinter singletons
+         base binary bytestring exceptions lens mtl prettyprinter singletons
          singletons-base singletons-th template-haskell
        ];
        executableHaskellDepends = [
···
          prettyprinter
        ];
        testHaskellDepends = [
-         base binary bytestring containers directory exceptions filepath mtl
+         base binary bytestring directory exceptions filepath mtl
          prettyprinter singletons singletons-th tasty tasty-golden
          tasty-hunit unix
        ];
···
        license = lib.licenses.gpl3Only;
      }) {};
 
+  "minicurl" = callPackage
+    ({ mkDerivation, base, bytestring, cryptohash-sha256, curl, HUnit
+     }:
+     mkDerivation {
+       pname = "minicurl";
+       version = "0";
+       sha256 = "0zyvy4iakc7m3hblmc6kmm7nkwajjg5wsvxwd51d4idlm1b11xm2";
+       libraryHaskellDepends = [ base bytestring ];
+       libraryPkgconfigDepends = [ curl ];
+       testHaskellDepends = [ base bytestring cryptohash-sha256 HUnit ];
+       description = "Minimal bindings to libcurl";
+       license = lib.licenses.bsd3;
+     }) {inherit (pkgs) curl;};
+
   "miniforth" = callPackage
     ({ mkDerivation, base, containers, lens, MonadRandom, mtl
      , mtl-compat, parsec, parsec3-numbers, readline
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "mmsyn2-array-ukrainian-data";
-       version = "0.1.0.0";
-       sha256 = "1fvwa0aby40pahi5gx47x09qzl6myj6djp6shjv5f07m5ygq3h3q";
+       version = "0.2.0.0";
+       sha256 = "1i8cqgypikc0rjcjgv4x62c6j29cf7q37zzvg7b8ividvdjvkpbj";
        libraryHaskellDepends = [ base ];
        description = "Data that is taken from the ukrainian-phonetics-basic-array for optimization";
        license = lib.licenses.mit;
···
     ({ mkDerivation, base, directory }:
      mkDerivation {
        pname = "mmsyn3";
-       version = "0.1.6.0";
-       sha256 = "0fbpjqr9vv10s0kn9i6l50csym40zrpa8yynm884a1580mq5w2d6";
+       version = "0.2.0.0";
+       sha256 = "1fmwxy9rb11l797gjmz1ymskcngqkll9q3g5z9zcqnprfcb8lpxi";
        libraryHaskellDepends = [ base directory ];
        description = "A small library to deal with executable endings";
        license = lib.licenses.mit;
···
        executableHaskellDepends = [ base directory mmsyn3 process ];
        description = "The \"glue\" between electronic tables and GraphViz";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "mmsyn4";
+       broken = true;
      }) {};
 
   "mmsyn5" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "mmsyn5";
-       version = "0.5.1.0";
-       sha256 = "0ay36zs4wxv69i11hr66b07x079p0k41h8zvaz2fl431d3h385rw";
+       version = "0.6.0.0";
+       sha256 = "1737c8b960ngc38fdzsj9gwdlz0qzvd6yc5wcb226r6fpkf36z8c";
        libraryHaskellDepends = [ base ];
        description = "Various additional operations on lists (some with intermediate Monads)";
        license = lib.licenses.mit;
···
        libraryHaskellDepends = [ base directory mmsyn3 process ];
        description = "Some common for mmsyn7ukr and mmsyn7ukr-array functionality using SoX";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "mmtf" = callPackage
···
      }:
      mkDerivation {
        pname = "mnist-idx";
-       version = "0.1.3.1";
-       sha256 = "12246lq1a0jc91yqyng9v2cgf4pqmfmf820jjwnc6aglx86vsmni";
+       version = "0.1.3.2";
+       sha256 = "0ana9dqnanh8wgv1v7xgdznz2kf1p20lg96vkix83hk9v49gdcs3";
        libraryHaskellDepends = [ base binary bytestring vector ];
        testHaskellDepends = [
          base binary directory hspec QuickCheck vector
···
        license = lib.licenses.mit;
      }) {};
 
+  "mod_0_2_0_0" = callPackage
+    ({ mkDerivation, base, containers, deepseq, ghc-bignum, primitive
+     , quickcheck-classes, quickcheck-classes-base, semirings, tasty
+     , tasty-bench, tasty-quickcheck, vector
+     }:
+     mkDerivation {
+       pname = "mod";
+       version = "0.2.0.0";
+       sha256 = "18jn2hsp42crfx0a8cm2aahxwf54pxkq3v94q3mccp2lkx9is40z";
+       libraryHaskellDepends = [
+         base deepseq ghc-bignum primitive semirings vector
+       ];
+       testHaskellDepends = [
+         base containers primitive quickcheck-classes
+         quickcheck-classes-base semirings tasty tasty-quickcheck vector
+       ];
+       benchmarkHaskellDepends = [ base tasty-bench ];
+       description = "Fast type-safe modular arithmetic";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "modbus-tcp" = callPackage
     ({ mkDerivation, base, bytestring, cereal, mtl, transformers }:
      mkDerivation {
···
        pname = "modular-arithmetic";
        version = "2.0.0.2";
        sha256 = "1bbn3pwvpl9v7a8gkxx83w2s8mk2q9gin7yvkkr97f64rdf8lnrq";
+       revision = "1";
+       editedCabalFile = "035z6pjgbgcb39dh6zd822d1yxvjs5j684cx7mn14wq0q1l0q295";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base doctest ];
        description = "A type for integers modulo some constant";
···
      }:
      mkDerivation {
        pname = "monad-logger";
-       version = "0.3.37";
-       sha256 = "1z275a428zcj73zz0cpfha2adwiwqqqp7klx3kbd3i9rl20xa106";
-       revision = "3";
-       editedCabalFile = "1dzkw08b4ijacdw0vcfxlr13rd819x2yj7b6sr9jrrwicd45zm1z";
-       libraryHaskellDepends = [
-         base bytestring conduit conduit-extra exceptions fast-logger
-         lifted-base monad-control monad-loops mtl resourcet stm stm-chans
-         template-haskell text transformers transformers-base
-         transformers-compat unliftio-core
-       ];
-       description = "A class of monads which can log messages";
-       license = lib.licenses.mit;
-     }) {};
-
-  "monad-logger_0_3_39" = callPackage
-    ({ mkDerivation, base, bytestring, conduit, conduit-extra
-     , exceptions, fast-logger, lifted-base, monad-control, monad-loops
-     , mtl, resourcet, stm, stm-chans, template-haskell, text
-     , transformers, transformers-base, transformers-compat
-     , unliftio-core
-     }:
-     mkDerivation {
-       pname = "monad-logger";
        version = "0.3.39";
        sha256 = "19992zh63axs0q86fgznk04dan8h3hbs72cjp1s3yynsgl23pwnk";
        libraryHaskellDepends = [
···
        ];
        description = "A class of monads which can log messages";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "monad-logger-aeson" = callPackage
···
      }:
      mkDerivation {
        pname = "monad-logger-aeson";
-       version = "0.4.0.2";
-       sha256 = "1z0r0xkd8i9nw9jlzb7m50m2qi48mf6v26h533jn91yw6gi830r0";
+       version = "0.4.0.3";
+       sha256 = "1i5lp7falarvwad3a7xnm865bl4q7jqj9dq96hlf4phh4rsx0h9q";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "monoid-statistics";
-       version = "1.1.2";
-       sha256 = "1ac59pk7yv0g55c7yxykmsy06d4dlxnas5739041ydc5f9vdd1wz";
+       version = "1.1.4";
+       sha256 = "1hg0vpm6nhdqxxpx9329gj135fqrfsw0kdlxd1ycfini69jsbxn6";
        libraryHaskellDepends = [
          base exceptions math-functions vector vector-th-unbox
        ];
···
        ];
        description = "Monoids for calculation of statistics of sample";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "monoid-subclasses" = callPackage
···
 
   "monoidal-functors" = callPackage
     ({ mkDerivation, base, bifunctors, comonad, contravariant
-     , profunctors, semigroupoids, tagged, these
+     , distributive, profunctors, semialign, semigroupoids, tagged
+     , these
      }:
      mkDerivation {
        pname = "monoidal-functors";
-       version = "0.1.1.0";
-       sha256 = "11qac7z7xy8rwdzmp3x1i7bd28xvpd13yyfi27rsn56pyq6a4rqf";
+       version = "0.2.1.0";
+       sha256 = "0fxbshb7ha6l872k77qiyv6k4056ihb8sjjgf767118azsmf130x";
        libraryHaskellDepends = [
-         base bifunctors comonad contravariant profunctors semigroupoids
-         tagged these
+         base bifunctors comonad contravariant distributive profunctors
+         semialign semigroupoids tagged these
        ];
        description = "Monoidal Functors Library";
        license = lib.licenses.mit;
···
      }) {};
 
   "monomer" = callPackage
-    ({ mkDerivation, aeson, async, attoparsec, base, bytestring
+    ({ mkDerivation, async, attoparsec, base, bytestring
      , bytestring-to-vector, c2hs, containers, data-default, exceptions
      , extra, formatting, glew, hspec, http-client, JuicyPixels, lens
-     , mtl, nanovg, OpenGLRaw, process, random, sdl2, stm, text
-     , text-show, time, transformers, vector, websockets, wreq, wuss
+     , mtl, nanovg, OpenGLRaw, process, sdl2, stm, text, text-show, time
+     , transformers, vector, wreq
      }:
      mkDerivation {
        pname = "monomer";
-       version = "1.5.0.0";
-       sha256 = "0asp7j9xmysspyv2l8fcr36flcayqyhp41139kzg00b7jglpbpyg";
-       revision = "1";
-       editedCabalFile = "1ig93calrshb8q4jp8iw0y2yqkxmd5n7xg1nabc9bp0ypacba13m";
+       version = "1.5.1.0";
+       sha256 = "13z6ls2y8d4r98dwxl8d65xf0rcs4i0v65zlq93i7yk5zcyw0s8i";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          transformers vector wreq
        ];
        librarySystemDepends = [ glew ];
+       libraryPkgconfigDepends = [ glew ];
        libraryToolDepends = [ c2hs ];
        executableHaskellDepends = [
-         aeson async attoparsec base bytestring bytestring-to-vector
-         containers data-default exceptions extra formatting http-client
-         JuicyPixels lens mtl nanovg OpenGLRaw process random sdl2 stm text
-         text-show time transformers vector websockets wreq wuss
+         async attoparsec base bytestring bytestring-to-vector containers
+         data-default exceptions extra formatting http-client JuicyPixels
+         lens mtl nanovg OpenGLRaw process sdl2 stm text text-show time
+         transformers vector wreq
        ];
        testHaskellDepends = [
          async attoparsec base bytestring bytestring-to-vector containers
···
        ];
        description = "A GUI library for writing native Haskell applications";
        license = lib.licenses.bsd3;
+       mainProgram = "dev-test-app";
      }) {inherit (pkgs) glew;};
 
   "monomer-hagrid" = callPackage
···
      }:
      mkDerivation {
        pname = "monomer-hagrid";
-       version = "0.2.0.1";
-       sha256 = "0vic013zr80wlm1gf33y8vlkpmrv6z52975dpa3ciypayd36hy2m";
+       version = "0.2.1.0";
+       sha256 = "1hgw5p8nfw12jklrd2blli0wc4z9b60bk9gf3j0l8jxpivzwakqd";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "named";
        version = "0.3.0.1";
        sha256 = "0dnp4qbhn6ci2dlp230gpq8c5z26wb2liani1myc598g2b3c2qij";
-       revision = "3";
-       editedCabalFile = "1rfli2b4asgasvgp7zjvydhxbyd0vx44vr7yck2760wz1crkzhhn";
+       revision = "4";
+       editedCabalFile = "05m3mw2prbag8bshayvvigxr70jk32398sn3n5gjv1nfhbsplwcr";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base ];
        description = "Named parameters (keyword arguments) for Haskell";
···
     ({ mkDerivation, array, base, containers, regex-compat }:
      mkDerivation {
        pname = "nofib-analyse";
-       version = "8.5.0.20180213";
-       sha256 = "04jdbbkjh0kmxn25hy7rqli8cmysvx8vbdqfnfxx35w93kpsndxf";
+       version = "9.4.4";
+       sha256 = "005a66adpsmlaj91qyf9x1f2xpnb311lqcdngnfb3rpryhjwvdzb";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ array base containers regex-compat ];
···
        pname = "numbered-semigroups";
        version = "0.1.0.0";
        sha256 = "100r6k3cwycl75mj9g1x4w4qv064v8bdaan5rsj2vnvx4w1jrhp2";
-       revision = "2";
-       editedCabalFile = "04wkhb2r275nax8wh00w6c4pxfaky190g2bsviw39jyi7wr2f33c";
+       revision = "3";
+       editedCabalFile = "1qi8cdying5l7anffawxjyjrqpvngg95aj646ahxr6wd9i96pwka";
        libraryHaskellDepends = [ base call-stack semigroups ];
        description = "A sequence of semigroups, for composing stuff in multiple spatial directions";
        license = lib.licenses.lgpl3Only;
···
   "nvim-hs" = callPackage
     ({ mkDerivation, base, bytestring, cereal, cereal-conduit, conduit
      , containers, data-default, deepseq, foreign-store, hslogger, hspec
-     , hspec-discover, HUnit, megaparsec, messagepack, mtl, network
-     , optparse-applicative, path, path-io, prettyprinter
-     , prettyprinter-ansi-terminal, QuickCheck, resourcet, stm
-     , streaming-commons, template-haskell
+     , hspec-discover, megaparsec, messagepack, mtl, network
+     , optparse-applicative, prettyprinter, prettyprinter-ansi-terminal
+     , QuickCheck, streaming-commons, template-haskell
      , template-haskell-compat-v0208, text, time, time-locale-compat
-     , transformers, transformers-base, typed-process, unliftio
-     , unliftio-core, utf8-string, vector, void
+     , typed-process, unliftio, unliftio-core, utf8-string, vector, void
      }:
      mkDerivation {
        pname = "nvim-hs";
-       version = "2.3.2.0";
-       sha256 = "1szvh65sbxk81321ml0b1iib5ziiks2l8liwkgs4z47pmb14cps9";
+       version = "2.3.2.1";
+       sha256 = "1rq4n453hc3890n4mmxkiaddfpamj4af66f9wx2hqfi40ammfgna";
        libraryHaskellDepends = [
          base bytestring cereal cereal-conduit conduit containers
          data-default deepseq foreign-store hslogger megaparsec messagepack
-         mtl network optparse-applicative path path-io prettyprinter
-         prettyprinter-ansi-terminal resourcet stm streaming-commons
-         template-haskell template-haskell-compat-v0208 text time
-         time-locale-compat transformers transformers-base typed-process
-         unliftio unliftio-core utf8-string vector void
+         mtl network optparse-applicative prettyprinter
+         prettyprinter-ansi-terminal streaming-commons template-haskell
+         template-haskell-compat-v0208 text time time-locale-compat
+         typed-process unliftio unliftio-core utf8-string vector void
        ];
        testHaskellDepends = [
-         base bytestring cereal cereal-conduit conduit containers
-         data-default foreign-store hslogger hspec hspec-discover HUnit
-         megaparsec messagepack mtl network optparse-applicative path
-         path-io prettyprinter prettyprinter-ansi-terminal QuickCheck
-         resourcet stm streaming-commons template-haskell
-         template-haskell-compat-v0208 text time time-locale-compat
-         transformers transformers-base typed-process unliftio unliftio-core
-         utf8-string vector
+         base containers data-default deepseq hspec hspec-discover
+         prettyprinter prettyprinter-ansi-terminal QuickCheck unliftio
+         unliftio-core vector void
        ];
        testToolDepends = [ hspec-discover ];
        description = "Haskell plugin backend for neovim";
···
        pname = "one-liner";
        version = "2.1";
        sha256 = "09gdivd38disddxs42179vmgca0yzk5dfm6ygicgl5l25qbizrfh";
+       revision = "1";
+       editedCabalFile = "1n6d74s0x91qi4fi6wv5yggjb1nvwk0ir580mkf67bca2x6f1cqn";
        libraryHaskellDepends = [
          base bifunctors contravariant ghc-prim linear-base profunctors
          tagged transformers
···
        ];
      }) {};
 
-  "pandoc_3_0_1" = callPackage
+  "pandoc_3_1" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, array, attoparsec, base
      , base64, binary, blaze-html, blaze-markup, bytestring
      , case-insensitive, citeproc, commonmark, commonmark-extensions
···
      }:
      mkDerivation {
        pname = "pandoc";
-       version = "3.0.1";
-       sha256 = "0yxrcr589z1wbk1ng7qg6ni7zy1vm2v5fg5df639xgk1na4sn0jc";
+       version = "3.1";
+       sha256 = "1dwnlvkisqr7lz6rnm89lh5dkg14kzd3bshqyvzg7c31gh45cygr";
        configureFlags = [ "-f-trypandoc" ];
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "pandoc-lua-engine";
-       version = "0.1";
-       sha256 = "08r7zfv8jpxscypdd814rirghmpxgh5a2wwv6bwl3ifhrxlrn4dq";
+       version = "0.1.1";
+       sha256 = "0gkpa0djv277b61n860dyc040p5sqvc1nmpq76wyvzav994jx6pj";
        libraryHaskellDepends = [
          base bytestring citeproc containers data-default doclayout
          doctemplates exceptions hslua hslua-aeson hslua-core
···
        license = lib.licenses.mit;
      }) {};
 
-  "pandoc-lua-marshal_0_2_0" = callPackage
-    ({ mkDerivation, base, bytestring, containers, exceptions, hslua
-     , hslua-list, hslua-marshalling, lua, pandoc-types, QuickCheck
-     , safe, tasty, tasty-hunit, tasty-lua, tasty-quickcheck, text
+  "pandoc-lua-marshal_0_2_1" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, exceptions
+     , hslua, hslua-list, hslua-marshalling, lua, pandoc-types
+     , QuickCheck, safe, tasty, tasty-hunit, tasty-lua, tasty-quickcheck
+     , text
      }:
      mkDerivation {
        pname = "pandoc-lua-marshal";
-       version = "0.2.0";
-       sha256 = "1sha2yxvwy31s4i1qhkk1jig37pbw5j5bxkfkwvvq0y52pl14j0g";
+       version = "0.2.1";
+       sha256 = "0mj5zb2n2wg41cmz3csvjn277hxxn6l1nfays9va2lmkgjmxpp4w";
        libraryHaskellDepends = [
-         base bytestring containers exceptions hslua hslua-list
+         aeson base bytestring containers exceptions hslua hslua-list
          hslua-marshalling lua pandoc-types safe text
        ];
        testHaskellDepends = [
-         base bytestring containers exceptions hslua hslua-list
+         aeson base bytestring containers exceptions hslua hslua-list
          hslua-marshalling lua pandoc-types QuickCheck safe tasty
          tasty-hunit tasty-lua tasty-quickcheck text
        ];
···
        pname = "parameterized-utils";
        version = "2.1.6.0";
        sha256 = "118inzvvr72bfr1pzgxglrpd2fsz0kn9hk791imygl0fv1258rb6";
+       revision = "1";
+       editedCabalFile = "126p5f4craqwlzqpj0rbrnrl83ykvkb8w6lz3sg4m9d91sqixfrh";
        libraryHaskellDepends = [
          base base-orphans constraints containers deepseq ghc-prim hashable
          hashtables indexed-traversable lens mtl profunctors
···
        ];
        description = "Provides the Pasta curves: Pallas, Vesta and their field elements Fp and Fq";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "pasta-curves";
+       broken = true;
      }) {};
 
   "pastis" = callPackage
···
        ];
        description = "Terminal-based presentations using Pandoc";
        license = lib.licenses.gpl2Only;
-       hydraPlatforms = lib.platforms.none;
        mainProgram = "patat";
-       broken = true;
      }) {};
 
   "patch" = callPackage
···
      }) {};
 
   "pathtype" = callPackage
-    ({ mkDerivation, base, deepseq, directory, old-time, QuickCheck
-     , random, semigroups, tagged, time, transformers, utility-ht
+    ({ mkDerivation, base, deepseq, directory, doctest-exitcode-stdio
+     , doctest-lib, QuickCheck, semigroups, tagged, time, transformers
+     , utility-ht
      }:
      mkDerivation {
        pname = "pathtype";
-       version = "0.8.1.1";
-       sha256 = "0322q8wd4mbp7q0cgym6mf2dxg2srp76r38kprxl9ik53s3y3p67";
-       isLibrary = true;
-       isExecutable = true;
+       version = "0.8.1.2";
+       sha256 = "1ikbl1yzlimf5yjvi6agliraqdi6mf6m7ig5rx97wh03vrx58hfk";
        libraryHaskellDepends = [
-         base deepseq directory old-time QuickCheck semigroups tagged time
-         transformers utility-ht
+         base deepseq directory doctest-exitcode-stdio QuickCheck semigroups
+         tagged time transformers utility-ht
        ];
-       testHaskellDepends = [ base random ];
+       testHaskellDepends = [
+         base doctest-exitcode-stdio doctest-lib QuickCheck
+       ];
        description = "Type-safe replacement for System.FilePath etc";
        license = lib.licenses.bsd3;
      }) {};
···
      }:
      mkDerivation {
        pname = "patrol";
-       version = "1.0.0.0";
-       sha256 = "1zlnfj8a4ijxjzqvp07fsnm40wdgpcjnqb1cn8nczhl7r1d0kil6";
+       version = "1.0.0.1";
+       sha256 = "0rzb7lsidhfbyw8z1l5958a6y766l0b0kzlmgxvci9qg5d6qzp8h";
        libraryHaskellDepends = [
          aeson base bytestring case-insensitive containers exceptions
          http-client http-types network-uri text time uuid
···
      }:
      mkDerivation {
        pname = "pcre-utils";
-       version = "0.1.8.2";
-       sha256 = "1plawzvgxww9m0vjawmkf59bfxzxf0l93g7hfwyqjq4hcc8pwq2l";
+       version = "0.1.9";
+       sha256 = "03z0hri4pwwxajn9xgnprjmaqkiqw42bypm6m8791l3hn2fabw24";
        libraryHaskellDepends = [
          array attoparsec base bytestring mtl regex-pcre-builtin vector
        ];
···
      }:
      mkDerivation {
        pname = "persistent-mysql";
-       version = "2.13.1.3";
-       sha256 = "0fm6agqwawwraw6l6kxm8lq40pm5pnjg093f574a7sdf648q21yc";
-       libraryHaskellDepends = [
-         aeson base blaze-builder bytestring conduit containers monad-logger
-         mysql mysql-simple persistent resource-pool resourcet text
-         transformers unliftio-core
-       ];
-       testHaskellDepends = [
-         aeson base bytestring conduit containers fast-logger hspec
-         http-api-data HUnit monad-logger mysql path-pieces persistent
-         persistent-qq persistent-test QuickCheck quickcheck-instances
-         resourcet text time transformers unliftio-core
-       ];
-       description = "Backend for the persistent library using MySQL database server";
-       license = lib.licenses.mit;
-     }) {};
-
-  "persistent-mysql_2_13_1_4" = callPackage
-    ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit
-     , containers, fast-logger, hspec, http-api-data, HUnit
-     , monad-logger, mysql, mysql-simple, path-pieces, persistent
-     , persistent-qq, persistent-test, QuickCheck, quickcheck-instances
-     , resource-pool, resourcet, text, time, transformers, unliftio-core
-     }:
-     mkDerivation {
-       pname = "persistent-mysql";
        version = "2.13.1.4";
        sha256 = "10i8x5byqjqgqmjwfjj56dgjhnkv7wf4bg1pad9dd1ld3crlaf8d";
        libraryHaskellDepends = [
···
        ];
        description = "Backend for the persistent library using MySQL database server";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "persistent-mysql-haskell" = callPackage
···
      }:
      mkDerivation {
        pname = "persistent-postgresql";
-       version = "2.13.5.0";
-       sha256 = "1q9hy49nfrb3azgz5rjz235d7scy27l5axkih7crskaa04hf4k8d";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         aeson attoparsec base blaze-builder bytestring conduit containers
-         monad-logger mtl persistent postgresql-libpq postgresql-simple
-         resource-pool resourcet string-conversions text time transformers
-         unliftio-core vault
-       ];
-       testHaskellDepends = [
-         aeson base bytestring containers fast-logger hspec
-         hspec-expectations hspec-expectations-lifted http-api-data HUnit
-         monad-logger path-pieces persistent persistent-qq persistent-test
-         QuickCheck quickcheck-instances resourcet text time transformers
-         unliftio unliftio-core unordered-containers vector
-       ];
-       description = "Backend for the persistent library using postgresql";
-       license = lib.licenses.mit;
-     }) {};
-
-  "persistent-postgresql_2_13_5_1" = callPackage
-    ({ mkDerivation, aeson, attoparsec, base, blaze-builder, bytestring
-     , conduit, containers, fast-logger, hspec, hspec-expectations
-     , hspec-expectations-lifted, http-api-data, HUnit, monad-logger
-     , mtl, path-pieces, persistent, persistent-qq, persistent-test
-     , postgresql-libpq, postgresql-simple, QuickCheck
-     , quickcheck-instances, resource-pool, resourcet
-     , string-conversions, text, time, transformers, unliftio
-     , unliftio-core, unordered-containers, vault, vector
-     }:
-     mkDerivation {
-       pname = "persistent-postgresql";
        version = "2.13.5.1";
        sha256 = "1snvzm01qgyiz3y12pzyy4phxwqpr7c47fi395w3cnl915y9i8rp";
        isLibrary = true;
···
        ];
        description = "Backend for the persistent library using postgresql";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "persistent-postgresql-streaming" = callPackage
···
      }:
      mkDerivation {
        pname = "persistent-sqlite";
-       version = "2.13.1.0";
-       sha256 = "1z8650nv10f6yldn9sihk54c7mlcnkxwaj956igvs6q3x3s8aa1b";
-       configureFlags = [ "-fsystemlib" ];
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         aeson base bytestring conduit containers microlens-th monad-logger
-         mtl persistent resource-pool resourcet text time transformers
-         unliftio-core unordered-containers
-       ];
-       librarySystemDepends = [ sqlite ];
-       testHaskellDepends = [
-         base bytestring conduit containers exceptions fast-logger hspec
-         HUnit microlens monad-logger mtl persistent persistent-test
-         QuickCheck resourcet system-fileio system-filepath temporary text
-         time transformers unliftio-core
-       ];
-       description = "Backend for the persistent library using sqlite3";
-       license = lib.licenses.mit;
-       maintainers = [ lib.maintainers.psibi ];
-     }) {inherit (pkgs) sqlite;};
-
-  "persistent-sqlite_2_13_1_1" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, conduit, containers
-     , exceptions, fast-logger, hspec, HUnit, microlens, microlens-th
-     , monad-logger, mtl, persistent, persistent-test, QuickCheck
-     , resource-pool, resourcet, sqlite, system-fileio, system-filepath
-     , temporary, text, time, transformers, unliftio-core
-     , unordered-containers
-     }:
-     mkDerivation {
-       pname = "persistent-sqlite";
        version = "2.13.1.1";
        sha256 = "0a7s0znm4580spgadiqy14dhvm2kzbh6v3kc4px41yyk8br6vnpj";
        configureFlags = [ "-fsystemlib" ];
···
        ];
        description = "Backend for the persistent library using sqlite3";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
        maintainers = [ lib.maintainers.psibi ];
      }) {inherit (pkgs) sqlite;};
 
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "phonetic-languages-basis";
-       version = "0.2.0.0";
-       sha256 = "0hpdf2m0wpzd680hhlsiymygmdr2sw62d2s2qj1pb5757n2kans1";
+       version = "0.3.0.0";
+       sha256 = "0qabibf3xk534pk2fsz5x3mv91zca1wczzgla9pldw4x0ginwibi";
        libraryHaskellDepends = [ base ];
-       description = "A basics of the phonetic-languages functionality";
+       description = "A basics of the phonetic-languages (PhLADiPreLiO-related) functionality";
        license = lib.licenses.mit;
      }) {};
 
···
     ({ mkDerivation, base, subG }:
      mkDerivation {
        pname = "phonetic-languages-constraints-array";
-       version = "0.1.2.0";
-       sha256 = "1s28pipyijz13sn6wni9v850w8c6n6rkiqmavhddfnichwp3gq55";
+       version = "0.2.0.0";
+       sha256 = "1pqdraxiw35kvpiivbi26pj81wakib8bzi62n2547rvj55dh5j3z";
        libraryHaskellDepends = [ base subG ];
        description = "Constraints to filter the needed permutations";
        license = lib.licenses.mit;
···
     ({ mkDerivation, base, filters-basic, mmsyn2-array }:
      mkDerivation {
        pname = "phonetic-languages-filters-array";
-       version = "0.5.0.0";
-       sha256 = "087ngarvpihrjvfnm6kbm7qfiy947r35rig44hyn5dxzq7pxqzp6";
+       version = "0.6.0.0";
+       sha256 = "1k320n79gl2n2cr0hgza4c1k4rvbw5y0vav48hvin7lrqffqmiw5";
        libraryHaskellDepends = [ base filters-basic mmsyn2-array ];
        description = "Allows to change the structure of the function output";
        license = lib.licenses.mit;
···
     ({ mkDerivation, base, subG }:
      mkDerivation {
        pname = "phonetic-languages-permutations-array";
-       version = "0.3.4.0";
-       sha256 = "06xlxh82m681ss0ycb9r6xmfcxgfq0pjsvd2s1nm43jk5a2yfxfn";
+       version = "0.4.0.0";
+       sha256 = "0z6zwzfngfhwy8lqylv06xd6lqdxrsrflhjpvqqv3hj68am5p17j";
        libraryHaskellDepends = [ base subG ];
        description = "Permutations and universal set related functions for the phonetic-languages series";
        license = lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "phonetic-languages-phonetics-basics";
-       version = "0.9.1.0";
-       sha256 = "1ahmgk42n08644h6gmrnz5p13pip18sbyaim5za0z7aaxm9qr70v";
+       version = "0.10.0.0";
+       sha256 = "0mcsmdb5mmykccmg8maw78m383549blfdbd691drhv7xk833n6sy";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "phonetic-languages-plus" = callPackage
-    ({ mkDerivation, base, bytestring, lists-flines, parallel
+    ({ mkDerivation, base, lists-flines, parallel
      , uniqueness-periods-vector-stats
      }:
      mkDerivation {
        pname = "phonetic-languages-plus";
-       version = "0.6.0.0";
-       sha256 = "03zfn9ql0gfgk2j0rgzkvbp8pd16khbc99hxzbv00ih5rjwyhzn5";
+       version = "0.7.1.0";
+       sha256 = "0bwj4zwgwy37fi6iybyl61fmlz07r87cbf46y93b21f0ffrw8084";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         base bytestring lists-flines parallel
-         uniqueness-periods-vector-stats
+         base lists-flines parallel uniqueness-periods-vector-stats
        ];
        executableHaskellDepends = [
-         base bytestring lists-flines parallel
-         uniqueness-periods-vector-stats
+         base lists-flines parallel uniqueness-periods-vector-stats
        ];
        description = "Some common shared between different packages functions";
        license = lib.licenses.mit;
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "phonetic-languages-rhythmicity";
-       version = "0.9.2.0";
-       sha256 = "0qnid53az0w4p4rb0pkxbn5z1s7r5h7cvyh4lh81c3q9bprc6cr0";
+       version = "0.10.2.0";
+       sha256 = "1ch9bd0ccmckrkfkgfy5mpm05jr0hkjbxxzwipcz1y3xf06yw5nw";
        libraryHaskellDepends = [ base ];
        description = "Allows to estimate the rhythmicity properties for the text";
        license = lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "phonetic-languages-simplified-base";
-       version = "0.6.1.0";
-       sha256 = "1217hpd1x65nl1yf50bghj8gmnv1wdwd5wbrhx454726p0fbjd7s";
+       version = "0.7.0.0";
+       sha256 = "0866pf3hyzhf2zygkk47n9yzm2z3mdm2asyq6fr8a34qrc9yyc4p";
        libraryHaskellDepends = [
          base phonetic-languages-basis phonetic-languages-permutations-array
          subG
···
      }:
      mkDerivation {
        pname = "phonetic-languages-simplified-properties-array-common";
-       version = "0.3.0.0";
-       sha256 = "1yf0z02zyqp9s441c2rg7rnfhvhiiqz0qm3i9r4jxwjr20hak333";
+       version = "0.4.0.0";
+       sha256 = "0fsjfgbqnn1bnvjiqaagh2mlzyyp5dgnvc508ps9h1iy505pm945";
        libraryHaskellDepends = [
          base phonetic-languages-basis phonetic-languages-rhythmicity
        ];
···
     ({ mkDerivation, base, mmsyn2-array, mmsyn5 }:
      mkDerivation {
        pname = "phonetic-languages-ukrainian-array";
-       version = "0.9.3.0";
-       sha256 = "0pi3dm72zw26lyp876r28ql4gxfp8h1sbr201a62g5p6jlvaixi4";
+       version = "0.10.0.0";
+       sha256 = "0ska3m86vs4xab1skzgaqdihqsnz9ag471fns880hj2lgjxn7jzb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base mmsyn2-array mmsyn5 ];
···
      }:
      mkDerivation {
        pname = "powerdns";
-       version = "0.4.1";
-       sha256 = "1ss88q1lndjvmy7bp2jxh7qbh6z57kl1q5zcv4kzjampajf1fjbi";
-       revision = "2";
-       editedCabalFile = "1gjpgq0pmhd4kv81fw399j2dqg8v9sjrfvk7m8dks0526vzr3nq3";
+       version = "0.4.2";
+       sha256 = "1pf57anqc7f90p6rhnlz78asm0xpj1wgh0642zb7g98pyxr1qx7g";
        libraryHaskellDepends = [
          aeson base base64-bytestring bytestring case-insensitive containers
          deepseq hashable servant servant-client servant-client-core text
···
      }:
      mkDerivation {
        pname = "prettyprinter-combinators";
-       version = "0.1.1";
-       sha256 = "1m6338w6cd7fsib00zs8dk16b4mxfa1vswg5bmkzafas1db6qbcg";
-       revision = "3";
-       editedCabalFile = "0kvfw63g2a6mn4sk3lf8i7g469gz5xazlniivbxxan91gcg7rfb2";
-       libraryHaskellDepends = [
-         base bimap bytestring containers dlist pretty-show prettyprinter
-         syb template-haskell text unordered-containers vector
-       ];
-       description = "Some useful combinators for the prettyprinter package";
-       license = lib.licenses.asl20;
-     }) {};
-
-  "prettyprinter-combinators_0_1_1_1" = callPackage
-    ({ mkDerivation, base, bimap, bytestring, containers, dlist
-     , pretty-show, prettyprinter, syb, template-haskell, text
-     , unordered-containers, vector
-     }:
-     mkDerivation {
-       pname = "prettyprinter-combinators";
        version = "0.1.1.1";
        sha256 = "1553qii74af7a5xxj3n6ch9vv84kr5ayd1z69x0d78lqqraibx4y";
        libraryHaskellDepends = [
···
        ];
        description = "Some useful combinators for the prettyprinter package";
        license = lib.licenses.asl20;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "prettyprinter-compat-annotated-wl-pprint" = callPackage
···
      }:
      mkDerivation {
        pname = "prettyprinter-interp";
-       version = "0.1.0.0";
-       sha256 = "0p5mqvgdmh76yndf2agrmbs3qzb9wx9rimw1jcb2xdaixjrc7gzm";
+       version = "0.2.0.0";
+       sha256 = "0ml068y49n0s6p0nq0qfv5dmpkpkbd9p06hkj582yn2a1h32x0ff";
        libraryHaskellDepends = [
          base prettyprinter string-interpolate template-haskell text
        ];
···
        libraryHaskellDepends = [ base directory mmsyn3 process sublists ];
        description = "A test suite for the complex multi files multi level processment";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "process-streaming" = callPackage
···
      }:
      mkDerivation {
        pname = "proof-assistant-bot";
-       version = "0.2.0";
-       sha256 = "1sks81xaxzz76ajcki43jy7a95d6lc5ijj3xgl5slmjd5m4fmwyc";
+       version = "0.2.1";
+       sha256 = "04vkg3yx0lviv2r8d46zh58af63pk4baaywzqf0jrqsppmqgzbg7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
 
   "publish" = callPackage
     ({ mkDerivation, base, bytestring, chronologique, core-data
-     , core-program, core-text, deepseq, directory, filepath, hspec
-     , megaparsec, pandoc, pandoc-types, template-haskell, text
-     , typed-process, unix, unordered-containers
+     , core-program, core-telemetry, core-text, deepseq, directory
+     , filepath, hspec, megaparsec, pandoc, pandoc-types
+     , safe-exceptions, template-haskell, text, typed-process, unix
+     , unordered-containers
      }:
      mkDerivation {
        pname = "publish";
-       version = "2.2.3";
-       sha256 = "150zvz40r7lwmrqv7hvn07wb0gs9rcyn37ivcdv0m0h96bzy84w3";
+       version = "2.5.3";
+       sha256 = "0sqy6q4vpjv0cmqq8iimfirhg9kmc9mjdw6a0rky9g7pybsqlrmf";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
-         base bytestring chronologique core-data core-program core-text
-         deepseq directory filepath megaparsec pandoc pandoc-types
-         template-haskell text typed-process unix unordered-containers
+         base bytestring chronologique core-data core-program core-telemetry
+         core-text deepseq directory filepath megaparsec pandoc pandoc-types
+         safe-exceptions template-haskell text typed-process unix
+         unordered-containers
        ];
        testHaskellDepends = [
-         base bytestring chronologique core-data core-program core-text
-         deepseq directory filepath hspec megaparsec pandoc pandoc-types
-         template-haskell text typed-process unix unordered-containers
+         base bytestring chronologique core-data core-program core-telemetry
+         core-text deepseq directory filepath hspec megaparsec pandoc
+         pandoc-types safe-exceptions template-haskell text typed-process
+         unix unordered-containers
        ];
        description = "Publishing tools for papers, books, and presentations";
        license = lib.licenses.mit;
···
     ({ mkDerivation, array, async, base, base16-bytestring, bytestring
      , containers, crypto-token, cryptonite, data-default-class, doctest
      , fast-logger, filepath, hspec, hspec-discover, iproute, memory
-     , network, network-byte-order, psqueues, QuickCheck, random, stm
-     , tls, unix-time, unliftio, unliftio-core, x509
+     , network, network-byte-order, network-udp, psqueues, QuickCheck
+     , random, stm, tls, unix-time, unliftio, unliftio-core, x509
+     , x509-system
      }:
      mkDerivation {
        pname = "quic";
-       version = "0.0.1";
-       sha256 = "0vwcfzkz56ldp8fx322vgxrh8g4f236zrv05rg9839x95l6jscsv";
+       version = "0.1.0";
+       sha256 = "0yv12241waj9ab4q7n1blnsv8h8rrbs7wk5xirz0p58zf6kkkbk5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          array base base16-bytestring bytestring containers crypto-token
          cryptonite data-default-class fast-logger filepath iproute memory
-         network network-byte-order psqueues random stm tls unix-time
-         unliftio unliftio-core x509
+         network network-byte-order network-udp psqueues random stm tls
+         unix-time unliftio unliftio-core x509 x509-system
        ];
        testHaskellDepends = [
          async base base16-bytestring bytestring containers cryptonite
-         doctest hspec network QuickCheck tls unix-time unliftio
+         doctest hspec network network-udp QuickCheck tls unix-time unliftio
        ];
        testToolDepends = [ hspec-discover ];
        description = "QUIC";
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "quickcheck-groups" = callPackage
+    ({ mkDerivation, base, groups, hspec, hspec-discover, pretty-show
+     , QuickCheck, quickcheck-classes, quickcheck-instances
+     , semigroupoids
+     }:
+     mkDerivation {
+       pname = "quickcheck-groups";
+       version = "0.0.0.0";
+       sha256 = "0ranwc1p7ps4f1ivbaxz18h98f3jh29hfw94zi11a27zqdyfscbg";
+       libraryHaskellDepends = [
+         base groups pretty-show QuickCheck quickcheck-classes
+         quickcheck-instances semigroupoids
+       ];
+       testHaskellDepends = [
+         base groups hspec QuickCheck quickcheck-classes
+       ];
+       testToolDepends = [ hspec-discover ];
+       doHaddock = false;
+       description = "Testing group class instances with QuickCheck";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "quickcheck-higherorder" = callPackage
     ({ mkDerivation, base, QuickCheck, tasty, tasty-hunit
      , tasty-quickcheck, test-fun
···
      }:
      mkDerivation {
        pname = "r-glpk-phonetic-languages-ukrainian-durations";
-       version = "0.4.2.0";
-       sha256 = "04m9493db98x5i2n1zpgdl6kc2lvx0fmr8w17hs89jwfr8h6k4ni";
+       version = "0.5.0.0";
+       sha256 = "1r90d6krir42qb7jw0ayfrgx0iliz6gnm96lj9sl25qhjwps39v1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.mit;
      }) {};
 
+  "rampart_2_0_0_4" = callPackage
+    ({ mkDerivation, base, hspec }:
+     mkDerivation {
+       pname = "rampart";
+       version = "2.0.0.4";
+       sha256 = "15wm7m2rj91d28bdpkmljhcfqcwp7024sqn9p0ciljf92y1h8k63";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base hspec ];
+       description = "Determine how intervals relate to each other";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "ramus" = callPackage
     ({ mkDerivation, base, criterion, hspec, QuickCheck, quickcheck-io
      }:
···
        license = lib.licenses.mit;
      }) {};
 
+  "ratel_2_0_0_5" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, case-insensitive
+     , containers, filepath, hspec, http-client, http-client-tls
+     , http-types, uuid
+     }:
+     mkDerivation {
+       pname = "ratel";
+       version = "2.0.0.5";
+       sha256 = "13cd8y318fyv0vrh9fcf8jp0iapfqkm3rb4yyjr5r04wbalnnnzw";
+       libraryHaskellDepends = [
+         aeson base bytestring case-insensitive containers http-client
+         http-client-tls http-types uuid
+       ];
+       testHaskellDepends = [
+         aeson base bytestring case-insensitive containers filepath hspec
+         http-client http-client-tls http-types uuid
+       ];
+       description = "Notify Honeybadger about exceptions";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "ratel-wai" = callPackage
     ({ mkDerivation, base, bytestring, case-insensitive, containers
      , http-client, ratel, wai
···
        ];
        description = "Notify Honeybadger about exceptions via a WAI middleware";
        license = lib.licenses.mit;
+     }) {};
+
+  "ratel-wai_2_0_0_2" = callPackage
+    ({ mkDerivation, base, bytestring, case-insensitive, containers
+     , http-client, ratel, wai
+     }:
+     mkDerivation {
+       pname = "ratel-wai";
+       version = "2.0.0.2";
+       sha256 = "14w6f9n0yr1mi9g2fq4r7fmm7zkk0lqw1fgfhpz6qdcpsx25w5fy";
+       libraryHaskellDepends = [
+         base bytestring case-insensitive containers http-client ratel wai
+       ];
+       description = "Notify Honeybadger about exceptions via a WAI middleware";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ratelimiter" = callPackage
···
        broken = true;
      }) {};
 
-  "rattletrap_12_0_0" = callPackage
+  "rattletrap_12_0_1" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, array, base, bytestring
      , containers, filepath, http-client, http-client-tls, text
      }:
      mkDerivation {
        pname = "rattletrap";
-       version = "12.0.0";
-       sha256 = "0l20d9m84mn6gkmi7hii0q80rs7nzhbmwp1dx3i5jkww42ixbyfi";
+       version = "12.0.1";
+       sha256 = "1m71a0qccqlf6l1iq4f5nf1gl26nq5rb726bm4rqsr6kp7md10g7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "reactive-banana" = callPackage
-    ({ mkDerivation, base, containers, hashable, pqueue, psqueues
-     , random, semigroups, tasty, tasty-bench, tasty-hunit, these
-     , transformers, unordered-containers, vault
-     }:
-     mkDerivation {
-       pname = "reactive-banana";
-       version = "1.3.1.0";
-       sha256 = "06cmr70cbvnvm69lnj2hkxfmznqj97rxs7y6baxpjkyhm0lsv1dl";
-       libraryHaskellDepends = [
-         base containers hashable pqueue semigroups these transformers
-         unordered-containers vault
-       ];
-       testHaskellDepends = [
-         base containers hashable pqueue psqueues semigroups tasty
-         tasty-hunit these transformers unordered-containers vault
-       ];
-       benchmarkHaskellDepends = [
-         base containers random tasty tasty-bench
-       ];
-       description = "Library for functional reactive programming (FRP)";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "reactive-banana_1_3_2_0" = callPackage
     ({ mkDerivation, base, containers, deepseq, hashable, pqueue
      , QuickCheck, random, semigroups, stm, tasty, tasty-bench
      , tasty-hunit, tasty-quickcheck, these, transformers
···
        ];
        description = "Library for functional reactive programming (FRP)";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "reactive-banana-automation" = callPackage
···
        ];
        description = "Recover run-time type information from the GHC heap";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "recursion" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "recv_0_1_0" = callPackage
+    ({ mkDerivation, base, bytestring, hspec, hspec-discover, network
+     }:
+     mkDerivation {
+       pname = "recv";
+       version = "0.1.0";
+       sha256 = "0nsdy7a0rbizgz5wpg06p9kac4chsrdxfk30paf7yjxlzxf90r7n";
+       libraryHaskellDepends = [ base bytestring network ];
+       testHaskellDepends = [ base bytestring hspec network ];
+       testToolDepends = [ hspec-discover ];
+       description = "Efficient network recv";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "red-black-record" = callPackage
     ({ mkDerivation, aeson, base, bytestring, doctest, profunctors
      , sop-core, tasty, tasty-hunit, text
···
        pname = "reflex-dom-colonnade";
        version = "0.4.6";
        sha256 = "05vw4v3mrvqrc4z349xb3nz9qhy7iisw5ylwaqq2qg4xy0mf0z5n";
+       revision = "1";
+       editedCabalFile = "1gbb1sqf45rsj0235krmhj9ifhs2p4dzbb2nz9fxilq6bi8dqivp";
        libraryHaskellDepends = [
          base colonnade containers contravariant reflex reflex-dom
          semigroups text vector
···
      }:
      mkDerivation {
        pname = "reform-happstack";
-       version = "0.2.5.5";
-       sha256 = "0knsx790vf5xvnxhfdz48gz3352z98ghy1ld7yh3rmp1apciqd35";
-       libraryHaskellDepends = [
-         base bytestring happstack-server mtl random reform text utf8-string
-       ];
-       description = "Happstack support for reform";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "reform-happstack_0_2_5_6" = callPackage
-    ({ mkDerivation, base, bytestring, happstack-server, mtl, random
-     , reform, text, utf8-string
-     }:
-     mkDerivation {
-       pname = "reform-happstack";
        version = "0.2.5.6";
        sha256 = "1v76z620b0iw3j2cr7mjs13jcf2lk800ilnl2k46jixc4zk75biy";
        libraryHaskellDepends = [
···
        ];
        description = "Happstack support for reform";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "reform-hsp" = callPackage
···
        pname = "regex-pcre-builtin";
        version = "0.95.2.3.8.44";
        sha256 = "0pn55ssrwr05c9sa9jvp0knvzjksz04wn3pmzf5dz4xgbyjadkna";
-       revision = "2";
-       editedCabalFile = "19ryjv8va9bjwhfk4v81lsvi91aj7aw1cflggywjpmw001qr419d";
+       revision = "3";
+       editedCabalFile = "071s6k97z0wiqx5rga360awgj0a031gqm725835xxszdz36w0mbv";
        libraryHaskellDepends = [
          array base bytestring containers regex-base text
        ];
···
      }:
      mkDerivation {
        pname = "rel8";
-       version = "1.4.0.0";
-       sha256 = "1i0ah0wqx0z7grm9zbvf6mx6gk7lx1xfa7svbp4dnb4k8p52b63k";
-       libraryHaskellDepends = [
-         aeson base bifunctors bytestring case-insensitive comonad
-         contravariant hasql opaleye pretty product-profunctors profunctors
-         scientific semialign semigroupoids text these time uuid
-       ];
-       testHaskellDepends = [
-         base bytestring case-insensitive containers hasql hasql-transaction
-         hedgehog mmorph scientific tasty tasty-hedgehog text time
-         tmp-postgres transformers uuid
-       ];
-       description = "Hey! Hey! Can u rel8?";
-       license = lib.licenses.bsd3;
-       maintainers = [ lib.maintainers.sternenseemann ];
-     }) {};
-
-  "rel8_1_4_1_0" = callPackage
-    ({ mkDerivation, aeson, base, bifunctors, bytestring
-     , case-insensitive, comonad, containers, contravariant, hasql
-     , hasql-transaction, hedgehog, mmorph, opaleye, pretty
-     , product-profunctors, profunctors, scientific, semialign
-     , semigroupoids, tasty, tasty-hedgehog, text, these, time
-     , tmp-postgres, transformers, uuid
-     }:
-     mkDerivation {
-       pname = "rel8";
        version = "1.4.1.0";
        sha256 = "0590pjiphpknxnc3g4y3f3rf134q9z5nbwrrbq81r1gx4nxb8d6n";
        libraryHaskellDepends = [
···
        ];
        description = "Hey! Hey! Can u rel8?";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
        maintainers = [ lib.maintainers.sternenseemann ];
      }) {};
 
···
        pname = "safecopy";
        version = "0.10.4.2";
        sha256 = "0r2mf0p82gf8vnldx477b5ykrj1x7hyg13nqfn6gzb50japs6h3i";
-       revision = "5";
-       editedCabalFile = "1qwzj9nija3kw6ijxl5nhny7vclp7x31cml3hl9fpajj5v0lhh4j";
+       revision = "6";
+       editedCabalFile = "0ii5cdg4l4ww81p7gd5m3z2jdqrs2hvqhwzrlz267nzxbws00x0b";
        libraryHaskellDepends = [
          array base bytestring cereal containers generic-data old-time
          template-haskell text time transformers vector
···
        testHaskellDepends = [ base HUnit ];
        description = "Semantic version numbers and constraints";
        license = lib.licenses.mit;
+     }) {};
+
+  "salve_2_0_0_2" = callPackage
+    ({ mkDerivation, base, HUnit }:
+     mkDerivation {
+       pname = "salve";
+       version = "2.0.0.2";
+       sha256 = "04281bi8vm78r5gsbfc1whkkrrivw3pa3s3wx33q1nh9ip0q7b6a";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base HUnit ];
+       description = "Semantic version numbers and constraints";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "salvia" = callPackage
···
        pname = "semigroupoids";
        version = "5.3.7";
        sha256 = "169pjrm7lxjxrqj5q1iyl288bx5nj8n0pf2ri1cclxccqnvcsibd";
+       revision = "1";
+       editedCabalFile = "063xzbp4p93kbaygn26rzs4wmwf01mcj7d4qfsiwf39gd0wkf2dc";
        libraryHaskellDepends = [
          base base-orphans bifunctors comonad containers contravariant
          distributive hashable tagged template-haskell transformers
···
 
   "sensei" = callPackage
     ({ mkDerivation, ansi-terminal, base, bytestring, directory
-     , filepath, fsnotify, hspec, hspec-discover, hspec-wai, http-client
-     , http-types, mockery, network, process, silently, stm, text, time
-     , unix, wai, warp
+     , filepath, fsnotify, hspec, hspec-contrib, hspec-discover
+     , hspec-wai, http-client, http-types, mockery, network, process
+     , QuickCheck, silently, stm, text, time, unix, wai, warp
      }:
      mkDerivation {
        pname = "sensei";
-       version = "0.6.2";
-       sha256 = "168znkrlciywsqpgbssnz2n2w1w6240j1cxk83bpzlflg7q934ps";
-       revision = "1";
-       editedCabalFile = "0i4k8zdyvv3ypwqg2x5s4p0dgszpgb6g8wc0s9zi05fyzhizpi4s";
+       version = "0.7.0";
+       sha256 = "032vn93gcya2drlcy4mw2rmncq9i21zrr53kdalsxa7xfsds93hw";
        isLibrary = false;
        isExecutable = true;
+       enableSeparateDataOutput = true;
        executableHaskellDepends = [
          ansi-terminal base bytestring directory filepath fsnotify
          http-client http-types network process stm text time unix wai warp
        ];
        testHaskellDepends = [
          ansi-terminal base bytestring directory filepath fsnotify hspec
-         hspec-wai http-client http-types mockery network process silently
-         stm text time unix wai warp
+         hspec-contrib hspec-wai http-client http-types mockery network
+         process QuickCheck silently stm text time unix wai warp
        ];
        testToolDepends = [ hspec-discover ];
        description = "Automatically run Hspec tests on file modifications";
···
        ];
        description = "A package with basic parsing utilities for several Bioinformatic data formats";
        license = lib.licenses.gpl3Only;
+     }) {};
+
+  "sequence-formats_1_7_0" = callPackage
+    ({ mkDerivation, attoparsec, base, bytestring, containers, errors
+     , exceptions, foldl, hspec, lens-family, pipes, pipes-attoparsec
+     , pipes-bytestring, pipes-safe, tasty, tasty-hunit, transformers
+     , vector
+     }:
+     mkDerivation {
+       pname = "sequence-formats";
+       version = "1.7.0";
+       sha256 = "09ygkfgn381312miqlwxb9ypyixbiaal2hmh0m9zs7szlp4fcp46";
+       libraryHaskellDepends = [
+         attoparsec base bytestring containers errors exceptions foldl
+         lens-family pipes pipes-attoparsec pipes-bytestring pipes-safe
+         transformers vector
+       ];
+       testHaskellDepends = [
+         base bytestring containers foldl hspec pipes pipes-safe tasty
+         tasty-hunit transformers vector
+       ];
+       description = "A package with basic parsing utilities for several Bioinformatic data formats";
+       license = lib.licenses.gpl3Only;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "sequenceTools" = callPackage
···
        broken = true;
      }) {};
 
+  "servant-elm_0_7_3" = callPackage
+    ({ mkDerivation, aeson, base, Diff, directory, elm-bridge, hspec
+     , HUnit, lens, servant, servant-client, servant-foreign, text
+     , wl-pprint-text
+     }:
+     mkDerivation {
+       pname = "servant-elm";
+       version = "0.7.3";
+       sha256 = "183grmmfa300mg7mjaqzhryprf9yzf7fnv1hwgsdv5q90n5v17lz";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base directory elm-bridge lens servant servant-foreign text
+         wl-pprint-text
+       ];
+       testHaskellDepends = [
+         aeson base Diff elm-bridge hspec HUnit servant servant-client text
+       ];
+       description = "Automatically derive Elm functions to query servant webservices";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "servant-errors" = callPackage
     ({ mkDerivation, aeson, base, base-compat, bytestring
      , http-api-data, http-media, http-types, markdown-unlit, scientific
···
      }:
      mkDerivation {
        pname = "servant-lucid";
-       version = "0.9.0.5";
-       sha256 = "0yhxj62hhqk0269wk3062dpb39qp7khz1gjqyqqmzfbb4v5x8mfz";
-       libraryHaskellDepends = [ base http-media lucid servant text ];
-       testHaskellDepends = [ base lucid servant-server wai warp ];
-       description = "Servant support for lucid";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "servant-lucid_0_9_0_6" = callPackage
-    ({ mkDerivation, base, http-media, lucid, servant, servant-server
-     , text, wai, warp
-     }:
-     mkDerivation {
-       pname = "servant-lucid";
        version = "0.9.0.6";
        sha256 = "1z894w9hfcnsdwivy2qvwa254l9d9bsbdjvzlvksxy92aw1p6fd0";
        libraryHaskellDepends = [ base http-media lucid servant text ];
        testHaskellDepends = [ base lucid servant-server wai warp ];
        description = "Servant support for lucid";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "servant-machines" = callPackage
···
        pname = "servant-openapi3";
        version = "2.0.1.6";
        sha256 = "1hxz3n6l5l8p9s58sjilrn4lv1z17kfik0xdh05v5v1bzf0j2aij";
+       revision = "1";
+       editedCabalFile = "0ixl07scnz0664sxbl7k784mi0pd2vdpsgizwnz9ik7j8hjqdi5c";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          aeson aeson-pretty base base-compat bytestring hspec http-media
···
      }:
      mkDerivation {
        pname = "servant-serialization";
-       version = "0.2.0";
-       sha256 = "159vbiifpjn86vid0r88sgrm639pqaqzyvxmv1yssx6pr7yw3xb6";
+       version = "0.2.1";
+       sha256 = "02xrbdwcnm9i33i386gnnigz1hk76z69iywxi2szzk0l8jnsgd32";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "shelly";
-       version = "1.10.0";
-       sha256 = "0hgzh0rrhipir8378civ5mwvkvcsd063jm2pyx8dqngdynph0h65";
-       revision = "1";
-       editedCabalFile = "07c1rjwvg2ldam6yaksvrr9f703b7d1rcw0482ns5yi2f7y1kczp";
+       version = "1.10.0.1";
+       sha256 = "0nm3yg6mhgxj670xn18v4zvzzqxqv9b1r6psdmsppgqny1szqm3x";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "siphon";
        version = "0.8.2.0";
        sha256 = "1nw8c9f7hyg26nldxkl4hkvdva5sgsyn7qqkqqrvp12qfsvdnqfi";
+       revision = "1";
+       editedCabalFile = "1hfvrh99bvh10gdw6z86scd8vzz56dkdfc8720hm7qiypdbgj8cr";
        libraryHaskellDepends = [
          attoparsec base bytestring colonnade semigroups streaming text
          transformers vector
···
      }:
      mkDerivation {
        pname = "skylighting";
-       version = "0.13.2";
-       sha256 = "0dh4k39ddqca5px2d06ni8n9x3mifvkwd5i16077l472dwjcs879";
+       version = "0.13.2.1";
+       sha256 = "0lq68cavdp73praa2h8cclgnrh53fqg9x4r6q3fsvnr8lbcb4x7h";
        configureFlags = [ "-fexecutable" ];
        isLibrary = true;
        isExecutable = true;
···
      }:
      mkDerivation {
        pname = "skylighting-core";
-       version = "0.13.2";
-       sha256 = "0iwzfgynj3l8rnvvrl4kg0i1n31rz15da8cf1943gw1vcfh6w585";
+       version = "0.13.2.1";
+       sha256 = "1ib59w12f7mlh10nwj7404jv8x7z2r58g8a9ndr6ag8pxnf81054";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
     ({ mkDerivation, base, hspec, text, text-icu }:
      mkDerivation {
        pname = "slugger";
-       version = "0.1.0.1";
-       sha256 = "1d1cx9c3qv8yd7q72q2vjp16mcsim4aw47dxv880q6xi5nmddcka";
+       version = "0.1.0.2";
+       sha256 = "003f44pc1q2mrprzxm492gd1v1y568k8m7vxdv5ys5zikz8gpqxy";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base text text-icu ];
···
     ({ mkDerivation, base, bytestring }:
      mkDerivation {
        pname = "smtlib-backends";
-       version = "0.2";
-       sha256 = "0p77m8f937zsnkxwc44pwhbm2dghbvw7f0xr867f07b1kzl6vpdk";
-       revision = "1";
-       editedCabalFile = "169qn41nvl5lcx41rhyj64nf7pxqabqh53f83m8wc0ydnim7jdc1";
+       version = "0.3";
+       sha256 = "13pyic8zq0dv7w529pciw0zfpzx63mrf3bq5nillsswbk0czv0qw";
        libraryHaskellDepends = [ base bytestring ];
        description = "Low-level functions for SMT-LIB-based interaction with SMT solvers";
        license = lib.licenses.mit;
···
      }) {};
 
   "smtlib-backends-process" = callPackage
-    ({ mkDerivation, async, base, bytestring, data-default
-     , smtlib-backends, smtlib-backends-tests, tasty, tasty-hunit
-     , typed-process
+    ({ mkDerivation, async, base, bytestring, process, smtlib-backends
+     , smtlib-backends-tests, tasty, tasty-hunit
      }:
      mkDerivation {
        pname = "smtlib-backends-process";
-       version = "0.2";
-       sha256 = "11jcx0ixf0yd9wjc77xvfsr1hvb5awr1wxvl18y54jdlkff8qfzz";
-       revision = "1";
-       editedCabalFile = "1shxanngvq2xfxqcxa4pkk5r570fbajvbrnwal0xnrljnf1rrfv5";
+       version = "0.3";
+       sha256 = "0jc7fmf3x53w8v0a8cj8v8r2f4gpn1jhndl80hyqzsblvrw5hcfg";
        libraryHaskellDepends = [
-         async base bytestring data-default smtlib-backends typed-process
+         base bytestring process smtlib-backends
        ];
        testHaskellDepends = [
-         base bytestring data-default smtlib-backends smtlib-backends-tests
-         tasty tasty-hunit typed-process
+         async base bytestring process smtlib-backends smtlib-backends-tests
+       sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
        ];
        description = "An SMT-LIB backend running solvers as external processes";
        license = lib.licenses.mit;
···
     ({ mkDerivation, base, smtlib-backends, tasty, tasty-hunit }:
      mkDerivation {
        pname = "smtlib-backends-tests";
-       version = "0.2";
-       sha256 = "14n5qdan4kbcc9h1agdnvc4hbaycmpm2srdx0c19g76iwc3598c8";
+       version = "0.3";
+       sha256 = "0lj4bpl4nkw6w2hfjzz16zmrbaj5g3myvbmzlsc5rdsz0xwisfb8";
        libraryHaskellDepends = [ base smtlib-backends tasty tasty-hunit ];
        description = "Testing SMT-LIB backends";
        license = lib.licenses.mit;
···
      }) {};
 
   "smtlib-backends-z3" = callPackage
-    ({ mkDerivation, base, bytestring, containers, gomp, inline-c
-     , smtlib-backends, smtlib-backends-tests, tasty, tasty-hunit, z3
+    ({ mkDerivation, base, bytestring, gomp, smtlib-backends
+     , smtlib-backends-tests, tasty, tasty-hunit, z3
      }:
      mkDerivation {
        pname = "smtlib-backends-z3";
-       version = "0.2";
-       sha256 = "0ar2ian2ap2zwq7x2vr4pf2ilkhfdkxl23mc4kga0hrq2n0nknf0";
-       revision = "1";
-       editedCabalFile = "1j38qi4025krwcqylkvv4n1vn2jh376ib6a9ii2sjz9k18xwnmin";
-       libraryHaskellDepends = [
-         base bytestring containers inline-c smtlib-backends
-       ];
+       version = "0.3";
+       sha256 = "1dny8jmkx1aclq5sbn4kgnpn0sg1rf34za0j6ppggzmh647aim8l";
+       libraryHaskellDepends = [ base bytestring smtlib-backends ];
        librarySystemDepends = [ gomp z3 ];
        testHaskellDepends = [
          base bytestring smtlib-backends smtlib-backends-tests tasty
···
      }:
      mkDerivation {
        pname = "snap-core";
-       version = "1.0.5.0";
-       sha256 = "0hf671g7h4nikfvi05q3mmcxhfcsh874dkansssn0mc68k9fsak4";
-       revision = "3";
-       editedCabalFile = "02r6plphl4vqig3xap9amdib0qjd98nqpn5jhy6hsbiwh3p7cy9b";
+       version = "1.0.5.1";
+       sha256 = "00h5xijkjvnhcgxpw3vmkpf5nwfpknqflvxgig6gvsy4wahc2157";
        libraryHaskellDepends = [
          attoparsec base bytestring bytestring-builder case-insensitive
          containers directory filepath hashable HUnit io-streams lifted-base
···
      }:
      mkDerivation {
        pname = "snap-server";
-       version = "1.1.2.0";
-       sha256 = "0w4yv9a5ilpma0335ariwap2iscmdbaaif88lq3cm7px910nyc4j";
-       revision = "2";
-       editedCabalFile = "0dzsn3y7jnha1jbp0n5igjrg4cb8kggps798rlix60d66iy8r1l2";
+       version = "1.1.2.1";
+       sha256 = "0znadz0av6k31s8d175904d2kajxayl38sva3dqh5ckdfkymfx54";
        configureFlags = [ "-fopenssl" ];
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         attoparsec base blaze-builder bytestring bytestring-builder
-         case-insensitive clock containers filepath HsOpenSSL io-streams
-         io-streams-haproxy lifted-base mtl network old-locale
-         openssl-streams snap-core text time transformers unix unix-compat
-         vector
+         attoparsec base blaze-builder bytestring case-insensitive clock
+         containers filepath HsOpenSSL io-streams io-streams-haproxy
+         lifted-base mtl network old-locale openssl-streams snap-core text
+         time transformers unix unix-compat vector
        ];
        testHaskellDepends = [
          attoparsec base base16-bytestring blaze-builder bytestring
-         bytestring-builder case-insensitive clock containers deepseq
-         directory filepath HsOpenSSL http-common http-streams HUnit
-         io-streams io-streams-haproxy lifted-base monad-control mtl network
-         old-locale openssl-streams parallel QuickCheck random snap-core
-         test-framework test-framework-hunit test-framework-quickcheck2 text
-         threads time transformers unix unix-compat vector
+         case-insensitive clock containers deepseq directory filepath
+         HsOpenSSL http-common http-streams HUnit io-streams
+         io-streams-haproxy lifted-base monad-control mtl network old-locale
+         openssl-streams parallel QuickCheck random snap-core test-framework
+         test-framework-hunit test-framework-quickcheck2 text threads time
+         transformers unix unix-compat vector
        ];
        benchmarkHaskellDepends = [
          attoparsec base blaze-builder bytestring bytestring-builder
···
      }:
      mkDerivation {
        pname = "sqlite-easy";
-       version = "0.2.0.1";
-       sha256 = "03sgw1g1iqkf1rv3dz5y9jh7z6iripx8dz9cs5ixznislsxkmg5l";
+       version = "1.0.0.0";
+       sha256 = "0w8mdfx4cwppdadbhqrcsl3lhwwmj7qv0r9r11lcm7y9frah7c02";
        libraryHaskellDepends = [
          base bytestring direct-sqlite migrant-core mtl resource-pool text
          unliftio-core
···
 
   "stack-hpc-coveralls" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, deepseq
-     , directory, docopt, filepath, hlint, hpc, hspec, hspec-contrib
+     , directory, docopt, filepath, hpc, hspec, hspec-contrib
      , http-client, HUnit, lens, lens-aeson, process, pureMD5, text
-     , time, unordered-containers, utf8-string, wreq, yaml
+     , time, utf8-string, wreq, yaml
      }:
      mkDerivation {
        pname = "stack-hpc-coveralls";
-       version = "0.0.4.0";
-       sha256 = "1xzjwngxidxd5xb470d2ans7swcdca14k3ilk758ravqsnk6xfyf";
+       version = "0.0.7.0";
+       sha256 = "1vf7h7a4mxxghmc3v5xys5jj3mxm1qkhqjkj92bkb4706gvph8a3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson base bytestring containers directory filepath hpc http-client
-         lens lens-aeson process pureMD5 text unordered-containers
-         utf8-string wreq yaml
+         lens lens-aeson process pureMD5 text utf8-string wreq yaml
        ];
        executableHaskellDepends = [ aeson base bytestring docopt ];
        testHaskellDepends = [
-         aeson base containers deepseq hlint hpc hspec hspec-contrib HUnit
-         time
+         aeson base containers deepseq hpc hspec hspec-contrib HUnit time
        ];
        description = "Initial project template from stack";
        license = lib.licenses.isc;
···
      }:
      mkDerivation {
        pname = "stackctl";
-       version = "1.3.0.1";
-       sha256 = "09328aw0bxps541nkb5h9r2v7lsqnsv2wv27r693r8a9fw9lsqxj";
+       version = "1.4.0.0";
+       sha256 = "1w435rqmgcfxqddjds8bgzkbily97ga6hjhs0cbk15yjm0xswv08";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "stm";
        version = "2.5.1.0";
        sha256 = "11c84d5qqvw2kfx6arw0vaf9h7pxwnyw8xvaf7fxjmhg4p8x16ib";
+       revision = "1";
+       editedCabalFile = "0wq35b8f0w577byhv0k1954pcy5bbv22w34qln0nlz62x8sgw1kr";
        libraryHaskellDepends = [ array base ];
        description = "Software Transactional Memory";
        license = lib.licenses.bsd3;
···
     ({ mkDerivation, base, hspec, stm }:
      mkDerivation {
        pname = "stm-incremental";
-       version = "0.1.0.2";
-       sha256 = "0fynnynx395r9mgm40w2nsb661vy9yaj7wxwfz206yrbpwrvd9vz";
+       version = "0.1.1.0";
+       sha256 = "15fymixnlbbdnpwqlnv83yzyx89a2x8y3h8d95xb4ad1d4fs79z3";
        libraryHaskellDepends = [ base stm ];
        testHaskellDepends = [ base hspec stm ];
        description = "A library for constructing incremental computations";
···
      }:
      mkDerivation {
        pname = "stooq-api";
-       version = "0.4.1.0";
-       sha256 = "0kjkccqwfr9bdlca8mw7ryw0jr88zs9ap9s9f2idzbdqdqavidiq";
+       version = "0.4.2.0";
+       sha256 = "0cfhmicx1z4biscn65ya5brqm606dxfnbi30f67k2w4km5vhs3d8";
        libraryHaskellDepends = [
          base bytestring cassava lens text time utf8-string vector wreq
        ];
···
        pname = "streaming-postgresql-simple";
        version = "0.2.0.5";
        sha256 = "1gaj099hxdvyzmzz6z0s1kzv3qqv3py609jz7cp2j3f6497dhdqa";
-       revision = "1";
-       editedCabalFile = "11c8gc25bzqxa4mxj0shry5hhhll8i3yv6bspznl1d7gz3pxhrp4";
+       revision = "2";
+       editedCabalFile = "04vw6sd2h9pdxq28wvxgwp708z4795fm0k1sz9d5l2h21k8ikdq9";
        libraryHaskellDepends = [
          base bytestring exceptions postgresql-libpq postgresql-simple
          resourcet safe-exceptions streaming transformers
···
      }:
      mkDerivation {
        pname = "string-interpreter";
-       version = "0.7.0.0";
-       sha256 = "0j8q9vps7r3vd71j4slz540y8a3bbh1c2hdn5d9g2892984chjb2";
+       version = "0.8.0.0";
+       sha256 = "0ycd25sxvzjd2b19d2d5qs5wi8yy4bd9ayk16kpwm9wcs2xi99p1";
        libraryHaskellDepends = [
          base cli-arguments phonetic-languages-basis
          phonetic-languages-permutations-array
···
     ({ mkDerivation, base, bytestring, text }:
      mkDerivation {
        pname = "stripe-concepts";
-       version = "1.0.3.1";
-       sha256 = "1mi538f8nm90mygrcv6w90bxf0d0lc4qxkbrq19j35l9r1xlm5bk";
+       version = "1.0.3.2";
+       sha256 = "1gvfqqfaxzgdyq03p7c6kys5bc6frpm5wsm8zsg8rk50wh18gzmg";
        libraryHaskellDepends = [ base bytestring text ];
        description = "Types for the Stripe API";
        license = lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "stripe-scotty";
-       version = "1.1.0.2";
-       sha256 = "123l1khqd0ilcihrij1givz4lg2jns2r2iyf90yjh7zdva1xf507";
-       revision = "1";
-       editedCabalFile = "0rr2vyw1vpa4psxqq2x9lsp67lgm0pylmnsnixm681qa6pykjnhr";
+       version = "1.1.0.3";
+       sha256 = "10nfpn0rsknnbir4ghad7rygp2l0rsfkd74ipgz76b60k23x4kj9";
        libraryHaskellDepends = [
          aeson base bytestring http-types scotty stripe-concepts
          stripe-signature text
···
      }:
      mkDerivation {
        pname = "stripe-signature";
-       version = "1.0.0.14";
-       sha256 = "0r982h1vd06yd1kyhyqf3s982a34amlnfzwykg3cs6pscpqbg7mz";
+       version = "1.0.0.15";
+       sha256 = "0p2m6lrl6sh44919wggzb3xpc29ib6khpac70zrx8s4f0iwrpyq4";
        libraryHaskellDepends = [
          base base16-bytestring bytestring cryptohash-sha256 stripe-concepts
          text
        ];
        testHaskellDepends = [
-         base base16-bytestring bytestring stripe-concepts text
+         base base16-bytestring bytestring cryptohash-sha256 stripe-concepts
+         text
        ];
        description = "Verification of Stripe webhook signatures";
        license = lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "stripe-wreq";
-       version = "1.0.1.14";
-       sha256 = "01z0hqqnnc2g8q0bzj4brjmd9wmpjda4rlk770brvk9ip9mjdlys";
-       revision = "2";
-       editedCabalFile = "1ijsspbd5in2jv1kcz78y0xxi09px60n51snfx9b49dsjnh2yniv";
+       version = "1.0.1.15";
+       sha256 = "0w9wa08i53k2557hd5cb0a8m65b6993j2dn9bd9g8p6j6j77cjcp";
        libraryHaskellDepends = [
          aeson base bytestring lens stripe-concepts text wreq
        ];
···
        license = lib.licenses.mit;
      }) {};
 
+  "strive_6_0_0_5" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, data-default, gpolyline
+     , http-client, http-client-tls, http-types, template-haskell, text
+     , time, transformers
+     }:
+     mkDerivation {
+       pname = "strive";
+       version = "6.0.0.5";
+       sha256 = "13m05mxw3z0ji7z6sr05v1i15xvaf4kyhn2cqqrpzxhzf44m2bvk";
+       libraryHaskellDepends = [
+         aeson base bytestring data-default gpolyline http-client
+         http-client-tls http-types template-haskell text time transformers
+       ];
+       description = "A client for the Strava V3 API";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "strong-path" = callPackage
     ({ mkDerivation, base, exceptions, filepath, hashable, hspec, path
      , tasty, tasty-discover, tasty-hspec, tasty-quickcheck
···
      }:
      mkDerivation {
        pname = "structs";
-       version = "0.1.6";
-       sha256 = "0wzbhsvix46aans0hdm11pvsigk1lxpdaha2sxslx0ip1xsdg0gk";
-       revision = "1";
-       editedCabalFile = "1vpi14bc8x53dxzcyya39zr287kyfrjxiy5z5lwfkf63dmsrbd28";
-       libraryHaskellDepends = [
-         base deepseq ghc-prim primitive template-haskell th-abstraction
-       ];
-       testHaskellDepends = [
-         base primitive QuickCheck tasty tasty-hunit tasty-quickcheck
-       ];
-       description = "Strict GC'd imperative object-oriented programming with cheap pointers";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "structs_0_1_7" = callPackage
-    ({ mkDerivation, base, deepseq, ghc-prim, primitive, QuickCheck
-     , tasty, tasty-hunit, tasty-quickcheck, template-haskell
-     , th-abstraction
-     }:
-     mkDerivation {
-       pname = "structs";
        version = "0.1.7";
        sha256 = "072gbzxh0cnrdmbwmksqfrdvv7xhsamjrmgd6vya17md76mqndab";
        libraryHaskellDepends = [
···
        ];
        description = "Strict GC'd imperative object-oriented programming with cheap pointers";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "structural-induction" = callPackage
···
      }:
      mkDerivation {
        pname = "supply-next";
-       version = "0.0.1.1";
-       sha256 = "0xvihbw7732w6n8qrfhdb78d8n206v5yd3ap26dcvwja58s7w7y1";
+       version = "0.0.1.2";
+       sha256 = "110j4ppkw155hdlz00wbzc9z3m0mqf4dl6pqcaigcqg624m0ppqk";
        libraryHaskellDepends = [
          base gambler integer-types quaalude supply-chain transformers
        ];
···
      , optparse-applicative, parser-combinators, prettyprinter
      , QuickCheck, random, servant, servant-server, simple-enumeration
      , split, stm, syb, tagged, tasty, tasty-expected-failure
-     , tasty-hunit, tasty-quickcheck, template-haskell, text
+     , tasty-hunit, tasty-quickcheck, template-haskell, text, text-rope
      , text-zipper, time, transformers, unification-fd
      , unordered-containers, vector, vty, wai, warp, witch, word-wrap
      , yaml
      }:
      mkDerivation {
        pname = "swarm";
-       version = "0.2.0.0";
-       sha256 = "1f1fp4yia54j5x6kxkrsdlj9y2859gz22k4r3pphfiadfiw1gww3";
+       version = "0.3.0.1";
+       sha256 = "0b0ji08csj07ragr8sabn84l1zzlchvm0nz8rd7541fwm5b3jb5f";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
          lsp megaparsec minimorph mtl murmur3 natural-sort
          parser-combinators prettyprinter random servant servant-server
          simple-enumeration split stm syb tagged template-haskell text
-         text-zipper time unification-fd unordered-containers vector vty wai
-         warp witch word-wrap yaml
+         text-rope text-zipper time unification-fd unordered-containers
+         vector vty wai warp witch word-wrap yaml
        ];
        executableHaskellDepends = [
          base githash optparse-applicative text
···
      }:
      mkDerivation {
        pname = "sydtest-webdriver-screenshot";
-       version = "0.0.0.0";
-       sha256 = "00w3ijgwwplgg0310qnc56c5a50i1vnzn94np4jscjv4aw849s1b";
+       version = "0.0.0.1";
+       sha256 = "0wh481za6x9bq4axazq6zpm0cgi98hsh4xiy02c90fxybzdk4mg9";
        libraryHaskellDepends = [
-         base bytestring http-types JuicyPixels mtl network-uri path path-io
-         sydtest sydtest-wai sydtest-webdriver webdriver
+         base bytestring JuicyPixels mtl path path-io sydtest
+         sydtest-webdriver webdriver
        ];
        testHaskellDepends = [
          base http-types network-uri sydtest sydtest-wai sydtest-webdriver
···
      }:
      mkDerivation {
        pname = "sydtest-webdriver-yesod";
-       version = "0.0.0.0";
-       sha256 = "10q112rsj5gh3ijy7pf93zslsxqk7jim1i1fslqpld71wqw2abr2";
+       version = "0.0.0.1";
+       sha256 = "0rfsr45ff7p81y157x06qspjp00ng2kikw84c2ciw4bfjicdvvsr";
        libraryHaskellDepends = [
-         base bytestring http-client http-types mtl network-uri path path-io
-         sydtest sydtest-wai sydtest-webdriver sydtest-yesod text webdriver
-         yesod
+         base bytestring http-client http-types mtl network-uri sydtest
+         sydtest-wai sydtest-webdriver sydtest-yesod text webdriver yesod
        ];
        testHaskellDepends = [
          base path path-io sydtest sydtest-webdriver yesod
···
        pname = "tasty-json";
        version = "0.1.0.0";
        sha256 = "0k6zzi2w675pghxfv5y6m67n2cv8bb22dq9zgb5yfwycfj3va4bp";
-       revision = "1";
-       editedCabalFile = "0jk27ld4l435nnzc80wg6b46ibmc0cmbb0k3hpp58yxbyldr6xdr";
+       revision = "2";
+       editedCabalFile = "0739101s43mvv3f3fjchbj25ggjvdxf2n7an4gqsbcqz7s1lskdf";
        libraryHaskellDepends = [
          base bytestring containers stm tagged tasty text
        ];
···
        pname = "tasty-rerun";
        version = "1.1.18";
        sha256 = "0sccp5zx9v2rx741nbmgd8mzjhy5m4v74hk26d23xz93ph8aqx7s";
-       revision = "3";
-       editedCabalFile = "0091arn90cx5rzn5n2bpb9alzybwraf9yj7hb0bwdfyamzpf3pkb";
+       revision = "4";
+       editedCabalFile = "1i2van23247h62sz94kjiyyb6xvz88z6kkjqqsbxi4m74pga27hn";
        libraryHaskellDepends = [
          base containers mtl optparse-applicative split stm tagged tasty
          transformers
···
        mainProgram = "hello-bot";
      }) {};
 
+  "telegram-bot-api" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, base, bytestring, cron
+     , filepath, hashable, http-api-data, http-client, http-client-tls
+     , monad-control, mtl, pretty-show, profunctors, servant
+     , servant-client, servant-multipart-api, servant-multipart-client
+     , servant-server, split, stm, template-haskell, text, time
+     , transformers, unordered-containers, warp, warp-tls
+     }:
+     mkDerivation {
+       pname = "telegram-bot-api";
+       version = "6.5";
+       sha256 = "176c9fhfa2vl9cqwqcsad0p212w27ni4q38r7fbp1qkwxd5xrd02";
+       libraryHaskellDepends = [
+         aeson aeson-pretty base bytestring cron filepath hashable
+         http-api-data http-client http-client-tls monad-control mtl
+         pretty-show profunctors servant servant-client
+         servant-multipart-api servant-multipart-client servant-server split
+         stm template-haskell text time transformers unordered-containers
+         warp warp-tls
+       ];
+       description = "Easy to use library for building Telegram bots. Exports Telegram Bot API.";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "telegram-bot-simple" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, base, bytestring, cron
      , filepath, hashable, http-api-data, http-client, http-client-tls
···
      }:
      mkDerivation {
        pname = "telegram-bot-simple";
-       version = "0.6.1";
-       sha256 = "01rxkgzfvqxgnxlcw70rhs84ygvccydlki827f3icqwfpm7cn6vn";
+       version = "0.6.2";
+       sha256 = "10w9lq0ns1ycn0agmpp5114yfjrd20vwq050jxnfyk603aaw49k1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "telegram-bot-simple_0_10" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, base, bytestring, cron
+     , filepath, hashable, http-api-data, http-client, http-client-tls
+     , monad-control, mtl, pretty-show, profunctors, servant
+     , servant-client, servant-multipart-api, servant-multipart-client
+     , servant-server, split, stm, telegram-bot-api, template-haskell
+     , text, time, transformers, unordered-containers, warp, warp-tls
+     }:
+     mkDerivation {
+       pname = "telegram-bot-simple";
+       version = "0.10";
+       sha256 = "1xkmmcxnv052hfc0bwr3w6ilrf173npdpc0v5pwrhkz0kd88xxvh";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson aeson-pretty base bytestring cron filepath hashable
+         http-api-data http-client http-client-tls monad-control mtl
+         pretty-show profunctors servant servant-client
+         servant-multipart-api servant-multipart-client servant-server split
+         stm telegram-bot-api template-haskell text time transformers
+         unordered-containers warp warp-tls
+       ];
+       description = "Easy to use library for building Telegram bots";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "telegram-raw-api" = callPackage
     ({ mkDerivation, aeson, base, bytestring, deriving-aeson
      , generic-lens, hashable, http-client, http-client-tls, http-media
···
        pname = "test-lib";
        version = "0.4";
        sha256 = "0jp0k27vvdz4lfrdi7874j7gnnn051kvqfn1k3zg1ap4m9jzyb45";
-       revision = "1";
-       editedCabalFile = "0hkscmcvgpqabc7fb8xln9grn31dw1p2cr6277l3snivkanc8889";
+       revision = "2";
+       editedCabalFile = "1l3xfmwhpvzixwx3s2zhc1ah9bjnp0yjr7d2cymhfnlpwv5jc47q";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "text-time";
-       version = "0.3.1";
-       sha256 = "1p0vdhvpcz07wiam3hsi7fixknb6shxlhvg624vksacg06qkck41";
+       version = "0.3.2";
+       sha256 = "0gi90lb4dvin9h9j2148fxg9z63y14yssqqa868q1spqpmnz1pim";
        libraryHaskellDepends = [ attoparsec base formatting text time ];
        testHaskellDepends = [
          attoparsec base Cabal formatting hspec QuickCheck text time
···
        testHaskellDepends = [ base hspec QuickCheck text ];
        description = "A text editor zipper library";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "text-zipper_0_13" = callPackage
+    ({ mkDerivation, base, deepseq, hspec, QuickCheck, text, vector }:
+     mkDerivation {
+       pname = "text-zipper";
+       version = "0.13";
+       sha256 = "1acq583wmgb53viqslbkgl454300fawg5lryxddfiy1mqk3iqlh6";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [ base deepseq text vector ];
+       testHaskellDepends = [ base hspec QuickCheck text ];
+       description = "A text editor zipper library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "text-zipper-monad" = callPackage
···
      }:
      mkDerivation {
        pname = "th-expand-syns";
-       version = "0.4.10.0";
-       sha256 = "044h1hv4b0ihpwr9wndj55fa843cbzqp1difgj9wyy3mw925higm";
+       version = "0.4.11.0";
+       sha256 = "1l7pkc16vnjgiam31745av14j7ngnr5mqmgp77xwd3h7fg75kkca";
        libraryHaskellDepends = [
          base containers syb template-haskell th-abstraction
        ];
···
        mainProgram = "Benchmark";
      }) {};
 
-  "transformers_0_6_0_6" = callPackage
+  "transformers_0_6_1_0" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "transformers";
-       version = "0.6.0.6";
-       sha256 = "1savf7rjhji0lcx7fv0gz7ci6dn1sycdgh5flqr63y31spbj4q3w";
+       version = "0.6.1.0";
+       sha256 = "1n54v7wrnk06rj9w70grpmr9c6xvw1shpwygfnshslarggnwpaz7";
        libraryHaskellDepends = [ base ];
        description = "Concrete functor and monad transformers";
        license = lib.licenses.bsd3;
···
     ({ mkDerivation, base, exceptions, text, transformers }:
      mkDerivation {
        pname = "transformers-either";
-       version = "0.1.2";
-       sha256 = "1vb6jr2lpj6mqx9bv0ziqs6586gj6xka218qagxsm7w52w0hvz1v";
-       libraryHaskellDepends = [ base exceptions text transformers ];
-       description = "An Either monad transformer";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "transformers-either_0_1_3" = callPackage
-    ({ mkDerivation, base, exceptions, text, transformers }:
-     mkDerivation {
-       pname = "transformers-either";
        version = "0.1.3";
        sha256 = "0vk4pyk26rpyn17r3imn0phl10lgdfw5cpabf77zpkdq8lr154yr";
        libraryHaskellDepends = [ base exceptions text transformers ];
        description = "An Either monad transformer";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "transformers-except" = callPackage
···
     ({ mkDerivation, base, containers, doctest, mtl }:
      mkDerivation {
        pname = "tree-traversals";
-       version = "0.1.1.0";
-       sha256 = "0wsa4qxlxk6308smv957by8fmnsnsxnxxga8c66bvnhlr95rg9rk";
+       version = "0.1.2.0";
+       sha256 = "1l31l43dv7gkv35qfh7vf6v9ar864s4kilki2nwniipdfbyrmjwd";
        libraryHaskellDepends = [ base containers ];
        testHaskellDepends = [ base containers doctest mtl ];
        description = "Functions and newtype wrappers for traversing Trees";
···
     ({ mkDerivation, base, doctest, Glob }:
      mkDerivation {
        pname = "type-level-kv-list";
-       version = "2.0.0";
-       sha256 = "0m1hyddkc7652crki2r2rd0c7mr9sqcj57vhhkn280plqpmbl1kx";
+       version = "2.0.2.0";
+       sha256 = "1bdnmsxxrfhifzy3nm1j6hh2b6wgs38k8wyrg6rzq10wzxzi7bpz";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base doctest Glob ];
        description = "Type level Key-Value list";
        license = lib.licenses.mit;
-     }) {};
-
-  "type-level-kv-list_2_0_1_2" = callPackage
-    ({ mkDerivation, base, doctest, Glob }:
-     mkDerivation {
-       pname = "type-level-kv-list";
-       version = "2.0.1.2";
-       sha256 = "0pm6zz37i57d6xnihybl2q0iqhb7cn1wrz8kxy7id4mpzhkysjis";
-       libraryHaskellDepends = [ base ];
-       testHaskellDepends = [ base doctest Glob ];
-       description = "Type level Key-Value list";
-       license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "type-level-kv-list-esqueleto" = callPackage
···
      }) {};
 
   "typograffiti" = callPackage
-    ({ mkDerivation, base, bytestring, containers, filepath, freetype2
-     , gl, linear, mtl, pretty-show, sdl2, stm, template-haskell, vector
+    ({ mkDerivation, base, bytestring, containers, freetype2, gl
+     , harfbuzz-pure, linear, mtl, sdl2, stm, text, vector
      }:
      mkDerivation {
        pname = "typograffiti";
-       version = "0.1.0.3";
-       sha256 = "16491jhiw8yvs1491plf5c98rarxk0j2dfy76ggayxypzqdn2rmr";
+       version = "0.2.0.0";
+       sha256 = "0x7s9bfb68qhdjz98gf0k762mflrigih1qhxp6a4padkc2plwvww";
+       revision = "2";
+       editedCabalFile = "10v1ha01phgacfwialk3kmyaly61x1b8x9wmxnwbjr2bhfjxssqq";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         base bytestring containers freetype2 gl linear mtl pretty-show stm
-         template-haskell vector
+         base bytestring containers freetype2 gl harfbuzz-pure linear mtl
+         stm text vector
        ];
-       executableHaskellDepends = [
-         base bytestring containers filepath freetype2 gl linear mtl
-         pretty-show sdl2 stm template-haskell vector
-       ];
-       testHaskellDepends = [
-         base bytestring containers freetype2 gl linear mtl pretty-show stm
-         template-haskell vector
-       ];
+       executableHaskellDepends = [ base gl mtl sdl2 text ];
        description = "Just let me draw nice text already";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
-       mainProgram = "typograffiti-exe";
+       mainProgram = "typograffiti";
        broken = true;
      }) {};
 
···
      }:
      mkDerivation {
        pname = "ukrainian-phonetics-basic-array";
-       version = "0.6.0.0";
-       sha256 = "1n6blzjbqkvhnwlzjkn0xs8vnlv7n419ska09zd1r59jv15623ac";
+       version = "0.7.0.0";
+       sha256 = "13kwf822598hpvp0sa724bp4dyqgh79k0bydnlmxp51jsj8d85cq";
        libraryHaskellDepends = [
          base mmsyn2-array mmsyn5 ukrainian-phonetics-common
        ];
···
     ({ mkDerivation, base, mmsyn2-array }:
      mkDerivation {
        pname = "ukrainian-phonetics-common";
-       version = "0.1.1.0";
-       sha256 = "09sj6d29fcifxc30wxm5fqgvpifk7i7xf1dbxq7grawxf3w3l7hz";
+       version = "0.2.0.0";
+       sha256 = "0d5d06jshhhc24ii0h5mxwz9jnmqjzxkckbhsj9zpl81hfs54dsv";
        libraryHaskellDepends = [ base mmsyn2-array ];
        description = "A library to work with the basic Ukrainian phonetics and syllable segmentation";
        license = lib.licenses.mit;
···
     ({ mkDerivation, base, transformers }:
      mkDerivation {
        pname = "unliftio-core";
-       version = "0.2.0.1";
-       sha256 = "16i97jax8rys57l0g0qswfwxh1cl5bgw2lw525rm6bzajw90v7wi";
-       revision = "2";
-       editedCabalFile = "1xx9nmxxg87nhwxgbmmw0xbrppnjc23ppyryar04i3njyg9wvazr";
+       version = "0.2.1.0";
+       sha256 = "1qz3gxcq1x8fjgq6fqsnws5vgkgbjcx332p3hldxdnaninx4qf4r";
+       revision = "1";
+       editedCabalFile = "19pw6f7hmka8kgnsbrrhp73rdnvdsmagh1s325rxqv5if1km1hwz";
        libraryHaskellDepends = [ base transformers ];
        description = "The MonadUnliftIO typeclass for unlifting monads to IO";
        license = lib.licenses.mit;
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "unliftio-pool_0_4_0_0" = callPackage
+    ({ mkDerivation, base, resource-pool, transformers, unliftio-core
+     }:
+     mkDerivation {
+       pname = "unliftio-pool";
+       version = "0.4.0.0";
+       sha256 = "0kkb9zsb624h9sx1izj7hf6fbaxh7hvp9d6qqdrqh1j6fdh46hlp";
+       libraryHaskellDepends = [
+         base resource-pool transformers unliftio-core
+       ];
+       description = "Data.Pool generalized to MonadUnliftIO.";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "unliftio-streams" = callPackage
     ({ mkDerivation, base, bytestring, io-streams, text, unliftio-core
      }:
···
      }:
      mkDerivation {
        pname = "vector-hashtables";
-       version = "0.1.1.1";
-       sha256 = "02kixbi9v4rcj46fvvba5aq6vn6f5yncnvc71f4y7h1wq5b452jj";
+       version = "0.1.1.2";
+       sha256 = "0hrjvy9qg1m5g3w91zxy4syqmp8jk7ajjbxbzkhy282dwfigkyd2";
        libraryHaskellDepends = [ base hashable primitive vector ];
        testHaskellDepends = [
          base containers hashable hspec primitive QuickCheck
···
      }:
      mkDerivation {
        pname = "vulkan";
-       version = "3.24.4";
-       sha256 = "0lpgnmdk05lc4za98i8p7l0g1c5c4cvigm423k1qh2k287wcdhan";
+       version = "3.24.5";
+       sha256 = "0b2r0malnzalz0s59sa4ryyy1qg8ii886g15dhkmzcpz29yzwrc3";
        libraryHaskellDepends = [ base bytestring transformers vector ];
        libraryPkgconfigDepends = [ vulkan ];
        testHaskellDepends = [
···
 
   "wai-lambda" = callPackage
     ({ mkDerivation, aeson, base, binary, bytestring, case-insensitive
-     , directory, http-types, iproute, network, temporary, text
+     , deepseq, directory, http-types, iproute, network, temporary, text
      , unliftio, unordered-containers, vault, wai
      }:
      mkDerivation {
        pname = "wai-lambda";
-       version = "0.1.0.0";
-       sha256 = "1m77i3zazvpa4jirvgxjdik5fnzarrbmavvi48d72c8a8jjwsx9x";
+       version = "0.1.1.0";
+       sha256 = "1qx69gp2mrlc1gy45vcyicj9f9wyzdnidkqw15lm4hdmz20qwjzc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         aeson base binary bytestring case-insensitive directory http-types
-         iproute network temporary text unliftio unordered-containers vault
-         wai
+         aeson base binary bytestring case-insensitive deepseq directory
+         http-types iproute network temporary text unliftio
+         unordered-containers vault wai
        ];
        executableHaskellDepends = [
-         aeson base binary bytestring case-insensitive directory http-types
-         iproute network temporary text unliftio unordered-containers vault
-         wai
+         aeson base binary bytestring case-insensitive deepseq directory
+         http-types iproute network temporary text unliftio
+         unordered-containers vault wai
        ];
        description = "Haskell Webapps on AWS Lambda";
        license = lib.licenses.mit;
···
        license = lib.licenses.mit;
      }) {};
 
+  "wai-saml2_0_4" = callPackage
+    ({ mkDerivation, base, base16-bytestring, base64-bytestring
+     , bytestring, c14n, containers, cryptonite, data-default-class
+     , filepath, http-types, mtl, network-uri, pretty-show, tasty
+     , tasty-golden, text, time, vault, wai, wai-extra, x509, x509-store
+     , xml-conduit, zlib
+     }:
+     mkDerivation {
+       pname = "wai-saml2";
+       version = "0.4";
+       sha256 = "0rsp4bz20a5fsl3plg6k40vqvnjp2h0hy7pkx5xf9iyfadv1a5jw";
+       libraryHaskellDepends = [
+         base base16-bytestring base64-bytestring bytestring c14n containers
+         cryptonite data-default-class http-types mtl network-uri text time
+         vault wai wai-extra x509 x509-store xml-conduit zlib
+       ];
+       testHaskellDepends = [
+         base base16-bytestring base64-bytestring bytestring c14n containers
+         cryptonite data-default-class filepath http-types mtl network-uri
+         pretty-show tasty tasty-golden text time vault wai wai-extra x509
+         x509-store xml-conduit zlib
+       ];
+       description = "SAML2 assertion validation as WAI middleware";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "wai-secure-cookies" = callPackage
     ({ mkDerivation, base, bytestring, cryptonite, hspec
      , hspec-expectations, hspec-wai, http-types, memory, random, split
···
        license = lib.licenses.mit;
      }) {};
 
+  "warp_3_3_24" = callPackage
+    ({ mkDerivation, array, auto-update, base, bsb-http-chunked
+     , bytestring, case-insensitive, containers, directory, gauge
+     , ghc-prim, hashable, hspec, hspec-discover, http-client, http-date
+     , http-types, http2, iproute, network, process, QuickCheck, recv
+     , simple-sendfile, stm, streaming-commons, text, time-manager, unix
+     , unix-compat, unliftio, vault, wai, word8, x509
+     }:
+     mkDerivation {
+       pname = "warp";
+       version = "3.3.24";
+       sha256 = "0g15zv35gvadx55k5165idnj8vxkd57zlmirm9clb94ck6ckmkba";
+       libraryHaskellDepends = [
+         array auto-update base bsb-http-chunked bytestring case-insensitive
+         containers ghc-prim hashable http-date http-types http2 iproute
+         network recv simple-sendfile stm streaming-commons text
+         time-manager unix unix-compat unliftio vault wai word8 x509
+       ];
+       testHaskellDepends = [
+         array auto-update base bsb-http-chunked bytestring case-insensitive
+         containers directory ghc-prim hashable hspec http-client http-date
+         http-types http2 iproute network process QuickCheck recv
+         simple-sendfile stm streaming-commons text time-manager unix
+         unix-compat unliftio vault wai word8 x509
+       ];
+       testToolDepends = [ hspec-discover ];
+       benchmarkHaskellDepends = [
+         auto-update base bytestring containers gauge hashable http-date
+         http-types network recv time-manager unix unix-compat unliftio x509
+       ];
+       description = "A fast, light-weight web server for WAI applications";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "warp-dynamic" = callPackage
     ({ mkDerivation, base, data-default, dyre, http-types, wai, warp }:
      mkDerivation {
···
        ];
        description = "HTTP over TLS support for Warp via the TLS package";
        license = lib.licenses.mit;
+     }) {};
+
+  "warp-tls_3_3_5" = callPackage
+       sha256 = "1bfzbwddss0m0z4jf7i0b06pmxy9rvknpqnzhf0v5jggv5nr442p";
+     , network, recv, streaming-commons, tls, tls-session-manager
+     , unliftio, wai, warp
+     }:
+     mkDerivation {
+       pname = "warp-tls";
+       version = "3.3.5";
+       sha256 = "1w59szdx5jipww9ypm86cnaid24xmyb0fgp2qvz8cgcdd2jmmrc7";
+       libraryHaskellDepends = [
+         base bytestring cryptonite data-default-class network recv
+         streaming-commons tls tls-session-manager unliftio wai warp
+       ];
+       description = "HTTP over TLS support for Warp via the TLS package";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "warp-tls-uid" = callPackage
···
      }:
      mkDerivation {
        pname = "web-routes";
-       version = "0.27.14.4";
-       sha256 = "10zpyxigrmp97x7xd9aw8kn925ygjf0jv8hppxmksjf9a6pvyfn1";
+       version = "0.27.15";
+       sha256 = "1kmyhyc3c9b2k0678q8yhd52x51jz153i8180a16ig05w6clc4xx";
        libraryHaskellDepends = [
          base blaze-builder bytestring exceptions ghc-prim http-types mtl
          parsec split text utf8-string
···
     ({ mkDerivation, base, boomerang, mtl, parsec, text, web-routes }:
      mkDerivation {
        pname = "web-routes-boomerang";
-       version = "0.28.4.3";
-       sha256 = "1cdn29084i2bvsh7pa6d4dr5bgpixix36dhi49q8nbcbp02qycap";
+       version = "0.28.4.4";
+       sha256 = "0sbw93flmhbwdg1lag5jm7qi8nh5fy4k3anxijzf1472y6kqncrp";
        libraryHaskellDepends = [
          base boomerang mtl parsec text web-routes
        ];
···
      }:
      mkDerivation {
        pname = "web-routes-happstack";
-       version = "0.23.12.2";
-       sha256 = "01ks9c8bln8yiff7dqfm3ai7scci304q94w1zaqvzph57m1whrd6";
-       libraryHaskellDepends = [
-         base bytestring happstack-server text web-routes
-       ];
-       description = "Adds support for using web-routes with Happstack";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "web-routes-happstack_0_23_12_3" = callPackage
-    ({ mkDerivation, base, bytestring, happstack-server, text
-     , web-routes
-     }:
-     mkDerivation {
-       pname = "web-routes-happstack";
        version = "0.23.12.3";
        sha256 = "1qkbaq5k9as5s0bdaiza02jfg17vwmsfwg6r3gg95sh4l5rvwyx6";
        libraryHaskellDepends = [
···
        ];
        description = "Adds support for using web-routes with Happstack";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "web-routes-hsp" = callPackage
···
      }:
      mkDerivation {
        pname = "web-routes-th";
-       version = "0.22.7";
-       sha256 = "0h3xaml18jgc66ylmwlymp1mqnf59lfvsd3xswdki8dk31ryaca4";
+       version = "0.22.8.1";
+       sha256 = "0sv8ya7s70zlfr9qhavpb9i0q3l5arcarsxgb20w6cbghfj67kh5";
        libraryHaskellDepends = [
          base parsec split template-haskell text web-routes
        ];
···
      }:
      mkDerivation {
        pname = "webauthn";
-       version = "0.5.0.0";
-       sha256 = "1kyjwg5hf3v1hxpsk9w9mdz601dyahr0a50z83bwaqgys9fb7m8d";
+       version = "0.5.0.1";
+       sha256 = "1nlcf3fgx4bp4pghbr5yy161sg1gkzxa1j0699r04dnw4i8qw9d0";
        libraryHaskellDepends = [
          aeson asn1-encoding asn1-parse asn1-types base base16-bytestring
          base64-bytestring binary bytestring cborg containers cryptonite
···
      }:
      mkDerivation {
        pname = "webp";
-       version = "0.1.0.1";
-       sha256 = "12ryx87z36ra243vcira7jkpn6k3c5sqp5r4h7zvxxm64rajyxcd";
+       version = "0.1.0.2";
+       sha256 = "04bf0apq9q2kpkkhsj93y3fmjkind7dmgb3hf3nxlj7sy46d4mix";
        libraryHaskellDepends = [ base bytestring JuicyPixels vector ];
        libraryPkgconfigDepends = [ libwebp ];
        libraryToolDepends = [ c2hs ];
···
      }:
      mkDerivation {
        pname = "welford-online-mean-variance";
-       version = "0.1.0.4";
-       sha256 = "0nzr6krkaa39h9v25hbagnw1f2g45dqrv8ifhvh16m4k7xf17xla";
+       version = "0.2.0.0";
+       sha256 = "0js964yvcpksy4mf7vx5919wk4yygwhk77g8w6j52ibgs87rijhf";
        libraryHaskellDepends = [ base cereal deepseq vector ];
        testHaskellDepends = [
          base cereal deepseq QuickCheck tasty tasty-discover
···
        maintainers = [ lib.maintainers.maralorn ];
      }) {};
 
+  "witch_1_1_6_1" = callPackage
+    ({ mkDerivation, base, bytestring, containers, HUnit, tagged
+     , template-haskell, text, time, transformers
+     }:
+     mkDerivation {
+       pname = "witch";
+       version = "1.1.6.1";
+       sha256 = "1n4kckgk5v63bpjgky3dfgyayl82hlnxzwaa99pzyxrcjkpql5ay";
+       libraryHaskellDepends = [
+         base bytestring containers tagged template-haskell text time
+       ];
+       testHaskellDepends = [
+         base bytestring containers HUnit tagged text time transformers
+       ];
+       description = "Convert values from one type into another";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = [ lib.maintainers.maralorn ];
+     }) {};
+
   "with-index" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "wuss";
-       version = "2.0.1.0";
-       sha256 = "0hl8s3fwmvxw0zamz72mzhs0pf84qvpyzhd6fjk03whrvg3f4qh7";
+       version = "2.0.1.1";
+       sha256 = "0mdj161z6dxvdm94r2mclv1yq90d2fz0c4q1jsv4qwq8g8abf8r0";
        libraryHaskellDepends = [
          base bytestring connection exceptions network websockets
        ];
···
      }:
      mkDerivation {
        pname = "xmlhtml";
-       version = "0.2.5.3";
-       sha256 = "0nvwrl4cw7hfsbndmxdmzs3cs35hs01bja6hrjrc8fairaaif2rf";
+       version = "0.2.5.4";
+       sha256 = "11aldkcd3lcxax42f4080127hqs1k95k84h5griwq27ig8gmbxdc";
        libraryHaskellDepends = [
          base blaze-builder blaze-html blaze-markup bytestring
          bytestring-builder containers parsec text unordered-containers
···
        pname = "xor";
        version = "0.0.1.1";
        sha256 = "05jwfrg4cm27ldj3dbl0y144njhiha9yiypirbhsg6lc1b36s3kh";
-       revision = "1";
-       editedCabalFile = "0ppy515y2y1bviaafx6hg440ain0l6j5pg4g5j7lwjzsknxb0jd5";
+       revision = "2";
+       editedCabalFile = "02y2587racvd9ppmllivzzn6zvdm051i6sc795lshvdq24ivvh9q";
        libraryHaskellDepends = [ base bytestring ghc-byteorder ];
        testHaskellDepends = [
          base bytestring ghc-byteorder QuickCheck tasty tasty-hunit
···
      }:
      mkDerivation {
        pname = "yahoo-prices";
-       version = "0.1.0.2";
-       sha256 = "1zyrj6rq75blzh1v9ja2bbyfaf3c2a6648lcmflmxmd45350ah9f";
+       version = "0.1.0.5";
+       sha256 = "0hkws2l46m9a859a9diph341shkq4x1270x5axj4clg36lsi5hcd";
        libraryHaskellDepends = [
          base bytestring cassava lens time vector wreq
        ];
···
      }:
      mkDerivation {
        pname = "yaml";
-       version = "0.11.8.0";
-       sha256 = "1s0arllihjjqp65jbc8c1w5106i2infppsirvbsifpmpkf14w6pn";
-       revision = "2";
-       editedCabalFile = "1dix5jm3d380vjr9l6wqz54zk883kilk8rijlvjp6b13mjxwcj1l";
+       version = "0.11.10.0";
+       sha256 = "01zylkpfrbwfbqxan9qywcjq6j6nks0pd6hjkah4lvr6vs9x4n38";
        configureFlags = [ "-fsystem-libyaml" ];
        isLibrary = true;
        isExecutable = true;
···
      }:
      mkDerivation {
        pname = "yampa-test";
-       version = "0.14";
-       sha256 = "1w2p15j1fh2xv460xc40w7li2mvv4nwqqys1xhr9zpby2cdkc39h";
+       version = "0.14.1";
+       sha256 = "163kl1iqldlz3b429zbyvasgd7kkv7z0h3vkk753273xl6kfx0xr";
        libraryHaskellDepends = [
          base normaldistribution QuickCheck Yampa
        ];
···
      }:
      mkDerivation {
        pname = "yesod-auth-oauth2";
-       version = "0.7.0.2";
-       sha256 = "1dnpw1rl8pa7dwfiy203l54x1rrzaiib7ryha9yy2vyaljlymg4v";
+       version = "0.7.0.3";
+       sha256 = "0qadhf72v71rzfzcbgfgxyf1dydf0x343n49995s6vkjx6p0kyy5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "yesod-colonnade";
        version = "1.3.0.1";
        sha256 = "1x5m3xv4jq2x49fnvxw3v8bvbsx4hdccykcn32fz3cwavp4p1q1p";
-       revision = "2";
-       editedCabalFile = "0z3zcfxsbjm1azbbscccimsazkc10jp0i24wznwb2pvm4pa5a7j4";
+       revision = "3";
+       editedCabalFile = "040r3scz1155ci40q3q7lhqyqfdq3x9cg2zp9jw1lqppl426fzmy";
        libraryHaskellDepends = [
          base blaze-html blaze-markup colonnade conduit conduit-extra text
          yesod-core yesod-elements
···
      }:
      mkDerivation {
        pname = "yesod-core";
-       version = "1.6.24.0";
-       sha256 = "19ilgm73108ki1hvqc86kir0yrx36vp9g45na6g8dmfsvk9izr10";
-       revision = "1";
-       editedCabalFile = "1406s7is60ji6nn3h1mafkdh7729ipq3i06cqsq77hz2ilj264jl";
+       version = "1.6.24.1";
+       sha256 = "1jbalzr3m92sfqladcpnvm6394qda0arhyzx7dychknssvbd2j3d";
        libraryHaskellDepends = [
          aeson auto-update base blaze-html blaze-markup bytestring
          case-insensitive cereal clientsession conduit conduit-extra
···
      }:
      mkDerivation {
        pname = "yesod-form";
-       version = "1.7.3";
-       sha256 = "10y3mfh96sicqyzngvl7f4wrjgkvl3znqnh71s8gx1vf7158sjww";
+       version = "1.7.4";
+       sha256 = "012w6pq0zznwqn19nx5h30rmd7dazcd0d75a6426d7brxvf9vn98";
        libraryHaskellDepends = [
          aeson attoparsec base blaze-builder blaze-html blaze-markup
          byteable bytestring containers data-default email-validate
···
      }:
      mkDerivation {
        pname = "yst";
-       version = "0.7.1.3";
-       sha256 = "120ppqk1jpkxjw3ip3q27f3aaghm4s725g6lmi54ma9f0s3m4hy9";
+       version = "0.7.2";
+       sha256 = "0prjrsz9xgk5drf2bp1mq7mq88w61zrn5g3qk1v93scpjp02dvs5";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        ];
        description = "Builds a static website from templates and data in YAML or CSV files";
        license = lib.licenses.gpl2Plus;
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "yst";
+       broken = true;
      }) {};
 
   "ytl" = callPackage
···
        pname = "zlib";
        version = "0.6.3.0";
        sha256 = "1nh4xsm3kgsg76jmkcphvy7hhslg9hx1s75mpsskhi2ksjd9ialy";
+       revision = "1";
+       editedCabalFile = "1z2dyphqmjb9akzqrqh8k82mfv416hqj82nz8mysidx09jgf7p4s";
        libraryHaskellDepends = [ base bytestring ];
        librarySystemDepends = [ zlib ];
        testHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "zoovisitor";
-       version = "0.2.1.1";
-       sha256 = "02hhscjj1rql1xn08x1dh5lppsvrs059wh2psxz5i2glwc7jgd9a";
+       version = "0.2.1.2";
+       sha256 = "1c0j41riwcp4c2cvalcrkz6cwrp9vw2hfmpadsfsfb2sa7qmf8rj";
        libraryHaskellDepends = [ base Z-Data Z-IO ];
        librarySystemDepends = [ zookeeper_mt ];
        testHaskellDepends = [ async base hspec uuid Z-Data ];

pkgs/development/interpreters/ruby/default.nix

···
           }).${ver.majMinTiny}
           ++ op (lib.versionOlder ver.majMin "3.1") ./do-not-regenerate-revision.h.patch
           ++ op (atLeast30 && useBaseRuby) ./do-not-update-gems-baseruby.patch
+          ++ ops (ver.majMin == "3.0") [
+            # Ruby 3.0 adds `-fdeclspec` to $CC instead of $CFLAGS. Fixed in later versions.
+            (fetchpatch {
+              url = "https://github.com/ruby/ruby/commit/0acc05caf7518cd0d63ab02bfa036455add02346.patch";
+              sha256 = "sha256-43hI9L6bXfeujgmgKFVmiWhg7OXvshPCCtQ4TxqK1zk=";
+            })
+          ]
           ++ ops (!atLeast30 && rubygemsSupport) [
             # We upgrade rubygems to a version that isn't compatible with the
             # ruby 2.7 installer. Backport the upstream fix.

pkgs/development/libraries/agda/agda-categories/default.nix

···
 { lib, mkDerivation, fetchFromGitHub, standard-library }:
 
 mkDerivation rec {
-  version = "0.1.7.1";
+  version = "0.1.7.1a";
   pname = "agda-categories";
 
   src = fetchFromGitHub {
     owner = "agda";
     repo = "agda-categories";
     rev = "v${version}";
-    sha256 = "1acb693ad2nrmnn6jxsyrlkc0di3kk2ksj2w9wnyfxrgvfsil7rn";
+    sha256 = "sha256-VlxRDxXg+unzYlACUU58JQUHXxtg0fI5dEQvlBRxJtU=";
   };
 
-  # Remove this once new version of agda-categories is released which
-  # directly references standard-library-1.7.1
   postPatch = ''
-    substituteInPlace agda-categories.agda-lib \
-      --replace 'standard-library-1.7' 'standard-library-1.7.1'
+    # Remove this once agda-categories incorporates this fix or once Agda's
+    # versioning system gets an overhaul in general. Right now there is no middle
+    # ground between "no version constraint" and "exact match down to patch". We
+    # do not want to need to change this postPatch directive on each minor
+    # version update of the stdlib, so we get rid of the version constraint
+    # altogether.
+    sed -Ei 's/standard-library-[0-9.]+/standard-library/' agda-categories.agda-lib
+
+    # The Makefile of agda-categories uses git(1) instead of find(1) to
+    # determine the list of source files. We cannot use git, as $PWD will not
+    # be a valid Git working directory.
+    find src -name '*.agda' | sed -e 's|^src/[/]*|import |' -e 's|/|.|g' -e 's/.agda//' -e '/import Everything/d' | LC_COLLATE='C' sort > Everything.agda
   '';
 
   buildInputs = [ standard-library ];

pkgs/development/libraries/agda/agda-prelude/default.nix

···
 { lib, mkDerivation, fetchFromGitHub }:
 
 mkDerivation rec {
-  version = "compat-2.6.2";
+  version = "unstable-2022-01-14";
   pname = "agda-prelude";
 
   src = fetchFromGitHub {
     owner = "UlfNorell";
     repo = "agda-prelude";
-    rev = version;
-    sha256 = "0j2nip5fbn61fpkm3qz4dlazl4mzdv7qlgw9zm15bkcvaila0h14";
+    rev = "3d143d6d0a3f75966602480665623e87233ff93e";
+    hash = "sha256-ILhXDq788vrceMp5mCiQUMrJxeLPtS4yGtvMHMYxzg8=";
   };
 
   preConfigure = ''

pkgs/development/libraries/agda/cubical/default.nix

···
 
 mkDerivation rec {
   pname = "cubical";
-  version = "0.4";
+  version = "unstable-2023-02-09";
 
   src = fetchFromGitHub {
     repo = pname;
     owner = "agda";
-    rev = "v${version}";
-    hash = "sha256-bnHz5uZXZnn1Zd36tq/veA4yT7dhJ1c+AYpgdDfSRzE=";
+    rev = "6b1ce0b67fd94693c1a3e340c8e8765380de0edc";
+    hash = "sha256-XRCaW94oAgy2GOnFiI9c5A8mEx7AzlbT4pFd+PMmc9o=";
   };
-
-  LC_ALL = "C.UTF-8";
 
   # The cubical library has several `Everything.agda` files, which are
   # compiled through the make file they provide.

pkgs/development/libraries/agda/standard-library/default.nix

···
 
 mkDerivation rec {
   pname = "standard-library";
-  version = "1.7.1";
+  version = "1.7.2";
 
   src = fetchFromGitHub {
     repo = "agda-stdlib";
     owner = "agda";
     rev = "v${version}";
-    sha256 = "0khl12jvknsvjsq3l5cbp2b5qlw983qbymi1dcgfz9z0b92si3r0";
+    hash = "sha256-vvbyfC5+Yyx18IDikSbAAcTHHtU6krlz45Fd2YlwsBg=";
   };
 
   nativeBuildInputs = [ (ghcWithPackages (self : [ self.filemanip ])) ];

pkgs/development/libraries/libisds/default.nix

···
 
   buildInputs = [ expat gpgme libgcrypt libxml2 libxslt curl docbook_xsl ];
 
+  NIX_CFLAGS_COMPILE = [ "-Wno-error=deprecated-declarations" ];
+
   meta = with lib; {
     description = "Client library for accessing SOAP services of Czech government-provided Databox infomation system";
     homepage = "http://xpisar.wz.cz/libisds/";

pkgs/development/libraries/libvirt/default.nix

···
       (feat "libpcap" true)
       (feat "libssh2" true)
       (feat "login_shell" isLinux)
-      (feat "nss" isLinux)
+      (feat "nss" (isLinux && !stdenv.hostPlatform.isMusl))
       (feat "numactl" isLinux)
       (feat "numad" isLinux)
       (feat "pciaccess" isLinux)

pkgs/development/tools/packer/default.nix

···
 
 buildGoModule rec {
   pname = "packer";
-  version = "1.8.5";
+  version = "1.8.6";
 
   src = fetchFromGitHub {
     owner = "hashicorp";
     repo = "packer";
     rev = "v${version}";
-    sha256 = "sha256-jdJD7AW4IrzVl4BPdsFFrRSdCWX9l4nFM+DWIuxLiJ8=";
+    sha256 = "sha256-Nc4H7qx+TmbG80Ogw4zRofux5VwqeQZIg9gLqZprgVE=";
   };
 
-  vendorSha256 = "sha256-ufvWgusTMbM88F3BkJ61KM2wRSdqPOlMKqDSYf7tZQA=";
+  vendorHash = "sha256-poTBx62m9Q4az5BECFKmFAE37B8C/DVIyHeC80P+VYQ=";
 
   subPackages = [ "." ];
 

pkgs/development/tools/zls/default.nix pkgs/development/tools/language-servers/zls/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "zls";
-  version = "0.9.0";
+  version = "0.10.0";
 
   src = fetchFromGitHub {
     owner = "zigtools";
     repo = pname;
     rev = version;
-    sha256 = "sha256-MVo21qNCZop/HXBqrPcosGbRY+W69KNCc1DfnH47GsI=";
+    sha256 = "sha256-M0GG4KIMcHN+bEprUv6ISZkWNvWN12S9vqSKP+DRU9M=";
     fetchSubmodules = true;
   };
 
   nativeBuildInputs = [ zig ];
 
+  dontConfigure = true;
+
   preBuild = ''
     export HOME=$TMPDIR
   '';
 
   installPhase = ''
+    runHook preInstall
     zig build -Drelease-safe -Dcpu=baseline --prefix $out install
+    runHook postInstall
   '';
 
   meta = with lib; {

pkgs/games/sdlpop/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "sdlpop";
-  version = "1.22";
+  version = "1.23";
 
   src = fetchFromGitHub {
     owner = "NagyD";
     repo = "SDLPoP";
     rev = "v${version}";
-    sha256 = "1yy5r1r0hv0xggk8qd8bwk2zy7abpv89nikq4flqgi53fc5q9xl7";
+    sha256 = "sha256-UI7NfOC/+druRYL5g2AhIjTPEq4ta1qEThcxgyrFjHY=";
   };
 
   nativeBuildInputs = [ pkg-config makeWrapper copyDesktopItems ];
···
   meta = with lib; {
     description = "Open-source port of Prince of Persia";
     homepage = "https://github.com/NagyD/SDLPoP";
+    changelog = "https://github.com/NagyD/SDLPoP/blob/v${version}/doc/ChangeLog.txt";
     license = licenses.gpl3Plus;
     maintainers = with maintainers; [ iblech ];
     platforms = platforms.unix;

pkgs/os-specific/linux/microcode/iucode-tool.nix

···
-{ lib, stdenv, fetchFromGitLab, autoreconfHook }:
+{ lib, stdenv, fetchFromGitLab, autoreconfHook, fetchpatch }:
 
 stdenv.mkDerivation rec {
   pname = "iucode-tool";
···
     rev    = "v${version}";
     sha256 = "04dlisw87dd3q3hhmkqc5dd58cp22fzx3rzah7pvcyij135yjc3a";
   };
+
+  patches = [
+    # build fix for musl libc, pending upstream review
+    # https://gitlab.com/iucode-tool/iucode-tool/-/merge_requests/4
+    (fetchpatch {
+      url = "https://gitlab.com/iucode-tool/iucode-tool/-/commit/fda4aaa4727601dbe817fac001f234c19420351a.patch";
+      hash = "sha256-BxYrXALpZFyJtFrgU5jFmzd1dIMPmpNgvYArgkwGt/w=";
+    })
+  ];
 
   nativeBuildInputs = [ autoreconfHook ];
 

pkgs/tools/networking/mailutils/default.nix

···
 , sasl
 , system-sendmail
 , libxcrypt
+
+, pythonSupport ? true
+, guileSupport ? true
 }:
 
 stdenv.mkDerivation rec {
   pname = "mailutils";
-  version = "3.14";
+  version = "3.15";
 
   src = fetchurl {
     url = "mirror://gnu/${pname}/${pname}-${version}.tar.xz";
-    hash = "sha256-wMWzj+qLRaSvzUNkh/Knb9VSUJLQN4gTputVQsIScTk=";
+    hash = "sha256-t9DChsNS/MfaeXjP1hfMZnNrIfqJGqT4iFX1FjVPLds=";
   };
 
   separateDebugInfo = true;
···
     gdbm
     gnutls
     gss
-    guile
     libmysqlclient
     mailcap
     ncurses
     pam
-    python3
     readline
     sasl
     libxcrypt
-  ] ++ lib.optionals stdenv.isLinux [ nettools ];
+  ] ++ lib.optionals stdenv.isLinux [ nettools ]
+  ++ lib.optionals pythonSupport [ python3 ]
+  ++ lib.optionals guileSupport [ guile ];
 
   patches = [
     ./fix-build-mb-len-max.patch
···
     })
   ];
 
-  enableParallelBuilding = false;
+  enableParallelBuilding = true;
   hardeningDisable = [ "format" ];
 
   configureFlags = [
···
     "--with-path-sendmail=${system-sendmail}/bin/sendmail"
     "--with-mail-rc=/etc/mail.rc"
     "DEFAULT_CUPS_CONFDIR=${mailcap}/etc" # provides mime.types to mimeview
-  ];
-
-  readmsg-tests = let
-    p = "https://raw.githubusercontent.com/gentoo/gentoo/9c921e89d51876fd876f250324893fd90c019326/net-mail/mailutils/files";
-  in [
-    (fetchurl { url = "${p}/hdr.at"; sha256 = "0phpkqyhs26chn63wjns6ydx9468ng3ssbjbfhcvza8h78jlsd98"; })
-    (fetchurl { url = "${p}/nohdr.at"; sha256 = "1vkbkfkbqj6ml62s1am8i286hxwnpsmbhbnq0i2i0j1i7iwkk4b7"; })
-    (fetchurl { url = "${p}/twomsg.at"; sha256 = "15m29rg2xxa17xhx6jp4s2vwa9d4khw8092vpygqbwlhw68alk9g"; })
-    (fetchurl { url = "${p}/weed.at"; sha256 = "1101xakhc99f5gb9cs3mmydn43ayli7b270pzbvh7f9rbvh0d0nh"; })
-  ];
+  ] ++ lib.optional (!pythonSupport) "--without-python"
+    ++ lib.optional (!guileSupport) "--without-guile";
 
   nativeCheckInputs = [ dejagnu ];
-  doCheck = false; # fails 1 out of a bunch of tests, looks like a bug
+  doCheck = true;
   doInstallCheck = false; # fails
 
   preCheck = ''
-    # Add missing test files
-    cp ${builtins.toString readmsg-tests} readmsg/tests/
-    for f in hdr.at nohdr.at twomsg.at weed.at; do
-      mv readmsg/tests/*-$f readmsg/tests/$f
-    done
     # Disable comsat tests that fail without tty in the sandbox.
     tty -s || echo > comsat/tests/testsuite.at
-    # Disable lmtp tests that require root spool.
-    echo > maidag/tests/lmtp.at
-    # Disable mda tests that require /etc/passwd to contain root.
-    grep -qo '^root:' /etc/passwd || echo > maidag/tests/mda.at
+    # Remove broken macro
+    sed -i '/AT_TESTED/d' libmu_scm/tests/testsuite.at
     # Provide libraries for mhn.
     export LD_LIBRARY_PATH=$(pwd)/lib/.libs
   '';
···
       Scheme.
 
       The utilities provided by Mailutils include imap4d and pop3d mail
-      servers, mail reporting utility comsatd, general-purpose mail delivery
-      agent maidag, mail filtering program sieve, and an implementation of MH
-      message handling system.
+      servers, mail reporting utility comsatd, mail filtering program sieve,
+      and an implementation of MH message handling system.
     '';
 
     license = with licenses; [
···
     maintainers = with maintainers; [ orivej vrthra ];
 
     homepage = "https://www.gnu.org/software/mailutils/";
+    changelog = "https://git.savannah.gnu.org/cgit/mailutils.git/tree/NEWS";
 
     # Some of the dependencies fail to build on {cyg,dar}win.
     platforms = platforms.gnu ++ platforms.unix;

pkgs/tools/networking/minio-client/default.nix

···
 
 buildGoModule rec {
   pname = "minio-client";
-  version = "2023-01-28T20-29-38Z";
+  version = "2023-02-16T19-20-11Z";
 
   src = fetchFromGitHub {
     owner = "minio";
     repo = "mc";
     rev = "RELEASE.${version}";
-    sha256 = "sha256-xlhAPJvZcd4tkaIK+xflUXcFKMbQQX8QgCSD7CTiPu8=";
+    sha256 = "sha256-UL49sZ8dBiXexmWt8rAUn2b2d58KJ8/5FyoojO7Y/68=";
   };
 
-  vendorHash = "sha256-fSHgwllxk10ipacOmtXXqFupEp3kuG25KIRklwmtIMU=";
+  vendorHash = "sha256-CdMpzYmJxOu4HvsQMJDZxRr7MWB4xN6ivEWldIptVnU=";
 
   subPackages = [ "." ];
 

pkgs/tools/networking/networkd-dispatcher/default.nix

···
+{ lib
+, stdenv
+, fetchFromGitLab
+, python3Packages
+, asciidoc
+, makeWrapper
+, iw
+}:
+
+stdenv.mkDerivation rec {
+  pname = "networkd-dispatcher";
+  version = "2.2.4";
+
+  src = fetchFromGitLab {
+    domain = "gitlab.com";
+    owner = "craftyguy";
+    repo = pname;
+    rev = version;
+    hash = "sha256-yO9/HlUkaQmW/n9N3vboHw//YMzBjxIHA2zAxgZNEv0=";
+  };
+
+  postPatch = ''
+    # Fix paths in systemd unit file
+    substituteInPlace networkd-dispatcher.service \
+      --replace "/usr/bin/networkd-dispatcher" "$out/bin/networkd-dispatcher" \
+      --replace "/etc/conf.d" "$out/etc/conf.d"
+    # Remove conditions on existing rules path
+    sed -i '/ConditionPathExistsGlob/g' networkd-dispatcher.service
+  '';
+
+  nativeBuildInputs = [
+    asciidoc
+    makeWrapper
+    python3Packages.wrapPython
+  ];
+
+  checkInputs = with python3Packages; [
+    dbus-python
+    iw
+    mock
+    pygobject3
+    pytestCheckHook
+  ];
+
+  pythonPath = with python3Packages; [
+    configparser
+    dbus-python
+    pygobject3
+  ];
+
+  installPhase = ''
+    runHook preInstall
+    install -D -m755 -t $out/bin networkd-dispatcher
+    install -Dm644 networkd-dispatcher.service $out/lib/systemd/system/networkd-dispatcher.service
+    install -Dm644 networkd-dispatcher.conf $out/etc/conf.d/networkd-dispatcher.conf
+    install -D networkd-dispatcher.8 -t $out/share/man/man8/
+    runHook postInstall
+  '';
+
+  doCheck = true;
+
+  postFixup = ''
+    wrapPythonPrograms
+    wrapProgram $out/bin/networkd-dispatcher --prefix PATH : ${lib.makeBinPath [ iw ]}
+  '';
+
+  meta = with lib; {
+    description = "Dispatcher service for systemd-networkd connection status changes";
+    homepage = "https://gitlab.com/craftyguy/networkd-dispatcher";
+    license = licenses.gpl3Only;
+    platforms = platforms.linux;
+    maintainers = with maintainers; [ onny ];
+  };
+}

pkgs/tools/networking/v2raya/default.nix

···
 let
   pname = "v2raya";
   version = "2.0.0";
+
   src = fetchFromGitHub {
     owner = "v2rayA";
     repo = "v2rayA";
     rev = "v${version}";
     sha256 = "sha256-1fWcrMd+TSrlS1H0z7XwVCQzZAa8DAFtlekEZNRMAPA=";
   };
+
   web = mkYarnPackage {
     inherit pname version;
     src = "${src}/gui";
···
     dontInstall = true;
     dontFixup = true;
   };
+
+  assetsDir = symlinkJoin {
+    name = "assets";
+    paths = [ v2ray-geoip v2ray-domain-list-community ];
+  };
+
 in
 buildGoModule {
   inherit pname version;
+
   src = "${src}/service";
   vendorSha256 = "sha256-Ud4pwS0lz7zSTowg3gXNllfDyj8fu33H1L20szxPcOA=";
+
   ldflags = [
     "-s"
     "-w"
     "-X github.com/v2rayA/v2rayA/conf.Version=${version}"
   ];
+
   subPackages = [ "." ];
+
   nativeBuildInputs = [ makeWrapper ];
   preBuild = ''
     cp -a ${web} server/router/web
   '';
+
   postInstall = ''
     install -Dm 444 ${src}/install/universal/v2raya.desktop -t $out/share/applications
     install -Dm 444 ${src}/install/universal/v2raya.png -t $out/share/icons/hicolor/512x512/apps
···
 
     wrapProgram $out/bin/v2rayA \
       --prefix PATH ":" "${lib.makeBinPath [ v2ray ]}" \
-      --prefix XDG_DATA_DIRS ":" ${symlinkJoin {
-        name = "assets";
-        paths = [ v2ray-geoip v2ray-domain-list-community ];
-      }}/share
+      --prefix XDG_DATA_DIRS ":" ${assetsDir}/share
   '';
+
   meta = with lib; {
     description = "A Linux web GUI client of Project V which supports V2Ray, Xray, SS, SSR, Trojan and Pingtunnel";
     homepage = "https://github.com/v2rayA/v2rayA";

pkgs/tools/security/certstrap/default.nix

···
 
 buildGoModule rec {
   pname = "certstrap";
-  version = "1.2.0";
+  version = "1.3.0";
 
   src = fetchFromGitHub {
     owner = "square";
     repo = "certstrap";
     rev = "v${version}";
-    sha256 = "sha256-kmlbz6Faw5INzw+fB1KXjo9vmuaZEp4PvuMldqyFrPo=";
+    sha256 = "sha256-mbZtomR8nnawXr3nGVSEuVObe79M1CqTlYN/aEpKmcU=";
   };
 
-  vendorSha256 = null;
+  vendorSha256 = "sha256-r7iYhTmFKTjfv11fEerC72M7JBp64rWfbkoTKzObNqM=";
 
   subPackages = [ "." ];
 

pkgs/tools/security/sudo/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "sudo";
-  version = "1.9.12p2";
+  version = "1.9.13";
 
   src = fetchurl {
     url = "https://www.sudo.ws/dist/${pname}-${version}.tar.gz";
-    hash = "sha256-uaCxrg8d3Zvn8+r+cL4F7oH1cvb1NmMsRM1BAbsqhTk=";
+    hash = "sha256-P1VFW0btsKEp2SXcw5ly8S98f7eNDMq2AX7hbIF35DY=";
   };
 
   prePatch = ''

pkgs/tools/system/bpytop/default.nix

···
-{ lib
-, stdenv
-, python3Packages
-, fetchFromGitHub
-, makeWrapper
-}:
-
-stdenv.mkDerivation rec {
-  pname = "bpytop";
-  version = "1.0.68";
-
-  src = fetchFromGitHub {
-    owner = "aristocratos";
-    repo = pname;
-    rev = "v${version}";
-    sha256 = "sha256-NHfaWWwNpGhqu/ALcW4p4X6sktEyLbKQuNHpAUUw4LY=";
-  };
-
-  nativeBuildInputs = [ makeWrapper ];
-
-  propagatedBuildInputs = with python3Packages; [ python psutil ];
-
-  dontBuild = true;
-
-  postPatch = ''
-    sed -i -e "s#/usr/\[local/\]#$out/#g" \
-           -e "s#/usr/{td}#$out/#g" \
-           -e "s#THEME_DIR: str = \"\"#THEME_DIR: str = \"$out/share/bpytop/themes\"#" \
-      ./bpytop.py
-  '';
-
-  installPhase = ''
-    mkdir -p $out/{bin,libexec,share/bpytop}/
-    cp -r ./themes $out/share/bpytop/
-    cp ./bpytop.py $out/libexec/
-
-    makeWrapper ${python3Packages.python.interpreter} $out/bin/bpytop \
-      --add-flags "$out/libexec/bpytop.py" \
-      --prefix PYTHONPATH : "$PYTHONPATH"
-  '';
-
-  meta = with lib; {
-    description = "A resource monitor; python port of bashtop";
-    homepage = src.meta.homepage;
-    license = licenses.asl20;
-    maintainers = with maintainers; [ aw ];
-    platforms = with platforms; linux ++ freebsd ++ darwin;
-  };
-}

pkgs/top-level/aliases.nix

···
   boost160 = throw "boost160 has been deprecated in favor of the latest version"; # Added 2023-01-01
   botan = throw "botan has been removed because it did not support a supported openssl version"; # added 2021-12-15
   bpftool = bpftools; # Added 2021-05-03
+  bpytop = throw "bpytop has been deprecated by btop"; # Added 2023-02-16
   brackets = throw "brackets has been removed, it was unmaintained and had open vulnerabilities"; # Added 2021-01-24
   bridge_utils = throw "'bridge_utils' has been renamed to/replaced by 'bridge-utils'"; # Converted to throw 2022-02-22
   bro = zeek; # Added 2019-09-29

pkgs/top-level/all-packages.nix

···
 
   bpb = callPackage ../tools/security/bpb { inherit (darwin.apple_sdk.frameworks) Security; };
 
-  bpytop = callPackage ../tools/system/bpytop { };
-
   brasero-original = lowPrio (callPackage ../tools/cd-dvd/brasero { });
 
   brasero = callPackage ../tools/cd-dvd/brasero/wrapper.nix { };
···
 
   verible = callPackage ../development/tools/language-servers/verible { };
 
+  zls = callPackage ../development/tools/language-servers/zls {
+    zig = zig_0_10;
+  };
+
   ansible-later = with python3.pkgs; toPythonApplication ansible-later;
 
   ansible-lint = with python3.pkgs; toPythonApplication ansible-lint;
···
   yq-go = callPackage ../development/tools/yq-go { };
 
   ytt = callPackage ../development/tools/ytt {};
-
-  zls = callPackage ../development/tools/zls {
-    zig = zig_0_9;
-  };
 
   zydis = callPackage ../development/libraries/zydis { };
 
···
   nar-serve = callPackage ../tools/nix/nar-serve { };
 
   neo = callPackage ../applications/misc/neo { };
+
+  networkd-dispatcher = callPackage ../tools/networking/networkd-dispatcher { };
 
   nixVersions = recurseIntoAttrs (callPackage ../tools/package-management/nix {
     storeDir = config.nix.storeDir or "/nix/store";

pkgs/top-level/haskell-packages.nix

···
     "ghc90"
     "ghc924"
     "ghc925"
+    "ghc926"
     "ghc92"
     "ghc942"
     "ghc943"
···
     "ghc92"
     "ghc924"
     "ghc925"
+    "ghc926"
     "ghc94"
     "ghc942"
     "ghc943"
···
       buildTargetLlvmPackages = pkgsBuildTarget.llvmPackages_12;
       llvmPackages = pkgs.llvmPackages_12;
     };
-    ghc92 = ghc924;
+    ghc926 = callPackage ../development/compilers/ghc/9.2.6.nix {
+      bootPkgs =
+        # aarch64 ghc8107Binary exceeds max output size on hydra
+        if stdenv.hostPlatform.isAarch then
+          packages.ghc8107BinaryMinimal
+        else if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then
+          packages.ghc810
+        else
+          packages.ghc8107Binary;
+      inherit (buildPackages.python3Packages) sphinx;
+      # Need to use apple's patched xattr until
+      # https://github.com/xattr/xattr/issues/44 and
+      # https://github.com/xattr/xattr/issues/55 are solved.
+      inherit (buildPackages.darwin) xattr autoSignDarwinBinariesHook;
+      buildTargetLlvmPackages = pkgsBuildTarget.llvmPackages_12;
+      llvmPackages = pkgs.llvmPackages_12;
+    };
+    ghc92 = ghc926;
     ghc942 = callPackage ../development/compilers/ghc/9.4.2.nix {
       bootPkgs =
         # Building with 9.2 is broken due to
···
       ghc = bh.compiler.ghc925;
       compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-9.2.x.nix { };
     };
-    ghc92 = ghc924;
+    ghc926 = callPackage ../development/haskell-modules {
+      buildHaskellPackages = bh.packages.ghc926;
+      ghc = bh.compiler.ghc926;
+      compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-9.2.x.nix { };
+    };
+    ghc92 = ghc926;
     ghc942 = callPackage ../development/haskell-modules {
       buildHaskellPackages = bh.packages.ghc942;
       ghc = bh.compiler.ghc942;

pkgs/top-level/release-haskell.nix

···
     ghc902
     ghc924
     ghc925
+    ghc926
     ghc944
   ];
 
···
               ;
             };
 
-            haskell.packages.native-bignum.ghc924 = {
-              inherit (packagePlatforms pkgs.pkgsStatic.haskell.packages.native-bignum.ghc924)
+            haskell.packages.native-bignum.ghc926 = {
+              inherit (packagePlatforms pkgs.pkgsStatic.haskell.packages.native-bignum.ghc926)
                 hello
                 lens
                 random
···
       ghc-lib = released;
       ghc-lib-parser = released;
       ghc-lib-parser-ex = released;
+      ghc-tags = [
+        compilerNames.ghc8107
+        compilerNames.ghc902
+        compilerNames.ghc924
+        compilerNames.ghc925
+        compilerNames.ghc926
+        compilerNames.ghc944
+      ];
       weeder = [
         compilerNames.ghc8107
         compilerNames.ghc902
         compilerNames.ghc924
         compilerNames.ghc925
+        compilerNames.ghc926
       ];
     })
     {
···
           jobs.pkgsMusl.haskell.compiler.ghc902
           jobs.pkgsMusl.haskell.compiler.ghc924
           jobs.pkgsMusl.haskell.compiler.ghc925
+          jobs.pkgsMusl.haskell.compiler.ghc926
           jobs.pkgsMusl.haskell.compiler.ghcHEAD
           jobs.pkgsMusl.haskell.compiler.integer-simple.ghc8107
           jobs.pkgsMusl.haskell.compiler.native-bignum.ghc902
           jobs.pkgsMusl.haskell.compiler.native-bignum.ghc924
           jobs.pkgsMusl.haskell.compiler.native-bignum.ghc925
+          jobs.pkgsMusl.haskell.compiler.native-bignum.ghc926
           jobs.pkgsMusl.haskell.compiler.native-bignum.ghcHEAD
         ];
       };
···
         };
         constituents = accumulateDerivations [
           jobs.pkgsStatic.haskellPackages
-          jobs.pkgsStatic.haskell.packages.native-bignum.ghc924
+          jobs.pkgsStatic.haskell.packages.native-bignum.ghc926
         ];
       };
     }