Merge staging-next into staging

nixos/modules/services/monitoring/apcupsd.nix

···
 
   );
 
+  # Ensure the CLI uses our generated configFile
+  wrappedBinaries = pkgs.runCommandLocal "apcupsd-wrapped-binaries"
+    { nativeBuildInputs = [ pkgs.makeWrapper ]; }
+    ''
+      for p in "${lib.getBin pkgs.apcupsd}/bin/"*; do
+          bname=$(basename "$p")
+          makeWrapper "$p" "$out/bin/$bname" --add-flags "-f ${configFile}"
+      done
+    '';
+
+  apcupsdWrapped = pkgs.symlinkJoin {
+    name = "apcupsd-wrapped";
+    # Put wrappers first so they "win"
+    paths = [ wrappedBinaries pkgs.apcupsd ];
+  };
 in
 
 {
···
     } ];
 
     # Give users access to the "apcaccess" tool
-    environment.systemPackages = [ pkgs.apcupsd ];
+    environment.systemPackages = [ apcupsdWrapped ];
 
     # NOTE 1: apcupsd runs as root because it needs permission to run
     # "shutdown"

nixos/tests/all-tests.nix

···
   allTerminfo = handleTest ./all-terminfo.nix {};
   alps = handleTest ./alps.nix {};
   amazon-init-shell = handleTest ./amazon-init-shell.nix {};
+  apcupsd = handleTest ./apcupsd.nix {};
   apfs = handleTest ./apfs.nix {};
   apparmor = handleTest ./apparmor.nix {};
   atd = handleTest ./atd.nix {};

nixos/tests/apcupsd.nix

···
+let
+  # arbitrary address
+  ipAddr = "192.168.42.42";
+in
+import ./make-test-python.nix ({ lib, pkgs, ... }: {
+  name = "apcupsd";
+  meta.maintainers = with lib.maintainers; [ bjornfor ];
+
+  nodes = {
+    machine = {
+      services.apcupsd = {
+        enable = true;
+        configText = ''
+          UPSTYPE usb
+          BATTERYLEVEL 42
+          # Configure NISIP so that the only way apcaccess can work is to read
+          # this config.
+          NISIP ${ipAddr}
+        '';
+      };
+      networking.interfaces.eth1 = {
+        ipv4.addresses = [{
+          address = ipAddr;
+          prefixLength = 24;
+        }];
+      };
+    };
+  };
+
+  # Check that the service starts, that the CLI (apcaccess) works and that it
+  # uses the config (ipAddr) defined in the service config.
+  testScript = ''
+    start_all()
+    machine.wait_for_unit("apcupsd.service")
+    machine.wait_for_open_port(3551, "${ipAddr}")
+    res = machine.succeed("apcaccess")
+    expect_line="MBATTCHG : 42 Percent"
+    assert "MBATTCHG : 42 Percent" in res, f"expected apcaccess output to contain '{expect_line}' but got '{res}'"
+    machine.shutdown()
+  '';
+})

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

···
     meta.homepage = "https://github.com/chentoast/marks.nvim/";
   };
 
+  mason-lspconfig-nvim = buildVimPluginFrom2Nix {
+    pname = "mason-lspconfig.nvim";
+    version = "2022-07-25";
+    src = fetchFromGitHub {
+      owner = "williamboman";
+      repo = "mason-lspconfig.nvim";
+      rev = "ad3b109cff22af979ab3d15564cd63dc3ae2f0f0";
+      sha256 = "0jvnc9zlr5cazdrhjm1v0bjkrz5lb2z8dzlkq59b433f52qv9zrf";
+    };
+    meta.homepage = "https://github.com/williamboman/mason-lspconfig.nvim/";
+  };
+
+  mason-tool-installer-nvim = buildVimPluginFrom2Nix {
+    pname = "mason-tool-installer.nvim";
+    version = "2022-07-26";
+    src = fetchFromGitHub {
+      owner = "WhoIsSethDaniel";
+      repo = "mason-tool-installer.nvim";
+      rev = "6d9276655c09ef2358ddb105cac4a34cfa8853c0";
+      sha256 = "0j5k9fhjffkx3b5asnwxzj22fvncs69vs0rkx13ii3gdvwczbc5w";
+    };
+    meta.homepage = "https://github.com/WhoIsSethDaniel/mason-tool-installer.nvim/";
+  };
+
+
+  mason-nvim = buildVimPluginFrom2Nix {
+    pname = "mason.nvim";
+    version = "2022-07-27";
+    src = fetchFromGitHub {
+      owner = "williamboman";
+      repo = "mason.nvim";
+      rev = "269ee222f76e705619da2c0130c0a06e76419b88";
+      sha256 = "1bngr68gfv33p989dqhz6xmhips7i2yjni96qgnqwhdjczfw865v";
+    };
+    meta.homepage = "https://github.com/williamboman/mason.nvim/";
+  };
+
   matchit-zip = buildVimPluginFrom2Nix {
     pname = "matchit.zip";
     version = "2010-10-18";

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

···
     '';
   });
 
+  mason-lspconfig-nvim = super.mason-lspconfig-nvim.overrideAttrs (old: {
+    dependencies = with self; [ mason-nvim nvim-lspconfig ];
+  });
+
+  mason-tool-installer-nvim = super.mason-tool-installer-nvim.overrideAttrs (old: {
+    dependencies = with self; [ mason-nvim ];
+  });
+
   meson = buildVimPluginFrom2Nix {
     inherit (meson) pname version src;
     preInstall = "cd data/syntax-highlighting/vim";

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

···
 https://github.com/mkasa/lushtags/,,
 https://github.com/iamcco/markdown-preview.nvim/,,
 https://github.com/chentoast/marks.nvim/,,
+https://github.com/williamboman/mason-lspconfig.nvim/,HEAD,
+https://github.com/WhoIsSethDaniel/mason-tool-installer.nvim/,HEAD,
+https://github.com/williamboman/mason.nvim/,HEAD,
 https://github.com/vim-scripts/matchit.zip/,,
 https://github.com/marko-cerovac/material.nvim/,,
 https://github.com/kaicataldo/material.vim/,HEAD,

pkgs/applications/misc/limesctl/default.nix

···
 
 buildGoModule rec {
   pname = "limesctl";
-  version = "3.1.1";
+  version = "3.1.3";
 
   src = fetchFromGitHub {
     owner = "sapcc";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-/CYZMuW5/YoZszTOaQZLRhJdZAGGMY+s7vMK01hyMvg=";
+    sha256 = "sha256-fi36jsQr/Mn1FyOlle/WSpREQgZU6+h4IJzd3ZfItvI=";
   };
 
-  vendorSha256 = "sha256-BwhbvCUOOp5ZeY/22kIZ58e+iPH0pVgiNOyoD6O2zPo=";
+  vendorSha256 = "sha256-gcIPASIk4Zq8y+KppYNRkf/9guCsYv9XskFANrqOCts=";
 
   subPackages = [ "." ];
 

pkgs/applications/networking/browsers/chromium/upstream-info.json

···
     }
   },
   "beta": {
-    "version": "109.0.5414.61",
-    "sha256": "1dk832ishjhba0rnf57w7vqrr8dyqga6zsgw9945i7zz997fpjyi",
-    "sha256bin64": "1s1d7h9ygzpa5b39pdivn5vvpm7fpnhw5p3lz8blrgn61m8h6jg6",
+    "version": "109.0.5414.74",
+    "sha256": "0pcfaj3n3rjk4va9g0ajlsv1719kdhqcnjdd4piinqxb4qy27vgd",
+    "sha256bin64": "1ihjjf8x5080p9bizhqrrr0rcjf0l1nps9xq9naa2f48y5zfshkd",
     "deps": {
       "gn": {
         "version": "2022-11-10",

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

···
   mkTerraform = attrs: pluggable (generic attrs);
 
   terraform_1 = mkTerraform {
-    version = "1.3.6";
-    sha256 = "sha256-aETsvcHoHSwqWCAdn9JPJLcX1Wi1umUghSjkq37OYDU=";
+    version = "1.3.7";
+    sha256 = "sha256-z49DXJ9oYObJQWHPeuKvQ6jJtAheYuy0+QmvZ74ZbTQ";
     vendorSha256 = "sha256-fviukVGBkbxFs2fJpEp/tFMymXex7NRQdcGIIA9W88k=";
     patches = [ ./provider-path-0_15.patch ];
     passthru = {

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

···
+{ lib, appimageTools, fetchurl }:
+
+let
+  pname = "keet";
+  version = "1.2.1";
+
+  src = fetchurl {
+    url = "https://keet.io/downloads/${version}/Keet.AppImage";
+    sha256 = "1f76ccfa16719a24f6d84b88e5ca49fab1c372de309ce74393461903c5c49d98";
+  };
+
+  appimageContents = appimageTools.extract { inherit pname version src; };
+in appimageTools.wrapType2 {
+  inherit src pname version;
+
+  extraInstallCommands = ''
+    mv $out/bin/${pname}-${version} $out/bin/${pname}
+
+    install -m 444 -D ${appimageContents}/${pname}.desktop -t $out/share/applications
+    substituteInPlace $out/share/applications/${pname}.desktop \
+      --replace 'Exec=AppRun' 'Exec=${pname}'
+    cp -r ${appimageContents}/usr/share/icons $out/share
+  '';
+
+  meta = with lib; {
+    description = "Peer-to-Peer Chat";
+    homepage = "https://keet.io";
+    license = licenses.unfree;
+    maintainers = with maintainers; [ extends ];
+    platforms = [ "x86_64-linux" ];
+  };
+}

pkgs/applications/networking/seaweedfs/default.nix

···
 
 buildGoModule rec {
   pname = "seaweedfs";
-  version = "3.34";
+  version = "3.38";
 
   src = fetchFromGitHub {
-    owner = "chrislusf";
+    owner = "seaweedfs";
     repo = "seaweedfs";
     rev = version;
-    hash = "sha256-lOCZHkLJCDvaT3CcHUBbsybdy0H6BfKKGpd/73cxcWA=";
+    hash = "sha256-LYMGkv1rgUtA/TwulBhgw0w+8kbICtEgr7/K6exalxM=";
   };
 
-  vendorHash = "sha256-1RUWONkXArXYg8gQogKUhMSGdIYyT3lq5qWuUQBsFig=";
+  vendorHash = "sha256-mwfs/tdq1Qq2auEwz24emf7pjpIJAncI78oxhAn2WkI=";
 
   subPackages = [ "weed" ];
 
···
   meta = with lib; {
     description = "Simple and highly scalable distributed file system";
     homepage = "https://github.com/chrislusf/seaweedfs";
-    maintainers = with maintainers; [ azahi cmacrae ];
+    maintainers = with maintainers; [ azahi cmacrae wozeparrot ];
     mainProgram = "weed";
     license = licenses.asl20;
   };

pkgs/data/misc/hackage/pin.json

···
 {
-  "commit": "208dc93f04d6fb2dbc01e11434c7dcea50a8a9e6",
-  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/208dc93f04d6fb2dbc01e11434c7dcea50a8a9e6.tar.gz",
-  "sha256": "19pgh69fj3p1glqyjikpsvn5j4bax6yw5qxf9qaaap19hksgn85p",
-  "msg": "Update from Hackage at 2022-12-28T16:35:05Z"
+  "commit": "78541d36393ac3dd0ffa32b4a9af15fecdefb5d1",
+  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/78541d36393ac3dd0ffa32b4a9af15fecdefb5d1.tar.gz",
+  "sha256": "1qwjkjlz9sw1jnsarin6803vj68bfm3iyysfwxaifga5w4dsrqcs",
+  "msg": "Update from Hackage at 2022-12-30T22:03:31Z"
 }

pkgs/development/compilers/blueprint/default.nix

···
-{ gtk4
-, python3
-, stdenv
-, fetchFromGitLab
+{ fetchFromGitLab
 , gobject-introspection
+, gtk4
 , lib
 , meson
 , ninja
+, python3
+, stdenv
 , testers
 }:
-
 stdenv.mkDerivation (finalAttrs: {
   pname = "blueprint-compiler";
   version = "0.6.0";
···
     hash = "sha256-L6EGterkZ8EB6xSnJDZ3IMuOumpTpEGnU74X3UgC7k0=";
   };
 
-  doCheck = true;
-
   nativeBuildInputs = [
     meson
     ninja
   ];
 
   buildInputs = [
-    python3
-    gtk4
-  ] ++ (with python3.pkgs; [
-    pygobject3
-    wrapPython
-  ]);
+    (python3.withPackages (ps: with ps; [
+      pygobject3
+    ]))
+  ];
 
   propagatedBuildInputs = [
+    # For setup hook, so that the compiler can find typelib files
     gobject-introspection
   ];
 
-  postFixup = ''
-    makeWrapperArgs="\
-      --prefix GI_TYPELIB_PATH : $GI_TYPELIB_PATH \
-      --prefix PYTHONPATH : \"$(toPythonPath $out):$(toPythonPath ${python3.pkgs.pygobject3})\""
-    wrapPythonPrograms
-  '';
+  doCheck = true;
+
+  checkInputs = [
+    gtk4
+  ];
 
   passthru.tests.version = testers.testVersion {
     package = finalAttrs.finalPackage;

pkgs/development/compilers/emscripten/default.nix

···
 , llvmPackages
 , symlinkJoin, makeWrapper, substituteAll
 , mkYarnModules
+, emscripten
 }:
 
 stdenv.mkDerivation rec {
···
 
     runHook postInstall
   '';
+
+  passthru = {
+    # HACK: Make emscripten look more like a cc-wrapper to GHC
+    # when building the javascript backend.
+    targetPrefix = "em";
+    bintools = emscripten;
+  };
 
   meta = with lib; {
     homepage = "https://github.com/emscripten-core/emscripten";

pkgs/development/compilers/ghc/8.10.7.nix

···
 
 , # If enabled, GHC will be built with the GPL-free but slower integer-simple
   # library instead of the faster but GPLed integer-gmp library.
-  enableIntegerSimple ? !(lib.meta.availableOn stdenv.hostPlatform gmp), gmp
+  enableIntegerSimple ? !(lib.meta.availableOn stdenv.hostPlatform gmp
+                          && lib.meta.availableOn stdenv.targetPlatform gmp)
+, gmp
 
 , # If enabled, use -fPIC when compiling static libs.
   enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform

pkgs/development/compilers/ghc/8.8.4.nix

···
 
 , # If enabled, GHC will be built with the GPL-free but slower integer-simple
   # library instead of the faster but GPLed integer-gmp library.
-  enableIntegerSimple ? !(lib.meta.availableOn stdenv.hostPlatform gmp), gmp
+  enableIntegerSimple ? !(lib.meta.availableOn stdenv.hostPlatform gmp
+                          && lib.meta.availableOn stdenv.targetPlatform gmp)
+, gmp
 
 , # If enabled, use -fPIC when compiling static libs.
   enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform

pkgs/development/compilers/ghc/9.0.2.nix

···
 
 , # If enabled, GHC will be built with the GPL-free but slightly slower native
   # bignum backend instead of the faster but GPLed gmp backend.
-  enableNativeBignum ? !(lib.meta.availableOn stdenv.hostPlatform gmp)
+  enableNativeBignum ? !(lib.meta.availableOn stdenv.hostPlatform gmp
+                         && lib.meta.availableOn stdenv.targetPlatform gmp)
 , gmp
 
 , # If enabled, use -fPIC when compiling static libs.

pkgs/development/compilers/ghc/9.2.4.nix

···
 
 , # If enabled, GHC will be built with the GPL-free but slightly slower native
   # bignum backend instead of the faster but GPLed gmp backend.
-  enableNativeBignum ? !(lib.meta.availableOn stdenv.hostPlatform gmp)
+  enableNativeBignum ? !(lib.meta.availableOn stdenv.hostPlatform gmp
+                         && lib.meta.availableOn stdenv.targetPlatform gmp)
 , gmp
 
 , # If enabled, use -fPIC when compiling static libs.

pkgs/development/compilers/ghc/9.2.5.nix

···
 
 , # If enabled, GHC will be built with the GPL-free but slightly slower native
   # bignum backend instead of the faster but GPLed gmp backend.
-  enableNativeBignum ? !(lib.meta.availableOn stdenv.hostPlatform gmp)
+  enableNativeBignum ? !(lib.meta.availableOn stdenv.hostPlatform gmp
+                         && lib.meta.availableOn stdenv.targetPlatform gmp)
 , gmp
 
 , # If enabled, use -fPIC when compiling static libs.

pkgs/development/compilers/ghc/9.4.2.nix

···
 
 , # If enabled, GHC will be built with the GPL-free but slightly slower native
   # bignum backend instead of the faster but GPLed gmp backend.
-  enableNativeBignum ? !(lib.meta.availableOn stdenv.hostPlatform gmp)
+  enableNativeBignum ? !(lib.meta.availableOn stdenv.hostPlatform gmp
+                         && lib.meta.availableOn stdenv.targetPlatform gmp)
 , gmp
 
 , # If enabled, use -fPIC when compiling static libs.

pkgs/development/compilers/ghc/9.4.3.nix

···
 
 , # If enabled, GHC will be built with the GPL-free but slightly slower native
   # bignum backend instead of the faster but GPLed gmp backend.
-  enableNativeBignum ? !(lib.meta.availableOn stdenv.hostPlatform gmp)
+  enableNativeBignum ? !(lib.meta.availableOn stdenv.hostPlatform gmp
+                         && lib.meta.availableOn stdenv.targetPlatform gmp)
 , gmp
 
 , # If enabled, use -fPIC when compiling static libs.

pkgs/development/compilers/ghc/9.4.4.nix

···
 
 , # If enabled, GHC will be built with the GPL-free but slightly slower native
   # bignum backend instead of the faster but GPLed gmp backend.
-  enableNativeBignum ? !(lib.meta.availableOn stdenv.hostPlatform gmp)
+  enableNativeBignum ? !(lib.meta.availableOn stdenv.hostPlatform gmp
+                         && lib.meta.availableOn stdenv.targetPlatform gmp)
 , gmp
 
 , # If enabled, use -fPIC when compiling static libs.

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

···
 , useLLVM ? !(stdenv.targetPlatform.isx86
               || stdenv.targetPlatform.isPower
               || stdenv.targetPlatform.isSparc
-              || (stdenv.targetPlatform.isAarch64 && stdenv.targetPlatform.isDarwin))
+              || (stdenv.targetPlatform.isAarch64 && stdenv.targetPlatform.isDarwin)
+              || stdenv.targetPlatform.isGhcjs)
 , # LLVM is conceptually a run-time-only depedendency, but for
   # non-x86, we need LLVM to bootstrap later stages, so it becomes a
   # build-time dependency too.
···
 
 , # If enabled, GHC will be built with the GPL-free but slightly slower native
   # bignum backend instead of the faster but GPLed gmp backend.
-  enableNativeBignum ? !(lib.meta.availableOn stdenv.hostPlatform gmp)
+  enableNativeBignum ? !(lib.meta.availableOn stdenv.hostPlatform gmp
+                         && lib.meta.availableOn stdenv.targetPlatform gmp)
+                       || stdenv.targetPlatform.isGhcjs
 , gmp
 
 , # If enabled, use -fPIC when compiling static libs.
···
   enableShared ? with stdenv.targetPlatform; !isWindows && !useiOSPrebuilt && !isStatic
 
 , # Whether to build terminfo.
-  enableTerminfo ? !stdenv.targetPlatform.isWindows
+  enableTerminfo ? !(stdenv.targetPlatform.isWindows
+                     || stdenv.targetPlatform.isGhcjs)
 
 , # Libdw.c only supports x86_64, i686 and s390x as of 2022-08-04
   enableDwarf ? (stdenv.targetPlatform.isx86 ||
···
 
 assert !enableNativeBignum -> gmp != null;
 
-assert stdenv.hostPlatform == stdenv.targetPlatform || throw ''
-  hadrian doesn't support building an installable GHC cross-compiler at the moment.
-  Consider using GHC 9.4 or lower which support this via the make build system.
-  See also: https://gitlab.haskell.org/ghc/ghc/-/issues/22090
-'';
-
 let
   src = (if rev != null then fetchgit else fetchurl) ({
     inherit url sha256;
···
 
   # Splicer will pull out correct variations
   libDeps = platform: lib.optional enableTerminfo ncurses
-    ++ [libffi]
+    ++ lib.optionals (!targetPlatform.isGhcjs) [libffi]
     # Bindist configure script fails w/o elfutils in linker search path
     # https://gitlab.haskell.org/ghc/ghc/-/issues/22081
     ++ lib.optional enableDwarf elfutils
     ++ lib.optional (!enableNativeBignum) gmp
-    ++ lib.optional (platform.libc != "glibc" && !targetPlatform.isWindows) libiconv;
+    ++ lib.optional (platform.libc != "glibc" && !targetPlatform.isWindows && !targetPlatform.isGhcjs) libiconv;
 
   # TODO(@sternenseemann): is buildTarget LLVM unnecessary?
   # GHC doesn't seem to have {LLC,OPT}_HOST
   toolsForTarget = [
-    pkgsBuildTarget.targetPackages.stdenv.cc
+    (if targetPlatform.isGhcjs
+     then pkgsBuildTarget.emscripten
+     else pkgsBuildTarget.targetPackages.stdenv.cc)
   ] ++ lib.optional useLLVM buildTargetLlvmPackages.llvm;
 
   targetCC = builtins.head toolsForTarget;
···
 # C compiler, bintools and LLVM are used at build time, but will also leak into
 # the resulting GHC's settings file and used at runtime. This means that we are
 # currently only able to build GHC if hostPlatform == buildPlatform.
-assert targetCC == pkgsHostTarget.targetPackages.stdenv.cc;
+assert !targetPlatform.isGhcjs -> targetCC == pkgsHostTarget.targetPackages.stdenv.cc;
 assert buildTargetLlvmPackages.llvm == llvmPackages.llvm;
 assert stdenv.targetPlatform.isDarwin -> buildTargetLlvmPackages.clang == llvmPackages.clang;
 
···
                     '*-android*|*-gnueabi*|*-musleabi*)'
       done
   ''
+  # Need to make writable EM_CACHE for emscripten
+  # https://gitlab.haskell.org/ghc/ghc/-/wikis/javascript-backend#configure-fails-with-sub-word-sized-atomic-operations-not-available
+  + lib.optionalString targetPlatform.isGhcjs ''
+    export EM_CACHE="$(mktemp -d emcache.XXXXXXXXXX)"
+    cp -Lr ${targetCC /* == emscripten */}/share/emscripten/cache/* "$EM_CACHE/"
+    chmod u+rwX -R "$EM_CACHE"
+  ''
   # Create bash array hadrianFlagsArray for use in buildPhase. Do it in
   # preConfigure, so overrideAttrs can be used to modify it effectively.
   # hadrianSettings are passed via the command line so they are more visible
···
       ${lib.escapeShellArgs hadrianSettings}
     )
   '';
+
+  ${if targetPlatform.isGhcjs then "configureScript" else null} = "emconfigure ./configure";
 
   # TODO(@Ericson2314): Always pass "--target" and always prefix.
   configurePlatforms = [ "build" "host" ]
···
   configureFlags = [
     "--datadir=$doc/share/doc/ghc"
     "--with-curses-includes=${ncurses.dev}/include" "--with-curses-libraries=${ncurses.out}/lib"
-  ] ++ lib.optionals (libffi != null) [
+  ] ++ lib.optionals (libffi != null && !targetPlatform.isGhcjs) [
     "--with-system-libffi"
     "--with-ffi-includes=${targetPackages.libffi.dev}/include"
     "--with-ffi-libraries=${targetPackages.libffi.out}/lib"
···
     autoSignDarwinBinariesHook
   ] ++ lib.optionals enableDocs [
     sphinx
+  ] ++ lib.optionals targetPlatform.isGhcjs [
+    # emscripten itself is added via depBuildTarget / targetCC
+    python3
   ];
 
   # For building runtime libs
···
   preInstall = ''
     pushd _build/bindist/*
 
-    ./configure $configureFlags "''${configureFlagsArray[@]}"
+    $configureScript $configureFlags "''${configureFlagsArray[@]}"
   '';
 
   postInstall = ''

pkgs/development/compilers/ghc/head.nix

···
 import ./common-hadrian.nix {
-  version = "9.5.20220921";
-  rev = "2463df2fe21b5b37ecada3df8c6726c534d24590";
-  sha256 = "1k2h4myqbs31fdzw5n4iw0qn44mp7d33kjwrr15ix4r54r8yskzs";
+  version = "9.7.20221224";
+  rev = "a5bd0eb8dd1d03c54e1b0b476ebbc4cc886d6f19";
+  sha256 = "1rrds9alzpy4vyh2isan32h1zmf44nsr8552wbsn1y3fg6bnpbxi";
 }

pkgs/development/compilers/openjdk/19.nix

···
 , libXi, libXinerama, libXcursor, libXrandr, fontconfig, openjdk19-bootstrap
 , ensureNewerSourcesForZipFilesHook
 , setJavaClassPath
-, headless ? false
+# TODO(@sternenseemann): gtk3 fails to evaluate in pkgsCross.ghcjs.buildPackages
+# which should be fixable, this is a no-rebuild workaround for GHC.
+, headless ? stdenv.targetPlatform.isGhcjs
 , enableJavaFX ? openjfx.meta.available, openjfx
 , enableGnome2 ? true, gtk3, gnome_vfs, glib, GConf
 }:

pkgs/development/compilers/temurin-bin/jdk-linux-base.nix

···
 # runtime dependencies
 , cups
 # runtime dependencies for GTK+ Look and Feel
-, gtkSupport ? true
+# TODO(@sternenseemann): gtk3 fails to evaluate in pkgsCross.ghcjs.buildPackages
+# which should be fixable, this is a no-rebuild workaround for GHC.
+, gtkSupport ? !stdenv.targetPlatform.isGhcjs
 , cairo
 , glib
 , gtk3

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

···
   # https://github.com/haskell-nix/hnix-store/issues/180
   hnix-store-core = doJailbreak super.hnix-store-core;
 
-  # Too strict upper bound on bytestring
-  # https://github.com/wangbj/hashing/issues/3
-  hashing = doJailbreak super.hashing;
-
   # Fails for non-obvious reasons while attempting to use doctest.
   focuslist = dontCheck super.focuslist;
   search = dontCheck super.search;
···
   servant-swagger-ui-core = doJailbreak super.servant-swagger-ui-core;
 
   hercules-ci-agent = lib.pipe super.hercules-ci-agent [
-    (appendPatches [
-      # haskell-updates branch, will be merged in 0.9.10
-      (fetchpatch2 {
-        name = "hercules-ci-agent-cachix-1.1";
-        url = "https://github.com/hercules-ci/hercules-ci-agent/commit/b76d888548da37a96ae47f1be871de6605d38edd.patch";
-        sha256 = "sha256-kqEkDHbatcYS8LuQlGV/1j/6LXWviQoDQAHDr6DBbDU=";
-        stripLen = 1;
-        includes = [ "*.hs" ];
-      })
-    ])
     (self.generateOptparseApplicativeCompletions [ "hercules-ci-agent" ])
   ];
 
···
   # 2022-12-30: Restrictive upper bound on optparse-applicative
   retrie = doJailbreak super.retrie;
 
-  # Fixes https://github.com/NixOS/nixpkgs/issues/140613
-  # https://github.com/recursion-schemes/recursion-schemes/issues/128
-  recursion-schemes = overrideCabal (drv: {
-    patches = drv.patches or [] ++ [
-      ./patches/recursion-schemes-128.patch
-    ];
-    # make sure line endings don't break the patch
-    prePatch = drv.prePatch or "" + ''
-      "${pkgs.buildPackages.dos2unix}/bin/dos2unix" *.cabal
-    '';
-  }) super.recursion-schemes;
-
   # 2022-08-30 Too strict bounds on finite-typelits
   # https://github.com/jumper149/blucontrol/issues/1
   blucontrol = doJailbreak super.blucontrol;
···
       "--skip" "/toJsonSerializer/should generate valid JSON/"
     ] ++ drv.testFlags or [];
   }) super.hschema-aeson;
-  # https://gitlab.com/k0001/xmlbf/-/issues/32
-  xmlbf = overrideCabal (drv: {
-    testFlags = [
-      "-p" "!/xml: <x b=\"\" a=\"y\"><\\/x>/&&!/xml: <x b=\"z\" a=\"y\"><\\/x>/"
-    ] ++ drv.testFlags or [];
-  }) super.xmlbf;
   # https://github.com/ssadler/aeson-quick/issues/3
   aeson-quick = overrideCabal (drv: {
     testFlags = [
···
   # Test suite doesn't support hspec 2.8
   # https://github.com/zellige/hs-geojson/issues/29
   geojson = dontCheck super.geojson;
-
-  # Doesn't support aeson >= 2.0
-  # https://github.com/channable/vaultenv/issues/118
-  vaultenv = super.vaultenv.overrideScope (self: super: {
-    aeson = self.aeson_1_5_6_0;
-  });
 
   # Support network >= 3.1.2
   # https://github.com/erebe/wstunnel/pull/107
···
   } super.postgrest));
 
   html-charset = dontCheck super.html-charset;
+
+  # true-name-0.1.0.4 has been tagged, but has not been released to Hackage.
+  # Also, beyond 0.1.0.4 an additional patch is required to make true-name
+  # compatible with current versions of template-haskell
+  # https://github.com/liyang/true-name/pull/4
+  true-name = appendPatch (fetchpatch {
+    url = "https://github.com/liyang/true-name/compare/0.1.0.3...nuttycom:true-name:update_template_haskell.patch";
+    hash = "sha256-ZMBXGGc2X5AKXYbqgkLXkg5BhEwyj022E37sUEWahtc=";
+  }) (overrideCabal (drv: {
+    revision = null;
+    editedCabalFile = null;
+  }) super.true-name);
 } // import ./configuration-tensorflow.nix {inherit pkgs haskellLib;} self super

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

···
 
   # consequences of doctest breakage follow:
 
-  double-conversion = markBroken super.double-conversion;
-  blaze-textual = checkAgainAfter super.double-conversion "2.0.4.1" "double-conversion fails to build; required for testsuite" (dontCheck super.blaze-textual);
   ghc-source-gen = checkAgainAfter super.ghc-source-gen "0.4.3.0" "fails to build" (markBroken super.ghc-source-gen);
 
   lucid = jailbreakForCurrentVersion super.lucid "2.11.1";

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

···
   - Feval
   - fez-conf
   - ffeed
+  - fft
   - ffunctor
   - fgl-extras-decompositions
   - fib
···
   - heterogeneous-list-literals
   - hetris
   - heukarya
-  - hevm
   - HExcel
   - hexchat
   - hexif
···
   - HLogger
   - hlongurl
   - hls-brittany-plugin
+  - hls-call-hierarchy-plugin
   - hls-haddock-comments-plugin
   - hls-selection-range-plugin
   - hls-stan-plugin
···
   - OddWord
   - oden-go-packages
   - oeis2
+  - OGDF
   - OGL
   - ogma-language-c
   - ogma-language-cocospec
···
   - open-adt
   - OpenAFP
   - openai-hs
+  - openapi3
   - openapi3-code-generator
   - openapi-petstore
   - openapi-typed
···
   - QuickAnnotate
   - quickbooks
   - quickcheck-arbitrary-template
+  - quickcheck-monoid-subclasses
   - quickcheck-property-comb
   - quickcheck-property-monad
   - quickcheck-rematch
···
   - SNet
   - snipcheck
   - snorkels
+  - snowchecked
   - snowtify
   - socket-activation
   - socketed
···
   - stm-firehose
   - stm-incremental
   - stm-promise
+  - stm-queue
   - stm-stats
   - stochastic
   - Stomp
···
   - trivia
   - tropical
   - tropical-geometry
-  - true-name
   - tsession
   - tslib
   - tsparse
···
   - unix-recursive
   - unlift
   - unlifted-list
+  - unliftio-messagebox
   - unlift-stm
   - unm-hip
   - unordered-containers-rematch

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

···
-# Stackage LTS 20.4
+# Stackage LTS 20.5
 # This file is auto-generated by
 # maintainers/scripts/haskell/update-stackage.sh
 default-package-overrides:
···
   - ad-delcont ==0.3.0.0
   - adjunctions ==4.4.2
   - adler32 ==0.1.2.0
-  - advent-of-code-api ==0.2.8.2
+  - advent-of-code-api ==0.2.8.4
   - aern2-mp ==0.2.11.0
   - aern2-real ==0.2.11.0
   - aeson ==2.0.3.0
···
   - annotated-exception ==0.2.0.4
   - annotated-wl-pprint ==0.7.0
   - ansi-terminal ==0.11.4
-  - ansi-terminal-game ==1.8.0.1
+  - ansi-terminal-game ==1.8.1.0
   - ansi-wl-pprint ==0.6.9
   - ANum ==0.2.0.2
   - aos-signature ==0.1.1
···
   - array-memoize ==0.6.0
   - arrow-extras ==0.1.0.1
   - arrows ==0.4.4.2
-  - ascii ==1.2.3.0
-  - ascii-case ==1.0.0.11
-  - ascii-char ==1.0.0.15
+  - ascii ==1.2.4.0
+  - ascii-case ==1.0.1.1
+  - ascii-char ==1.0.0.16
   - asciidiagram ==1.3.3.3
-  - ascii-group ==1.0.0.13
+  - ascii-group ==1.0.0.14
   - ascii-numbers ==1.1.0.0
   - ascii-predicates ==1.0.1.0
   - ascii-progress ==0.3.3.0
···
   - aws-xray-client-wai ==0.1.0.2
   - backtracking ==0.1.0
   - bank-holidays-england ==0.2.0.8
-  - barbies ==2.0.3.1
+  - barbies ==2.0.4.0
   - base16 ==0.3.2.1
   - base16-bytestring ==1.0.2.0
   - base32 ==0.2.2.0
···
   - bench-show ==0.3.2
   - bencode ==0.6.1.1
   - bencoding ==0.4.5.4
-  - benri-hspec ==0.1.0.0
+  - benri-hspec ==0.1.0.1
   - between ==0.11.0.0
   - bhoogle ==0.1.4.2
   - bibtex ==0.1.0.6
···
   - bm ==0.1.0.2
   - bmp ==1.2.6.3
   - bnb-staking-csvs ==0.2.1.0
-  - BNFC ==2.9.4
+  - BNFC ==2.9.4.1
   - BNFC-meta ==0.6.1
   - bodhi ==0.1.0
   - boltzmann-samplers ==0.1.1.0
   - bookkeeping ==0.4.0.1
   - Boolean ==0.2.4
   - boolsimplifier ==0.1.8
-  - boomerang ==1.4.8
+  - boomerang ==1.4.8.1
   - boots ==0.2.0.1
   - bordacount ==0.1.0.0
   - boring ==0.2
···
   - bytes ==0.17.2
   - byteset ==0.1.1.0
   - byteslice ==0.2.7.0
-  - bytesmith ==0.3.9.0
+  - bytesmith ==0.3.9.1
   - bytestring-builder ==0.10.8.2.0
   - bytestring-conversion ==0.3.2
   - bytestring-lexing ==0.5.0.9
···
   - check-email ==1.0.2
   - checkers ==0.6.0
   - checksum ==0.0
-  - chimera ==0.3.2.0
+  - chimera ==0.3.3.0
   - choice ==0.2.2
   - chronologique ==0.3.1.3
   - chunked-data ==0.3.1
···
   - code-page ==0.2.1
   - cointracking-imports ==0.1.0.2
   - collect-errors ==0.1.5.0
+  - co-log-core ==0.3.2.0
   - Color ==0.3.3
   - colorful-monoids ==0.2.1.3
   - colorize-haskell ==1.0.1
···
   - componentm ==0.0.0.2
   - componentm-devel ==0.0.0.2
   - composable-associations ==0.1.0.0
-  - composite-base ==0.8.2.0
-  - composite-binary ==0.8.2.0
-  - composite-ekg ==0.8.2.0
+  - composite-base ==0.8.2.1
+  - composite-binary ==0.8.2.1
+  - composite-ekg ==0.8.2.1
   - composite-tuple ==0.1.2.0
   - composite-xstep ==0.1.0.0
   - composition ==1.0.2.2
···
   - data-dword ==0.3.2.1
   - data-endian ==0.1.1
   - data-fix ==0.3.2
-  - data-forest ==0.1.0.9
+  - data-forest ==0.1.0.10
   - data-functor-logistic ==0.0
   - data-has ==0.4.0.0
   - data-hash ==0.2.0.1
···
   - dejafu ==2.4.0.4
   - dense-linear-algebra ==0.1.0.0
   - dependent-map ==0.4.0.0
-  - dependent-sum ==0.7.1.0
+  - dependent-sum ==0.7.2.0
   - dependent-sum-template ==0.1.1.1
   - depq ==0.4.2
   - deque ==0.4.4
···
   - dictionary-sharing ==0.1.0.0
   - di-df1 ==1.2.1
   - Diff ==0.4.1
-  - digest ==0.0.1.3
+  - digest ==0.0.1.4
   - digits ==0.3.1
   - di-handle ==1.0.1
   - dimensional ==1.5
···
   - dl-fedora ==0.9.3
   - dlist ==1.0
   - dlist-instances ==0.1.1.1
-  - dlist-nonempty ==0.1.1
+  - dlist-nonempty ==0.1.2
   - dns ==4.1.0
   - docker ==0.7.0.1
   - dockerfile ==0.2.0
···
   - doctemplates ==0.10.0.2
   - doctest ==0.20.1
   - doctest-discover ==0.2.0.0
-  - doctest-driver-gen ==0.3.0.5
+  - doctest-driver-gen ==0.3.0.6
   - doctest-exitcode-stdio ==0.0
   - doctest-lib ==0.1
-  - doctest-parallel ==0.2.5
+  - doctest-parallel ==0.2.6
   - doldol ==0.4.1.2
   - do-list ==1.0.1
   - domain ==0.1.1.4
···
   - domain-optics ==0.1.0.3
   - do-notation ==0.1.0.2
   - dot ==0.3
-  - dotenv ==0.9.0.3
   - dotgen ==0.4.3
   - dotnet-timespan ==0.0.1.0
-  - double-conversion ==2.0.4.1
+  - double-conversion ==2.0.4.2
   - download ==0.3.2.7
   - download-curl ==0.1.4
   - DPutils ==0.1.1.0
···
   - dual ==0.1.1.1
   - dual-tree ==0.2.3.1
   - dublincore-xml-conduit ==0.1.0.2
-  - dunai ==0.9.1
+  - dunai ==0.9.2
   - duration ==0.2.0.0
   - dvorak ==0.1.0.0
   - dynamic-state ==0.3.1
···
   - errors-ext ==0.4.2
   - ersatz ==0.4.13
   - esqueleto ==3.5.8.1
-  - essence-of-live-coding ==0.2.6
-  - essence-of-live-coding-gloss ==0.2.6
-  - essence-of-live-coding-pulse ==0.2.6
-  - essence-of-live-coding-quickcheck ==0.2.6
-  - essence-of-live-coding-warp ==0.2.6
+  - essence-of-live-coding ==0.2.7
+  - essence-of-live-coding-gloss ==0.2.7
+  - essence-of-live-coding-pulse ==0.2.7
+  - essence-of-live-coding-quickcheck ==0.2.7
+  - essence-of-live-coding-warp ==0.2.7
   - event-list ==0.1.2
   - eventstore ==1.4.2
   - every ==0.0.1
   - evm-opcodes ==0.1.2
   - exact-combinatorics ==0.2.0.11
   - exact-pi ==0.5.0.2
-  - exception-hierarchy ==0.1.0.7
+  - exception-hierarchy ==0.1.0.8
   - exception-mtl ==0.4.0.1
   - exception-transformers ==0.4.0.11
   - executable-hash ==0.2.0.4
···
   - fitspec ==0.4.10
   - fixed ==0.3
   - fixed-length ==0.2.3.1
-  - fixed-vector ==1.2.1.0
+  - fixed-vector ==1.2.2.1
   - fixed-vector-hetero ==0.6.1.1
-  - fix-whitespace ==0.0.10
+  - fix-whitespace ==0.0.11
   - flac ==0.2.0
   - flac-picture ==0.1.2
   - flags-applicative ==0.1.0.3
···
   - haskell-gi ==0.26.2
   - haskell-gi-base ==0.26.3
   - haskell-gi-overloading ==1.0
-  - haskell-lexer ==1.1
+  - haskell-lexer ==1.1.1
   - HaskellNet ==0.6.0.1
   - HaskellNet-SSL ==0.3.4.4
   - haskell-src ==1.0.4
···
   - heatshrink ==0.1.0.0
   - hebrew-time ==0.1.2
   - hedgehog ==1.1.2
-  - hedgehog-classes ==0.2.5.3
+  - hedgehog-classes ==0.2.5.4
   - hedgehog-corpus ==0.2.0
   - hedgehog-fakedata ==0.0.1.5
   - hedgehog-fn ==1.0
···
   - hourglass ==0.2.12
   - hourglass-orphans ==0.1.0.0
   - hp2pretty ==0.10
-  - hpack ==0.35.0
+  - hpack ==0.35.1
   - hpack-dhall ==0.5.7
   - hpc-codecov ==0.3.0.0
   - hpc-lcov ==1.1.0
···
   - hslua-packaging ==2.2.1
   - hsndfile ==0.8.0
   - hsndfile-vector ==0.5.2
-  - HsOpenSSL ==0.11.7.2
+  - HsOpenSSL ==0.11.7.4
   - HsOpenSSL-x509-system ==0.1.0.4
   - hsp ==0.10.0
   - hspec ==2.9.7
···
   - hw-int ==0.0.2.0
   - hw-ip ==2.4.2.1
   - hw-json ==1.3.2.3
-  - hw-json-simd ==0.1.1.1
+  - hw-json-simd ==0.1.1.2
   - hw-json-simple-cursor ==0.1.1.1
   - hw-json-standard-cursor ==0.2.3.2
   - hwk ==0.6
···
   - hw-prim ==0.6.3.2
   - hw-rankselect ==0.13.4.1
   - hw-rankselect-base ==0.3.4.1
-  - hw-simd ==0.1.2.1
+  - hw-simd ==0.1.2.2
   - hw-streams ==0.0.1.0
   - hw-string-parse ==0.0.0.5
   - hw-succinct ==0.1.0.1
···
   - markov-chain ==0.0.3.4
   - markov-chain-usage-model ==0.0.0
   - mason ==0.2.5
-  - massiv ==1.0.2.0
+  - massiv ==1.0.3.0
   - massiv-io ==1.0.0.1
   - massiv-persist ==1.0.0.3
   - massiv-serialise ==1.0.0.2
···
   - microaeson ==0.1.0.1
   - microlens ==0.4.12.0
   - microlens-aeson ==2.5.0
-  - microlens-contra ==0.1.0.2
+  - microlens-contra ==0.1.0.3
   - microlens-ghc ==0.4.13.2
-  - microlens-mtl ==0.2.0.2
+  - microlens-mtl ==0.2.0.3
   - microlens-platform ==0.4.2.1
   - microlens-process ==0.2.0.2
-  - microlens-th ==0.4.3.10
+  - microlens-th ==0.4.3.11
   - microspec ==0.2.1.3
   - microstache ==1.0.2.2
   - midair ==0.2.0.1
···
   - monad-time ==0.3.1.0
   - mongoDB ==2.7.1.2
   - monoidal-containers ==0.6.3.0
-  - monoid-extras ==0.6.1
+  - monoid-extras ==0.6.2
   - monoid-subclasses ==1.1.3
   - monoid-transformer ==0.0.4
   - monomer ==1.5.0.0
···
   - network-simple ==0.4.5
   - network-simple-tls ==0.4
   - network-transport ==0.5.6
-  - network-uri ==2.6.4.1
+  - network-uri ==2.6.4.2
   - network-wait ==0.2.0.0
   - newtype ==0.2.2.0
   - newtype-generics ==0.6.2
···
   - NumInstances ==1.4
   - numtype-dk ==0.5.0.3
   - nuxeo ==0.3.2
-  - nvim-hs ==2.3.1.0
+  - nvim-hs ==2.3.2.0
   - nvim-hs-contrib ==2.0.0.1
-  - nvim-hs-ghcid ==2.0.0.0
+  - nvim-hs-ghcid ==2.0.1.0
   - oauthenticated ==0.3.0.0
   - ObjectName ==1.1.0.2
   - oblivious-transfer ==0.1.0
···
   - oo-prototypes ==0.1.0.0
   - opaleye ==0.9.6.1
   - OpenAL ==1.7.0.5
-  - openapi3 ==3.2.2
+  - openapi3 ==3.2.3
   - open-browser ==0.2.1.0
   - openexr-write ==0.1.0.2
   - OpenGL ==3.0.3.0
···
   - polysemy-fs ==0.1.0.0
   - polysemy-kvstore ==0.1.3.0
   - polysemy-methodology ==0.2.2.0
-  - polysemy-plugin ==0.4.3.1
+  - polysemy-plugin ==0.4.4.0
   - polysemy-several ==0.1.1.0
   - polysemy-webserver ==0.2.1.1
   - polysemy-zoo ==0.8.1.0
···
   - record-dot-preprocessor ==0.2.15
   - record-hasfield ==1.0
   - rec-smallarray ==0.1.0.0
-  - recursion-schemes ==5.2.2.2
+  - recursion-schemes ==5.2.2.3
   - recv ==0.0.0
   - redact ==0.4.0.0
   - reddit-scrape ==0.0.1
···
   - servant-multipart ==0.12.1
   - servant-multipart-api ==0.12.1
   - servant-multipart-client ==0.12.1
-  - servant-openapi3 ==2.0.1.5
+  - servant-openapi3 ==2.0.1.6
   - servant-pipes ==0.15.3
   - servant-rate-limit ==0.2.0.0
   - servant-rawm ==1.0.0.0
···
   - skein ==1.0.9.4
   - skews ==0.1.0.3
   - skip-var ==0.1.1.0
-  - skylighting ==0.13.1.2
-  - skylighting-core ==0.13.1.2
+  - skylighting ==0.13.2
+  - skylighting-core ==0.13.2
   - skylighting-format-ansi ==0.1
   - skylighting-format-blaze-html ==0.1.1
+  - skylighting-format-context ==0.1.0.1
   - skylighting-format-latex ==0.1
   - slack-progressbar ==0.1.0.1
   - slave-thread ==1.1.0.2
···
   - socket ==0.8.3.0
   - socks ==0.6.1
   - solana-staking-csvs ==0.1.2.0
-  - some ==1.0.3
+  - some ==1.0.4.1
   - some-dict-of ==0.1.0.2
   - sop-core ==0.5.0.2
   - sort ==1.0.0.0
···
   - string-combinators ==0.6.0.5
   - string-conv ==0.2.0
   - string-conversions ==0.4.0.1
-  - string-interpolate ==0.3.1.2
+  - string-interpolate ==0.3.2.0
   - stringprep ==1.0.0
   - string-qq ==0.0.4
   - string-random ==0.1.4.3
···
   - tar ==0.5.1.1
   - tar-conduit ==0.3.2
   - tardis ==0.4.4.0
-  - tasty ==1.4.2.3
+  - tasty ==1.4.3
   - tasty-ant-xml ==1.1.8
   - tasty-autocollect ==0.3.2.0
   - tasty-bench ==0.3.2
···
   - tcp-streams ==1.0.1.1
   - tdigest ==0.2.1.1
   - teardown ==0.5.0.1
-  - telegram-bot-simple ==0.6
+  - telegram-bot-simple ==0.6.1
   - template ==0.2.0.10
   - template-haskell-compat-v0208 ==0.1.9.1
   - temporary ==1.3
···
   - text-ansi ==0.2.1
   - text-binary ==0.2.1.1
   - text-builder ==0.6.7
-  - text-builder-dev ==0.3.3
+  - text-builder-dev ==0.3.3.2
   - text-conversions ==0.3.1.1
   - text-icu ==0.8.0.2
   - text-latin1 ==0.3.1
···
   - text-rope ==0.2
   - text-short ==0.1.5
   - text-show ==3.10
-  - text-show-instances ==3.9.2
+  - text-show-instances ==3.9.3
   - text-zipper ==0.12
   - tfp ==1.0.2
   - tf-random ==0.5
···
   - vector-builder ==0.3.8.4
   - vector-bytes-instances ==0.1.1
   - vector-circular ==0.1.4
-  - vector-extras ==0.2.7.1
+  - vector-extras ==0.2.8
   - vector-instances ==3.4
   - vector-mmap ==0.0.3
   - vector-rotcev ==0.1.0.1
···
   - webrtc-vad ==0.1.0.3
   - websockets ==0.12.7.3
   - weigh ==0.0.16
-  - wide-word ==0.1.3.0
+  - wide-word ==0.1.4.0
   - Win32 ==2.12.0.1
   - Win32-notify ==0.3.0.3
   - windns ==0.1.0.1

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

···
  - JsContracts
  - JsonGrammar
  - JuPyTer-notebook
+ - JuicyPixels-scale-dct
  - JunkDB-driver-gdbm
  - JunkDB-driver-hashtables
  - KiCS
···
  - audiovisual
  - aura
  - authoring
+ - autodocodec-openapi3
  - automata
  - autonix-deps-kf5
  - avers
···
  - essence-of-live-coding-PortMidi
  - essence-of-live-coding-gloss
  - essence-of-live-coding-gloss-example
- - essence-of-live-coding-gloss_0_2_7
  - essence-of-live-coding-pulse
  - essence-of-live-coding-pulse-example
- - essence-of-live-coding-pulse_0_2_7
  - essence-of-live-coding-quickcheck
- - essence-of-live-coding-quickcheck_0_2_7
  - essence-of-live-coding-vivid
  - essence-of-live-coding-warp
- - essence-of-live-coding-warp_0_2_7
  - estimators
  - estreps
  - eternity
···
  - exinst-serialise
  - exist
  - exist-instances
- - exon
  - expand
  - expat-enumerator
  - expiring-containers
···
  - jmacro-rpc-happstack
  - jmacro-rpc-snap
  - join
+ - jordan-openapi
+ - jordan-servant-openapi
  - jot
  - jsaddle-hello
  - jsc
···
  - nakadi-client
  - named-servant-client
  - named-servant-server
+ - named-text
  - nats-queue
  - natural-number
  - nemesis-titan
···
  - remotion
  - repa-array
  - repa-convert
+ - repa-fftw
  - repa-flow
  - repa-plugin
  - repa-stream
···
  - ribosome-root
  - ribosome-test
  - ridley-extras
+ - rio-process-pool
  - riot
  - ripple
  - ripple-federation
···
  - servant-matrix-param
  - servant-oauth2
  - servant-oauth2-examples
+ - servant-openapi3
  - servant-postgresql
  - servant-pushbullet-client
  - servant-rate-limit
···
  - servant-streamly
  - servant-swagger-tags
  - servant-to-elm
+ - servant-util
+ - servant-util-beam-pg
  - servant-waargonaut
  - servant-zeppelin-client
  - servant-zeppelin-server
···
  - statsd-client
  - statsdi
  - stern-brocot
+ - stm-actor
  - stm-supply
  - stmcontrol
  - storablevector-carray
···
  - webcloud
  - webcrank-wai
  - webdriver-w3c
+ - webgear-openapi
  - webify
  - webserver
  - websockets-rpc

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

···
     '';
   }) super.haskell-language-server;
 
-  # NOTE: this patch updates the hevm code to work with the latest packages that broke the build
-  # it's temporary until hevm version 0.50.0 is released - https://github.com/ethereum/hevm/milestone/1
-  # tests depend on a specific version of solc
-  hevm = dontCheck (appendPatch ./patches/hevm-update-deps.patch super.hevm);
+  # there are three very heavy test suites that need external repos, one requires network access
+  hevm = dontCheck super.hevm;
 
   # hadolint enables static linking by default in the cabal file, so we have to explicitly disable it.
   # https://github.com/hadolint/hadolint/commit/e1305042c62d52c2af4d77cdce5d62f6a0a3ce7b

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

···
      }) {};
 
   "BNFC" = callPackage
-    ({ mkDerivation, alex, array, base, Cabal, cabal-doctest
-     , containers, deepseq, directory, doctest, filepath, happy, hspec
-     , hspec-discover, HUnit, mtl, pretty, process, QuickCheck
-     , string-qq, temporary, time
-     }:
-     mkDerivation {
-       pname = "BNFC";
-       version = "2.9.4";
-       sha256 = "1gy7ggrf2zikyfi8anlj2zavs5b99z7rzs1lmyflrjd82a31bmzp";
-       isLibrary = true;
-       isExecutable = true;
-       setupHaskellDepends = [ base Cabal cabal-doctest ];
-       libraryHaskellDepends = [
-         array base containers deepseq directory filepath mtl pretty process
-         string-qq time
-       ];
-       libraryToolDepends = [ alex happy ];
-       executableHaskellDepends = [ base ];
-       testHaskellDepends = [
-         array base containers deepseq directory doctest filepath hspec
-         HUnit mtl pretty process QuickCheck string-qq temporary time
-       ];
-       testToolDepends = [ alex happy hspec-discover ];
-       description = "A compiler front-end generator";
-       license = lib.licenses.bsd3;
-       mainProgram = "bnfc";
-     }) {};
-
-  "BNFC_2_9_4_1" = callPackage
     ({ mkDerivation, alex, array, base, containers, deepseq, directory
      , filepath, happy, hspec, hspec-discover, HUnit, mtl, pretty
      , process, QuickCheck, string-qq, temporary, time, transformers
···
        testToolDepends = [ alex happy hspec-discover ];
        description = "A compiler front-end generator";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
        mainProgram = "bnfc";
      }) {};
 
···
        pname = "Cabal-syntax";
        version = "3.8.1.0";
        sha256 = "03yfk3b2sjmqpxmvx3mj185nifiaqapvc8hmbx4825z0kyqxvs07";
-       revision = "1";
-       editedCabalFile = "0rmrcjpm169acfranqq04ach5g3jv7v6g45yzpwcp3ksk9g7cdj9";
+       revision = "2";
+       editedCabalFile = "1bzwjxj5mrsxxcgrfgisamx3f3ymz5bz085k6p83s7djh39ayaxx";
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq directory filepath
          mtl parsec pretty text time transformers unix
···
        pname = "HStringTemplate";
        version = "0.8.8";
        sha256 = "1n8ci0kzjcgnqh4dfpqwlh7mnlzyiqiqc6hc0zr65p0balbg8zbi";
-       revision = "3";
-       editedCabalFile = "0316jr5npssxxxj85x74vasvm2ib09mjv2jy7abwjs7cfqbpnr8w";
+       revision = "4";
+       editedCabalFile = "0sj82pzq2hcx3yjsljwgbr1kcdgwpgfmq0n0dhz3am8ckwir0slz";
        libraryHaskellDepends = [
          array base blaze-builder bytestring containers deepseq directory
          filepath mtl old-locale parsec pretty semigroups syb
···
     ({ mkDerivation, base, bytestring, Cabal, network, openssl, time }:
      mkDerivation {
        pname = "HsOpenSSL";
-       version = "0.11.7.2";
-       sha256 = "0ysdfl8ck3nzhx597fa13dqf31jq5gzwajlak6r91jajks9w0dl5";
-       revision = "3";
-       editedCabalFile = "0nsqxym87s48029laqba4nzwpk7nrk35x7wmpjqfnbrj82ddcshd";
-       setupHaskellDepends = [ base Cabal ];
-       libraryHaskellDepends = [ base bytestring network time ];
-       librarySystemDepends = [ openssl ];
-       testHaskellDepends = [ base bytestring ];
-       description = "Partial OpenSSL binding for Haskell";
-       license = lib.licenses.publicDomain;
-     }) {inherit (pkgs) openssl;};
-
-  "HsOpenSSL_0_11_7_4" = callPackage
-    ({ mkDerivation, base, bytestring, Cabal, network, openssl, time }:
-     mkDerivation {
-       pname = "HsOpenSSL";
        version = "0.11.7.4";
        sha256 = "0zxcfa8b0ng97v53vb8fvg2gss89b28xiz83rx38a0h4lsxpn2xf";
        setupHaskellDepends = [ base Cabal ];
···
        testHaskellDepends = [ base bytestring ];
        description = "Partial OpenSSL binding for Haskell";
        license = lib.licenses.publicDomain;
-       hydraPlatforms = lib.platforms.none;
      }) {inherit (pkgs) openssl;};
 
   "HsOpenSSL-x509-system" = callPackage
···
        ];
        description = "Scale JuicyPixels images with DCT";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "JuicyPixels-stbir" = callPackage
···
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
+
+  "OGDF" = callPackage
+    ({ mkDerivation, base, COIN, fficxx, fficxx-runtime, OGDF, stdcxx
+     , template-haskell
+     }:
+     mkDerivation {
+       pname = "OGDF";
+       version = "1.0.0.0";
+       sha256 = "0sn5xyn2yqh7aywadzxvaxcyqj2clivvizqdbnjkljib7960w44z";
+       libraryHaskellDepends = [
+         base fficxx fficxx-runtime stdcxx template-haskell
+       ];
+       librarySystemDepends = [ COIN OGDF ];
+       description = "Haskell binding to OGDF";
+       license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {COIN = null; OGDF = null;};
 
   "OGL" = callPackage
     ({ mkDerivation, base, mtl }:
···
      }:
      mkDerivation {
        pname = "advent-of-code-api";
-       version = "0.2.8.2";
-       sha256 = "1z4y8bssmaappc7hamdzynjxd1mamn7vzyc0nymldxb8ly7fvpwy";
-       libraryHaskellDepends = [
-         aeson base bytestring containers deepseq directory filepath
-         finite-typelits http-api-data http-client http-client-tls
-         http-media megaparsec mtl profunctors servant servant-client
-         servant-client-core stm tagsoup text time time-compat
-       ];
-       testHaskellDepends = [ base directory filepath HUnit text ];
-       description = "Advent of Code REST API bindings and servant API";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "advent-of-code-api_0_2_8_4" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, containers, deepseq
-     , directory, filepath, finite-typelits, http-api-data, http-client
-     , http-client-tls, http-media, HUnit, megaparsec, mtl, profunctors
-     , servant, servant-client, servant-client-core, stm, tagsoup, text
-     , time, time-compat
-     }:
-     mkDerivation {
-       pname = "advent-of-code-api";
        version = "0.2.8.4";
        sha256 = "1l7bl0aqn5d6ph730jpwb5h0lwhvrkcw4vla0l73sxrm52j9ma58";
        libraryHaskellDepends = [
···
        testHaskellDepends = [ base directory filepath HUnit text ];
        description = "Advent of Code REST API bindings and servant API";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "advent-of-code-ocr" = callPackage
···
 
   "ansi-terminal-game" = callPackage
     ({ mkDerivation, ansi-terminal, array, base, bytestring, cereal
-     , clock, containers, exceptions, hspec, hspec-discover, linebreak
-     , mintty, mtl, QuickCheck, random, split, terminal-size
-     , timers-tick, unidecode
-     }:
-     mkDerivation {
-       pname = "ansi-terminal-game";
-       version = "1.8.0.1";
-       sha256 = "1fic8wjkbpfd076shfrq8pxlnpsrm59yilbhiinynlgr4vhjncz5";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         ansi-terminal array base bytestring cereal clock containers
-         exceptions linebreak mintty mtl QuickCheck random split
-         terminal-size timers-tick unidecode
-       ];
-       testHaskellDepends = [
-         ansi-terminal array base bytestring cereal clock containers
-         exceptions hspec linebreak mintty mtl QuickCheck random split
-         terminal-size timers-tick unidecode
-       ];
-       testToolDepends = [ hspec-discover ];
-       description = "sdl-like functions for terminal applications, based on ansi-terminal";
-       license = lib.licenses.gpl3Only;
-     }) {};
-
-  "ansi-terminal-game_1_8_1_0" = callPackage
-    ({ mkDerivation, ansi-terminal, array, base, bytestring, cereal
      , clock, colour, containers, exceptions, hspec, hspec-discover
      , linebreak, mintty, mtl, QuickCheck, random, split, terminal-size
      , timers-tick, unidecode
···
        testToolDepends = [ hspec-discover ];
        description = "sdl-like functions for terminal applications, based on ansi-terminal";
        license = lib.licenses.gpl3Only;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ansi-wl-pprint" = callPackage
···
      }:
      mkDerivation {
        pname = "ascii";
-       version = "1.2.3.0";
-       sha256 = "0s6w1wv6hjx1abz038cw7fyl8ilbs3cxmcs989c3hh9659l82p2j";
-       revision = "2";
-       editedCabalFile = "16b1dmjl0p2zdn05h2iwm1ymhrvgr19c1gzankrn0i7jj89nf979";
-       libraryHaskellDepends = [
-         ascii-case ascii-char ascii-group ascii-numbers ascii-predicates
-         ascii-superset ascii-th base bytestring text
-       ];
-       testHaskellDepends = [ base hedgehog text ];
-       description = "The ASCII character set and encoding";
-       license = lib.licenses.asl20;
-     }) {};
-
-  "ascii_1_2_4_0" = callPackage
-    ({ mkDerivation, ascii-case, ascii-char, ascii-group, ascii-numbers
-     , ascii-predicates, ascii-superset, ascii-th, base, bytestring
-     , hedgehog, text
-     }:
-     mkDerivation {
-       pname = "ascii";
        version = "1.2.4.0";
        sha256 = "1rsv9ah0jvf66w3k4smh67wpbm03xl4pdyj8svmdy49hbpihimwi";
        libraryHaskellDepends = [
···
        testHaskellDepends = [ base hedgehog text ];
        description = "The ASCII character set and encoding";
        license = lib.licenses.asl20;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ascii-art-to-unicode" = callPackage
···
      }) {};
 
   "ascii-case" = callPackage
-    ({ mkDerivation, ascii-char, base, hashable }:
-     mkDerivation {
-       pname = "ascii-case";
-       version = "1.0.0.11";
-       sha256 = "03rhq303igzvx9yil5qli2ga9iz47psrlnbb494785w9whwayxq1";
-       revision = "1";
-       editedCabalFile = "0a4nz34a5034lkq42q2l7xqdkjpakcy44syqy0gvx8p6h83ccrb1";
-       libraryHaskellDepends = [ ascii-char base hashable ];
-       testHaskellDepends = [ ascii-char base ];
-       description = "ASCII letter case";
-       license = lib.licenses.asl20;
-     }) {};
-
-  "ascii-case_1_0_1_1" = callPackage
     ({ mkDerivation, ascii-char, base, hashable, hspec }:
      mkDerivation {
        pname = "ascii-case";
···
        testHaskellDepends = [ ascii-char base hspec ];
        description = "ASCII letter case";
        license = lib.licenses.asl20;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ascii-caseless" = callPackage
···
      }) {};
 
   "ascii-char" = callPackage
-    ({ mkDerivation, base, hashable }:
+    ({ mkDerivation, base, hashable, hspec }:
      mkDerivation {
        pname = "ascii-char";
-       version = "1.0.0.15";
-       sha256 = "10vvhpl7y1gpw7gw2hpcckl0pmx7rkn35zy6yl6c9mx0hib0745a";
-       revision = "1";
-       editedCabalFile = "0b73pm9z5k3xbpn49fz4m8jwzw3r4z0l2v4alinf5l7n6vx4wvj0";
+       version = "1.0.0.16";
+       sha256 = "06iig5p15ip0wpg330dq8kclq7g7j2xkrkk0dbl3z509d44mg049";
        libraryHaskellDepends = [ base hashable ];
-       testHaskellDepends = [ base ];
+       testHaskellDepends = [ base hspec ];
        description = "A Char type representing an ASCII character";
        license = lib.licenses.asl20;
      }) {};
 
-  "ascii-char_1_0_0_16" = callPackage
+  "ascii-char_1_0_0_17" = callPackage
     ({ mkDerivation, base, hashable, hspec }:
      mkDerivation {
        pname = "ascii-char";
-       version = "1.0.0.16";
-       sha256 = "06iig5p15ip0wpg330dq8kclq7g7j2xkrkk0dbl3z509d44mg049";
+       version = "1.0.0.17";
+       sha256 = "1562gkfvrcjygs9qpyswsk25d4m2pxblmmbb0hw8jsaml2jwsyss";
        libraryHaskellDepends = [ base hashable ];
        testHaskellDepends = [ base hspec ];
        description = "A Char type representing an ASCII character";
···
     ({ mkDerivation, ascii-char, base, hashable, hedgehog }:
      mkDerivation {
        pname = "ascii-group";
-       version = "1.0.0.13";
-       sha256 = "1xynfvrr8lwmrxqww2c2bwp6r3162mqgmx7hljwmbvdmnc0na30d";
-       revision = "1";
-       editedCabalFile = "0snp4qfj20jjchhhf7v8lyssjydv57sd2wy88fbc0aaba4c5lq7y";
-       libraryHaskellDepends = [ ascii-char base hashable ];
-       testHaskellDepends = [ ascii-char base hedgehog ];
-       description = "ASCII character groups";
-       license = lib.licenses.asl20;
-     }) {};
-
-  "ascii-group_1_0_0_14" = callPackage
-    ({ mkDerivation, ascii-char, base, hashable, hedgehog }:
-     mkDerivation {
-       pname = "ascii-group";
        version = "1.0.0.14";
        sha256 = "0rk3lvs4b6d4cfzb5zc87f42wdmziprpfd4fww5r68ry3ccyn1ps";
+       revision = "1";
+       editedCabalFile = "0iwf48cq67qzgw4ih6532yxl03bpnzrhz68y0yfk87r1y3hsdxfx";
        libraryHaskellDepends = [ ascii-char base hashable ];
        testHaskellDepends = [ ascii-char base hedgehog ];
        description = "ASCII character groups";
        license = lib.licenses.asl20;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ascii-holidays" = callPackage
···
        license = lib.licenses.asl20;
      }) {};
 
+  "ascii-numbers_1_1_0_1" = callPackage
+    ({ mkDerivation, ascii-case, ascii-char, ascii-superset, base
+     , bytestring, hashable, hedgehog, invert, text
+     }:
+     mkDerivation {
+       pname = "ascii-numbers";
+       version = "1.1.0.1";
+       sha256 = "1zb37db0vpcnh63izq9m62p2an1w496ljh7d196k0i1w76j2jhiy";
+       libraryHaskellDepends = [
+         ascii-case ascii-char ascii-superset base bytestring hashable text
+       ];
+       testHaskellDepends = [
+         ascii-case ascii-char ascii-superset base bytestring hashable
+         hedgehog invert text
+       ];
+       description = "ASCII representations of numbers";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "ascii-predicates" = callPackage
     ({ mkDerivation, ascii-char, base, hedgehog }:
      mkDerivation {
···
        testHaskellDepends = [ ascii-char base hedgehog ];
        description = "Various categorizations of ASCII characters";
        license = lib.licenses.asl20;
+     }) {};
+
+  "ascii-predicates_1_0_1_1" = callPackage
+    ({ mkDerivation, ascii-char, base, hedgehog }:
+     mkDerivation {
+       pname = "ascii-predicates";
+       version = "1.0.1.1";
+       sha256 = "1r8kd5p17jd46298wp7b1rvfg86g752k2x45ppqikrbkqv9vkvmc";
+       libraryHaskellDepends = [ ascii-char base ];
+       testHaskellDepends = [ ascii-char base hedgehog ];
+       description = "Various categorizations of ASCII characters";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ascii-progress" = callPackage
···
        license = lib.licenses.asl20;
      }) {};
 
+  "ascii-superset_1_0_1_14" = callPackage
+    ({ mkDerivation, ascii-char, base, bytestring, hashable, hedgehog
+     , text
+     }:
+     mkDerivation {
+       pname = "ascii-superset";
+       version = "1.0.1.14";
+       sha256 = "1zggxgxwdc8cd224dgmrq0bijgi0adv233ysnpaw97sa9m6mgmb6";
+       libraryHaskellDepends = [
+         ascii-char base bytestring hashable text
+       ];
+       testHaskellDepends = [ ascii-char base hedgehog text ];
+       description = "Representing ASCII with refined supersets";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "ascii-table" = callPackage
     ({ mkDerivation, aeson, base, containers, dlist, hashable, text
      , unordered-containers, vector, wl-pprint-extras
···
        license = lib.licenses.asl20;
      }) {};
 
+  "ascii-th_1_0_0_12" = callPackage
+    ({ mkDerivation, ascii-char, ascii-superset, base, bytestring
+     , hedgehog, template-haskell, text
+     }:
+     mkDerivation {
+       pname = "ascii-th";
+       version = "1.0.0.12";
+       sha256 = "1kdqkd7sq8kb8ymy4p45w39ndr7z2jcjy9c5ws227hrhglam9pcy";
+       libraryHaskellDepends = [
+         ascii-char ascii-superset base template-haskell
+       ];
+       testHaskellDepends = [
+         ascii-char ascii-superset base bytestring hedgehog text
+       ];
+       description = "Template Haskell support for ASCII";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "ascii-vector-avc" = callPackage
     ({ mkDerivation, attoparsec, base, binary, bytestring, deepseq
      , deepseq-generics, HUnit, split, zlib
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "atomic-counter" = callPackage
+    ({ mkDerivation, async, base, primitive, QuickCheck, stm, tasty
+     , tasty-bench, tasty-quickcheck
+     }:
+     mkDerivation {
+       pname = "atomic-counter";
+       version = "0.1";
+       sha256 = "1vrggycr9jbnrx2gz71rfqrldmf6417kx5sp2w5g238iv6a3m9p1";
+       libraryHaskellDepends = [ async base QuickCheck ];
+       testHaskellDepends = [ base QuickCheck tasty tasty-quickcheck ];
+       benchmarkHaskellDepends = [
+         base primitive QuickCheck stm tasty tasty-bench tasty-quickcheck
+       ];
+       doHaddock = false;
+       description = "Mutable counters that can be modified with atomic operatinos";
+       license = lib.licenses.asl20;
+     }) {};
+
   "atomic-file-ops" = callPackage
     ({ mkDerivation, base, directory, filelock, filepath
      , io-string-like
···
        ];
        description = "Autodocodec interpreters for openapi3";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "autodocodec-schema" = callPackage
···
      }:
      mkDerivation {
        pname = "barbies";
-       version = "2.0.3.1";
-       sha256 = "0gfzb52k3py1qnr2b6gshdg7c9aj1j9y2xsdhz86n01ybv81yg51";
-       libraryHaskellDepends = [ base distributive transformers ];
-       testHaskellDepends = [
-         base distributive QuickCheck tasty tasty-hunit tasty-quickcheck
-       ];
-       description = "Classes for working with types that can change clothes";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "barbies_2_0_4_0" = callPackage
-    ({ mkDerivation, base, distributive, QuickCheck, tasty, tasty-hunit
-     , tasty-quickcheck, transformers
-     }:
-     mkDerivation {
-       pname = "barbies";
        version = "2.0.4.0";
        sha256 = "0v8bckxi58fkqgf1i1xd3100wp792pzd319xlfvmmw8z0ii1g872";
        libraryHaskellDepends = [ base distributive transformers ];
···
        ];
        description = "Classes for working with types that can change clothes";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "barbies-layered" = callPackage
···
     ({ mkDerivation, base, hspec }:
      mkDerivation {
        pname = "benri-hspec";
-       version = "0.1.0.0";
-       sha256 = "0vvc7fw52c9flmdjmgrc9cca9yrl4r7yvh2l5ixc23gvvmlhdycy";
-       libraryHaskellDepends = [ base hspec ];
-       description = "Simplify tests where Either or Maybe types are returned from monadic code";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "benri-hspec_0_1_0_1" = callPackage
-    ({ mkDerivation, base, hspec }:
-     mkDerivation {
-       pname = "benri-hspec";
        version = "0.1.0.1";
        sha256 = "11x7dsp6hmz1an1nm8076lgdvgd8r67hl54p81jprpi8m0lh6mqa";
        libraryHaskellDepends = [ base hspec ];
        description = "Simplify tests where Either or Maybe types are returned from monadic code";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "bento" = callPackage
···
      }:
      mkDerivation {
        pname = "boomerang";
-       version = "1.4.8";
-       sha256 = "141rs9q8i89118ldplm90zqzkjff3jwqhsdld4vp4ipc26f9gjdl";
-       libraryHaskellDepends = [
-         base mtl semigroups template-haskell text th-abstraction
-       ];
-       description = "Library for invertible parsing and printing";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "boomerang_1_4_8_1" = callPackage
-    ({ mkDerivation, base, mtl, semigroups, template-haskell, text
-     , th-abstraction
-     }:
-     mkDerivation {
-       pname = "boomerang";
        version = "1.4.8.1";
        sha256 = "1hal4z1c1skqjq7vvjql0gm2rhfgrrlj29rgchjwlr2hm22zgnjp";
        libraryHaskellDepends = [
···
        ];
        description = "Library for invertible parsing and printing";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "boomslang" = callPackage
···
      }:
      mkDerivation {
        pname = "bytesmith";
-       version = "0.3.9.0";
-       sha256 = "0jmx4flf3j5a4gyrw79cxiybp6f7y0rm9ifmrxypxpwrwc220zjg";
-       revision = "1";
-       editedCabalFile = "0ly247yj2ay0fpj5v3dqp0hava1wrllqhphf7k3hcifpi5zfr8i0";
-       libraryHaskellDepends = [
-         base byteslice bytestring contiguous primitive run-st text-short
-         wide-word
-       ];
-       testHaskellDepends = [
-         base byte-order byteslice primitive tasty tasty-hunit
-         tasty-quickcheck text-short wide-word
-       ];
-       benchmarkHaskellDepends = [
-         base byteslice bytestring gauge primitive
-       ];
-       description = "Nonresumable byte parser";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "bytesmith_0_3_9_1" = callPackage
-    ({ mkDerivation, base, byte-order, byteslice, bytestring
-     , contiguous, gauge, primitive, run-st, tasty, tasty-hunit
-     , tasty-quickcheck, text-short, wide-word
-     }:
-     mkDerivation {
-       pname = "bytesmith";
        version = "0.3.9.1";
        sha256 = "10d0wzinc30b2xc26cfadvpn29gf30gnppysyl3n35ym3p9lnhm2";
        libraryHaskellDepends = [
···
        ];
        description = "Nonresumable byte parser";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "bytestring_0_11_3_1" = callPackage
···
      }:
      mkDerivation {
        pname = "cabal-cache";
-       version = "1.0.5.4";
-       sha256 = "15jg140ly7rska7v8ihvd383q9lj4i5c18rzjad4yi8f78jjciqb";
+       version = "1.0.5.5";
+       sha256 = "0474z8cw2wikqg3bnsxqj4rxy13n5l8p06fq72l4klh01s8i1qfl";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "chimera" = callPackage
-    ({ mkDerivation, adjunctions, base, distributive, mtl, QuickCheck
-     , random, tasty, tasty-bench, tasty-hunit, tasty-quickcheck
-     , tasty-smallcheck, vector
+    ({ mkDerivation, adjunctions, base, distributive, mtl, primitive
+     , QuickCheck, random, tasty, tasty-bench, tasty-hunit
+     , tasty-quickcheck, tasty-smallcheck, transformers, vector
      }:
      mkDerivation {
        pname = "chimera";
-       version = "0.3.2.0";
-       sha256 = "1p8in1a37hrb0qwvabwi4a9ahzydkd8j3v402cn2i3xmkzcr0kh9";
+       version = "0.3.3.0";
+       sha256 = "1cy38pgdlgz4f1fglm70w3dlqbnd0lzpckr7j065nnpp0ljlwlpx";
        libraryHaskellDepends = [
-         adjunctions base distributive mtl vector
+         adjunctions base distributive mtl primitive transformers vector
        ];
        testHaskellDepends = [
          base QuickCheck tasty tasty-hunit tasty-quickcheck tasty-smallcheck
          vector
        ];
-       benchmarkHaskellDepends = [ base mtl random tasty-bench ];
+       benchmarkHaskellDepends = [ base mtl random tasty tasty-bench ];
        description = "Lazy infinite streams with O(1) indexing and applications for memoization";
        license = lib.licenses.bsd3;
      }) {};
···
        pname = "clash-prelude";
        version = "1.6.4";
        sha256 = "12ic8jcgz3jr4zrgrx06dzd6whlypyyxilrgbja27dcdv02fs6yr";
+       revision = "1";
+       editedCabalFile = "09ra3gbhghrqlzaanjlvm0qpj05v3ilps62lblzy44n7sxmc5db7";
        libraryHaskellDepends = [
          array arrows base binary bytestring constraints containers
          data-binary-ieee754 data-default-class deepseq extra ghc-bignum
···
      }:
      mkDerivation {
        pname = "composite-base";
-       version = "0.8.2.0";
-       sha256 = "0niw6rc9sscq73vja8pzds4r87yvckh0h5138i86wv18m34ksniw";
-       libraryHaskellDepends = [
-         base deepseq exceptions lens monad-control mtl profunctors
-         template-haskell text transformers transformers-base unliftio-core
-         vinyl
-       ];
-       testHaskellDepends = [
-         base deepseq exceptions hspec lens monad-control mtl profunctors
-         QuickCheck template-haskell text transformers transformers-base
-         unliftio-core vinyl
-       ];
-       description = "Shared utilities for composite-* packages";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "composite-base_0_8_2_1" = callPackage
-    ({ mkDerivation, base, deepseq, exceptions, hspec, lens
-     , monad-control, mtl, profunctors, QuickCheck, template-haskell
-     , text, transformers, transformers-base, unliftio-core, vinyl
-     }:
-     mkDerivation {
-       pname = "composite-base";
        version = "0.8.2.1";
        sha256 = "0i2mamh5gz7ay1cm5nkmdbh2lnaph42pfi2aa9jb2baxi0jgxdri";
        libraryHaskellDepends = [
···
        ];
        description = "Shared utilities for composite-* packages";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "composite-binary" = callPackage
     ({ mkDerivation, base, binary, composite-base }:
      mkDerivation {
        pname = "composite-binary";
-       version = "0.8.2.0";
-       sha256 = "1ijlrwyji9179hc5wcmdzzf3g79xkz6k1kjxq0l7iqyvfjh2zrkh";
-       libraryHaskellDepends = [ base binary composite-base ];
-       description = "Orphan binary instances";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "composite-binary_0_8_2_1" = callPackage
-    ({ mkDerivation, base, binary, composite-base }:
-     mkDerivation {
-       pname = "composite-binary";
        version = "0.8.2.1";
        sha256 = "0bxnzxvw5mjhz3kh6x265l70hp1z3z1y9fbdwhrgv6bhhinxb3hq";
        libraryHaskellDepends = [ base binary composite-base ];
        description = "Orphan binary instances";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "composite-cassava" = callPackage
···
      }:
      mkDerivation {
        pname = "composite-ekg";
-       version = "0.8.2.0";
-       sha256 = "0kcyscjs8qsydhj7labm8v62xcm9vc39rcw13xlvwmxz3lwi5jl3";
-       libraryHaskellDepends = [
-         base composite-base ekg-core lens text vinyl
-       ];
-       description = "EKG Metrics for Vinyl records";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "composite-ekg_0_8_2_1" = callPackage
-    ({ mkDerivation, base, composite-base, ekg-core, lens, text, vinyl
-     }:
-     mkDerivation {
-       pname = "composite-ekg";
        version = "0.8.2.1";
        sha256 = "0c0rxa30r19wcvqrw20xk96652mxknbs1lqpnzdj9kz77al3k1kl";
        libraryHaskellDepends = [
···
        ];
        description = "EKG Metrics for Vinyl records";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "composite-hashable" = callPackage
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "data-forest";
-       version = "0.1.0.9";
-       sha256 = "1l16hg1pfzrbi2ih6najcam18p2b5lvmmkl6fxvk7izynvcc79jc";
-       revision = "1";
-       editedCabalFile = "0m0fp8fx21257z5k1g575wjcmavd29qav4cgjcwg5nxkxwrfldg8";
+       version = "0.1.0.10";
+       sha256 = "0wfw87vb00lgc1pf6cmqmlzfqskhy42kyzfj5nyfw1lch8s6sbvm";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base ];
        description = "A simple multi-way tree data structure";
···
     ({ mkDerivation, base, constraints-extras, some }:
      mkDerivation {
        pname = "dependent-sum";
-       version = "0.7.1.0";
-       sha256 = "0aj63gvak0y4mgxndykqfg5w958hf7lp5blml2z647rjgy85bjw1";
-       revision = "2";
-       editedCabalFile = "0d7wb1ag60mcm56axcrx9pd6hgrsxmqynyplbcfl01ms2i60fhr9";
-       libraryHaskellDepends = [ base constraints-extras some ];
-       description = "Dependent sum type";
-       license = lib.licenses.publicDomain;
-     }) {};
-
-  "dependent-sum_0_7_2_0" = callPackage
-    ({ mkDerivation, base, constraints-extras, some }:
-     mkDerivation {
-       pname = "dependent-sum";
        version = "0.7.2.0";
        sha256 = "1frw5965v8i6xqdgs95gg8asgdqcqnmfahz0pmbwiaw5ybn62rc2";
        libraryHaskellDepends = [ base constraints-extras some ];
        description = "Dependent sum type";
        license = lib.licenses.publicDomain;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "dependent-sum-aeson-orphans" = callPackage
···
     ({ mkDerivation, base, bytestring, zlib }:
      mkDerivation {
        pname = "digest";
-       version = "0.0.1.3";
-       sha256 = "1l5383l5pvp018rj3vabrppnzcqrr2g0dvgvmsrbjdn02wzab5jm";
-       libraryHaskellDepends = [ base bytestring ];
-       librarySystemDepends = [ zlib ];
-       description = "Various cryptographic hashes for bytestrings; CRC32 and Adler32 for now";
-       license = lib.licenses.bsd3;
-     }) {inherit (pkgs) zlib;};
-
-  "digest_0_0_1_4" = callPackage
-    ({ mkDerivation, base, bytestring, zlib }:
-     mkDerivation {
-       pname = "digest";
        version = "0.0.1.4";
        sha256 = "05pc5l4bwddszc6vy1hazwi1dnrxg323521gdkis9cvh7zs2a4gr";
        libraryHaskellDepends = [ base bytestring ];
        libraryPkgconfigDepends = [ zlib ];
        description = "Various hashes for bytestrings; CRC32 and Adler32 for now";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {inherit (pkgs) zlib;};
 
   "digest-pure" = callPackage
···
      }:
      mkDerivation {
        pname = "dlist-nonempty";
-       version = "0.1.1";
-       sha256 = "0csbspdy43pzvasb5mhs5pz2f49ws78pi253cx7pp84wjx6ads20";
-       revision = "13";
-       editedCabalFile = "1hbd0j8yw81y4rnxqxxnvhy33ccgl5c7qcr9shzqy97fwi2vkikm";
-       libraryHaskellDepends = [
-         base base-compat deepseq dlist semigroupoids
-       ];
-       testHaskellDepends = [
-         base Cabal QuickCheck quickcheck-instances
-       ];
-       benchmarkHaskellDepends = [
-         base base-compat criterion dlist dlist-instances
-       ];
-       description = "Non-empty difference lists";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "dlist-nonempty_0_1_2" = callPackage
-    ({ mkDerivation, base, base-compat, Cabal, criterion, deepseq
-     , dlist, dlist-instances, QuickCheck, quickcheck-instances
-     , semigroupoids
-     }:
-     mkDerivation {
-       pname = "dlist-nonempty";
        version = "0.1.2";
        sha256 = "1phdqr9fi2smscmqn7l9kfjxfnqfw6ws1v0a1lrqm5civ15gxhms";
        libraryHaskellDepends = [ base deepseq dlist semigroupoids ];
···
        ];
        description = "Non-empty difference lists";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "dmc" = callPackage
···
     ({ mkDerivation, base, doctest }:
      mkDerivation {
        pname = "doctest-driver-gen";
-       version = "0.3.0.5";
-       sha256 = "08zv5c1cfklknpbw974sw4rb6jiijd3q28cpjw1cncc06n2jy85b";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [ base ];
-       executableHaskellDepends = [ base ];
-       testHaskellDepends = [ base doctest ];
-       description = "Generate driver file for doctest's cabal integration";
-       license = lib.licenses.bsd3;
-       mainProgram = "doctest-driver-gen";
-     }) {};
-
-  "doctest-driver-gen_0_3_0_6" = callPackage
-    ({ mkDerivation, base, doctest }:
-     mkDerivation {
-       pname = "doctest-driver-gen";
        version = "0.3.0.6";
        sha256 = "0a4jdg4mzhdgfal7jp60yrlv63iv7d8f7nxc9aqvrl93mairny8l";
        isLibrary = true;
···
        testHaskellDepends = [ base doctest ];
        description = "Generate driver file for doctest's cabal integration";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
        mainProgram = "doctest-driver-gen";
      }) {};
 
···
      }:
      mkDerivation {
        pname = "doctest-parallel";
-       version = "0.2.5";
-       sha256 = "075y4yllpgfq0dlfd6y9nqhsdkxzb9s3jgb0v194l216kg5zsqzc";
-       revision = "1";
-       editedCabalFile = "1q81qjz9af9a57xyxz6kci28shl4r9y3lrl3rckknhqwcy1ahqz4";
-       libraryHaskellDepends = [
-         base base-compat Cabal code-page containers deepseq directory
-         exceptions extra filepath ghc ghc-paths Glob pretty process random
-         syb template-haskell transformers unordered-containers
-       ];
-       testHaskellDepends = [
-         base base-compat code-page containers deepseq directory exceptions
-         filepath ghc ghc-paths hspec hspec-core hspec-discover HUnit
-         mockery process QuickCheck setenv silently stringbuilder syb
-         transformers
-       ];
-       testToolDepends = [ hspec-discover ];
-       doHaddock = false;
-       description = "Test interactive Haskell examples";
-       license = lib.licenses.mit;
-     }) {};
-
-  "doctest-parallel_0_2_6" = callPackage
-    ({ mkDerivation, base, base-compat, Cabal, code-page, containers
-     , deepseq, directory, exceptions, extra, filepath, ghc, ghc-paths
-     , Glob, hspec, hspec-core, hspec-discover, HUnit, mockery, pretty
-     , process, QuickCheck, random, setenv, silently, stringbuilder, syb
-     , template-haskell, transformers, unordered-containers
-     }:
-     mkDerivation {
-       pname = "doctest-parallel";
        version = "0.2.6";
        sha256 = "13hjwhdjw8jrj07zxkrrfbzr0mrk8gwyis1rbdi4ld4jbq3rr1z7";
        libraryHaskellDepends = [
···
        doHaddock = false;
        description = "Test interactive Haskell examples";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "doctest-prop" = callPackage
···
      }:
      mkDerivation {
        pname = "dotenv";
-       version = "0.9.0.3";
-       sha256 = "163w2japbcdjzmhr7afq2rss7sp7gz2j8mylcc716x63gm3ws20h";
-       isLibrary = true;
-       isExecutable = true;
-       enableSeparateDataOutput = true;
-       libraryHaskellDepends = [
-         base base-compat containers directory exceptions megaparsec process
-         shellwords text
-       ];
-       executableHaskellDepends = [
-         base base-compat megaparsec optparse-applicative process text
-       ];
-       testHaskellDepends = [
-         base base-compat containers directory exceptions hspec
-         hspec-megaparsec megaparsec process shellwords text
-       ];
-       testToolDepends = [ hspec-discover ];
-       description = "Loads environment variables from dotenv files";
-       license = lib.licenses.mit;
-       mainProgram = "dotenv";
-     }) {};
-
-  "dotenv_0_10_0_0" = callPackage
-    ({ mkDerivation, base, base-compat, containers, directory
-     , exceptions, hspec, hspec-discover, hspec-megaparsec, megaparsec
-     , optparse-applicative, process, shellwords, text
-     }:
-     mkDerivation {
-       pname = "dotenv";
        version = "0.10.0.0";
        sha256 = "04brkjk9a17xv2qv2xbsdxbil6ncrrzxcfji9q0civmxhj4vbcfq";
        isLibrary = true;
···
        testToolDepends = [ hspec-discover ];
        description = "Loads environment variables from dotenv files";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
        mainProgram = "dotenv";
      }) {};
 
···
      }:
      mkDerivation {
        pname = "double-conversion";
-       version = "2.0.4.1";
-       sha256 = "1hrpqh8lbw0kkryqsya95mfnnnj0pj7zswxrn6kvfy4rf7z8v2d4";
-       revision = "2";
-       editedCabalFile = "0qya075j3kz4jq1kx4951qvi9blh6hcqfd7vpcx8l8ql143ajvqs";
-       libraryHaskellDepends = [ base bytestring ghc-prim text ];
-       testHaskellDepends = [
-         base bytestring HUnit test-framework test-framework-hunit
-         test-framework-quickcheck2 text
-       ];
-       description = "Fast conversion between single and double precision floating point and text";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "double-conversion_2_0_4_2" = callPackage
-    ({ mkDerivation, base, bytestring, ghc-prim, HUnit, test-framework
-     , test-framework-hunit, test-framework-quickcheck2, text
-     }:
-     mkDerivation {
-       pname = "double-conversion";
        version = "2.0.4.2";
        sha256 = "0r7c1801gzdm5x1flmpx8ajxygbc9dl7sgdj0xn3bpm71wgvrf4s";
        revision = "2";
···
        ];
        description = "Fast conversion between single and double precision floating point and text";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "double-extra" = callPackage
···
      }:
      mkDerivation {
        pname = "dunai";
-       version = "0.9.1";
-       sha256 = "0krgbs9xqar78815xrgqbj63678jm0mjbsvnqdayh0c2awf9i8bj";
-       libraryHaskellDepends = [
-         base MonadRandom simple-affine-space transformers transformers-base
-       ];
-       testHaskellDepends = [ base tasty tasty-hunit transformers ];
-       description = "Generalised reactive framework supporting classic, arrowized and monadic FRP";
-       license = lib.licenses.bsd3;
-       maintainers = [ lib.maintainers.turion ];
-     }) {};
-
-  "dunai_0_9_2" = callPackage
-    ({ mkDerivation, base, MonadRandom, simple-affine-space, tasty
-     , tasty-hunit, transformers, transformers-base
-     }:
-     mkDerivation {
-       pname = "dunai";
        version = "0.9.2";
        sha256 = "08skmwkfwiyy83s764fcpa9i8zny10bdbpv9wha6fjqr1b80i80f";
        libraryHaskellDepends = [
···
        testHaskellDepends = [ base tasty tasty-hunit transformers ];
        description = "Generalised reactive framework supporting classic, arrowized and monadic FRP";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
        maintainers = [ lib.maintainers.turion ];
      }) {};
 
···
      }:
      mkDerivation {
        pname = "essence-of-live-coding";
-       version = "0.2.6";
-       sha256 = "0bmcy6j0zw9v7z4sr0m300ckr1mdh3wxj975wbgbl8qlkwsfwv9l";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         base containers foreign-store mmorph syb time transformers
-         vector-sized
-       ];
-       executableHaskellDepends = [ base transformers ];
-       testHaskellDepends = [
-         base containers HUnit mtl QuickCheck syb test-framework
-         test-framework-hunit test-framework-quickcheck2 transformers
-       ];
-       description = "General purpose live coding framework";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       maintainers = [ lib.maintainers.turion ];
-       broken = true;
-     }) {};
-
-  "essence-of-live-coding_0_2_7" = callPackage
-    ({ mkDerivation, base, containers, foreign-store, HUnit, mmorph
-     , mtl, QuickCheck, syb, test-framework, test-framework-hunit
-     , test-framework-quickcheck2, time, transformers, vector-sized
-     }:
-     mkDerivation {
-       pname = "essence-of-live-coding";
        version = "0.2.7";
        sha256 = "1vg10x8radvr8ysqfzf1cngp2hnqy8g139x07pwqwycj9zwwnbl4";
        isLibrary = true;
···
      }:
      mkDerivation {
        pname = "essence-of-live-coding-gloss";
-       version = "0.2.6";
-       sha256 = "02jdi5ijkhf9jc9r5jyqvlk6idmgbjbv3x4yw6ich2m95yhf8hrl";
-       libraryHaskellDepends = [
-         base essence-of-live-coding foreign-store gloss syb transformers
-       ];
-       description = "General purpose live coding framework - Gloss backend";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       maintainers = [ lib.maintainers.turion ];
-     }) {};
-
-  "essence-of-live-coding-gloss_0_2_7" = callPackage
-    ({ mkDerivation, base, essence-of-live-coding, foreign-store, gloss
-     , syb, transformers
-     }:
-     mkDerivation {
-       pname = "essence-of-live-coding-gloss";
        version = "0.2.7";
        sha256 = "0iv5wgzfxy1k80dh6c6hrzh4jcjy3ak4l3l004jm3wpfm7fm0lmx";
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "essence-of-live-coding-pulse";
-       version = "0.2.6";
-       sha256 = "16fipxz90vlsy9hgksiw7m7r7wzrqrjdhb6fg11m6jlrk1f5bkka";
-       libraryHaskellDepends = [
-         base essence-of-live-coding foreign-store pulse-simple transformers
-       ];
-       description = "General purpose live coding framework - pulse backend";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       maintainers = [ lib.maintainers.turion ];
-     }) {};
-
-  "essence-of-live-coding-pulse_0_2_7" = callPackage
-    ({ mkDerivation, base, essence-of-live-coding, foreign-store
-     , pulse-simple, transformers
-     }:
-     mkDerivation {
-       pname = "essence-of-live-coding-pulse";
        version = "0.2.7";
        sha256 = "0bmnc7901zgak223kfm29md0w5fd9lfv4dxc8c27cdcrdqnqfc2p";
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "essence-of-live-coding-quickcheck";
-       version = "0.2.6";
-       sha256 = "1hkzp0q0xk3wa892vnjimi7m9gq56m5wx1m2i72ssl6x2jgy52hl";
-       libraryHaskellDepends = [
-         base boltzmann-samplers essence-of-live-coding QuickCheck syb
-         transformers
-       ];
-       description = "General purpose live coding framework - QuickCheck integration";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       maintainers = [ lib.maintainers.turion ];
-     }) {};
-
-  "essence-of-live-coding-quickcheck_0_2_7" = callPackage
-    ({ mkDerivation, base, boltzmann-samplers, essence-of-live-coding
-     , QuickCheck, syb, transformers
-     }:
-     mkDerivation {
-       pname = "essence-of-live-coding-quickcheck";
        version = "0.2.7";
        sha256 = "0jn5bz7xq8jmlkhrrbn5mj3ywh8288gpx43n8fkjzmzdk233kbvp";
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "essence-of-live-coding-warp";
-       version = "0.2.6";
-       sha256 = "0x18jxw0xwqvbwdalbrz4lp2lq9pyl4a5r9vnky5hc5wcwqm2f4m";
-       libraryHaskellDepends = [
-         base essence-of-live-coding http-types wai warp
-       ];
-       testHaskellDepends = [
-         base bytestring essence-of-live-coding http-client
-       ];
-       description = "General purpose live coding framework";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       maintainers = [ lib.maintainers.turion ];
-     }) {};
-
-  "essence-of-live-coding-warp_0_2_7" = callPackage
-    ({ mkDerivation, base, bytestring, essence-of-live-coding
-     , http-client, http-types, wai, warp
-     }:
-     mkDerivation {
-       pname = "essence-of-live-coding-warp";
        version = "0.2.7";
        sha256 = "1zykg5qik61xr4ri6d9r04w5rj7wm0wqmnzm6nipwpixal3gdxqa";
        libraryHaskellDepends = [
···
     ({ mkDerivation, base, template-haskell }:
      mkDerivation {
        pname = "exception-hierarchy";
-       version = "0.1.0.7";
-       sha256 = "14kk0rync05rq2adx5lk59y56h97s0yv7mqfn2grhhwqb10maqj0";
-       libraryHaskellDepends = [ base template-haskell ];
-       description = "Exception type hierarchy with TemplateHaskell";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "exception-hierarchy_0_1_0_8" = callPackage
-    ({ mkDerivation, base, template-haskell }:
-     mkDerivation {
-       pname = "exception-hierarchy";
        version = "0.1.0.8";
        sha256 = "17wx40kic0gw5lbz1nr094ps612i0j0pbf0wfj4kgzsl6cj80hih";
        libraryHaskellDepends = [ base template-haskell ];
        description = "Exception type hierarchy with TemplateHaskell";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "exception-mailer" = callPackage
···
   "exon" = callPackage
     ({ mkDerivation, base, criterion, flatparse, generics-sop
      , ghc-hs-meta, hedgehog, incipit-base, tasty, tasty-hedgehog
-     , template-haskell, type-errors-pretty
+     , template-haskell
      }:
      mkDerivation {
        pname = "exon";
-       version = "1.2.0.0";
-       sha256 = "1cayih5rp386cn1ig5g7flxjfh47451h095zx4av4i0c72j6q7s1";
+       version = "1.3.0.0";
+       sha256 = "1w93x0yfqm1yp82lh2q1wibb88xn7rh4vh16pq1pzs8vdhgbapc2";
        libraryHaskellDepends = [
          base flatparse generics-sop ghc-hs-meta incipit-base
-         template-haskell type-errors-pretty
+         template-haskell
        ];
        testHaskellDepends = [
          base hedgehog incipit-base tasty tasty-hedgehog template-haskell
···
        benchmarkHaskellDepends = [ base criterion incipit-base ];
        description = "Customizable Quasiquote Interpolation";
        license = "BSD-2-Clause-Patent";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "exotic-list-monads" = callPackage
···
        testHaskellDepends = [ base carray QuickCheck storable-complex ];
        description = "Bindings to the FFTW library";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {inherit (pkgs) fftw; inherit (pkgs) fftwFloat;};
 
   "fftw-ffi" = callPackage
···
      }:
      mkDerivation {
        pname = "fix-whitespace";
-       version = "0.0.10";
-       sha256 = "1jlkx0ygl315yik0f2fh4ml77c4080y0czs2mlnc84pkhximj58l";
-       isLibrary = false;
-       isExecutable = true;
-       executableHaskellDepends = [
-         base directory extra filepath filepattern text yaml
-       ];
-       description = "Fixes whitespace issues";
-       license = "unknown";
-       mainProgram = "fix-whitespace";
-     }) {};
-
-  "fix-whitespace_0_0_11" = callPackage
-    ({ mkDerivation, base, directory, extra, filepath, filepattern
-     , text, yaml
-     }:
-     mkDerivation {
-       pname = "fix-whitespace";
        version = "0.0.11";
        sha256 = "0q36vr3pfk1x14hl86g4g557299ih0510j7cf37h8n5nv8bs8gq2";
        isLibrary = false;
···
        ];
        description = "Fixes whitespace issues";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
        mainProgram = "fix-whitespace";
      }) {};
 
···
     ({ mkDerivation, base, deepseq, doctest, filemanip, primitive }:
      mkDerivation {
        pname = "fixed-vector";
-       version = "1.2.1.0";
-       sha256 = "05x3qivymg02n17wik17fmz2bqbbhj4b0w5iz7vnjz3szhwjizdf";
+       version = "1.2.2.1";
+       sha256 = "0kp747v67x1ija33nyqmyh6g178pqn2c7glynrpzcv733lalp00z";
        libraryHaskellDepends = [ base deepseq primitive ];
        testHaskellDepends = [ base doctest filemanip primitive ];
        description = "Generic vectors with statically known size";
        license = lib.licenses.bsd3;
-     }) {};
-
-  "fixed-vector_1_2_1_1" = callPackage
-    ({ mkDerivation, base, deepseq, doctest, filemanip, primitive }:
-     mkDerivation {
-       pname = "fixed-vector";
-       version = "1.2.1.1";
-       sha256 = "1gf3gpdl92yb7s68d39wmj7h9ivm925ix3yb7l5x0ljdw5xjldki";
-       libraryHaskellDepends = [ base deepseq primitive ];
-       testHaskellDepends = [ base doctest filemanip primitive ];
-       description = "Generic vectors with statically known size";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "fixed-vector-binary" = callPackage
···
        pname = "hackage-security-HTTP";
        version = "0.1.1.1";
        sha256 = "14hp7gssf80b9937j7m56w8sxrv3hrzjf2s9kgfk76v6llgx79k2";
-       revision = "3";
-       editedCabalFile = "14cypbxm6njhxwxps9ac80nf1j00vgh9bwcyxx9h74z5hi7wdld2";
+       revision = "4";
+       editedCabalFile = "09hs3iidjlwdppm5q1vq58p70js11whhcl5nr73kv8zj1yh0ir3h";
        libraryHaskellDepends = [
          base bytestring hackage-security HTTP mtl network network-uri zlib
        ];
···
     ({ mkDerivation, aeson, aeson-pretty, aeson-qq, base, Diff, hspec
      mkDerivation {
     ({ mkDerivation, aeson, aeson-pretty, aeson-qq, base, Diff, hspec
-       version = "0.0.0.3";
-    ({ mkDerivation, aeson, aeson-pretty, aeson-qq, base, Diff, hspec
+       version = "0.0.0.4";
+       sha256 = "07cqp51hq9andw9pw5nbpqkcmk4q6a9xlspayfh964pvz7p0vsbv";
     ({ mkDerivation, aeson, aeson-pretty, aeson-qq, base, Diff, hspec
     ({ mkDerivation, aeson, aeson-pretty, aeson-qq, base, Diff, hspec
        license = lib.licenses.mit;
···
     ({ mkDerivation, base }:
      mkDerivation {
     ({ mkDerivation, aeson, aeson-pretty, aeson-qq, base, Diff, hspec
-       version = "1.1";
-    ({ mkDerivation, aeson, aeson-pretty, aeson-qq, base, Diff, hspec
-       libraryHaskellDepends = [ base ];
-    ({ mkDerivation, aeson, aeson-pretty, aeson-qq, base, Diff, hspec
-       license = lib.licenses.bsd3;
-     }) {};
-
-    ({ mkDerivation, aeson, aeson-pretty, aeson-qq, base, Diff, hspec
-    ({ mkDerivation, base }:
-     mkDerivation {
-    ({ mkDerivation, aeson, aeson-pretty, aeson-qq, base, Diff, hspec
        version = "1.1.1";
     ({ mkDerivation, aeson, aeson-pretty, aeson-qq, base, Diff, hspec
        libraryHaskellDepends = [ base ];
     ({ mkDerivation, aeson, aeson-pretty, aeson-qq, base, Diff, hspec
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
     ({ mkDerivation, aeson, aeson-pretty, aeson-qq, base, Diff, hspec
···
      }:
      mkDerivation {
        pname = "hedgehog-classes";
-       version = "0.2.5.3";
-       sha256 = "1qanfnvciykm5hmiqyf0icn4xn16v6zvlfal98lphhcmym26m9x1";
-       revision = "3";
-       editedCabalFile = "09khb9px24zj24ahb51w1a6glgmcnhk2xn89gn1qwzhs3xn4vlj5";
-       libraryHaskellDepends = [
-         aeson base binary comonad containers hedgehog pretty-show primitive
-         semirings silently transformers vector wl-pprint-annotated
-       ];
-       testHaskellDepends = [
-         aeson base binary comonad containers hedgehog vector
-       ];
-       description = "Hedgehog will eat your typeclass bugs";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "hedgehog-classes_0_2_5_4" = callPackage
-    ({ mkDerivation, aeson, base, binary, comonad, containers, hedgehog
-     , pretty-show, primitive, semirings, silently, transformers, vector
-     , wl-pprint-annotated
-     }:
-     mkDerivation {
-       pname = "hedgehog-classes";
        version = "0.2.5.4";
        sha256 = "0z9ik5asddc2pnz430jsi1pyahkh6jy36ng0vwm7ywcq7cvhcvlz";
        libraryHaskellDepends = [
···
        ];
        description = "Hedgehog will eat your typeclass bugs";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "hedgehog-corpus" = callPackage
···
      }:
      mkDerivation {
        pname = "hercules-ci-agent";
-       version = "0.9.9";
-       sha256 = "1havsghzsbicixb8cya0v1694l7r9n2frnmy297ar3chblfj8hgl";
+       version = "0.9.10";
+       sha256 = "1sbp3jjn54z6hwkfgb83g0zgn1dm8qi9254g2yc8r4msm6n3nzww";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
      }:
      mkDerivation {
        pname = "hercules-ci-api";
-       version = "0.7.2.0";
-       sha256 = "0z3j96il0rvzplxih4vq5dghp18plbk5k55ymwm7dxp51d0jg902";
+       version = "0.7.2.1";
+       sha256 = "1nkmiyfmidrfqvlfy9k75y4asrrbrs2511kdzhrpb3zlrlaw4zb8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "hercules-ci-api-agent";
-       version = "0.4.6.0";
-       sha256 = "0bdmz7c4ln2bbss5wa4q8k9wha47knnp9d9n3w9kj8p7wzhc2kly";
+       version = "0.4.6.1";
+       sha256 = "07gvmcag36ai945j7bxnvy2x8fsx9apkabcikp6x1a2anvkgws24";
        libraryHaskellDepends = [
          aeson base base64-bytestring-type bytestring containers cookie
          deepseq exceptions hashable hercules-ci-api-core http-api-data
···
      , hercules-ci-api, hercules-ci-api-agent, hercules-ci-api-core
      , hercules-ci-cnix-expr, hercules-ci-cnix-store
      , hercules-ci-optparse-applicative, hostname, hspec, http-client
-     , http-client-tls, http-types, katip, lens, lens-aeson, lifted-base
-     , monad-control, network-uri, process, protolude, QuickCheck, retry
-     , rio, safe-exceptions, servant, servant-auth-client
-     , servant-client, servant-client-core, servant-conduit, temporary
-     , text, transformers, transformers-base, unix, unliftio
-     , unliftio-core, unordered-containers, uuid
+     , http-client-tls, http-types, inline-c-cpp, katip, lens
+     , lens-aeson, lifted-base, monad-control, network-uri, process
+     , protolude, QuickCheck, retry, rio, safe-exceptions, servant
+     , servant-auth-client, servant-client, servant-client-core
+     , servant-conduit, temporary, text, transformers, transformers-base
+     , unix, unliftio, unliftio-core, unordered-containers, uuid
      }:
      mkDerivation {
        pname = "hercules-ci-cli";
-       version = "0.3.4";
-       sha256 = "1n79ka1bn99vqa8i14f94zs4b78vl2pidx0h8nrdvg1xclqa5fka";
+       version = "0.3.5";
+       sha256 = "0mk6q6ccgpdpjfc7mdms28dbhh1bawy4jnnqcfcb6vxg4cj83f44";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          hercules-ci-agent hercules-ci-api hercules-ci-api-agent
          hercules-ci-api-core hercules-ci-cnix-expr hercules-ci-cnix-store
          hercules-ci-optparse-applicative hostname http-client
-         http-client-tls http-types katip lens lens-aeson lifted-base
-         monad-control network-uri process protolude retry rio
+         http-client-tls http-types inline-c-cpp katip lens lens-aeson
+         lifted-base monad-control network-uri process protolude retry rio
          safe-exceptions servant servant-auth-client servant-client
          servant-client-core servant-conduit temporary text transformers
          transformers-base unix unliftio unliftio-core unordered-containers
···
      }:
      mkDerivation {
        pname = "hercules-ci-cnix-expr";
-       version = "0.3.4.0";
-       sha256 = "1mszhnd2z0qy58x13w5nbw3ymqvd8vf0d4kh3bprrjlbll0rxmgn";
+       version = "0.3.5.0";
+       sha256 = "0r70kjn8a1wiw1zndahrg2gc88k52dscm4yjmms2caf22pkh562a";
        enableSeparateDataOutput = true;
        setupHaskellDepends = [ base Cabal cabal-pkg-config-version-hook ];
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "hercules-ci-cnix-store";
-       version = "0.3.3.2";
-       sha256 = "11z6k9r8z2bvf0wly6b0fr0s3svbrf1rgz0v2in33jq6739lci92";
+       version = "0.3.3.3";
+       sha256 = "1w4azya8phkk3gmkifcv2pc6jh8zanwk9m2vwqsdgk7kr8zkkzws";
        setupHaskellDepends = [ base Cabal cabal-pkg-config-version-hook ];
        libraryHaskellDepends = [
          base bytestring conduit containers inline-c inline-c-cpp protolude
···
     ({ mkDerivation, abstract-par, aeson, ansi-wl-pprint, array, async
      , base, base16-bytestring, binary, brick, bytestring, cereal
      , containers, cryptonite, data-dword, Decimal, deepseq, directory
-     , fgl, filepath, free, haskeline, here, HUnit, lens, lens-aeson
-     , libff, megaparsec, memory, monad-par, mtl, multiset, operational
-     , optparse-generic, parsec, process, QuickCheck
+     , fgl, filemanip, filepath, free, haskeline, here, HUnit, lens
+     , lens-aeson, libff, megaparsec, memory, monad-par, mtl, multiset
+     , operational, optparse-generic, parsec, process, QuickCheck
      , quickcheck-instances, quickcheck-text, regex, regex-tdfa
      , restless-git, rosezipper, s-cargot, scientific, secp256k1
      , semver-range, smt2-parser, spool, tasty, tasty-expected-failure
···
      }:
      mkDerivation {
        pname = "hevm";
-       version = "0.50.0";
-       sha256 = "0wdp7vl1aq79k8sw7n4mf6wv184as0pmprdffzklzkcskvs9yjmb";
+       version = "0.50.1";
+       sha256 = "07s6p22j8cagwyni8f362c0z9cmd7l0xhh6cm0xv1g7kphnla2qp";
        isLibrary = true;
        isExecutable = true;
-       enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          abstract-par aeson ansi-wl-pprint array async base
          base16-bytestring binary brick bytestring cereal containers
-         cryptonite data-dword Decimal deepseq directory fgl filepath free
-         haskeline here HUnit lens lens-aeson megaparsec memory monad-par
-         mtl multiset operational optparse-generic parsec process QuickCheck
-         quickcheck-instances quickcheck-text regex regex-tdfa restless-git
-         rosezipper s-cargot scientific semver-range smt2-parser spool tasty
-         tasty-expected-failure tasty-hunit tasty-quickcheck temporary text
-         time transformers tree-view tuple unordered-containers vector vty
-         witherable word-wrap wreq
+         cryptonite data-dword Decimal deepseq directory fgl filemanip
+         filepath free haskeline here HUnit lens lens-aeson megaparsec
+         memory monad-par mtl multiset operational optparse-generic parsec
+         process QuickCheck quickcheck-instances quickcheck-text regex
+         regex-tdfa restless-git rosezipper s-cargot scientific semver-range
+         smt2-parser spool tasty tasty-expected-failure tasty-hunit
+         tasty-quickcheck temporary text time transformers tree-view tuple
+         unordered-containers vector vty witherable word-wrap wreq
        ];
        librarySystemDepends = [ libff secp256k1 ];
        executableHaskellDepends = [
···
          temporary text unordered-containers vector vty
        ];
        testHaskellDepends = [
-         array base base16-bytestring binary bytestring containers
-         data-dword directory here HUnit lens mtl process QuickCheck
-         quickcheck-instances regex regex-tdfa smt2-parser tasty
+         aeson array base base16-bytestring binary bytestring containers
+         data-dword directory filemanip filepath here HUnit lens mtl process
+         QuickCheck quickcheck-instances regex regex-tdfa smt2-parser tasty
          tasty-expected-failure tasty-hunit tasty-quickcheck temporary text
-         time vector
+         time vector witherable
        ];
        testSystemDepends = [ secp256k1 ];
        doHaddock = false;
        description = "Ethereum virtual machine evaluator";
        license = lib.licenses.agpl3Only;
-       hydraPlatforms = lib.platforms.none;
        mainProgram = "hevm";
        maintainers = [ lib.maintainers.arturcygan ];
-       broken = true;
      }) {inherit (pkgs) libff; inherit (pkgs) secp256k1;};
 
   "hevolisa" = callPackage
···
        ];
        description = "Call hierarchy plugin for Haskell Language Server";
        license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "hls-change-type-signature-plugin" = callPackage
···
      }:
      mkDerivation {
        pname = "horizon-gen-nix";
-       version = "0.3.1.0";
-       sha256 = "1by0813yzhnzl188b7sdcy682arprhgahnivpqxkm1pfk2im92i9";
+       version = "0.4.0";
+       sha256 = "0s0macrn45wh1y7nflw9y73wxsynvym7n12f9n0yhxi8w3j7wzn2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        mainProgram = "hp2pretty";
      }) {};
 
-  "hpack" = callPackage
+  "hpack_0_35_0" = callPackage
     ({ mkDerivation, aeson, base, bifunctors, bytestring, Cabal
      , containers, cryptonite, deepseq, directory, filepath, Glob, hspec
      , hspec-discover, http-client, http-client-tls, http-types, HUnit
···
        testToolDepends = [ hspec-discover ];
        description = "A modern format for Haskell packages";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "hpack";
      }) {};
 
-  "hpack_0_35_1" = callPackage
+  "hpack" = callPackage
     ({ mkDerivation, aeson, base, bifunctors, bytestring, Cabal
      , containers, cryptonite, deepseq, directory, filepath, Glob, hspec
      , hspec-discover, http-client, http-client-tls, http-types, HUnit
···
        testToolDepends = [ hspec-discover ];
        description = "A modern format for Haskell packages";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
        mainProgram = "hpack";
      }) {};
 
···
      }:
      mkDerivation {
        pname = "hw-json-simd";
-       version = "0.1.1.1";
-       sha256 = "0nn6fyvw0j2csn8anqpgjzdzdasiwa99g1v2qrcyym1wi86biqqb";
-       revision = "1";
-       editedCabalFile = "0cavymml55m8f1zyh8pby44xq67ckdqdy0wgib8i0xjq00hrp07m";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [ base bytestring hw-prim lens vector ];
-       libraryToolDepends = [ c2hs ];
-       executableHaskellDepends = [
-         base bytestring hw-prim lens optparse-applicative vector
-       ];
-       testHaskellDepends = [
-         base bytestring doctest doctest-discover hw-prim lens transformers
-         vector
-       ];
-       testToolDepends = [ doctest-discover ];
-       description = "SIMD-based JSON semi-indexer";
-       license = lib.licenses.bsd3;
-       mainProgram = "hw-json-simd";
-     }) {};
-
-  "hw-json-simd_0_1_1_2" = callPackage
-    ({ mkDerivation, base, bytestring, c2hs, doctest, doctest-discover
-     , hw-prim, lens, optparse-applicative, transformers, vector
-     }:
-     mkDerivation {
-       pname = "hw-json-simd";
        version = "0.1.1.2";
        sha256 = "03g2gwmkp6v7b0vf4x8bh4qk91ghr0av5x3c9paj3rp3igycccd6";
        isLibrary = true;
···
        testToolDepends = [ doctest-discover ];
        description = "SIMD-based JSON semi-indexer";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
        mainProgram = "hw-json-simd";
      }) {};
 
···
      }:
      mkDerivation {
        pname = "hw-simd";
-       version = "0.1.2.1";
-       sha256 = "051dbwi4kvv04dnglcx9666g097fy9rw8kmgbcw5y9cs06mbw9cr";
-       revision = "2";
-       editedCabalFile = "10ns52d5xzry7bkaaggv5sgry44fxl9jpyx48iafyfpcn3h8439k";
-       libraryHaskellDepends = [
-         base bits-extra bytestring deepseq hw-bits hw-prim hw-rankselect
-         hw-rankselect-base transformers vector
-       ];
-       libraryToolDepends = [ c2hs ];
-       testHaskellDepends = [
-         base bits-extra bytestring deepseq directory doctest
-         doctest-discover hedgehog hspec hw-bits hw-hedgehog
-         hw-hspec-hedgehog hw-prim hw-rankselect hw-rankselect-base lens
-         text vector
-       ];
-       testToolDepends = [ doctest-discover hspec-discover ];
-       benchmarkHaskellDepends = [
-         base bits-extra bytestring cassava containers criterion deepseq
-         directory hw-bits hw-prim hw-rankselect hw-rankselect-base mmap
-         transformers vector
-       ];
-       description = "SIMD library";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "hw-simd_0_1_2_2" = callPackage
-    ({ mkDerivation, base, bits-extra, bytestring, c2hs, cassava
-     , containers, criterion, deepseq, directory, doctest
-     , doctest-discover, hedgehog, hspec, hspec-discover, hw-bits
-     , hw-hedgehog, hw-hspec-hedgehog, hw-prim, hw-rankselect
-     , hw-rankselect-base, lens, mmap, text, transformers, vector
-     }:
-     mkDerivation {
-       pname = "hw-simd";
        version = "0.1.2.2";
        sha256 = "0ipcrv19xwmq6znbmwmzrjahmymmcmpbs7hpx0183hrwbx2hyhqx";
        libraryHaskellDepends = [
···
        ];
        description = "SIMD library";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "hw-simd-cli" = callPackage
···
      }:
      mkDerivation {
        pname = "incipit";
-       version = "0.5.0.0";
-       sha256 = "137i92xfpchyvnrckb8876cxw514zxf53hbzqyyj6f4mipiq319j";
+       version = "0.7.0.0";
+       sha256 = "00ymmb2d5hlskc2zc88kibgx1c5mxp4bdfymahzhqg1qhyw3q9ci";
        libraryHaskellDepends = [
          base incipit-core polysemy-conc polysemy-log polysemy-resume
          polysemy-time
···
      }:
      mkDerivation {
        pname = "incipit-base";
-       version = "0.4.0.0";
-       sha256 = "08r934qii1hc7hb3xmk7mpw0srh82h2djxkh55gskm7wbaby15qi";
+       version = "0.5.0.0";
+       sha256 = "1h3mmabxb0c29cy349xkk87df4x0dxakfaryyr8r43wj2l39yhj0";
        libraryHaskellDepends = [
          base bytestring containers data-default stm text
        ];
···
     ({ mkDerivation, base, incipit-base, polysemy }:
      mkDerivation {
        pname = "incipit-core";
-       version = "0.4.0.0";
-       sha256 = "0nh1ivn74fcciwmvnqdr1h1vdhxxy3xjf2bzsdm1dpyylglcaspr";
+       version = "0.5.0.0";
+       sha256 = "17fbdp2v22fni36ijfm9hb9hkcarg4jy3xksngnhlzxqz77adcyj";
        libraryHaskellDepends = [ base incipit-base polysemy ];
        description = "A Prelude for Polysemy";
        license = "BSD-2-Clause-Patent";
···
        ];
        description = "OpenAPI Definitions for Jordan, Automatically";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "jordan-servant" = callPackage
···
        ];
        description = "OpenAPI schemas for Jordan-Powered Servant APIs";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "jordan-servant-server" = callPackage
···
      }:
      mkDerivation {
        pname = "lzma-static";
-       version = "5.2.5.4";
-       sha256 = "0ql96kb7hg50d1flk36999p5p05bqs7rp7a59ys4q02423mq1z7b";
-       revision = "2";
-       editedCabalFile = "0dvqqjihfzkcqaahicga0cnimcwh197dpj8spqrk9mmicmqs5gcr";
+       version = "5.2.5.5";
+       sha256 = "1qq0lzyfpnjdl9mh8qrr5lhhby8gxzgi1a8wiwpf3vkrziz5hh23";
        libraryHaskellDepends = [ base bytestring ];
        testHaskellDepends = [
          base bytestring HUnit QuickCheck tasty tasty-hunit tasty-quickcheck
···
   "massiv" = callPackage
     ({ mkDerivation, base, bytestring, deepseq, doctest, exceptions
      , primitive, random, scheduler, unliftio-core, vector
-     }:
-     mkDerivation {
-       pname = "massiv";
-       version = "1.0.2.0";
-       sha256 = "15ckrsavsrkgm4c9al2jlk1r4nm2mdjshw1ksbkh8m65l3l5kcrr";
-       libraryHaskellDepends = [
-         base bytestring deepseq exceptions primitive random scheduler
-         unliftio-core vector
-       ];
-       testHaskellDepends = [ base doctest ];
-       description = "Massiv (Массив) is an Array Library";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "massiv_1_0_3_0" = callPackage
-    ({ mkDerivation, base, bytestring, deepseq, doctest, exceptions
-     , primitive, random, scheduler, unliftio-core, vector
      , vector-stream
      }:
      mkDerivation {
···
        testHaskellDepends = [ base doctest ];
        description = "Massiv (Массив) is an Array Library";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "massiv-io" = callPackage
···
     ({ mkDerivation, base, microlens }:
      mkDerivation {
        pname = "microlens-contra";
-       version = "0.1.0.2";
-       sha256 = "1ny9qhvd7rfzdkq4jdcgh4mfia856rsgpdhg8lprfprh6p7lhy5m";
-       libraryHaskellDepends = [ base microlens ];
-       description = "True folds and getters for microlens";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "microlens-contra_0_1_0_3" = callPackage
-    ({ mkDerivation, base, microlens }:
-     mkDerivation {
-       pname = "microlens-contra";
        version = "0.1.0.3";
        sha256 = "1jxm6shmvacbic6i6hask0kv89kramnk77pcxpv4gv4xydjsr88n";
        libraryHaskellDepends = [ base microlens ];
        description = "True folds and getters for microlens";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "microlens-each" = callPackage
···
      }:
      mkDerivation {
        pname = "microlens-mtl";
-       version = "0.2.0.2";
-       sha256 = "0y1jli9379l8sgv5a4xl8v3qkz9fkp4qlfsywzdpywbnydl1d5v6";
-       libraryHaskellDepends = [
-         base microlens mtl transformers transformers-compat
-       ];
-       description = "microlens support for Reader/Writer/State from mtl";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "microlens-mtl_0_2_0_3" = callPackage
-    ({ mkDerivation, base, microlens, mtl, transformers
-     , transformers-compat
-     }:
-     mkDerivation {
-       pname = "microlens-mtl";
        version = "0.2.0.3";
        sha256 = "1ilz0zyyk9f6h97gjsaqq65njfs23fk3wxhigvj4z0brf7rnlssd";
        libraryHaskellDepends = [
···
        ];
        description = "microlens support for Reader/Writer/State from mtl";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "microlens-platform" = callPackage
···
      }:
      mkDerivation {
        pname = "microlens-th";
-       version = "0.4.3.10";
-       sha256 = "1dg2xhj85fy8q39m5dd94kjlabjyxgc0336vzkg0174l6l110l1c";
-       revision = "1";
-       editedCabalFile = "142wksvc854qmd665qd6mwzik8g02yzfpjk1fpxw4mlcns06y4m2";
-       libraryHaskellDepends = [
-         base containers microlens template-haskell th-abstraction
-         transformers
-       ];
-       testHaskellDepends = [ base microlens tagged ];
-       description = "Automatic generation of record lenses for microlens";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "microlens-th_0_4_3_11" = callPackage
-    ({ mkDerivation, base, containers, microlens, tagged
-     , template-haskell, th-abstraction, transformers
-     }:
-     mkDerivation {
-       pname = "microlens-th";
        version = "0.4.3.11";
        sha256 = "1vjjaclfxr0kvlpmj8zh7f6ci4n4b8vynqd67zszx42al7gal6pj";
        libraryHaskellDepends = [
···
        testHaskellDepends = [ base microlens tagged ];
        description = "Automatic generation of record lenses for microlens";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "micrologger" = callPackage
···
      }:
      mkDerivation {
        pname = "monoid-extras";
-       version = "0.6.1";
-       sha256 = "1nj5rfax9lmr1pprvgdgq90am9mknx9iv7s84smv6qaw050356jf";
-       revision = "2";
-       editedCabalFile = "04zbzq7dbv0ddpc1dxrxn9jfyg1xj8sar6ngzhc0cji72cail503";
-       libraryHaskellDepends = [ base groups semigroupoids ];
-       benchmarkHaskellDepends = [ base criterion semigroups ];
-       description = "Various extra monoid-related definitions and utilities";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "monoid-extras_0_6_2" = callPackage
-    ({ mkDerivation, base, criterion, groups, semigroupoids, semigroups
-     }:
-     mkDerivation {
-       pname = "monoid-extras";
        version = "0.6.2";
        sha256 = "1qaxp0cf2cvzvfpk7x9mjz1zmlpjfzxij8v2n45w89s7bq9ckvlw";
        libraryHaskellDepends = [ base groups semigroupoids ];
        benchmarkHaskellDepends = [ base criterion semigroups ];
        description = "Various extra monoid-related definitions and utilities";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "monoid-map" = callPackage
···
      }:
      mkDerivation {
        pname = "monomer-hagrid";
-       version = "0.2.0.0";
-       sha256 = "160d4acqrrxhlbx85749vm02c01sz7lxp8gxnykv1f0f00bb8w67";
+       version = "0.2.0.1";
+       sha256 = "0vic013zr80wlm1gf33y8vlkpmrv6z52975dpa3ciypayd36hy2m";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "multicurryable" = callPackage
+    ({ mkDerivation, base, sop-core }:
+     mkDerivation {
+       pname = "multicurryable";
+       version = "0.1.0.0";
+       sha256 = "0p0wlz44scvkxzdhd059ivrhz4bsgbml26a8fm7jsav80cwbdfc4";
+       libraryHaskellDepends = [ base sop-core ];
+       testHaskellDepends = [ base sop-core ];
+       description = "Uncurry functions with multiple arguments";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "multifile" = callPackage
     ({ mkDerivation, base, directory, HaXml, optparse-applicative
      , pretty, process, transformers
···
      }) {};
 
   "named-text" = callPackage
-    ({ mkDerivation, base, deepseq, hashable, prettyprinter, sayable
-     , text
+    ({ mkDerivation, aeson, base, bytestring, deepseq, hashable, hspec
+     , parameterized-utils, prettyprinter, sayable, tasty, tasty-ant-xml
+     , tasty-checklist, tasty-hspec, text, unordered-containers
      }:
      mkDerivation {
        pname = "named-text";
-       version = "1.0.1.0";
-       sha256 = "05v79ry6rlrpfvf36nkzf6l4xm2kzgpdrvaivg878nxcrni1gr78";
+       version = "1.1.1.0";
+       sha256 = "1g3xb3pr6sxn3sk9h2jbqlj30vh4nxcc14d06dawmqfva8b1gfp5";
        libraryHaskellDepends = [
-         base deepseq hashable prettyprinter sayable text
+         aeson base deepseq hashable prettyprinter sayable text
+       ];
+       testHaskellDepends = [
+         aeson base bytestring hspec parameterized-utils prettyprinter
+         sayable tasty tasty-ant-xml tasty-checklist tasty-hspec text
+         unordered-containers
        ];
        description = "A parameterized named text type and associated functionality";
        license = lib.licenses.isc;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "namelist" = callPackage
···
      }:
      mkDerivation {
        pname = "network-uri";
-       version = "2.6.4.1";
-       sha256 = "111m485rx2kyqdymi1x6sl08hi6lp34q3f41yqcx99086swnv1ap";
-       libraryHaskellDepends = [
-         base deepseq parsec template-haskell th-compat
-       ];
-       testHaskellDepends = [
-         base HUnit QuickCheck tasty tasty-hunit tasty-quickcheck
-       ];
-       benchmarkHaskellDepends = [ base criterion deepseq HUnit ];
-       description = "URI manipulation";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "network-uri_2_6_4_2" = callPackage
-    ({ mkDerivation, base, criterion, deepseq, HUnit, parsec
-     , QuickCheck, tasty, tasty-hunit, tasty-quickcheck
-     , template-haskell, th-compat
-     }:
-     mkDerivation {
-       pname = "network-uri";
        version = "2.6.4.2";
        sha256 = "0a3jg6aykwm1yw32nh137hi6r86w2640xwl1p18352bf29rqj64w";
        libraryHaskellDepends = [
···
        benchmarkHaskellDepends = [ base criterion deepseq HUnit ];
        description = "URI manipulation";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "network-uri-flag" = callPackage
···
      }:
      mkDerivation {
        pname = "nvim-hs";
-       version = "2.3.1.0";
-       sha256 = "1vgdvcvjyl7dxmvmcljb130gwp806769hks00fj1sqfi953lm9bf";
-       libraryHaskellDepends = [
-         base bytestring cereal cereal-conduit conduit containers
-         data-default deepseq foreign-store hslogger megaparsec messagepack
-         mtl network optparse-applicative path path-io prettyprinter
-         prettyprinter-ansi-terminal resourcet stm streaming-commons
-         template-haskell template-haskell-compat-v0208 text time
-         time-locale-compat transformers transformers-base typed-process
-         unliftio unliftio-core utf8-string vector void
-       ];
-       testHaskellDepends = [
-         base bytestring cereal cereal-conduit conduit containers
-         data-default foreign-store hslogger hspec hspec-discover HUnit
-         megaparsec messagepack mtl network optparse-applicative path
-         path-io prettyprinter prettyprinter-ansi-terminal QuickCheck
-         resourcet stm streaming-commons template-haskell
-         template-haskell-compat-v0208 text time time-locale-compat
-         transformers transformers-base typed-process unliftio unliftio-core
-         utf8-string vector
-       ];
-       testToolDepends = [ hspec-discover ];
-       description = "Haskell plugin backend for neovim";
-       license = lib.licenses.asl20;
-     }) {};
-
-  "nvim-hs_2_3_2_0" = callPackage
-    ({ mkDerivation, base, bytestring, cereal, cereal-conduit, conduit
-     , containers, data-default, deepseq, foreign-store, hslogger, hspec
-     , hspec-discover, HUnit, megaparsec, messagepack, mtl, network
-     , optparse-applicative, path, path-io, prettyprinter
-     , prettyprinter-ansi-terminal, QuickCheck, resourcet, stm
-     , streaming-commons, template-haskell
-     , template-haskell-compat-v0208, text, time, time-locale-compat
-     , transformers, transformers-base, typed-process, unliftio
-     , unliftio-core, utf8-string, vector, void
-     }:
-     mkDerivation {
-       pname = "nvim-hs";
        version = "2.3.2.0";
        sha256 = "1szvh65sbxk81321ml0b1iib5ziiks2l8liwkgs4z47pmb14cps9";
        libraryHaskellDepends = [
···
        testToolDepends = [ hspec-discover ];
        description = "Haskell plugin backend for neovim";
        license = lib.licenses.asl20;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "nvim-hs-contrib" = callPackage
···
      }) {};
 
   "nvim-hs-ghcid" = callPackage
-    ({ mkDerivation, base, bytestring, containers, directory, filepath
-     , ghcid, nvim-hs, nvim-hs-contrib, resourcet, transformers
-     , unliftio, yaml
-     }:
-     mkDerivation {
-       pname = "nvim-hs-ghcid";
-       version = "2.0.0.0";
-       sha256 = "0i9wc6mgxxzymw1smjvin70i4ynqsn2k3ig36pxmbb6qd0ci0hwg";
-       revision = "1";
-       editedCabalFile = "0na6lv57jdrpq1zkp3dhlpzh0wrr9632h7izw7jf8622x51qlh4r";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         base bytestring containers directory filepath ghcid nvim-hs
-         nvim-hs-contrib resourcet transformers unliftio yaml
-       ];
-       executableHaskellDepends = [ base nvim-hs ];
-       description = "Neovim plugin that runs ghcid to update the quickfix list";
-       license = lib.licenses.asl20;
-       hydraPlatforms = lib.platforms.none;
-       mainProgram = "nvim-hs-ghcid";
-       broken = true;
-     }) {};
-
-  "nvim-hs-ghcid_2_0_1_0" = callPackage
     ({ mkDerivation, base, bytestring, containers, directory, filepath
      , ghcid, nvim-hs, nvim-hs-contrib, resourcet, transformers
      , unliftio, yaml
···
     ({ mkDerivation, aeson, aeson-pretty, base, base-compat-batteries
      , bytestring, Cabal, cabal-doctest, containers, cookie, doctest
      , generics-sop, Glob, hashable, hspec, hspec-discover, http-media
-     , HUnit, insert-ordered-containers, lens, mtl, network, optics-core
-     , optics-th, QuickCheck, quickcheck-instances, scientific
-     , template-haskell, text, time, transformers, unordered-containers
-     , utf8-string, uuid-types, vector
-     }:
-     mkDerivation {
-       pname = "openapi3";
-       version = "3.2.2";
-       sha256 = "0d31ilv2ivwswzbpfibqwnld8697vk63wyr6yl80brjx60g4jp9j";
-       revision = "2";
-       editedCabalFile = "1yc3wlc8j84glav3hzx1l4yq33k05bll252a8yl6ld275jjswn8p";
-       isLibrary = true;
-       isExecutable = true;
-       setupHaskellDepends = [ base Cabal cabal-doctest ];
-       libraryHaskellDepends = [
-         aeson aeson-pretty base base-compat-batteries bytestring containers
-         cookie generics-sop hashable http-media insert-ordered-containers
-         lens mtl network optics-core optics-th QuickCheck scientific
-         template-haskell text time transformers unordered-containers
-         uuid-types vector
-       ];
-       executableHaskellDepends = [ aeson base lens text ];
-       testHaskellDepends = [
-         aeson base base-compat-batteries bytestring containers doctest Glob
-         hashable hspec HUnit insert-ordered-containers lens mtl QuickCheck
-         quickcheck-instances template-haskell text time
-         unordered-containers utf8-string vector
-       ];
-       testToolDepends = [ hspec-discover ];
-       description = "OpenAPI 3.0 data model";
-       license = lib.licenses.bsd3;
-       mainProgram = "example";
-     }) {};
-
-  "openapi3_3_2_3" = callPackage
-    ({ mkDerivation, aeson, aeson-pretty, base, base-compat-batteries
-     , bytestring, Cabal, cabal-doctest, containers, cookie, doctest
-     , generics-sop, Glob, hashable, hspec, hspec-discover, http-media
      , HUnit, insert-ordered-containers, lens, mtl, optics-core
      , optics-th, QuickCheck, quickcheck-instances, scientific
      , template-haskell, text, time, transformers, unordered-containers
···
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        mainProgram = "example";
+       broken = true;
      }) {};
 
   "openapi3-code-generator" = callPackage
···
      }) {};
 
   "pandoc-stylefrommeta" = callPackage
-    ({ mkDerivation, base, bytestring, containers, extra, pandoc
-     , pandoc-types, text
+    ({ mkDerivation, base, bytestring, containers, pandoc, pandoc-types
+     , text
      }:
      mkDerivation {
        pname = "pandoc-stylefrommeta";
-       version = "0.2.3.0";
-       sha256 = "1145flz4jkn5knqkc5cppc1412m6hfzd13124k2kfm8dmw196k31";
+       version = "0.2.4.0";
+       sha256 = "0j25frcafcr0jvk3dfrmxan2q95920wy6jm0fahwf20f4jbanzfc";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
-         base bytestring containers extra pandoc pandoc-types text
+         base bytestring containers pandoc pandoc-types text
        ];
        description = "Pandoc filter to customize links, images and paragraphs";
        license = lib.licenses.bsd3;
···
     ({ mkDerivation, base, hedgehog, partial-semigroup }:
      mkDerivation {
        pname = "partial-semigroup-hedgehog";
-       version = "0.6.0.12";
-       sha256 = "0razhgznrrzp23zdpl1z8056n2dp2azl42cnha2g0b5h04nipg4q";
-       revision = "1";
-       editedCabalFile = "13ba819c67d1j6a5rr5w2lss1drb3znjdkfv2y0fd5givda2ds5v";
+       version = "0.6.0.13";
+       sha256 = "117k12wgaypj7lkj9lqi7xhli9f33hsd455p87g9xxcwx32m0r53";
        libraryHaskellDepends = [ base hedgehog partial-semigroup ];
        description = "Property testing for partial semigroups using Hedgehog";
        license = lib.licenses.asl20;
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "polysemy_1_8_0_0" = callPackage
+  "polysemy_1_9_0_0" = callPackage
     ({ mkDerivation, async, base, Cabal, cabal-doctest, containers
      , doctest, first-class-families, hspec, hspec-discover
      , inspection-testing, mtl, stm, syb, template-haskell
···
      }:
      mkDerivation {
        pname = "polysemy";
-       version = "1.8.0.0";
-       sha256 = "1fyysldfnirhk8nfgiji248rc35c97r0hm4hk6j1n12ynhxcaiwb";
+       version = "1.9.0.0";
+       sha256 = "00qmsn0mr88y29my389ln6c5imcac73p7hisd102w4qlwikwj9ir";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          async base containers first-class-families mtl stm syb
···
      }:
      mkDerivation {
        pname = "polysemy-conc";
-       version = "0.11.1.0";
-       sha256 = "0kwfvwv4hzbm51sk78k1ka9i3f23jp9r8d0acs4gjnbbjfvv78wk";
+       version = "0.12.1.0";
+       sha256 = "0js5hl84nfmb2i5si67wrf9d0i69piaj44v3sbia6yncq85fj7vn";
        libraryHaskellDepends = [
          async base containers incipit-core polysemy polysemy-resume
          polysemy-time stm stm-chans torsor unagi-chan unix
···
      }:
      mkDerivation {
        pname = "polysemy-http";
-       version = "0.9.0.0";
-       sha256 = "13d5ydyaq6jjinq8h8slxj0iw6bfpg7cdv0lj0kl8kpvikr6livg";
+       version = "0.10.0.0";
+       sha256 = "1j0a0gmlr1cd6mwa8y4f6dq3zf4asmgj4v4cdriiw0k1cxi81l9c";
        libraryHaskellDepends = [
          aeson base case-insensitive exon http-client http-client-tls
          http-types polysemy polysemy-plugin prelate time
···
      }:
      mkDerivation {
        pname = "polysemy-log";
-       version = "0.8.0.0";
-       sha256 = "0zvlx1y852c1jyaw3lcxps8yb6qk56i8drnfbqvdpss3hb6jhii7";
+       version = "0.9.0.0";
+       sha256 = "1sgmgbh7gkyhp7rmdx2rj6dibwhi6z2qzg4cbnjsx8asz6xa188h";
        libraryHaskellDepends = [
          ansi-terminal async base incipit-core polysemy polysemy-conc
          polysemy-time stm time
···
      }:
      mkDerivation {
        pname = "polysemy-log-co";
-       version = "0.8.0.0";
-       sha256 = "09r4aqkwfjnwnlym97mfasghb3c9jq9vlmqlycz0kgsid8hdjh52";
+       version = "0.9.0.0";
+       sha256 = "18z75dbbqf18ff3dc641svm93fvrdaxzplbaicdy7y3dz3y7apmv";
        libraryHaskellDepends = [
          base co-log co-log-concurrent co-log-polysemy incipit-core polysemy
          polysemy-conc polysemy-log polysemy-time stm
···
      }:
      mkDerivation {
        pname = "polysemy-log-di";
-       version = "0.8.0.0";
-       sha256 = "1gmwrmnw4675y8hzywazjcafd0hkfal7rxpcycz4dpvzsqznrcrz";
+       version = "0.9.0.0";
+       sha256 = "0zwcv6b0m5phwiy0c1z3wfnbw0976qg744dpb6k66wdr3yvpl05f";
        libraryHaskellDepends = [
          base di-polysemy incipit-core polysemy polysemy-conc polysemy-log
          polysemy-time stm
···
      }:
      mkDerivation {
        pname = "polysemy-mocks";
-       version = "0.3.0.0";
-       sha256 = "03yq5pyrg2rhykyhvp3f8b816r9j035xr5d9d1cls73zh9pbbh7z";
+       version = "0.3.1.0";
+       sha256 = "08dsx682fvx7ywiixxjaa5b05r3s97anl893nlfc3vy6qynaqkns";
        libraryHaskellDepends = [ base polysemy template-haskell ];
        testHaskellDepends = [ base hspec polysemy ];
        testToolDepends = [ hspec-discover ];
···
      }:
      mkDerivation {
        pname = "polysemy-plugin";
-       version = "0.4.3.1";
-       sha256 = "02s9hb0y4fgvmlkg7izwq24hrgb92h1jd7v0gjzayjn6la8xmf6r";
-       setupHaskellDepends = [ base Cabal cabal-doctest ];
-       libraryHaskellDepends = [
-         base containers ghc ghc-tcplugins-extra polysemy syb transformers
-       ];
-       testHaskellDepends = [
-         base containers doctest ghc ghc-tcplugins-extra hspec
-         inspection-testing polysemy should-not-typecheck syb transformers
-       ];
-       testToolDepends = [ hspec-discover ];
-       description = "Disambiguate obvious uses of effects";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "polysemy-plugin_0_4_4_0" = callPackage
-    ({ mkDerivation, base, Cabal, cabal-doctest, containers, doctest
-     , ghc, ghc-tcplugins-extra, hspec, hspec-discover
-     , inspection-testing, polysemy, should-not-typecheck, syb
-     , transformers
-     }:
-     mkDerivation {
-       pname = "polysemy-plugin";
        version = "0.4.4.0";
        sha256 = "1kp7d4m007mlk4pl2p8933b5yzzb8gl30g1vfbbz01vm3pgjcj3d";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
···
        testToolDepends = [ hspec-discover ];
        description = "Disambiguate obvious uses of effects";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "polysemy-process" = callPackage
···
      }:
      mkDerivation {
        pname = "polysemy-process";
-       version = "0.11.1.0";
-       sha256 = "09bzjdnj15bv0fnvs99f6x71yqmy0lbsnxbr4w3mxn4yp73sppc1";
+       version = "0.12.1.0";
+       sha256 = "0009h21pwfkwfyb5qk6v9gw5gh2ksap3xbcbny2icn88dhqs42k6";
        libraryHaskellDepends = [
          base incipit-core path path-io polysemy polysemy-conc
          polysemy-resume polysemy-time posix-pty process stm-chans
···
      }:
      mkDerivation {
        pname = "polysemy-resume";
-       version = "0.6.0.0";
-       sha256 = "1m6rw8h1glvzic2zhnksiag377zqyf771ypqks59yksmw11hvsyv";
+       version = "0.7.0.0";
+       sha256 = "0f2hlccg7qpx9dd1k73ni59yl447m3v2s6r8h9n2k1klxc21jr07";
        libraryHaskellDepends = [
          base incipit-core polysemy transformers
        ];
···
      }:
      mkDerivation {
        pname = "prelate";
-       version = "0.3.0.0";
-       sha256 = "13qrk305k5mgpkhjhk92zs0rp3y68k7rhj5d3cqj785bvyvpz3wh";
+       version = "0.4.0.0";
+       sha256 = "0bil1d1daw6a37zi0fddf3mja3ab12rcsldi879qcipbjc7bh4bz";
        libraryHaskellDepends = [
          aeson base exon extra generic-lens incipit microlens microlens-ghc
          polysemy-chronos polysemy-conc polysemy-log polysemy-process
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "quickcheck-monoid-subclasses" = callPackage
+    ({ mkDerivation, base, bytestring, commutative-semigroups
+     , containers, hspec, hspec-discover, monoid-subclasses, pretty-show
+     , QuickCheck, quickcheck-classes, quickcheck-instances
+     , semigroupoids, text, vector
+     }:
+     mkDerivation {
+       pname = "quickcheck-monoid-subclasses";
+       version = "0.0.0.1";
+       sha256 = "1x1jza5s1v89ik0h5m3kla5qwgh05j5dbd7f2m2miwyy1b75bqly";
+       libraryHaskellDepends = [
+         base containers monoid-subclasses pretty-show QuickCheck
+         quickcheck-classes quickcheck-instances semigroupoids
+       ];
+       testHaskellDepends = [
+         base bytestring commutative-semigroups containers hspec
+         monoid-subclasses QuickCheck quickcheck-classes
+         quickcheck-instances text vector
+       ];
+       testToolDepends = [ hspec-discover ];
+       doHaddock = false;
+       description = "Testing monoid subclass instances with QuickCheck";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "quickcheck-poly" = callPackage
     ({ mkDerivation, base, haskell98, hint, MonadCatchIO-mtl
      , QuickCheck, regex-compat, regex-tdfa
···
      }:
      mkDerivation {
        pname = "recursion-schemes";
-       version = "5.2.2.2";
-       sha256 = "018l7j9pk8izi817vqyrakrkjsxr332jh24d6j0yl35i5wm4khv6";
-       revision = "1";
-       editedCabalFile = "1l6wbzx8804pb6p8gvk45hal6sz8r1gvyxb8aa9ih6j8pqv4q04c";
-       libraryHaskellDepends = [
-         base base-orphans comonad containers data-fix free template-haskell
-         th-abstraction transformers
-       ];
-       testHaskellDepends = [ base HUnit template-haskell transformers ];
-       description = "Representing common recursion patterns as higher-order functions";
-       license = lib.licenses.bsd2;
-     }) {};
-
-  "recursion-schemes_5_2_2_3" = callPackage
-    ({ mkDerivation, base, base-orphans, comonad, containers, data-fix
-     , free, HUnit, template-haskell, th-abstraction, transformers
-     }:
-     mkDerivation {
-       pname = "recursion-schemes";
        version = "5.2.2.3";
        sha256 = "04233y5qw7vm0kyh4h44zpfk2zsd6kz9081ngvi098y0xiphrwm9";
        libraryHaskellDepends = [
···
        testHaskellDepends = [ base HUnit template-haskell transformers ];
        description = "Representing common recursion patterns as higher-order functions";
        license = lib.licenses.bsd2;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "recursion-schemes-ext" = callPackage
···
        ];
        description = "Perform fft with repa via FFTW";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "repa-flow" = callPackage
···
        ];
        description = "A library for process pools coupled with asynchronous message queues";
        license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "rio-process-pool-memleak-test";
      }) {};
 
···
          vector-sized
        ];
        description = "Implementation of the ROC National ID standard";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "roc-id_0_2_0_0" = callPackage
+    ({ mkDerivation, base, hspec, MonadRandom, Only, QuickCheck, text
+     , vector-sized
+     }:
+     mkDerivation {
+       pname = "roc-id";
+       version = "0.2.0.0";
+       sha256 = "1gng9rw9z9zmrkk68q8zf95w3d05yaglk2hp17jvnaw8qxfs3mvp";
+       libraryHaskellDepends = [
+         base MonadRandom Only text vector-sized
+       ];
+       testHaskellDepends = [
+         base hspec MonadRandom Only QuickCheck text vector-sized
+       ];
+       description = "Implementation of the ROC (Taiwan) National ID standard";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        broken = true;
···
      }:
      mkDerivation {
        pname = "servant-openapi3";
-       version = "2.0.1.5";
-       sha256 = "0zcyqga4hbdyk34368108vv9vavzdhv26xphas7yppada2sshfay";
-       revision = "3";
-       editedCabalFile = "0xvs5a9zsg32iziznvvjhfji577xmza419xk0cy1hwamw17f43mi";
-       setupHaskellDepends = [ base Cabal cabal-doctest ];
-       libraryHaskellDepends = [
-         aeson aeson-pretty base base-compat bytestring hspec http-media
-         insert-ordered-containers lens openapi3 QuickCheck servant
-         singleton-bool text unordered-containers
-       ];
-       testHaskellDepends = [
-         aeson base base-compat directory doctest filepath hspec lens
-         lens-aeson openapi3 QuickCheck servant template-haskell text time
-         utf8-string vector
-       ];
-       testToolDepends = [ hspec-discover ];
-       description = "Generate a Swagger/OpenAPI/OAS 3.0 specification for your servant API.";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "servant-openapi3_2_0_1_6" = callPackage
-    ({ mkDerivation, aeson, aeson-pretty, base, base-compat, bytestring
-     , Cabal, cabal-doctest, directory, doctest, filepath, hspec
-     , hspec-discover, http-media, insert-ordered-containers, lens
-     , lens-aeson, openapi3, QuickCheck, servant, singleton-bool
-     , template-haskell, text, time, unordered-containers, utf8-string
-     , vector
-     }:
-     mkDerivation {
-       pname = "servant-openapi3";
        version = "2.0.1.6";
        sha256 = "1hxz3n6l5l8p9s58sjilrn4lv1z17kfik0xdh05v5v1bzf0j2aij";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
···
        testToolDepends = [ hspec-discover ];
        description = "Servant servers utilities";
        license = lib.licenses.mpl20;
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "servant-util-examples";
      }) {};
 
···
        testToolDepends = [ hspec-discover ];
        description = "Implementation of servant-util primitives for beam-postgres";
        license = lib.licenses.mpl20;
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "servant-util-beam-pg-examples";
      }) {};
 
···
   "skylighting" = callPackage
     ({ mkDerivation, base, binary, blaze-html, bytestring, containers
      , pretty-show, skylighting-core, skylighting-format-ansi
-     , skylighting-format-blaze-html, skylighting-format-latex, text
-     }:
-     mkDerivation {
-       pname = "skylighting";
-       version = "0.13.1.2";
-       sha256 = "05m11hd6xr4kh6jgdj4mgwa7nbrj29jzca76pjpm0mjiqv3ah3av";
-       configureFlags = [ "-fexecutable" ];
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         base binary containers skylighting-core skylighting-format-ansi
-         skylighting-format-blaze-html skylighting-format-latex
-       ];
-       executableHaskellDepends = [
-         base blaze-html bytestring containers pretty-show text
-       ];
-       description = "syntax highlighting library";
-       license = lib.licenses.gpl2Only;
-       mainProgram = "skylighting";
-     }) {};
-
-  "skylighting_0_13_2" = callPackage
-    ({ mkDerivation, base, binary, blaze-html, bytestring, containers
-     , pretty-show, skylighting-core, skylighting-format-ansi
      , skylighting-format-blaze-html, skylighting-format-context
      , skylighting-format-latex, text
      }:
···
        ];
        description = "syntax highlighting library";
        license = lib.licenses.gpl2Only;
-       hydraPlatforms = lib.platforms.none;
        mainProgram = "skylighting";
      }) {};
 
···
      }:
      mkDerivation {
        pname = "skylighting-core";
-       version = "0.13.1.2";
-       sha256 = "0081zihpiq4w99x4s5bhf0r2j627dzmlnmpca5rq16mqvhz22mmz";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         aeson attoparsec base base64-bytestring binary bytestring
-         case-insensitive colour containers directory filepath mtl safe text
-         transformers utf8-string xml-conduit
-       ];
-       testHaskellDepends = [
-         aeson base bytestring containers Diff directory filepath
-         pretty-show QuickCheck tasty tasty-golden tasty-hunit
-         tasty-quickcheck text
-       ];
-       benchmarkHaskellDepends = [
-         base containers criterion filepath text
-       ];
-       description = "syntax highlighting library";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "skylighting-core_0_13_2" = callPackage
-    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring, binary
-     , bytestring, case-insensitive, colour, containers, criterion, Diff
-     , directory, filepath, mtl, pretty-show, QuickCheck, safe, tasty
-     , tasty-golden, tasty-hunit, tasty-quickcheck, text, transformers
-     , utf8-string, xml-conduit
-     }:
-     mkDerivation {
-       pname = "skylighting-core";
        version = "0.13.2";
        sha256 = "0iwzfgynj3l8rnvvrl4kg0i1n31rz15da8cf1943gw1vcfh6w585";
        isLibrary = true;
···
        ];
        description = "syntax highlighting library";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "skylighting-extensions" = callPackage
···
        ];
        description = "A checksummed variation on Twitter's Snowflake UID generation algorithm";
        license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "snowflake" = callPackage
···
     ({ mkDerivation, base, deepseq }:
      mkDerivation {
        pname = "some";
-       version = "1.0.3";
-       sha256 = "0w3syapwz9v916zf1i4f8vxymdfg7syc2cpxgnqr018pbswzxrk2";
-       revision = "2";
-       editedCabalFile = "1w3snkgqhrgi2x2bdny9i7a9ybmal3asrh6g6kg8v86kq1gyr34k";
-       libraryHaskellDepends = [ base deepseq ];
-       testHaskellDepends = [ base ];
-       description = "Existential type: Some";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "some_1_0_4_1" = callPackage
-    ({ mkDerivation, base, deepseq }:
-     mkDerivation {
-       pname = "some";
        version = "1.0.4.1";
        sha256 = "1qy840b2f58f0jxmw4q9sfgbx64kypzdlqnwc72md5wwv84b9b1d";
        libraryHaskellDepends = [ base deepseq ];
        testHaskellDepends = [ base ];
        description = "Existential type: Some";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "some-dict-of" = callPackage
···
        testHaskellDepends = [ base hspec mtl stm stm-queue ];
        description = "A simplistic actor model based on STM";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "stm-channelize" = callPackage
···
        ];
        description = "An implementation of a real-time concurrent queue";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "stm-queue-extras" = callPackage
···
        pname = "store-core";
        version = "0.4.4.4";
        sha256 = "0h21wp51phbwk9ajblqaqzx1hk9c58gkihmycjn0hj299kxly80y";
+       revision = "1";
+       editedCabalFile = "04jv0y5k9iscw8ac72rbycmcscadnjsv2rjgwj6x0r2bymvdq00g";
        libraryHaskellDepends = [
          base bytestring ghc-prim primitive text transformers
        ];
···
      }:
      mkDerivation {
        pname = "string-interpolate";
-       version = "0.3.1.2";
-       sha256 = "0gmph9mikqq8hch9wjyyx6dxfxwhmdfrwsrxkvbk7i24lvi19hhp";
-       revision = "1";
-       editedCabalFile = "1nrpng7r59a25z4qns8vy26rvp1wgn5f4bs8ism40q66ags8f2ad";
-       libraryHaskellDepends = [
-         base bytestring haskell-src-exts haskell-src-meta split
-         template-haskell text text-conversions utf8-string
-       ];
-       testHaskellDepends = [
-         base bytestring hspec hspec-core QuickCheck quickcheck-instances
-         quickcheck-text quickcheck-unicode template-haskell text
-         unordered-containers
-       ];
-       benchmarkHaskellDepends = [
-         base bytestring criterion deepseq formatting interpolate
-         neat-interpolation QuickCheck text
-       ];
-       description = "Haskell string/text/bytestring interpolation that just works";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "string-interpolate_0_3_2_0" = callPackage
-    ({ mkDerivation, base, bytestring, criterion, deepseq, formatting
-     , haskell-src-exts, haskell-src-meta, hspec, hspec-core
-     , interpolate, neat-interpolation, QuickCheck, quickcheck-instances
-     , quickcheck-text, quickcheck-unicode, split, template-haskell
-     , text, text-conversions, unordered-containers, utf8-string
-     }:
-     mkDerivation {
-       pname = "string-interpolate";
        version = "0.3.2.0";
        sha256 = "1sdd472rvykrqkv76745vavpycvb0dzcaxs3yw9dfczaxaz16xws";
        libraryHaskellDepends = [
···
        ];
        description = "Haskell string/text/bytestring interpolation that just works";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "string-interpreter" = callPackage
···
      }) {};
 
   "tasty" = callPackage
-    ({ mkDerivation, ansi-terminal, base, clock, containers
-     , optparse-applicative, stm, tagged, transformers, unbounded-delays
-     , unix, wcwidth
-     }:
-     mkDerivation {
-       pname = "tasty";
-       version = "1.4.2.3";
-       sha256 = "1inhrayiqhd3k14b9cnjcv5kdxb95sgk8b0ibbf37z4dlalsf569";
-       libraryHaskellDepends = [
-         ansi-terminal base clock containers optparse-applicative stm tagged
-         transformers unbounded-delays unix wcwidth
-       ];
-       description = "Modern and extensible testing framework";
-       license = lib.licenses.mit;
-     }) {};
-
-  "tasty_1_4_3" = callPackage
     ({ mkDerivation, ansi-terminal, base, containers
      , optparse-applicative, stm, tagged, transformers, unix
      }:
···
        ];
        description = "Modern and extensible testing framework";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "tasty-ant-xml" = callPackage
···
      }:
      mkDerivation {
        pname = "telegram-bot-simple";
-       version = "0.6";
-       sha256 = "1f4nfh32v5l60p2bqifg5dl311p86lis51na7hri074w0p3kg6ki";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         aeson aeson-pretty base bytestring cron filepath hashable
-         http-api-data http-client http-client-tls monad-control mtl
-         pretty-show profunctors servant servant-client
-         servant-multipart-api servant-multipart-client servant-server split
-         stm template-haskell text time transformers unordered-containers
-         warp warp-tls
-       ];
-       description = "Easy to use library for building Telegram bots";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "telegram-bot-simple_0_6_1" = callPackage
-    ({ mkDerivation, aeson, aeson-pretty, base, bytestring, cron
-     , filepath, hashable, http-api-data, http-client, http-client-tls
-     , monad-control, mtl, pretty-show, profunctors, servant
-     , servant-client, servant-multipart-api, servant-multipart-client
-     , servant-server, split, stm, template-haskell, text, time
-     , transformers, unordered-containers, warp, warp-tls
-     }:
-     mkDerivation {
-       pname = "telegram-bot-simple";
        version = "0.6.1";
        sha256 = "01rxkgzfvqxgnxlcw70rhs84ygvccydlki827f3icqwfpm7cn6vn";
        isLibrary = true;
···
        ];
        description = "Easy to use library for building Telegram bots";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "telegram-raw-api" = callPackage
···
      }:
      mkDerivation {
        pname = "text-builder-dev";
-       version = "0.3.3";
-       sha256 = "0h88yxj0w7ycpmzxyxnxkrz05dmi902dv9v8mxlx7nrr8idxss74";
-       libraryHaskellDepends = [
-         base bytestring deferred-folds isomorphism-class split text
-         transformers
-       ];
-       testHaskellDepends = [
-         QuickCheck quickcheck-instances rerebase tasty tasty-hunit
-         tasty-quickcheck
-       ];
-       benchmarkHaskellDepends = [ criterion rerebase ];
-       description = "Edge of developments for \"text-builder\"";
-       license = lib.licenses.mit;
-     }) {};
-
-  "text-builder-dev_0_3_3_2" = callPackage
-    ({ mkDerivation, base, bytestring, criterion, deferred-folds
-     , isomorphism-class, QuickCheck, quickcheck-instances, rerebase
-     , split, tasty, tasty-hunit, tasty-quickcheck, text, transformers
-     }:
-     mkDerivation {
-       pname = "text-builder-dev";
        version = "0.3.3.2";
        sha256 = "1bsm4yl22mpzggcnh908ccw9mvg3prckydwxxqa4rfj4k8hy4x7m";
        libraryHaskellDepends = [
···
        benchmarkHaskellDepends = [ criterion rerebase ];
        description = "Edge of developments for \"text-builder\"";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "text-builder-linear" = callPackage
···
      }) {};
 
   "text-show-instances" = callPackage
-    ({ mkDerivation, base, base-compat-batteries, bifunctors, binary
+    ({ mkDerivation, aeson, base, base-compat, bifunctors, binary
      , containers, directory, generic-deriving, ghc-boot-th, ghc-prim
      , haskeline, hpc, hspec, hspec-discover, old-locale, old-time
      , pretty, QuickCheck, quickcheck-instances, random, scientific
···
      }:
      mkDerivation {
        pname = "text-show-instances";
-       version = "3.9.2";
-       sha256 = "1j1mcmw9l7hfmvhmv083bssc2w6zbvibaq3w4c7g7a2vxxcqwh3y";
+       version = "3.9.3";
+       sha256 = "153hfl8k0489ll71apq48s59ngv8ag1vyhhs6pp3fgxmdwwg2xpl";
        libraryHaskellDepends = [
-         base base-compat-batteries bifunctors binary containers directory
+         aeson base base-compat bifunctors binary containers directory
          ghc-boot-th haskeline hpc old-locale old-time pretty random
          scientific semigroups tagged template-haskell terminfo text
-         text-short text-show time transformers transformers-compat unix
-         unordered-containers uuid-types vector xhtml
+         text-short text-show time transformers unix unordered-containers
+         uuid-types vector xhtml
        ];
        testHaskellDepends = [
-         base base-compat-batteries bifunctors binary containers directory
+         aeson base base-compat bifunctors binary containers directory
          generic-deriving ghc-boot-th ghc-prim haskeline hpc hspec
          old-locale old-time pretty QuickCheck quickcheck-instances random
          scientific tagged template-haskell terminfo text-short text-show
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "text-show-instances_3_9_3" = callPackage
+  "text-show-instances_3_9_4" = callPackage
     ({ mkDerivation, aeson, base, base-compat, bifunctors, binary
      , containers, directory, generic-deriving, ghc-boot-th, ghc-prim
      , haskeline, hpc, hspec, hspec-discover, old-locale, old-time
···
      }:
      mkDerivation {
        pname = "text-show-instances";
-       version = "3.9.3";
-       sha256 = "153hfl8k0489ll71apq48s59ngv8ag1vyhhs6pp3fgxmdwwg2xpl";
+       version = "3.9.4";
+       sha256 = "154smhpc3l2h1iacdsywzirkv19w493yajhsiqg9pqmmiii7kwr5";
        libraryHaskellDepends = [
          aeson base base-compat bifunctors binary containers directory
          ghc-boot-th haskeline hpc old-locale old-time pretty random
···
        testHaskellDepends = [ base containers template-haskell time ];
        description = "Template Haskell hack to violate module abstractions";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "truelevel" = callPackage
···
        ];
        description = "Fast and robust message queues for concurrent processes";
        license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "unliftio-messagebox-memleak-test";
+       broken = true;
      }) {};
 
   "unliftio-path" = callPackage
···
     ({ mkDerivation, base, stm }:
      mkDerivation {
        pname = "var-monad";
-       version = "0.2.0.0";
-       sha256 = "12l536ca32dhvylp3kizq664lsfysmc5r0hqzs50aqrbx8db40ji";
+       version = "0.2.0.1";
+       sha256 = "1k1v503ww56chlxy9a9vh3w5rh047l3q97si1bi3x1575b1sppm2";
        libraryHaskellDepends = [ base stm ];
        description = "The VarMonad typeclass, generalizing types of references";
        license = lib.licenses.asl20;
···
      }:
      mkDerivation {
        pname = "vector-extras";
-       version = "0.2.7.1";
-       sha256 = "1a8aak9v68qmrx719w782ww7accn7bk11gnca3d2lvbzw793dl4q";
-       libraryHaskellDepends = [
-         base containers deferred-folds foldl hashable unordered-containers
-         vector
-       ];
-       description = "Utilities for the \"vector\" library";
-       license = lib.licenses.mit;
-     }) {};
-
-  "vector-extras_0_2_8" = callPackage
-    ({ mkDerivation, base, containers, deferred-folds, foldl, hashable
-     , unordered-containers, vector
-     }:
-     mkDerivation {
-       pname = "vector-extras";
        version = "0.2.8";
        sha256 = "1xnz733p9p66693hb31fmq2cfsy2rwyw1b0915p7y5my1d8dxyzi";
        libraryHaskellDepends = [
···
        ];
        description = "Utilities for the \"vector\" library";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "vector-fft" = callPackage
···
        pname = "vector-sized";
        version = "1.5.0";
        sha256 = "13h4qck1697iswd9f8w17fpjc6yhl2pgrvay7pb22j2h3mgaxpjl";
+       revision = "1";
+       editedCabalFile = "0y088b8fdhjrghi203n11ip4x2j4632c8rz6a5hx8azmdz2giiph";
        libraryHaskellDepends = [
          adjunctions base binary comonad deepseq distributive
          finite-typelits hashable indexed-list-literals primitive vector
···
        pname = "vty";
        version = "5.35.1";
        sha256 = "062dpz8fxrnggzpl041zpbph0xj56jki98ajm2s78dldg5vy0c9k";
+       revision = "1";
+       editedCabalFile = "1zqcvgqhcij92241g20zn3c3a4033biid3f3cqg05q1ygrmznxb5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        description = "Composable, type-safe library to build HTTP API servers";
        license = lib.licenses.mpl20;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "webgear-server" = callPackage
···
      }:
      mkDerivation {
        pname = "wide-word";
-       version = "0.1.3.0";
-       sha256 = "03g0v5zp3ra2z31vyjkhgd23s2dyaks640y2imkv649fcvvz33xj";
-       revision = "1";
-       editedCabalFile = "1y1w3ih92dni6bzp4w1hcwn96ahdrk34lmqrgkri2dcdkykwyqwb";
-       libraryHaskellDepends = [
-         base deepseq ghc-prim hashable primitive
-       ];
-       testHaskellDepends = [
-         base bytestring ghc-prim hedgehog primitive QuickCheck
-         quickcheck-classes semirings
-       ];
-       description = "Data types for large but fixed width signed and unsigned integers";
-       license = lib.licenses.bsd2;
-     }) {};
-
-  "wide-word_0_1_4_0" = callPackage
-    ({ mkDerivation, base, bytestring, deepseq, ghc-prim, hashable
-     , hedgehog, primitive, QuickCheck, quickcheck-classes, semirings
-     }:
-     mkDerivation {
-       pname = "wide-word";
        version = "0.1.4.0";
        sha256 = "1jajlkcbymf0jqmcbn46x3yxqxjslzdcnp1v582jjpa2glibsnf0";
        libraryHaskellDepends = [
···
        ];
        description = "Data types for large but fixed width signed and unsigned integers";
        license = lib.licenses.bsd2;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "wide-word-instances" = callPackage

pkgs/development/haskell-modules/patches/hevm-update-deps.patch

···
-diff --git a/hevm.cabal b/hevm.cabal
-index cf36961e..3b31f595 100644
---- a/hevm.cabal
-+++ b/hevm.cabal
-@@ -71,6 +71,10 @@ library
-     -Wall -Wno-deprecations
-   extra-libraries:
-     secp256k1, ff
-+  if os(darwin)
-+     extra-libraries: c++
-+  else
-+     extra-libraries: stdc++
-   c-sources:
-     ethjet/tinykeccak.c, ethjet/ethjet.c
-   cxx-sources:
-@@ -88,7 +92,7 @@ library
-     transformers                      >= 0.5.6 && < 0.6,
-     tree-view                         >= 0.5 && < 0.6,
-     abstract-par                      >= 0.3.3 && < 0.4,
--    aeson                             >= 1.5.6 && < 1.6,
-+    aeson                             >= 2.0 && < 2.1,
-     bytestring                        >= 0.10.8 && < 0.11,
-     scientific                        >= 0.3.6 && < 0.4,
-     binary                            >= 0.8.6 && < 0.9,
-@@ -97,7 +101,7 @@ library
-     vector                            >= 0.12.1 && < 0.13,
-     ansi-wl-pprint                    >= 0.6.9 && < 0.7,
-     base16-bytestring                 >= 1.0.0 && < 2.0,
--    brick                             >= 0.58 && < 0.63,
-+    brick                             >= 0.58 && < 0.69,
-     megaparsec                        >= 9.0.0 && < 10.0,
-     mtl                               >= 2.2.2 && < 2.3,
-     directory                         >= 1.3.3 && < 1.4,
-@@ -105,13 +109,13 @@ library
-     vty                               >= 5.25.1 && < 5.34,
-     cereal                            >= 0.5.8 && < 0.6,
-     cryptonite                        >= 0.27 && <= 0.29,
--    memory                            >= 0.14.18 && < 0.16,
-+    memory                            >= 0.14.18 && < 0.20,
-     data-dword                        >= 0.3.1 && < 0.4,
-     fgl                               >= 5.7.0 && < 5.8,
-     free                              >= 5.1.3 && < 5.2,
-     haskeline                         >= 0.8.0 && < 0.9,
-     process                           >= 1.6.5 && < 1.7,
--    lens                              >= 4.17.1 && < 4.20,
-+    lens                              >= 4.17.1 && < 5.1,
-     lens-aeson                        >= 1.0.2 && < 1.2,
-     monad-par                         >= 0.3.5 && < 0.4,
-     multiset                          >= 0.3.4 && < 0.4,
-@@ -124,7 +128,6 @@ library
-     sbv                               >= 8.9,
-     semver-range                      >= 0.2.7 && < 0.3,
-     temporary                         >= 1.3 && < 1.4,
--    text-format                       >= 0.3.2 && < 0.4,
-     witherable                        >= 0.3.5 && < 0.5,
-     wreq                              >= 0.5.3 && < 0.6,
-     regex-tdfa                        >= 1.2.3 && < 1.4,
-@@ -190,7 +193,6 @@ executable hevm
-     sbv,
-     temporary,
-     text,
--    text-format,
-     unordered-containers,
-     vector,
-     vty
-diff --git a/src/EVM/Solidity.hs b/src/EVM/Solidity.hs
-index b7d0f36b..4e9d6892 100644
---- a/src/EVM/Solidity.hs
-+++ b/src/EVM/Solidity.hs
-@@ -70,6 +70,7 @@ import Control.Monad
- import Control.Lens         hiding (Indexed, (.=))
- import qualified Data.String.Here as Here
- import Data.Aeson hiding (json)
-+import qualified Data.Aeson.KeyMap as KeyMap
- import Data.Aeson.Types
- import Data.Aeson.Lens
- import Data.Scientific
-@@ -714,8 +715,8 @@ astIdMap = foldMap f
-     f :: Value -> Map Int Value
-     f (Array x) = foldMap f x
-     f v@(Object x) =
--      let t = foldMap f (HMap.elems x)
--      in case HMap.lookup "id" x of
-+      let t = foldMap f (KeyMap.elems x)
-+      in case KeyMap.lookup "id" x of
-         Nothing         -> t
-         Just (Number i) -> t <> Map.singleton (round i) v
-         Just _          -> t
-diff --git a/src/EVM/SymExec.hs b/src/EVM/SymExec.hs
-index 5bbf1c03..b828098e 100644
---- a/src/EVM/SymExec.hs
-+++ b/src/EVM/SymExec.hs
-@@ -40,8 +40,8 @@ type EquivalenceResult = ProofResult ([VM], [VM]) VM ()
-
- -- | Convenience functions for generating large symbolic byte strings
- sbytes32, sbytes128, sbytes256, sbytes512, sbytes1024 :: Query ([SWord 8])
--sbytes32 = toBytes <$> freshVar_ @ (WordN 256)
--sbytes128 = toBytes <$> freshVar_ @ (WordN 1024)
-+sbytes32 = toBytes <$> freshVar_ @(WordN 256)
-+sbytes128 = toBytes <$> freshVar_ @(WordN 1024)
- sbytes256 = liftA2 (++) sbytes128 sbytes128
- sbytes512 = liftA2 (++) sbytes256 sbytes256
- sbytes1024 = liftA2 (++) sbytes512 sbytes512
-diff --git a/src/EVM/Types.hs b/src/EVM/Types.hs
-index fdd2368d..1dc29e83 100644
---- a/src/EVM/Types.hs
-+++ b/src/EVM/Types.hs
-@@ -434,17 +434,17 @@ readN s = fromIntegral (read s :: Integer)
- readNull :: Read a => a -> String -> a
- readNull x = fromMaybe x . Text.Read.readMaybe
-
--wordField :: JSON.Object -> Text -> JSON.Parser W256
-+wordField :: JSON.Object -> Key -> JSON.Parser W256
- wordField x f = ((readNull 0) . Text.unpack)
-                   <$> (x .: f)
-
--addrField :: JSON.Object -> Text -> JSON.Parser Addr
-+addrField :: JSON.Object -> Key -> JSON.Parser Addr
- addrField x f = (read . Text.unpack) <$> (x .: f)
-
--addrFieldMaybe :: JSON.Object -> Text -> JSON.Parser (Maybe Addr)
-+addrFieldMaybe :: JSON.Object -> Key -> JSON.Parser (Maybe Addr)
- addrFieldMaybe x f = (Text.Read.readMaybe . Text.unpack) <$> (x .: f)
-
--dataField :: JSON.Object -> Text -> JSON.Parser ByteString
-+dataField :: JSON.Object -> Key -> JSON.Parser ByteString
- dataField x f = hexText <$> (x .: f)
-
- toWord512 :: W256 -> Word512

pkgs/development/haskell-modules/patches/recursion-schemes-128.patch

···
-diff --git a/recursion-schemes.cabal b/recursion-schemes.cabal
-index c35f2c6..e692ade 100644
---- a/recursion-schemes.cabal
-+++ b/recursion-schemes.cabal
-@@ -93,6 +93,7 @@ library
-       Paths_recursion_schemes
- 
-   ghc-options: -Wall
-+  ghc-prof-options: -DPROFILING_ENABLED
-   if impl(ghc >= 8.6)
-     ghc-options: -Wno-star-is-type
-   default-language: Haskell2010
-diff --git a/src/Data/Functor/Foldable/TH.hs b/src/Data/Functor/Foldable/TH.hs
-index b3d5ac8..d4ef0e4 100644
---- a/src/Data/Functor/Foldable/TH.hs
-+++ b/src/Data/Functor/Foldable/TH.hs
-@@ -1,4 +1,7 @@
- {-# LANGUAGE CPP, PatternGuards, Rank2Types #-}
-+#if defined(PROFILING_ENABLED)
-+{-# OPTIONS_GHC -O0 #-}
-+#endif
- module Data.Functor.Foldable.TH
-   ( MakeBaseFunctor(..)
-   , BaseRules

pkgs/development/libraries/libbluray/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "libbluray";
-  version = "1.3.2";
+  version = "1.3.4";
 
   src = fetchurl {
     url = "https://get.videolan.org/libbluray/${version}/${pname}-${version}.tar.bz2";
-    sha256 = "sha256-RWgU258Hwe7N736ED8uyCXbvgU34dUKL+4Hs9FhR8XA=";
+    hash = "sha256-R4/9aKD13ejvbKmJt/A1taCiLFmRQuXNP/ewO76+Xys=";
   };
-
-  patches = [
-    ./BDJ-JARFILE-path.patch
-    (fetchpatch {
-      name = "Initial-support-for-Java-18.patch";
-      url = "https://code.videolan.org/videolan/libbluray/-/commit/3187c3080096e107f0a27eed1843232b58342577.patch";
-      hash = "sha256-2TSciAoPzELkgmFGB38h1RgynOCJueyCL8hIADxAPHo=";
-    })
-    (fetchpatch {
-      name = "bd-j-BDJSecurityManager-Change-setSecurityManager-de.patch";
-      url = "https://code.videolan.org/videolan/libbluray/-/commit/9a2d23d049760ef9cc9661ff90011a84d90368f1.patch";
-      hash = "sha256-xCc2h5ocXCqnpVMPQaybT2Ncs2YOzifQ0mlCCUhYlc8=";
-    })
-  ];
 
   nativeBuildInputs = [ pkg-config autoreconfHook ]
     ++ lib.optionals withJava [ ant ];

pkgs/development/python-modules/ansible-lint/default.nix

···
 
 buildPythonPackage rec {
   pname = "ansible-lint";
-  version = "6.10.0";
+  version = "6.10.1";
   format = "pyproject";
+
   disabled = pythonOlder "3.8";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "sha256-9ezsWOvntr/El2vn1uQAQRqK8FsOGhnxXyX1nzQBNIw=";
+    hash = "sha256-JPFbYa9SvCKwXQCPnrdmLxz0KrdACNqfia9x/FQMz6Q=";
   };
 
   postPatch = ''
···
     "test_run_inside_role_dir"
     "test_run_multiple_role_path_no_trailing_slash"
     "test_runner_exclude_globs"
-
     "test_discover_lintables_umlaut"
   ];
 
   makeWrapperArgs = [ "--prefix PATH : ${lib.makeBinPath [ ansible-core ]}" ];
 
   meta = with lib; {
+    description = "Best practices checker for Ansible";
     homepage = "https://github.com/ansible/ansible-lint";
-    description = "Best practices checker for Ansible";
+    changelog = "https://github.com/ansible/ansible-lint/releases/tag/v${version}";
     license = licenses.mit;
     maintainers = with maintainers; [ sengaya ];
   };

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

···
 
   disabled = pythonOlder "3.6";
 
+  __darwinAllowLocalNetworking = true;
+
   src = fetchFromGitHub {
     owner = "ionrock";
     repo = pname;

pkgs/development/python-modules/ghrepo-stats/default.nix

···
 { lib
+, beautifulsoup4
 , buildPythonPackage
 , fetchFromGitHub
 , matplotlib
···
 
 buildPythonPackage rec {
   pname = "ghrepo-stats";
-  version = "0.4.0";
+  version = "0.5.0";
   format = "setuptools";
 
   disabled = pythonOlder "3.8";
···
     owner = "mrbean-bremen";
     repo = pname;
     rev = "v${version}";
-    hash = "sha256-KFjqHrN0prcqu3wEPZpa7rLfuD0X/DN7BMo4zcHNmYo=";
+    hash = "sha256-rTW6wADpkP9GglNmQNVecHfA2yJZuzYhJfsLfucbcgY=";
   };
 
+  postPatch = ''
+    # https://github.com/mrbean-bremen/ghrepo-stats/pull/1
+    substituteInPlace setup.py \
+      --replace "bs4" "beautifulsoup4"
+  '';
+
   propagatedBuildInputs = [
+    beautifulsoup4
     matplotlib
     PyGithub
   ];

pkgs/development/python-modules/meross-iot/default.nix

···
 
 buildPythonPackage rec {
   pname = "meross-iot";
-  version = "0.4.5.2";
+  version = "0.4.5.4";
   format = "setuptools";
 
   disabled = pythonOlder "3.7";
···
     owner = "albertogeniola";
     repo = "MerossIot";
     rev = "refs/tags/${version}";
-    hash = "sha256-gT4HxdmyX7oOQFBo1frkmmoXrNfGOcqL0hPZ40kRZeo=";
+    hash = "sha256-HPA3oeanFHx+g0nt/nsTzG3RTCdsjNSvDCXILR271P4=";
   };
 
   propagatedBuildInputs = [

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

···
 
 buildPythonPackage rec {
   pname = "pypck";
-  version = "0.7.15";
+  version = "0.7.16";
   format = "setuptools";
 
   disabled = pythonOlder "3.8";
···
   src = fetchFromGitHub {
     owner = "alengwenus";
     repo = pname;
-    rev = version;
-    hash = "sha256-OuM/r9rxIl4niY87cEcbZ73x2ZIQbaPZqbMrQ7hZE/g=";
+    rev = "refs/tags/${version}";
+    hash = "sha256-OcXMVgG62JUH28BGvfO/rpnC++/klhBLJ2HafDu9R40=";
   };
 
   checkInputs = [
···
   meta = with lib; {
     description = "LCN-PCK library written in Python";
     homepage = "https://github.com/alengwenus/pypck";
+    changelog = "https://github.com/alengwenus/pypck/releases/tag/${version}";
     license = with licenses; [ epl20 ];
     maintainers = with maintainers; [ fab ];
   };

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

···
 
 buildPythonPackage rec {
   pname = "python-fsutil";
-  version = "0.8.0";
+  version = "0.9.1";
   format = "setuptools";
 
   disabled = pythonOlder "3.7";
···
     owner = "fabiocaccamo";
     repo = pname;
     rev = "refs/tags/${version}";
-    hash = "sha256-J5B5THfB/yPG1JSCpO2HTHTH0jn0nbKFzXpZMGJ/dKA=";
+    hash = "sha256-rMQjsGqdiXe8zS18hZQAro3UWyHPjNJYyQ/NAoxbE7k=";
   };
 
   propagatedBuildInputs = [

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

···
 
 buildPythonPackage rec {
   pname = "python-ipmi";
-  version = "0.5.2";
+  version = "0.5.3";
   disabled = pythonOlder "3.6";
 
   src = fetchFromGitHub {
     owner = "kontron";
     repo = pname;
     rev = version;
-    sha256 = "sha256-VXWSoVRfgJWf9rOT4SE1mTJdeNmzR3TRc2pc6Pp1M5U=";
+    sha256 = "sha256-Y8HJ7MXYHJRUWPTcw8p+GGSFswuRI7u+/bIaJpKy7lY=";
   };
 
   propagatedBuildInputs = [

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

···
 
 buildPythonPackage rec {
   pname = "roonapi";
-  version = "0.1.2";
+  version = "0.1.3";
   format = "pyproject";
 
   disabled = pythonOlder "3.7";
···
     owner = "pavoni";
     repo = "pyroon";
     rev = version;
-    hash = "sha256-HcHs9UhRbSKTxW5qEvmMrQ+kWIBAqVpyldapx635uNM=";
+    hash = "sha256-QOFBNTz8g3f6C8Vjkblrd3QFCRrA1WqOCv6xS4GbFC4=";
   };
 
   nativeBuildInputs = [

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

···
 
 buildPythonPackage rec {
   pname = "skodaconnect";
-  version = "1.2.5";
+  version = "1.3.0";
   format = "setuptools";
 
   disabled = pythonOlder "3.8";
···
     owner = "lendy007";
     repo = pname;
     rev = "refs/tags/${version}";
-    hash = "sha256-Re6ECMaDmg007XHw9Kpa46+oEs+01CzOZzszKzKS4WA=";
+    hash = "sha256-1x1TQNhKL3RgoeYSB8l607mHt0VrHwOU1CFemoaTCt8=";
   };
 
   SETUPTOOLS_SCM_PRETEND_VERSION = version;

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

···
 
 buildPythonPackage rec {
   pname = "socialscan";
-  version = "1.4.2";
+  version = "2.0.0";
   format = "setuptools";
 
   disabled = pythonOlder "3.8";
···
   src = fetchFromGitHub {
     owner = "iojw";
     repo = pname;
-    rev = "v${version}";
-    sha256 = "rT+/j6UqDOzuNBdN3I74YIxS6qkhd7BjHCGX+gGjprc=";
+    rev = "refs/tags/v${version}";
+    sha256 = "sha256-jiyTcpJ00DvfweChawj1ugdCVHHAdwDbHEp9jivH7gs=";
   };
 
   propagatedBuildInputs = [
···
   meta = with lib; {
     description = "Python library and CLI for accurately querying username and email usage on online platforms";
     homepage = "https://github.com/iojw/socialscan";
+    changelog = "https://github.com/iojw/socialscan/releases/tag/v${version}";
     license = with licenses; [ mpl20 ];
     maintainers = with maintainers; [ fab ];
   };

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

···
 , fetchPypi
 , yt-dlp
 , docopt
-, isPy27
+, pythonOlder
+, urllib3
 }:
 
 buildPythonPackage rec {
   pname = "tubeup";
-  version = "0.0.34";
+  version = "0.0.35";
   format = "setuptools";
 
-  disabled = isPy27;
+  disabled = pythonOlder "3.7";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "ae1e606b243fd70742f8b5871c497628d258ee9f416caa46544aca9a5fbfbca0";
+    sha256 = "006aea68bb8d967a7427c58ee7862e3f2481dae667c2bbcfb1a1f2fd80e665d1";
   };
 
   postPatch = ''
     substituteInPlace setup.py \
+      --replace "internetarchive==3.0.2" "internetarchive" \
+      --replace "urllib3==1.26.13" "urllib3" \
       --replace "docopt==0.6.2" "docopt"
   '';
 
-  propagatedBuildInputs = [ internetarchive docopt yt-dlp ];
+  propagatedBuildInputs = [
+    internetarchive
+    docopt
+    urllib3
+    yt-dlp
+  ];
 
-  pythonImportsCheck = [ "tubeup" ];
+  pythonImportsCheck = [
+    "tubeup"
+  ];
 
   # Tests failing upstream
   doCheck = false;
···
   meta = with lib; {
     description = "Youtube (and other video site) to Internet Archive Uploader";
     homepage = "https://github.com/bibanon/tubeup";
+    changelog = "https://github.com/bibanon/tubeup/releases/tag/${version}";
     license = licenses.gpl3Only;
-    maintainers = [ maintainers.marsam ];
+    maintainers = with maintainers; [ marsam ];
   };
 }

pkgs/development/tools/build-managers/tup/default.nix

···
-{ lib, stdenv, fetchFromGitHub, fuse3, macfuse-stubs, pkg-config, pcre }:
+{ lib, stdenv, fetchFromGitHub, fuse3, macfuse-stubs, pkg-config, sqlite, pcre }:
 
 let
   fuse = if stdenv.isDarwin then macfuse-stubs else fuse3;
···
   };
 
   nativeBuildInputs = [ pkg-config ];
-  buildInputs = [ fuse pcre ];
+  buildInputs = [ fuse pcre sqlite ];
 
   patches = [ ./fusermount-setuid.patch ];
 
   configurePhase = ''
     substituteInPlace  src/tup/link.sh --replace '`git describe' '`echo ${version}'
-    substituteInPlace Tuprules.tup --replace 'pcre-config' 'pkg-config libpcre'
+
+    for f in Tupfile Tuprules.tup src/tup/server/Tupfile build.sh; do
+      substituteInPlace "$f" \
+        --replace "pkg-config"  "${stdenv.cc.targetPrefix}pkg-config" \
+        --replace "pcre-config" "${stdenv.cc.targetPrefix}pkg-config libpcre"
+    done
+
+    cat << EOF > tup.config
+    CONFIG_CC=${stdenv.cc.targetPrefix}cc
+    CONFIG_AR=${stdenv.cc.targetPrefix}ar
+    CONFIG_TUP_USE_SYSTEM_SQLITE=y
+    EOF
   '';
 
   # Regular tup builds require fusermount to have suid, which nix cannot

pkgs/development/tools/haskell/vaultenv/default.nix

···
 , parser-combinators
 , retry
 , lib
+, quickcheck-instances
 , text
 , unix
 , unordered-containers
···
 }:
 mkDerivation rec {
   pname = "vaultenv";
-  version = "0.14.0";
+  version = "0.15.1";
 
   src = fetchFromGitHub {
     owner = "channable";
     repo = "vaultenv";
     rev = "v${version}";
-    sha256 = "sha256-sH4iaKQXgwI/WISXzMR7xqh9Dyx61U/gjYn7exgUetI=";
+    sha256 = "sha256-yoYkAypH+HQSVTvd/qKNFkL5krbB5mZw3ec9ojvy+Pw=";
   };
 
   buildTools = [ hpack ];
···
     optparse-applicative
     parser-combinators
     retry
+    quickcheck-instances
     text
     unix
     unordered-containers
···
   description = "Runs processes with secrets from HashiCorp Vault";
   license = lib.licenses.bsd3;
   maintainers = with lib.maintainers; [ lnl7 manveru ];
-
-  # Does not compile on ghc92
-  hydraPlatforms = lib.platforms.none;
-  broken = true;
 }

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

···
 
   # the (optional) BPF feature requires bpftool, libbpf, clang and llvm-strip to be available during build time.
   # Only libbpf should be a runtime dependency.
+  # Note: llvmPackages is explicitly taken from buildPackages instead of relying
+  # on splicing. Splicing will evaluate the adjacent (pkgsHostTarget) llvmPackages
+  # which is sometimes problematic: llvmPackages.clang looks at targetPackages.stdenv.cc
+  # which, in the unfortunate case of pkgsCross.ghcjs, `throw`s. If we explicitly
+  # take buildPackages.llvmPackages, this is no problem because
+  # `buildPackages.targetPackages.stdenv.cc == stdenv.cc` relative to us. Working
+  # around this is important, because systemd is in the dependency closure of
+  # GHC via emscripten and jdk.
 , bpftools
 , libbpf
-, llvmPackages
 
 , withAnalyze ? true
 , withApparmor ? true
···
 , withHostnamed ? true
 , withHwdb ? true
 , withImportd ? !stdenv.hostPlatform.isMusl
-, withLibBPF ? lib.versionAtLeast llvmPackages.clang.version "10.0"
+, withLibBPF ? lib.versionAtLeast buildPackages.llvmPackages.clang.version "10.0"
 , withLocaled ? true
 , withLogind ? true
 , withMachined ? true
···
     ]
     ++ lib.optionals withLibBPF [
       bpftools
-      llvmPackages.clang
-      llvmPackages.libllvm
+      buildPackages.llvmPackages.clang
+      buildPackages.llvmPackages.libllvm
     ]
   ;
 

pkgs/servers/apcupsd/default.nix

···
 { lib, stdenv, fetchurl, pkg-config, systemd, util-linux, coreutils, wall, hostname, man
 , enableCgiScripts ? true, gd
+, nixosTests
 }:
 
 assert enableCgiScripts -> gd != null;
···
                "$file"
     done
   '';
+
+  passthru.tests.smoke = nixosTests.apcupsd;
 
   meta = with lib; {
     description = "Daemon for controlling APC UPSes";

pkgs/servers/home-assistant/component-packages.nix

···
 # Do not edit!
 
 {
-  version = "2022.12.8";
+  version = "2022.12.9";
   components = {
     "3_day_blinds" = ps: with ps; [
     ];

pkgs/servers/home-assistant/default.nix

···
   extraPackagesFile = writeText "home-assistant-packages" (lib.concatMapStringsSep "\n" (pkg: pkg.pname) extraBuildInputs);
 
   # Don't forget to run parse-requirements.py after updating
-  hassVersion = "2022.12.8";
+  hassVersion = "2022.12.9";
 
 in python.pkgs.buildPythonApplication rec {
   pname = "homeassistant";
···
     owner = "home-assistant";
     repo = "core";
     rev = "refs/tags/${version}";
-    hash = "sha256-oJwA0YELlgMbnf1XiLDGlMLrvFaLP7WMv9/0KOI4XDI=";
+    hash = "sha256-tf2H4+79CGTmbKZtJpzYOzAgi90RpSy89hoDNS24m0Q=";
   };
 
   # leave this in, so users don't have to constantly update their downstream patch handling

pkgs/tools/filesystems/gcsfuse/default.nix

···
-{ lib, buildGoModule, fetchFromGitHub }:
+{ lib
+, buildGoModule
+, fetchFromGitHub
+}:
 
 buildGoModule rec {
   pname = "gcsfuse";
-  version = "0.41.9";
+  version = "0.41.10";
 
   src = fetchFromGitHub {
     owner = "googlecloudplatform";
     repo = "gcsfuse";
-    rev = "v${version}";
-    sha256 = "sha256-hfdQa0e1S1cIF4V2XPFBl4jzzTWlIxZIJ99PRxCP55s=";
+    rev = "refs/tags/${version}";
+    hash = "sha256-rtBqXC1CTkbKDP6pzkRQ7GnM5f4xt6eUMW3n9wZu0hc=";
   };
 
   vendorSha256 = null;
 
-  subPackages = [ "." "tools/mount_gcsfuse" ];
+  subPackages = [
+    "."
+    "tools/mount_gcsfuse"
+  ];
 
-  ldflags = [ "-s" "-w" "-X main.gcsfuseVersion=${version}" ];
+  ldflags = [
+    "-s"
+    "-w"
+    "-X main.gcsfuseVersion=${version}"
+  ];
 
   preCheck =
     let skippedTests = [
···
   meta = with lib;{
     description = "A user-space file system for interacting with Google Cloud Storage";
     homepage = "https://cloud.google.com/storage/docs/gcs-fuse";
+    changelog = "https://github.com/GoogleCloudPlatform/gcsfuse/releases/tag/v${version}";
     license = licenses.asl20;
     platforms = platforms.unix;
     maintainers = with maintainers; [ aaronjheng ];

pkgs/tools/misc/broot/default.nix

···
 { lib
 , stdenv
 , rustPlatform
-, fetchCrate
+, fetchFromGitHub
 , installShellFiles
 , makeWrapper
 , pkg-config
···
 
 rustPlatform.buildRustPackage rec {
   pname = "broot";
-  version = "1.18.0";
+  version = "1.19.0";
 
-  src = fetchCrate {
-    inherit pname version;
-    sha256 = "sha256-GR0a5NDJBcRLoNOeG6S+fP3Fr7r5fVB9oEcjANRYJt4=";
+  src = fetchFromGitHub {
+    owner = "Canop";
+    repo = pname;
+    rev = "v${version}";
+    hash = "sha256-pg+eHmClDd04tWljQUS0IRyMzkHnkpkofuhz/KyQbWo=";
   };
 
-  cargoHash = "sha256-Hk9bc1mo8GxcPICKXc9zDq18S5TZElDncxJ+w2fC2do=";
+  cargoHash = "sha256-+RUYC39L7yyh1xYPfZn7tDIf1cmmBuGcqTNibFk7s6M=";
 
   nativeBuildInputs = [
     installShellFiles

pkgs/tools/networking/iwgtk/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "iwgtk";
-  version = "0.8";
+  version = "0.9";
 
   src = fetchFromGitHub {
     owner = "j-lentz";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-89rzDxalZtQkwAKS6hKPVY87kOWPySwDeZrPs2rGs/k=";
+    sha256 = "sha256-/Nxti4PfYVLnIiBgtAuR3KGI8dULszuSdTp+2DzBfbs=";
   };
 
   # patch systemd service to pass necessary environments and use absolute paths
···
   buildInputs = [ gtk4 qrencode ];
 
   postInstall = ''
-    mv $out/share/lib/systemd $out/share
-    rmdir $out/share/lib
-    substituteInPlace $out/share/systemd/user/iwgtk.service --subst-var out
+    substituteInPlace $out/lib/systemd/user/iwgtk.service --subst-var out
   '';
 
   meta = with lib; {

pkgs/tools/networking/nfdump/default.nix

···
-{ lib, stdenv, fetchFromGitHub
-, autoconf, automake, libtool, pkg-config
-, bzip2, libpcap, flex, bison }:
-
-let version = "1.7.0.1"; in
+{ lib
+, stdenv
+, fetchFromGitHub
+, autoconf
+, automake
+, libtool
+, pkg-config
+, bzip2
+, libpcap
+, flex
+, bison
+}:
 
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   pname = "nfdump";
-  inherit version;
+  version = "1.7.1";
 
   src = fetchFromGitHub {
     owner = "phaag";
     repo = "nfdump";
-    rev = "v${version}";
-    sha256 = "sha256-yD/NFGw38ishqQmKhlnHYodXmJuezI09hxNsyObZ1QE=";
+    rev =  "refs/tags/v${version}";
+    hash = "sha256-oCaJPx6+C0NQSuUcsP54sycNLt/zaqe5c81dwHNBcnQ=";
   };
 
-  nativeBuildInputs = [ autoconf automake flex libtool pkg-config bison ];
-  buildInputs = [ bzip2 libpcap ];
+  nativeBuildInputs = [
+    autoconf
+    automake
+    flex
+    libtool
+    pkg-config
+    bison
+  ];
+
+  buildInputs = [
+    bzip2
+    libpcap
+  ];
 
   preConfigure = ''
     # The script defaults to glibtoolize on darwin, so we pass the correct
···
       nfdump is a set of tools for working with netflow data.
     '';
     homepage = "https://github.com/phaag/nfdump";
+    changelog = "https://github.com/phaag/nfdump/releases/tag/v${version}";
     license = licenses.bsd3;
-    maintainers = [ maintainers.takikawa ];
+    maintainers = with maintainers; [ takikawa ];
     platforms = platforms.unix;
   };
 }

pkgs/tools/security/mitmproxy2swagger/default.nix

···
 
 python3.pkgs.buildPythonApplication rec {
   pname = "mitmproxy2swagger";
-  version = "0.7.1";
+  version = "0.7.2";
   format = "pyproject";
 
   src = fetchFromGitHub {
     owner = "alufers";
     repo = pname;
     rev = "refs/tags/${version}";
-    hash = "sha256-morBtuRZZ/d3ye8aB+m2dSwWoaF3JJ92c+CgF71MqH4=";
+    hash = "sha256-LnH0RDiRYJAGI7ZT6Idu1AqSz0yBRuBJvhIgY72Z4CA=";
   };
 
   nativeBuildInputs = with python3.pkgs; [

pkgs/tools/security/trufflehog/default.nix

···
 { lib
-, python3Packages
+, fetchFromGitHub
+, buildGoModule
 }:
 
-let
-  truffleHogRegexes = python3Packages.buildPythonPackage rec {
-    pname = "truffleHogRegexes";
-    version = "0.0.7";
-    src = python3Packages.fetchPypi {
-      inherit pname version;
-      sha256 = "b81dfc60c86c1e353f436a0e201fd88edb72d5a574615a7858485c59edf32405";
-    };
-  };
-in
-  python3Packages.buildPythonApplication rec {
-    pname = "truffleHog";
-    version = "2.2.1";
+buildGoModule rec {
+  pname = "trufflehog";
+  version = "3.21.0";
 
-    src = python3Packages.fetchPypi {
-      inherit pname version;
-      hash = "sha256-fw0JyM2iqQrkL4FAXllEozJdkKWELS3eAURx5NZcceQ=";
-    };
+  src = fetchFromGitHub {
+    owner = "trufflesecurity";
+    repo = "trufflehog";
+    rev = "refs/tags/v${version}";
+    hash = "sha256-rse5uyQ7EUBhs0IyC92B/Z7YCeNIXTlZEqrlcjFekgA=";
+  };
 
-    # Relax overly restricted version constraint
-    postPatch = ''
-      substituteInPlace setup.py --replace "GitPython ==" "GitPython >= "
-    '';
+  vendorHash = "sha256-KyyJ7hUWF29L8oB9GkJ918/BQoLMsz+tStT2T9Azunk=";
 
-    propagatedBuildInputs = [
-      python3Packages.gitpython
-      truffleHogRegexes
-    ];
+  # Test cases run git clone and require network access
+  doCheck = false;
 
-    # Test cases run git clone and require network access
-    doCheck = false;
+  postInstall = ''
+    rm $out/bin/{generate,snifftest}
+  '';
 
-    meta = with lib; {
-      homepage = "https://github.com/dxa4481/truffleHog";
-      description = "Searches through git repositories for high entropy strings and secrets, digging deep into commit history";
-      license = with licenses; [ gpl2 ];
-      maintainers = with maintainers; [ bhipple ];
-    };
-  }
+  meta = with lib; {
+    description = "Find credentials all over the place";
+    homepage = "https://github.com/trufflesecurity/trufflehog";
+    changelog = "https://github.com/trufflesecurity/trufflehog/releases/tag/v${version}";
+    license = with licenses; [ agpl3 ];
+    maintainers = with maintainers; [ ];
+  };
+}

pkgs/top-level/all-packages.nix

···
 
   kdeltachat = libsForQt5.callPackage ../applications/networking/instant-messengers/kdeltachat { };
 
+  keet = callPackage ../applications/networking/instant-messengers/keet { };
+
   kepubify = callPackage ../tools/misc/kepubify { };
 
   kermit = callPackage ../tools/misc/kermit { };

pkgs/top-level/haskell-packages.nix

···
       # https://github.com/xattr/xattr/issues/44 and
       # https://github.com/xattr/xattr/issues/55 are solved.
       inherit (buildPackages.darwin) xattr autoSignDarwinBinariesHook;
-      # 2022-08-04: Support range >= 10 && < 14
-      buildTargetLlvmPackages = pkgsBuildTarget.llvmPackages_12;
-      llvmPackages = pkgs.llvmPackages_12;
+      # 2022-08-04: Support range >= 10 && < 15
+      buildTargetLlvmPackages = pkgsBuildTarget.llvmPackages_14;
+      llvmPackages = pkgs.llvmPackages_14;
     };
 
     ghcjs = compiler.ghcjs810;