Merge master into staging-next

maintainers/maintainer-list.nix

···
     githubId = 410028;
     name = "Tobias Bergkvist";
   };
+  berryp = {
+    email = "[e-mail]";
+    github = "berryp";
+    githubId = 19911;
+    name = "Berry Phillips";
+  };
   betaboon = {
     email = "[e-mail]";
     github = "betaboon";

pkgs/applications/audio/axoloti/default.nix

···
-{ lib, stdenv, fetchFromGitHub, fetchurl, makeWrapper, unzip
-, gnumake, gcc-arm-embedded, binutils-arm-embedded
-, dfu-util-axoloti, jdk, ant, libfaketime }:
-
-stdenv.mkDerivation rec {
-  version = "1.0.12-2";
-  pname = "axoloti";
-
-  src = fetchFromGitHub {
-    owner = "axoloti";
-    repo = "axoloti";
-    rev = version;
-    sha256 = "1qffis277wshldr3i939b0r2x3a2mlr53samxqmr2nk1sfm2b4w9";
-  };
-
-  chibi_version = "2.6.9";
-  chibi_name = "ChibiOS_${chibi_version}";
-
-  chibios = fetchurl {
-    url = "mirror://sourceforge/project/chibios/ChibiOS_RT%20stable/Version%20${chibi_version}/${chibi_name}.zip";
-    sha256 = "0lb5s8pkj80mqhsy47mmq0lqk34s2a2m3xagzihalvabwd0frhlj";
-  };
-
-  nativeBuildInputs = [
-    makeWrapper
-    unzip
-    gcc-arm-embedded
-    binutils-arm-embedded
-    dfu-util-axoloti
-    ant
-  ];
-  buildInputs = [jdk libfaketime ];
-
-  patchPhase = ''
-    unzip ${chibios}
-    mv ${chibi_name} chibios
-    (cd chibios/ext; unzip -q -o fatfs-0.9-patched.zip)
-
-    # Remove source of non-determinism in ChibiOS
-    substituteInPlace "chibios/os/various/shell.c" \
-      --replace "#ifdef __DATE__" "#if 0"
-
-    # Hardcode path to "make"
-    for f in "firmware/compile_firmware_linux.sh" \
-             "firmware/compile_patch_linux.sh"; do
-      substituteInPlace "$f" \
-        --replace "make" "${gnumake}/bin/make"
-    done
-
-    # Hardcode dfu-util path
-    substituteInPlace "platform_linux/upload_fw_dfu.sh" \
-      --replace "/bin/dfu-util" ""
-    substituteInPlace "platform_linux/upload_fw_dfu.sh" \
-      --replace "./dfu-util" "${dfu-util-axoloti}/bin/dfu-util"
-
-    # Fix build version
-    substituteInPlace "build.xml" \
-      --replace "(git missing)" "${version}"
-
-    # Remove build time
-    substituteInPlace "build.xml" \
-      --replace "<tstamp>" ""
-    substituteInPlace "build.xml" \
-      --replace \
-        '<format property="build.time" pattern="dd/MM/yyyy HH:mm:ss z"/>' \
-        '<property name="build.time" value=""/>'
-    substituteInPlace "build.xml" \
-      --replace "</tstamp>" ""
-    substituteInPlace "build.xml" \
-      --replace \
-       '{line.separator}</echo>' \
-       '{line.separator}</echo> <touch file="src/main/java/axoloti/Version.java" millis="0" />'
-  '';
-
-  buildPhase = ''
-    find . -exec touch -d '1970-01-01 00:00' {} \;
-    (cd platform_linux; sh compile_firmware.sh)
-    faketime "1970-01-01 00:00:00" ant -Dbuild.runtime=true
-  '';
-
-  installPhase = ''
-    mkdir -p $out/bin $out/share/axoloti
-
-    cp -r doc firmware chibios platform_linux CMSIS *.txt $out/share/axoloti/
-    install -vD dist/Axoloti.jar $out/share/axoloti/
-
-    makeWrapper ${jdk}/bin/java $out/bin/axoloti --add-flags "-Daxoloti_release=$out/share/axoloti -Daxoloti_runtime=$out/share/axoloti -jar $out/share/axoloti/Axoloti.jar"
-  '';
-
-  meta = with lib; {
-    homepage = "http://www.axoloti.com";
-    description = ''
-      Sketching embedded digital audio algorithms.
-
-      To fix permissions of the Axoloti USB device node, add a similar udev rule to <literal>services.udev.extraRules</literal>:
-      <literal>SUBSYSTEM=="usb", ATTR{idVendor}=="16c0", ATTR{idProduct}=="0442", OWNER="someuser", GROUP="somegroup"</literal>
-    '';
-    license = licenses.gpl3;
-    maintainers = with maintainers; [ ];
-  };
-}

pkgs/applications/audio/axoloti/dfu-util.nix

···
-{ lib, stdenv, fetchurl, pkg-config, libusb1-axoloti }:
-
-stdenv.mkDerivation rec {
-  pname = "dfu-util";
-  version = "0.8";
-
-  nativeBuildInputs = [ pkg-config ];
-  buildInputs = [ libusb1-axoloti ];
-
-  src = fetchurl {
-    url = "http://dfu-util.sourceforge.net/releases/${pname}-${version}.tar.gz";
-    sha256 = "0n7h08avlzin04j93m6hkq9id6hxjiiix7ff9gc2n89aw6dxxjsm";
-  };
-
-  meta = with lib; {
-    description = "Device firmware update (DFU) USB programmer";
-    longDescription = ''
-      dfu-util is a program that implements the host (PC) side of the USB
-      DFU 1.0 and 1.1 (Universal Serial Bus Device Firmware Upgrade) protocol.
-
-      DFU is intended to download and upload firmware to devices connected over
-      USB. It ranges from small devices like micro-controller boards up to mobile
-      phones. With dfu-util you are able to download firmware to your device or
-      upload firmware from it.
-    '';
-    homepage = "http://dfu-util.sourceforge.net";
-    license = licenses.gpl2Plus;
-    platforms = platforms.unix;
-    maintainers = [ ];
-  };
-}

pkgs/applications/audio/axoloti/libusb1.nix

···
-{ stdenv, lib, fetchurl, pkg-config, systemd, libobjc, IOKit, fetchpatch }:
-
-stdenv.mkDerivation rec {
-  pname = "libusb";
-  version = "1.0.19";
-
-  src = fetchurl {
-    url = "mirror://sourceforge/libusb/libusb-${version}.tar.bz2";
-    sha256 = "0h38p9rxfpg9vkrbyb120i1diq57qcln82h5fr7hvy82c20jql3c";
-  };
-
-  outputs = [ "out" "dev" ]; # get rid of propagating systemd closure
-
-  buildInputs = [ pkg-config ];
-  propagatedBuildInputs = lib.optional stdenv.isLinux systemd
-    ++ lib.optionals stdenv.isDarwin [ libobjc IOKit ];
-
-  patches = [
-    (fetchpatch {
-      name = "libusb.stdfu.patch";
-      url = "https://raw.githubusercontent.com/axoloti/axoloti/1.0.12/platform_linux/src/libusb.stdfu.patch";
-      sha256 = "194j7j61i4q6x0ihm9ms8dxd4vliw20n2rj6cm9h17qzdl9xr33d";
-    })
-  ];
-
-  NIX_LDFLAGS = lib.optionalString stdenv.isLinux "-lgcc_s";
-
-  preFixup = lib.optionalString stdenv.isLinux ''
-    sed 's,-ludev,-L${lib.getLib systemd}/lib -ludev,' -i $out/lib/libusb-1.0.la
-  '';
-
-  meta = with lib; {
-    homepage = "http://www.libusb.info";
-    description = "User-space USB library";
-    maintainers = with maintainers; [ ];
-    platforms = platforms.unix;
-    license = licenses.lgpl21;
-  };
-}

pkgs/applications/audio/sptlrx/default.nix

···
-{ lib, buildGoModule, fetchFromGitHub, testers, sptlrx }:
+{ lib, buildGoModule, fetchFromGitHub, nix-update-script, testers, sptlrx }:
 
 buildGoModule rec {
   pname = "sptlrx";
···
 
   ldflags = [ "-s" "-w" ];
 
-  passthru.tests.version = testers.testVersion {
-    package = sptlrx;
-    # TODO Wrong version in `0.2.0`. Has been fixed upstream.
-    version = "v0.1.0";
+  passthru = {
+    updateScript = nix-update-script { attrPath = pname; };
+    tests.version = testers.testVersion {
+      package = sptlrx;
+      # TODO Wrong version in `0.2.0`. Has been fixed upstream.
+      version = "v0.1.0";
+    };
   };
 
   meta = with lib; {

pkgs/applications/blockchains/btcdeb/default.nix

···
 
 with lib;
 stdenv.mkDerivation rec {
-  pname = "btcdeb-unstable";
-  version = "200806";
+  pname = "btcdeb";
+  version = "unstable-2022-04-03";
 
   src = fetchFromGitHub {
     owner = "bitcoin-core";
     repo = "btcdeb";
-    rev = "f6708c397c64894c9f9e31bea2d22285d9462de7";
-    sha256 = "0qkmf89z2n7s95vhw3n9vh9dbi14zy4vqw3ffdh1w911jwm5ry3z";
+    rev = "3ba1ec7f4d37f7d2ff0544403465004c6e12036e";
+    hash = "sha256-l/PGXXX288mnoSFZ32t2Xd13dC6JCU5wDHoDxb+fcp0=";
   };
 
   nativeBuildInputs = [ pkg-config autoreconfHook ];
···
 
   meta = {
     description = "Bitcoin Script Debugger";
-    homepage = "https://github.com/kallewoof/btcdeb";
+    homepage = "https://github.com/bitcoin-core/btcdeb";
     license = licenses.mit;
     maintainers = with maintainers; [ akru ];
     platforms = platforms.unix;

pkgs/applications/blockchains/zcash/default.nix

···
 { rust, rustPlatform, stdenv, lib, fetchFromGitHub, fetchpatch, autoreconfHook
-, makeWrapper, cargo, pkg-config, curl, coreutils, boost178, db62, hexdump
-, libsodium, libevent, utf8cpp, util-linux, withDaemon ? true, withMining ? true
-, withUtils ? true, withWallet ? true, withZmq ? true, zeromq
+, makeWrapper, cargo, pkg-config, curl, coreutils, boost179, db62, hexdump
+, libsodium, libevent, testers, utf8cpp, util-linux, withDaemon ? true
+, withMining ? true, withUtils ? true, withWallet ? true, withZmq ? true, zcash
+, zeromq
 }:
 
 rustPlatform.buildRustPackage.override { stdenv = stdenv; } rec {
   pname = "zcash";
-  version = "4.7.0";
+  version = "5.0.0";
 
   src = fetchFromGitHub {
     owner = "zcash";
     repo  = "zcash";
     rev = "v${version}";
-    sha256 = "sha256-yF+/QepSiZwsdZydWjvxDIFeFyJbJyqZmCdMyQHmrzI=";
+    sha256 = "sha256-5PlqFs2njqNeZgmNz0VKMWcRY5lPaF9oTsoh/uLEWi8=";
   };
 
   prePatch = lib.optionalString stdenv.isAarch64 ''
···
       --replace "linker = \"aarch64-linux-gnu-gcc\"" ""
   '';
 
-  cargoPatches = [
-    (fetchpatch {
-      url = "https://github.com/zcash/zcash/commit/61cd19a52d41d60c1987ecf269f7aa8e4d527310.diff";
-      sha256 = "sha256-/7T2yCSVlRN7qfFjrZlfBNMlbVHb/KRjtUBY2xFr0mo=";
-    })
-  ];
-
-  cargoSha256 = "sha256-+BLfO5OnCBqQTIqMXKJdoPCRgtENa+m0WOHKG9gkdMk=";
+  cargoSha256 = "sha256-eRRRjUbOieRC88wf+f1jAYvqGFmogBEla67NnImicEc=";
 
   nativeBuildInputs = [ autoreconfHook cargo hexdump makeWrapper pkg-config ];
-  buildInputs = [ boost178 libevent libsodium utf8cpp ]
+  buildInputs = [ boost179 libevent libsodium utf8cpp ]
     ++ lib.optional withWallet db62
     ++ lib.optional withZmq zeromq;
 
···
 
   configureFlags = [
     "--disable-tests"
-    "--with-boost-libdir=${lib.getLib boost178}/lib"
+    "--with-boost-libdir=${lib.getLib boost179}/lib"
     "CXXFLAGS=-I${lib.getDev utf8cpp}/include/utf8cpp"
     "RUST_TARGET=${rust.toRustTargetSpec stdenv.hostPlatform}"
   ] ++ lib.optional (!withWallet) "--disable-wallet"
···
 
   # Requires hundreds of megabytes of zkSNARK parameters.
   doCheck = false;
+
+  passthru.tests.version = testers.testVersion {
+    package = zcash;
+    command = "zcashd --version";
+    version = "v${zcash.version}";
+  };
 
   postInstall = ''
     wrapProgram $out/bin/zcash-fetch-params \

pkgs/applications/misc/authenticator/default.nix

···
 , fetchFromGitLab
 , fetchpatch
 , appstream-glib
+, clang
 , desktop-file-utils
 , meson
 , ninja
 , pkg-config
-, python3
 , rustPlatform
 , wrapGAppsHook
 , gdk-pixbuf
···
 , gst_all_1
 , gtk4
 , libadwaita
+, libclang
 , openssl
+, pipewire
 , sqlite
 , wayland
 , zbar
···
 
 stdenv.mkDerivation rec {
   pname = "authenticator";
-  version = "4.0.3";
+  version = "4.1.1";
 
   src = fetchFromGitLab {
     domain = "gitlab.gnome.org";
     owner = "World";
     repo = "Authenticator";
     rev = version;
-    sha256 = "0fvs76f3fm5pxn7wg6sjbqpgip5w2j7xrh4siasdcl2bx6vsld8b";
+    hash = "sha256-wl7wyj0vVDkOB7XKQFOEFzCmffTsrUsaM83fWgZ6tG0=";
   };
 
   cargoDeps = rustPlatform.fetchCargoTarball {
     inherit src;
     name = "${pname}-${version}";
-    sha256 = "1s97jyszxf24rs3ni11phiyvmp1wm8sicb0rh1jgwz4bn1cnakx4";
+    hash = "sha256-3SzemDjLsZUXPPtSlDMBQXQf5P3Sz8caJL73mHRv1js=";
   };
 
-  postPatch = ''
-    patchShebangs build-aux
-  '';
-
   nativeBuildInputs = [
     appstream-glib
+    clang
     desktop-file-utils
     meson
     ninja
     pkg-config
-    python3
     wrapGAppsHook
   ] ++ (with rustPlatform; [
     cargoSetupHook
···
     glib
     gst_all_1.gstreamer
     gst_all_1.gst-plugins-base
-
-    # gst-plugins-good needs gtk4 support:
-    # https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/merge_requests/767
-    # We copy the way it is built from the Flatpak:
-    # https://gitlab.gnome.org/World/Authenticator/-/blob/master/build-aux/com.belmoussaoui.Authenticator.Devel.json
-    (gst_all_1.gst-plugins-good.overrideAttrs (old: {
-      patches = old.patches or [ ] ++ [
-        "${src}/build-aux/767.patch"
-      ];
-      mesonFlags = old.mesonFlags ++ [
-        "-Dgtk3=disabled"
-        "-Dgtk4=enabled"
-        "-Dgtk4-experiments=true"
-      ];
-      buildInputs = old.buildInputs ++ [
-        gtk4
-      ];
-    }))
-
     (gst_all_1.gst-plugins-bad.override { enableZbar = true; })
     gtk4
     libadwaita
     openssl
+    pipewire
     sqlite
     wayland
     zbar
   ];
 
-  meta = with lib; {
-    broken = true; # https://gitlab.gnome.org/World/Authenticator/-/issues/271
+  LIBCLANG_PATH = "${lib.getLib libclang}/lib";
+
+  meta = {
     description = "Two-factor authentication code generator for GNOME";
     homepage = "https://gitlab.gnome.org/World/Authenticator";
-    license = licenses.gpl3Plus;
-    maintainers = with maintainers; [ dotlambda ];
+    license = lib.licenses.gpl3Plus;
+    maintainers = with lib.maintainers; [ dotlambda ];
+    platforms = lib.platforms.linux;
   };
 }

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

···
 
 in stdenv.mkDerivation rec {
   pname = "signal-desktop";
-  version = "5.42.0"; # Please backport all updates to the stable channel.
+  version = "5.43.0"; # Please backport all updates to the stable channel.
   # All releases have a limited lifetime and "expire" 90 days after the release.
   # When releases "expire" the application becomes unusable until an update is
   # applied. The expiration date for the current release can be extracted with:
···
 
   src = fetchurl {
     url = "https://updates.signal.org/desktop/apt/pool/main/s/signal-desktop/signal-desktop_${version}_amd64.deb";
-    sha256 = "sha256-xjSj7eKaDV8WB0SiPb4orxKK8mV2a2EWiMBK7BE8mgU=";
+    sha256 = "sha256-DYJ3WZbaalKhQXhVQO3qhJiGj92Cc+pwRDx/YBIi6gg=";
   };
 
   nativeBuildInputs = [

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

···
 
 stdenv.mkDerivation rec {
   pname = "alliance";
-  version = "unstable-2021-09-15";
+  version = "unstable-2022-01-13";
 
   src = fetchFromGitLab {
     domain = "gitlab.lip6.fr";
     owner = "vlsi-eda";
     repo = "alliance";
-    rev = "5e83c92d0307cce9d599f7099fb0023f81d26d65";
-    sha256 = "Vd3MTT4eKn4FMt0/F4fQUPcWq25kH0FpeGxQUOetKPY=";
+    rev = "ebece102e15c110fc79f1da50524c68fd9523f0c";
+    hash = "sha256-NGtE3ZmN9LrgXG4NIKrp7dFRVzrKMoudlPUtYYKrZjY=";
   };
 
   prePatch = "cd alliance/src";

pkgs/data/misc/hackage/pin.json

···
 {
-  "commit": "78324aa49909392e169c86bbfd204694523907e8",
-  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/78324aa49909392e169c86bbfd204694523907e8.tar.gz",
-  "sha256": "15k5ag36asswwv8yazq53lkj9blnz4hzlq23cznvvk5pkjpdm0ni",
-  "msg": "Update from Hackage at 2022-05-05T15:07:55Z"
+  "commit": "38aa99a1623af5371157721c2a4b033b828e9938",
+  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/38aa99a1623af5371157721c2a4b033b828e9938.tar.gz",
+  "sha256": "0phak7cjg3nrj5i3ih2k95hcwx25s6zijbp81ycqd0yb108gvw34",
+  "msg": "Update from Hackage at 2022-05-10T13:45:20Z"
 }

pkgs/development/compilers/mruby/default.nix

···
-{ lib, stdenv, ruby, bison, rake, fetchFromGitHub, fetchpatch }:
+{ lib, stdenv, ruby, bison, rake, fetchFromGitHub }:
 
 stdenv.mkDerivation rec {
   pname = "mruby";
-  version = "3.0.0";
+  version = "3.1.0";
 
   src = fetchFromGitHub {
     owner   = "mruby";
     repo    = "mruby";
     rev     = version;
-    sha256  = "sha256-C3K7ZooaOMa+V2HjxwiKxrrMb7ffl4QAgPsftRtb60c=";
+    sha256  = "0gnzip7qfadnl0r1k8bpc9a6796sy503h77ggds02wrz7mpq32nf";
   };
-
-  patches = [
-    (fetchpatch {
-      name = "CVE-2022-1212.patch";
-      url = "https://github.com/mruby/mruby/commit/3cf291f72224715942beaf8553e42ba8891ab3c6.patch";
-      sha256  = "1bl8wm6v7v18zgxqvm4kbn8g97a75phzrdah279xqw1qvplbd2w7";
-    })
-  ];
 
   nativeBuildInputs = [ ruby bison rake ];
 

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

···
   matplotlib = dontCheck super.matplotlib;
 
   # https://github.com/matterhorn-chat/matterhorn/issues/679 they do not want to be on stackage
-  matterhorn = doJailbreak (super.matterhorn.overrideScope (self: super: {
-    brick = self.brick_0_64_2;
-    # Doesn't support aeson 2.0
-    # https://github.com/matterhorn-chat/matterhorn/issues/759
-    aeson = self.aeson_1_5_6_0;
-  }));
-  mattermost-api = super.mattermost-api.override {
-    aeson = self.aeson_1_5_6_0;
-  };
+  matterhorn = doJailbreak super.matterhorn;
 
   memcache = dontCheck super.memcache;
   metrics = dontCheck super.metrics;

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

···
   liquidhaskell = markBroken super.liquidhaskell;
 
   # This became a core library in ghc 8.10., so we don‘t have an "exception" attribute anymore.
-  exceptions = super.exceptions_0_10_4;
+  exceptions = super.exceptions_0_10_5;
 
   # ghc versions which don‘t match the ghc-lib-parser-ex version need the
   # additional dependency to compile successfully.

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

···
   - LTS
   - lua-bc
   - luautils
+  - lucid2
   - lucid-htmx
   - lucid-hyperscript
   - luis-client

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

···
   - ghc-lib-parser == 8.10.7.*          # 2022-02-17: preserve for GHC 8.10.7
   - ghc-lib-parser-ex == 8.10.*         # 2022-02-17: preserve for GHC 8.10.7
   - doctest == 0.18.*                   # 2021-11-19: closest to stackage version for GHC 9.*
-  - brick == 0.64.*                     # 2021-12-03: matterhorn depends on brick < 0.65
   - path == 0.9.0                       # 2021-12-03: path version building with stackage genvalidity and GHC 9.0.2
   - ormolu == 0.2.*                     # 2022-02-21: For ghc 8.8 and 8.10
   - ShellCheck == 0.7.2                 # 2022-02-20: haskell-ci 0.14 needs this

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

···
      }:
      mkDerivation {
        pname = "AesonBson";
-       version = "0.4.0";
-       sha256 = "08ffz1fr8x5z3ipvk99wc5n363ghxrq1z0cv1yh57wx18ialk1cx";
+       version = "0.4.1";
+       sha256 = "0nyl0a3814163dxpmiadmmjdhd9cycmihwmsz7f0316hbm30lg7z";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson attoparsec base bson scientific text unordered-containers
···
      }) {};
 
   "AspectAG" = callPackage
-    ({ mkDerivation, base, containers, mtl, poly-rec, requirements
-     , tagged, template-haskell
+    ({ mkDerivation, base, containers, ghc-prim, loch-th, mtl, poly-rec
+     , requirements, template-haskell
      }:
      mkDerivation {
        pname = "AspectAG";
-       version = "0.6.0.0";
-       sha256 = "09lm1hs9l3h6ndv385adhh0kf9id10fjf0n1bczgzqgxmiykx2kn";
+       version = "0.7.0.0";
+       sha256 = "1w5zfx5vgvkys84vdrdd3rv39ly25wbn9izlir19irniqsbf6z6v";
        libraryHaskellDepends = [
-         base containers mtl poly-rec requirements tagged template-haskell
+         base containers ghc-prim loch-th mtl poly-rec requirements
+         template-haskell
        ];
        description = "Strongly typed Attribute Grammars implemented using type-level programming";
        license = lib.licenses.gpl3Only;
···
        pname = "Naperian";
        version = "0.1.1.0";
        sha256 = "1i9hc1pdp9mg9x1xd4wrv06cbhjxw0yhyk2xhsm8jz6rgksa22j7";
+       revision = "1";
+       editedCabalFile = "0njjyn54cda1j2rmxhmz9hnbg5rwd5f8qcdgfk2z9bq1aiv3h61q";
        libraryHaskellDepends = [ base containers ghc-prim vector ];
        description = "Naperian Functors for APL-like programming";
        license = "unknown";
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "adjunctions_4_4_1" = callPackage
+    ({ mkDerivation, array, base, comonad, containers, contravariant
+     , distributive, free, generic-deriving, hspec, hspec-discover, mtl
+     , profunctors, semigroupoids, semigroups, tagged, transformers
+     , transformers-compat, void
+     }:
+     mkDerivation {
+       pname = "adjunctions";
+       version = "4.4.1";
+       sha256 = "0hqm86v5in7xp31wv3wvr1h7gsim96fpl0si0xrpv8060qalzwww";
+       libraryHaskellDepends = [
+         array base comonad containers contravariant distributive free mtl
+         profunctors semigroupoids semigroups tagged transformers
+         transformers-compat void
+       ];
+       testHaskellDepends = [ base distributive generic-deriving hspec ];
+       testToolDepends = [ hspec-discover ];
+       description = "Adjunctions and representable functors";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "adler32" = callPackage
     ({ mkDerivation, base, bytestring, hspec, zlib }:
      mkDerivation {
···
        pname = "aeson-better-errors";
        version = "0.9.1.1";
        sha256 = "05yibq9kqbjb8rh84n12sbax05amvd8jccpja0hyadz58pjy4jnk";
+       revision = "1";
+       editedCabalFile = "0wzvrmhn5q2x1mcv43cyxhlck815ldkhx7c7gz5ijjyva1iicgn2";
        libraryHaskellDepends = [
          aeson base bytestring dlist mtl scientific text transformers
          transformers-compat unordered-containers vector void
···
      }) {};
 
   "aeson-iproute" = callPackage
-    ({ mkDerivation, aeson, base, doctest, iproute, text
-     , unordered-containers
-     }:
+    ({ mkDerivation, aeson, base, doctest, iproute, text }:
      mkDerivation {
        pname = "aeson-iproute";
-       version = "0.2.1";
-       sha256 = "1130mr5fqwi4d74xg6nkvpqycc0vvd6rsiahm1pdhbrx3wvra8p2";
-       revision = "1";
-       editedCabalFile = "1q9yr42mvvcqy20ww1xcsy2q6jji0mrqng2clq8yd5diyy7kqx1a";
-       libraryHaskellDepends = [
-         aeson base iproute text unordered-containers
-       ];
+       version = "0.3.0";
+       sha256 = "027mmmjlfld6mncn0k8v0i2lg4xkgymaakl5nqs7jw7apgy83x2z";
+       libraryHaskellDepends = [ aeson base iproute text ];
        testHaskellDepends = [ base doctest ];
        description = "Aeson instances for iproute types";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "arduino-copilot";
-       version = "1.7.0";
-       sha256 = "073l9fmg1i83whdfbplpshz2695ls7bb4kf4c40446q0cpccpnrc";
+       version = "1.7.1";
+       sha256 = "1w42y0avx032i7s208p1rkc24c7hy7lbjia5qjgixzv8qcc0693b";
        libraryHaskellDepends = [
          base containers copilot copilot-c99 copilot-language directory
          filepath mtl optparse-applicative sketch-frp-copilot temporary
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "benchpress_0_2_2_20" = callPackage
+    ({ mkDerivation, base, bytestring, mtl, time }:
+     mkDerivation {
+       pname = "benchpress";
+       version = "0.2.2.20";
+       sha256 = "0yh44hdk7gh6ygdlys2mrij2gphdv5da8hmc7rnyf6cr5509ynn8";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base mtl time ];
+       executableHaskellDepends = [ base bytestring time ];
+       description = "Micro-benchmarking with detailed statistics";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "bencode" = callPackage
     ({ mkDerivation, base, binary, bytestring, containers, hspec
      , parsec, QuickCheck, transformers, transformers-compat
···
        testToolDepends = [ hspec-discover ];
        description = "Bifunctors";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "bifunctors_5_5_12" = callPackage
+    ({ mkDerivation, base, base-orphans, comonad, containers, hspec
+     , hspec-discover, QuickCheck, tagged, template-haskell
+     , th-abstraction, transformers, transformers-compat
+     }:
+     mkDerivation {
+       pname = "bifunctors";
+       version = "5.5.12";
+       sha256 = "0pbidsv1w3bvzs8w6sv8g1iqf0l9r1y0b1fmvd67cwlp01r7f1n6";
+       libraryHaskellDepends = [
+         base base-orphans comonad containers tagged template-haskell
+         th-abstraction transformers
+       ];
+       testHaskellDepends = [
+         base hspec QuickCheck template-haskell transformers
+         transformers-compat
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Bifunctors";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "bighugethesaurus" = callPackage
···
        pname = "bits";
        version = "0.6";
        sha256 = "18s2aa99cwcshcws2zl2ll7xgqn9dpznpkv1nplamc9h4vmqqs93";
+       revision = "1";
+       editedCabalFile = "1f118vwwskai74l6wn5sfy002k241qv1rhpsahphfr58llzgvv50";
        libraryHaskellDepends = [ base bytes mtl transformers ];
        description = "Various bit twiddling and bitwise serialization primitives";
        license = lib.licenses.bsd3;
···
        broken = true;
      }) {};
 
+  "blaze-htmx" = callPackage
+    ({ mkDerivation, base, blaze-html, blaze-markup }:
+     mkDerivation {
+       pname = "blaze-htmx";
+       version = "0.1.0.0";
+       sha256 = "18bl1bnf5z3p9pa12hjd2j53hi1qigya8bbpsj9jczgn4cbvx5q6";
+       libraryHaskellDepends = [ base blaze-html blaze-markup ];
+       testHaskellDepends = [ base blaze-html ];
+       description = "Blaze integration of the htmx library";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "blaze-json" = callPackage
     ({ mkDerivation, aeson, base, bytestring, bytestring-builder
      , containers, data-default-class, doctest, QuickCheck, scientific
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "bound_2_0_5" = callPackage
+    ({ mkDerivation, base, bifunctors, binary, bytes, cereal, comonad
+     , deepseq, deriving-compat, hashable, mmorph, profunctors
+     , template-haskell, th-abstraction, transformers
+     , transformers-compat, vector, void
+     }:
+     mkDerivation {
+       pname = "bound";
+       version = "2.0.5";
+       sha256 = "1cnw0q97bys7jcpjds2fb6zkq9pyqxcb8v0b5dvkckqmlp8agn4v";
+       libraryHaskellDepends = [
+         base bifunctors binary bytes cereal comonad deepseq hashable mmorph
+         profunctors template-haskell th-abstraction transformers
+         transformers-compat
+       ];
+       testHaskellDepends = [
+         base deriving-compat transformers transformers-compat vector void
+       ];
+       description = "Making de Bruijn Succ Less";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "bound-extras" = callPackage
     ({ mkDerivation, adjunctions, base, bound, containers, deepseq
      , filepath, hashable, pretty, tasty, tasty-golden, text-short
···
        broken = true;
      }) {};
 
-  "brick_0_64_2" = callPackage
-    ({ mkDerivation, base, bytestring, config-ini, containers
-     , contravariant, data-clist, deepseq, directory, dlist, exceptions
-     , filepath, microlens, microlens-mtl, microlens-th, QuickCheck, stm
-     , template-haskell, text, text-zipper, transformers, unix, vector
-     , vty, word-wrap
-     }:
-     mkDerivation {
-       pname = "brick";
-       version = "0.64.2";
-       sha256 = "058kpghx5s559z5l9hav44s8vb5lizn8j7v7l4lmvpqx3a6cisn7";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         base bytestring config-ini containers contravariant data-clist
-         deepseq directory dlist exceptions filepath microlens microlens-mtl
-         microlens-th stm template-haskell text text-zipper transformers
-         unix vector vty word-wrap
-       ];
-       testHaskellDepends = [
-         base containers microlens QuickCheck vector
-       ];
-       description = "A declarative terminal user interface library";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-     }) {};
-
   "brick" = callPackage
     ({ mkDerivation, base, bytestring, config-ini, containers
      , contravariant, data-clist, deepseq, directory, dlist, exceptions
···
        ];
        description = "Sharing code for serialization between binary and cereal";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "bytes_0_17_2" = callPackage
+    ({ mkDerivation, base, binary, binary-orphans, bytestring, cereal
+     , containers, hashable, mtl, scientific, text, time, transformers
+     , transformers-compat, unordered-containers, void
+     }:
+     mkDerivation {
+       pname = "bytes";
+       version = "0.17.2";
+       sha256 = "06kqqk19qjhrwdqi6pyd1lwqfnj2sw3b3s49lc5vr2fmv8gg8mdw";
+       libraryHaskellDepends = [
+         base binary binary-orphans bytestring cereal containers hashable
+         mtl scientific text time transformers transformers-compat
+         unordered-containers void
+       ];
+       description = "Sharing code for serialization between binary and cereal";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "byteset" = callPackage
···
 
   "cantor-pairing" = callPackage
     ({ mkDerivation, base, containers, hspec, hspec-discover
-     , integer-gmp, integer-logarithms, integer-roots, mtl
+     , integer-gmp, integer-logarithms, integer-roots
      }:
      mkDerivation {
        pname = "cantor-pairing";
-       version = "0.2.0.1";
-       sha256 = "12wfm27gwhar7djd459yc86bv29818xdyc8glkhgn4q1kx7nda90";
+       version = "0.2.0.2";
+       sha256 = "1h95xbc1lhwd40qk64qw2cmr7prwygli1q2wy5hscny7jyah95c2";
        libraryHaskellDepends = [
          base containers integer-gmp integer-logarithms integer-roots
        ];
-       testHaskellDepends = [ base containers hspec mtl ];
+       testHaskellDepends = [ base containers hspec ];
        testToolDepends = [ hspec-discover ];
        description = "Convert data to and from a natural number representation";
        license = lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "copilot";
-       version = "3.8";
-       sha256 = "0lqr2ns6jg7m36pynl6i442d8x4kdlwlxqf59a0gspn8zgidwaii";
+       version = "3.9";
+       sha256 = "0kryqpk4sn5gbpjpvzcdhd5yp5045cfr2c112df5vagd7gp4a4gd";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "copilot-c99";
-       version = "3.8";
-       sha256 = "0bpak9kd23j8bmc8x7ksb84gggmxplax4wj00c39mrvh5cb5wlwx";
+       version = "3.9";
+       sha256 = "1m915j72b6axbwnls4kcjcdpixxlrjxw4zpvdzq34jym5h2kpd78";
        libraryHaskellDepends = [
          base containers copilot-core directory filepath language-c99
          language-c99-simple language-c99-util mtl pretty
···
      }:
      mkDerivation {
        pname = "copilot-core";
-       version = "3.8";
-       sha256 = "0vv3p9a0c3pa856yx8zmr4d5ag8mym9gbpz5bgi17a7cgfc682cz";
+       version = "3.9";
+       sha256 = "0haqyci12b44dn1hpfqp9hfyw949gl61yzxic8kznb0hl1h1sl5a";
        libraryHaskellDepends = [ base dlist mtl pretty ];
        testHaskellDepends = [
          base HUnit pretty QuickCheck test-framework test-framework-hunit
···
      }:
      mkDerivation {
        pname = "copilot-language";
-       version = "3.8";
-       sha256 = "1wnv7xkgalxd7p7bm2zrsbg2r2wip9an8m5m3fc63wxvk9wcabj6";
+       version = "3.9";
+       sha256 = "1041mm4c8zf7wlrcnfp97lsnr8qsmclr7y3qcawx9pmarwk8arg8";
        libraryHaskellDepends = [
          array base containers copilot-core copilot-theorem data-reify mtl
        ];
···
      }:
      mkDerivation {
        pname = "copilot-libraries";
-       version = "3.8";
-       sha256 = "1sx8bl10j7qwqi91dbl9dahy9l2n17qfbyni73az2fx9rq3q1jkz";
+       version = "3.9";
+       sha256 = "12h121zlq4xbkh947lkxdsjykf061rlmxkyhzyc2s2520fhkapx3";
        libraryHaskellDepends = [
          array base containers copilot-language data-reify mtl parsec
        ];
···
      }:
      mkDerivation {
        pname = "copilot-theorem";
-       version = "3.8";
-       sha256 = "18287hs36lhf1g6l740vkynccy1d87lrr9rcjpgzfn03s9y3d58n";
+       version = "3.9";
+       sha256 = "1gnr6rd88gxs5wxkh6j28hqm81bj8b585n6ywm6s5p2wxgx0wzbn";
        libraryHaskellDepends = [
          ansi-terminal base bimap bv-sized containers copilot-core
          data-default directory filepath libBF mtl panic parameterized-utils
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "deriving-compat_0_6_1" = callPackage
+    ({ mkDerivation, base, base-compat, base-orphans, containers
+     , ghc-boot-th, ghc-prim, hspec, hspec-discover, QuickCheck, tagged
+     , template-haskell, th-abstraction, transformers
+     , transformers-compat, void
+     }:
+     mkDerivation {
+       pname = "deriving-compat";
+       version = "0.6.1";
+       sha256 = "09lxms6220saycra4kpxihwa7zh253zmv1zpa41dbnhgffxs3zbb";
+       libraryHaskellDepends = [
+         base containers ghc-boot-th ghc-prim template-haskell
+         th-abstraction transformers transformers-compat
+       ];
+       testHaskellDepends = [
+         base base-compat base-orphans hspec QuickCheck tagged
+         template-haskell transformers transformers-compat void
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Backports of GHC deriving extensions";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "deriving-show-simple" = callPackage
     ({ mkDerivation, base, HUnit }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "diagnose";
-       version = "1.9.0";
-       sha256 = "0w3mzk50pzf5rr2k8lfkmmlsr8kmvgx1jcszla4khx0an5bsafnf";
+       version = "2.0.0";
+       sha256 = "1rb2fm0bx1rmb63xc56v19adi9f0iy72j0h8rvrvw0lvcwp398xk";
        libraryHaskellDepends = [
          base data-default hashable prettyprinter
          prettyprinter-ansi-terminal unordered-containers wcwidth
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "either_5_0_2" = callPackage
+    ({ mkDerivation, base, bifunctors, mtl, profunctors, QuickCheck
+     , semigroupoids, test-framework, test-framework-quickcheck2
+     }:
+     mkDerivation {
+       pname = "either";
+       version = "5.0.2";
+       sha256 = "1gl748ia68bldbqb2fl7vjv44g0y8ivn659fjmy1qyypgyb5p95z";
+       libraryHaskellDepends = [
+         base bifunctors mtl profunctors semigroupoids
+       ];
+       testHaskellDepends = [
+         base QuickCheck test-framework test-framework-quickcheck2
+       ];
+       description = "Combinators for working with sums";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "either-both" = callPackage
     ({ mkDerivation, base, smallcheck, tasty, tasty-smallcheck }:
      mkDerivation {
···
        broken = true;
      }) {};
 
-  "exceptions_0_10_4" = callPackage
+  "exceptions_0_10_5" = callPackage
     ({ mkDerivation, base, mtl, QuickCheck, stm, template-haskell
      , test-framework, test-framework-hunit, test-framework-quickcheck2
      , transformers
      }:
      mkDerivation {
        pname = "exceptions";
-       version = "0.10.4";
-       sha256 = "1kw4pmx7j7zwbdwm0dyn9rcs6kp4byfxy48861yxdz6gam1zn2sd";
-       revision = "3";
-       editedCabalFile = "0b9bml5j46zz62ik2827ndsd5293dh8630086x1mngb80gnrml3y";
+       version = "0.10.5";
+       sha256 = "12xz2x16pv1a6csz64bpl22v40vykjwvdaiz39i8f8nkwasc1qv6";
        libraryHaskellDepends = [
          base mtl stm template-haskell transformers
        ];
···
        pname = "foldl";
        version = "1.4.12";
        sha256 = "0zf4yljh3s2ddxa7dhzdglmylj14kfldhkclc44g37zvjq6kcnag";
-       revision = "2";
-       editedCabalFile = "0ggl6djyqrc56j8iy56f61jki7v3ym35ykd944z045gpjzbaq3c6";
+       revision = "3";
+       editedCabalFile = "1xijnq8qkmrj2w7h6gr2vy8a0ajhiapzi2fain5pgcllli2fny2r";
        libraryHaskellDepends = [
          base bytestring comonad containers contravariant hashable primitive
          profunctors random semigroupoids text transformers
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "free_5_1_8" = callPackage
+    ({ mkDerivation, base, comonad, containers, distributive
+     , exceptions, indexed-traversable, mtl, profunctors, semigroupoids
+     , template-haskell, th-abstraction, transformers, transformers-base
+     }:
+     mkDerivation {
+       pname = "free";
+       version = "5.1.8";
+       sha256 = "0h43a7w6yjnvqp3rl8qvcjl9a0hg86l0h7zxkikd0mw8n65l8xvr";
+       libraryHaskellDepends = [
+         base comonad containers distributive exceptions indexed-traversable
+         mtl profunctors semigroupoids template-haskell th-abstraction
+         transformers transformers-base
+       ];
+       description = "Monads for free";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "free-algebras" = callPackage
     ({ mkDerivation, base, containers, data-fix, dlist, free, groups
      , hedgehog, kan-extensions, mtl, transformers
···
   "futhark" = callPackage
     ({ mkDerivation, aeson, alex, ansi-terminal, array, base
      , base16-bytestring, binary, blaze-html, bmp, bytestring
-     , bytestring-to-vector, cmark-gfm, containers, cryptohash-md5
+     , bytestring-to-vector, cmark-gfm, containers, cryptohash-md5, Diff
      , directory, directory-tree, dlist, file-embed, filepath, free
      , futhark-data, futhark-manifest, futhark-server, githash, half
      , happy, haskeline, hslogger, language-c-quote, lens, lsp
···
      }:
      mkDerivation {
        pname = "futhark";
-       version = "0.21.10";
-       sha256 = "0mm0awd1sf5sfb6i1yjbcm67j2nhqpfnn11q8p61z3b2py6lnzzf";
+       version = "0.21.11";
+       sha256 = "1n8id7h0qpgifbmkdh3ma72kpv6hn6siyfjd62day3zywrjfxd61";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson ansi-terminal array base base16-bytestring binary blaze-html
          bmp bytestring bytestring-to-vector cmark-gfm containers
-         cryptohash-md5 directory directory-tree dlist file-embed filepath
-         free futhark-data futhark-manifest futhark-server githash half
-         haskeline hslogger language-c-quote lens lsp mainland-pretty
+         cryptohash-md5 Diff directory directory-tree dlist file-embed
+         filepath free futhark-data futhark-manifest futhark-server githash
+         half haskeline hslogger language-c-quote lens lsp mainland-pretty
          megaparsec mtl mwc-random neat-interpolation parallel process
          process-extras random regex-tdfa srcloc statistics template-haskell
          temporary terminal-size text time transformers vector versions
          zip-archive zlib
        ];
        libraryToolDepends = [ alex happy ];
-       executableHaskellDepends = [ base text ];
+       executableHaskellDepends = [ base ];
        testHaskellDepends = [
          base containers megaparsec mtl parser-combinators QuickCheck tasty
          tasty-hunit tasty-quickcheck text
···
        pname = "generic-lens";
        version = "2.2.1.0";
        sha256 = "17an4669igzs6pwzqxnpkx9gmxwz64p32d1zcinhh5agd56y70pa";
+       revision = "1";
+       editedCabalFile = "1wzxvfi9kzhbglih1syqhx42kcsvlinnfc338fl731k6hc95hmlm";
        libraryHaskellDepends = [
          base generic-lens-core profunctors text
        ];
···
        pname = "generic-lens-core";
        version = "2.2.1.0";
        sha256 = "08i4c9yb6z84iknrnl9f3f343121j7ilp0a679v81nsjm9xz3rlf";
+       revision = "1";
+       editedCabalFile = "1dbjhd6k7ypqa9f4h9v2xndgb4mjhfli3n1vjm8r8ga0kfndbqfn";
        libraryHaskellDepends = [ base indexed-profunctors text ];
        description = "Generically derive traversals, lenses and prisms";
        license = lib.licenses.bsd3;
···
        pname = "generic-optics";
        version = "2.2.1.0";
        sha256 = "1bw7bbkrd1sfshzx7v1nbdnkxc82krw96x7vnl7myz9748m4472z";
+       revision = "1";
+       editedCabalFile = "13wkbs8x0clkqzi4xqin89qywpky8jkpz9cxgwsglbpcyw11jvgq";
        libraryHaskellDepends = [
          base generic-lens-core optics-core text
        ];
···
 
   "geomancy" = callPackage
     ({ mkDerivation, base, containers, criterion, deepseq, hedgehog
-     , linear
+     , linear, mono-traversable, simple-affine-space
      }:
      mkDerivation {
        pname = "geomancy";
-       version = "0.2.3.0";
-       sha256 = "1li0411y725c5k6zmkki0brz4w4yksxfdbk2ggq31yirmdihc5al";
-       libraryHaskellDepends = [ base containers deepseq ];
-       testHaskellDepends = [ base deepseq hedgehog linear ];
-       benchmarkHaskellDepends = [ base criterion deepseq linear ];
+       version = "0.2.4.0";
+       sha256 = "1wc9fza03afha1ni7jh9gpm39k20d6n5kmjgkpd06aqpf6yaqfcl";
+       libraryHaskellDepends = [
+         base containers deepseq mono-traversable simple-affine-space
+       ];
+       testHaskellDepends = [
+         base deepseq hedgehog linear simple-affine-space
+       ];
+       benchmarkHaskellDepends = [
+         base criterion deepseq linear simple-affine-space
+       ];
        description = "Geometry and matrix manipulation";
        license = lib.licenses.bsd3;
      }) {};
···
      }) {};
 
   "ghc-debug-brick" = callPackage
-    ({ mkDerivation, base, brick, containers, cursor, directory
+    ({ mkDerivation, base, brick, containers, deepseq, directory
      , exceptions, filepath, ghc-debug-client, ghc-debug-common
      , ghc-debug-convention, microlens, microlens-platform, text, time
      , unordered-containers, vty
      }:
      mkDerivation {
        pname = "ghc-debug-brick";
-       version = "0.2.0.0";
-       sha256 = "1jv2n0bxy37whsxs4drajs0mx83qng82qr62igicfnlqsvd5sk36";
+       version = "0.2.1.0";
+       sha256 = "02zkfndppp386va6vp6mamsv195sdvvwa3dj0ff2kp3kb4gbny7n";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
-         base brick containers cursor directory exceptions filepath
+         base brick containers deepseq directory exceptions filepath
          ghc-debug-client ghc-debug-common ghc-debug-convention microlens
          microlens-platform text time unordered-containers vty
        ];
···
      }:
      mkDerivation {
        pname = "ghc-debug-common";
-       version = "0.2.0.0";
-       sha256 = "1fw9whgh2zayvaagn1f7x1qkwvznpjhpn4zkfnfav24pkmpf5ijy";
-       revision = "2";
-       editedCabalFile = "1cq2bgq9n6295912p8bfwkrg9jqx36x4zxzj468pkr3dsfhjqr23";
+       version = "0.2.1.0";
+       sha256 = "1p895vq31ijkp8lgscxrvpiq2z97l9wx8rcji4nf8kc3bkprk8kl";
        libraryHaskellDepends = [
          array base binary bytestring containers cpu deepseq directory
          dom-lt filepath ghc-debug-convention ghc-heap hashable transformers
···
      }:
      mkDerivation {
        pname = "ghc-debug-stub";
-       version = "0.2.0.0";
-       sha256 = "1zi388jwdad9qlj1v0ihrv67abknbhh7scr1fymc808xmkkwk701";
-       revision = "1";
-       editedCabalFile = "0irnhf32ghxch8r0p2vd7afj3282a1r9lval2an2mj99kcllhl6d";
+       version = "0.2.1.0";
+       sha256 = "1wjmlm9m6iwpn7bz3bjww7vlbp5jac5a8adzzfcxsgw4dz47n221";
        libraryHaskellDepends = [
          base directory filepath ghc-debug-convention ghc-prim
        ];
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "graphs_0_7_2" = callPackage
+    ({ mkDerivation, array, base, containers, transformers
+     , transformers-compat, void
+     }:
+     mkDerivation {
+       pname = "graphs";
+       version = "0.7.2";
+       sha256 = "1isdy8qx3q00pb3jinvvmfvzhwblr3yhj4dzmlv0hdj0yi9j8bly";
+       libraryHaskellDepends = [
+         array base containers transformers transformers-compat void
+       ];
+       description = "A simple monadic graph library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "graphted" = callPackage
     ({ mkDerivation, base, indexed }:
      mkDerivation {
···
     ({ mkDerivation, base, containers, deepseq, fgl, hashable, HUnit
      , monad-primitive, primitive, QuickCheck, ref-tf, test-framework
      , test-framework-hunit, test-framework-quickcheck2, vector
+     , vector-th-unbox
      }:
      mkDerivation {
        pname = "haggle";
-       version = "0.1.0.1";
-       sha256 = "1j598hcjw0p9iac4h91w47k4rh9k0h2r9gk3rrfkklvw84aznkrz";
+       version = "0.2";
+       sha256 = "1n7rg63bz283d938vr2w7ghza2qmljw04bg1wr4zhpylw6jjy2b7";
        libraryHaskellDepends = [
          base containers deepseq hashable monad-primitive primitive ref-tf
-         vector
+         vector vector-th-unbox
        ];
        testHaskellDepends = [
          base containers fgl HUnit QuickCheck test-framework
···
        pname = "happy";
        version = "1.19.12";
        sha256 = "03xlmq6qmdx4zvzw8bp33kd9g7yvcq5cz4wg50xilw812kj276pv";
+       revision = "1";
+       editedCabalFile = "13wydw1mmdry4l9r63vxjk4h55ci9hgwzn1a842qqk1m2rb4xiln";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        pname = "happy";
        version = "1.20.0";
        sha256 = "1346r2x5ravs5fqma65bzjragqbb2g6v41wz9maknwm2jf7kl79v";
+       revision = "1";
+       editedCabalFile = "16dy1cv942rizxp8slnnbwi5l24ggsmy38madbin9scz38idqisx";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
      }:
      mkDerivation {
        pname = "higgledy";
-       version = "0.4.1.1";
-       sha256 = "1aqln8y055ysnzw3sqfdi6rm63a4a8c3n3f4fgv1rqmx76vsvsaz";
+       version = "0.4.2.0";
+       sha256 = "01hl63wq6rb2wgml850wawq07sn9vl8d2hv1jc3m366dxdqqhy8j";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          barbies base generic-lens generic-lens-core named QuickCheck
···
        pname = "hlrdb";
        version = "0.3.2.0";
        sha256 = "1k4dsd4h3fv1ag753gwxvirfrj53ra4ik948pyacq31c16mz1l2p";
-       revision = "2";
-       editedCabalFile = "15z6f2qqis3qi1cfq43hhcqgcsinx58ha3bghh0pfybqysvbjmmd";
+       revision = "3";
+       editedCabalFile = "1r8dmsfbsm4lhak2hskid03bad2fvnb71v779grzf5hy6y46jc42";
        libraryHaskellDepends = [
          base base64-bytestring bytestring cryptonite hashable hedis
          hlrdb-core memory random store time unordered-containers zstd
···
        pname = "hlrdb-core";
        version = "0.1.6.2";
        sha256 = "19pnwjlcg504kpvxq8r1hwb533adi2d919vgb1lr25c9bdyxc32n";
+       revision = "1";
+       editedCabalFile = "0d6bwxk390f00qsmhn71sssw47f53j2wgrwwarhs8vvz6kyvncmp";
        libraryHaskellDepends = [
          base bytestring hashable hedis lens mtl profunctors random time
          unordered-containers
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "http-reverse-proxy_0_6_0_1" = callPackage
+    ({ mkDerivation, base, blaze-builder, bytestring, case-insensitive
+     , conduit, conduit-extra, containers, hspec, http-client
+     , http-conduit, http-types, network, resourcet, streaming-commons
+     , text, transformers, unliftio, wai, wai-logger, warp, word8
+     }:
+     mkDerivation {
+       pname = "http-reverse-proxy";
+       version = "0.6.0.1";
+       sha256 = "0a0fc9rqr1crbb1sbq3gzbkwjcfff662d4bgmy3vzspk7ky697ld";
+       libraryHaskellDepends = [
+         base blaze-builder bytestring case-insensitive conduit
+         conduit-extra containers http-client http-types network resourcet
+         streaming-commons text transformers unliftio wai wai-logger word8
+       ];
+       testHaskellDepends = [
+         base blaze-builder bytestring conduit conduit-extra hspec
+         http-conduit http-types network resourcet streaming-commons
+         transformers unliftio wai warp
+       ];
+       description = "Reverse proxy HTTP requests, either over raw sockets or with WAI";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "http-rfc7807" = callPackage
     ({ mkDerivation, aeson, base, call-stack, hspec-expectations-json
      , http-media, http-types, HUnit, servant, servant-server, tasty
···
   "intricacy" = callPackage
     ({ mkDerivation, array, base, binary, bytestring, containers
      , cryptonite, directory, exceptions, filepath, hscurses, memory
-     , mtl, ncurses, network-fancy, random, safe, SDL, SDL-gfx
+     , mtl, ncurses, network-simple, random, safe, SDL, SDL-gfx
      , SDL-mixer, SDL-ttf, stm, time, transformers, vector
      }:
      mkDerivation {
        pname = "intricacy";
-       version = "0.8.0.1";
-       sha256 = "0kyhswgg8iyxvicgpf0f5rn3gk4k620crk02xd4bn797xws5bzzs";
+       version = "0.8.1";
+       sha256 = "0jpg3rvngsil7zii57inax3im92n1ahv6lcrb3swikahbli0d8wc";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
        executableHaskellDepends = [
          array base binary bytestring containers cryptonite directory
-         exceptions filepath hscurses memory mtl network-fancy random safe
+         exceptions filepath hscurses memory mtl network-simple random safe
          SDL SDL-gfx SDL-mixer SDL-ttf stm time transformers vector
        ];
        executablePkgconfigDepends = [ ncurses ];
···
        testToolDepends = [ hspec-discover ];
        description = "Haskell98 invariant functors";
        license = lib.licenses.bsd2;
+     }) {};
+
+  "invariant_0_5_6" = callPackage
+    ({ mkDerivation, array, base, bifunctors, comonad, containers
+     , contravariant, ghc-prim, hspec, hspec-discover, profunctors
+     , QuickCheck, StateVar, stm, tagged, template-haskell
+     , th-abstraction, transformers, transformers-compat
+     , unordered-containers
+     }:
+     mkDerivation {
+       pname = "invariant";
+       version = "0.5.6";
+       sha256 = "1l73wlnmh09187w8y61qyjjycpljds9lydy16ifa08bmmbxgkzcw";
+       libraryHaskellDepends = [
+         array base bifunctors comonad containers contravariant ghc-prim
+         profunctors StateVar stm tagged template-haskell th-abstraction
+         transformers transformers-compat unordered-containers
+       ];
+       testHaskellDepends = [ base hspec QuickCheck template-haskell ];
+       testToolDepends = [ hspec-discover ];
+       description = "Haskell98 invariant functors";
+       license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "inventory" = callPackage
···
      }:
      mkDerivation {
        pname = "ixset-typed";
-       version = "0.5";
-       sha256 = "07n7qfi8slmrlgzvrkddr17b792phhb140q9gb5pm68kk1im4izs";
+       version = "0.5.1.0";
+       sha256 = "033rm2sik1qz4dmqlabjzwwqw38vj3hrwlkmhm554yvk1n3v9dq8";
        libraryHaskellDepends = [
          base containers deepseq safecopy syb template-haskell
        ];
···
      }:
      mkDerivation {
        pname = "jsonrpc-conduit";
-       version = "0.3.8";
-       sha256 = "196w8jmb8107shbrdhr17axl6x2sx088hdys2yfpqmrcsxc77z45";
+       version = "0.3.9";
+       sha256 = "0qj3rlh695nbs3kxix2r7h4np99q6pn7x8x86j4785d6d2gly1ik";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring conduit conduit-extra mtl text
          transformers unordered-containers
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "kan-extensions_5_2_4" = callPackage
+    ({ mkDerivation, adjunctions, array, base, comonad, containers
+     , contravariant, distributive, free, invariant, mtl, profunctors
+     , semigroupoids, tagged, transformers, transformers-compat
+     }:
+     mkDerivation {
+       pname = "kan-extensions";
+       version = "5.2.4";
+       sha256 = "0qnds0vwhsqznirqalm8f4c0qsmp1awfhc4fn2rx5agl5az3zip8";
+       libraryHaskellDepends = [
+         adjunctions array base comonad containers contravariant
+         distributive free invariant mtl profunctors semigroupoids tagged
+         transformers transformers-compat
+       ];
+       description = "Kan extensions, Kan lifts, the Yoneda lemma, and (co)density (co)monads";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "kangaroo" = callPackage
     ({ mkDerivation, array, base }:
      mkDerivation {
···
        pname = "keys";
        version = "3.12.3";
        sha256 = "0ik6wsff306dnbz0v3gpiajlj5b558hrk9176fzcb2fclf4447nm";
-       revision = "1";
-       editedCabalFile = "18fapd53nby46p5103y1m2hwpixn5p12mbyvb8va71pk4b77qlcy";
+       revision = "2";
+       editedCabalFile = "1sb7ii9mhx77rhviqbmdc5r6wlimkmadxi1pyk7k3imdqcdzgjlp";
        libraryHaskellDepends = [
          array base comonad containers free hashable semigroupoids
          semigroups tagged transformers transformers-compat
···
      }:
      mkDerivation {
        pname = "koji-tool";
-       version = "0.8.3";
-       sha256 = "17xd1755yr2acf6brwbxn3yzbndv982s7jgxbj9dmd7my6v1d9i2";
+       version = "0.8.5";
+       sha256 = "1zkvw8fibav9n8x7dvw7mcns6zc00il5ajcwsvb1ycbb3pqj82ps";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        license = lib.licenses.mit;
      }) {};
 
-  "lens-aeson_1_2" = callPackage
+  "lens-aeson_1_2_1" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, bytestring, lens
      , scientific, text, text-short, unordered-containers, vector
      }:
      mkDerivation {
        pname = "lens-aeson";
-       version = "1.2";
-       sha256 = "1hi0y3bn3xny7w2cjzxn9j5hmfg6l7kbsji5skbj32zfrqlhkkwi";
+       version = "1.2.1";
+       sha256 = "08x0vbkay8d6s24fzy2iria0hl9pmq891cnzm6zl0j9j53z9jw9l";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring lens scientific text text-short
          unordered-containers vector
···
        pname = "lentil";
        version = "1.5.4.0";
        sha256 = "0xfsf7g9r2w30qkp4829w77hsja562jvx4n9i880j9qngi2ms2h1";
+       revision = "1";
+       editedCabalFile = "15dr5jlb6b18j2brxji4k1g12zwvhpjq96nqb27pjkznm59c4x19";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        pname = "lift-generics";
        version = "0.2.1";
        sha256 = "1qkzq8hcb6j15cslv577bmhjcxmljzsrryysdgd7r99kr3q445b4";
-       revision = "1";
-       editedCabalFile = "0i0qxm2fi34bnpnwk5k61yjx72pc9j8jhbx44xk176pw7y2pinxd";
+       revision = "2";
+       editedCabalFile = "1q6lviqfvyis3ss9w6r6j5d35is50r2favj9lkdagcmczw9c4706";
        libraryHaskellDepends = [
          base generic-deriving ghc-prim template-haskell th-compat
        ];
···
        license = lib.licenses.publicDomain;
      }) {};
 
+  "linkcheck" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, conduit, containers
+     , http-client, http-client-tls, http-types, lrucache, monad-logger
+     , mtl, network-uri, optparse-applicative, path, path-io, retry, stm
+     , tagsoup, text, unliftio
+     }:
+     mkDerivation {
+       pname = "linkcheck";
+       version = "0.1.0.0";
+       sha256 = "18wb2naxqhvnvyjjmgbsa0ky98ikgrdhrcra9bxy1vfizhrpwhfn";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base bytestring conduit containers http-client
+         http-client-tls http-types lrucache monad-logger mtl network-uri
+         optparse-applicative path path-io retry stm tagsoup text unliftio
+       ];
+       executableHaskellDepends = [ base ];
+       testHaskellDepends = [ base ];
+       description = "Check for broken links in CI";
+       license = lib.licenses.mit;
+     }) {};
+
   "linkchk" = callPackage
     ({ mkDerivation, base, gtk, haskell98, popenhs, regex-compat, unix
      }:
···
        license = lib.licenses.mit;
      }) {};
 
+  "list-t_1_0_5_2" = callPackage
+    ({ mkDerivation, base, base-prelude, foldl, HTF, logict, mmorph
+     , monad-control, mtl, mtl-prelude, semigroups, transformers
+     , transformers-base
+     }:
+     mkDerivation {
+       pname = "list-t";
+       version = "1.0.5.2";
+       sha256 = "0478iigfrkinhkjyq9zc4xvrbzcfvq46s6k0bj4a2sy8j41jzgww";
+       libraryHaskellDepends = [
+         base foldl logict mmorph monad-control mtl semigroups transformers
+         transformers-base
+       ];
+       testHaskellDepends = [ base-prelude HTF mmorph mtl-prelude ];
+       description = "ListT done right";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "list-t-attoparsec" = callPackage
     ({ mkDerivation, attoparsec, base-prelude, either, hspec, list-t
      , list-t-text, text, transformers
···
        testHaskellDepends = [ base doctest ];
        description = "List monad transformer";
        license = lib.licenses.bsd3;
+       maintainers = with lib.maintainers; [ Gabriel439 ];
+     }) {};
+
+  "list-transformer_1_0_8" = callPackage
+    ({ mkDerivation, base, doctest, mtl }:
+     mkDerivation {
+       pname = "list-transformer";
+       version = "1.0.8";
+       sha256 = "03rqs8hrddlbq4v3pzh42z7lh11z3klpgbmyp85i926shpm5qibh";
+       libraryHaskellDepends = [ base mtl ];
+       testHaskellDepends = [ base doctest ];
+       description = "List monad transformer";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
        maintainers = with lib.maintainers; [ Gabriel439 ];
      }) {};
 
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "logict_0_8_0_0" = callPackage
+    ({ mkDerivation, async, base, mtl, tasty, tasty-hunit }:
+     mkDerivation {
+       pname = "logict";
+       version = "0.8.0.0";
+       sha256 = "0mpv50ifb3x9vfmgi1p9piwcgz8d19x0wdj789wxyhxwjpr6v4py";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base mtl ];
+       testHaskellDepends = [ async base mtl tasty tasty-hunit ];
+       description = "A backtracking logic-programming monad";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "logict-sequence" = callPackage
     ({ mkDerivation, base, logict, mtl, sequence, type-aligned }:
      mkDerivation {
···
      }) {};
 
   "looper" = callPackage
-    ({ mkDerivation, aeson, base, hspec, optparse-applicative, text
+    ({ mkDerivation, aeson, autodocodec, autodocodec-yaml, base
+     , envparse, optparse-applicative, sydtest, sydtest-discover, text
      , time, unliftio
      }:
      mkDerivation {
        pname = "looper";
-       version = "0.0.0.2";
-       sha256 = "0w4aancb0lbfgmk2drnbc1w6bxlbdkhg0zy1qj7xp3kvgc76vqli";
+       version = "0.2.0.1";
+       sha256 = "0nqkqbna1fivf0ziilqrlg38hxpkhll4yv42p8r5g87d7r33jmc2";
        libraryHaskellDepends = [
-         aeson base optparse-applicative text time unliftio
+         aeson autodocodec base envparse optparse-applicative text time
+         unliftio
        ];
        testHaskellDepends = [
-         aeson base hspec optparse-applicative text time unliftio
+         autodocodec-yaml base optparse-applicative sydtest unliftio
        ];
-       license = lib.licenses.bsd3;
+       testToolDepends = [ sydtest-discover ];
+       license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        pname = "lucid";
        version = "2.11.0";
        sha256 = "1m1f13vxn3pwc7wvhx0czzxlx2ws8lzdgxlxd1707cx79jyib5sl";
-       revision = "1";
-       editedCabalFile = "0ai0rxiyni9cxzad3ix50vkxqqmgxfd1vpqzfrmmll1swxpicd8q";
+       revision = "2";
+       editedCabalFile = "01vqjqpng0wkf8955vrdwd499y9h2mlh4jqbnmzp5598iswgq15c";
        libraryHaskellDepends = [
          base blaze-builder bytestring containers hashable mmorph mtl text
          transformers unordered-containers
···
        ];
        description = "Clear to write, read and edit DSL for HTML";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "lucid_2_11_1" = callPackage
+    ({ mkDerivation, base, bifunctors, blaze-builder, bytestring
+     , containers, criterion, deepseq, hashable, hspec, HUnit, mmorph
+     , mtl, parsec, text, transformers
+     }:
+     mkDerivation {
+       pname = "lucid";
+       version = "2.11.1";
+       sha256 = "13krwrvv0w24rnl7pc7qhv18c6030fkxpx7sxkffdm8sr9173xfw";
+       libraryHaskellDepends = [
+         base blaze-builder bytestring containers hashable mmorph mtl text
+         transformers
+       ];
+       testHaskellDepends = [
+         base bifunctors hspec HUnit mtl parsec text
+       ];
+       benchmarkHaskellDepends = [
+         base blaze-builder bytestring criterion deepseq text transformers
+       ];
+       description = "Clear to write, read and edit DSL for HTML";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "lucid-alpine" = callPackage
···
        ];
        description = "DSL for SVG using lucid for HTML";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "lucid2" = callPackage
+    ({ mkDerivation, base, bifunctors, blaze-builder, bytestring
+     , containers, hspec, HUnit, mtl, parsec, text, transformers
+     }:
+     mkDerivation {
+       pname = "lucid2";
+       version = "0.0.20220509";
+       sha256 = "0d38gic3xjqj5in97sbfzjb696011bl47sshzh0377md5j02yc85";
+       libraryHaskellDepends = [
+         base blaze-builder bytestring containers mtl text transformers
+       ];
+       testHaskellDepends = [
+         base bifunctors hspec HUnit mtl parsec text
+       ];
+       description = "Clear to write, read and edit DSL for HTML";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "lucienne" = callPackage
···
      }:
      mkDerivation {
        pname = "matterhorn";
-       version = "50200.15.0";
-       sha256 = "0hn3d1fifzls714a0hsvhbf7wxhg0q60igpr2jcd76yqnzax1mda";
+       version = "50200.16.0";
+       sha256 = "1hjb408dznls8r6k89jv0zvliv259xj2gzl03f4ypwacihmr3qiw";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
      }:
      mkDerivation {
        pname = "mattermost-api";
-       version = "50200.11.0";
-       sha256 = "0knrc00377wx8j4ly8d2nxqswybp3782j7qig6mrzlww6nbd68j7";
+       version = "50200.12.0";
+       sha256 = "12mmpyw1lcmyxh73rgzckww7dd6lxc6m81h2xa9rpd8mxwx0n17n";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "mattermost-api-qc";
-       version = "50200.11.0";
-       sha256 = "0crz0nc8qbsjyq3fllbj50d01axgwfas76bmr6xnz83sic2s1yw1";
+       version = "50200.12.0";
+       sha256 = "00fgr80xanrni835n7wgazq6900f040cwnhbsz99936azx125nx4";
        libraryHaskellDepends = [
          base containers mattermost-api QuickCheck text time
        ];
···
        pname = "megaparsec";
        version = "9.2.0";
        sha256 = "1whjn3n14h2q3ja1v7zllzmj28ai7lqwfbif22c08rl00wpwmwhd";
-       revision = "1";
-       editedCabalFile = "1jv3j59fvykvplj3c653c9rk5wiwg6x0jnljhi2vknzxxmxkjj02";
+       revision = "2";
+       editedCabalFile = "1f82q0v5iaqnl6f3pjgrwin2lg7w5zykgn6vpds08pjgwfg39va1";
        libraryHaskellDepends = [
          base bytestring case-insensitive containers deepseq mtl
          parser-combinators scientific text transformers
···
        license = lib.licenses.bsd2;
      }) {};
 
+  "megaparsec_9_2_1" = callPackage
+    ({ mkDerivation, base, bytestring, case-insensitive, containers
+     , criterion, deepseq, mtl, parser-combinators, scientific, text
+     , transformers, weigh
+     }:
+     mkDerivation {
+       pname = "megaparsec";
+       version = "9.2.1";
+       sha256 = "1zz92mkwyhvvh8c8nc7cfz8cw2g9374na11k2gb6dbm4pabq69vb";
+       libraryHaskellDepends = [
+         base bytestring case-insensitive containers deepseq mtl
+         parser-combinators scientific text transformers
+       ];
+       benchmarkHaskellDepends = [
+         base bytestring containers criterion deepseq text weigh
+       ];
+       description = "Monadic parser combinators";
+       license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "megaparsec-tests" = callPackage
     ({ mkDerivation, base, bytestring, case-insensitive, containers
      , hspec, hspec-discover, hspec-expectations, hspec-megaparsec
···
        license = lib.licenses.bsd2;
      }) {};
 
+  "megaparsec-tests_9_2_1" = callPackage
+    ({ mkDerivation, base, bytestring, case-insensitive, containers
+     , hspec, hspec-discover, hspec-expectations, hspec-megaparsec
+     , megaparsec, mtl, parser-combinators, QuickCheck, scientific, text
+     , transformers
+     }:
+     mkDerivation {
+       pname = "megaparsec-tests";
+       version = "9.2.1";
+       sha256 = "1w9maxfld3by01kl8z0a4v64y2vm5rmsdss6n57mr3j43ng2isr9";
+       libraryHaskellDepends = [
+         base bytestring containers hspec hspec-expectations
+         hspec-megaparsec megaparsec mtl QuickCheck text transformers
+       ];
+       testHaskellDepends = [
+         base bytestring case-insensitive containers hspec
+         hspec-expectations hspec-megaparsec megaparsec mtl
+         parser-combinators QuickCheck scientific text transformers
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Test utilities and the test suite of Megaparsec";
+       license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "meldable-heap" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
        pname = "mfsolve";
        version = "0.3.2.1";
        sha256 = "190dszcnvy5j5bs3n0kya8a9nq0vdhrpgpndjpsxw7x70y3hc9d2";
+       revision = "1";
+       editedCabalFile = "0938ji6l1bx787lxcw6rzjwskm9vxm615cvx7hxpbwp0hbxrj5sa";
        libraryHaskellDepends = [
          base hashable mtl mtl-compat unordered-containers
        ];
···
        pname = "mmorph";
        version = "1.2.0";
        sha256 = "1022d8mm523dihkf85mqsqxpm9rnyicmv91c8rm4csv7xdc80cv1";
-       revision = "1";
-       editedCabalFile = "13j6znh33pnnk8yfxnndqiiwal1w6rs2jigs7fgpa26883ff2788";
+       revision = "2";
+       editedCabalFile = "00jrrmns4w77l06kcpr7798wcbc8abmhlivy12fxajs3x1ycb3hn";
        libraryHaskellDepends = [
          base mtl transformers transformers-compat
        ];
···
        pname = "monad-par";
        version = "0.3.5";
        sha256 = "1a8m99g9x1ivch4vhksk7fdzygbil3d33w8gdqngxbmwdikdafl2";
-       revision = "1";
-       editedCabalFile = "17l7zjykf5iqjmw1pq4iwls7v9x9d3in94iikxabx43q5l2iccsm";
+       revision = "2";
+       editedCabalFile = "1q4npp0vrsjpxk7n7rcf3lgqg1sf2qx628ciiw48al9y9xlznsaz";
        libraryHaskellDepends = [
          abstract-deque abstract-par array base containers deepseq
          monad-par-extras mtl mwc-random parallel
···
        pname = "monoidal-containers";
        version = "0.6.2.0";
        sha256 = "0rnhlm77zrql42z3zsn3ag279q0vrz2idygc0x4p50q3780670p3";
+       revision = "1";
+       editedCabalFile = "07l42gkixdpamqqzdwqfcd62yga5cvhbxz5l0jpgs8kgf6prna4p";
        libraryHaskellDepends = [
          aeson base containers deepseq hashable lens newtype semialign these
          unordered-containers witherable
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "mtl_2_2_2" = callPackage
+  "mtl_2_3" = callPackage
     ({ mkDerivation, base, transformers }:
      mkDerivation {
        pname = "mtl";
-       version = "2.2.2";
-       sha256 = "1xmy5741h8cyy0d91ahvqdz2hykkk20l8br7lg1rccnkis5g80w8";
+       version = "2.3";
+       sha256 = "0krx6bl7xd5n2v9775igv4p8723w6ilshmpljryzfsv4gp74dsy7";
        libraryHaskellDepends = [ base transformers ];
-       description = "Monad classes, using functional dependencies";
+       description = "Monad classes for transformers, using functional dependencies";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
      }) {};
···
      }:
      mkDerivation {
        pname = "niv";
-       version = "0.2.20";
-       sha256 = "1bspaz1a1vy50336d264b6wv7wrfb4a758ghcv6j437lhinjjbf9";
+       version = "0.2.21";
+       sha256 = "1i4n706nrrd0mk34wrjgg597gsd95xslg8aqrhp3ijh4j4h2b8n2";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
      }:
      mkDerivation {
        pname = "opentracing";
-       version = "0.2.1";
-       sha256 = "0p2y996cl5hfw85kdr0majymxccv2d1ka15wbyc2qxgskz3dy9cq";
+       version = "0.2.2";
+       sha256 = "0d2zxq6y943kwpis9nbbj7cn8amy315bxy56mjj54bkg3jm43jn7";
        libraryHaskellDepends = [
          aeson async base base64-bytestring bytestring case-insensitive
          clock containers http-types iproute lens mtl mwc-random network
···
     ({ mkDerivation, base, http-client, lens, mtl, opentracing, text }:
      mkDerivation {
        pname = "opentracing-http-client";
-       version = "0.2.0";
-       sha256 = "19mwl69ggyd7zf1dvx5yjzsq5mlw5l94h989hgwc4ryvp8zqwv4n";
+       version = "0.2.2";
+       sha256 = "03adv17m82imw7bq618zm6x79gq6avvhcz3i0jak4157f3lwdq6b";
        libraryHaskellDepends = [
          base http-client lens mtl opentracing text
        ];
···
      }:
      mkDerivation {
        pname = "opentracing-jaeger";
-       version = "0.2.0";
-       sha256 = "0ffcbmg8qzvyhm7vzk2zkk5czli4ndrp18cc328i7600gzv1gr81";
+       version = "0.2.2";
+       sha256 = "1wy8n4ci3hs2glwahhgzzl6g4dw370ay2dg8bf1af8a27sl3dhjn";
        libraryHaskellDepends = [
          base bytestring exceptions hashable http-client http-types lens mtl
          network opentracing pinch QuickCheck safe-exceptions text
···
     ({ mkDerivation, base, lens, opentracing, text, wai }:
      mkDerivation {
        pname = "opentracing-wai";
-       version = "0.2.0";
-       sha256 = "178xxgg0rw94gld5jlvix6czsvg66q60h06nj2b1x7rnd0pjryc6";
+       version = "0.2.2";
+       sha256 = "1yfbh7pp2rp16xm5bqij9f6m0cm23zrd0jsndkngl1mxjkv6l24i";
        libraryHaskellDepends = [ base lens opentracing text wai ];
        description = "Middleware adding OpenTracing tracing for WAI applications";
        license = lib.licenses.asl20;
···
     ({ mkDerivation, aeson, base, opentracing, text }:
      mkDerivation {
        pname = "opentracing-zipkin-common";
-       version = "0.2.0";
-       sha256 = "0yngiz8135v844wcx28izwhx18iz06di3dl8bm5xqh47ir43wdw6";
+       version = "0.2.2";
+       sha256 = "1vridakdz07yfiyr92byd8kab2zc68izpv1j8dh4a0xnks8910wk";
        libraryHaskellDepends = [ aeson base opentracing text ];
        description = "Zipkin OpenTracing Backend Commons";
        license = lib.licenses.asl20;
···
      }:
      mkDerivation {
        pname = "opentracing-zipkin-v1";
-       version = "0.2.0";
-       sha256 = "15n9m7affy81fr80zw7l54lch7gr6bvhcqpga797x7rvdxqqjv9j";
+       version = "0.2.2";
+       sha256 = "0z263yksbcgyfzsb6fj6id3bdsbhb0b92bfjm0myclj8f703hxbj";
        libraryHaskellDepends = [
          base bytestring exceptions hashable http-client http-types iproute
          lens opentracing opentracing-zipkin-common pinch QuickCheck text
···
      }:
      mkDerivation {
        pname = "opentracing-zipkin-v2";
-       version = "0.2.0";
-       sha256 = "1ykssjhknfyiw02abjpz38zmlw8l03zb8c3y3ic5njmsg23nxfzb";
+       version = "0.2.2";
+       sha256 = "1hqbr4ifabyg6sr40jw9hqi2xq00wqy8srw9q6hj5qxqnvl39110";
        libraryHaskellDepends = [
          aeson base base64-bytestring bytestring exceptions http-client
          http-types lens opentracing opentracing-zipkin-common text
···
        broken = true;
      }) {};
 
-  "parsec_3_1_15_0" = callPackage
+  "parsec_3_1_15_1" = callPackage
     ({ mkDerivation, base, bytestring, mtl, tasty, tasty-hunit, text }:
      mkDerivation {
        pname = "parsec";
-       version = "3.1.15.0";
-       sha256 = "1v8zs8zv1rk16lag2yqaxfwanjpgnh4gxw1vd70py0n04d20z0lq";
+       version = "3.1.15.1";
+       sha256 = "1pcqgxzhzlyaxrkgdixsl0jh7jfcg66kwqqf6va0am8q64ar1r5b";
        libraryHaskellDepends = [ base bytestring mtl text ];
        testHaskellDepends = [ base mtl tasty tasty-hunit ];
        description = "Monadic parser combinators";
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "parsers_0_12_11" = callPackage
+    ({ mkDerivation, attoparsec, base, base-orphans, binary, bytestring
+     , charset, containers, mtl, parsec, QuickCheck
+     , quickcheck-instances, scientific, text, transformers
+     , unordered-containers
+     }:
+     mkDerivation {
+       pname = "parsers";
+       version = "0.12.11";
+       sha256 = "068k7fm0s13z0jkkffc149cqcxnzpk1m066lp4ccdfcb41km1zwi";
+       libraryHaskellDepends = [
+         attoparsec base base-orphans binary charset containers mtl parsec
+         scientific text transformers unordered-containers
+       ];
+       testHaskellDepends = [
+         attoparsec base bytestring parsec QuickCheck quickcheck-instances
+       ];
+       description = "Parsing combinators";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "parsers-megaparsec" = callPackage
     ({ mkDerivation, base, fail, megaparsec, mtl, parsers, semigroups
      , text, transformers
···
        pname = "pattern-arrows";
        version = "0.0.2";
        sha256 = "13q7bj19hd60rnjfc05wxlyck8llxy11z3mns8kxg197wxrdkhkg";
+       revision = "1";
+       editedCabalFile = "0vngc3mlyj52fl6cdrbwngpcyzp0gahq2h1sy1ysga62mv76wpc9";
        libraryHaskellDepends = [ base mtl ];
        description = "Arrows for Pretty Printing";
        license = lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "pinboard";
-       version = "0.10.2.0";
-       sha256 = "12hwfgqkn7sym9hig0b0afnzf0an6wcwdw9bc166y3539r3v13ck";
+       version = "0.10.3.0";
+       sha256 = "0j0isf2539b3fj393766wlrpgdpi39cqjqzw5jxihn7b67cvblyp";
        libraryHaskellDepends = [
          aeson base bytestring containers http-client http-client-tls
          http-types monad-logger mtl network profunctors random text time
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "pointed_5_0_4" = callPackage
+    ({ mkDerivation, base, comonad, containers, data-default-class
+     , hashable, kan-extensions, semigroupoids, semigroups, stm, tagged
+     , transformers, transformers-compat, unordered-containers
+     }:
+     mkDerivation {
+       pname = "pointed";
+       version = "5.0.4";
+       sha256 = "1mv06x2hscs220w4acm5jwg96vi4faky6ir9hnljfry3n2r2xix3";
+       libraryHaskellDepends = [
+         base comonad containers data-default-class hashable kan-extensions
+         semigroupoids semigroups stm tagged transformers
+         transformers-compat unordered-containers
+       ];
+       description = "Pointed and copointed data";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "pointedalternative" = callPackage
     ({ mkDerivation, base, mtl, semigroups, transformers }:
      mkDerivation {
···
     ({ mkDerivation, base, requirements }:
      mkDerivation {
        pname = "poly-rec";
-       version = "0.6.0.0";
-       sha256 = "1csi81i0j3hk2gsc3c0rx939i67b0mj2pi064giw20yspqqjrp27";
+       version = "0.7.0.0";
+       sha256 = "0ayaz87l2rgpm4ddc7bidss042xhfcwa3sk7685ypssqvp02k5r0";
        libraryHaskellDepends = [ base requirements ];
        description = "Polykinded extensible records";
        license = lib.licenses.gpl3Only;
···
      }:
      mkDerivation {
        pname = "popkey";
-       version = "0.1.0.1";
-       sha256 = "1nlbd54q7npxm9hk4f289md6rch0sqnl236iimwsrwllpq6rbxbz";
-       revision = "2";
-       editedCabalFile = "1wpbwyya9fcdiyqs6lrbcxw7d64vn12kc7n63h2wjxrizjhfs6n6";
+       version = "0.1.0.2";
+       sha256 = "0ibk4qwcizsqvyvb8lgad5c0szgw7571bi2c54b5r3rrm7vzpx05";
        libraryHaskellDepends = [
          base bitvec bytestring containers hw-bits hw-prim hw-rankselect
          hw-rankselect-base store text vector
···
      }:
      mkDerivation {
        pname = "prettyprinter-combinators";
-       version = "0.1.0.1";
-       sha256 = "0plnan8dvxl1y9h5vazszhdrf47862jqbhyx1ibldak19bibp367";
+       version = "0.1.1";
+       sha256 = "1m6338w6cd7fsib00zs8dk16b4mxfa1vswg5bmkzafas1db6qbcg";
        libraryHaskellDepends = [
          base bimap bytestring containers dlist pretty-show prettyprinter
          syb template-haskell text unordered-containers vector
···
     ({ mkDerivation, base, mtl, template-haskell, th-compat }:
      mkDerivation {
        pname = "quotet";
-       version = "0.0.1.0";
-       sha256 = "1ajxvhh2zl99ddvmvicsjq775l0k3d8lh433v1z6z6i7zra5hg4g";
+       version = "0.0.1.1";
+       sha256 = "16fwbf9q2ivpi3j7y26lsbqvwwk7vidjn6q9iz4x6sq8adhy45rz";
        libraryHaskellDepends = [ base mtl template-haskell th-compat ];
        description = "Monad transformer for Quote from template-haskell";
        license = lib.licenses.cc0;
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "random_1_2_1_1" = callPackage
+    ({ mkDerivation, base, bytestring, containers, deepseq, doctest
+     , mtl, primitive, rdtsc, smallcheck, split, splitmix, stm, tasty
+     , tasty-bench, tasty-hunit, tasty-inspection-testing
+     , tasty-smallcheck, time, transformers
+     }:
+     mkDerivation {
+       pname = "random";
+       version = "1.2.1.1";
+       sha256 = "0xlv1k4sj87akwvj54kq4nrfkzi6qcz1941bf78pnkbaxpvp44iy";
+       libraryHaskellDepends = [ base bytestring deepseq mtl splitmix ];
+       testHaskellDepends = [
+         base bytestring containers doctest smallcheck stm tasty tasty-hunit
+         tasty-inspection-testing tasty-smallcheck transformers
+       ];
+       benchmarkHaskellDepends = [
+         base mtl primitive rdtsc split splitmix tasty-bench time
+       ];
+       description = "Pseudo-random number generation";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "random-access-file" = callPackage
     ({ mkDerivation, base, bytestring, concurrent-extra, containers
      , criterion, directory, lrucaching, mwc-random, random, stm, unix
···
        broken = true;
      }) {};
 
-  "rattletrap_11_2_6" = callPackage
+  "rattletrap_11_2_7" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, array, base, bytestring
      , containers, filepath, http-client, http-client-tls, text
      }:
      mkDerivation {
        pname = "rattletrap";
-       version = "11.2.6";
-       sha256 = "1y8g39vjnn3lywhg389ql0hqrzpgcj0j76wzhrzsh7ymj87vvirk";
+       version = "11.2.7";
+       sha256 = "19vgqkyxvv9y3yyb42p075nmdm7338f9ln6g0d7sgy9w9zd2vy0d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "requirements";
-       version = "0.6.0.0";
-       sha256 = "1s0s3p0dy07222ks83w3spfw9df33q5lggqv3dw4m9hd5x16a6zi";
+       version = "0.7.0.0";
+       sha256 = "030vwfasxjdgdadcf5i68i3dc436dj6gi3ql4k8qh09yf8q1mm63";
        libraryHaskellDepends = [ base ];
        description = "Abstraction to manage user defined Type Errors";
        license = lib.licenses.gpl3Only;
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "resourcet_1_2_5" = callPackage
+    ({ mkDerivation, base, containers, exceptions, hspec, mtl
+     , primitive, transformers, unliftio-core
+     }:
+     mkDerivation {
+       pname = "resourcet";
+       version = "1.2.5";
+       sha256 = "0bj98srdlz2yx3nx030m0nzv6yyz1ry50v6bwdff5a6xi256jz7n";
+       libraryHaskellDepends = [
+         base containers exceptions mtl primitive transformers unliftio-core
+       ];
+       testHaskellDepends = [ base exceptions hspec transformers ];
+       description = "Deterministic allocation and freeing of scarce resources";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "resourcet-pool" = callPackage
     ({ mkDerivation, base, resource-pool, resourcet }:
      mkDerivation {
···
        testHaskellDepends = [ base filepath hspec ];
        description = "RPM package name-version-release data types";
        license = lib.licenses.gpl2Only;
+     }) {};
+
+  "rpm-nvr_0_1_2" = callPackage
+    ({ mkDerivation, base, extra, filepath, hspec }:
+     mkDerivation {
+       pname = "rpm-nvr";
+       version = "0.1.2";
+       sha256 = "0g4fpay6rry9mnvy6mk793my1fkvpdxx40b5hn6gjr0vr1mvg2yp";
+       libraryHaskellDepends = [ base extra filepath ];
+       testHaskellDepends = [ base filepath hspec ];
+       description = "RPM package name-version-release data types";
+       license = lib.licenses.gpl2Only;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "rpmbuild-order" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "seocheck" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, case-insensitive, conduit
+     , containers, html-conduit, http-client, http-client-tls
+     , http-types, monad-logger, network-uri, optparse-applicative, path
+     , path-io, pretty-show, rainbow, stm, text, unliftio, validity
+     , xml-conduit
+     }:
+     mkDerivation {
+       pname = "seocheck";
+       version = "0.1.0.0";
+       sha256 = "065hs3y4mkl4l49qa6n7i441aax8y5zyxcpf0zpl9rz6w6llc3g7";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base bytestring case-insensitive conduit containers
+         html-conduit http-client http-client-tls http-types monad-logger
+         network-uri optparse-applicative path path-io pretty-show rainbow
+         stm text unliftio validity xml-conduit
+       ];
+       executableHaskellDepends = [ base ];
+       testHaskellDepends = [ base ];
+       description = "Check for common SEO mistakes on CI";
+       license = lib.licenses.mit;
+     }) {};
+
   "seonbi" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, bytestring
      , bytestring-trie, Cabal, case-insensitive, cases, cassava, cmark
···
      }:
      mkDerivation {
        pname = "sketch-frp-copilot";
-       version = "1.0.1";
-       sha256 = "0hm4bvlj7g9j6k2mc0s426s17nj4w1jpi0v052i2c7b0g7ahdxj8";
+       version = "1.0.2";
+       sha256 = "10r4j3plg70vawczk9fr388ljjqnjn08apv8s9am754g59fnwrd3";
        libraryHaskellDepends = [
          base containers copilot copilot-c99 copilot-language mtl
          optparse-applicative
        ];
-       description = "FRP sketch programming with Copilot";
+       description = "Sketch programming with Copilot";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
      }) {};
···
        license = lib.licenses.isc;
      }) {};
 
+  "splint_1_0_1_5" = callPackage
+    ({ mkDerivation, base, containers, ghc, hlint, stm }:
+     mkDerivation {
+       pname = "splint";
+       version = "1.0.1.5";
+       sha256 = "1mvkd5jcrivc57g6dw6iwss6682q7wyi6zb2k3nd3vywm1a0c8ql";
+       libraryHaskellDepends = [ base containers ghc hlint stm ];
+       description = "HLint as a GHC source plugin";
+       license = lib.licenses.isc;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "split" = callPackage
     ({ mkDerivation, base, QuickCheck }:
      mkDerivation {
···
        license = lib.licenses.mit;
      }) {};
 
+  "strict-list_0_1_7" = callPackage
+    ({ mkDerivation, base, deepseq, hashable, QuickCheck
+     , quickcheck-instances, rerebase, semigroupoids, tasty, tasty-hunit
+     , tasty-quickcheck
+     }:
+     mkDerivation {
+       pname = "strict-list";
+       version = "0.1.7";
+       sha256 = "0dhfnb5zvwnnbsy0c9lyymfq223zw9jgwv3wn1rq5xp1np68mkbh";
+       libraryHaskellDepends = [ base deepseq hashable semigroupoids ];
+       testHaskellDepends = [
+         QuickCheck quickcheck-instances rerebase tasty tasty-hunit
+         tasty-quickcheck
+       ];
+       description = "Strict linked list";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "strict-optics" = callPackage
     ({ mkDerivation, base, optics-core, strict }:
      mkDerivation {
···
      }) {};
 
   "svgsym" = callPackage
-    ({ mkDerivation, base, bytestring, containers, directory, filepath
-     , filepattern, optparse-applicative, regex-tdfa, xml
+    ({ mkDerivation, array, base, bytestring, containers, directory
+     , filepath, filepattern, optparse-applicative, regex-base
+     , regex-tdfa, xml
      }:
      mkDerivation {
        pname = "svgsym";
-       version = "0.1.0.0";
-       sha256 = "0wiy03v3sdw8mzn3kibgjzjp6m50nnc31nld9zvr86fcrsl7bdgl";
+       version = "0.1.1.0";
+       sha256 = "014vand8zag2b9ll2g6xn0s91bav7x2v2l4xdvidc0rs6m8s5fx5";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
-         base bytestring containers directory filepath filepattern
-         optparse-applicative regex-tdfa xml
+         array base bytestring containers directory filepath filepattern
+         optparse-applicative regex-base regex-tdfa xml
        ];
        description = "A tool to prune unused symbols from icon SVG files";
        license = lib.licenses.gpl3Plus;
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "tagged-transformer_0_8_2" = callPackage
+    ({ mkDerivation, base, comonad, contravariant, distributive
+     , exceptions, mtl, reflection, semigroupoids, tagged
+     }:
+     mkDerivation {
+       pname = "tagged-transformer";
+       version = "0.8.2";
+       sha256 = "10wlwqxzm1xdyzxl6xyfsrb40zmvh7g0y3w0a69b1lw2rp6v4vyy";
+       libraryHaskellDepends = [
+         base comonad contravariant distributive exceptions mtl reflection
+         semigroupoids tagged
+       ];
+       description = "Monad transformer carrying an extra phantom type tag";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "tagging" = callPackage
     ({ mkDerivation, base, bytestring, pcre-light }:
      mkDerivation {
···
        pname = "tardis";
        version = "0.4.3.0";
        sha256 = "1ffmpdvnmr1s3rh3kpqqscsbz2rq4s7k8nfc93zw9m4mchg37waw";
+       revision = "1";
+       editedCabalFile = "1krk42qgdg10s6pxp805zv7z4c7mlhbhk15l07v9i750im1k73v3";
        libraryHaskellDepends = [ base mmorph mtl ];
        testHaskellDepends = [ base ];
        description = "Bidirectional state monad transformer";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "tardis_0_4_4_0" = callPackage
+    ({ mkDerivation, base, mmorph, mtl }:
+     mkDerivation {
+       pname = "tardis";
+       version = "0.4.4.0";
+       sha256 = "0frm9kffdsia22rwyr8295n9xwhca1d6w04yz4l4cfjav6bgczfs";
+       libraryHaskellDepends = [ base mmorph mtl ];
+       testHaskellDepends = [ base ];
+       description = "Bidirectional state monad transformer";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "target" = callPackage
···
        pname = "tasty";
        version = "1.4.2.1";
        sha256 = "0ki3gdzfsqvk9mwzzvgj18ck1sbkwac06gcc128wpwh9g8c4bzqr";
-       revision = "1";
-       editedCabalFile = "1fm1yx9dqikspw3a6ygnwj61vx1zwgjxm84zpkydbhcf6hgab5sg";
+       revision = "2";
+       editedCabalFile = "134sp1sjyx5hh1vwraxdfs98yx9gf19zp9kpfzqvvajfgy9i37jv";
        libraryHaskellDepends = [
          ansi-terminal base clock containers mtl optparse-applicative stm
          tagged unbounded-delays unix wcwidth
···
        license = lib.licenses.mit;
      }) {};
 
+  "tasty_1_4_2_2" = callPackage
+    ({ mkDerivation, ansi-terminal, base, clock, containers, mtl
+     , optparse-applicative, stm, tagged, unbounded-delays, unix
+     , wcwidth
+     }:
+     mkDerivation {
+       pname = "tasty";
+       version = "1.4.2.2";
+       sha256 = "1qqzrvmfnh2s0b3356wil1flzvvyrh5bvx3v65k9807wp9r5pxrq";
+       libraryHaskellDepends = [
+         ansi-terminal base clock containers mtl optparse-applicative stm
+         tagged unbounded-delays unix wcwidth
+       ];
+       description = "Modern and extensible testing framework";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "tasty-ant-xml" = callPackage
     ({ mkDerivation, base, containers, directory, filepath
      , generic-deriving, ghc-prim, mtl, stm, tagged, tasty, transformers
···
        pname = "tasty-silver";
        version = "3.3.1";
        sha256 = "1pd83mzx0iv3f396m09rxmgcpcfaya0a9818dl3h4vgw0hnqkmav";
+       revision = "1";
+       editedCabalFile = "1gsjspgy9li9lsk7sqikm44mr3cjsxkrhvql6rabk5x9nb5ajrnr";
        libraryHaskellDepends = [
          ansi-terminal async base bytestring containers deepseq directory
          filepath mtl optparse-applicative process process-extras regex-tdfa
···
        license = lib.licenses.mit;
      }) {};
 
+  "tasty-silver_3_3_1_1" = callPackage
+    ({ mkDerivation, ansi-terminal, async, base, bytestring, containers
+     , deepseq, directory, filepath, mtl, optparse-applicative, process
+     , process-extras, regex-tdfa, silently, stm, tagged, tasty
+     , tasty-hunit, temporary, text, transformers
+     }:
+     mkDerivation {
+       pname = "tasty-silver";
+       version = "3.3.1.1";
+       sha256 = "13j0zs0ciijv9q2nncna1gbgsgw2g7xc228hzmqic1750n3ybz9m";
+       libraryHaskellDepends = [
+         ansi-terminal async base bytestring containers deepseq directory
+         filepath mtl optparse-applicative process process-extras regex-tdfa
+         silently stm tagged tasty temporary text transformers
+       ];
+       testHaskellDepends = [
+         base directory filepath process silently tasty tasty-hunit
+         temporary transformers
+       ];
+       description = "A fancy test runner, including support for golden tests";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "tasty-smallcheck" = callPackage
     ({ mkDerivation, base, optparse-applicative, smallcheck, tagged
      , tasty
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "telegram-bot-simple_0_5" = callPackage
+  "telegram-bot-simple_0_5_1" = 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
···
      }:
      mkDerivation {
        pname = "telegram-bot-simple";
-       version = "0.5";
-       sha256 = "0mzzq7lfl56h1i9dr617h5vcv47j2nsf77pkq18s8wk5zrc67r2w";
-       revision = "1";
-       editedCabalFile = "0nz2g3jfb3l66ixrxlz257pmg2qbg7l6wsi0q38iv8fl4483md2s";
+       version = "0.5.1";
+       sha256 = "0vkvnxfa9lmp6j2wc2s3yxvq6ilwjbb1xnrwk5kysrlsklvc86bs";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "th-compat";
        version = "0.1.3";
        sha256 = "1il1hs5yjfkb417c224pw1vrh4anyprasfwmjbd4fkviyv55jl3b";
+       revision = "1";
+       editedCabalFile = "1ax5yz41sfy9klif7j3ihahvdi08alb56l4y9nr45vbc9kvijn7n";
        libraryHaskellDepends = [ base template-haskell ];
        testHaskellDepends = [
          base base-compat hspec mtl template-haskell
···
        maintainers = with lib.maintainers; [ Gabriel439 ];
      }) {};
 
+  "turtle_1_5_25" = callPackage
+    ({ mkDerivation, ansi-wl-pprint, async, base, bytestring, clock
+     , containers, directory, doctest, exceptions, foldl, hostname
+     , managed, optional-args, optparse-applicative, process, stm
+     , streaming-commons, system-fileio, system-filepath, tasty-bench
+     , temporary, text, time, transformers, unix, unix-compat
+     }:
+     mkDerivation {
+       pname = "turtle";
+       version = "1.5.25";
+       sha256 = "1hh2rbwk3m4iklk67f1l1a8shsng9qzs9132j6lpag7cgqkrmqdk";
+       libraryHaskellDepends = [
+         ansi-wl-pprint async base bytestring clock containers directory
+         exceptions foldl hostname managed optional-args
+         optparse-applicative process stm streaming-commons system-fileio
+         system-filepath temporary text time transformers unix unix-compat
+       ];
+       testHaskellDepends = [ base doctest system-filepath temporary ];
+       benchmarkHaskellDepends = [ base tasty-bench text ];
+       description = "Shell programming, Haskell-style";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ Gabriel439 ];
+     }) {};
+
   "turtle-options" = callPackage
     ({ mkDerivation, base, HUnit, optional-args, parsec, text, turtle
      }:
···
        pname = "typed-process";
        version = "0.2.8.0";
        sha256 = "1af0g34sws7fppziv7firr9r2wrnly4y6sr9nyqa8bvbbmadly45";
+       revision = "1";
+       editedCabalFile = "1m017nqbaqishii32gwhxa1849h0qnn06w7k1rn8c9d8w71m4vqm";
        libraryHaskellDepends = [
          async base bytestring process stm transformers unliftio-core
        ];
···
        license = lib.licenses.mit;
      }) {};
 
-  "wai-extra_3_1_11" = callPackage
+  "wai-extra_3_1_12" = callPackage
     ({ mkDerivation, aeson, ansi-terminal, base, base64-bytestring
      , bytestring, call-stack, case-insensitive, containers, cookie
      , data-default-class, directory, fast-logger, hspec, http-types
···
      }:
      mkDerivation {
        pname = "wai-extra";
-       version = "3.1.11";
-       sha256 = "0z9hl0a8vh6049m4pvnqjm7fibp60qc3jrcz0vpqbscncr59l7h5";
+       version = "3.1.12";
+       sha256 = "1i6gh02sprdbkwg92pzm6rwxcm3k8286vazziwjq05xln3vckd1n";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "web-inv-route";
-       version = "0.1.3.1";
-       sha256 = "1l10rgrhcqld8znw6akxjlsm1h8z76l9yxa4yik11lk2l0g9anb2";
+       version = "0.1.3.2";
+       sha256 = "0gmbj6c6c8gqz9xfxv0d4134d7c2wfla3zg3bgqvvzsqjjmrg81v";
        libraryHaskellDepends = [
          base bytestring case-insensitive containers happstack-server
          hashable http-types invertible network-uri snap-core text
···
        ];
        description = "values that witness types";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "witness_0_6" = callPackage
+    ({ mkDerivation, base, constraints, countable }:
+     mkDerivation {
+       pname = "witness";
+       version = "0.6";
+       sha256 = "1y8scf6a061s8gnx38sfwn88ramakjr0h54qwlwcjrjpf0y6024l";
+       libraryHaskellDepends = [ base constraints countable ];
+       description = "values that witness types";
+       license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "witty" = callPackage
···
      }:
      mkDerivation {
        pname = "zephyr-copilot";
-       version = "1.0.1";
-       sha256 = "0d489krxzj30gl8j8idwfi10k82w0p4kr30f0h78qvl9ikzinhvk";
+       version = "1.0.2";
+       sha256 = "01dvqzh97bw423kwhmgdr8l913p4miq69frv3nkjs889ps16faz0";
        libraryHaskellDepends = [
          base containers copilot copilot-c99 copilot-language directory
          filepath mtl optparse-applicative sketch-frp-copilot temporary

pkgs/development/libraries/boolstuff/default.nix

···
 { lib, stdenv, fetchurl, pkg-config }:
 stdenv.mkDerivation rec {
   pname = "boolstuff";
-  version = "0.1.16";
+  version = "0.1.17";
 
   src = fetchurl {
-    url = "https://perso.b2b2c.ca/~sarrazip/dev/${pname}-${version}.tar.gz";
-    sha256 = "10qynbyw723gz2vrvn4xk2var172kvhlz3l3l80qbdsfb3d12wn0";
+    url = "http://perso.b2b2c.ca/~sarrazip/dev/${pname}-${version}.tar.gz";
+    hash = "sha256-WPFUoTUofigPxTRo6vUbVTEVWMeEPDWszCA05toOX0I=";
   };
 
   nativeBuildInputs = [ pkg-config ];

pkgs/development/libraries/ctl/default.nix

···
-{ lib, stdenv, fetchFromGitHub, fetchpatch, cmake, pkg-config, ilmbase, libtiff, openexr }:
-
-stdenv.mkDerivation rec {
-  pname = "ctl";
-  version = "1.5.2";
-
-  src = fetchFromGitHub {
-    owner = "ampas";
-    repo = pname;
-    rev = "${pname}-${version}";
-    sha256 = "0a698rd1cmixh3mk4r1xa6rjli8b8b7dbx89pb43xkgqxy67glwx";
-  };
-
-  patches = [
-    (fetchpatch {
-      name = "ctl-1.5.2-ilm_230.patch";
-      url = "https://src.fedoraproject.org/rpms/CTL/raw/9d7c15a91bccdc0a9485d463bf2789be72e6b17d/f/ctl-1.5.2-ilm_230.patch";
-      sha256 = "0mdx7llwrm0q8ai53zhyxi40i9h5s339dbkqpqv30yzi2xpnfj3d";
-    })
-  ];
-
-  postPatch = ''
-    # Fix include guard name
-    substituteInPlace lib/dpx/dpx_raw.hh \
-        --replace CRL_DPX_RAW_INTERNAL_INCLUDE CTL_DPX_RAW_INTERNAL_INCLUDE
-
-    # Fix undefined symbols (link with Imath)
-    substituteInPlace lib/IlmCtlMath/CMakeLists.txt \
-        --replace "( IlmCtlMath IlmCtl )" "( IlmCtlMath IlmCtl Imath)"
-  '';
-
-  nativeBuildInputs = [ cmake pkg-config ];
-  buildInputs = [ libtiff ilmbase openexr ];
-
-  meta = with lib; {
-    description = "Color Transformation Language";
-    homepage = "https://github.com/ampas/CTL";
-    license = "A.M.P.A.S"; # BSD-derivative, free but GPL incompatible
-    platforms = platforms.all;
-  };
-}

pkgs/development/libraries/v8/default.nix

···
     maintainers = with maintainers; [ cstrahan proglodyte matthewbauer ];
     platforms = platforms.unix;
     license = licenses.bsd3;
+    # Fails to build on Darwin, see https://github.com/NixOS/nixpkgs/issues/158076
+    broken = stdenv.isDarwin;
   };
 }

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

···
 { lib
 , fetchhg
 , stdenv
-, python3
+, python
 }:
 
 stdenv.mkDerivation rec {
···
   dontBuild = true;
 
   installPhase = ''
-    mkdir -p $out/lib/${python3.libPrefix}/site-packages/hgext3rd/
+    mkdir -p $out/lib/${python.libPrefix}/site-packages/hgext3rd/
     install -D $src/commitsigs.py \
-               $out/lib/${python3.libPrefix}/site-packages/hgext3rd/
+               $out/lib/${python.libPrefix}/site-packages/hgext3rd/
   '';
 
   meta = with lib; {

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

···
 , fetchFromGitHub
 , buildPythonPackage
 , wxPython_4_0
-, python3
+, python
 }:
 
 buildPythonPackage rec {
···
   checkPhase = ''
     runHook preCheck
     for i in examples/*; do
-      ${python3.interpreter} $i
+      ${python.interpreter} $i
     done
     runHook postCheck
   '';

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

···
-{ lib, buildPythonPackage, fetchFromGitHub, python3, cmake
+{ lib, buildPythonPackage, fetchFromGitHub, python, cmake
 , libnest2d, sip_4, clipper }:
 
 buildPythonPackage rec {
···
   CLIPPER_PATH = "${clipper.out}";
 
   postPatch = ''
-     sed -i 's#''${Python3_SITEARCH}#${placeholder "out"}/${python3.sitePackages}#' cmake/SIPMacros.cmake
+     sed -i 's#''${Python3_SITEARCH}#${placeholder "out"}/${python.sitePackages}#' cmake/SIPMacros.cmake
    '';
 
   meta = with lib; {

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

···
-{ lib, buildPythonPackage, fetchPypi, isPy3k, python3, xvfb-run
+{ lib, buildPythonPackage, fetchPypi, isPy3k, python, xvfb-run
 , wrapGAppsHook, gobject-introspection, pygobject3, graphviz, gtk3, numpy }:
 
 buildPythonPackage rec {
···
   '';
 
   checkPhase = ''
-    xvfb-run -s '-screen 0 800x600x24' ${python3.interpreter} nix_run_setup test
+    xvfb-run -s '-screen 0 800x600x24' ${python.interpreter} nix_run_setup test
   '';
 
   # https://github.com/NixOS/nixpkgs/pull/107872#issuecomment-752175866

pkgs/games/blightmud/default.nix

···
     license = licenses.gpl3Plus;
     maintainers = with maintainers; [ cpu ];
     platforms = platforms.linux;
+    # See https://github.com/NixOS/nixpkgs/pull/160120
+    broken = withTTS;
   };
 }

pkgs/servers/http/trafficserver/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "trafficserver";
-  version = "9.1.1";
+  version = "9.1.2";
 
   src = fetchzip {
     url = "mirror://apache/trafficserver/trafficserver-${version}.tar.bz2";
-    sha256 = "sha256-oicRqKFE6hOpcNG9o3BmrMujtEzi4hrPhBWaljOW+VI=";
+    sha256 = "sha256-eRpyTdwwO5EzrVpt9fF6VEYGZjHb905nQJd065wY5RU=";
   };
 
   patches = [
···
       sha256 = "0z1ikgpp00rzrrcqh97931586yn9wbksgai9xlkcjd5cg8gq0150";
     })
 
-    # Fix build against ncurses-6.3:
-    #  https://github.com/apache/trafficserver/pull/8437
-    (fetchpatch {
-      url = "https://github.com/apache/trafficserver/commit/66c86c6b082903a92b9db33c60e3ed947e77d540.patch";
-      sha256 = "1hgpp80xnnjr4k5i6gcllrb7dw4q4xcdrkwxpc1xk2np5cbyxd16";
-    })
+    ./fix-catch2-version-incompatibility.patch
   ];
 
   # NOTE: The upstream README indicates that flex is needed for some features,
···
 
     substituteInPlace configure --replace '/usr/bin/file' '${file}/bin/file'
 
+    # TODO: remove after the following change has been released
+    # https://github.com/apache/trafficserver/pull/8683
     cp ${catch2}/include/catch2/catch.hpp tests/include/catch.hpp
   '' + lib.optionalString stdenv.isLinux ''
     substituteInPlace configure \

pkgs/servers/http/trafficserver/fix-catch2-version-incompatibility.patch

···
+diff --git a/src/tscore/unit_tests/test_History.cc b/src/tscore/unit_tests/test_History.cc
+index 3e699139da0..7505f10aa4c 100644
+--- a/src/tscore/unit_tests/test_History.cc
++++ b/src/tscore/unit_tests/test_History.cc
+@@ -59,10 +59,10 @@ TEST_CASE("History", "[libts][History]")
+   REQUIRE(history[2].reentrancy == static_cast<short>(NO_REENTRANT));
+ 
+   history[0].location.str(buf, sizeof(buf));
+-  REQUIRE(string_view{buf} == "test_History.cc:48 (____C_A_T_C_H____T_E_S_T____0)");
++  REQUIRE(string_view{buf} == "test_History.cc:48 (C_A_T_C_H_T_E_S_T_0)");
+ 
+   history[1].location.str(buf, sizeof(buf));
+-  REQUIRE(string_view{buf} == "test_History.cc:49 (____C_A_T_C_H____T_E_S_T____0)");
++  REQUIRE(string_view{buf} == "test_History.cc:49 (C_A_T_C_H_T_E_S_T_0)");
+ 
+   ts::LocalBufferWriter<128> w;
+   SM<HISTORY_DEFAULT_SIZE> *sm = new SM<HISTORY_DEFAULT_SIZE>;
+@@ -71,10 +71,10 @@ TEST_CASE("History", "[libts][History]")
+   SM_REMEMBER(sm, 3, NO_REENTRANT);
+ 
+   w.print("{}", sm->history[0].location);
+-  REQUIRE(w.view() == "test_History.cc:69 (____C_A_T_C_H____T_E_S_T____0)");
++  REQUIRE(w.view() == "test_History.cc:69 (C_A_T_C_H_T_E_S_T_0)");
+ 
+   w.reset().print("{}", sm->history[1].location);
+-  REQUIRE(w.view() == "test_History.cc:70 (____C_A_T_C_H____T_E_S_T____0)");
++  REQUIRE(w.view() == "test_History.cc:70 (C_A_T_C_H_T_E_S_T_0)");
+ 
+   REQUIRE(sm->history[0].event == 1);
+   REQUIRE(sm->history[0].reentrancy == 1);
+@@ -106,10 +106,10 @@ TEST_CASE("History", "[libts][History]")
+   REQUIRE(sm2->history.overflowed() == true);
+ 
+   w.reset().print("{}", sm2->history[0].location);
+-  REQUIRE(w.view() == "test_History.cc:103 (____C_A_T_C_H____T_E_S_T____0)");
++  REQUIRE(w.view() == "test_History.cc:103 (C_A_T_C_H_T_E_S_T_0)");
+ 
+   w.reset().print("{}", sm2->history[1].location);
+-  REQUIRE(w.view() == "test_History.cc:98 (____C_A_T_C_H____T_E_S_T____0)");
++  REQUIRE(w.view() == "test_History.cc:98 (C_A_T_C_H_T_E_S_T_0)");
+ 
+   sm2->history.clear();
+   REQUIRE(sm2->history.size() == 0);

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

···
 
 stdenv.mkDerivation rec {
   pname = "plpgsql_check";
-  version = "2.1.3";
+  version = "2.1.5";
 
   src = fetchFromGitHub {
     owner = "okbob";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-hVbx1eUrVQ35UzcokoqYCi6RFI5Dn7t9XH8q9VbyDbQ=";
+    sha256 = "sha256-DYdZuHraecQZ33xHX6ugiUJVfFVAayD2spIQt2Qqa5U=";
   };
 
   buildInputs = [ postgresql ];

pkgs/tools/misc/clickclack/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "clickclack";
-  version = "0.2.2";
+  version = "0.2.3";
 
   src = fetchFromSourcehut {
     owner = "~proycon";
     repo = "clickclack";
     rev = version;
-    hash = "sha256-ABVfJRSzbQ6jIpON2g2wS52QsyNQVfW6+AhTvjkkf6s=";
+    hash = "sha256-YmlbGEmZgT/30c+mWQzdz4rKc69d75zhoNUA5FdxdMc=";
   };
 
   buildInputs = [

pkgs/tools/security/dirmngr/default.nix

···
-{ lib, stdenv, fetchurl, libgpg-error, libgcrypt, libassuan, libksba, pth, openldap
-, libiconv}:
-
-stdenv.mkDerivation rec {
-  pname = "dirmngr";
-  version = "1.1.1";
-  src = fetchurl {
-    url = "mirror://gnupg/dirmngr/dirmngr-${version}.tar.bz2";
-    sha256 = "1zz6m87ca55nq5f59hzm6qs48d37h93il881y7d0rf2d6660na6j";
-  };
-  buildInputs = [ libgpg-error libgcrypt libassuan libksba
-                  pth openldap libiconv ];
-
-  meta = {
-    platforms = lib.platforms.unix;
-    license = lib.licenses.gpl2Plus;
-  };
-}

pkgs/tools/typesetting/sile/default.nix

···
   luaEnv = lua.withPackages(ps: with ps; [
     cassowary
     cosmo
-    compat53
     linenoise
     lpeg
     lua-zlib
···
     penlight
     stdlib
     vstruct
+  ] ++ lib.optionals (lib.versionOlder lua.luaversion "5.2") [
+    bit32
+  ] ++ lib.optionals (lib.versionOlder lua.luaversion "5.3") [
+    compat53
   ]);
 in
 

pkgs/top-level/aliases.nix

···
   avxsynth = throw "avxsynth was removed because it was broken"; # Added 2021-05-18
   awesome-4-0 = awesome; # Added 2022-05-05
   aws-okta = throw "aws-okta is on indefinite hiatus. See https://github.com/segmentio/aws-okta/issues/278"; # Added 2022-04-05;
+  axoloti = throw "axoloti has been removed: abandoned by upstream"; # Added 2022-05-13
   azureus = throw "azureus is now known as vuze and the version in nixpkgs was really outdated"; # Added 2021-08-02
 
   ### B ###
···
   cpuminer-multi = throw "cpuminer-multi has been removed: deleted by upstream"; # Added 2022-01-07
   crafty = throw "crafty has been removed: deleted by upstream"; # Added 2022-01-07
   cryptol = throw "cryptol was removed due to prolonged broken build"; # Added 2020-08-21
+  ctl = throw "ctl has been removed: abandoned by upstream"; # Added 2022-05-13
 
   # CUDA Toolkit
   cudatoolkit_6 = throw "cudatoolkit_6 has been removed in favor of newer versions"; # Added 2021-02-14
···
   demjson = with python3Packages; toPythonApplication demjson; # Added 2022-01-18
   desktop_file_utils = throw "'desktop_file_utils' has been renamed to/replaced by 'desktop-file-utils'"; # Converted to throw 2022-02-22
   devicemapper = throw "'devicemapper' has been renamed to/replaced by 'lvm2'"; # Converted to throw 2022-02-22
+  dfu-util-axoloti = throw "dfu-util-axoloti has been removed: abandoned by upstream"; # Added 2022-05-13
   dhall-text = throw "'dhall-text' has been deprecated in favor of the 'dhall text' command from 'dhall'"; # Added 2022-03-26
   digikam5 = throw "'digikam5' has been renamed to/replaced by 'digikam'"; # Converted to throw 2022-02-22
+  dirmngr = throw "dirmngr has been removed: merged into gnupg"; # Added 2022-05-13
   disper = throw "disper has been removed: abandoned by upstream"; # Added 2022-03-18
   displaycal = throw "displaycal has been removed from nixpkgs, as it hasn't migrated to python3"; # Added 2022-01-12
   dmtx = throw "'dmtx' has been renamed to/replaced by 'dmtx-utils'"; # Converted to throw 2022-02-22
···
   libudev = throw "'libudev' has been renamed to/replaced by 'udev'"; # Converted to throw 2022-02-22
   libungif = giflib; # Added 2020-02-12
   libusb = libusb1; # Added 2020-04-28
+  libusb1-axoloti = throw "libusb1-axoloti has been removed: axoloti has been removed"; # Added 2022-05-13
   libva-full = throw "'libva-full' has been renamed to/replaced by 'libva'"; # Converted to throw 2022-02-22
   libva1-full = throw "'libva1-full' has been renamed to/replaced by 'libva1'"; # Converted to throw 2022-02-22
   libwnck3 = libwnck;

pkgs/top-level/all-packages.nix

···
 
   bonnmotion = callPackage ../development/tools/misc/bonnmotion { };
 
-  bonnie = callPackage ../tools/filesystems/bonnie { };
+  bonnie = callPackage ../tools/filesystems/bonnie {
+    stdenv = if stdenv.cc.isGNU then gcc10Stdenv else stdenv;
+  };
 
   botamusique = callPackage ../tools/audio/botamusique { };
 
···
 
   axel = callPackage ../tools/networking/axel {
     libssl = openssl;
-  };
-
-  axoloti = callPackage ../applications/audio/axoloti {
-    gcc-arm-embedded = pkgsCross.arm-embedded.buildPackages.gcc;
-    binutils-arm-embedded = pkgsCross.arm-embedded.buildPackages.binutils;
-    jdk = jdk8; # TODO: remove override https://github.com/NixOS/nixpkgs/pull/89731
-  };
-  dfu-util-axoloti = callPackage ../applications/audio/axoloti/dfu-util.nix { };
-  libusb1-axoloti = callPackage ../applications/audio/axoloti/libusb1.nix {
-    inherit (darwin) libobjc;
-    inherit (darwin.apple_sdk.frameworks) IOKit;
   };
 
   b3sum = callPackage ../tools/security/b3sum {};
···
   picotts = callPackage ../tools/audio/picotts { };
 
   wgetpaste = callPackage ../tools/text/wgetpaste { };
-
-  dirmngr = callPackage ../tools/security/dirmngr { };
 
   dismap = callPackage ../tools/security/dismap { };
 
···
 
   classads = callPackage ../development/libraries/classads { };
 
-  clfft = callPackage ../development/libraries/clfft { };
+  clfft = callPackage ../development/libraries/clfft {
+    stdenv = if stdenv.cc.isGNU then gcc10Stdenv else stdenv;
+  };
 
   clipp  = callPackage ../development/libraries/clipp { };
 
···
   cosmopolitan = callPackage ../development/libraries/cosmopolitan { };
 
   python-cosmopolitan = callPackage ../development/interpreters/python-cosmopolitan { };
-
-  ctl = callPackage ../development/libraries/ctl { };
 
   ctpp2 = callPackage ../development/libraries/ctpp2 { };