Merge master into staging-next

nixos/modules/installer/tools/nix-fallback-paths.nix

···
 {
-  x86_64-linux = "/nix/store/6g4fla3vkcxihph282a0v3cd10709y7c-nix-2.9.1";
-  i686-linux = "/nix/store/j143221z44469zx21f5m9a47x7y1jpr5-nix-2.9.1";
-  aarch64-linux = "/nix/store/c4z3vy1sgm49la8bvmdrrpssgk4iw2nk-nix-2.9.1";
-  x86_64-darwin = "/nix/store/cqdwb7khf6zg94bz7lnvfjqx6z775qaw-nix-2.9.1";
-  aarch64-darwin = "/nix/store/1brkxcs287n1px2i4fq39l7h51hjv0f8-nix-2.9.1";
+  x86_64-linux = "/nix/store/qx384jvdjk2vzd2wpr9pmkcimk12g3as-nix-2.10.2";
+  i686-linux = "/nix/store/8mhknp6flnlnbj11zmskb3972ia1mdl5-nix-2.10.2";
+  aarch64-linux = "/nix/store/digzqw2vgdsg0fdzf7qlwbl4xii9i458-nix-2.10.2";
+  x86_64-darwin = "/nix/store/w62jxmpvjykw707qr9s5nxi90r35xqmd-nix-2.10.2";
+  aarch64-darwin = "/nix/store/6pjrn22f57n854x88a9kkbqnxw1yai73-nix-2.10.2";
 }

nixos/modules/programs/dmrconfig.nix

···
   cfg = config.programs.dmrconfig;
 
 in {
-  meta.maintainers = [ maintainers.etu ];
+  meta.maintainers = with maintainers; [ ];
 
   ###### interface
   options = {

nixos/modules/services/system/cachix-agent/default.nix

···
       path = [ config.nix.package ];
       wantedBy = [ "multi-user.target" ];
 
-      # don't restart while changing
-      restartIfChanged = false;
+      # Cachix requires $USER to be set
+      environment.USER = "root";
+
+      # don't stop the service if the unit disappears
       unitConfig.X-StopOnRemoval = false;
 
-      environment.USER = "root";
       serviceConfig = {
+        # we don't want to kill children processes as those are deployments
+        KillMode = "process";
         Restart = "on-failure";
         EnvironmentFile = cfg.credentialsFile;
         ExecStart = "${cfg.package}/bin/cachix ${lib.optionalString cfg.verbose "--verbose"} deploy agent ${cfg.name} ${if cfg.profile != null then profile else ""}";

pkgs/applications/audio/redux/default.nix

···
 , stdenv
 , fetchurl
 , libX11
+, libXext
 , alsa-lib
 , autoPatchelfHook
 , releasePath ? null
···
 
 stdenv.mkDerivation rec {
   pname = "redux";
-  version = "1.2.2";
+  version = "1.3.2";
 
   src = if releasePath != null then releasePath
     else fetchurl {
-      url = "https://files.renoise.com/demo/Renoise_Redux_${lib.replaceStrings ["."] ["_"] version}_Demo_Linux.tar.gz";
-      sha256 = "0zbwsg7nh9x3q29jv2kpqb3vwi0ksdwybhb4m2qr95rxrpx1kxhm";
+      url = "https://files.renoise.com/demo/Renoise_Redux_${lib.replaceStrings ["."] ["_"] version}_Demo_Linux_x86_64.tar.gz";
+      sha256 = "sha256-wafOeNvVIHc8pOHoNQcCwV8+OwnuevJo1EcRQKRX4YA=";
     };
 
   nativeBuildInputs = [
     autoPatchelfHook
   ];
 
-  buildInputs = [ libX11 alsa-lib stdenv.cc.cc.lib ];
+  buildInputs = [
+    libX11
+    libXext
+    alsa-lib
+    stdenv.cc.cc.lib
+  ];
 
   installPhase = ''
     runHook preInstall

pkgs/applications/audio/uade123/default.nix

···
 { lib
 , stdenv
 , fetchFromGitLab
+, python3
 , pkg-config
 , which
 , makeWrapper
···
 , vorbis-tools
 }:
 
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   pname = "uade123";
-  version = "unstable-2021-05-21";
+  version = "3.01";
 
   src = fetchFromGitLab {
     owner = "uade-music-player";
     repo = "uade";
-    rev = "7169a46e777d19957cd7ff8ac31843203e725ddc";
-    sha256 = "1dm7c924fy79y3wkb0qi71m1k6yw1x6j3whw7d0w4ka9hv6za03b";
+    rev = "uade-${version}";
+    sha256 = "0fam3g8mlzrirrac3iwcwsz9jmsqwdy7lkwwdr2q4pkq9cpmh8m5";
   };
 
   postPatch = ''
-    patchShebangs .
+    patchShebangs configure
+    substituteInPlace configure \
+      --replace 'PYTHON_SETUP_ARGS=""' 'PYTHON_SETUP_ARGS="--prefix=$out"'
     substituteInPlace src/frontends/mod2ogg/mod2ogg2.sh.in \
       --replace '-e stat' '-n stat' \
       --replace '/usr/local' "$out"
···
     pkg-config
     which
     makeWrapper
+    python3
   ];
 
   buildInputs = [
···
     lame
     flac
     vorbis-tools
+    (python3.withPackages (p: with p; [
+      pillow
+      tqdm
+    ]))
   ];
 
   configureFlags = [
···
       --prefix PATH : $out/bin:${lib.makeBinPath [ sox lame flac vorbis-tools ]}
     # This is an old script, don't break expectations by renaming it
     ln -s $out/bin/mod2ogg2{.sh,}
+    wrapProgram $out/bin/generate_amiga_oscilloscope_view \
+      --prefix PYTHONPATH : "$PYTHONPATH:$out/${python3.sitePackages}"
   '';
 
   meta = with lib; {

pkgs/applications/blockchains/besu/default.nix

···
     description = "An enterprise-grade Java-based, Apache 2.0 licensed Ethereum client";
     homepage = "https://www.hyperledger.org/projects/besu";
     license = licenses.asl20;
+    sourceProvenance = with sourceTypes; [ binaryBytecode ];
     platforms = platforms.all;
     maintainers = with maintainers; [ mmahut ];
   };

pkgs/applications/misc/sequeler/default.nix

···
     '';
     homepage = "https://github.com/Alecaddd/sequeler";
     license = licenses.gpl3;
-    maintainers = with maintainers; [ etu ] ++ teams.pantheon.members;
+    maintainers = with maintainers; [ ] ++ teams.pantheon.members;
     platforms = platforms.linux;
     mainProgram = "com.github.alecaddd.sequeler";
   };

pkgs/applications/misc/sunwait/default.nix

···
     description = "Calculates sunrise or sunset times with civil, nautical, astronomical and custom twilights";
     homepage = "https://github.com/risacher/sunwait";
     license = licenses.gpl3Only;
-    maintainers = with maintainers; [ etu ];
+    maintainers = with maintainers; [ ];
     platforms = platforms.all;
   };
 }

pkgs/applications/networking/mailreaders/aerc/default.nix

···
 
 buildGoModule rec {
   pname = "aerc";
-  version = "0.10.0";
+  version = "0.11.0";
 
   src = fetchFromSourcehut {
     owner = "~rjarry";
     repo = pname;
     rev = version;
-    sha256 = "sha256-v1+12UCgBbH/2PxZ9QdDN30LmyzVcfGlYiVNVPYO3zs=";
+    sha256 = "sha256-w0h6BNuGwXV1CzyvXvsRs2MXHKLbK3EUaK4mKiuNBxc=";
   };
 
   proxyVendor = true;
-  vendorSha256 = "sha256-fGQ15i3mWNmmfypRt5A7SAVYSEg9m4so4FYlUY+7mW8=";
+  vendorSha256 = "sha256-vw9lDIZMswh/vrF1g8FvZ/faN5jWWPwfgnm66EWaohw=";
 
   doCheck = false;
 

pkgs/applications/radio/aldo/default.nix

···
     description = "Morse code training program";
     homepage = "http://aldo.nongnu.org/";
     license = licenses.gpl3Plus;
-    maintainers = with maintainers; [ etu ];
+    maintainers = with maintainers; [ ];
     platforms = platforms.linux;
   };
 }

pkgs/applications/radio/dmrconfig/default.nix

···
     '';
     homepage = "https://github.com/sergev/dmrconfig";
     license = licenses.asl20;
-    maintainers = [ maintainers.etu ];
+    maintainers = with maintainers; [ ];
     platforms = platforms.linux;
   };
 }

pkgs/applications/radio/tlf/default.nix

···
     '';
     homepage = "https://tlf.github.io/";
     license = licenses.gpl2;
-    maintainers = with maintainers; [ etu ];
+    maintainers = with maintainers; [ ];
     platforms = platforms.linux;
   };
 }

pkgs/applications/version-management/git-and-tools/conform/default.nix

···
 
 buildGoModule rec {
   pname = "conform";
-  version = "0.1.0-alpha.25";
+  version = "0.1.0-alpha.26";
 
   src = fetchFromGitHub {
     owner = "siderolabs";
     repo = "conform";
     rev = "v${version}";
-    sha256 = "sha256-WgWgigpqPoEBY4tLjbzK02WFwrCWPGQWJ5eakLv5IWw=";
+    sha256 = "sha256-+VOwQE2uhoQ4sSXa/SVbyjLn9An08D4GQHxxDRRuXks=";
   };
-
   vendorSha256 = "sha256-Oigt7tAK4jhBQtfG1wdLHqi11NWu6uJn5fmuqTmR76E=";
 
   ldflags = [
     "-s"
     "-w"
-    "-X github.com/talos-systems/conform/internal/version.Tag=v${version}"
+    "-X github.com/siderolabs/conform/internal/version.Tag=v${version}"
   ];
 
   checkInputs = [ git ];

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

···
 
   self = python3Packages.buildPythonApplication rec {
     pname = "mercurial${lib.optionalString fullBuild "-full"}";
-    version = "6.1.4";
+    version = "6.2";
 
     src = fetchurl {
       url = "https://mercurial-scm.org/release/mercurial-${version}.tar.gz";
-      sha256 = "sha256-82H5gCs241esAZzrcSyhHegzKwfere7Y36kE8Fv3yng=";
+      sha256 = "sha256-04K14/q4kxEmATIBcxQWV0s1roV4dAS7KggZ9Bu4iXI=";
     };
 
     format = "other";
···
     cargoDeps = if rustSupport then rustPlatform.fetchCargoTarball {
       inherit src;
       name = "mercurial-${version}";
-      sha256 = "sha256-GEsRA8od2S9v5xipCwsCmkdLvKKpbbKJGNqPFmrZASQ=";
+      sha256 = "sha256-L4BbU6GTq54DFucqvBZeWtA8zUPvPCwmtIxv/SxgAXk=";
       sourceRoot = "mercurial-${version}/rust";
     } else null;
     cargoRoot = if rustSupport then "rust" else null;

pkgs/applications/window-managers/xmonad/xmonadctl.nix

···
+{ stdenv, lib, fetchFromGitHub, ghcWithPackages, ... }:
+
+let xmonadctlEnv = ghcWithPackages (self: [ self.xmonad-contrib self.X11 ]);
+in stdenv.mkDerivation rec {
+  pname = "xmonadctl";
+  version = "0.17.0";
+
+  src = fetchFromGitHub {
+    owner = "xmonad";
+    repo = "xmonad-contrib";
+    rev = "v${version}";
+    sha256 = "142ycg7dammq98drimv6xbih8dla9qindxds9fgkspmrrils3sar";
+  };
+
+  installPhase = ''
+    runHook preInstall
+    mkdir -p $out/bin
+    ${xmonadctlEnv}/bin/ghc -o $out/bin/xmonadctl \
+      --make scripts/xmonadctl.hs
+    runHook postInstall
+  '';
+
+  meta = with lib; {
+    platforms = platforms.unix;
+    description = "Send commands to a running instance of xmonad";
+    homepage = "https://github.com/xmonad/xmonad-contrib";
+    license = licenses.bsd3;
+    maintainers = [ maintainers.ajgrf ];
+  };
+}

pkgs/data/misc/hackage/pin.json

···
 {
-  "commit": "c096b9d83b86ab92dffac5d97927e8458ebd4dfa",
-  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/c096b9d83b86ab92dffac5d97927e8458ebd4dfa.tar.gz",
-  "sha256": "1j9j97zn8qhxsigi73319l0dairkymjk6mknsgindzgsvrrag9xg",
-  "msg": "Update from Hackage at 2022-07-07T10:54:07Z"
+  "commit": "0b418fc93e5dd9f19c4ca625c57e2cf984267e90",
+  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/0b418fc93e5dd9f19c4ca625c57e2cf984267e90.tar.gz",
+  "sha256": "0rvx383fyl39spw0qr7a1rpqnyzfsjykakia4y2z3658aw4k72cx",
+  "msg": "Update from Hackage at 2022-07-12T21:40:07Z"
 }

pkgs/desktops/surf-display/default.nix

···
   meta = with lib; {
     description = "Kiosk browser session manager based on the surf browser";
     homepage = "https://code.it-zukunft-schule.de/cgit/surf-display/";
-    maintainers = with maintainers; [ etu ];
+    maintainers = with maintainers; [ ];
     license = licenses.gpl2;
     platforms = platforms.linux;
   };

pkgs/development/compilers/gnatboot/default.nix

···
-{ lib, stdenv, fetchurl }:
+{ stdenv, lib, autoPatchelfHook, fetchzip, xz, ncurses5, readline, gmp, mpfr
+, expat, libipt, zlib, dejagnu, sourceHighlight, python3, elfutils, guile, glibc
+}:
 
-if stdenv.hostPlatform != stdenv.targetPlatform
-then builtins.throw "gnatboot can't cross-compile"
-else
+stdenv.mkDerivation rec {
+  pname = "gnatboot";
+  version = "11.2.0-4";
 
-stdenv.mkDerivation {
-  pname = "gentoo-gnatboot";
-  version = "4.1";
+  src = fetchzip {
+    url = "https://github.com/alire-project/GNAT-FSF-builds/releases/download/gnat-${version}/gnat-x86_64-linux-${version}.tar.gz";
+    hash = "sha256-8fMBJp6igH+Md5jE4LMubDmC4GLt4A+bZG/Xcz2LAJQ=";
+  };
 
-  src = if stdenv.hostPlatform.system == "i686-linux" then
-    fetchurl {
-      url = "mirror://gentoo/distfiles/gnatboot-4.1-i386.tar.bz2";
-      sha256 = "0665zk71598204bf521vw68i5y6ccqarq9fcxsqp7ccgycb4lysr";
-    }
-  else if stdenv.hostPlatform.system == "x86_64-linux" then
-    fetchurl {
-      url = "mirror://gentoo/distfiles/gnatboot-4.1-amd64.tar.bz2";
-      sha256 = "1li4d52lmbnfs6llcshlbqyik2q2q4bvpir0f7n38nagp0h6j0d4";
-    }
-  else
-    throw "Platform not supported";
-
-  dontStrip = 1;
+  nativeBuildInputs = [
+    autoPatchelfHook
+    dejagnu
+    elfutils
+    expat
+    glibc
+    gmp
+    guile
+    libipt
+    mpfr
+    ncurses5
+    python3
+    readline
+    sourceHighlight
+    xz
+    zlib
+  ];
 
   installPhase = ''
     mkdir -p $out
-    cp -R * $out
-
-    set +e
-    for a in $out/bin/* ; do
-      patchelf --interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \
-        --set-rpath $(cat $NIX_CC/nix-support/orig-libc)/lib:$(cat $NIX_CC/nix-support/orig-cc)/lib64:$(cat $NIX_CC/nix-support/orig-cc)/lib $a
-    done
-    set -e
-
-    mv $out/bin/gnatgcc_2wrap $out/bin/gnatgcc
-    ln -s $out/bin/gnatgcc $out/bin/gcc
+    cp -ar * $out/
   '';
 
   passthru = {
···
   };
 
   meta = with lib; {
-    homepage = "https://gentoo.org";
-    license = licenses.gpl3Plus;
-    maintainers = [ maintainers.lucus16 ];
-
-    platforms = platforms.linux;
+    description = "GNAT, the GNU Ada Translator";
+    homepage = "https://www.gnu.org/software/gnat";
+    license = licenses.gpl3;
+    maintainers = with maintainers; [ ethindp ];
+    platforms = with platforms; [ "x86_64-linux" ];
   };
 }

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

···
   lvmrun = disableHardening ["format"] (dontCheck super.lvmrun);
   matplotlib = dontCheck super.matplotlib;
 
-  brick_0_71_1 = super.brick_0_71_1.overrideScope (self: super: {
+  brick_0_73 = doDistribute (super.brick_0_73.overrideScope (self: super: {
     vty = self.vty_5_36;
-  });
+    text-zipper = self.text-zipper_0_12;
+  }));
 
   # https://github.com/matterhorn-chat/matterhorn/issues/679 they do not want to be on stackage
-  # Needs brick ^>= 0.70
-  matterhorn = doJailbreak (super.matterhorn.overrideScope (self: super: {
-    brick = self.brick_0_71_1;
-  }));
+  matterhorn = doJailbreak (appendPatches [
+    # Fix build with brick 0.73
+    (fetchpatch {
+      name = "matterhorn-brick-0.72.patch";
+      url = "https://github.com/matterhorn-chat/matterhorn/commit/d52df3342b8420e219095aad477205e47fbef11b.patch";
+      sha256 = "1ifvv926g9m8niyc9nl1hy9bkx4kf12ciyv2v8vnrzz3njp4fsrz";
+    })
+  ] (super.matterhorn.overrideScope (self: super: {
+    brick = self.brick_0_73;
+  })));
 
   memcache = dontCheck super.memcache;
   metrics = dontCheck super.metrics;
···
 
   # 2022-03-21: Newest stylish-haskell needs ghc-lib-parser-9_2
   stylish-haskell = (super.stylish-haskell.override {
-    ghc-lib-parser = super.ghc-lib-parser_9_2_3_20220527;
+    ghc-lib-parser = super.ghc-lib-parser_9_2_3_20220709;
     ghc-lib-parser-ex = self.ghc-lib-parser-ex_9_2_1_0;
   });
 
   ghc-lib-parser-ex_9_2_1_0 = super.ghc-lib-parser-ex_9_2_1_0.override {
-    ghc-lib-parser = super.ghc-lib-parser_9_2_3_20220527;
+    ghc-lib-parser = super.ghc-lib-parser_9_2_3_20220709;
   };
+
+  ghc-lib-parser-ex_9_2_0_4 = super.ghc-lib-parser-ex_9_2_0_4.override {
+    ghc-lib-parser = super.ghc-lib-parser_9_2_3_20220709;
+  };
+
+  hlint_3_4_1 = doDistribute (super.hlint_3_4_1.override {
+    ghc-lib-parser-ex = self.ghc-lib-parser-ex_9_2_0_4;
+  });
 
   # To strict bound on hspec
   # https://github.com/dagit/zenc/issues/5
···
   # file revision on hackage was gifted CRLF line endings
   gogol-core = appendPatch ./patches/gogol-core-144.patch super.gogol-core;
 
-  # Too strict bound on deepseq
-  # https://github.com/hadolint/hadolint/issues/800
-  hadolint = doJailbreak super.hadolint;
+  # Stackage LTS 19 still has 10.*
+  hadolint = super.hadolint.override {
+    language-docker = self.language-docker_11_0_0;
+  };
 
   nix-tree = super.nix-tree;
 

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

···
   # Tests fail because of typechecking changes
   conduit = dontCheck super.conduit;
 
-  # 0.30 introduced support for GHC 9.2.x, so when this assert fails, the whole block can be removed
-  cryptonite = assert super.cryptonite.version == "0.29"; appendPatch (pkgs.fetchpatch {
-    url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/dfd024c9a336c752288ec35879017a43bd7e85a0/patches/cryptonite-0.29.patch";
-    sha256 = "1g48lrmqgd88hqvfq3klz7lsrpwrir2v1931myrhh6dy0d9pqj09";
-  }) super.cryptonite;
+  # 0.30 introduced support for GHC 9.2.
+  cryptonite = doDistribute self.cryptonite_0_30;
 
   # cabal-install needs more recent versions of Cabal
   cabal-install = (doJailbreak super.cabal-install).overrideScope (self: super: {
···
   constraints = doJailbreak super.constraints;
   cpphs = overrideCabal (drv: { postPatch = "sed -i -e 's,time >=1.5 && <1.11,time >=1.5 \\&\\& <1.12,' cpphs.cabal";}) super.cpphs;
   data-fix = doJailbreak super.data-fix;
-  dbus = super.dbus_1_2_24;
+  dbus = self.dbus_1_2_25;
   dec = doJailbreak super.dec;
   ed25519 = doJailbreak super.ed25519;
   ghc-byteorder = doJailbreak super.ghc-byteorder;
···
       self.data-default
     ] ++ drv.libraryHaskellDepends or [];
   }) super.ghc-exactprint;
-  ghc-lib = self.ghc-lib_9_2_3_20220527;
-  ghc-lib-parser = self.ghc-lib-parser_9_2_3_20220527;
+  ghc-lib = self.ghc-lib_9_2_3_20220709;
+  ghc-lib-parser = self.ghc-lib-parser_9_2_3_20220709;
   ghc-lib-parser-ex = self.ghc-lib-parser-ex_9_2_1_0;
   hackage-security = doJailbreak super.hackage-security;
   hashable = super.hashable_1_4_0_2;
···
   singleton-bool = doJailbreak super.singleton-bool;
   servant = doJailbreak super.servant;
   servant-auth = doJailbreak super.servant-auth;
-  servant-server = appendPatches [
-    # awaiting release
-    (pkgs.fetchpatch {
-      url = "https://github.com/haskell-servant/servant/commit/61d0d14b5cb01db3d589101b3f17b0178f52e386.diff";
-      relative = "servant-server";
-      sha256 = "sha256-3lM8xLO8avVRo8oncJR8QLDSWEzOaoCmzgVtyaEBEw8=";
-    })
-  ] (doJailbreak super.servant-server);
   servant-swagger = doJailbreak super.servant-swagger;
   servant-auth-swagger = doJailbreak super.servant-auth-swagger;
   shelly = doJailbreak super.shelly;
···
   } super.memory);
 
   # Use hlint from git for GHC 9.2.1 support
-  hlint = self.hlint_3_4;
+  hlint = self.hlint_3_4_1;
 
   # https://github.com/sjakobi/bsb-http-chunked/issues/38
   bsb-http-chunked = dontCheck super.bsb-http-chunked;

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

···
   - bizzlelude-js
   - bkr
   - blakesum
+  - Blammo
   - blas
   - blaze-html-contrib
   - blaze-html-hexpat
···
   - effin
   - egison-pattern-src
   - ehaskell
+  - ehlo
   - ehs
   - eibd-client-simple
   - eigen
···
   - exinst
   - exists
   - exitcode
+  - exon
   - exp-cache
   - explain
   - explicit-constraint-lens
···
   - heist-emanote
   - helic
   - helisp
+  - helix
   - hell
   - helm
   - help-esb
···
   - hext
   - hextra
   - heyefi
+  - heystone
   - hF2
   - hfann
   - HFitUI
···
   - pyfi
   - python-pickle
   - q4c12-twofinger
+  - qbe
   - qc-oi-testgenerator
   - qd
   - qed
···
   - relacion
   - relapse
   - relevant-time
+  - reload
   - remark
   - remarks
   - remote
···
   - simple-form
   - simple-genetic-algorithm
   - SimpleH
+  - SimpleServer
   - simple-index
   - simpleirc
   - simple-log
···
   - sodium
   - soegtk
   - softfloat-hs
+  - solga
   - sonic-visualiser
   - Sonnex
   - SoOSiM
···
   - tapioca
   - TaskMonad
   - tasty-auto
+  - tasty-autocollect
   - tasty-fail-fast
   - tasty-grading-system
   - tasty-hedgehog-coverage
···
   - wai-request-spec
   - wai-responsible
   - wai-router
+  - wai-routes
   - wai-secure-cookies
   - wai-session-alt
   - wai-session-mysql

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

···
   - ghc-lib == 8.10.7.*                 # 2022-02-17: preserve for GHC 8.10.7
   - 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
+  - ghc-lib-parser-ex >= 9.2.0.3 && < 9.2.1 # 2022-07-13: needed by hlint 3.4.1
   - doctest == 0.18.*                   # 2021-11-19: closest to stackage version for GHC 9.*
   - 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

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

···
-# Stackage LTS 19.14
+# Stackage LTS 19.15
 # This file is auto-generated by
 # maintainers/scripts/haskell/update-stackage.sh
 default-package-overrides:
···
   - asn1-encoding ==0.9.6
   - asn1-parse ==0.9.5
   - asn1-types ==0.3.4
-  - assert-failure ==0.1.2.5
+  - assert-failure ==0.1.2.6
   - assoc ==1.0.2
   - astro ==0.4.3.0
   - async ==2.2.4
···
   - gi-harfbuzz ==0.0.5
   - gi-javascriptcore ==4.0.24
   - ginger ==0.10.4.0
-  - gi-pango ==1.0.25
+  - gi-pango ==1.0.26
   - githash ==0.1.6.2
   - github ==0.27
   - github-release ==2.0.0.1
···
   - hi-file-parser ==0.1.2.0
   - higher-leveldb ==0.6.0.0
   - highlighting-kate ==0.6.4
-  - hindent ==5.3.2
+  - hindent ==5.3.4
   - hinfo ==0.0.3.0
   - hinotify ==0.4.1
   - hint ==0.9.0.6
···
   - markov-chain ==0.0.3.4
   - massiv ==1.0.1.1
   - massiv-io ==1.0.0.1
-  - massiv-persist ==1.0.0.2
+  - massiv-persist ==1.0.0.3
   - massiv-serialise ==1.0.0.2
   - massiv-test ==1.0.0.0
   - mathexpr ==0.3.0.0
···
   - mime-mail-ses ==0.4.3
   - mime-types ==0.1.0.9
   - minimal-configuration ==0.1.4
-  - minimorph ==0.3.0.0
+  - minimorph ==0.3.0.1
   - minio-hs ==1.6.0
-  - miniutter ==0.5.1.1
+  - miniutter ==0.5.1.2
   - min-max-pqueue ==0.1.0.2
   - mintty ==0.1.4
   - missing-foreign ==0.1.1
···
   - proto-lens ==0.7.1.1
   - proto-lens-arbitrary ==0.1.2.11
   - proto-lens-optparse ==0.1.1.9
-  - proto-lens-protobuf-types ==0.7.1.1
+  - proto-lens-protobuf-types ==0.7.1.2
   - proto-lens-protoc ==0.7.1.1
   - proto-lens-runtime ==0.7.0.2
   - proto-lens-setup ==0.4.0.6
···
   - read-env-var ==1.0.0.0
   - reanimate-svg ==0.13.0.1
   - rebase ==1.15.0.3
-  - record-dot-preprocessor ==0.2.14
+  - record-dot-preprocessor ==0.2.15
   - record-hasfield ==1.0
   - records-sop ==0.1.1.0
   - record-wrangler ==0.1.1.0
···
   - servant-swagger-ui-redoc ==0.3.4.1.22.3
   - servant-websockets ==2.0.0
   - servant-xml ==1.0.1.4
-  - serversession ==1.0.2
+  - serversession ==1.0.3
   - serversession-frontend-wai ==1.0
   - servius ==1.2.3.0
   - ses-html ==0.4.0.0
···
   - shake ==0.19.6
   - shake-language-c ==0.12.0
   - shake-plus ==0.3.4.0
-  - shakespeare ==2.0.29
+  - shakespeare ==2.0.30
   - shared-memory ==0.2.0.0
   - ShellCheck ==0.8.0
   - shell-conduit ==5.0.0

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

···
  - Shpadoinkle-widgets
  - SimpleGL
  - SimpleLog
- - SimpleServer
  - Smooth
  - Snusmumrik
  - SoccerFun
···
  - helics
  - helics-wai
  - helium
- - helix
  - hellage
  - hellnet
  - hemokit
···
  - relational-record-examples
  - relational-schemas
  - relative-date
- - reload
  - remote-json
  - remote-json-client
  - remote-json-server
···
  - sock2stream
  - socket-io
  - sockets
- - solga
  - solga-swagger
  - solr
  - souffle-dsl
···
  - wai-middleware-rollbar
  - wai-middleware-route
  - wai-middleware-throttle
- - wai-routes
  - wai-routing
  - wai-session-tokyocabinet
  - wai-thrift

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

···
      }:
      mkDerivation {
        pname = "Blammo";
-       version = "1.0.2.1";
-       sha256 = "0ym6j8ysng4kqdzbkhr4i4wgq1lsl70c3arm3g8z976lzc7612m5";
+       version = "1.0.2.2";
+       sha256 = "1xj2m7hblaq1d5z9f4ygfwi23w1xvfmjjwrsm2m5kwkp10k5d19i";
        libraryHaskellDepends = [
          aeson base bytestring case-insensitive clock containers dlist
          envparse exceptions fast-logger http-types lens monad-logger-aeson
···
        testToolDepends = [ markdown-unlit ];
        description = "Batteries-included Structured Logging library";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "BlastHTTP" = callPackage
···
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
        mainProgram = "simpleserver";
+       broken = true;
      }) {};
 
   "SimpleTableGenerator" = callPackage
···
        description = "Parsers and utilities for the OBJ WaveFront 3D model format";
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "WeakSets" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "WeakSets";
+       version = "0.1.0.0";
+       sha256 = "1qlvlwwif93lm3q072lmp9gs6zp2zy1rsl76d51s7mbvxr9lyrq8";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base ];
+       description = "Simple set types. Useful to create sets of arbitrary types and nested sets.";
+       license = lib.licenses.lgpl3Plus;
      }) {};
 
   "Weather" = callPackage
···
     ({ mkDerivation, base, pretty-show, text }:
      mkDerivation {
        pname = "assert-failure";
-       version = "0.1.2.5";
-       sha256 = "0k8a7g82dsj50djpy2kvhnfljb3y9w9dx9mpymvn6hxd6rir4bpm";
-       enableSeparateDataOutput = true;
-       libraryHaskellDepends = [ base pretty-show text ];
-       description = "Syntactic sugar improving 'assert' and 'error'";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "assert-failure_0_1_2_6" = callPackage
-    ({ mkDerivation, base, pretty-show, text }:
-     mkDerivation {
-       pname = "assert-failure";
        version = "0.1.2.6";
        sha256 = "198bvr7wgshwmbl8gcgq91hz7d87ar6gkqhhp1xgsg1mqikqi02z";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [ base pretty-show text ];
        description = "Syntactic sugar improving 'assert' and 'error'";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "assert4hs" = callPackage
···
      }:
      mkDerivation {
        pname = "avro";
-       version = "0.6.1.0";
-       sha256 = "0fvpva4516y9yxh2bh8kp9vzrcyh2hcffpn2f4g27l2pqsdjanyq";
+       version = "0.6.1.1";
+       sha256 = "16ii6mvls85i0gfmq9c2mhzan3rcfz3ishnk80rw5z69r29z2wyl";
        libraryHaskellDepends = [
          aeson array base base16-bytestring bifunctors binary bytestring
          containers data-binary-ieee754 deepseq fail HasBigDecimal hashable
···
      }) {};
 
   "binrep" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, cereal, refined
-     , refined-with, text
+    ({ mkDerivation, aeson, base, bytestring, either, flatparse
+     , generic-random, hspec, hspec-discover, mason, megaparsec
+     , QuickCheck, quickcheck-instances, refined, strongweak, text
+     , text-icu, vector, vector-sized
      }:
      mkDerivation {
        pname = "binrep";
-       version = "0.1.0";
-       sha256 = "10b65qdk4h96q44bl6ic8c4v2lfkr3vsm15zpia0dlikxnibvb8i";
+       version = "0.2.0";
+       sha256 = "151vvxs4h6x24j437qma62z3n82yhvl754321zlyjj815icrax5a";
        libraryHaskellDepends = [
-         aeson base bytestring cereal refined refined-with text
+         aeson base bytestring either flatparse mason megaparsec refined
+         strongweak text text-icu vector vector-sized
        ];
-       description = "Encode binary representations via types";
+       testHaskellDepends = [
+         aeson base bytestring either flatparse generic-random hspec mason
+         megaparsec QuickCheck quickcheck-instances refined strongweak text
+         text-icu vector vector-sized
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Encode precise binary representations directly in types";
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
      }) {};
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "brick_0_71_1" = callPackage
+  "brick_0_73" = callPackage
     ({ mkDerivation, base, bytestring, config-ini, containers
      , contravariant, data-clist, deepseq, directory, dlist, exceptions
      , filepath, microlens, microlens-mtl, microlens-th, QuickCheck, stm
···
      }:
      mkDerivation {
        pname = "brick";
-       version = "0.71.1";
-       sha256 = "0m6j49izmmgqvqp3jnp5lc8b84a87hmhmv0bclqv2d2571k18w29";
+       version = "0.73";
+       sha256 = "17030aydkn9gkd8dwywhfc65lr3dnf6cib6kspfmmazh2w3qs73l";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "cachix";
-       version = "0.7.1";
-       sha256 = "1n3gb40bj426fzdcqx7yypbss17z3snrz75d1aff60az4942n3jd";
+       version = "0.8.0";
+       sha256 = "0wdqb5pm7nqlm0g9mkv0spbc1j2hxb2p2aihs1c3vrz112z40fxm";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          uri-bytestring uuid vector versions websockets wuss
        ];
        libraryPkgconfigDepends = [ nix ];
-       executableHaskellDepends = [ base cachix-api safe-exceptions ];
+       executableHaskellDepends = [
+         aeson async base cachix-api conduit http-conduit katip protolude
+         safe-exceptions stm stm-conduit time uuid websockets wuss
+       ];
        executableToolDepends = [ hspec-discover ];
        testHaskellDepends = [
          base cachix-api directory here hspec protolude servant-auth-client
···
        ];
        description = "Command line client for Nix binary cache hosting https://cachix.org";
        license = lib.licenses.asl20;
-       mainProgram = "cachix";
        maintainers = [ lib.maintainers.domenkozar ];
      }) {inherit (pkgs) nix;};
 
···
        pname = "cassava";
        version = "0.5.2.0";
        sha256 = "01h1zrdqb313cjd4rqm1107azzx4czqi018c2djf66a5i7ajl3dk";
-       revision = "8";
-       editedCabalFile = "17vm6016k4phznax0v4jbg14wckwwxlx9q0kkrvz1m2zcbjk8r9h";
+       revision = "9";
+       editedCabalFile = "087489f6wx9gcr107xnw7pbmnwh9rkdqqk2sky3g43k87j2aqhbj";
        configureFlags = [ "-f-bytestring--lt-0_10_4" ];
        libraryHaskellDepends = [
          array attoparsec base bytestring containers deepseq hashable Only
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "cassava_0_5_3_0" = callPackage
+    ({ mkDerivation, array, attoparsec, base, bytestring, containers
+     , deepseq, hashable, HUnit, Only, QuickCheck, quickcheck-instances
+     , scientific, test-framework, test-framework-hunit
+     , test-framework-quickcheck2, text, text-short, transformers
+     , unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "cassava";
+       version = "0.5.3.0";
+       sha256 = "1gp954w05bj83z4i6isq2qxi1flqwppsgxxrp1f75mrs8cglbj5l";
+       configureFlags = [ "-f-bytestring--lt-0_10_4" ];
+       libraryHaskellDepends = [
+         array attoparsec base bytestring containers deepseq hashable Only
+         scientific text text-short transformers unordered-containers vector
+       ];
+       testHaskellDepends = [
+         attoparsec base bytestring hashable HUnit QuickCheck
+         quickcheck-instances scientific test-framework test-framework-hunit
+         test-framework-quickcheck2 text unordered-containers vector
+       ];
+       description = "A CSV parsing and encoding library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "cassava-conduit" = callPackage
     ({ mkDerivation, array, base, bifunctors, bytestring, cassava
      , conduit, containers, criterion, mtl, QuickCheck, text
···
        maintainers = [ lib.maintainers.dschrempf ];
      }) {};
 
+  "circular_0_4_0_3" = callPackage
+    ({ mkDerivation, aeson, base, criterion, hspec, primitive
+     , QuickCheck, quickcheck-instances, vector
+     }:
+     mkDerivation {
+       pname = "circular";
+       version = "0.4.0.3";
+       sha256 = "0mfsrf60cdw4c7lff8vmvkp5bj4kql46zp0f3fkx9xkf61zqkn3m";
+       libraryHaskellDepends = [ aeson base primitive vector ];
+       testHaskellDepends = [
+         aeson base hspec primitive QuickCheck quickcheck-instances vector
+       ];
+       benchmarkHaskellDepends = [ base criterion vector ];
+       description = "Circular fixed-sized mutable vectors";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = [ lib.maintainers.dschrempf ];
+     }) {};
+
   "circus" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, mtl, syb
      , text
···
     ({ mkDerivation, aeson, base-noprelude, bytestring, constraints
      , containers, criterion, cryptonite, data-default, directory
      , either, exceptions, file-embed, filepath, fmt, hedgehog, hex-text
-     , hspec, hspec-expectations, HUnit, lens, lorentz, MonadRandom
-     , morley, morley-client, morley-prelude, mtl, named, o-clock
+     , hspec-expectations, HUnit, lens, lorentz, MonadRandom, morley
+     , morley-client, morley-prelude, mtl, named, o-clock
      , optparse-applicative, safe-exceptions, servant-client
-     , servant-client-core, singletons, statistics, tagged, tasty
-     , tasty-ant-xml, tasty-discover, tasty-hedgehog, tasty-hunit-compat
-     , template-haskell, temporary, text, time, with-utf8
+     , servant-client-core, singletons, singletons-base, statistics
+     , tagged, tasty, tasty-ant-xml, tasty-discover, tasty-hedgehog
+     , tasty-hunit-compat, template-haskell, temporary, text, time
+     , with-utf8
      }:
      mkDerivation {
        pname = "cleveland";
-       version = "0.1.2";
-       sha256 = "0fci9g9fw0lg6xzb6jxqql6nda0by6p89mxdmwncs6dsh7c2lsaw";
+       version = "0.2.0";
+       sha256 = "1y99n14283vlgcy517bz1qcdaw5lad30lkg6yd4id7z6pfg9bl3d";
        libraryHaskellDepends = [
          aeson base-noprelude bytestring constraints containers criterion
          cryptonite data-default directory either exceptions file-embed fmt
-         hedgehog hex-text hspec hspec-expectations HUnit lens lorentz
-         MonadRandom morley morley-client morley-prelude mtl named o-clock
-         optparse-applicative safe-exceptions servant-client-core singletons
+         hedgehog hex-text HUnit lens lorentz MonadRandom morley
+         morley-client morley-prelude mtl named o-clock optparse-applicative
+         safe-exceptions servant-client-core singletons singletons-base
          statistics tagged tasty tasty-ant-xml tasty-hedgehog
-         tasty-hunit-compat template-haskell text time with-utf8
+         tasty-hunit-compat template-haskell temporary text time with-utf8
        ];
        testHaskellDepends = [
          base-noprelude either filepath fmt hedgehog hspec-expectations lens
          lorentz morley morley-client morley-prelude named o-clock
-         servant-client tasty tasty-hedgehog tasty-hunit-compat temporary
-         text time
+         servant-client tasty tasty-hedgehog tasty-hunit-compat text time
        ];
        testToolDepends = [ tasty-discover ];
        description = "Testing framework for Morley";
···
      }:
      mkDerivation {
        pname = "consumers";
-       version = "2.2.0.6";
-       sha256 = "16b21s3j4srjafam3d6s1zc9lwlk5ir875bnfcnjmc5717iv0k29";
+       version = "2.3.0.0";
+       sha256 = "0kx4kfs9sp9mkwxdwb0c2dicbxb7k4cyfmvqzln4vrzqxykc73wv";
        libraryHaskellDepends = [
          base containers exceptions extra hpqtypes lifted-base
          lifted-threads log-base monad-control monad-time mtl stm time
···
      }:
      mkDerivation {
        pname = "copilot";
-       version = "3.9";
-       sha256 = "0kryqpk4sn5gbpjpvzcdhd5yp5045cfr2c112df5vagd7gp4a4gd";
+       version = "3.10";
+       sha256 = "1xdd1f62r0zrkb4gvyl1r8c93zwf56ill2yflbdv8gjjrgc2np3r";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "copilot-c99" = callPackage
-    ({ mkDerivation, base, containers, copilot-core, directory
-     , filepath, language-c99, language-c99-simple, language-c99-util
-     , mtl, pretty
+    ({ mkDerivation, base, copilot-core, directory, filepath
+     , language-c99, language-c99-simple, mtl, pretty
      }:
      mkDerivation {
        pname = "copilot-c99";
-       version = "3.9";
-       sha256 = "1m915j72b6axbwnls4kcjcdpixxlrjxw4zpvdzq34jym5h2kpd78";
+       version = "3.10";
+       sha256 = "1zly8qmwyn996cjsrjnscmf3j1akvkk3sdd393skqdfylmvvs0gv";
        libraryHaskellDepends = [
-         base containers copilot-core directory filepath language-c99
-         language-c99-simple language-c99-util mtl pretty
+         base copilot-core directory filepath language-c99
+         language-c99-simple mtl pretty
        ];
        description = "A compiler for Copilot targeting C99";
        license = lib.licenses.bsd3;
···
      }) {};
 
   "copilot-core" = callPackage
-    ({ mkDerivation, base, dlist, HUnit, mtl, pretty, QuickCheck
+    ({ mkDerivation, base, dlist, HUnit, pretty, QuickCheck
      , test-framework, test-framework-hunit, test-framework-quickcheck2
      }:
      mkDerivation {
        pname = "copilot-core";
-       version = "3.9";
-       sha256 = "0haqyci12b44dn1hpfqp9hfyw949gl61yzxic8kznb0hl1h1sl5a";
-       libraryHaskellDepends = [ base dlist mtl pretty ];
+       version = "3.10";
+       sha256 = "1mxg8ldzkzf6wn08c6s35qx8ykx7689yi1fvl4slps2gdnnq7sj6";
+       libraryHaskellDepends = [ base dlist pretty ];
        testHaskellDepends = [
          base HUnit pretty QuickCheck test-framework test-framework-hunit
          test-framework-quickcheck2
···
      }:
      mkDerivation {
        pname = "copilot-language";
-       version = "3.9";
-       sha256 = "1041mm4c8zf7wlrcnfp97lsnr8qsmclr7y3qcawx9pmarwk8arg8";
+       version = "3.10";
+       sha256 = "060245sgdcwlxf2nj7j03h81ks1d9vc234p6v784gpvgwgh7h1qq";
        libraryHaskellDepends = [
          array base containers copilot-core copilot-theorem data-reify mtl
        ];
···
      }) {};
 
   "copilot-libraries" = callPackage
-    ({ mkDerivation, array, base, containers, copilot-language
-     , data-reify, mtl, parsec
-     }:
+    ({ mkDerivation, base, containers, copilot-language, mtl, parsec }:
      mkDerivation {
        pname = "copilot-libraries";
-       version = "3.9";
-       sha256 = "12h121zlq4xbkh947lkxdsjykf061rlmxkyhzyc2s2520fhkapx3";
+       version = "3.10";
+       sha256 = "1ix7p8bczxl1a5hyyh2608vy21qsvv3cq5p0g0i7ybkxagf0bgns";
        libraryHaskellDepends = [
-         array base containers copilot-language data-reify mtl parsec
+         base containers copilot-language mtl parsec
        ];
        description = "Libraries for the Copilot language";
        license = lib.licenses.bsd3;
···
      }) {};
 
   "copilot-theorem" = callPackage
-    ({ mkDerivation, ansi-terminal, base, bimap, bv-sized, containers
-     , copilot-core, data-default, directory, filepath, libBF, mtl
-     , panic, parameterized-utils, parsec, pretty, process, random
-     , transformers, what4, xml
+    ({ mkDerivation, base, bimap, bv-sized, containers, copilot-core
+     , data-default, directory, libBF, mtl, panic, parameterized-utils
+     , parsec, pretty, process, random, transformers, what4, xml
      }:
      mkDerivation {
        pname = "copilot-theorem";
-       version = "3.9";
-       sha256 = "1gnr6rd88gxs5wxkh6j28hqm81bj8b585n6ywm6s5p2wxgx0wzbn";
+       version = "3.10";
+       sha256 = "1xz32kwd9q90q5qsjwxppzxvcns5q51mzj49jsvxxv1rahqyb9cy";
        libraryHaskellDepends = [
-         ansi-terminal base bimap bv-sized containers copilot-core
-         data-default directory filepath libBF mtl panic parameterized-utils
-         parsec pretty process random transformers what4 xml
+         base bimap bv-sized containers copilot-core data-default directory
+         libBF mtl panic parameterized-utils parsec pretty process random
+         transformers what4 xml
        ];
        description = "k-induction for Copilot";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "core-telemetry";
-       version = "0.2.3.5";
-       sha256 = "11r1cnxfal8k8ya2qrkr1ywrpcx3f23rh3s1c1agv6q47qxi1kd9";
+       version = "0.2.3.7";
+       sha256 = "1pr0rvkbxn9sp496ax4s6464aac2q1aiqd618xnm80v07myyfic5";
        libraryHaskellDepends = [
          async base bytestring core-data core-program core-text exceptions
          http-streams io-streams mtl network-info random safe-exceptions
···
        maintainers = [ lib.maintainers.dschrempf ];
      }) {};
 
-  "covariance_0_2_0_0" = callPackage
+  "covariance_0_2_0_1" = callPackage
     ({ mkDerivation, base, glasso, hmatrix, statistics, tasty
      , tasty-hunit, vector
      }:
      mkDerivation {
        pname = "covariance";
-       version = "0.2.0.0";
-       sha256 = "1746jgqsnzlq23g5a5w91ms33czx4p0dsckhm76frpk8wq7g1dh9";
+       version = "0.2.0.1";
+       sha256 = "1qidlpg3g76vw390bdily0hdnzx2xlnb21ai11xzffwqywg5xpzh";
        libraryHaskellDepends = [ base glasso hmatrix statistics vector ];
        testHaskellDepends = [ base hmatrix tasty tasty-hunit ];
        description = "Well-conditioned estimation of large-dimensional covariance matrices";
···
        pname = "cron";
        version = "0.7.0";
        sha256 = "0f8jb2pxy89hkdnm20yz88b3j3vgh1a9c1dxiym3150izp34ikd5";
+       revision = "1";
+       editedCabalFile = "1xlfpdb7f5ycdn19f3a8c4lzr7w4cv02g6k83rrm4a8xbdda66hg";
        libraryHaskellDepends = [
          attoparsec base data-default-class mtl mtl-compat old-locale
          semigroups text time
···
        pname = "cryptonite";
        version = "0.29";
        sha256 = "13xhp3hshb8x06bw37kp16c9jpjmgfn06nkj9drz745fv8f04fnq";
+       revision = "1";
+       editedCabalFile = "1gaabsh8ihxcb6f3pplvpkplw7xbdxvflmc1wwnssx7s070n4323";
        libraryHaskellDepends = [
          base basement bytestring deepseq ghc-prim integer-gmp memory
        ];
···
      }) {};
 
   "currycarbon" = callPackage
-    ({ mkDerivation, base, doctest, filepath, math-functions
+    ({ mkDerivation, base, filepath, math-functions
      , optparse-applicative, parsec, vector
      }:
      mkDerivation {
        pname = "currycarbon";
-       version = "0.1.1.0";
-       sha256 = "0x328zl65hpaw93w9w167rc1sdpk7j7z4spwdmyj9wll6g57cwpb";
+       version = "0.2.1.1";
+       sha256 = "07r6pzwihdmw1c7rp3lvhka5zcm2pk1knkp8z2nzlf8a3szm63kq";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          base filepath math-functions parsec vector
        ];
        executableHaskellDepends = [ base filepath optparse-applicative ];
-       testHaskellDepends = [ base doctest ];
        description = "A package for simple, fast radiocarbon calibration";
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
···
        license = lib.licenses.asl20;
      }) {};
 
-  "dbus_1_2_24" = callPackage
+  "dbus_1_2_25" = callPackage
     ({ mkDerivation, base, bytestring, cereal, conduit, containers
      , criterion, deepseq, directory, exceptions, extra, filepath, lens
      , network, parsec, process, QuickCheck, random, resourcet, split
···
      }:
      mkDerivation {
        pname = "dbus";
-       version = "1.2.24";
-       sha256 = "0w7337hn9l6n35qr9h5lscd0csss72hz88n99vqg3z8dz6g0ha17";
+       version = "1.2.25";
+       sha256 = "10qijlyr7aj4f92ci6728rkhng1w8ng7l3csm2rs27dqvafhs3qy";
        libraryHaskellDepends = [
          base bytestring cereal conduit containers deepseq exceptions
          filepath lens network parsec random split template-haskell text
···
        maintainers = [ lib.maintainers.dschrempf ];
      }) {};
 
+  "dirichlet_0_1_0_7" = callPackage
+    ({ mkDerivation, base, hspec, log-domain, math-functions
+     , mwc-random, random, vector
+     }:
+     mkDerivation {
+       pname = "dirichlet";
+       version = "0.1.0.7";
+       sha256 = "1mphjhizkm8jrwf698kbi1gxgx01wvmxb7v4an9gnnpwyybmcy7w";
+       libraryHaskellDepends = [
+         base log-domain math-functions mwc-random random vector
+       ];
+       testHaskellDepends = [ base hspec log-domain random vector ];
+       description = "Multivariate Dirichlet distribution";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = [ lib.maintainers.dschrempf ];
+     }) {};
+
   "dirstream" = callPackage
     ({ mkDerivation, base, directory, pipes, pipes-safe, system-fileio
      , system-filepath, unix
···
        broken = true;
      }) {};
 
+  "ehlo" = callPackage
+    ({ mkDerivation, attoparsec, base, bytestring, hookup, HsOpenSSL
+     , network, text, transformers
+     }:
+     mkDerivation {
+       pname = "ehlo";
+       version = "0.1.0.0";
+       sha256 = "0svw1iw0if93fchd23y4j0a2d157i3s4lvjq57bvnpfn4bwn5167";
+       libraryHaskellDepends = [
+         attoparsec base bytestring hookup HsOpenSSL network text
+         transformers
+       ];
+       description = "Minimalistic SMTP client for Haskell";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "ehs" = callPackage
     ({ mkDerivation, base, bytestring, haskell-src-meta, parsec
      , template-haskell, text, transformers
···
        maintainers = [ lib.maintainers.dschrempf ];
      }) {};
 
+  "elynx_0_7_0_1" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, elynx-tools
+     , optparse-applicative, slynx, tlynx
+     }:
+     mkDerivation {
+       pname = "elynx";
+       version = "0.7.0.1";
+       sha256 = "1r2d3v2y4xmqf45d7649d54f1dsrywil2km40qx951adrawp8g0q";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         aeson base bytestring elynx-tools optparse-applicative slynx tlynx
+       ];
+       description = "Validate and (optionally) redo ELynx analyses";
+       license = lib.licenses.gpl3Plus;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "elynx";
+       maintainers = [ lib.maintainers.dschrempf ];
+     }) {};
+
   "elynx-markov" = callPackage
     ({ mkDerivation, async, attoparsec, base, bytestring, containers
      , elynx-seq, elynx-tools, hmatrix, hspec, integration
···
        maintainers = [ lib.maintainers.dschrempf ];
      }) {};
 
+  "elynx-markov_0_7_0_1" = callPackage
+    ({ mkDerivation, async, attoparsec, base, bytestring, containers
+     , elynx-seq, elynx-tools, hmatrix, hspec, integration
+     , math-functions, mwc-random, random, statistics, vector
+     }:
+     mkDerivation {
+       pname = "elynx-markov";
+       version = "0.7.0.1";
+       sha256 = "0dci3fpvyxjffn2lapdddj8flyk2id2b9z0shfidcknaghgig1gr";
+       libraryHaskellDepends = [
+         async attoparsec base bytestring containers elynx-seq hmatrix
+         integration math-functions mwc-random random statistics vector
+       ];
+       testHaskellDepends = [
+         base containers elynx-tools hmatrix hspec random vector
+       ];
+       benchmarkHaskellDepends = [ base ];
+       description = "Simulate molecular sequences along trees";
+       license = lib.licenses.gpl3Plus;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = [ lib.maintainers.dschrempf ];
+     }) {};
+
   "elynx-nexus" = callPackage
     ({ mkDerivation, attoparsec, base, bytestring, hspec }:
      mkDerivation {
···
        maintainers = [ lib.maintainers.dschrempf ];
      }) {};
 
+  "elynx-nexus_0_7_0_1" = callPackage
+    ({ mkDerivation, attoparsec, base, bytestring, hspec }:
+     mkDerivation {
+       pname = "elynx-nexus";
+       version = "0.7.0.1";
+       sha256 = "0rf1ydwhglcnvp3cdqhij859c3gn7l54nazw4501b6wj59ky7p75";
+       libraryHaskellDepends = [ attoparsec base bytestring ];
+       testHaskellDepends = [ base hspec ];
+       description = "Import and export Nexus files";
+       license = lib.licenses.gpl3Plus;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = [ lib.maintainers.dschrempf ];
+     }) {};
+
   "elynx-seq" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, bytestring, containers
      , elynx-tools, hspec, matrices, mwc-random, parallel, primitive
···
        maintainers = [ lib.maintainers.dschrempf ];
      }) {};
 
+  "elynx-seq_0_7_0_1" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, bytestring, containers
+     , elynx-tools, hspec, matrices, parallel, primitive, random, vector
+     , vector-th-unbox, word8
+     }:
+     mkDerivation {
+       pname = "elynx-seq";
+       version = "0.7.0.1";
+       sha256 = "1zjg9kayk97xqxpd6pryypmk9p69ylcyycfdzccj9pssqx99i5bi";
+       libraryHaskellDepends = [
+         aeson attoparsec base bytestring containers matrices parallel
+         primitive random vector vector-th-unbox word8
+       ];
+       testHaskellDepends = [
+         base bytestring elynx-tools hspec matrices vector
+       ];
+       description = "Handle molecular sequences";
+       license = lib.licenses.gpl3Plus;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = [ lib.maintainers.dschrempf ];
+     }) {};
+
   "elynx-tools" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, base16-bytestring
      , bytestring, cryptohash-sha256, directory, hmatrix, mwc-random
···
        maintainers = [ lib.maintainers.dschrempf ];
      }) {};
 
+  "elynx-tools_0_7_0_1" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, base16-bytestring
+     , bytestring, cryptohash-sha256, directory, hmatrix
+     , optparse-applicative, random, template-haskell, time
+     , transformers, zlib
+     }:
+     mkDerivation {
+       pname = "elynx-tools";
+       version = "0.7.0.1";
+       sha256 = "1lqsmpdwxg9b6v7hm8aizgwzcwp4kspvc6wphk6nlj34dxsjy673";
+       libraryHaskellDepends = [
+         aeson attoparsec base base16-bytestring bytestring
+         cryptohash-sha256 directory hmatrix optparse-applicative random
+         template-haskell time transformers zlib
+       ];
+       description = "Tools for ELynx";
+       license = lib.licenses.gpl3Plus;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = [ lib.maintainers.dschrempf ];
+     }) {};
+
   "elynx-tree" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, bytestring, comonad
      , containers, criterion, data-default, data-default-class, deepseq
···
        ];
        description = "Handle phylogenetic trees";
        license = lib.licenses.gpl3Plus;
+       maintainers = [ lib.maintainers.dschrempf ];
+     }) {};
+
+  "elynx-tree_0_7_0_1" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, bytestring, comonad
+     , containers, criterion, data-default, data-default-class, deepseq
+     , double-conversion, elynx-nexus, elynx-tools, hspec
+     , math-functions, microlens, parallel, QuickCheck
+     , quickcheck-classes, random, statistics
+     }:
+     mkDerivation {
+       pname = "elynx-tree";
+       version = "0.7.0.1";
+       sha256 = "0f9fmwv0580027qhlcffkzvx55nccx43klgkdbjnrhdqvd7h5a1s";
+       libraryHaskellDepends = [
+         aeson attoparsec base bytestring comonad containers
+         data-default-class deepseq double-conversion elynx-nexus
+         math-functions parallel random statistics
+       ];
+       testHaskellDepends = [
+         attoparsec base bytestring containers data-default elynx-tools
+         hspec QuickCheck quickcheck-classes
+       ];
+       benchmarkHaskellDepends = [
+         base criterion elynx-tools microlens parallel random
+       ];
+       description = "Handle phylogenetic trees";
+       license = lib.licenses.gpl3Plus;
+       hydraPlatforms = lib.platforms.none;
        maintainers = [ lib.maintainers.dschrempf ];
      }) {};
 
···
        ];
        description = "Monoidal Quasiquote Interpolation";
        license = "BSD-2-Clause-Patent";
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "exotic-list-monads" = callPackage
···
      }:
      mkDerivation {
        pname = "flatparse";
-       version = "0.3.4.0";
-       sha256 = "0q0pn2dwkril6gqh2lzczb5a15jmnhq21y76aljsmab2r3q9yahm";
+       version = "0.3.5.1";
+       sha256 = "1gv6c5qas3n9hxfm2anj99df9m960grhi7csb5g3w9w4lshcw9vz";
        libraryHaskellDepends = [
          base bytestring containers integer-gmp template-haskell
        ];
···
 
   "freckle-app" = callPackage
     ({ mkDerivation, aeson, base, Blammo, bugsnag, bytestring
-     , case-insensitive, conduit, containers, datadog, directory, dlist
-     , doctest, ekg-core, envparse, errors, exceptions, filepath, Glob
-     , hashable, hspec, hspec-core, hspec-expectations-lifted
+     , case-insensitive, conduit, containers, datadog, directory
+     , doctest, ekg-core, envparse, errors, exceptions, extra, filepath
+     , Glob, hashable, hspec, hspec-core, hspec-expectations-lifted
      , hspec-junit-formatter, http-client, http-conduit
      , http-link-header, http-types, immortal, lens, lens-aeson
-     , load-env, memcache, monad-control, monad-logger, MonadRandom, mtl
-     , network-uri, persistent, persistent-postgresql, postgresql-simple
-     , primitive, process, resource-pool, retry, safe, scientist
-     , semigroupoids, template-haskell, temporary, text, time
+     , load-env, memcache, monad-control, MonadRandom, mtl, network-uri
+     , path-pieces, persistent, persistent-postgresql, postgresql-simple
+     , primitive, process, QuickCheck, resource-pool, retry, safe
+     , scientist, semigroupoids, template-haskell, temporary, text, time
      , transformers, transformers-base, typed-process, unliftio
      , unliftio-core, unordered-containers, vector, wai, wai-extra, yaml
      , yesod-core
      }:
      mkDerivation {
        pname = "freckle-app";
-       version = "1.3.0.0";
-       sha256 = "1h2ckdjq4h7qv7r5dm28gbs5ja125wi2inzjg3436css9qn1s7v9";
+       version = "1.5.0.0";
+       sha256 = "09lrzca5yi67irbjlypqs2pd16swgw0wls5k5d08sipq3q1h9phd";
        libraryHaskellDepends = [
          aeson base Blammo bugsnag bytestring case-insensitive conduit
-         containers datadog dlist doctest ekg-core envparse errors
-         exceptions filepath Glob hashable hspec hspec-core
+         containers datadog doctest ekg-core envparse errors exceptions
+         extra filepath Glob hashable hspec hspec-core
          hspec-expectations-lifted hspec-junit-formatter http-client
          http-conduit http-link-header http-types immortal lens load-env
-         memcache monad-control monad-logger MonadRandom mtl network-uri
+         memcache monad-control MonadRandom mtl network-uri path-pieces
          persistent persistent-postgresql postgresql-simple primitive
          resource-pool retry safe scientist semigroupoids template-haskell
          text time transformers transformers-base typed-process unliftio
···
          yesod-core
        ];
        testHaskellDepends = [
-         aeson base bytestring directory errors hspec http-types lens
-         lens-aeson memcache mtl postgresql-simple process temporary text
-         time wai wai-extra
+         aeson base Blammo bytestring directory errors hspec http-types lens
+         lens-aeson memcache postgresql-simple process QuickCheck temporary
+         text time wai wai-extra
        ];
        description = "Haskell application toolkit used at Freckle";
        license = lib.licenses.mit;
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "fused-effects_1_1_2_0" = callPackage
+    ({ mkDerivation, base, containers, hedgehog, hedgehog-fn
+     , inspection-testing, markdown-unlit, tasty-bench, transformers
+     , unliftio-core
+     }:
+     mkDerivation {
+       pname = "fused-effects";
+       version = "1.1.2.0";
+       sha256 = "0wzlzd8ccilhlhhk713hziwvdja78lm9yz9v5rfl1w214g6rlcgx";
+       libraryHaskellDepends = [ base transformers unliftio-core ];
+       testHaskellDepends = [
+         base containers hedgehog hedgehog-fn inspection-testing
+         transformers
+       ];
+       testToolDepends = [ markdown-unlit ];
+       benchmarkHaskellDepends = [ base tasty-bench transformers ];
+       description = "A fast, flexible, fused effect system";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "fused-effects-exceptions" = callPackage
     ({ mkDerivation, base, fused-effects, markdown-unlit, tasty
      , tasty-hunit, transformers
···
        pname = "fused-effects-th";
        version = "0.1.0.3";
        sha256 = "01z3fjhbgq2if08fj72mc9xkxg0l9g3nfhwynzrhfwmqwcd9l3dp";
+       revision = "1";
+       editedCabalFile = "0av6mgwx56drmfjh3wqy1wrfi0xirx7c83kgmaq2qc62qcjkc5cw";
        libraryHaskellDepends = [ base fused-effects template-haskell ];
        testHaskellDepends = [
          base fused-effects tasty tasty-hunit template-haskell
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "ghc-lib_9_2_3_20220527" = callPackage
+  "ghc-lib_9_2_3_20220709" = callPackage
     ({ mkDerivation, alex, array, base, binary, bytestring, containers
      , deepseq, directory, exceptions, filepath, ghc-lib-parser
      , ghc-prim, happy, hpc, parsec, pretty, process, rts, time
···
      }:
      mkDerivation {
        pname = "ghc-lib";
-       version = "9.2.3.20220527";
-       sha256 = "0ldafrp5j91cjqgh78vfqjmf1ywj1cjhjyxch9yqlj6yz4r6gqi4";
+       version = "9.2.3.20220709";
+       sha256 = "12073grb3wykvgv3kagaymarklsjxns16y0n9na3cdbmhgxazrvw";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq directory
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "ghc-lib-parser_9_2_3_20220527" = callPackage
+  "ghc-lib-parser_9_2_3_20220709" = callPackage
     ({ mkDerivation, alex, array, base, binary, bytestring, containers
      , deepseq, directory, exceptions, filepath, ghc-prim, happy, parsec
      , pretty, process, time, transformers, unix
      }:
      mkDerivation {
        pname = "ghc-lib-parser";
-       version = "9.2.3.20220527";
-       sha256 = "0w7rnpjyrl8h8rxplfwqdsj9g4q8y8fz9rs8mshil1f4wxnc6nmx";
+       version = "9.2.3.20220709";
+       sha256 = "04xxjvnr3mas1nf4y68x50jpjs7gzw0yrlkn61gqlzgbq5rqjjyl";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq directory
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "ghc-lib-parser-ex_9_2_0_4" = callPackage
+    ({ mkDerivation, base, bytestring, containers, directory, extra
+     , filepath, ghc-lib-parser, tasty, tasty-hunit, uniplate
+     }:
+     mkDerivation {
+       pname = "ghc-lib-parser-ex";
+       version = "9.2.0.4";
+       sha256 = "138wkpy7qpdkp07028flab3lwq4b3mns0qcrkfrhclixlz8pi74v";
+       libraryHaskellDepends = [
+         base bytestring containers ghc-lib-parser uniplate
+       ];
+       testHaskellDepends = [
+         base directory extra filepath ghc-lib-parser tasty tasty-hunit
+         uniplate
+       ];
+       description = "Algorithms on GHC parse trees";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "ghc-lib-parser-ex_9_2_1_0" = callPackage
     ({ mkDerivation, base, bytestring, containers, directory, extra
      , filepath, ghc-lib-parser, tasty, tasty-hunit, uniplate
···
     ({ mkDerivation, base, ghc, transformers }:
      mkDerivation {
        pname = "ghc-tcplugin-api";
-       version = "0.7.1.0";
-       sha256 = "02qmqmhlcfn53hs7wl92r65r6dcg01fdrwqn4capjlxs1bdsfpbr";
+       version = "0.8.0.0";
+       sha256 = "1xk6ircvrx0dy0dff5vlxz7sjf1i1dkpkd3vaifc2sifmb9m5j3y";
        libraryHaskellDepends = [ base ghc transformers ];
        description = "An API for type-checker plugins";
        license = lib.licenses.bsd3;
···
        pname = "ghcide";
        version = "1.7.0.0";
        sha256 = "097vpp1gds36ijldz29bsk71pxc82l966ka578cxsrcdc3g3ll1b";
-       revision = "1";
-       editedCabalFile = "0xvszq1jad6126vg73qys8z9jys7b1gs75fsaa4kq5dnrfg8hpx3";
+       revision = "2";
+       editedCabalFile = "1j4jzqhghjlzsyfn9jh70ah73nydjp9sjabpc041q5fv17s9b65z";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "ghcup";
        version = "0.1.17.10";
        sha256 = "18vskipglwds41l1gr1ks7h1h30hasrjdhpmcdm4nhg0ifmjzsag";
+       revision = "1";
+       editedCabalFile = "0pk2s6mcdby4553zcx08pgxcq854rzjkinvmyqjvc8yxjlb6j76r";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        badPlatforms = lib.platforms.darwin;
      }) {inherit (pkgs) gtk3; inherit (pkgs) libdbusmenu-gtk3;};
 
+  "gi-freetype2" = callPackage
+    ({ mkDerivation, base, bytestring, Cabal, containers, freetype
+     , haskell-gi, haskell-gi-base, haskell-gi-overloading, text
+     , transformers
+     }:
+     mkDerivation {
+       pname = "gi-freetype2";
+       version = "2.0.1";
+       sha256 = "00sgy9ppwf7im98vrcjp0ihb3zgaxcsm8klqv4h3z8n8ypv44ir2";
+       setupHaskellDepends = [ base Cabal haskell-gi ];
+       libraryHaskellDepends = [
+         base bytestring containers haskell-gi haskell-gi-base
+         haskell-gi-overloading text transformers
+       ];
+       libraryPkgconfigDepends = [ freetype ];
+       description = "freetype2 bindings";
+       license = lib.licenses.lgpl21Only;
+     }) {inherit (pkgs) freetype;};
+
   "gi-gdk" = callPackage
     ({ mkDerivation, base, bytestring, Cabal, containers, gi-cairo
      , gi-gdkpixbuf, gi-gio, gi-glib, gi-gobject, gi-pango, gtk3
···
        license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) harfbuzz; harfbuzz-gobject = null;};
 
+  "gi-harfbuzz_0_0_6" = callPackage
+    ({ mkDerivation, base, bytestring, Cabal, containers, gi-freetype2
+     , gi-glib, gi-gobject, harfbuzz, harfbuzz-gobject, haskell-gi
+     , haskell-gi-base, haskell-gi-overloading, text, transformers
+     }:
+     mkDerivation {
+       pname = "gi-harfbuzz";
+       version = "0.0.6";
+       sha256 = "05jmh8mhx17jys9620shbkz1nc9jvfjr7snmpq2lxpvq2fw813ss";
+       setupHaskellDepends = [
+         base Cabal gi-freetype2 gi-glib gi-gobject haskell-gi
+       ];
+       libraryHaskellDepends = [
+         base bytestring containers gi-freetype2 gi-glib gi-gobject
+         haskell-gi haskell-gi-base haskell-gi-overloading text transformers
+       ];
+       libraryPkgconfigDepends = [ harfbuzz harfbuzz-gobject ];
+       description = "HarfBuzz bindings";
+       license = lib.licenses.lgpl21Only;
+       hydraPlatforms = lib.platforms.none;
+     }) {inherit (pkgs) harfbuzz; harfbuzz-gobject = null;};
+
   "gi-ibus" = callPackage
     ({ mkDerivation, base, bytestring, Cabal, containers, gi-gio
      , gi-glib, gi-gobject, haskell-gi, haskell-gi-base
···
      }) {inherit (pkgs) ostree;};
 
   "gi-pango" = callPackage
-    ({ mkDerivation, base, bytestring, Cabal, cairo, containers
+    ({ mkDerivation, base, bytestring, Cabal, cairo, containers, gi-gio
      , gi-glib, gi-gobject, gi-harfbuzz, haskell-gi, haskell-gi-base
      , haskell-gi-overloading, pango, text, transformers
      }:
      mkDerivation {
        pname = "gi-pango";
-       version = "1.0.25";
-       sha256 = "1m1n9jcpr8j4k7212yv4asm62w0pp9wlikl164xfgv8yfa3gh7s0";
+       version = "1.0.26";
+       sha256 = "1x1d4v5g6sxw12pcq7qrv4kyr7wkv755wqzdal2z9l2qzr1bqssz";
        setupHaskellDepends = [
-         base Cabal gi-glib gi-gobject gi-harfbuzz haskell-gi
+         base Cabal gi-gio gi-glib gi-gobject gi-harfbuzz haskell-gi
        ];
        libraryHaskellDepends = [
-         base bytestring containers gi-glib gi-gobject gi-harfbuzz
+         base bytestring containers gi-gio gi-glib gi-gobject gi-harfbuzz
          haskell-gi haskell-gi-base haskell-gi-overloading text transformers
        ];
        libraryPkgconfigDepends = [ cairo pango ];
···
      }:
      mkDerivation {
        pname = "hadolint";
-       version = "2.10.0";
-       sha256 = "19szxwz633n8zk0zm9hzw029npy9my84kdygxv9jbmy69ndyw9d6";
+       version = "2.11.0";
+       sha256 = "1k5xjy064q6v306kaqkglkwzk5qwnljs7x550rxjk6012d8allcm";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "haskell-language-server";
        version = "1.7.0.0";
        sha256 = "1p5dr5j7vl86a4ig6y6cxf7rk8lswxsdxq9029sydghnyl3kaf3f";
+       revision = "1";
+       editedCabalFile = "0ds5za9xgn5qgmzdy0rps0ywsqy3f12szmi77kwv61lp4y7khwpv";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        description = "Web development micro framework for haskell with typesafe URLs";
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "hell" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
+  "heterocephalus_1_0_5_7" = callPackage
+    ({ mkDerivation, base, blaze-html, blaze-markup, containers, dlist
+     , doctest, Glob, mtl, parsec, shakespeare, template-haskell
+     , template-haskell-compat-v0208, text, transformers
+     }:
+     mkDerivation {
+       pname = "heterocephalus";
+       version = "1.0.5.7";
+       sha256 = "1dxvmkrkhqfapbywr202s4182r3nqlciqvbixd5g7c851qwfvpj2";
+       libraryHaskellDepends = [
+         base blaze-html blaze-markup containers dlist mtl parsec
+         shakespeare template-haskell template-haskell-compat-v0208 text
+         transformers
+       ];
+       testHaskellDepends = [ base doctest Glob ];
+       description = "A type-safe template engine for working with front end development tools";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "heterogeneous-list-literals" = callPackage
     ({ mkDerivation, base, Only }:
      mkDerivation {
···
        mainProgram = "heyefi";
        broken = true;
      }) {};
+
+  "heystone" = callPackage
+    ({ mkDerivation, base, bytestring, c2hs, keystone, transformers }:
+     mkDerivation {
+       pname = "heystone";
+       version = "0.1.0";
+       sha256 = "0vq39mdiyd2ck9sah2w36g1caiq39qbm1qjhag0hfz99mf4x2ag7";
+       libraryHaskellDepends = [ base bytestring transformers ];
+       libraryPkgconfigDepends = [ keystone ];
+       libraryToolDepends = [ c2hs ];
+       description = "Haskell bindings for the Keystone assembler framework";
+       license = lib.licenses.gpl2Only;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {inherit (pkgs) keystone;};
 
   "heyting-algebras" = callPackage
     ({ mkDerivation, base, containers, free-algebras, hashable
···
      }:
      mkDerivation {
        pname = "hindent";
-       version = "5.3.2";
-       sha256 = "129gkn8qg68wsd60mq8yk7hrqsc8sd8v56xn41m5ii3hriq1mmv7";
-       isLibrary = true;
-       isExecutable = true;
-       enableSeparateDataOutput = true;
-       libraryHaskellDepends = [
-         base bytestring Cabal containers directory exceptions filepath
-         haskell-src-exts monad-loops mtl text transformers utf8-string yaml
-       ];
-       executableHaskellDepends = [
-         base bytestring deepseq directory exceptions ghc-prim
-         haskell-src-exts optparse-applicative path path-io text
-         transformers unix-compat utf8-string yaml
-       ];
-       testHaskellDepends = [
-         base bytestring deepseq Diff directory exceptions haskell-src-exts
-         hspec monad-loops mtl utf8-string
-       ];
-       benchmarkHaskellDepends = [
-         base bytestring criterion deepseq directory exceptions ghc-prim
-         haskell-src-exts mtl utf8-string
-       ];
-       description = "Extensible Haskell pretty printer";
-       license = lib.licenses.bsd3;
-       mainProgram = "hindent";
-     }) {};
-
-  "hindent_5_3_4" = callPackage
-    ({ mkDerivation, base, bytestring, Cabal, containers, criterion
-     , deepseq, Diff, directory, exceptions, filepath, ghc-prim
-     , haskell-src-exts, hspec, monad-loops, mtl, optparse-applicative
-     , path, path-io, text, transformers, unix-compat, utf8-string, yaml
-     }:
-     mkDerivation {
-       pname = "hindent";
        version = "5.3.4";
        sha256 = "1pc20iza3v0ljzbx6cycm1j1kbmz8h95xwfq47fd6zfmsrx9w6vn";
        isLibrary = true;
···
        ];
        description = "Extensible Haskell pretty printer";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
        mainProgram = "hindent";
      }) {};
 
···
        maintainers = [ lib.maintainers.peti ];
      }) {};
 
-  "hledger_1_26" = callPackage
+  "hledger_1_26_1" = callPackage
     ({ mkDerivation, aeson, ansi-terminal, base, bytestring, cmdargs
      , containers, data-default, Decimal, Diff, directory, extra
      , filepath, githash, hashable, haskeline, hledger-lib, lucid
···
      }:
      mkDerivation {
        pname = "hledger";
-       version = "1.26";
-       sha256 = "15gl5nms9yn1jr8di9sj9r3l9ysihvdn6m4c962y6ka8v695ppg2";
+       version = "1.26.1";
+       sha256 = "0iz26pagpc6l94g6nzbcv4rvfch76vx8zbd7i2s4yxbac7ng4ni4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.gpl3Only;
      }) {};
 
-  "hledger-lib_1_26" = callPackage
+  "hledger-lib_1_26_1" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, array, base
      , blaze-markup, bytestring, call-stack, cassava, cassava-megaparsec
      , cmdargs, containers, data-default, Decimal, directory, doclayout
···
      }:
      mkDerivation {
        pname = "hledger-lib";
-       version = "1.26";
-       sha256 = "159s1gqd14d9khlvb9145dbi5qmgqzhla4fixfp28bxyszy363py";
+       version = "1.26.1";
+       sha256 = "19axr2bbl13jd5g857jzbvcqqaas5x8xilmqhcmrwrns5i6g17ic";
        libraryHaskellDepends = [
          aeson aeson-pretty ansi-terminal array base blaze-markup bytestring
          call-stack cassava cassava-megaparsec cmdargs containers
···
        maintainers = [ lib.maintainers.peti ];
      }) {};
 
-  "hledger-ui_1_26" = callPackage
+  "hledger-ui_1_26_1" = callPackage
     ({ mkDerivation, ansi-terminal, async, base, brick, cmdargs
      , containers, data-default, directory, doclayout, extra, filepath
      , fsnotify, hledger, hledger-lib, megaparsec, microlens
···
      }:
      mkDerivation {
        pname = "hledger-ui";
-       version = "1.26";
-       sha256 = "09x45yvc266p2v8aby8iy0ric9lmxgcvnxkvl2j3v6i7x2nad498";
-       revision = "1";
-       editedCabalFile = "0dczpzkayd56h323jk76vc4fkxp9k1gm3iywsvg2m2hlhi0kc9h4";
+       version = "1.26.1";
+       sha256 = "0gbysjc8vknlsd0rl60iz3da2zpyhwvq5gj9bpl2h4r0hf1ymplb";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        maintainers = [ lib.maintainers.peti ];
      }) {};
 
-  "hledger-web_1_26" = callPackage
+  "hledger-web_1_26_1" = callPackage
     ({ mkDerivation, aeson, base, base64, blaze-html, blaze-markup
      , bytestring, case-insensitive, clientsession, cmdargs, conduit
      , conduit-extra, containers, data-default, Decimal, directory
···
      }:
      mkDerivation {
        pname = "hledger-web";
-       version = "1.26";
-       sha256 = "1h4h98kv645gzb4dyhfwpa7f0xpci89la247z9aqng57d84w98ka";
+       version = "1.26.1";
+       sha256 = "1iz6s33p5hi4r0rgi6z0xb49052ipzxrshwiz7a398jpcqfd5c72";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        maintainers = [ lib.maintainers.maralorn ];
      }) {};
 
-  "hlint_3_4" = callPackage
+  "hlint_3_4_1" = callPackage
     ({ mkDerivation, aeson, ansi-terminal, base, bytestring, cmdargs
-     , containers, cpphs, data-default, directory, extra, file-embed
-     , filepath, filepattern, ghc-lib-parser, ghc-lib-parser-ex
-     , hscolour, process, refact, text, transformers, uniplate
-     , unordered-containers, utf8-string, vector, yaml
+     , containers, cpphs, data-default, deriving-aeson, directory, extra
+     , file-embed, filepath, filepattern, ghc-lib-parser
+     , ghc-lib-parser-ex, hscolour, process, refact, text, transformers
+     , uniplate, unordered-containers, utf8-string, vector, yaml
      }:
      mkDerivation {
        pname = "hlint";
-       version = "3.4";
-       sha256 = "15cfvch0yrzkl7qr87966amdsy05a7axvjc6wmw99ys9d5fn3z3n";
+       version = "3.4.1";
+       sha256 = "0bkk03c9hacvfd73dk89g4r81b50g7pjgw5pavldali4qwss34cz";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson ansi-terminal base bytestring cmdargs containers cpphs
-         data-default directory extra file-embed filepath filepattern
-         ghc-lib-parser ghc-lib-parser-ex hscolour process refact text
-         transformers uniplate unordered-containers utf8-string vector yaml
+         data-default deriving-aeson directory extra file-embed filepath
+         filepattern ghc-lib-parser ghc-lib-parser-ex hscolour process
+         refact text transformers uniplate unordered-containers utf8-string
+         vector yaml
        ];
        executableHaskellDepends = [ base ];
        description = "Source code suggestions";
···
        pname = "hls-eval-plugin";
        version = "1.2.2.0";
        sha256 = "17si94yzxz19hcddn57wf0npxc9m9vzb08b2gph7pkbxprsksb6g";
+       revision = "1";
+       editedCabalFile = "1hilh189fmqbm65cmsn2j70n83dq356xq1r6mf893chxwins57p3";
        libraryHaskellDepends = [
          aeson base containers data-default deepseq Diff directory dlist
          extra filepath ghc ghc-boot-th ghc-paths ghcide hashable hls-graph
···
        pname = "hls-fourmolu-plugin";
        version = "1.0.3.0";
        sha256 = "103rndxbmv72ghbh685766498j9rqnmgdwsrswk5nrf7afwd9x8w";
+       revision = "1";
+       editedCabalFile = "1y7jbjzi68x8xxqwhczn4z4nqis2gczggzv65fyvxhlzympsrg28";
        libraryHaskellDepends = [
          base filepath fourmolu ghc ghc-boot-th ghcide hls-plugin-api lens
          lsp process-extras text
···
     ({ mkDerivation, base, wirelesstools }:
      mkDerivation {
        pname = "iwlib";
-       version = "0.1.0";
-       sha256 = "0khmfwql4vwj55idsxmhjhrbqzfir3g9wm5lmpvnf77mm95cfpdz";
+       version = "0.1.2";
+       sha256 = "0iyibjiviqkh79bifnpnzs2cl8790hhbhh8wp10l8nl7wbwzppzx";
        libraryHaskellDepends = [ base ];
        librarySystemDepends = [ wirelesstools ];
        description = "Bindings for the iw C library";
···
      }) {};
 
   "libsecp256k1" = callPackage
-    ({ mkDerivation, base, base16, bytestring, cereal, deepseq, entropy
-     , hashable, hspec, hspec-discover, HUnit, monad-par, mtl
-     , QuickCheck, secp256k1, secp256k1-haskell, string-conversions
-     , unliftio-core
+    ({ mkDerivation, base, bytestring, entropy, hedgehog, hspec, HUnit
+     , memory, secp256k1, transformers
      }:
      mkDerivation {
        pname = "libsecp256k1";
-       version = "0.0.1";
-       sha256 = "1bjrnh3y37iij5y8g3fpl0nl2102n1h6q09xsgkdrxgcbsdbkl0j";
+       version = "0.1.0";
+       sha256 = "0b66h6rfsv1dfdmyqmmkdpg4aj08g2aajgwzn04h1wb4sgn11rxl";
        libraryHaskellDepends = [
-         base base16 bytestring cereal deepseq entropy hashable QuickCheck
-         string-conversions unliftio-core
+         base bytestring entropy hedgehog memory transformers
        ];
        libraryPkgconfigDepends = [ secp256k1 ];
        testHaskellDepends = [
-         base base16 bytestring cereal deepseq entropy hashable hspec HUnit
-         monad-par mtl QuickCheck secp256k1-haskell string-conversions
-         unliftio-core
+         base bytestring entropy hedgehog hspec HUnit memory transformers
        ];
-       testToolDepends = [ hspec-discover ];
        description = "Bindings for secp256k1";
        license = lib.licenses.mit;
      }) {inherit (pkgs) secp256k1;};
···
        license = lib.licenses.asl20;
      }) {};
 
+  "linux-capabilities_0_1_1_0" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "linux-capabilities";
+       version = "0.1.1.0";
+       sha256 = "0j5q4ddsg3bmkhb82da39rj3h1knhxm74z3jknprzwhavz2wxcn6";
+       libraryHaskellDepends = [ base ];
+       description = "Linux capabilities Haskell data type";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "linux-cgroup" = callPackage
     ({ mkDerivation, base, filepath }:
      mkDerivation {
···
        license = lib.licenses.mit;
      }) {};
 
+  "list-t_1_0_5_3" = 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.3";
+       sha256 = "0j3fgfa84f2cw87j80v5sq82s42505v82pwxgjyhbiflaxjd7wxd";
+       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
···
     ({ mkDerivation, aeson-pretty, base-noprelude, bimap, bytestring
      , constraints, containers, cryptonite, data-default
      , first-class-families, fmt, lens, morley, morley-prelude, mtl
-     , named, optparse-applicative, singletons, template-haskell, text
-     , text-manipulate, unordered-containers, vinyl, with-utf8
+     , named, optparse-applicative, singletons, singletons-base
+     , template-haskell, text, text-manipulate, unordered-containers
+     , vinyl, with-utf8
      }:
      mkDerivation {
        pname = "lorentz";
-       version = "0.13.4";
-       sha256 = "10lldpp9618ybgwcy8zvcc8m2q5i0kslxfrd2yhis1d1gd40wglb";
+       version = "0.14.0";
+       sha256 = "1f9yhkg8q4bzsbrk6srgkaqlykj00i7jsvdqvjp9b2nd6mn7cf1j";
        libraryHaskellDepends = [
          aeson-pretty base-noprelude bimap bytestring constraints containers
          cryptonite data-default first-class-families fmt lens morley
          morley-prelude mtl named optparse-applicative singletons
-         template-haskell text text-manipulate unordered-containers vinyl
-         with-utf8
+         singletons-base template-haskell text text-manipulate
+         unordered-containers vinyl with-utf8
        ];
        description = "EDSL for the Michelson Language";
        license = lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "massiv-persist";
-       version = "1.0.0.2";
-       sha256 = "1hqmwbrxv664y4rfm37ziym25l9218pd21lz4180c0k3hfpdfsxy";
-       revision = "1";
-       editedCabalFile = "06vlaj1f4619knz7k087dppihas4cglvyy9iwg4bkgvagb968aj4";
-       libraryHaskellDepends = [
-         base bytestring deepseq massiv persist primitive
-       ];
-       testHaskellDepends = [
-         base doctest hspec massiv massiv-test persist QuickCheck
-       ];
-       testToolDepends = [ hspec-discover ];
-       description = "Compatibility of 'massiv' with 'persist'";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
-     }) {};
-
-  "massiv-persist_1_0_0_3" = callPackage
-    ({ mkDerivation, base, bytestring, deepseq, doctest, hspec
-     , hspec-discover, massiv, massiv-test, persist, primitive
-     , QuickCheck
-     }:
-     mkDerivation {
-       pname = "massiv-persist";
        version = "1.0.0.3";
        sha256 = "0qpnrqjhj6y2spg9izxc3jzqs4jcqzn6zlgi87816ycpdgxq6s02";
        libraryHaskellDepends = [
···
        maintainers = [ lib.maintainers.dschrempf ];
      }) {};
 
-  "mcmc_0_6_2_5" = callPackage
-    ({ mkDerivation, aeson, async, base, bytestring, circular
-     , containers, covariance, criterion, data-default, deepseq
-     , directory, dirichlet, double-conversion, hmatrix, hspec
+  "mcmc_0_7_0_1" = callPackage
+    ({ mkDerivation, ad, aeson, async, base, bytestring, circular
+     , containers, covariance, criterion, data-default, directory
+     , dirichlet, double-conversion, fixed-vector, hmatrix, hspec
      , log-domain, math-functions, microlens, mwc-random, parallel
-     , pretty-show, primitive, statistics, time, transformers, vector
-     , zlib
+     , pretty-show, primitive, random, splitmix, statistics, time
+     , transformers, vector, zlib
      }:
      mkDerivation {
        pname = "mcmc";
-       version = "0.6.2.5";
-       sha256 = "1yx72if0411pxxxqipz7dpmmn8hwmhgh9vsmw0a0za0niq8lmsm0";
+       version = "0.7.0.1";
+       sha256 = "0v480m7zc6rh97j4hxg6wslk6b5i24fl4xsr9bmb85kkzmpn8fbk";
        libraryHaskellDepends = [
-         aeson async base bytestring circular containers covariance
-         data-default deepseq directory dirichlet double-conversion hmatrix
+         ad aeson async base bytestring circular containers covariance
+         data-default directory dirichlet double-conversion hmatrix
          log-domain math-functions microlens mwc-random parallel pretty-show
-         primitive statistics time transformers vector zlib
+         primitive random splitmix statistics time transformers vector zlib
        ];
-       testHaskellDepends = [ base hspec mwc-random statistics ];
+       testHaskellDepends = [ base hspec random statistics ];
        benchmarkHaskellDepends = [
-         base criterion math-functions microlens mwc-random
+         aeson base criterion fixed-vector math-functions random vector
        ];
        description = "Sample from a posterior using Markov chain Monte Carlo";
        license = lib.licenses.gpl3Plus;
···
      }:
      mkDerivation {
        pname = "minimorph";
-       version = "0.3.0.0";
-       sha256 = "1jq2yrvhknnbc4b44nk2k6ynivn6s2j43w8bq1vi8gix7k4sazf4";
-       libraryHaskellDepends = [ base text ];
-       testHaskellDepends = [
-         base HUnit test-framework test-framework-hunit text
-       ];
-       description = "English spelling functions with an emphasis on simplicity";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "minimorph_0_3_0_1" = callPackage
-    ({ mkDerivation, base, HUnit, test-framework, test-framework-hunit
-     , text
-     }:
-     mkDerivation {
-       pname = "minimorph";
        version = "0.3.0.1";
        sha256 = "05z2y36q2m7lvrqnv5q40r8nr09q7bfbjvi5nca62xlnzxw1gy0g";
        libraryHaskellDepends = [ base text ];
···
        ];
        description = "English spelling functions with an emphasis on simplicity";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "minimung" = callPackage
···
      }:
      mkDerivation {
        pname = "miniutter";
-       version = "0.5.1.1";
-       sha256 = "126gwbii4j8j778h7c8vwapn6dya8phbjja37pys4kly0p877mp4";
-       enableSeparateDataOutput = true;
-       libraryHaskellDepends = [ base binary containers minimorph text ];
-       testHaskellDepends = [
-         base containers HUnit test-framework test-framework-hunit text
-       ];
-       description = "Simple English clause creation from arbitrary words";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "miniutter_0_5_1_2" = callPackage
-    ({ mkDerivation, base, binary, containers, HUnit, minimorph
-     , test-framework, test-framework-hunit, text
-     }:
-     mkDerivation {
-       pname = "miniutter";
        version = "0.5.1.2";
        sha256 = "04xpb9jyhvi8cs61xv3192kwis4nh1dib4s33c747j8yfg3q90m6";
        enableSeparateDataOutput = true;
···
        ];
        description = "Simple English clause creation from arbitrary words";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "minizinc-process" = callPackage
···
      }:
      mkDerivation {
        pname = "monad-logger-aeson";
-       version = "0.3.0.2";
-       sha256 = "1y5iw0k9y8i4sgak04nh6fbl4ahljy7av8pn4fq09827v54qgx70";
+       version = "0.3.1.0";
+       sha256 = "1j5gxmzqblqqbdf1xdmi2j0s89hhc28bv8jsbx114wdqyl9v4nb5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
 
   "morley" = callPackage
     ({ mkDerivation, aeson, aeson-casing, aeson-pretty, base-noprelude
-     , base58-bytestring, binary, bytestring, constraints, containers
-     , crypto-sodium, cryptonite, data-default, Diff, elliptic-curve
-     , first-class-families, fmt, galois-field, generic-deriving, gitrev
-     , haskeline, hex-text, lens, megaparsec, memory, MonadRandom
-     , morley-prelude, mtl, named, optparse-applicative, pairing
-     , parser-combinators, scientific, semigroups, show-type, singletons
-     , syb, template-haskell, text, text-manipulate, th-lift-instances
+     , base58-bytestring, bimap, binary, bytestring, constraints
+     , containers, crypto-sodium, cryptonite, data-default, Diff
+     , elliptic-curve, first-class-families, fmt, galois-field
+     , generic-deriving, gitrev, haskeline, hex-text, lens, megaparsec
+     , memory, MonadRandom, morley-prelude, mtl, named
+     , optparse-applicative, pairing, parser-combinators, scientific
+     , semigroups, show-type, singletons, singletons-base, syb
+     , template-haskell, text, text-manipulate, th-lift-instances
      , th-reify-many, time, timerep, uncaught-exception
      , unordered-containers, vector, vinyl, with-utf8, wl-pprint-text
      }:
      mkDerivation {
        pname = "morley";
-       version = "1.16.4";
-       sha256 = "17ggz4h5byg81sgji2kmqamynrff27jzdx8g0xvzn6mjdc1frr4f";
+       version = "1.17.0";
+       sha256 = "1a0z4351rf3aix5gwkacjvf9wjfgnv8b5xv8w1y1hk7c4cflaand";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson aeson-casing aeson-pretty base-noprelude base58-bytestring
-         binary bytestring constraints containers crypto-sodium cryptonite
-         data-default Diff elliptic-curve first-class-families fmt
-         galois-field generic-deriving gitrev hex-text lens megaparsec
+         bimap binary bytestring constraints containers crypto-sodium
+         cryptonite data-default Diff elliptic-curve first-class-families
+         fmt galois-field generic-deriving gitrev hex-text lens megaparsec
          memory MonadRandom morley-prelude mtl named optparse-applicative
          pairing parser-combinators scientific semigroups show-type
-         singletons syb template-haskell text text-manipulate
-         th-lift-instances th-reify-many time timerep uncaught-exception
-         unordered-containers vector vinyl with-utf8 wl-pprint-text
+         singletons singletons-base syb template-haskell text
+         text-manipulate th-lift-instances th-reify-many time timerep
+         uncaught-exception unordered-containers vector vinyl with-utf8
+         wl-pprint-text
        ];
        executableHaskellDepends = [
          aeson base-noprelude base58-bytestring bytestring fmt haskeline
          hex-text megaparsec MonadRandom morley-prelude named
-         optparse-applicative text vinyl with-utf8
+         optparse-applicative singletons text vinyl with-utf8
        ];
        description = "Developer tools for the Michelson Language";
        license = lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "morley-client";
-       version = "0.1.2";
-       sha256 = "00lp0i2fjn0s4l53d71jkady9pwdg1ya2csjwvlb7xbcr5rmgl6i";
+       version = "0.2.0";
+       sha256 = "1pdaqvhg94bikn3dsdg7l98wwy62l3wyxzrkx5pzl0pkwzqqbfy0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {nfc = null;};
+
+  "nfc_0_1_1" = callPackage
+    ({ mkDerivation, base, bytestring, c2hs, libnfc }:
+     mkDerivation {
+       pname = "nfc";
+       version = "0.1.1";
+       sha256 = "01ld7bdcaplxypaz8w3709g2l4c0gfpxz14q6hgbh9kf6wrnr8iw";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base bytestring ];
+       libraryPkgconfigDepends = [ libnfc ];
+       libraryToolDepends = [ c2hs ];
+       description = "libnfc bindings";
+       license = lib.licenses.publicDomain;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {inherit (pkgs) libnfc;};
 
   "ngram" = callPackage
     ({ mkDerivation, base, bytestring, cereal, cereal-text, containers
···
        broken = true;
      }) {};
 
+  "pasta-curves" = callPackage
+    ({ mkDerivation, base, bytestring, criterion, cryptonite, memory
+     , tasty, tasty-hunit, tasty-quickcheck, utf8-string
+     }:
+     mkDerivation {
+       pname = "pasta-curves";
+       version = "0.0.0.0";
+       sha256 = "18cdg16p9a8nqcr754wfzsc581j5r96kxh891195hyv3rw4ps315";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring cryptonite memory utf8-string
+       ];
+       executableHaskellDepends = [
+         base bytestring cryptonite memory utf8-string
+       ];
+       testHaskellDepends = [
+         base bytestring cryptonite memory tasty tasty-hunit
+         tasty-quickcheck utf8-string
+       ];
+       benchmarkHaskellDepends = [
+         base bytestring criterion cryptonite memory utf8-string
+       ];
+       description = "Provides the Pasta curves: Pallas, Vesta and their field elements Fp and Fq";
+       license = lib.licenses.mit;
+       mainProgram = "pasta-curves";
+     }) {};
+
   "pastis" = callPackage
     ({ mkDerivation, base, HTTP, network }:
      mkDerivation {
···
        benchmarkHaskellDepends = [ base criterion mwc-random vector ];
        description = "Greatest convex majorants and least concave minorants";
        license = lib.licenses.gpl3Plus;
+       maintainers = [ lib.maintainers.dschrempf ];
+     }) {};
+
+  "pava_0_1_1_4" = callPackage
+    ({ mkDerivation, base, criterion, hspec, mwc-random, random, vector
+     }:
+     mkDerivation {
+       pname = "pava";
+       version = "0.1.1.4";
+       sha256 = "1p43yiqkawvl5x6jmivc6y2zvl0azravs0zqhfhjnxbpqv8qd5d7";
+       libraryHaskellDepends = [ base vector ];
+       testHaskellDepends = [ base hspec vector ];
+       benchmarkHaskellDepends = [
+         base criterion mwc-random random vector
+       ];
+       description = "Greatest convex majorants and least concave minorants";
+       license = lib.licenses.gpl3Plus;
+       hydraPlatforms = lib.platforms.none;
        maintainers = [ lib.maintainers.dschrempf ];
      }) {};
 
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "polysemy-plugin_0_4_3_0" = callPackage
+  "polysemy-plugin_0_4_3_1" = callPackage
     ({ mkDerivation, base, Cabal, cabal-doctest, containers, doctest
      , ghc, ghc-tcplugins-extra, hspec, hspec-discover
      , inspection-testing, polysemy, should-not-typecheck, syb
···
      }:
      mkDerivation {
        pname = "polysemy-plugin";
-       version = "0.4.3.0";
-       sha256 = "1y4najvwas9rmd7xzn4k1nkpdld86606z3qzky7zr1d3l1z1vafb";
+       version = "0.4.3.1";
+       sha256 = "02s9hb0y4fgvmlkg7izwq24hrgb92h1jd7v0gjzayjn6la8xmf6r";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          base containers ghc ghc-tcplugins-extra polysemy syb transformers
···
      }) {};
 
   "postgrest" = callPackage
-    ({ mkDerivation, aeson, aeson-qq, ansi-wl-pprint, async
-     , auto-update, base, base64-bytestring, bytestring
-     , case-insensitive, cassava, configurator-pg, containers
-     , contravariant, contravariant-extras, cookie, directory, doctest
-     , either, fast-logger, gitrev, hasql, hasql-dynamic-statements
-     , hasql-notifications, hasql-pool, hasql-transaction, heredoc
-     , hspec, hspec-wai, hspec-wai-json, HTTP, http-types
-     , insert-ordered-containers, interpolatedstring-perl6, jose, lens
-     , lens-aeson, monad-control, mtl, network, network-uri
-     , optparse-applicative, parsec, pretty-simple, process, protolude
-     , Ranged-sets, regex-tdfa, retry, scientific, swagger2, text, time
-     , transformers-base, unix, unordered-containers, vector, wai
-     , wai-cors, wai-extra, wai-logger, wai-middleware-static, warp
+    ({ mkDerivation, aeson, aeson-qq, async, auto-update, base
+     , base64-bytestring, bytestring, case-insensitive, cassava
+     , configurator-pg, containers, contravariant, contravariant-extras
+     , cookie, directory, doctest, either, gitrev, hasql
+     , hasql-dynamic-statements, hasql-notifications, hasql-pool
+     , hasql-transaction, heredoc, hspec, hspec-wai, hspec-wai-json
+     , HTTP, http-types, insert-ordered-containers
+     , interpolatedstring-perl6, jose, lens, lens-aeson, monad-control
+     , mtl, network, network-uri, optparse-applicative, parsec
+     , pretty-simple, process, protolude, Ranged-sets, regex-tdfa, retry
+     , scientific, swagger2, text, time, transformers-base, unix
+     , unordered-containers, vector, wai, wai-cors, wai-extra, warp
      }:
      mkDerivation {
        pname = "postgrest";
-       version = "9.0.0";
-       sha256 = "1gd5h2091bqva37cfzzgq0cf7cd0djkmyq7ig1af9vmhzq8ljrw7";
+       version = "9.0.1";
+       sha256 = "000a9nj8xp4n337mbw8pq9f3md4wx5f9n0dxdhilf9zfk6s06970";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         aeson ansi-wl-pprint auto-update base base64-bytestring bytestring
-         case-insensitive cassava configurator-pg containers contravariant
-         contravariant-extras cookie directory either fast-logger gitrev
-         hasql hasql-dynamic-statements hasql-notifications hasql-pool
+         aeson auto-update base base64-bytestring bytestring
+         case-insensitive cassava configurator-pg containers
+         contravariant-extras cookie directory either gitrev hasql
+         hasql-dynamic-statements hasql-notifications hasql-pool
          hasql-transaction heredoc HTTP http-types insert-ordered-containers
          interpolatedstring-perl6 jose lens lens-aeson mtl network
          network-uri optparse-applicative parsec protolude Ranged-sets
          regex-tdfa retry scientific swagger2 text time unix
-         unordered-containers vector wai wai-cors wai-extra wai-logger
-         wai-middleware-static warp
+         unordered-containers vector wai wai-cors wai-extra warp
        ];
        executableHaskellDepends = [ base containers protolude ];
        testHaskellDepends = [
          aeson aeson-qq async auto-update base base64-bytestring bytestring
-         case-insensitive cassava containers contravariant doctest hasql
+         case-insensitive containers contravariant doctest hasql
          hasql-dynamic-statements hasql-pool hasql-transaction heredoc hspec
          hspec-wai hspec-wai-json http-types lens lens-aeson monad-control
-         pretty-simple process protolude regex-tdfa text time
-         transformers-base wai wai-extra
+         pretty-simple process protolude regex-tdfa text transformers-base
+         wai wai-extra
        ];
        description = "REST API for any Postgres database";
        license = lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "proto-lens-protobuf-types";
-       version = "0.7.1.1";
-       sha256 = "17m7aysj1mdx74r7mk9c1jy3q3nn7cfksdmadaxr0lmdq7iawk2g";
+       version = "0.7.1.2";
+       sha256 = "1fd141fb69wgc2alx4yyhyxdp9s86i3rxl9aah816b31bskbcjaa";
        setupHaskellDepends = [ base Cabal proto-lens-setup ];
        libraryHaskellDepends = [
          base lens-family proto-lens proto-lens-runtime text
···
      }:
      mkDerivation {
        pname = "proto3-suite";
-       version = "0.5.0";
-       sha256 = "09y09y321jflxlrx13b9fm4v3f3k4j475wpp0bilmc4ygq9bxjcm";
-       revision = "2";
-       editedCabalFile = "0wd212sjjdvggav7a719pxh3q232bnyp6jlgdavhay4b5n4adzx8";
+       version = "0.5.1";
+       sha256 = "0dgcmifz7p3g4gnyjnfm8gh48l3yhpixklscmfrv027lnc0awi6r";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        broken = true;
      }) {};
 
+  "qbe" = callPackage
+    ({ mkDerivation, base, bytestring, deepseq, filepath, hashable
+     , prettyprinter, tasty, tasty-silver, text, text-short
+     }:
+     mkDerivation {
+       pname = "qbe";
+       version = "1.1.0.0";
+       sha256 = "0hjllz846a7dyfrvjgqhjlkbhzbwhqdrvn3x0hijly01allcypr2";
+       libraryHaskellDepends = [
+         base bytestring deepseq hashable prettyprinter text text-short
+       ];
+       testHaskellDepends = [
+         base filepath prettyprinter tasty tasty-silver
+       ];
+       description = "Types and prettyprinter for the IL of the QBE compiler backend";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "qc-oi-testgenerator" = callPackage
     ({ mkDerivation, base, fclabels, QuickCheck, template-haskell }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "record-dot-preprocessor";
-       version = "0.2.14";
-       sha256 = "07hq90pk30p14jqk016wchmqrc1qhwa9qajaj90i363g3arcb24p";
+       version = "0.2.15";
+       sha256 = "0avdisbl1faqpny1r6ljm5gb8xz1yghmls7pgs2nshjkxd94i761";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base extra ghc uniplate ];
···
 
   "reddit" = callPackage
     ({ mkDerivation, aeson, api-builder, base, bytestring, Cabal
-     , data-default-class, free, hspec, http-client, http-client-tls
-     , http-types, network, text, time, transformers
+     , data-default-class, directory, free, hspec, http-client
+     , http-client-tls, http-types, network, text, time, transformers
      , unordered-containers, vector, yaml
      }:
      mkDerivation {
        pname = "reddit";
-       version = "0.2.3.0";
-       sha256 = "1hm1ax5h3p0avk4v3w08gac8mfiav8k9vd1vbkn77xlhxamp8jfi";
+       version = "0.3.0.0";
+       sha256 = "1gf1lid3wsldqnhi6zpq51hk6nsxvlllrigzgw0z8qbf67aqv55z";
        libraryHaskellDepends = [
          aeson api-builder base bytestring data-default-class free
          http-client http-client-tls http-types network text time
          transformers unordered-containers vector
        ];
        testHaskellDepends = [
-         aeson api-builder base bytestring Cabal data-default-class hspec
-         http-client http-client-tls text time transformers yaml
+         aeson api-builder base bytestring Cabal data-default-class
+         directory hspec http-client http-client-tls text time transformers
+         yaml
        ];
        description = "Library for interfacing with Reddit's API";
        license = lib.licenses.bsd2;
···
      }:
      mkDerivation {
        pname = "registry";
-       version = "0.3.2.0";
-       sha256 = "12xs0gdpjgh28yix0562d035nnw2x8zi5n06iaysxvz7d796sd37";
+       version = "0.3.2.1";
+       sha256 = "0packha6whpsx8f4a38nxiiykpy7b08r2l121scdz726z8kyz44y";
        libraryHaskellDepends = [
          base containers exceptions hashable mmorph mtl protolude resourcet
          semigroupoids semigroups template-haskell text transformers-base
···
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        mainProgram = "reload-exe";
+       broken = true;
      }) {};
 
   "reloto" = callPackage
···
     ({ mkDerivation, aeson, base, row-types, text }:
      mkDerivation {
        pname = "row-types-aeson";
-       version = "1.0.0.0";
-       sha256 = "0har2qcca9asd50jmcqab4v8jx83v5h5bgqk82awnrg7d99c24sf";
+       version = "1.1.0.0";
+       sha256 = "0zxcpr5bfk67zhqsqd8bnbmc6nswbq4hv98g0j516s1b5llpp8c4";
        libraryHaskellDepends = [ aeson base row-types text ];
        description = "aeson instances for Open Records and Variants";
        license = lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "serversession";
-       version = "1.0.2";
-       sha256 = "02ynhgq6gn5ddx2yd8ns8ay0rrhzln2h6jrmnwk7x1fqqfvzx0jf";
-       libraryHaskellDepends = [
-         aeson base base64-bytestring bytestring data-default hashable nonce
-         path-pieces persistent-test text time transformers
-         unordered-containers
-       ];
-       testHaskellDepends = [
-         aeson base base64-bytestring bytestring containers data-default
-         hspec nonce path-pieces QuickCheck text time transformers
-         unordered-containers
-       ];
-       description = "Secure, modular server-side sessions";
-       license = lib.licenses.mit;
-     }) {};
-
-  "serversession_1_0_3" = callPackage
-    ({ mkDerivation, aeson, base, base64-bytestring, bytestring
-     , containers, data-default, hashable, hspec, nonce, path-pieces
-     , persistent-test, QuickCheck, text, time, transformers
-     , unordered-containers
-     }:
-     mkDerivation {
-       pname = "serversession";
        version = "1.0.3";
        sha256 = "0hzyvz3jkv248lbq4pgy92dm054wj2s4d19rjr096ymcaznhxgfl";
        libraryHaskellDepends = [
···
        ];
        description = "Secure, modular server-side sessions";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "serversession-backend-acid-state" = callPackage
···
      }:
      mkDerivation {
        pname = "shakespeare";
-       version = "2.0.29";
-       sha256 = "016vkhn2g91cip5w06kh0z577s90sd768rmx044n4b5sa135c89j";
-       libraryHaskellDepends = [
-         aeson base blaze-html blaze-markup bytestring containers directory
-         exceptions file-embed ghc-prim parsec process scientific
-         template-haskell text th-lift time transformers
-         unordered-containers vector
-       ];
-       testHaskellDepends = [
-         aeson base blaze-html blaze-markup bytestring containers directory
-         exceptions ghc-prim hspec HUnit parsec process template-haskell
-         text time transformers
-       ];
-       description = "A toolkit for making compile-time interpolated templates";
-       license = lib.licenses.mit;
-       maintainers = [ lib.maintainers.psibi ];
-     }) {};
-
-  "shakespeare_2_0_30" = callPackage
-    ({ mkDerivation, aeson, base, blaze-html, blaze-markup, bytestring
-     , containers, directory, exceptions, file-embed, ghc-prim, hspec
-     , HUnit, parsec, process, scientific, template-haskell, text
-     , th-lift, time, transformers, unordered-containers, vector
-     }:
-     mkDerivation {
-       pname = "shakespeare";
        version = "2.0.30";
        sha256 = "038yprj9yig2xbjs2pqsjzs4pl9ir2frdz9wn2pklc4kvdazx3aw";
        libraryHaskellDepends = [
···
        ];
        description = "A toolkit for making compile-time interpolated templates";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
        maintainers = [ lib.maintainers.psibi ];
      }) {};
 
···
        maintainers = [ lib.maintainers.dschrempf ];
      }) {};
 
+  "slynx_0_7_0_1" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, bytestring, containers
+     , elynx-markov, elynx-seq, elynx-tools, elynx-tree, hmatrix
+     , matrices, optparse-applicative, random, statistics, text
+     , transformers, vector
+     }:
+     mkDerivation {
+       pname = "slynx";
+       version = "0.7.0.1";
+       sha256 = "1l46xpilja815zsj96lhginl4x8jg9skxb0pvny3h12972s1k89d";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson attoparsec base bytestring containers elynx-markov elynx-seq
+         elynx-tools elynx-tree hmatrix matrices optparse-applicative random
+         statistics text transformers vector
+       ];
+       executableHaskellDepends = [ base ];
+       description = "Handle molecular sequences";
+       license = lib.licenses.gpl3Plus;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "slynx";
+       maintainers = [ lib.maintainers.dschrempf ];
+     }) {};
+
   "small-bytearray-builder" = callPackage
     ({ mkDerivation, base, bytebuild, byteslice }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "snack";
-       version = "0.2.0.0";
-       sha256 = "13crnza7fav388s3n8gywbjam97xqhdqh0r10dcgpm5jffi8vns2";
+       version = "0.3.0.0";
+       sha256 = "10a5bjhq8ncp097gh415mn48cc65l73z9gd2vq9fg4d9qg5v5jp2";
        libraryHaskellDepends = [ base bytestring bytestring-lexing text ];
        benchmarkHaskellDepends = [
          attoparsec base bytestring criterion string-conversions text
···
        description = "Simple typesafe web routing";
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "solga-swagger" = callPackage
···
      }:
      mkDerivation {
        pname = "stooq-api";
-       version = "0.3.0.0";
-       sha256 = "1ax4ar3f0vnh1gcybxmf4vf0hvj1shs8mhin046jmgjqj14ss6zn";
+       version = "0.3.1.0";
+       sha256 = "0a2hnhrb00h52z0717zbx1ha4i5aixps0b9n3sw7svdjvz3dygkp";
        libraryHaskellDepends = [
          aeson base bytestring lens stringsearch text time utf8-string
          vector wreq
···
      }:
      mkDerivation {
        pname = "streamly-lmdb";
-       version = "0.4.0";
-       sha256 = "10749fl4dgm89z1d6sas1ngwxkkfl385465yxnrhxcc63wz53p5d";
+       version = "0.5.0";
+       sha256 = "1hwqr95dh9da70147r6g4jwd8an0ghfnm64y2x34d8sr0zhb7j9z";
        libraryHaskellDepends = [ async base bytestring streamly ];
        librarySystemDepends = [ lmdb ];
        testHaskellDepends = [
···
        pname = "superrecord";
        version = "0.5.1.0";
        sha256 = "0dg1h7213vinlm6vmdr73xh81j0ysvs7mqmphwr58d3ymn12mfqa";
+       revision = "1";
+       editedCabalFile = "10nydjdsk25rw12m5my19pl6fwzivxhrpiy9dhnxz2sjrwr6hvlk";
        libraryHaskellDepends = [
          aeson base bytestring constraints deepseq ghc-prim mtl text
        ];
···
        broken = true;
      }) {};
 
+  "tasty-autocollect" = callPackage
+    ({ mkDerivation, base, bytestring, containers, directory
+     , explainable-predicates, filepath, ghc, tasty, tasty-golden
+     , tasty-hunit, tasty-quickcheck, template-haskell, temporary, text
+     , transformers, typed-process
+     }:
+     mkDerivation {
+       pname = "tasty-autocollect";
+       version = "0.2.0.0";
+       sha256 = "1wn8mf1caml2qzsq0b9fhir97lzlydpwr2q711qldiq4vrjszj5n";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base containers directory filepath ghc tasty template-haskell text
+         transformers
+       ];
+       executableHaskellDepends = [ base text ];
+       testHaskellDepends = [
+         base bytestring containers directory explainable-predicates
+         filepath tasty tasty-golden tasty-hunit tasty-quickcheck temporary
+         text typed-process
+       ];
+       description = "Autocollection of tasty tests";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "tasty-autocollect";
+       broken = true;
+     }) {};
+
   "tasty-bdd" = callPackage
     ({ mkDerivation, aeson, aeson-qq, base, exceptions, free, HUnit
      , microlens, microlens-th, mtl, pretty, pretty-show
···
        mainProgram = "tasty-discover";
      }) {};
 
+  "tasty-discover_5_0_0" = callPackage
+    ({ mkDerivation, base, bytestring, containers, directory, filepath
+     , Glob, hedgehog, hspec, hspec-core, tasty, tasty-golden
+     , tasty-hedgehog, tasty-hspec, tasty-hunit, tasty-quickcheck
+     , tasty-smallcheck
+     }:
+     mkDerivation {
+       pname = "tasty-discover";
+       version = "5.0.0";
+       sha256 = "0a3h3m6hjwr9dgnr1m2zwifn1c40rhbyh55ihlrh9m98z6jpvcpf";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base containers directory filepath Glob tasty
+       ];
+       executableHaskellDepends = [
+         base containers directory filepath Glob
+       ];
+       testHaskellDepends = [
+         base bytestring containers directory filepath Glob hedgehog hspec
+         hspec-core tasty tasty-golden tasty-hedgehog tasty-hspec
+         tasty-hunit tasty-quickcheck tasty-smallcheck
+       ];
+       description = "Test discovery for the tasty framework";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "tasty-discover";
+     }) {};
+
   "tasty-expected-failure" = callPackage
     ({ mkDerivation, base, hedgehog, tagged, tasty, tasty-golden
      , tasty-hedgehog, tasty-hunit, unbounded-delays
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "text-zipper_0_12" = callPackage
+    ({ mkDerivation, base, deepseq, hspec, QuickCheck, text, vector }:
+     mkDerivation {
+       pname = "text-zipper";
+       version = "0.12";
+       sha256 = "00k7d6qfznhp6l2ihw3pppkn580pwd7ac7wx9vidil4y9hjagaw6";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [ base deepseq text vector ];
+       testHaskellDepends = [ base hspec QuickCheck text ];
+       description = "A text editor zipper library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "text-zipper-monad" = callPackage
     ({ mkDerivation, base, hspec, mtl, text-zipper }:
      mkDerivation {
···
        maintainers = [ lib.maintainers.dschrempf ];
      }) {};
 
+  "tlynx_0_7_0_1" = callPackage
+    ({ mkDerivation, aeson, async, attoparsec, base, bytestring
+     , comonad, containers, data-default-class, elynx-tools, elynx-tree
+     , optparse-applicative, parallel, random, statistics, text
+     , transformers, vector
+     }:
+     mkDerivation {
+       pname = "tlynx";
+       version = "0.7.0.1";
+       sha256 = "117kwfqyww9qwsja4vx03vja7g6lgin3iy0ss2ckmdmnddimm9qs";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson async attoparsec base bytestring comonad containers
+         data-default-class elynx-tools elynx-tree optparse-applicative
+         parallel random statistics text transformers vector
+       ];
+       executableHaskellDepends = [ base ];
+       description = "Handle phylogenetic trees";
+       license = lib.licenses.gpl3Plus;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "tlynx";
+       maintainers = [ lib.maintainers.dschrempf ];
+     }) {};
+
   "tmapchan" = callPackage
     ({ mkDerivation, base, containers, hashable, stm
      , unordered-containers
···
        license = lib.licenses.mit;
      }) {};
 
+  "universum_1_8_0" = callPackage
+    ({ mkDerivation, base, bytestring, containers, deepseq, gauge
+     , ghc-prim, hashable, hedgehog, microlens, microlens-mtl, mtl
+     , safe-exceptions, stm, tasty, tasty-hedgehog, text, transformers
+     , unordered-containers, utf8-string, vector
+     }:
+     mkDerivation {
+       pname = "universum";
+       version = "1.8.0";
+       sha256 = "0kq41glz96318bxgwy8l5vqn9d9ha6bsbzgd2kjzlxxn6y7zvwr6";
+       libraryHaskellDepends = [
+         base bytestring containers deepseq ghc-prim hashable microlens
+         microlens-mtl mtl safe-exceptions stm text transformers
+         unordered-containers utf8-string vector
+       ];
+       testHaskellDepends = [
+         base bytestring hedgehog tasty tasty-hedgehog text
+       ];
+       benchmarkHaskellDepends = [
+         base containers gauge text unordered-containers
+       ];
+       description = "Custom prelude used in Serokell";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "unix_2_7_2_2" = callPackage
     ({ mkDerivation, base, bytestring, time }:
      mkDerivation {
···
        description = "Typesafe URLs for Wai applications";
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "wai-routing" = callPackage
···
      }:
      mkDerivation {
        pname = "xmobar";
-       version = "0.43";
-       sha256 = "0r0ba8xv3f0jy4ycmhxhpd146bqzf7v97svxg6r3w9agva3l8454";
+       version = "0.44";
+       sha256 = "0zjsym9ldj1rslci787br7vwgqnd7z5s55yclfxi2r8gibq3f2ha";
        configureFlags = [
          "-fwith_alsa" "-fwith_conduit" "-fwith_datezone" "-fwith_dbus"
          "-fwith_inotify" "-fwith_iwlib" "-fwith_mpd" "-fwith_mpris"
···
        license = lib.licenses.mit;
      }) {};
 
+  "yesod-middleware-csp" = callPackage
+    ({ mkDerivation, base, base64-bytestring, bytestring
+     , case-insensitive, classy-prelude, classy-prelude-yesod, conduit
+     , containers, directory, fast-logger, filepath, hspec, http-client
+     , http-types, monad-logger, network-uri, template-haskell, text
+     , time, uuid, wai-extra, yesod, yesod-core, yesod-static
+     , yesod-test
+     }:
+     mkDerivation {
+       pname = "yesod-middleware-csp";
+       version = "1.0.2";
+       sha256 = "0b024ryklhrf683pzrrrfwfw0cl5nawjgz529xv9pzql1ly56yz3";
+       libraryHaskellDepends = [
+         base base64-bytestring bytestring classy-prelude conduit containers
+         directory filepath http-client network-uri template-haskell text
+         time uuid yesod yesod-core yesod-static
+       ];
+       testHaskellDepends = [
+         base base64-bytestring bytestring case-insensitive classy-prelude
+         classy-prelude-yesod conduit containers directory fast-logger
+         filepath hspec http-types monad-logger network-uri template-haskell
+         text uuid wai-extra yesod yesod-core yesod-static yesod-test
+       ];
+       description = "A middleware for building CSP headers on the fly";
+       license = lib.licenses.mit;
+     }) {};
+
   "yesod-newsfeed" = callPackage
     ({ mkDerivation, base, blaze-html, blaze-markup, bytestring
      , containers, shakespeare, text, time, xml-conduit, yesod-core
···
      }:
      mkDerivation {
        pname = "yet-another-logger";
-       version = "0.4.0";
-       sha256 = "11nylldbb6fd0hvpddhqc8s1s9w6c0r5iv15wvg8wyw738vgvh69";
+       version = "0.4.1";
+       sha256 = "1p465nvysvchq97b5iak3m5avxslq8igjb7qkib5bwb08zc7cf8i";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [

pkgs/development/libraries/cjose/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "cjose";
-  version = "0.6.1";
+  version = "0.6.2";
 
   src = fetchFromGitHub {
-    owner = "cisco";
+    owner = "zmartzone";
     repo = "cjose";
-    rev = version;
-    sha256 = "1msyjwmylb5c7jc16ryx3xb9cdwx682ihsm0ni766y6dfwx8bkhp";
+    rev = "v${version}";
+    sha256 = "sha256-FHKuaf4Gg3On7d3UBbGD8k1gA8kGsCOaWtLMohr5woA=";
   };
 
   nativeBuildInputs = [ autoreconfHook pkg-config doxygen ];
···
   ];
 
   meta = with lib; {
-    homepage = "https://github.com/cisco/cjose";
-    changelog = "https://github.com/cisco/cjose/blob/${version}/CHANGELOG.md";
-    description = "C library for Javascript Object Signing and Encryption";
+    homepage = "https://github.com/zmartzone/cjose";
+    changelog = "https://github.com/zmartzone/cjose/blob/${version}/CHANGELOG.md";
+    description = "C library for Javascript Object Signing and Encryption. This is a maintained fork of the original project";
     license = licenses.mit;
     maintainers = with maintainers; [ midchildan ];
     platforms = platforms.all;

pkgs/development/libraries/libbencodetools/default.nix

···
-{ stdenv, lib, fetchFromGitLab
+{ stdenv
+, lib
+, fetchFromGitLab
+, python3
 }:
 
 stdenv.mkDerivation rec {
   pname = "libbencodetools";
-  version = "unstable-2021-04-15";
+  version = "unstable-2022-05-11";
 
   src = fetchFromGitLab {
     owner = "heikkiorsila";
     repo = "bencodetools";
-    rev = "1ab11f6509a348975e8aec829d7abbf2f8e9b7d1";
-    sha256 = "1i2dgvxxwj844yn45hnfx3785ljbvbkri0nv0jx51z4i08w7cz0h";
+    rev = "384d78d297a561dddbbd0f4632f0c74c0db41577";
+    sha256 = "1d699q9r33hkmmqkbh92ax54mcdf9smscmc0dza2gp4srkhr83qm";
   };
 
   postPatch = ''
-    patchShebangs .
+    patchShebangs configure
+    substituteInPlace configure \
+      --replace 'python_install_option=""' 'python_install_option="--prefix=$out"'
   '';
 
-  configureFlags = [
-    "--without-python"
+  enableParallelBuilding = true;
+
+  nativeBuildInputs = [
+    python3
   ];
 
   meta = with lib; {

pkgs/development/libraries/openzwave/default.nix

···
     description = "C++ library to control Z-Wave Networks via a USB Z-Wave Controller";
     homepage = "http://www.openzwave.net/";
     license = licenses.gpl3;
-    maintainers = with maintainers; [ etu ];
+    maintainers = with maintainers; [ ];
     platforms = platforms.linux;
   };
 }

pkgs/development/libraries/qt-6/hooks/wrap-qt-apps-hook.sh

···
 qtHostPathHook() {
     qtUnseenHostPath "$1" || return 0
 
+    if ! [ -v qtPluginPrefix ]
+    then
+        echo "wrapQtAppsHook qtHostPathHook: qtPluginPrefix is unset. hint: add qt6.qtbase to buildInputs"
+    fi
+
     local pluginDir="$1/${qtPluginPrefix:?}"
     if [ -d "$pluginDir" ]
     then
···
         qtWrapperArgs+=(--prefix QML2_IMPORT_PATH : "$qmlDir")
     fi
 }
-addEnvHooks "$hostOffset" qtHostPathHook
+addEnvHooks "$targetOffset" qtHostPathHook
 
 makeQtWrapper() {
     local original="$1"
···
 
         find "$targetDir" ! -type d -executable -print0 | while IFS= read -r -d '' file
         do
-            isELF "$file" || isMachO "$file" || continue
-
             if [ -f "$file" ]
             then
                 echo "wrapping $file"

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

···
     description = "Python module to implement EZSP for EmberZNet devices";
     homepage = "https://github.com/zigpy/bellows";
     license = licenses.gpl3Plus;
-    maintainers = with maintainers; [ etu mvnetbiz ];
+    maintainers = with maintainers; [ mvnetbiz ];
   };
 }

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

···
     description = "Python library for CRCs and checksums";
     homepage = "https://sourceforge.net/projects/crccheck/";
     license = licenses.gpl3Plus;
-    maintainers = with maintainers; [ etu ];
+    maintainers = with maintainers; [ ];
     platforms = platforms.linux;
   };
 }

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

···
 
 buildPythonPackage rec {
   pname = "hahomematic";
-  version = "2022.7.7";
+  version = "2022.7.8";
   format = "pyproject";
 
   disabled = pythonOlder "3.9";
···
     owner = "danielperna84";
     repo = pname;
     rev = "refs/tags/${version}";
-    sha256 = "sha256-obkvx7P2nkn7z3kMJeY9ERzkuCAlmE27mwjUUPxOisc=";
+    sha256 = "sha256-Tzl7LH4Wisge3B7d2ChQnNPBAj1SNGmHI94k8fkMuqk=";
   };
 
   propagatedBuildInputs = [

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

···
 }:
 
 buildPythonPackage rec {
-  version = "4.0.9";
+  version = "4.1.0";
   pname = "icalendar";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "cc73fa9c848744843046228cb66ea86cd8c18d73a51b140f7c003f760b84a997";
+    sha256 = "sha256-l0i3wC78xD5Y0GFa4JdqxPJl6Q2t7ptPiE3imQXBs5U=";
   };
 
   buildInputs = [ setuptools ];

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

···
   ] ++ lib.optionals stdenv.isDarwin [
     # attempts to use trashcan, build env doesn't allow this
     "test_delete"
+    # test is presumable broken in sandbox
+    "test_authorized_requests"
   ];
 
   disabledTestPaths = [

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

···
   __darwinAllowLocalNetworking = true;
 
   meta = with lib; {
-    broken = stdenv.isDarwin;
     description = "JupyterLab Server";
     homepage = "https://jupyter.org";
     license = licenses.bsdOriginal;

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

···
 
 buildPythonPackage rec {
   pname = "jupytext";
-  version = "1.13.8";
+  version = "1.14.0";
   format = "pyproject";
 
   disabled = pythonOlder "3.6";
···
     owner = "mwouts";
     repo = pname;
     rev = "refs/tags/v${version}";
-    sha256 = "sha256-ebe5sQJxA8QE6eJp6vPUyMaEvZUPqzCmQ6damzo1BVo=";
+    sha256 = "sha256-a/dvY7MLCjYGOvsCC5tiIIJpApNriRtBN63VK+McEVw=";
   };
 
   buildInputs = [
···
     notebook
     pytestCheckHook
   ];
-
-  postPatch = ''
-    # https://github.com/mwouts/jupytext/pull/885
-    substituteInPlace setup.py \
-      --replace "markdown-it-py~=1.0" "markdown-it-py>=1.0.0,<3.0.0"
-  '';
 
   preCheck = ''
     # Tests that use a Jupyter notebook require $HOME to be writable

pkgs/development/python-modules/oslo-context/default.nix

···
 
 buildPythonPackage rec {
   pname = "oslo.context";
-  version = "4.1.0";
+  version = "5.0.0";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "sha256-damnIqVS+6ionooBAo+oKmGQqzF6lZG7gzA6IhCnkUQ=";
+    sha256 = "sha256-iMDG0HZoHGDVYPfWZWXkKsEWxaqKKKBNt8CsACUTMiQ=";
   };
 
   postPatch = ''

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

···
 
 buildPythonPackage rec {
   pname = "pex";
-  version = "2.1.97";
+  version = "2.1.98";
   format = "flit";
 
   disabled = pythonOlder "3.7";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-h2fDyL1spMBjnqTvjj3C3eXFFmgtvX7NyTUo5my6Lk4=";
+    hash = "sha256-5qvcaxbRR6Mt4lgSxQlcfSEfxjzW134hLJxxMZxg6LQ=";
   };
 
   nativeBuildInputs = [

pkgs/development/python-modules/pure-pcapy3/default.nix

···
     description = "Reimplementation of pcapy";
     homepage = "https://github.com/rcloran/pure-pcapy-3";
     license = licenses.bsd2;
-    maintainers = with maintainers; [ etu ];
+    maintainers = with maintainers; [ ];
   };
 }

pkgs/development/python-modules/pyserial-asyncio/default.nix

···
     description = "Asyncio extension package for pyserial";
     homepage = "https://github.com/pyserial/pyserial-asyncio";
     license = licenses.bsd3;
-    maintainers = with maintainers; [ etu ];
+    maintainers = with maintainers; [ ];
     platforms = platforms.linux;
   };
 }

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

···
     description = "Python wrapper for the OpenZWave C++ library";
     homepage = "https://github.com/OpenZWave/python-openzwave";
     license = licenses.gpl3Plus;
-    maintainers = with maintainers; [ etu ];
+    maintainers = with maintainers; [ ];
     inherit (openzwave.meta) platforms;
   };
 }

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

···
 
 buildPythonPackage rec {
   pname = "sqlmap";
-  version = "1.6.6";
+  version = "1.6.7";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "sha256-eXQ3sddIDHJ/pc6n5pmJoi3FvA8j2GMyWtToiKVIaVg=";
+    sha256 = "sha256-J0USsiCWaysQOir/wpkw6GT1ILckjK7EUiY541aoahA=";
   };
 
   postPatch = ''

pkgs/development/python-modules/voluptuous-serialize/default.nix

···
     homepage = "https://github.com/home-assistant-libs/voluptuous-serialize";
     license = licenses.asl20;
     description = "Convert Voluptuous schemas to dictionaries so they can be serialized";
-    maintainers = with maintainers; [ etu ];
+    maintainers = with maintainers; [ ];
   };
 }

pkgs/development/python-modules/zha-quirks/default.nix

···
     description = "ZHA Device Handlers are custom quirks implementations for Zigpy";
     homepage = "https://github.com/dmulcahey/zha-device-handlers";
     license = licenses.asl20;
-    maintainers = with maintainers; [ etu ];
+    maintainers = with maintainers; [ ];
     platforms = platforms.linux;
   };
 }

pkgs/development/python-modules/zigpy-cc/default.nix

···
     description = "Library which communicates with Texas Instruments CC2531 radios for zigpy";
     homepage = "https://github.com/zigpy/zigpy-cc";
     license = licenses.gpl3Plus;
-    maintainers = with maintainers; [ etu mvnetbiz ];
+    maintainers = with maintainers; [ mvnetbiz ];
     platforms = platforms.linux;
   };
 }

pkgs/development/python-modules/zigpy-deconz/default.nix

···
     description = "Library which communicates with Deconz radios for zigpy";
     homepage = "https://github.com/zigpy/zigpy-deconz";
     license = licenses.gpl3Plus;
-    maintainers = with maintainers; [ etu mvnetbiz ];
+    maintainers = with maintainers; [ mvnetbiz ];
     platforms = platforms.linux;
   };
 }

pkgs/development/python-modules/zigpy-xbee/default.nix

···
     description = "A library which communicates with XBee radios for zigpy";
     homepage = "https://github.com/zigpy/zigpy-xbee";
     license = licenses.gpl3Plus;
-    maintainers = with maintainers; [ etu mvnetbiz ];
+    maintainers = with maintainers; [ mvnetbiz ];
     platforms = platforms.linux;
   };
 }

pkgs/development/python-modules/zigpy-zigate/default.nix

···
     description = "Library which communicates with ZiGate radios for zigpy";
     homepage = "https://github.com/zigpy/zigpy-zigate";
     license = licenses.gpl3Plus;
-    maintainers = with maintainers; [ etu mvnetbiz ];
+    maintainers = with maintainers; [ mvnetbiz ];
     platforms = platforms.linux;
   };
 }

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

···
     description = "Library implementing a ZigBee stack";
     homepage = "https://github.com/zigpy/zigpy";
     license = licenses.gpl3Plus;
-    maintainers = with maintainers; [ etu mvnetbiz ];
+    maintainers = with maintainers; [ mvnetbiz ];
     platforms = platforms.linux;
   };
 }

pkgs/development/tools/gopls/default.nix

···
 
 buildGoModule rec {
   pname = "gopls";
-  version = "0.9.0";
+  version = "0.9.1";
 
   src = fetchFromGitHub {
     owner = "golang";
     repo = "tools";
     rev = "gopls/v${version}";
-    sha256 = "sha256-pEEqzaV3B/eDSiqJa5AZydlmYrvpD9CDryy2rHf4N5Y=";
+    sha256 = "sha256-+9NOQRu7cwEkRMB+HFEVrF7Z8y5UCxdUL005vZFPUHk=";
   };
 
   modRoot = "gopls";
-  vendorSha256 = "sha256-ZdFYAQxStbY6KPyRAHvnwPeKLrOLVrr59MMyjknyK5Y=";
+  vendorSha256 = "sha256-V5HQAKRFtHfJJzdQ8eutCpVmnOWe0yYKKnlGxphulAc=";
 
   doCheck = false;
 

pkgs/development/web/deno/default.nix

···
 , fetchFromGitHub
 , rustPlatform
 , installShellFiles
+, fetchpatch
+, tinycc
 , libiconv
 , libobjc
 , Security
···
 , librusty_v8 ? callPackage ./librusty_v8.nix { }
 }:
 
+let
+  libtcc = tinycc.overrideAttrs (oa: {
+    makeFlags = [ "libtcc.a" ];
+    # tests want tcc binary
+    doCheck = false;
+    outputs = [ "out" ];
+    installPhase = ''
+      mkdir -p $out/lib/
+      mv libtcc.a $out/lib/
+    '';
+  });
+in
 rustPlatform.buildRustPackage rec {
   pname = "deno";
-  version = "1.23.3";
+  version = "1.23.4";
 
   src = fetchFromGitHub {
     owner = "denoland";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-kxQZDuqVddooYeelW3gJBbU7N/PnARj/IG7eBVJoAJ8=";
+    sha256 = "sha256-nLQqfLRuh9mhZfjeiPaGpQbi5bXEg7HiGwrwDmaIRWM=";
   };
-  cargoSha256 = "sha256-bQZpE3kBqN5+lPdHWiiUQsWQwuMkvnfHLy3S1HnS4lk=";
+  cargoSha256 = "sha256-l5Ce/ypYXZKEi859OFskwC/Unpo842ZPxIHvp6lCjQc=";
+
+  patches = [
+    # remove after https://github.com/denoland/deno/pull/15193 is in a release
+    (fetchpatch {
+      name = "byo-tcc.patch";
+      url = "https://github.com/denoland/deno/pull/15193/commits/c43698b2b58af1ef69b1558d55c8ebea0268dfea.patch";
+      sha256 = "sha256-YE5mGHyEm20FjFhr8yveBRlrOVL3+qQYxz2xp/IfmJs=";
+    })
+  ];
 
   postPatch = ''
     # upstream uses lld on aarch64-darwin for faster builds
···
     substituteInPlace .cargo/config.toml --replace '"-C", "link-arg=-fuse-ld=lld"' ""
   '';
 
-  # Install completions post-install
   nativeBuildInputs = [ installShellFiles ];
+  buildInputs = lib.optionals stdenv.isDarwin
+    [ libiconv libobjc Security CoreServices Metal Foundation QuartzCore ];
 
   buildAndTestSubdir = "cli";
-
-  buildInputs = lib.optionals stdenv.isDarwin
-    [ libiconv libobjc Security CoreServices Metal Foundation QuartzCore ];
 
   # The v8 package will try to download a `librusty_v8.a` release at build time to our read-only filesystem
   # To avoid this we pre-download the file and export it via RUSTY_V8_ARCHIVE
   RUSTY_V8_ARCHIVE = librusty_v8;
+
+  # The deno_ffi package currently needs libtcc.a on linux and macos and will try to compile it at build time
+  # To avoid this we point it to our copy (dir)
+  # In the future tinycc will be replaced with asm
+  DENO_FFI_LIBTCC = "${libtcc}/lib";
 
   # Tests have some inconsistencies between runs with output integration tests
   # Skipping until resolved

pkgs/development/web/deno/librusty_v8.nix

···
   };
 in
 fetch_librusty_v8 {
-  version = "0.44.3";
+  version = "0.45.0";
   shas = {
-    x86_64-linux = "sha256-0l05QWfWICFTStB0AVGMAzB28MFOe4kH7Y5mT6CxvGc=";
-    aarch64-linux = "sha256-G2yZPD1lXHZvEX3CwnijoFyWF2dv6fM07+xK0oYKMVU=";
-    x86_64-darwin = "sha256-f0lBrayYNo7ivCqeJcYF5EMEnmrgH+qHLofMzbUJ+Os=";
-    aarch64-darwin = "sha256-3DG8IIMeniYLk+GyK0znFpx/f3URxFy5SFMusEPzykU=";
+    x86_64-linux = "sha256-yZw6zwEhJyRntqOmyk03N+sHxzIrbY/e67AQ21ePlAU=";
+    aarch64-linux = "sha256-2p21Smm5wZycv9u+yDbyerKTjSTB7yau5WC2aJ+Vr8w=";
+    x86_64-darwin = "sha256-HO287V+iBwdqKZUWhZJnuGJO9RE4wGG4cQMN8CkB7WQ=";
+    aarch64-darwin = "sha256-ekoMhWMQpBUdM7R7i82NWrNtQMNqCujNYy1ijOxT64U=";
   };
 }

pkgs/development/web/deno/update/librusty_v8.ts

···
+import * as toml from "https://deno.land/std@0.148.0/encoding/toml.ts";
 import {
   genValueRegExp,
   getExistingVersion,
···
   versionRegExp,
   write,
 } from "./common.ts";
+
 
 const log = logger("librusty_v8");
 
···
 ) =>
   fetch(`https://github.com/${owner}/${repo}/raw/${version}/core/Cargo.toml`)
     .then((res) => res.text())
-    .then((txt) => txt.match(genValueRegExp("v8", versionRegExp))?.shift());
+    .then((txt) => mod.parse(txt).dependencies.v8.version);
 
 const fetchArchShaTasks = (version: string, arches: Architecture[]) =>
   arches.map(

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

···
 
 rustPlatform.buildRustPackage rec {
   pname = "tuigreet";
-  version = "0.7.2";
+  version = "0.8.0";
 
   src = fetchFromGitHub {
     owner = "apognu";
     repo = pname;
     rev = version;
-    sha256 = "sha256-Mu4GGlX7ZjBaBECXRD6iJCqDMSzcj17BriJ6Nas0J70=";
+    sha256 = "sha256-8/2I6bk29/GqZ1ACuN9RgBiGAy7yt0iw2fagHfu4/BI=";
   };
 
-  cargoSha256 = "sha256-H5xqk7Yd3M8sFGHlmhAS0fhh3eM4dkvkNQGVxRSXUJs=";
+  cargoSha256 = "sha256-fOs9a0/1c8Kh4JA5up3XSQ+km/FwSYzl0w4UDL4yU4M=";
 
   meta = with lib; {
     description = "Graphical console greeter for greetd";

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

···
   meta = with lib; {
     homepage = "https://github.com/aguinet/usbtop";
     description = "A top utility that shows an estimated instantaneous bandwidth on USB buses and devices";
-    maintainers = with maintainers; [ etu ];
+    maintainers = with maintainers; [ ];
     license = licenses.bsd3;
     platforms = platforms.linux;
   };

pkgs/servers/nosql/redis/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "redis";
-  version = "7.0.2";
+  version = "7.0.3";
 
   src = fetchurl {
     url = "https://download.redis.io/releases/${pname}-${version}.tar.gz";
-    sha256 = "sha256-Xlfq/n1Kxey2p9ZNa2Hbd1YW2/kDKTs/zGYHFtvaXus=";
+    sha256 = "sha256-LN59FyFP/jBZU9qf/xIzPopyyqV/1JI+SHL2NiogjnM=";
   };
 
   # Cross-compiling fixes

pkgs/tools/admin/iredis/default.nix

···
+{ lib, python3Packages }:
+
+with python3Packages;
+
+buildPythonApplication rec {
+  pname = "iredis";
+  version = "1.12.0";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "c3031094db0aa03d48b6f9be750e32d3e901942a96cc05283029086cb871cd81";
+  };
+
+  postPatch = ''
+    substituteInPlace setup.py \
+      --replace "click>=7.0,<8.0" "click" \
+      --replace "wcwidth==0.1.9" "wcwidth" \
+      --replace "redis>=3.4.0,<4.0.0" "redis" \
+      --replace "mistune>=2.0,<3.0" "mistune"
+  '';
+
+  propagatedBuildInputs = [
+    pygments
+    click
+    configobj
+    importlib-resources
+    mistune_2_0
+    packaging
+    pendulum
+    prompt-toolkit
+    redis
+    wcwidth
+  ];
+
+  checkInputs = [
+    pytestCheckHook
+    pexpect
+  ];
+
+  pytestFlagsArray = [
+    # Fails on sandbox
+    "--ignore=tests/unittests/test_client.py"
+    "--deselect=tests/unittests/test_render_functions.py::test_render_unixtime_config_raw"
+    "--deselect=tests/unittests/test_render_functions.py::test_render_time"
+    # Only execute unittests, because cli tests require a running Redis
+    "tests/unittests/"
+  ];
+
+  pythonImportsCheck = [ "iredis" ];
+
+  meta = with lib; {
+    description = "A Terminal Client for Redis with AutoCompletion and Syntax Highlighting";
+    changelog = "https://github.com/laixintao/iredis/raw/v${version}/CHANGELOG.md";
+    homepage = "https://iredis.io/";
+    license = licenses.bsd3;
+    maintainers = with maintainers; [ marsam ];
+  };
+}

pkgs/tools/archivers/fsarchiver/default.nix

···
     '';
     homepage = "https://www.fsarchiver.org/";
     license = licenses.lgpl2;
-    maintainers = [ maintainers.etu ];
+    maintainers = with maintainers; [ ];
     platforms = platforms.linux;
   };
 }

pkgs/tools/cd-dvd/ventoy-bin/default.nix

···
     maintainers = with maintainers; [ k4leg AndersonTorres ];
     platforms = [ "x86_64-linux" "i686-linux" "aarch64-linux" "mipsel-linux" ];
     sourceProvenance = with sourceTypes; [ binaryNativeCode ];
+    mainProgram = "ventoy";
   };
 }

pkgs/tools/misc/adafruit-ampy/default.nix

···
     homepage = "https://github.com/pycampers/ampy";
     license = licenses.mit;
     description = "Utility to interact with a MicroPython board over a serial connection";
-    maintainers = with maintainers; [ etu ];
+    maintainers = with maintainers; [ ];
   };
 }

pkgs/tools/misc/broot/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "broot";
-  version = "1.14.1";
+  version = "1.14.2";
 
   src = fetchCrate {
     inherit pname version;
-    sha256 = "sha256-6t2yJM3LAG1LY5MAXg/7lwmufEEO8dqOZJgQXICmLf8=";
+    sha256 = "sha256-3SaR3ug9J1nqhbM8OW9oIM8mJwbw99YXrPgSIHsDG/0=";
   };
 
-  cargoHash = "sha256-NsKiTsdfC1UPTLKBibVGXSx5wZubAMgIWLiEMzR5p6g=";
+  cargoHash = "sha256-bNDM7RJCclEMRZ+BlXy0ALLZZ3Wu7wjxPMRmSeWNaVw=";
 
   nativeBuildInputs = [
     installShellFiles

pkgs/tools/misc/paps/default.nix

···
     description = "Pango to PostScript converter";
     homepage = "https://github.com/dov/paps";
     license = licenses.lgpl2;
-    maintainers = with maintainers; [ etu ];
+    maintainers = with maintainers; [ ];
     platforms = platforms.linux;
   };
 }

pkgs/tools/package-management/nix/common.nix

···
   atLeast24 = lib.versionAtLeast version "2.4pre";
   atLeast25 = lib.versionAtLeast version "2.5pre";
   atLeast27 = lib.versionAtLeast version "2.7pre";
+  atLeast210 = lib.versionAtLeast version "2.10pre";
 in
 { stdenv
 , autoconf-archive
···
   installFlags = [ "sysconfdir=$(out)/etc" ];
 
   doInstallCheck = true;
+  installCheckTarget = if atLeast210 then "installcheck" else null;
 
   # socket path becomes too long otherwise
   preInstallCheck = lib.optionalString stdenv.isDarwin ''

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

···
     };
   }).override { boehmgc = boehmgc-nix_2_3; };
 
-  nix_2_4 = common {
-    version = "2.4";
-    sha256 = "sha256-op48CCDgLHK0qV1Batz4Ln5FqBiRjlE6qHTiZgt3b6k=";
-    # https://github.com/NixOS/nix/pull/5537
-    patches = [ ./patches/install-nlohmann_json-headers.patch ];
-  };
+  nix_2_4 = throw "nixVersions.nix_2_4 has been removed";
 
-  nix_2_5 = common {
-    version = "2.5.1";
-    sha256 = "sha256-GOsiqy9EaTwDn2PLZ4eFj1VkXcBUbqrqHehRE9GuGdU=";
-    # https://github.com/NixOS/nix/pull/5536
-    patches = [ ./patches/install-nlohmann_json-headers.patch ];
-  };
+  nix_2_5 = throw "nixVersions.nix_2_5 has been removed";
 
-  nix_2_6 = common {
-    version = "2.6.1";
-    sha256 = "sha256-E9iQ7f+9Z6xFcUvvfksTEfn8LsDfzmwrcRBC//5B3V0=";
-  };
+  nix_2_6 = throw "nixVersions.nix_2_6 has been removed";
 
-  nix_2_7 = common {
-    version = "2.7.0";
-    sha256 = "sha256-m8tqCS6uHveDon5GSro5yZor9H+sHeh+v/veF1IGw24=";
-    patches = [
-      # remove when there's a 2.7.1 release
-      # https://github.com/NixOS/nix/pull/6297
-      # https://github.com/NixOS/nix/issues/6243
-      # https://github.com/NixOS/nixpkgs/issues/163374
-      (fetchpatch {
-        url = "https://github.com/NixOS/nix/commit/c9afca59e87afe7d716101e6a75565b4f4b631f7.patch";
-        sha256 = "sha256-xz7QnWVCI12lX1+K/Zr9UpB93b10t1HS9y/5n5FYf8Q=";
-      })
-    ];
-  };
+  nix_2_7 = throw "nixVersions.nix_2_7 has been removed";
 
   nix_2_8 = common {
     version = "2.8.1";
···
   };
 
   nix_2_9 = common {
-    version = "2.9.1";
-    sha256 = "sha256-qNL3lQPBsnStkru3j1ajN/H+knXI+X3dku8/dBfSw3g=";
-    patches = [
-      # add missing --git-dir flags
-      # remove once 2.9.2 is out
-      (fetchpatch {
-        url = "https://github.com/NixOS/nix/commit/1a994cc35b33dcfd484e7a96be0e76e23bfb9029.patch";
-        sha256 = "sha256-7rDlqWRSVPijbvrTm4P+YykbMWyJryorXqGLEgg8/Wo=";
-      })
-    ];
+    version = "2.9.2";
+    sha256 = "sha256-uZCaBo9rdWRO/AlQMvVVjpAwzYijB2H5KKQqde6eHkg=";
+  };
+
+  nix_2_10 = common {
+    version = "2.10.2";
+    sha256 = "sha256-/8zlkXoZEZd+LgJq5xw8h+u2STqeKLrGTARZklE3CP8=";
+    patches = [ ./patches/flaky-tests.patch ];
   };
 
-  stable = self.nix_2_9;
+  stable = self.nix_2_10;
 
   unstable = self.stable;
 })

pkgs/tools/package-management/nix/patches/flaky-tests.patch

···
+diff --git a/mk/run_test.sh b/mk/run_test.sh
+index 7e95df2ac..58420c317 100755
+--- a/mk/run_test.sh
++++ b/mk/run_test.sh
+@@ -27,7 +27,6 @@ run_test "$1"
+ # appear randomly without anyone knowing why.
+ # See https://github.com/NixOS/nix/issues/3605 for more info
+ if [[ $status -ne 0 && $status -ne 99 && \
+-    "$(uname)" == "Darwin" && \
+     "$log" =~ "unexpected EOF reading a line" \
+ ]]; then
+     echo "$post_run_msg [${yellow}FAIL$normal] (possibly flaky, so will be retried)"

pkgs/tools/package-management/nix/patches/install-nlohmann_json-headers.patch

···
-From 3884f7a69a57d8ecfcbcaae476ec2ff53ffbd549 Mon Sep 17 00:00:00 2001
-From: Robert Hensing <[e-mail]>
-Date: Thu, 11 Nov 2021 11:03:21 +0100
-Subject: [PATCH] Install nlohmann_json headers
-
-These headers are included by the libexpr, libfetchers, libstore
-and libutil headers.
-Considering that these are vendored sources, Nix should expose them,
-as it is not a good idea for reverse dependencies to rely on a
-potentially different source that can go out of sync.
----
- Makefile              | 1 +
- src/nlohmann/local.mk | 2 ++
- 2 files changed, 3 insertions(+)
- create mode 100644 src/nlohmann/local.mk
-
-diff --git a/Makefile b/Makefile
-index 5040d288485..e6ce50cbdb7 100644
---- a/Makefile
-+++ b/Makefile
-@@ -10,6 +10,7 @@ makefiles = \
-   src/libexpr/local.mk \
-   src/libcmd/local.mk \
-   src/nix/local.mk \
-+  src/nlohmann/local.mk \
-   src/resolve-system-dependencies/local.mk \
-   scripts/local.mk \
-   misc/bash/local.mk \
-diff --git a/src/nlohmann/local.mk b/src/nlohmann/local.mk
-new file mode 100644
-index 00000000000..63c427e000e
---- /dev/null
-+++ b/src/nlohmann/local.mk
-@@ -0,0 +1,2 @@
-+$(foreach i, $(wildcard src/nlohmann/*.hpp), \
-+  $(eval $(call install-file-in, $(i), $(includedir)/nlohmann, 0644)))

pkgs/tools/security/httpx/default.nix

···
 
 buildGoModule rec {
   pname = "httpx";
-  version = "1.2.2";
+  version = "1.2.3";
 
   src = fetchFromGitHub {
     owner = "projectdiscovery";
     repo = "httpx";
     rev = "v${version}";
-    sha256 = "sha256-DfbogRkxFiiW/UF9mKrq8x4nQvNj7D7D76/DsaTA/A0=";
+    sha256 = "sha256-gBt1xllfzw8M+n+vgUmOQ3vgDxDuDaQ7YXfWdLWnpVk=";
   };
 
-  vendorSha256 = "sha256-ZI56as5eD2Q2JNc5+lv4A7ja6cbZ9kha7ofUaOAkeHg=";
+  vendorSha256 = "sha256-9ZwRbeZ1iSuJiIJDBauU1U9PpGn8QQPTd3MfrnSmF+w=";
 
   meta = with lib; {
     description = "Fast and multi-purpose HTTP toolkit";

pkgs/top-level/all-packages.nix

···
 
   kea = callPackage ../tools/networking/kea { };
 
+  iredis = callPackage ../tools/admin/iredis { };
+
   ispell = callPackage ../tools/text/ispell {};
 
   iodash = callPackage ../development/libraries/iodash { };
···
     inherit (gnome2) libart_lgpl;
   });
 
-  gnat = gnat11;
+  gnat = gnat12;
 
   gnat6 = wrapCC (gcc6.cc.override {
     name = "gnat";
···
     gnatboot =
       if stdenv.hostPlatform == stdenv.targetPlatform
          && stdenv.buildPlatform == stdenv.hostPlatform
-      then buildPackages.gnat6
+      then buildPackages.gnatboot
       else buildPackages.gnat9;
   });
 
···
     gnatboot =
       if stdenv.hostPlatform == stdenv.targetPlatform
          && stdenv.buildPlatform == stdenv.hostPlatform
-      then buildPackages.gnat6
+      then buildPackages.gnatboot
       else buildPackages.gnat10;
   });
 
···
     gnatboot =
       if stdenv.hostPlatform == stdenv.targetPlatform
          && stdenv.buildPlatform == stdenv.hostPlatform
-      then buildPackages.gnat6
+      then buildPackages.gnatboot
       else buildPackages.gnat11;
   });
 
···
     gnatboot =
       if stdenv.hostPlatform == stdenv.targetPlatform
          && stdenv.buildPlatform == stdenv.hostPlatform
-      then buildPackages.gnat6
+      then buildPackages.gnatboot
       else buildPackages.gnat12;
   });
 
···
 
   rman = callPackage ../development/tools/misc/rman { };
 
-  rnix-lsp = callPackage ../development/tools/rnix-lsp { };
+  rnix-lsp = callPackage ../development/tools/rnix-lsp { nix = nixVersions.nix_2_9; };
 
   rnginline = with python3Packages; toPythonApplication rnginline;
 
···
   xmonad-with-packages = callPackage ../applications/window-managers/xmonad/wrapper.nix {
     inherit (haskellPackages) ghcWithPackages;
     packages = _: [ haskellPackages.xmonad-contrib ];
+  };
+
+  xmonadctl = callPackage ../applications/window-managers/xmonad/xmonadctl.nix {
+    inherit (haskellPackages) ghcWithPackages;
   };
 
   xmonad_log_applet = callPackage ../applications/window-managers/xmonad/log-applet {

pkgs/top-level/release-haskell.nix

···
         vaultenv
         wstunnel
         xmobar
+        xmonadctl
         xmonad-with-packages
         yi
         zsh-git-prompt