Merge master into staging-next

maintainers/maintainer-list.nix

···
     githubId = 54999;
     name = "Ariel Nunez";
   };
+  iopq = {
+    email = "[e-mail]";
+    github = "iopq";
+    githubId = 1817528;
+    name = "Igor Polyakov";
+  };
   irenes = {
     name = "Irene Knapp";
     email = "[e-mail]";
···
     github = "tasmo";
     githubId = 102685;
     name = "Thomas Friese";
+  };
+  taylor1791 = {
+    email = "[e-mail]";
+    github = "taylor1791";
+    githubId = 555003;
+    name = "Taylor Everding";
   };
   tazjin = {
     email = "[e-mail]";

nixos/doc/manual/from_md/release-notes/rl-2211.section.xml

···
       </listitem>
       <listitem>
         <para>
+          [xray] (https://github.com/XTLS/Xray-core), a fully compatible
+          v2ray-core replacement. Features XTLS, which when enabled on
+          server and client, brings UDP FullCone NAT to proxy setups.
+          Available as
+          <link xlink:href="options.html#opt-services.xray.enable">services.xray</link>.
+        </para>
+      </listitem>
+      <listitem>
+        <para>
           <link xlink:href="https://github.com/mozilla-services/syncstorage-rs">syncstorage-rs</link>,
           a self-hostable sync server for Firefox. Available as
           <link xlink:href="options.html#opt-services.firefox-syncserver.enable">services.firefox-syncserver</link>.

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

···
 ## New Services {#sec-release-22.11-new-services}
 
 - [appvm](https://github.com/jollheef/appvm), Nix based app VMs. Available as [virtualisation.appvm](options.html#opt-virtualisation.appvm.enable).
+
+- [xray] (https://github.com/XTLS/Xray-core), a fully compatible v2ray-core replacement. Features XTLS, which when enabled on server and client, brings UDP FullCone NAT to proxy setups. Available as [services.xray](options.html#opt-services.xray.enable).
+
 - [syncstorage-rs](https://github.com/mozilla-services/syncstorage-rs), a self-hostable sync server for Firefox. Available as [services.firefox-syncserver](options.html#opt-services.firefox-syncserver.enable).
 
 - [dragonflydb](https://dragonflydb.io/), a modern replacement for Redis and Memcached. Available as [services.dragonflydb](#opt-services.dragonflydb.enable).

nixos/modules/module-list.nix

···
   ./services/networking/xinetd.nix
   ./services/networking/xl2tpd.nix
   ./services/networking/x2goserver.nix
+  ./services/networking/xray.nix
   ./services/networking/xrdp.nix
   ./services/networking/yggdrasil.nix
   ./services/networking/zerobin.nix

nixos/modules/services/continuous-integration/jenkins/job-builder.nix

···
       };
 
       accessUser = mkOption {
-        default = "";
+        default = "admin";
         type = types.str;
         description = lib.mdDoc ''
           User id in Jenkins used to reload config.
···
       };
 
       accessTokenFile = mkOption {
-        default = "";
+        default = "${config.services.jenkins.home}/secrets/initialAdminPassword";
+        defaultText = literalExpression ''"''${config.services.jenkins.home}/secrets/initialAdminPassword"'';
         type = types.str;
         example = "/run/keys/jenkins-job-builder-access-token";
         description = lib.mdDoc ''

nixos/modules/services/hardware/udev.nix

···
   ###### interface
 
   options = {
-
     boot.hardwareScan = mkOption {
       type = types.bool;
       default = true;
···
     };
 
     services.udev = {
+      enable = mkEnableOption (lib.mdDoc "udev") // {
+        default = true;
+      };
 
       packages = mkOption {
         type = types.listOf types.path;
···
 
   ###### implementation
 
-  config = mkIf (!config.boot.isContainer) {
+  config = mkIf cfg.enable {
 
     services.udev.extraRules = nixosRules;
 

nixos/modules/services/networking/xray.nix

···
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+{
+  options = {
+
+    services.xray = {
+      enable = mkOption {
+        type = types.bool;
+        default = false;
+        description = lib.mdDoc ''
+          Whether to run xray server.
+
+          Either `settingsFile` or `settings` must be specified.
+        '';
+      };
+
+      package = mkOption {
+        type = types.package;
+        default = pkgs.xray;
+        defaultText = literalExpression "pkgs.xray";
+        description = lib.mdDoc ''
+          Which xray package to use.
+        '';
+      };
+
+      settingsFile = mkOption {
+        type = types.nullOr types.path;
+        default = null;
+        example = "/etc/xray/config.json";
+        description = lib.mdDoc ''
+          The absolute path to the configuration file.
+
+          Either `settingsFile` or `settings` must be specified.
+
+          See <https://www.v2fly.org/en_US/config/overview.html>.
+        '';
+      };
+
+      settings = mkOption {
+        type = types.nullOr (types.attrsOf types.unspecified);
+        default = null;
+        example = {
+          inbounds = [{
+            port = 1080;
+            listen = "127.0.0.1";
+            protocol = "http";
+          }];
+          outbounds = [{
+            protocol = "freedom";
+          }];
+        };
+        description = lib.mdDoc ''
+          The configuration object.
+
+          Either `settingsFile` or `settings` must be specified.
+
+          See <https://www.v2fly.org/en_US/config/overview.html>.
+        '';
+      };
+    };
+
+  };
+
+  config = let
+    cfg = config.services.xray;
+    settingsFile = if cfg.settingsFile != null
+      then cfg.settingsFile
+      else pkgs.writeTextFile {
+        name = "xray.json";
+        text = builtins.toJSON cfg.settings;
+        checkPhase = ''
+          ${cfg.package}/bin/xray -test -config $out
+        '';
+      };
+
+  in mkIf cfg.enable {
+    assertions = [
+      {
+        assertion = (cfg.settingsFile == null) != (cfg.settings == null);
+        message = "Either but not both `settingsFile` and `settings` should be specified for xray.";
+      }
+    ];
+
+    systemd.services.xray = {
+      description = "xray Daemon";
+      after = [ "network.target" ];
+      wantedBy = [ "multi-user.target" ];
+      serviceConfig = {
+        DynamicUser = true;
+        ExecStart = "${cfg.package}/bin/xray -config ${settingsFile}";
+      };
+    };
+  };
+}

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

···
 
   environmentFile = pkgs.writeText "healthchecks-environment" (lib.generators.toKeyValue { } environment);
 
-  healthchecksManageScript = with pkgs; (writeShellScriptBin "healthchecks-manage" ''
+  healthchecksManageScript = pkgs.writeShellScriptBin "healthchecks-manage" ''
+    sudo=exec
     if [[ "$USER" != "${cfg.user}" ]]; then
-        echo "please run as user 'healtchecks'." >/dev/stderr
-        exit 1
+      sudo='exec /run/wrappers/bin/sudo -u ${cfg.user} --preserve-env --preserve-env=PYTHONPATH'
     fi
-    export $(cat ${environmentFile} | xargs);
-    exec ${pkg}/opt/healthchecks/manage.py "$@"
-  '');
+    export $(cat ${environmentFile} | xargs)
+    $sudo ${pkg}/opt/healthchecks/manage.py "$@"
+  '';
 in
 {
   options.services.healthchecks = {
···
           WorkingDirectory = cfg.dataDir;
           User = cfg.user;
           Group = cfg.group;
-          EnvironmentFile = environmentFile;
+          EnvironmentFile = [ environmentFile ];
           StateDirectory = mkIf (cfg.dataDir == "/var/lib/healthchecks") "healthchecks";
           StateDirectoryMode = mkIf (cfg.dataDir == "/var/lib/healthchecks") "0750";
         };

nixos/modules/virtualisation/container-config.nix

···
     # Containers should be light-weight, so start sshd on demand.
     services.openssh.startWhenNeeded = mkDefault true;
 
+    # containers do not need to setup devices
+    services.udev.enable = false;
+
     # Shut up warnings about not having a boot loader.
     system.build.installBootLoader = lib.mkDefault "${pkgs.coreutils}/bin/true";
 

nixos/tests/jenkins.nix

···
           enable = true;
           jobBuilder = {
             enable = true;
-            accessUser = "admin";
-            accessTokenFile = "/var/lib/jenkins/secrets/initialAdminPassword";
             nixJobs = [
               { job = {
                   name = "job-1";

nixos/tests/web-apps/healthchecks.nix

···
         )
 
     with subtest("Manage script works"):
-        # Should fail if not called by healthchecks user
-        machine.fail("echo 'print(\"foo\")' | healthchecks-manage help")
-
         # "shell" sucommand should succeed, needs python in PATH.
         assert "foo\n" == machine.succeed("echo 'print(\"foo\")' | sudo -u healthchecks healthchecks-manage shell")
+
+        # Shouldn't fail if not called by healthchecks user
+        assert "foo\n" == machine.succeed("echo 'print(\"foo\")' | healthchecks-manage shell")
   '';
 })

pkgs/applications/audio/cider/default.nix

···
 
 appimageTools.wrapType2 rec {
   pname = "cider";
-  version = "1.5.6";
+  version = "1.5.7";
 
   src = fetchurl {
     url = "https://github.com/ciderapp/cider-releases/releases/download/v${version}/Cider-${version}.AppImage";
-    sha256 = "sha256-gn0dRoPPolujZ1ukuo/esSLwbhiPdcknIe9+W6iRaYw=";
+    sha256 = "sha256-fWpt7YxqEDa1U4CwyVZwgbiwe0lrh64v0cJG9pbNMUU=";
   };
 
   extraInstallCommands =

pkgs/applications/audio/tagger/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "tagger";
-  version = "2022.10.4";
+  version = "2022.10.5";
 
   src = fetchFromGitHub {
     owner = "nlogozzo";
     repo = "NickvisionTagger";
     rev = version;
-    hash = "sha256-I4jhlz/dmS24nszP755xlYMF6aLhmAxlv6Td4xFbr3U=";
+    hash = "sha256-rkpeecJUOBom0clrwftBa/VxACTihfMfWVmfbZhMQ50=";
   };
 
   nativeBuildInputs = [

pkgs/applications/blockchains/zcash/default.nix

···
-{ autoreconfHook, boost179, cargo, coreutils, curl, cxx-rs, db62, fetchFromGitHub
-, hexdump, lib, libevent, libsodium, makeWrapper, rust, rustPlatform, pkg-config
-, stdenv, testers, utf8cpp, util-linux, zcash, zeromq
+{ autoreconfHook, boost180, cargo, coreutils, curl, cxx-rs, db62, fetchFromGitHub
+, hexdump, hostPlatform, lib, libevent, libsodium, makeWrapper, rust, rustPlatform
+, pkg-config, Security, stdenv, testers, utf8cpp, util-linux, zcash, zeromq
 }:
 
 rustPlatform.buildRustPackage.override { inherit stdenv; } rec {
   pname = "zcash";
-  version = "5.1.0";
+  version = "5.3.0";
 
   src = fetchFromGitHub {
     owner = "zcash";
     repo  = "zcash";
     rev = "v${version}";
-    sha256 = "sha256-tU6DuWpe8Vlx0qIilAKWuO7WFp1ucbxtvOxoWLA0gdc=";
+    hash = "sha256-mlABKZDYYC3y+KlXQVFqdcm46m8K9tbOCqk4lM4shp8=";
   };
 
   prePatch = lib.optionalString stdenv.isAarch64 ''
···
       --replace "linker = \"aarch64-linux-gnu-gcc\"" ""
   '';
 
-  patches = [
-    ./patches/fix-missing-header.patch
-  ];
-
-  cargoSha256 = "sha256-ZWmkveDEENdXRirGmnUWSjtPNJvX0Jpgfxhzk44F7Q0=";
+  cargoHash = "sha256-6uhtOaBsgMw59Dy6yivZYUEWDsYfpInA7VmJrqxDS/4=";
 
   nativeBuildInputs = [ autoreconfHook cargo cxx-rs hexdump makeWrapper pkg-config ];
 
-  buildInputs = [ boost179 db62 libevent libsodium utf8cpp zeromq ];
+  buildInputs = [
+    boost180
+    db62
+    libevent
+    libsodium
+    utf8cpp
+    zeromq
+  ] ++ lib.optionals stdenv.isDarwin [
+    Security
+  ];
 
   # Use the stdenv default phases (./configure; make) instead of the
   # ones from buildRustPackage.
···
 
   configureFlags = [
     "--disable-tests"
-    "--with-boost-libdir=${lib.getLib boost179}/lib"
+    "--with-boost-libdir=${lib.getLib boost180}/lib"
     "RUST_TARGET=${rust.toRustTargetSpec stdenv.hostPlatform}"
   ];
 
···
     homepage = "https://z.cash/";
     maintainers = with maintainers; [ rht tkerber centromere ];
     license = licenses.mit;
+
+    # https://github.com/zcash/zcash/issues/4405
+    broken = hostPlatform.isAarch64 && hostPlatform.isDarwin;
   };
 }

pkgs/applications/blockchains/zcash/patches/fix-missing-header.patch

···
---- a/src/uint256.h	2022-07-20 10:07:39.191319302 +0000
-+++ b/src/uint256.h	2022-07-20 10:07:11.809632293 +0000
-@@ -7,6 +7,7 @@
- #ifndef BITCOIN_UINT256_H
- #define BITCOIN_UINT256_H
-
-+#include <array>
- #include <assert.h>
- #include <cstring>
- #include <stdexcept>

pkgs/applications/editors/vscode/extensions/default.nix

···
         mktplcRef = {
           name = "nix-ide";
           publisher = "jnoortheen";
-          version = "0.1.23";
-          sha256 = "sha256-64gwwajfgniVzJqgVLK9b8PfkNG5mk1W+qewKL7Dv0Q=";
+          version = "0.2.1";
+          sha256 = "sha256-yC4ybThMFA2ncGhp8BYD7IrwYiDU3226hewsRvJYKy4=";
         };
         meta = with lib; {
           changelog = "https://marketplace.visualstudio.com/items/jnoortheen.nix-ide/changelog";

pkgs/applications/emulators/bochs/default.nix

···
 { lib
 , stdenv
 , fetchurl
+, SDL2
+, curl
 , docbook_xml_dtd_45
 , docbook_xsl
+, gtk3
+, libGL
+, libGLU
+, libX11
+, libXpm
+, libobjc
 , libtool
+, ncurses
 , pkg-config
-, curl
 , readline
 , wget
-, libobjc
-, enableX11 ? !stdenv.isDarwin
-, libGL
-, libGLU
-, libX11
-, libXpm
-, enableSdl2 ? true
-, SDL2
+, wxGTK
+, enableSDL2 ? true
 , enableTerm ? true
-, ncurses
 , enableWx ? !stdenv.isDarwin
-, wxGTK
-, gtk3
+, enableX11 ? !stdenv.isDarwin
 }:
 
 stdenv.mkDerivation (finalAttrs: {
···
   version = "2.7";
 
   src = fetchurl {
-    url = "mirror://sourceforge/project/${finalAttrs.pname}/${finalAttrs.pname}/${finalAttrs.version}/${finalAttrs.pname}-${finalAttrs.version}.tar.gz";
+    url = "mirror://sourceforge/project/bochs/bochs/${finalAttrs.version}/bochs-${finalAttrs.version}.tar.gz";
     hash = "sha256-oBCrG/3HKsWgjS4kEs1HHA/r1mrx2TSbwNeWh53lsXo=";
   };
 
···
     curl
     readline
     wget
-  ] ++ lib.optionals stdenv.isDarwin [
-    libobjc
-  ] ++ lib.optionals enableX11 [
-    libGL
-    libGLU
-    libX11
-    libXpm
-  ] ++ lib.optionals enableSdl2 [
+  ] ++ lib.optionals enableSDL2 [
     SDL2
   ] ++ lib.optionals enableTerm [
     ncurses
   ] ++ lib.optionals enableWx [
+    gtk3
     wxGTK
-    gtk3
+  ] ++ lib.optionals enableX11 [
+    libGL
+    libGLU
+    libX11
+    libXpm
+  ] ++ lib.optionals stdenv.isDarwin [
+    libobjc
   ];
 
   configureFlags = [
···
     "--enable-voodoo"
     "--enable-x86-64"
     "--enable-x86-debugger"
+  ] ++ lib.optionals enableSDL2 [
+    "--with-sdl2"
+  ] ++ lib.optionals enableTerm [
+    "--with-term"
+  ] ++ lib.optionals enableWx [
+    "--with-wx"
+  ] ++ lib.optionals enableX11 [
+    "--with-x"
+    "--with-x11"
   ] ++ lib.optionals (!stdenv.isDarwin) [
     "--enable-e1000"
     "--enable-es1370"
···
     "--enable-plugins"
     "--enable-pnic"
     "--enable-sb16"
-  ] ++ lib.optionals enableX11 [
-    "--with-x"
-    "--with-x11"
-  ] ++ lib.optionals enableSdl2 [
-    "--with-sdl2"
-  ] ++ lib.optionals enableTerm [
-    "--with-term"
-  ] ++ lib.optionals enableWx [
-    "--with-wx"
   ];
 
   enableParallelBuilding = true;

pkgs/applications/misc/gallery-dl/default.nix

···
 
 buildPythonApplication rec {
   pname = "gallery-dl";
-  version = "1.23.4";
+  version = "1.23.5";
   format = "setuptools";
 
   src = fetchPypi {
     inherit version;
     pname = "gallery_dl";
-    sha256 = "sha256-IpbV6wWIfRDuljX/Bexo9siFXMezeCRBFK5CzVH0vUU=";
+    sha256 = "sha256-NhnuW7rq5Dgrnkw/nUO/pFg/Sh2D/d9gFCIb+gQy5QE=";
   };
 
   propagatedBuildInputs = [

pkgs/applications/misc/passky-desktop/default.nix

···
 
 let
   pname = "passky-desktop";
-  version = "5.0.0";
+  version = "7.1.0";
 
   srcs = {
     x86_64-linux = fetchurl {
       url = "https://github.com/Rabbit-Company/Passky-Desktop/releases/download/v${version}/Passky-${version}.AppImage";
-      sha256 = "19sy9y2bcxrf10ifszinh4yn32q3032h3d1qxm046zffzl069807";
+      sha256 = "1xnhrmmm018mmyzjq05mhbf673f0n81fh1k3kbfarbgk2kbwpq6y";
     };
     x86_64-darwin = fetchurl {
       url = "https://github.com/Rabbit-Company/Passky-Desktop/releases/download/v${version}/Passky-${version}.dmg";
-      sha256 = "sha256-lclJOaYe+2XeKhJb2WcOAzjBMzK3YEmlS4rXuRUJYU0=";
+      sha256 = "0mm7hk4v7zvpjdqyw3nhk33x72j0gh3f59bx3q18azlm4dr61r2d";
     };
   };
   src = srcs.${stdenv.hostPlatform.system} or (throw "Unsupported system: ${stdenv.hostPlatform.system}");

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

···
 {
   "stable": {
-    "version": "107.0.5304.68",
-    "sha256": "0k5qrmby1k2gw3lj96x3qag20kka61my578pv0zyrqqj5sdz3i5a",
-    "sha256bin64": "1x9svz5s8fm2zhnpzjpqckzfp37hjni3nf3pm63rwnvbd06y48ja",
+    "version": "107.0.5304.87",
+    "sha256": "0n9wr5v7zcdmbqs7mmnyydjvzw0glh5l3skpj7i1nap2hv0h03kc",
+    "sha256bin64": "16a6qisxkfmx60qh67rvfy3knp66hdgxan48cga6j3zd683inas2",
     "deps": {
       "gn": {
         "version": "2022-09-14",
···
     }
   },
   "beta": {
-    "version": "107.0.5304.68",
-    "sha256": "0k5qrmby1k2gw3lj96x3qag20kka61my578pv0zyrqqj5sdz3i5a",
-    "sha256bin64": "15ijvsm9k28iwr7dxi2vbrlb7z5nz63yvpx7cg766z1z1q5jcg7m",
+    "version": "108.0.5359.22",
+    "sha256": "1wwrwqyl9nl4kpkmkybw14ygj5lfrk274yx5f817ha1kpk8vma0y",
+    "sha256bin64": "0dq3mf1rai7i3aqq9h8g4iy9nxy3hbb6gd86c31admxygdpgpds5",
     "deps": {
       "gn": {
-        "version": "2022-09-14",
+        "version": "2022-10-05",
         "url": "https://gn.googlesource.com/gn",
-        "rev": "fff29c1b3f9703ea449f720fe70fa73575ef24e5",
-        "sha256": "1c0dvpp4im1hf277bs5w7rgqxz3g2bax266i2g6smi3pl7a8jpnp"
+        "rev": "b9c6c19be95a3863e02f00f1fe403b2502e345b6",
+        "sha256": "1rhadb6qk867jafr85x2m3asis3jv7x06blhmad2d296p26d5w6x"
       }
     }
   },
   "dev": {
-    "version": "108.0.5359.19",
-    "sha256": "1093anaymbmza6rf9hisl6qdf9jfaa27kyd3gbv5xyc0i450ypg5",
-    "sha256bin64": "0yi6qi7asmh3kx6y86p22smjf5bpay1nrj09zg7l2qd3gi836xp0",
+    "version": "109.0.5384.0",
+    "sha256": "195lbklp5c6bvfzhdvah4k2yr44jwy64499y37kgxky0mb79a26n",
+    "sha256bin64": "02qbwj9gfcgxdqm1mhxg0mljvrhnl994lhis615y23099r3r67i8",
     "deps": {
       "gn": {
-        "version": "2022-10-05",
+        "version": "2022-10-26",
         "url": "https://gn.googlesource.com/gn",
-        "rev": "b9c6c19be95a3863e02f00f1fe403b2502e345b6",
-        "sha256": "1rhadb6qk867jafr85x2m3asis3jv7x06blhmad2d296p26d5w6x"
+        "rev": "3e98c606ed0dff59fa461fbba4892c0b6de1966e",
+        "sha256": "08cz58svkb7c71f1x1ahr60a6ircr31rfmkk4d46z2v39sgry1gv"
       }
     }
   },
   "ungoogled-chromium": {
-    "version": "107.0.5304.68",
-    "sha256": "0k5qrmby1k2gw3lj96x3qag20kka61my578pv0zyrqqj5sdz3i5a",
-    "sha256bin64": "1x9svz5s8fm2zhnpzjpqckzfp37hjni3nf3pm63rwnvbd06y48ja",
+    "version": "107.0.5304.88",
+    "sha256": "1k4j4j9b1m7kjybfgns9akb7adfby3gnjpibk0kjd22n3sprar8y",
+    "sha256bin64": null,
     "deps": {
       "gn": {
         "version": "2022-09-14",
···
         "sha256": "1c0dvpp4im1hf277bs5w7rgqxz3g2bax266i2g6smi3pl7a8jpnp"
       },
       "ungoogled-patches": {
-        "rev": "107.0.5304.68-1",
-        "sha256": "0rjdi2lr71xjjf4x27183ys87fc95m85yp5x3kk6i39ppksvsj6b"
+        "rev": "107.0.5304.88-1",
+        "sha256": "1m9hjbs79ga5jw7x332jl882lh7yrr4n4r4qrzy37ai75x371pz2"
       }
     }
   }

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

···
 }:
 
 let
-  version = "1.10.1";
+  version = "1.10.3";
   pname = "session-desktop";
 
   src = fetchurl {
     url = "https://github.com/oxen-io/session-desktop/releases/download/v${version}/session-desktop-linux-x86_64-${version}.AppImage";
-    sha256 = "sha256-DArIq5bxyeHy45ZkE+FIpxBl4P6jiHTCN1lVCuF81O8=";
+    sha256 = "sha256-I9YyzfI8EqH8LZe5E5BnD9lGPAdQo++l3yRClfN7+pY=";
   };
   appimage = appimageTools.wrapType2 {
     inherit version pname src;

pkgs/applications/networking/maestral-qt/default.nix

···
 { lib
 , fetchFromGitHub
 , python3
-, wrapQtAppsHook
+, qt6
 , nixosTests
 }:
 
-let
-  inherit (pypkgs) makePythonPath;
-
-  pypkgs = (python3.override {
-    packageOverrides = self: super: {
-      # Use last available version of maestral that still supports PyQt5
-      # Remove this override when PyQt6 is available
-      maestral = super.maestral.overridePythonAttrs (old: rec {
-        version = "1.5.3";
-        src = fetchFromGitHub {
-          owner = "SamSchott";
-          repo = "maestral";
-          rev = "refs/tags/v${version}";
-          hash = "sha256-Uo3vcYez2qSq162SSKjoCkwygwR5awzDceIq8/h3dao=";
-        };
-      });
-    };
-  }).pkgs;
-
-in
-pypkgs.buildPythonApplication rec {
+python3.pkgs.buildPythonApplication rec {
   pname = "maestral-qt";
-  version = "1.5.3";
-  disabled = pypkgs.pythonOlder "3.6";
+  version = "1.6.3";
+  disabled = python3.pythonOlder "3.7";
 
   src = fetchFromGitHub {
     owner = "SamSchott";
     repo = "maestral-qt";
     rev = "refs/tags/v${version}";
-    sha256 = "sha256-zaG9Zwz9S/SVb7xDa7eXkjLNt1BhA1cQ3I18rVt+8uQ=";
+    sha256 = "sha256-Fvr5WhrhxPBeAMsrVj/frg01qgt2SeWgrRJYgBxRFHc=";
   };
 
   format = "pyproject";
 
-  propagatedBuildInputs = with pypkgs; [
+  propagatedBuildInputs = with python3.pkgs; [
     click
     markdown2
     maestral
     packaging
-    pyqt5
-  ] ++ lib.optionals (pythonOlder "3.9") [
-    importlib-resources
+    pyqt6
   ];
 
-  nativeBuildInputs = [ wrapQtAppsHook ];
+  buildInputs = [
+    qt6.qtbase
+    qt6.qtsvg  # Needed for the systray icon
+  ];
+
+  nativeBuildInputs = [
+    qt6.wrapQtAppsHook
+  ];
+
+  dontWrapQtApps = true;
 
-  makeWrapperArgs = [
+  makeWrapperArgs = with python3.pkgs; [
     # Firstly, add all necessary QT variables
     "\${qtWrapperArgs[@]}"
 
     # Add the installed directories to the python path so the daemon can find them
-    "--prefix PYTHONPATH : ${makePythonPath (pypkgs.requiredPythonModules pypkgs.maestral.propagatedBuildInputs)}"
-    "--prefix PYTHONPATH : ${makePythonPath [ pypkgs.maestral ]}"
+    "--prefix PYTHONPATH : ${makePythonPath (requiredPythonModules maestral.propagatedBuildInputs)}"
+    "--prefix PYTHONPATH : ${makePythonPath [ maestral ]}"
   ];
 
   # no tests

pkgs/applications/science/biology/sambamba/default.nix

···
   nativeBuildInputs = [ which python3 ldc ];
   buildInputs = [ zlib lz4 ];
 
+  buildFlags = [
+    "CC=${stdenv.cc.targetPrefix}cc"
+  ];
+
   # Upstream's install target is broken; copy manually
   installPhase = ''
-    mkdir -p $out/bin
-    cp bin/sambamba-${version} $out/bin/sambamba
+    runHook preInstall
+
+    install -Dm755 bin/sambamba-${version} $out/bin/sambamba
+
+    runHook postInstall
   '';
 
   meta = with lib; {

pkgs/applications/science/logic/nusmv/default.nix

···
+{ stdenv
+, lib
+, fetchurl
+, autoPatchelfHook
+}:
+
+stdenv.mkDerivation rec {
+  pname = "NuSMV";
+  version = "2.6.0";
+
+  src = with stdenv; fetchurl (
+    if isx86_64 && isLinux then {
+      url = "https://nusmv.fbk.eu/distrib/NuSMV-${version}-linux64.tar.gz";
+      sha256 = "1370x2vwjndv9ham5q399nn84hvhm1gj1k7pq576qmh4pi12xc8i";
+    } else if isx86_32 && isLinux then {
+      url = "https://nusmv.fbk.eu/distrib/NuSMV-${version}-linux32.tar.gz";
+      sha256 = "1qf41czwbqxlrmv0rv2daxgz2hljza5xks85sx3dhwpjy2iav9jb";
+    } else throw "only linux x86_64 and x86_32 are currently supported") ;
+
+
+  nativeBuildInputs = [ autoPatchelfHook ];
+
+  installPhase = ''
+    install -m755 -D bin/NuSMV $out/bin/NuSMV
+    install -m755 -D bin/ltl2smv $out/bin/ltl2smv
+    cp -r include $out/include
+    cp -r share $out/share
+  '';
+
+  meta = with lib; {
+    description = "A new symbolic model checker for the analysis of synchronous finite-state and infinite-state systems";
+    homepage = "https://nuxmv.fbk.eu/pmwiki.php";
+    maintainers = with maintainers; [ mgttlinger ];
+    sourceProvenance = with sourceTypes; [ binaryNativeCode ];
+    platforms = platforms.linux;
+  };
+}

pkgs/applications/window-managers/gamescope/default.nix

···
 }:
 let
   pname = "gamescope";
-  version = "3.11.47";
+  version = "3.11.48";
 in
 stdenv.mkDerivation {
   inherit pname version;
···
     owner = "Plagman";
     repo = "gamescope";
     rev = "refs/tags/${version}";
-    hash = "sha256-GkvujrYc7dBbsGqeG0THqtEAox+VZ3DoWQK4gkHo+ds=";
+    hash = "sha256-/a0fW0NVIrg9tuK+mg+D+IOcq3rJJxKdFwspM1ZRR9M=";
   };
 
   patches = [ ./use-pkgconfig.patch ];

pkgs/data/fonts/go-font/default.nix

···
   rev = "41969df76e82aeec85fa3821b1e24955ea993001";
 
   postFetch = ''
-    mv $out/* .
+    mv $out source
+    cd source
+
     mkdir -p $out/share/fonts/truetype
     mkdir -p $out/share/doc/go-font
     cp font/gofont/ttfs/* $out/share/fonts/truetype
     mv $out/share/fonts/truetype/README $out/share/doc/go-font/LICENSE
   '';
 
-  sha256 = "dteUL/4ZUq3ybL6HaLYqu2Tslx3q8VvELIY3tVC+ODo=";
+  sha256 = "175jwq16qjnd2k923n9gcbjizchy7yv4n41dm691sjwrhbl0b13x";
 }) // {
   meta = with lib; {
     homepage = "https://blog.golang.org/go-fonts";

pkgs/data/misc/hackage/pin.json

···
 {
-  "commit": "2c8100e0ec017b1ab20fcf4679176087b10fbd45",
-  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/2c8100e0ec017b1ab20fcf4679176087b10fbd45.tar.gz",
-  "sha256": "16jvcyn4cxc2f0p92f71yk1n2p6jmblnhqm8is5ipn0j4xz6l0bl",
-  "msg": "Update from Hackage at 2022-10-11T19:16:50Z"
+  "commit": "8983027e744098e8a2fbeac09bcc6eb8a9471fff",
+  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/8983027e744098e8a2fbeac09bcc6eb8a9471fff.tar.gz",
+  "sha256": "1iqgakw71x8cymdifpqnv546wmmrda6w862axli4k03vj7rv91iw",
+  "msg": "Update from Hackage at 2022-10-27T19:26:33Z"
 }

pkgs/development/compilers/dmd/binary.nix

···
 
   nativeBuildInputs = lib.optionals hostPlatform.isLinux [
     autoPatchelfHook
-  ] ++ lib.optional hostPlatform.isDarwin fixDarwinDylibNames;
-  propagatedBuildInputs = [ curl tzdata ] ++ lib.optional hostPlatform.isLinux glibc;
+  ] ++ lib.optionals hostPlatform.isDarwin [
+    fixDarwinDylibNames
+  ];
+  propagatedBuildInputs = [
+    curl
+    tzdata
+  ] ++ lib.optionals hostPlatform.isLinux [
+    glibc
+  ];
 
   installPhase = ''
+    runHook preInstall
+
     mkdir -p $out
 
     # try to copy model-specific binaries into bin first
···
 
     # fix paths in dmd.conf (one level less)
     substituteInPlace $out/bin/dmd.conf --replace "/../../" "/../"
+
+    runHook postInstall
   '';
+
+  # Stripping on Darwin started to break libphobos2.a
+  # Undefined symbols for architecture x86_64:
+  #   "_rt_envvars_enabled", referenced from:
+  #       __D2rt6config16rt_envvarsOptionFNbNiAyaMDFNbNiQkZQnZQq in libphobos2.a(config_99a_6c3.o)
+  dontStrip = hostPlatform.isDarwin;
 
   meta = with lib; {
     description = "Digital Mars D Compiler Package";

pkgs/development/compilers/dmd/bootstrap.nix

···
   version = "2.090.1";
   hashes = {
     # Get these from `nix-prefetch-url http://downloads.dlang.org/releases/2.x/2.090.1/dmd.2.090.1.linux.tar.xz` etc..
-    osx = "0rbn7j4dr3q0y09fblpj999bi063pi4230rqd5xgd3gwxxa0cz7l";
-    linux = "1vk6lsvd6y7ccvffd23yial4ig90azaxf2rxc6yvidqd1qhan807";
+    osx = "sha256-9HwGVO/8jfZ6aTiDIUi8w4C4Ukry0uUS8ACP3Ig8dmU=";
+    linux = "sha256-ByCrIA4Nt7i9YT0L19VXIL1IqIp+iObcZux407amZu4=";
   };
 }

pkgs/development/compilers/dmd/default.nix

···
-{ stdenv, lib, fetchFromGitHub
-, makeWrapper, unzip, which, writeTextFile
-, curl, tzdata, gdb, Foundation, git, callPackage
-, targetPackages, fetchpatch, bash
-, HOST_DMD? "${callPackage ./bootstrap.nix { }}/bin/dmd"
-, version? "2.097.2"
-, dmdSha256? "16ldkk32y7ln82n7g2ym5d1xf3vly3i31hf8600cpvimf6yhr6kb"
-, druntimeSha256? "1sayg6ia85jln8g28vb4m124c27lgbkd6xzg9gblss8ardb8dsp1"
-, phobosSha256? "0czg13h65b6qwhk9ibya21z3iv3fpk3rsjr3zbcrpc2spqjknfw5"
-}:
-
-let
-  dmdConfFile = writeTextFile {
-    name = "dmd.conf";
-    text = (lib.generators.toINI {} {
-      Environment = {
-        DFLAGS = ''-I@out@/include/dmd -L-L@out@/lib -fPIC ${lib.optionalString (!targetPackages.stdenv.cc.isClang) "-L--export-dynamic"}'';
-      };
-    });
-  };
-
-  bits = builtins.toString stdenv.hostPlatform.parsed.cpu.bits;
-in
-
-stdenv.mkDerivation rec {
-  pname = "dmd";
-  inherit version;
-
-  enableParallelBuilding = true;
-
-  srcs = [
-    (fetchFromGitHub {
-      owner = "dlang";
-      repo = "dmd";
-      rev = "v${version}";
-      sha256 = dmdSha256;
-      name = "dmd";
-    })
-    (fetchFromGitHub {
-      owner = "dlang";
-      repo = "druntime";
-      rev = "v${version}";
-      sha256 = druntimeSha256;
-      name = "druntime";
-    })
-    (fetchFromGitHub {
-      owner = "dlang";
-      repo = "phobos";
-      rev = "v${version}";
-      sha256 = phobosSha256;
-      name = "phobos";
-    })
-  ];
-
-  sourceRoot = ".";
-
-  # https://issues.dlang.org/show_bug.cgi?id=19553
-  hardeningDisable = [ "fortify" ];
-
-  # Not using patches option to make it easy to patch, for example, dmd and
-  # Phobos at same time if that's required
-  patchPhase =
-
-  # Migrates D1-style operator overloads in DMD source, to allow building with
-  # a newer DMD
-  lib.optionalString (lib.versionOlder version "2.088.0") ''
-    patch -p1 -F3 --directory=dmd -i ${(fetchpatch {
-      url = "https://github.com/dlang/dmd/commit/c4d33e5eb46c123761ac501e8c52f33850483a8a.patch";
-      sha256 = "0rhl9h3hsi6d0qrz24f4zx960cirad1h8mm383q6n21jzcw71cp5";
-    })}
-  ''
-
-  # Fixes C++ tests that compiled on older C++ but not on the current one
-  + lib.optionalString (lib.versionOlder version "2.092.2") ''
-    patch -p1 -F3 --directory=druntime -i ${(fetchpatch {
-      url = "https://github.com/dlang/druntime/commit/438990def7e377ca1f87b6d28246673bb38022ab.patch";
-      sha256 = "0nxzkrd1rzj44l83j7jj90yz2cv01na8vn9d116ijnm85jl007b4";
-    })}
-  ''
-
-  + postPatch;
-
-
-  postPatch =
-  ''
-    patchShebangs .
-
-    # Disable tests that rely on objdump whitespace until fixed upstream:
-    #   https://issues.dlang.org/show_bug.cgi?id=23317
-    rm dmd/test/runnable/cdvecfill.sh
-    rm dmd/test/compilable/cdcmp.d
-  ''
-
-  # This one has tested against a hardcoded year, then against a current year on
-  # and off again. It just isn't worth it to patch all the historical versions
-  # of it, so just remove it until the most recent change.
-  + lib.optionalString (lib.versionOlder version "2.091.0") ''
-    rm dmd/test/compilable/ddocYear.d
-  ''
-
-  + lib.optionalString (version == "2.092.1") ''
-    rm dmd/test/dshell/test6952.d
-  '' + lib.optionalString (lib.versionAtLeast version "2.092.2") ''
-    substituteInPlace dmd/test/dshell/test6952.d --replace "/usr/bin/env bash" "${bash}/bin/bash"
-  ''
-
-  + ''
-    rm dmd/test/runnable/gdb1.d
-    rm dmd/test/runnable/gdb10311.d
-    rm dmd/test/runnable/gdb14225.d
-    rm dmd/test/runnable/gdb14276.d
-    rm dmd/test/runnable/gdb14313.d
-    rm dmd/test/runnable/gdb14330.d
-    rm dmd/test/runnable/gdb15729.sh
-    rm dmd/test/runnable/gdb4149.d
-    rm dmd/test/runnable/gdb4181.d
-
-    # Grep'd string changed with gdb 12
-    substituteInPlace druntime/test/exceptions/Makefile \
-      --replace 'in D main (' 'in _Dmain ('
-  ''
-
-  + lib.optionalString stdenv.isLinux ''
-    substituteInPlace phobos/std/socket.d --replace "assert(ih.addrList[0] == 0x7F_00_00_01);" ""
-  '' + lib.optionalString stdenv.isDarwin ''
-    substituteInPlace phobos/std/socket.d --replace "foreach (name; names)" "names = []; foreach (name; names)"
-  '';
-
-  nativeBuildInputs = [ makeWrapper unzip which git ];
-
-  buildInputs = [ gdb curl tzdata ]
-    ++ lib.optionals stdenv.isDarwin [ Foundation gdb ];
-
-
-  osname = if stdenv.isDarwin then
-    "osx"
-  else
-    stdenv.hostPlatform.parsed.kernel.name;
-  top = "$NIX_BUILD_TOP";
-  pathToDmd = "${top}/dmd/generated/${osname}/release/${bits}/dmd";
-
-  # Build and install are based on http://wiki.dlang.org/Building_DMD
-  buildPhase = ''
-    cd dmd
-    make -j$NIX_BUILD_CORES -f posix.mak INSTALL_DIR=$out BUILD=release ENABLE_RELEASE=1 PIC=1 HOST_DMD=${HOST_DMD}
-    cd ../druntime
-    make -j$NIX_BUILD_CORES -f posix.mak BUILD=release ENABLE_RELEASE=1 PIC=1 INSTALL_DIR=$out DMD=${pathToDmd}
-    cd ../phobos
-    echo ${tzdata}/share/zoneinfo/ > TZDatabaseDirFile
-    echo ${curl.out}/lib/libcurl${stdenv.hostPlatform.extensions.sharedLibrary} > LibcurlPathFile
-    make -j$NIX_BUILD_CORES -f posix.mak BUILD=release ENABLE_RELEASE=1 PIC=1 INSTALL_DIR=$out DMD=${pathToDmd} DFLAGS="-version=TZDatabaseDir -version=LibcurlPath -J$(pwd)"
-    cd ..
-  '';
-
-  doCheck = true;
-
-  # many tests are disbled because they are failing
-
-  # NOTE: Purity check is disabled for checkPhase because it doesn't fare well
-  # with the DMD linker. See https://github.com/NixOS/nixpkgs/issues/97420
-  checkPhase = ''
-    cd dmd
-    NIX_ENFORCE_PURITY= \
-      make -j$NIX_BUILD_CORES -C test -f Makefile PIC=1 CC=$CXX DMD=${pathToDmd} BUILD=release SHELL=$SHELL
-
-    cd ../druntime
-    NIX_ENFORCE_PURITY= \
-      make -j$NIX_BUILD_CORES -f posix.mak unittest PIC=1 DMD=${pathToDmd} BUILD=release
-
-    cd ../phobos
-    NIX_ENFORCE_PURITY= \
-      make -j$NIX_BUILD_CORES -f posix.mak unittest BUILD=release ENABLE_RELEASE=1 PIC=1 DMD=${pathToDmd} DFLAGS="-version=TZDatabaseDir -version=LibcurlPath -J$(pwd)"
-
-    cd ..
-  '';
-
-  installPhase = ''
-    cd dmd
-    mkdir $out
-    mkdir $out/bin
-    cp ${pathToDmd} $out/bin
-
-    mkdir -p $out/share/man/man1
-    mkdir -p $out/share/man/man5
-    cp -r docs/man/man1/* $out/share/man/man1/
-    cp -r docs/man/man5/* $out/share/man/man5/
-
-    cd ../druntime
-    mkdir $out/include
-    mkdir $out/include/dmd
-    cp -r import/* $out/include/dmd
-
-    cd ../phobos
-    mkdir $out/lib
-    cp generated/${osname}/release/${bits}/libphobos2.* $out/lib
-
-    cp -r std $out/include/dmd
-    cp -r etc $out/include/dmd
-
-    wrapProgram $out/bin/dmd \
-      --prefix PATH ":" "${targetPackages.stdenv.cc}/bin" \
-      --set-default CC "${targetPackages.stdenv.cc}/bin/cc"
-
-    substitute ${dmdConfFile} "$out/bin/dmd.conf" --subst-var out
-  '';
-
-  meta = with lib; {
-    broken = stdenv.isDarwin;
-    description = "Official reference compiler for the D language";
-    homepage = "https://dlang.org/";
-    # Everything is now Boost licensed, even the backend.
-    # https://github.com/dlang/dmd/pull/6680
-    license = licenses.boost;
-    maintainers = with maintainers; [ ThomasMader lionello dukc ];
-    platforms = [ "x86_64-linux" "i686-linux" "x86_64-darwin" ];
-  };
+import ./generic.nix {
+  version = "2.100.2";
+  dmdSha256 = "sha256-o4+G3ARXIGObYHtHooYZKr+Al6kHpiwpMIog3i4BlDM=";
+  druntimeSha256 = "sha256-qXvY1ECN4mPwOGgOE1FWwvxoRvlSww3tGLWgBdhzAKo=";
+  phobosSha256 = "sha256-kTHRaAKG7cAGb4IE/NGHWaZ8t7ZceKj03l6E8wLzJzs=";
 }

pkgs/development/compilers/dmd/generic.nix

···
+{ version
+, dmdSha256
+, druntimeSha256
+, phobosSha256
+}:
+
+{ stdenv
+, lib
+, fetchFromGitHub
+, makeWrapper
+, which
+, writeTextFile
+, curl
+, tzdata
+, gdb
+, Foundation
+, callPackage
+, targetPackages
+, fetchpatch
+, bash
+, installShellFiles
+, git
+, unzip
+, HOST_DMD ? "${callPackage ./bootstrap.nix { }}/bin/dmd"
+}:
+
+let
+  dmdConfFile = writeTextFile {
+    name = "dmd.conf";
+    text = (lib.generators.toINI { } {
+      Environment = {
+        DFLAGS = ''-I@out@/include/dmd -L-L@out@/lib -fPIC ${lib.optionalString (!targetPackages.stdenv.cc.isClang) "-L--export-dynamic"}'';
+      };
+    });
+  };
+
+  bits = builtins.toString stdenv.hostPlatform.parsed.cpu.bits;
+  osname =
+    if stdenv.isDarwin then
+      "osx"
+    else
+      stdenv.hostPlatform.parsed.kernel.name;
+
+  pathToDmd = "\${NIX_BUILD_TOP}/dmd/generated/${osname}/release/${bits}/dmd";
+in
+
+stdenv.mkDerivation rec {
+  pname = "dmd";
+  inherit version;
+
+  enableParallelBuilding = true;
+
+  srcs = [
+    (fetchFromGitHub {
+      owner = "dlang";
+      repo = "dmd";
+      rev = "v${version}";
+      sha256 = dmdSha256;
+      name = "dmd";
+    })
+    (fetchFromGitHub {
+      owner = "dlang";
+      repo = "druntime";
+      rev = "v${version}";
+      sha256 = druntimeSha256;
+      name = "druntime";
+    })
+    (fetchFromGitHub {
+      owner = "dlang";
+      repo = "phobos";
+      rev = "v${version}";
+      sha256 = phobosSha256;
+      name = "phobos";
+    })
+  ];
+
+  sourceRoot = ".";
+
+  # https://issues.dlang.org/show_bug.cgi?id=19553
+  hardeningDisable = [ "fortify" ];
+
+  patches = lib.optionals (lib.versionOlder version "2.088.0") [
+    # Migrates D1-style operator overloads in DMD source, to allow building with
+    # a newer DMD
+    (fetchpatch {
+      url = "https://github.com/dlang/dmd/commit/c4d33e5eb46c123761ac501e8c52f33850483a8a.patch";
+      stripLen = 1;
+      extraPrefix = "dmd/";
+      sha256 = "sha256-N21mAPfaTo+zGCip4njejasraV5IsWVqlGR5eOdFZZE=";
+    })
+  ] ++ lib.optionals (lib.versionOlder version "2.092.2") [
+    # Fixes C++ tests that compiled on older C++ but not on the current one
+    (fetchpatch {
+      url = "https://github.com/dlang/druntime/commit/438990def7e377ca1f87b6d28246673bb38022ab.patch";
+      stripLen = 1;
+      extraPrefix = "druntime/";
+      sha256 = "sha256-/pPKK7ZK9E/mBrxm2MZyBNhYExE8p9jz8JqBdZSE6uY=";
+    })
+  ];
+
+  postPatch = ''
+    patchShebangs dmd/test/{runnable,fail_compilation,compilable,tools}{,/extra-files}/*.sh
+
+    rm dmd/test/runnable/gdb1.d
+    rm dmd/test/runnable/gdb10311.d
+    rm dmd/test/runnable/gdb14225.d
+    rm dmd/test/runnable/gdb14276.d
+    rm dmd/test/runnable/gdb14313.d
+    rm dmd/test/runnable/gdb14330.d
+    rm dmd/test/runnable/gdb15729.sh
+    rm dmd/test/runnable/gdb4149.d
+    rm dmd/test/runnable/gdb4181.d
+
+    # Disable tests that rely on objdump whitespace until fixed upstream:
+    #   https://issues.dlang.org/show_bug.cgi?id=23317
+    rm dmd/test/runnable/cdvecfill.sh
+    rm dmd/test/compilable/cdcmp.d
+
+    # Grep'd string changed with gdb 12
+    #   https://issues.dlang.org/show_bug.cgi?id=23198
+    substituteInPlace druntime/test/exceptions/Makefile \
+      --replace 'in D main (' 'in _Dmain ('
+
+    # We're using gnused on all platforms
+    substituteInPlace druntime/test/coverage/Makefile \
+      --replace 'freebsd osx' 'none'
+  ''
+
+  + lib.optionalString (lib.versionOlder version "2.091.0") ''
+    # This one has tested against a hardcoded year, then against a current year on
+    # and off again. It just isn't worth it to patch all the historical versions
+    # of it, so just remove it until the most recent change.
+    rm dmd/test/compilable/ddocYear.d
+  '' + lib.optionalString (lib.versionAtLeast version "2.089.0" && lib.versionOlder version "2.092.2") ''
+    rm dmd/test/dshell/test6952.d
+  '' + lib.optionalString (lib.versionAtLeast version "2.092.2") ''
+    substituteInPlace dmd/test/dshell/test6952.d --replace "/usr/bin/env bash" "${bash}/bin/bash"
+  ''
+
+  + lib.optionalString stdenv.isLinux ''
+    substituteInPlace phobos/std/socket.d --replace "assert(ih.addrList[0] == 0x7F_00_00_01);" ""
+  '' + lib.optionalString stdenv.isDarwin ''
+    substituteInPlace phobos/std/socket.d --replace "foreach (name; names)" "names = []; foreach (name; names)"
+  '';
+
+  nativeBuildInputs = [
+    makeWrapper
+    which
+    installShellFiles
+  ] ++ lib.optionals (lib.versionOlder version "2.088.0") [
+    git
+  ];
+
+  buildInputs = [
+    curl
+    tzdata
+  ] ++ lib.optionals stdenv.isDarwin [
+    Foundation
+  ];
+
+  checkInputs = [
+    gdb
+  ] ++ lib.optionals (lib.versionOlder version "2.089.0") [
+    unzip
+  ];
+
+  buildFlags = [
+    "BUILD=release"
+    "ENABLE_RELEASE=1"
+    "PIC=1"
+  ];
+
+  # Build and install are based on http://wiki.dlang.org/Building_DMD
+  buildPhase = ''
+    runHook preBuild
+
+    export buildJobs=$NIX_BUILD_CORES
+    if [ -z $enableParallelBuilding ]; then
+      buildJobs=1
+    fi
+
+    make -C dmd -f posix.mak $buildFlags -j$buildJobs HOST_DMD=${HOST_DMD}
+    make -C druntime -f posix.mak $buildFlags -j$buildJobs DMD=${pathToDmd}
+    echo ${tzdata}/share/zoneinfo/ > TZDatabaseDirFile
+    echo ${lib.getLib curl}/lib/libcurl${stdenv.hostPlatform.extensions.sharedLibrary} > LibcurlPathFile
+    make -C phobos -f posix.mak $buildFlags -j$buildJobs DMD=${pathToDmd} DFLAGS="-version=TZDatabaseDir -version=LibcurlPath -J$PWD"
+
+    runHook postBuild
+  '';
+
+  doCheck = true;
+
+  checkFlags = buildFlags;
+
+  # many tests are disbled because they are failing
+
+  # NOTE: Purity check is disabled for checkPhase because it doesn't fare well
+  # with the DMD linker. See https://github.com/NixOS/nixpkgs/issues/97420
+  checkPhase = ''
+    runHook preCheck
+
+    export checkJobs=$NIX_BUILD_CORES
+    if [ -z $enableParallelChecking ]; then
+      checkJobs=1
+    fi
+
+    NIX_ENFORCE_PURITY= \
+      make -C dmd/test $checkFlags CC=$CXX SHELL=$SHELL -j$checkJobs N=$checkJobs
+
+    NIX_ENFORCE_PURITY= \
+      make -C druntime -f posix.mak unittest $checkFlags -j$checkJobs
+
+    NIX_ENFORCE_PURITY= \
+      make -C phobos -f posix.mak unittest $checkFlags -j$checkJobs DFLAGS="-version=TZDatabaseDir -version=LibcurlPath -J$PWD"
+
+    runHook postBuild
+  '';
+
+  installPhase = ''
+    runHook preInstall
+
+    install -Dm755 ${pathToDmd} $out/bin/dmd
+
+    installManPage dmd/docs/man/man*/*
+
+    mkdir -p $out/include/dmd
+    cp -r {druntime/import/*,phobos/{std,etc}} $out/include/dmd/
+
+    mkdir $out/lib
+    cp phobos/generated/${osname}/release/${bits}/libphobos2.* $out/lib/
+
+    wrapProgram $out/bin/dmd \
+      --prefix PATH ":" "${targetPackages.stdenv.cc}/bin" \
+      --set-default CC "${targetPackages.stdenv.cc}/bin/cc"
+
+    substitute ${dmdConfFile} "$out/bin/dmd.conf" --subst-var out
+
+    runHook postInstall
+  '';
+
+  meta = with lib; {
+    description = "Official reference compiler for the D language";
+    homepage = "https://dlang.org/";
+    # Everything is now Boost licensed, even the backend.
+    # https://github.com/dlang/dmd/pull/6680
+    license = licenses.boost;
+    maintainers = with maintainers; [ ThomasMader lionello dukc ];
+    platforms = [ "x86_64-linux" "i686-linux" "x86_64-darwin" ];
+  };
+}

pkgs/development/compilers/fbc/default.nix

···
+{ stdenv
+, buildPackages
+, lib
+, fetchzip
+, fetchpatch
+, gpm
+, libffi
+, libGL
+, libX11
+, libXext
+, libXpm
+, libXrandr
+, ncurses
+}:
+
+stdenv.mkDerivation rec {
+  pname = "fbc";
+  version = "1.09.0";
+
+  src = fetchzip {
+    # Bootstrap tarball has sources pretranslated from FreeBASIC to C
+    url = "https://github.com/freebasic/fbc/releases/download/${version}/FreeBASIC-${version}-source-bootstrap.tar.xz";
+    sha256 = "1q1gxp5kjz4vkcs9jl0x01v8qm1q2j789lgvxvikzd591ay0xini";
+  };
+
+  patches = [
+    # Fixes fbc_tests.udt_wstring_.midstmt ascii getting stuck due to stack corruption
+    # Remove when >1.09.0
+    (fetchpatch {
+      name = "fbc-tests-Fix-stack-corruption.patch";
+      url = "https://github.com/freebasic/fbc/commit/42f4f6dfdaafdd5302a647152f16cda78e4ec904.patch";
+      excludes = [ "changelog.txt" ];
+      sha256 = "sha256-Bn+mnTIkM2/uM2k/b9+Up4HJ7SJWwfD3bWLJsSycFRE=";
+    })
+    # Respect SOURCE_DATE_EPOCH when set
+    # Remove when >1.09.0
+    (fetchpatch {
+      name = "fbc-SOURCE_DATE_EPOCH-support.patch";
+      url = "https://github.com/freebasic/fbc/commit/74ea6efdcfe9a90d1c860f64d11ab4a6cd607269.patch";
+      excludes = [ "changelog.txt" ];
+      sha256 = "sha256-v5FTi4vKOvSV03kigZDiOH8SEGEphhzkBL6p1hd+NtU=";
+    })
+  ];
+
+  postPatch = ''
+    patchShebangs tests/warnings/test.sh
+
+    # Some tests lack proper dependency on libstdc++
+    for missingStdcpp in tests/cpp/{class,call2}-fbc.bas; do
+      sed -i -e "/'"' TEST_MODE : /a #inclib "stdc++"' $missingStdcpp
+    done
+
+    # Help compiler find libstdc++ with gcc backend
+    sed -i -e '/fbcAddLibPathFor( "libgcc.a" )/a fbcAddLibPathFor( "libstdc++.so" )' src/compiler/fbc.bas
+  '';
+
+  dontConfigure = true;
+
+  depsBuildBuild = [
+    buildPackages.stdenv.cc
+    buildPackages.ncurses
+    buildPackages.libffi
+  ];
+
+  buildInputs = [
+    ncurses
+    libffi
+  ] ++ lib.optionals stdenv.hostPlatform.isLinux [
+    gpm
+    libGL
+    libX11
+    libXext
+    libXpm
+    libXrandr
+  ];
+
+  enableParallelBuilding = true;
+
+  hardeningDisable = [
+    "format"
+  ];
+
+  makeFlags = lib.optionals (stdenv.buildPlatform != stdenv.hostPlatform) [
+    "TARGET=${stdenv.hostPlatform.config}"
+  ];
+
+  preBuild = ''
+    export buildJobs=$NIX_BUILD_CORES
+    if [ -z "$enableParallelBuilding" ]; then
+      buildJobs=1
+    fi
+
+    echo Bootstrap an unpatched build compiler
+    make bootstrap-minimal -j$buildJobs \
+      BUILD_PREFIX=${buildPackages.stdenv.cc.targetPrefix} LD=${buildPackages.stdenv.cc.targetPrefix}ld
+
+    echo Compile patched build compiler and host rtlib
+    make compiler -j$buildJobs \
+      "FBC=$PWD/bin/fbc${stdenv.buildPlatform.extensions.executable} -i $PWD/inc" \
+      BUILD_PREFIX=${buildPackages.stdenv.cc.targetPrefix} LD=${buildPackages.stdenv.cc.targetPrefix}ld
+    make rtlib -j$buildJobs \
+      "FBC=$PWD/bin/fbc${stdenv.buildPlatform.extensions.executable} -i $PWD/inc" \
+      ${if (stdenv.buildPlatform == stdenv.hostPlatform) then
+        "BUILD_PREFIX=${buildPackages.stdenv.cc.targetPrefix} LD=${buildPackages.stdenv.cc.targetPrefix}ld"
+      else
+        "TARGET=${stdenv.hostPlatform.config}"
+      }
+
+    echo Install patched build compiler and host rtlib to local directory
+    make install-compiler prefix=$PWD/patched-fbc
+    make install-rtlib prefix=$PWD/patched-fbc ${lib.optionalString (stdenv.buildPlatform != stdenv.hostPlatform) "TARGET=${stdenv.hostPlatform.config}"}
+    make clean
+
+    echo Compile patched host everything with previous patched stage
+    buildFlagsArray+=("FBC=$PWD/patched-fbc/bin/fbc${stdenv.buildPlatform.extensions.executable} -i $PWD/inc")
+  '';
+
+  installFlags = [
+    "prefix=${placeholder "out"}"
+  ];
+
+  # Tests do not work when cross-compiling even if build platform can execute
+  # host binaries, compiler struggles to find the cross compiler's libgcc_s
+  doCheck = stdenv.buildPlatform == stdenv.hostPlatform;
+
+  checkTarget = "unit-tests warning-tests log-tests";
+
+  checkFlags = [
+    "UNITTEST_RUN_ARGS=--verbose" # see what unit-tests are doing
+    "ABORT_CMD=false" # abort log-tests on failure
+  ];
+
+  checkPhase = ''
+    runHook preCheck
+
+    # Some tests fail with too much parallelism
+    export maxCheckJobs=50
+    export checkJobs=$(($NIX_BUILD_CORES<=$maxCheckJobs ? $NIX_BUILD_CORES : $maxCheckJobs))
+    if [ -z "$enableParallelChecking" ]; then
+      checkJobs=1
+    fi
+
+    # Run check targets in series, else the logs are a mess
+    for target in $checkTarget; do
+      make $target -j$checkJobs $makeFlags $checkFlags
+    done
+
+    runHook postCheck
+  '';
+
+  meta = with lib; {
+    homepage = "https://www.freebasic.net/";
+    description = "A multi-platform BASIC Compiler";
+    longDescription = ''
+      FreeBASIC is a completely free, open-source, multi-platform BASIC compiler (fbc),
+      with syntax similar to (and support for) MS-QuickBASIC, that adds new features
+      such as pointers, object orientation, unsigned data types, inline assembly,
+      and many others.
+    '';
+    license = licenses.gpl2Plus; # runtime & graphics libraries are LGPLv2+ w/ static linking exception
+    maintainers = with maintainers; [ OPNA2608 ];
+    platforms = with platforms; windows ++ linux;
+  };
+}

pkgs/development/compilers/fbc/mac-bin.nix

···
+{ stdenvNoCC
+, lib
+, fetchzip
+}:
+
+stdenvNoCC.mkDerivation rec {
+  pname = "fbc-mac-bin";
+  version = "1.06-darwin-wip20160505";
+
+  src = fetchzip {
+    url = "https://tmc.castleparadox.com/temp/fbc-${version}.tar.bz2";
+    sha256 = "sha256-hD3SRUkk50sf0MhhgHNMvBoJHTKz/71lyFxaAXM4/qI=";
+  };
+
+  dontConfigure = true;
+  dontBuild = true;
+
+  installPhase = ''
+    runHook preInstall
+
+    mkdir -p $out
+    cp -R * $out
+
+    runHook postInstall
+  '';
+
+  meta = with lib; {
+    homepage = "https://rpg.hamsterrepublic.com/ohrrpgce/Compiling_in_Mac_OS_X";
+    description = "FreeBASIC, a multi-platform BASIC Compiler (precompiled Darwin build by OHRRPGCE team)";
+    sourceProvenance = with sourceTypes; [ binaryNativeCode ];
+    license = licenses.gpl2Plus; # runtime & graphics libraries are LGPLv2+ w/ static linking exception
+    maintainers = with maintainers; [ OPNA2608 ];
+    platforms = [ "x86_64-darwin" ];
+  };
+}

pkgs/development/compilers/ldc/bootstrap.nix

···
   version = "1.25.0";
   hashes = {
     # Get these from `nix-prefetch-url https://github.com/ldc-developers/ldc/releases/download/v1.19.0/ldc2-1.19.0-osx-x86_64.tar.xz` etc..
-    osx-x86_64 = "1xaqxf1lz8kdb0n5iycfpxpvabf1zy0akg14kg554sm85xnsf8pa";
-    linux-x86_64 = "1shzdq564jg3ga1hwrvpx30lpszc6pqndqndr5mqmc352znkiy5i";
-    linux-aarch64  = "04i4xxwhq02d98r3qrrnv5dbd4xr4d7ph3zv94z2m58z3vgphdjh";
-    osx-arm64  = "0b0cpgzn23clggx0cvdaja29q7w7ihkmjbnf1md03h9h5nzp9z1v";
+    osx-x86_64 = "sha256-6iKnbS+oalLKmyS8qYD/wS21b7+O+VgsWG2iT4PrWPU=";
+    linux-x86_64 = "sha256-sfg47RdlsIpryc3iZvE17OtLweh3Zw6DeuNJYgpuH+o=";
+    linux-aarch64  = "sha256-UDZ43x4flSo+SfsPeE8juZO2Wtk2ZzwySk0ADHnvJBI=";
+    osx-arm64  = "sha256-O/x0vy0wwQFaDc4uWSeMhx+chJKqbQb6e5QNYf+7DCw=";
   };
 }

pkgs/development/compilers/ldc/default.nix

···
 import ./generic.nix {
-  version = "1.27.1";
-  ldcSha256 = "1775001ba6n8w46ln530kb5r66vs935ingnppgddq8wqnc0gbj4k";
+  version = "1.30.0";
+  sha256 = "sha256-/bs3bwgkLZF5IqaiKnc5gCF/r6MQBG/F1kWUkK8j2s0=";
 }

pkgs/development/compilers/ldc/generic.nix

···
-{ version, ldcSha256 }:
+{ version, sha256 }:
 { lib, stdenv, fetchurl, cmake, ninja, llvm_11, curl, tzdata
 , libconfig, lit, gdb, unzip, darwin, bash
 , callPackage, makeWrapper, runCommand, targetPackages
···
 
   src = fetchurl {
     url = "https://github.com/ldc-developers/ldc/releases/download/v${version}/ldc-${version}-src.tar.gz";
-    sha256 = ldcSha256;
+    inherit sha256;
   };
 
   # https://issues.dlang.org/show_bug.cgi?id=19553

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

···
 
   # Requires pg_ctl command during tests
   beam-postgres = overrideCabal (drv: {
+    # https://github.com/NixOS/nixpkgs/issues/198495
+    doCheck = pkgs.postgresql.doCheck;
     testToolDepends = (drv.testToolDepends or []) ++ [pkgs.postgresql];
   }) super.beam-postgres;
 
···
           sed -i test/PostgreSQL/Test.hs \
             -e s^host=localhost^^
         '';
+        # https://github.com/NixOS/nixpkgs/issues/198495
+        doCheck = pkgs.postgresql.doCheck;
         # Match the test suite defaults (or hardcoded values?)
         preCheck = drv.preCheck or "" + ''
           PGUSER=esqutest
···
           sed -i test/PgInit.hs \
             -e s^'host=" <> host <> "'^^
         '';
+        # https://github.com/NixOS/nixpkgs/issues/198495
+        doCheck = pkgs.postgresql.doCheck;
         preCheck = drv.preCheck or "" + ''
           PGDATABASE=test
           PGUSER=test
···
     testToolDepends = drv.testToolDepends or [] ++ [
       pkgs.postgresql pkgs.postgresqlTestHook
     ];
+    # https://github.com/NixOS/nixpkgs/issues/198495
+    doCheck = pkgs.postgresql.doCheck;
     preCheck = drv.preCheck or "" + ''
       # empty string means use default connection
       export DATABASE_URL=""
···
     hlint = enableCabalFlag "ghc-lib" lself.hlint_3_4_1;
     ghc-lib-parser-ex = self.ghc-lib-parser-ex_9_2_0_4;
     ghc-lib-parser = lself.ghc-lib-parser_9_2_4_20220729;
+    # For most ghc versions, we overrideScope Cabal in the configuration-ghc-???.nix,
+    # because some packages, like ormolu, need a newer Cabal version.
+    # ghc-paths is special because it depends on Cabal for building
+    # its Setup.hs, and therefor declares a Cabal dependency, but does
+    # not actually use it as a build dependency.
+    # That means ghc-paths can just use the ghc included Cabal version,
+    # without causing package-db incoherence and we should do that because
+    # otherwise we have different versions of ghc-paths
+    # around with have the same abi-hash, which can lead to confusions and conflicts.
+    ghc-paths = lsuper.ghc-paths.override { Cabal = null; };
   });
 
   hls-hlint-plugin = super.hls-hlint-plugin.overrideScope (lself: lsuper: {
···
   # 2022-09-19: https://github.com/haskell/haskell-language-server/issues/3200
   hls-refactor-plugin = dontCheck super.hls-refactor-plugin;
 
+  # 2022-10-27: implicit-hie 0.1.3.0 needs a newer version of Cabal-syntax.
+  implicit-hie = super.implicit-hie.override {
+    Cabal-syntax = self.Cabal-syntax_3_8_1_0;
+  };
+
   # 2021-03-21: Test hangs
   # https://github.com/haskell/haskell-language-server/issues/1562
   # 2021-11-13: Too strict upper bound on implicit-hie-cradle
···
 
   # 2021-04-02: Outdated optparse-applicative bound is fixed but not realeased on upstream.
   trial-optparse-applicative = assert super.trial-optparse-applicative.version == "0.0.0.0"; doJailbreak super.trial-optparse-applicative;
-
-  # 2021-04-02: Outdated optparse-applicative bound is fixed but not realeased on upstream.
-  extensions = assert super.extensions.version == "0.0.0.1"; doJailbreak super.extensions;
 
   # 2021-04-02: iCalendar is basically unmaintained.
   # There are PRs for bumping the bounds: https://github.com/chrra/iCalendar/pull/46
···
   csv = overrideCabal (drv: { preCompileBuildDriver = "rm Setup.hs"; }) super.csv;
 
   cabal-fmt = doJailbreak (super.cabal-fmt.override {
-    # Needs newer Cabal-syntex version.
+    # Needs newer Cabal-syntax version.
     Cabal-syntax = self.Cabal-syntax_3_8_1_0;
   });
 
···
     testTarget = "regex-tdfa-unittest";
   } super.regex-tdfa;
 
+  # Missing test files https://github.com/qrilka/xlsx/issues/165
+  xlsx = dontCheck super.xlsx;
+
+  # Missing test files https://github.com/kephas/xdg-basedir-compliant/issues/1
+  xdg-basedir-compliant = dontCheck super.xdg-basedir-compliant;
+
   # 2022-09-01:
   # Restrictive upper bound on base.
   # Remove once version 1.* is released
···
   purescript =
     lib.pipe
       (super.purescript.overrideScope purescriptOverlay)
-      [
+      ([
         # PureScript uses nodejs to run tests, so the tests have been disabled
         # for now.  If someone is interested in figuring out how to get this
         # working, it seems like it might be possible.
···
         doJailbreak
         # Generate shell completions
         (self.generateOptparseApplicativeCompletions [ "purs" ])
-      ];
+      ] ++ lib.optionals (lib.versions.majorMinor self.ghc.version == "9.2") [
+        markUnbroken
+        doDistribute
+      ]);
 
   purescript-cst = purescriptStOverride super.purescript-cst;
 

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

···
   cabal-install = super.cabal-install.overrideScope (self: super: {
     Cabal = self.Cabal_3_8_1_0;
     Cabal-syntax = self.Cabal-syntax_3_8_1_0;
-    process = self.process_1_6_15_0;
+    process = self.process_1_6_16_0;
   });
   cabal-install-solver = super.cabal-install-solver.overrideScope (self: super: {
     Cabal = self.Cabal_3_8_1_0;
     Cabal-syntax = self.Cabal-syntax_3_8_1_0;
-    process = self.process_1_6_15_0;
+    process = self.process_1_6_16_0;
   });
 
   # Pick right versions for GHC-specific packages

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

···
   cabal-install = super.cabal-install.overrideScope (self: super: {
     Cabal = self.Cabal_3_8_1_0;
     Cabal-syntax = self.Cabal-syntax_3_8_1_0;
-    process = self.process_1_6_15_0;
+    process = self.process_1_6_16_0;
   });
   cabal-install-solver = super.cabal-install-solver.overrideScope (self: super: {
     Cabal = self.Cabal_3_8_1_0;
     Cabal-syntax = self.Cabal-syntax_3_8_1_0;
-    process = self.process_1_6_15_0;
+    process = self.process_1_6_16_0;
   });
 
   # Ignore overly restrictive upper version bounds.

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

···
   cabal-install = super.cabal-install.overrideScope (self: super: {
     Cabal = self.Cabal_3_8_1_0;
     Cabal-syntax = self.Cabal-syntax_3_8_1_0;
-    process = self.process_1_6_15_0;
+    process = self.process_1_6_16_0;
   });
   cabal-install-solver = super.cabal-install-solver.overrideScope (self: super: {
     Cabal = self.Cabal_3_8_1_0;
     Cabal-syntax = self.Cabal-syntax_3_8_1_0;
-    process = self.process_1_6_15_0;
+    process = self.process_1_6_16_0;
   });
 
   # Jailbreaks & Version Updates

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

···
   cabal-install = super.cabal-install.overrideScope (self: super: {
     Cabal = self.Cabal_3_8_1_0;
     Cabal-syntax = self.Cabal-syntax_3_8_1_0;
-    process = self.process_1_6_15_0;
+    process = self.process_1_6_16_0;
   });
   cabal-install-solver = super.cabal-install-solver.overrideScope (self: super: {
     Cabal = self.Cabal_3_8_1_0;
     Cabal-syntax = self.Cabal-syntax_3_8_1_0;
-    process = self.process_1_6_15_0;
+    process = self.process_1_6_16_0;
   });
 
   doctest = dontCheck (doJailbreak super.doctest);
···
   constraints = doJailbreak super.constraints;
   cpphs = overrideCabal (drv: { postPatch = "sed -i -e 's,time >=1.5 && <1.11,time >=1.5 \\&\\& <1.12,' cpphs.cabal";}) super.cpphs;
   data-fix = doJailbreak super.data-fix;
-  dbus = self.dbus_1_2_26;
+  dbus = self.dbus_1_2_27;
   dec = doJailbreak super.dec;
   ed25519 = doJailbreak super.ed25519;
   ghc-byteorder = doJailbreak super.ghc-byteorder;
···
   singleton-bool = doJailbreak super.singleton-bool;
   servant = doJailbreak super.servant;
   servant-swagger = doJailbreak super.servant-swagger;
+
+  # Depends on utf8-light which isn't maintained / doesn't support base >= 4.16
+  # https://github.com/haskell-infra/hackage-trustees/issues/347
+  # https://mail.haskell.org/pipermail/haskell-cafe/2022-October/135613.html
+  language-javascript_0_7_0_0 = dontCheck super.language-javascript_0_7_0_0;
 
   # 2022-09-02: Too strict bounds on lens
   # https://github.com/haskell-servant/servant/pull/1607/files

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

···
 
 with haskellLib;
 self: super: let
-  doctest_0_20_broken = p: checkAgainAfter self.doctest "0.20.0" "doctest broken on 9.4" (dontCheck p);
   jailbreakForCurrentVersion = p: v: checkAgainAfter p v "bad bounds" (doJailbreak p);
 in {
   llvmPackages = lib.dontRecurseIntoAttrs self.ghc.llvmPackages;
···
   # 0.30 introduced support for GHC 9.2.
   cryptonite = doDistribute self.cryptonite_0_30;
 
-  # Too strict bound on base
-  # https://github.com/haskell/cabal/issues/8509
-  # Requested versions of Cabal, Cabal-syntax and process match GHC 9.4's for now
-  cabal-install = doJailbreak super.cabal-install;
-  cabal-install-solver = doJailbreak super.cabal-install-solver;
-
-  # Test failure due to new Cabal 3.8 version. Since the failure only pertains
-  # to a change in how Cabal internally represents some platforms and we depend
-  # on the type of representation anywhere, this failure is harmless. Can be
-  # removed after https://github.com/NixOS/cabal2nix/pull/571 is merged.
-  # TODO(@sternenseemann): merge and release a fixed version
-  distribution-nixpkgs = dontCheck super.distribution-nixpkgs;
   cabal2nix =
     # cabal2nix depends on foundation, which is broken on aarch64-linux.
     # https://github.com/haskell-foundation/foundation/issues/571
     overrideCabal
       (drv: { badPlatforms = [ "aarch64-linux" ]; })
-      (dontCheck super.cabal2nix);
-  cabal2nix-unstable = dontCheck super.cabal2nix-unstable;
+      super.cabal2nix;
 
-  # build fails on due to ghc api changes
-  # unfinished PR that doesn't yet compile:
-  # https://github.com/sol/doctest/pull/375
-  doctest = markBroken super.doctest_0_20_0;
+  doctest = self.doctest_0_20_1;
   # consequences of doctest breakage follow:
-  http-types = doctest_0_20_broken super.http-types;
-  iproute = doctest_0_20_broken super.iproute;
-  foldl = doctest_0_20_broken super.foldl;
-  prettyprinter-ansi-terminal = doctest_0_20_broken super.prettyprinter-ansi-terminal;
-  pretty-simple = doctest_0_20_broken super.pretty-simple;
-  http-date = doctest_0_20_broken super.http-date;
-  network-byte-order = doctest_0_20_broken super.network-byte-order;
-  co-log-core = doctest_0_20_broken (doJailbreak super.co-log-core);
-  xml-conduit = doctest_0_20_broken (dontCheck super.xml-conduit);
-  validation-selective = doctest_0_20_broken (dontCheck super.validation-selective);
 
   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);
···
   lucid = jailbreakForCurrentVersion super.lucid "2.11.1";
   invariant = jailbreakForCurrentVersion super.invariant "0.5.6";
   implicit-hie-cradle = jailbreakForCurrentVersion super.implicit-hie-cradle "0.5.0.0";
+  # https://github.com/co-log/co-log-core/pull/22#issuecomment-1294040208
+  co-log-core = jailbreakForCurrentVersion super.co-log-core "0.3.1.0";
 
   haskell-src-meta = doJailbreak super.haskell-src-meta;
 
···
   # Jailbreaks & Version Updates
 
   aeson = self.aeson_2_1_1_0;
-  aeson-diff = doctest_0_20_broken (dontCheck super.aeson-diff);
   lens-aeson = self.lens-aeson_1_2_2;
 
   assoc = doJailbreak super.assoc;
···
 
   # 2022-09-02: Too strict bounds on lens
   # https://github.com/GetShopTV/swagger2/pull/242
-  swagger2 = doctest_0_20_broken (dontCheck (doJailbreak super.swagger2));
+  swagger2 = doJailbreak super.swagger2;
 
   base-orphans = dontCheck super.base-orphans;
 

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

···
   - avatar-generator
   - aviation-units
   - avl-static
+  - avro
   - avro-piper
   - avr-shake
   - avwx
···
   - codo-notation
   - coin
   - coinbase-pro
+  - cointracking-imports
   - collada-output
   - collapse-util
   - collections
···
   - djinn-th
   - dmcc
   - dmenu
+  - dnf-repo
   - dns-patterns
   - dnsrbl
   - dnssd
···
   - edit
   - edit-lenses
   - editline
+  - effectful-st
   - effect-handlers
   - effective-aspects
   - effect-monad
···
   - eventful-sql-common
   - eventsource-api
   - eventstore
+  - eventuo11y
+  - eventuo11y-dsl
   - evoke
   - ewe
   - exact-cover
···
   - extended-containers
   - extensible-effects-concurrent
   - extensible-skeleton
-  - extensions
   - Extra
   - extractelf
   - ez3
···
   - hquantlib
   - hquery
   - hR
+  - h-raylib
   - hreq-core
   - h-reversi
   - hricket
···
   - monoid-owns
   - monoidplus
   - monoids
+  - monomer-hagrid
   - monopati
   - monus
   - monzo
···
   - Omega
   - om-elm
   - om-fail
+  - om-fork
   - om-http
   - om-http-logging
   - omnifmt
···
   - Pup-Events-Server
   - pure-io
   - pure-priority-queue
+  - purescript
   - purescript-tsd-gen
   - pure-zlib
   - pushbullet
···
   - Tablify
   - tabloid
   - tabs
-  - taffybar
   - tag-bits
   - tagged-exception-core
   - tagged-timers
···
   - unescaping-print
   - unfix-binders
   - unfoldable
+  - unicode-data-names
+  - unicode-data-scripts
+  - unicode-data-security
   - unicode-prelude
   - unicode-symbols
   - unicode-tricks
···
   - xleb
   - xls
   - xlsior
+  - xlsx-tabular
   - xlsx-templater
   - xml2json
   - xml-conduit-decode

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

···
     - rel8
     - regex-rure
     - jacinda
+    - citeproc
     # owothia
     - irc-client
     - chatter

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

···
-# Stackage LTS 19.28
+# Stackage LTS 19.30
 # This file is auto-generated by
 # maintainers/scripts/haskell/update-stackage.sh
 default-package-overrides:
···
   - executable-path ==0.0.3.1
   - exit-codes ==1.0.0
   - exomizer ==1.0.0
-  - experimenter ==0.1.0.12
+  - experimenter ==0.1.0.14
   - expiring-cache-map ==0.0.6.1
   - explainable-predicates ==0.1.2.3
   - explicit-exception ==0.1.10
···
   - fakedata-quickcheck ==0.2.0
   - fakefs ==0.3.0.2
   - fakepull ==0.3.0.2
-  - faktory ==1.1.2.3
+  - faktory ==1.1.2.4
   - fast-builder ==0.1.3.0
   - fast-logger ==3.1.1
   - fast-math ==1.0.2
···
   - ghc-syntax-highlighter ==0.0.7.0
   - ghc-tcplugins-extra ==0.4.3
   - ghc-trace-events ==0.1.2.6
-  - ghc-typelits-extra ==0.4.3
-  - ghc-typelits-knownnat ==0.7.6
-  - ghc-typelits-natnormalise ==0.7.6
+  - ghc-typelits-extra ==0.4.4
+  - ghc-typelits-knownnat ==0.7.7
+  - ghc-typelits-natnormalise ==0.7.7
   - ghc-typelits-presburger ==0.6.2.0
   - ghost-buster ==0.1.1.0
-  - gi-atk ==2.0.24
-  - gi-cairo ==1.0.26
+  - gi-atk ==2.0.25
+  - gi-cairo ==1.0.27
   - gi-cairo-connector ==0.1.1
-  - gi-cairo-render ==0.1.1
-  - gi-dbusmenu ==0.4.10
-  - gi-dbusmenugtk3 ==0.4.11
-  - gi-freetype2 ==2.0.1
-  - gi-gdk ==3.0.25
-  - gi-gdkpixbuf ==2.0.28
-  - gi-gdkx11 ==3.0.12
-  - gi-gio ==2.0.29
-  - gi-glib ==2.0.26
-  - gi-gmodule ==2.0.2
-  - gi-gobject ==2.0.27
-  - gi-graphene ==1.0.4
-  - gi-gtk ==3.0.38
-  - gi-gtk-hs ==0.3.12
-  - gi-gtksource ==3.0.25
-  - gi-harfbuzz ==0.0.6
-  - gi-javascriptcore ==4.0.24
+  - gi-cairo-render ==0.1.2
+  - gi-dbusmenu ==0.4.11
+  - gi-dbusmenugtk3 ==0.4.12
+  - gi-freetype2 ==2.0.2
+  - gi-gdk ==3.0.26
+  - gi-gdkpixbuf ==2.0.29
+  - gi-gdkx11 ==3.0.13
+  - gi-gio ==2.0.30
+  - gi-glib ==2.0.27
+  - gi-gmodule ==2.0.3
+  - gi-gobject ==2.0.28
+  - gi-graphene ==1.0.5
+  - gi-gtk ==3.0.39
+  - gi-gtk-hs ==0.3.13
+  - gi-gtksource ==3.0.26
+  - gi-harfbuzz ==0.0.7
+  - gi-javascriptcore ==4.0.25
   - ginger ==0.10.4.0
-  - gi-pango ==1.0.26
+  - gi-pango ==1.0.27
   - githash ==0.1.6.2
   - github ==0.27
   - github-release ==2.0.0.2
···
   - github-types ==0.2.1
   - github-webhooks ==0.15.0
   - gitrev ==1.3.1
-  - gi-vte ==2.91.29
-  - gi-xlib ==2.0.11
+  - gi-vte ==2.91.30
+  - gi-xlib ==2.0.12
   - gl ==0.9
-  - glabrous ==2.0.5
+  - glabrous ==2.0.6
   - glasso ==0.1.0
   - GLFW-b ==3.3.0.0
   - Glob ==0.10.2
···
   - haskeline ==0.8.2
   - haskell-awk ==1.2.0.1
   - haskell-gi ==0.26.1
-  - haskell-gi-base ==0.26.1
+  - haskell-gi-base ==0.26.2
   - haskell-gi-overloading ==1.0
   - haskell-lexer ==1.1
   - haskell-lsp-types ==0.24.0.0
···
   - has-transformers ==0.1.0.4
   - hasty-hamiltonian ==1.3.4
   - HaTeX ==3.22.3.1
-  - HaXml ==1.25.11
+  - HaXml ==1.25.12
   - haxr ==3000.11.4.1
   - HCodecs ==0.5.2
   - hdaemonize ==0.5.6
···
   - lazysmallcheck ==0.6
   - lca ==0.4
   - leancheck ==0.9.12
-  - leancheck-instances ==0.0.4
+  - leancheck-instances ==0.0.5
   - leapseconds-announced ==2017.1.0.1
   - learn-physics ==0.6.5
   - lens ==5.0.1
···
   - mock-time ==0.1.0
   - mod ==0.1.2.2
   - model ==0.5
-  - modern-uri ==0.3.4.4
+  - modern-uri ==0.3.5.0
   - modular ==0.1.0.8
   - monad-chronicle ==1.0.1
   - monad-control ==1.0.3.1
···
   - monads-tf ==0.1.0.3
   - monad-time ==0.3.1.0
   - mongoDB ==2.7.1.1
-  - monoidal-containers ==0.6.2.0
+  - monoidal-containers ==0.6.3.0
   - monoid-extras ==0.6.1
   - monoid-subclasses ==1.1.3
   - monoid-transformer ==0.0.4
···
   - network-simple-tls ==0.4
   - network-transport ==0.5.4
   - network-transport-composed ==0.2.1
-  - network-transport-tcp ==0.8.0
-  - network-transport-tests ==0.3.0
+  - network-transport-tcp ==0.8.1
+  - network-transport-tests ==0.3.1
   - network-uri ==2.6.4.1
   - network-wait ==0.1.2.0
   - newtype ==0.2.2.0
···
   - partial-isomorphisms ==0.2.3.0
   - partial-order ==0.2.0.0
   - partial-semigroup ==0.5.1.14
-  - password ==3.0.1.0
+  - password ==3.0.2.0
   - password-instances ==3.0.0.0
   - password-types ==1.0.0.0
   - pasta-curves ==0.0.1.0
···
   - pava ==0.1.1.4
   - pcg-random ==0.1.3.7
   - pcre2 ==2.1.1.1
-  - pcre-heavy ==1.0.0.2
+  - pcre-heavy ==1.0.0.3
   - pcre-light ==0.4.1.0
   - pcre-utils ==0.1.8.2
   - pdc ==0.1.1
···
   - phatsort ==0.5.0.1
   - picosat ==0.1.6
   - pid1 ==0.1.3.0
-  - pinch ==0.4.1.2
+  - pinch ==0.4.2.0
   - pipes ==4.3.16
   - pipes-attoparsec ==0.5.1.5
   - pipes-bytestring ==2.1.7
···
   - polysemy-plugin ==0.4.1.1
   - polysemy-several ==0.1.1.0
   - polysemy-socket ==0.0.2.0
-  - polysemy-uncontrolled ==0.1.1.0
+  - polysemy-uncontrolled ==0.1.1.1
   - polysemy-video ==0.2.0.1
   - polysemy-vinyl ==0.1.5.0
   - polysemy-webserver ==0.2.1.1
···
   - svg-builder ==0.1.1
   - SVGFonts ==1.8.0.1
   - svg-tree ==0.6.2.4
-  - swagger2 ==2.8.4
+  - swagger2 ==2.8.5
   - swish ==0.10.2.0
   - syb ==0.7.2.2
   - sydtest-discover ==0.0.0.2
···
   - type-spec ==0.4.0.0
   - typography-geometry ==1.0.1.0
   - tz ==0.1.3.6
-  - tzdata ==0.2.20220923.0
+  - tzdata ==0.2.20221011.0
   - ua-parser ==0.7.7.0
   - uglymemo ==0.1.0.1
   - unagi-chan ==0.4.1.4
···
   - unicode-transforms ==0.4.0.1
   - unidecode ==0.1.0.4
   - unification-fd ==0.11.2
-  - union ==0.1.2
   - union-angle ==0.1.0.1
   - union-find ==0.2
   - unipatterns ==0.0.0.0
···
   - vector-th-unbox ==0.2.2
   - vectortiles ==1.5.1
   - verbosity ==0.4.0.0
-  - versions ==5.0.3
+  - versions ==5.0.4
   - vformat ==0.14.1.0
   - vformat-time ==0.1.0.0
   - ViennaRNAParser ==1.3.3

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

···
  - KiCS-debugger
  - KiCS-prophecy
  - LDAPv3
+ - LPPaver
  - LambdaHack
  - LambdaINet
  - LambdaPrettyQuote
···
  - blubber
  - bluetile
  - blunt
+ - bnb-staking-csvs
  - bno055-haskell
  - bogre-banana
  - boilerplate
···
  - cheapskate-terminal
  - check-pvp
  - chevalier-common
+ - chiasma-test
  - chitauri
  - choose-exe
  - chorale-geo
···
  - eventsource-geteventstore-store
  - eventsource-store-specs
  - eventsource-stub-store
+ - eventuo11y-batteries
+ - eventuo11y-json
  - every-bit-counts
  - exception-monads-fd
  - exference
···
  - gi-ges
  - gi-gsk
  - gi-gstpbutils
- - gi-gtk_4_0_5
+ - gi-gtk_4_0_6
  - gipeda
  - git-config
  - git-fmt
···
  - hpaste
  - hpc-tracer
  - hplayground
+ - hpqtypes-effectful
  - hpqtypes-extras
  - hprotoc-fork
  - hps
···
  - hsfacter
  - hsinspect-lsp
  - hslogstash
+ - hslua-module-zip
  - hsnsq
  - hspec-expectations-pretty
  - hspec-pg-transact
···
  - huzzy
  - hw-all
  - hw-aws-sqs-conduit
+ - hw-kafka-avro
  - hw-uri
  - hworker-ses
  - hwormhole
···
  - indentation-parsec
  - indentation-trifecta
  - indexation
- - indieweb-algorithms
  - indigo
  - infernu
  - infinity
···
  - lambdiff
  - lang
  - language-Modula2
+ - language-avro
  - language-boogie
  - language-ecmascript-analysis
  - language-eiffel
···
  - metar-http
  - metronome
  - micro-gateway
- - microformats2-parser
  - microformats2-types
  - midimory
  - mighttpd
···
  - morpheus-graphql-cli
  - morpheus-graphql-client
  - morpheus-graphql-code-gen
+ - morpheus-graphql-code-gen-utils
+ - morpheus-graphql-server
  - morpheus-graphql-subscriptions
  - morphisms-functors-inventory
  - mortred
···
  - pisigma
  - pitchtrack
  - pkgtreediff
+ - pkgtreediff_0_6_0
  - planet-mitchell
  - playlists-http
  - plocketed
···
  - ribosome-host
  - ribosome-host-test
  - ribosome-root
+ - ribosome-test
  - ridley-extras
  - rio-process-pool
  - riot
···
  - skeletons
  - sketch-frp-copilot
  - skylark-client
- - skylighting_0_13
+ - skylighting_0_13_1
  - slate
  - slidemews
  - slip32
···
  - sock2stream
  - socket-io
  - sockets
+ - solana-staking-csvs
  - solga-swagger
  - solr
  - souffle-dsl

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

···
 # If you have an override of this kind, see configuration-common.nix instead.
 { pkgs, haskellLib }:
 
+let
+  inherit (pkgs) lib;
+in
+
 with haskellLib;
 
 # All of the overrides in this set should look like:
···
   # Tests access internet
   prune-juice = dontCheck super.prune-juice;
 
+  citeproc = lib.pipe super.citeproc [
+    enableSeparateBinOutput
+    # Enable executable being built and add missing dependencies
+    (enableCabalFlag "executable")
+    (addBuildDepends [ self.aeson-pretty ])
+    # TODO(@sternenseemann): we may want to enable that for improved performance
+    # Is correctness good enough since 0.5?
+    (disableCabalFlag "icu")
+  ];
+
   # based on https://github.com/gibiansky/IHaskell/blob/aafeabef786154d81ab7d9d1882bbcd06fc8c6c4/release.nix
   ihaskell = overrideCabal (drv: {
     # ihaskell's cabal file forces building a shared executable, which we need
···
       '';
     }) super.nvfetcher);
 
-  rel8 = addTestToolDepend pkgs.postgresql super.rel8;
+  rel8 = pkgs.lib.pipe super.rel8 [
+    (addTestToolDepend pkgs.postgresql)
+    # https://github.com/NixOS/nixpkgs/issues/198495
+    (overrideCabal { doCheck = pkgs.postgresql.doCheck; })
+  ];
 
   cachix = self.generateOptparseApplicativeCompletions [ "cachix" ] (super.cachix.override { nix = pkgs.nixVersions.nix_2_9; });
 
···
   # Make sure that Cabal 3.8.* can be built as-is
   Cabal_3_8_1_0 = doDistribute (super.Cabal_3_8_1_0.override {
     Cabal-syntax = self.Cabal-syntax_3_8_1_0;
-    process = self.process_1_6_15_0;
+    process = self.process_1_6_16_0;
   });
 
   # cabal-install switched to build type simple in 3.2.0.0

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

···
      }:
      mkDerivation {
        pname = "Blammo";
-       version = "1.0.2.3";
-       sha256 = "1c113fdjwfbh01n3xsprya4dp6wc4m9xvilx9fyb3lbzdmmii624";
+       version = "1.1.0.0";
+       sha256 = "02j49dzwlx0p39njspz10vbj5qybb1l2l2lk4gdrbicp953czaa8";
        libraryHaskellDepends = [
          aeson base bytestring case-insensitive clock containers dlist
          envparse exceptions fast-logger http-types lens monad-logger-aeson
···
        pname = "HStringTemplate";
        version = "0.8.8";
        sha256 = "1n8ci0kzjcgnqh4dfpqwlh7mnlzyiqiqc6hc0zr65p0balbg8zbi";
-       revision = "2";
-       editedCabalFile = "1iq8ni7im7b0q3hpchyc9j7iw1r431xlikwsqlhiwnw61q2c5qi5";
+       revision = "3";
+       editedCabalFile = "0316jr5npssxxxj85x74vasvm2ib09mjv2jy7abwjs7cfqbpnr8w";
        libraryHaskellDepends = [
          array base blaze-builder bytestring containers deepseq directory
          filepath mtl old-locale parsec pretty semigroups syb
···
      }:
      mkDerivation {
        pname = "HaXml";
-       version = "1.25.11";
-       sha256 = "1l5kmiqvnqzdzz3jyaphy7ckglm6jhn0b10kf47yizv0w496bmjg";
+       version = "1.25.12";
+       sha256 = "1xaqp519dw948v00q309msx07yhzxbd0k8ds5q434l6g6cmsqqgc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "LPPaver" = callPackage
+    ({ mkDerivation, aern2-mfun, aern2-mp, base, collect-errors
+     , containers, directory, mixed-types-num, optparse-applicative
+     , parallel, pqueue, PropaFP, simplex-method
+     }:
+     mkDerivation {
+       pname = "LPPaver";
+       version = "0.0.3.1";
+       sha256 = "0avnvdd538akcf8dsybyp4k3sb539n38d0vv6fv7psvhz8bwbr7a";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aern2-mfun aern2-mp base collect-errors containers directory
+         mixed-types-num optparse-applicative parallel pqueue PropaFP
+         simplex-method
+       ];
+       executableHaskellDepends = [
+         aern2-mfun aern2-mp base collect-errors containers directory
+         mixed-types-num optparse-applicative parallel pqueue PropaFP
+         simplex-method
+       ];
+       testHaskellDepends = [
+         aern2-mfun aern2-mp base collect-errors containers directory
+         mixed-types-num optparse-applicative parallel pqueue PropaFP
+         simplex-method
+       ];
+       description = "An automated prover targeting problems that involve nonlinear real arithmetic";
+       license = lib.licenses.mpl20;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "lppaver";
+     }) {};
+
   "LParse" = callPackage
     ({ mkDerivation, base, containers }:
      mkDerivation {
···
      }) {};
 
   "Monadoro" = callPackage
-    ({ mkDerivation, ansi-terminal, base, doctest, hspec, process, time
-     }:
+    ({ mkDerivation, base, doctest, hspec, process, time }:
      mkDerivation {
        pname = "Monadoro";
-       version = "0.2.8.1";
-       sha256 = "0w0wjxvg36y1qdvljqlg2l4dw5jwbhmm1q6979rns6ncvlyjyyvn";
+       version = "0.3.3.0";
+       sha256 = "1zya572cc0gml4k9mm2g9z5bakjzz6ivigdc9fpv2bsrnc58a4y4";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
-       libraryHaskellDepends = [ ansi-terminal base process time ];
-       executableHaskellDepends = [ ansi-terminal base process time ];
-       testHaskellDepends = [
-         ansi-terminal base doctest hspec process time
-       ];
+       libraryHaskellDepends = [ base process time ];
+       executableHaskellDepends = [ base process time ];
+       testHaskellDepends = [ base doctest hspec process time ];
        description = "A minimalistic CLI Pomodoro timer";
        license = lib.licenses.mit;
        mainProgram = "monadoro";
···
      }:
      mkDerivation {
        pname = "PropaFP";
-       version = "0.1.0.0";
-       sha256 = "1rq39yciyqrzc2ky9w0phg6m00m106mng6vf586rl3yd9v83makg";
+       version = "0.1.1.0";
+       sha256 = "0r69x9i5iq740y6r7v3i86q7vx19qwrad0klmi3iy7a0g7wa5ldy";
+       revision = "1";
+       editedCabalFile = "0sx7198rx2ajcp6mn0ym474h24fizf1cbw0skyw8fanri7jr2i41";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "PyF";
        version = "0.10.2.0";
        sha256 = "0a1bq7c3vx6yp7745xr2vlxjsqgqa0s1f7yzqnfsybqwff03zbcw";
+       revision = "1";
+       editedCabalFile = "0hinbn56d8bw45zxazpmgv1b6lcmlcys9jfdkv2lyr5j44pzpvvj";
        libraryHaskellDepends = [
          base bytestring ghc ghc-boot mtl parsec template-haskell text time
        ];
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "aeson-typescript_0_4_0_0" = callPackage
+  "aeson-typescript_0_4_1_0" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, directory
      , filepath, hspec, mtl, process, string-interpolate
      , template-haskell, temporary, text, th-abstraction, transformers
···
      }:
      mkDerivation {
        pname = "aeson-typescript";
-       version = "0.4.0.0";
-       sha256 = "0qy8hnrczyfxlyayrs9x1sp25wv9klc5n6c1pdds4lf09aq201ji";
+       version = "0.4.1.0";
+       sha256 = "0zr6p0yyzm1mdhnyycd37alw3xg2jmx303mbd5a7251wffxc42n8";
        libraryHaskellDepends = [
          aeson base containers mtl string-interpolate template-haskell text
          th-abstraction transformers unordered-containers
···
        pname = "aeson-yaml";
        version = "1.1.0.1";
        sha256 = "06x1l0a0dvzf8n2xmqny5qpsgdsl03xlh2z9x7wdxiykl8p4xd24";
-       revision = "2";
-       editedCabalFile = "1pylybgbj1z3b7yj6xig60w2x9j3ljr0s0pfxsrqdym2c65dv7ww";
+       revision = "3";
+       editedCabalFile = "11srm7kkslnicqvbk728kzpy58am8rz680f7l6axn2nfh5ykx8n6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "avro";
-       version = "0.6.1.1";
-       sha256 = "16ii6mvls85i0gfmq9c2mhzan3rcfz3ishnk80rw5z69r29z2wyl";
+       version = "0.6.1.2";
+       sha256 = "02qczc2hih1yvmarbi4vjccvh8x2n8wsjllq3hm42shkd9xl0s6a";
        libraryHaskellDepends = [
          aeson array base base16-bytestring bifunctors binary bytestring
          containers data-binary-ieee754 deepseq fail HasBigDecimal hashable
···
        ];
        description = "Avro serialization support for Haskell";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "avro-piper" = callPackage
···
      }:
      mkDerivation {
        pname = "aws-arn";
-       version = "0.2.0.0";
-       sha256 = "1amqcycxncgcs7nvpxrr2f2r2g6dhyfmlcwsk2am8l9ncmrr8ijx";
+       version = "0.3.0.0";
+       sha256 = "042lzvm1wpdqfrmgl1ygqgkdisvjyf9jfg9aqnibwhk2pw354dj3";
        libraryHaskellDepends = [
          base deriving-compat hashable profunctors tagged text
        ];
···
      }) {};
 
   "bearriver" = callPackage
-    ({ mkDerivation, base, dunai, MonadRandom, mtl, simple-affine-space
-     , transformers
+    ({ mkDerivation, base, deepseq, dunai, MonadRandom, mtl
+     , simple-affine-space, transformers
      }:
      mkDerivation {
        pname = "bearriver";
-       version = "0.13.6";
-       sha256 = "07ga08r2wwwd2n7jq2bc93jaiqymn4kih2mjb43273zz29kxds99";
+       version = "0.13.7";
+       sha256 = "1synznzas89cyp05lhiwxfsbmz5zv2pyjn08548dr21ih1x4560j";
        libraryHaskellDepends = [
-         base dunai MonadRandom mtl simple-affine-space transformers
+         base deepseq dunai MonadRandom mtl simple-affine-space transformers
        ];
        description = "FRP Yampa replacement implemented with Monadic Stream Functions";
        license = lib.licenses.bsd3;
···
        ];
        description = "Generate CSV Exports of Your BNB Staking Rewards";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "bnb-staking-csvs";
      }) {};
 
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "brick_1_3" = callPackage
+  "brick_1_4" = callPackage
     ({ mkDerivation, base, bimap, bytestring, config-ini, containers
      , contravariant, data-clist, deepseq, directory, exceptions
      , filepath, microlens, microlens-mtl, microlens-th, mtl, QuickCheck
···
      }:
      mkDerivation {
        pname = "brick";
-       version = "1.3";
-       sha256 = "0lpd6685ya0va0a6n7cw70f5b1s13y8ynzac0gkxyqb1ivzj0hsb";
+       version = "1.4";
+       sha256 = "12gwwqq38x0k6hjcn72dpcdwi0lrvyy8gxmp884h22l73xa4vda6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "brick-panes";
-       version = "1.0.0.0";
-       sha256 = "1q4j4scamy1rracjx78nld3r2grn53ifs7qjhk80w8qdjabjh6vr";
+       version = "1.0.0.1";
+       sha256 = "05f5c99b44c6aajx12hx4ayxjldbj4n0fi70i95q18qxy9aacljw";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base brick containers microlens vty ];
···
        pname = "bugzilla-redhat";
        version = "1.0.0";
        sha256 = "1g95j03y2sg1fwdf48a05nijqllkd0m7scn1wbfyzvb57q716hlx";
-       revision = "2";
-       editedCabalFile = "1x4vkr7wxwdvzdcam9zawmbc1ssl8ifpyaczimw2h63l47vv4y8b";
+       revision = "3";
+       editedCabalFile = "1f5mbfskr7h14ywg3v23x3r7d0k80z4ksflvqsbzkb2z3nqikj4a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "cabal-install";
        version = "3.8.1.0";
        sha256 = "1rk7xb86c1vgarv1m16d2i82fiig6q119j51gvq2pq8l5rpl7kk1";
-       revision = "1";
-       editedCabalFile = "0d6g8q9g8xv69dk51d2jjnc2bv9ah59vn1p5xg1hn42filh35sa1";
+       revision = "2";
+       editedCabalFile = "1l2lvljkr1ibnr3py7xfp2csxyb3rzlhy7jlpx8gkamq9cjmi6p2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "cabal-install-solver";
        version = "3.8.1.0";
        sha256 = "1rzzi3jx5ivxy43vdg460fsbn1p2v5br1havcara65vmqgv6j8yz";
+       revision = "1";
+       editedCabalFile = "1g487j20pj03pc10yaha18v73wh3ackxjgfpfqaj7xznqcbm5xwm";
        libraryHaskellDepends = [
          array base bytestring Cabal Cabal-syntax containers edit-distance
          filepath mtl pretty transformers
···
      }:
      mkDerivation {
        pname = "cabal2nix";
-       version = "2.19.0";
-       sha256 = "1cmx8vas9fryr8sd5a485aa43rdx60l3fbrk1kppwx4s9jw9hq65";
+       version = "2.19.1";
+       sha256 = "1ck7yqvvxkylwh3pw8hj24jg5jqx6hqy3bm37dkg85q9p9fs7nz0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        broken = true;
      }) {};
 
+  "call-alloy_0_4" = callPackage
+    ({ mkDerivation, async, base, bytestring, containers, directory
+     , extra, filepath, hspec, mtl, process, split, trifecta, unix
+     }:
+     mkDerivation {
+       pname = "call-alloy";
+       version = "0.4";
+       sha256 = "1af4a6inik3dcawn4lwlk01pyx6j5a1ly07qqf0ywkz2pv4ifgdc";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         async base bytestring containers directory extra filepath mtl
+         process split trifecta unix
+       ];
+       testHaskellDepends = [
+         async base bytestring containers directory extra filepath hspec mtl
+         process split trifecta unix
+       ];
+       description = "A simple library to call Alloy given a specification";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "call-haskell-from-anything" = callPackage
     ({ mkDerivation, base, bytestring, data-msgpack, mtl
      , storable-endian, template-haskell
···
      }) {};
 
   "call-plantuml" = callPackage
-    ({ mkDerivation, base, bytestring, filepath, hspec, process }:
+    ({ mkDerivation, async, base, bytestring, filepath, hspec, process
+     }:
      mkDerivation {
        pname = "call-plantuml";
-       version = "0.0.1";
-       sha256 = "1bx914719566fkhpxxyc22m3x8aq6c134kgs2a6ipf583883yfzh";
+       version = "0.0.1.1";
+       sha256 = "0wipnjcwv4d92vh1nmf228gf8bdy2yc0fana0a7zg5fxkaqznq0v";
        enableSeparateDataOutput = true;
-       libraryHaskellDepends = [ base bytestring filepath process ];
-       testHaskellDepends = [ base bytestring filepath hspec process ];
+       libraryHaskellDepends = [ async base bytestring filepath process ];
+       testHaskellDepends = [
+         async base bytestring filepath hspec process
+       ];
        description = "A simple library to call PlantUML given a diagram specification";
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
···
      , GenericPretty, ghc-prim, happy, hmatrix, hspec, hspec-discover
      , lattices, lens, matrix, mmorph, mtl, optparse-applicative
      , parallel, pipes, pretty, QuickCheck, sbv, silently, singletons
-     , strict, syb, syz, template-haskell, temporary, text, time
-     , transformers, uniplate, vector, verifiable-expressions, vinyl
+     , singletons-base, singletons-th, strict, syb, syz
+     , template-haskell, temporary, text, time, transformers, uniplate
+     , vector, verifiable-expressions, vinyl
      }:
      mkDerivation {
        pname = "camfort";
-       version = "1.1.2";
-       sha256 = "13a6x4j4f95izwz7g5sykpb2pq4lzwcswi31986gkyl6nicn5cfj";
+       version = "1.2.0";
+       sha256 = "1i2ssa4zlxa0c9gfhzm32rg8kc2fixyqyh203xhd9f82rn113mn8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq directory fgl
          filepath fortran-src GenericPretty ghc-prim hmatrix lattices lens
-         matrix mmorph mtl parallel pipes pretty sbv singletons strict syb
-         syz template-haskell text transformers uniplate vector
-         verifiable-expressions vinyl
+         matrix mmorph mtl parallel pipes pretty sbv singletons
+         singletons-base singletons-th strict syb syz template-haskell text
+         transformers uniplate vector verifiable-expressions vinyl
        ];
        librarySystemDepends = [ flint ];
        libraryToolDepends = [ alex happy ];
        executableHaskellDepends = [
-         base directory fortran-src optparse-applicative
+         array base binary bytestring containers directory fgl filepath
+         fortran-src hmatrix lattices lens mtl optparse-applicative sbv text
+         uniplate verifiable-expressions
        ];
        testHaskellDepends = [
          array base binary bytestring containers directory fgl filepath
···
        pname = "cbor-tool";
        version = "0.2.2.0";
        sha256 = "0rsnnz1zh9jyjif94lrdppzaa41hypqs1r5dlyzbwlw1m75g286p";
-       revision = "3";
-       editedCabalFile = "12sdpffqii9z70kbxn64vg08wlsgd6llbi479nxjc819cdmpgm59";
+       revision = "4";
+       editedCabalFile = "1wr6dlijy5j1b88bfmyvzj5pdipw6rcb40gfik678apr2q7gw0i6";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        pname = "cborg";
        version = "0.2.8.0";
        sha256 = "07mh5bk61k5dz2x5g7fqw2cv7bjzs7v65yxvzkq7mdbkq8kwhn9f";
+       revision = "1";
+       editedCabalFile = "13m2shrlpvg5s9d40a2463mmckzg50y8jb47zfd6i1rg6q3q6xx6";
        libraryHaskellDepends = [
          array base bytestring containers deepseq ghc-bignum ghc-prim half
          primitive text
···
        pname = "cborg-json";
        version = "0.2.5.0";
        sha256 = "1m3w0yyp6xb07fx04g5c52pb0b46vpkgpi32w1c8bz867x2p7hsq";
+       revision = "1";
+       editedCabalFile = "0zzn2p6yl9mqw7agm5w7iiz105078gv66vxr8bqazilgssqk5wyg";
        libraryHaskellDepends = [
          aeson aeson-pretty base cborg scientific text unordered-containers
          vector
···
      }) {};
 
   "chiasma" = callPackage
-    ({ mkDerivation, aeson, attoparsec, base, bytestring, composition
-     , composition-extra, conduit, conduit-extra, containers, cornea
-     , data-default, deepseq, directory, either, exceptions, filepath
-     , free, hedgehog, lens, mtl, parsec, parsers, posix-pty
-     , prettyprinter, prettyprinter-ansi-terminal, process, random
-     , relude, resourcet, split, stm-chans, stm-conduit, tasty
-     , tasty-hedgehog, text, transformers, typed-process, unix, unliftio
-     , unliftio-core, uuid
+    ({ mkDerivation, attoparsec, base, bytestring, composition
+     , containers, exon, extra, first-class-families, lens, parsec
+     , parsers, path, polysemy, polysemy-conc, polysemy-log
+     , polysemy-plugin, polysemy-process, polysemy-time, prelate
+     , prettyprinter, prettyprinter-ansi-terminal, random, text
+     , transformers, typed-process, uuid
      }:
      mkDerivation {
        pname = "chiasma";
-       version = "0.2.0.0";
-       sha256 = "11pbg9mlmp15hs2wdca0qyhbc94d91xkl75jlcaksla8l1qnnz9m";
+       version = "0.10.0.0";
+       sha256 = "116780x6a6avs2w62r32319w6fqhn2iwvxbfrl83h01iskr57x53";
+       libraryHaskellDepends = [
+         attoparsec base bytestring composition containers exon extra
+         first-class-families lens parsec parsers path polysemy
+         polysemy-conc polysemy-log polysemy-plugin polysemy-process
+         polysemy-time prelate prettyprinter prettyprinter-ansi-terminal
+         random text transformers typed-process uuid
+       ];
+       description = "A tmux client for Polysemy";
+       license = "BSD-2-Clause-Patent";
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "chiasma-test" = callPackage
+    ({ mkDerivation, base, bytestring, chiasma, chronos, exon, hedgehog
+     , lens, path, path-io, polysemy, polysemy-chronos, polysemy-conc
+     , polysemy-log, polysemy-plugin, polysemy-process, polysemy-test
+     , polysemy-time, prelate, tasty, tasty-hedgehog, text
+     , typed-process
+     }:
+     mkDerivation {
+       pname = "chiasma-test";
+       version = "0.10.0.0";
+       sha256 = "0244xxn0j53v0jcvj9d11wfrxjwjpr9247nbgqj8ipz5v56amih3";
        libraryHaskellDepends = [
-         aeson attoparsec base bytestring composition composition-extra
-         conduit conduit-extra containers cornea data-default deepseq
-         directory either exceptions filepath free lens mtl parsec parsers
-         posix-pty prettyprinter prettyprinter-ansi-terminal process random
-         relude resourcet split stm-chans stm-conduit text transformers
-         typed-process unix unliftio unliftio-core uuid
+         base bytestring chiasma chronos exon hedgehog path path-io polysemy
+         polysemy-chronos polysemy-conc polysemy-log polysemy-plugin
+         polysemy-process polysemy-test polysemy-time prelate text
+         typed-process
        ];
        testHaskellDepends = [
-         aeson attoparsec base bytestring composition composition-extra
-         conduit conduit-extra containers cornea data-default deepseq
-         directory either exceptions filepath free hedgehog lens mtl parsec
-         parsers posix-pty prettyprinter prettyprinter-ansi-terminal process
-         random relude resourcet split stm-chans stm-conduit tasty
-         tasty-hedgehog text transformers typed-process unix unliftio
-         unliftio-core uuid
+         base chiasma hedgehog lens path-io polysemy polysemy-chronos
+         polysemy-plugin polysemy-test prelate tasty tasty-hedgehog
        ];
-       description = "tmux api";
+       description = "A tmux client for Polysemy";
        license = "BSD-2-Clause-Patent";
        hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "chimera" = callPackage
···
      }:
      mkDerivation {
        pname = "churros";
-       version = "0.1.5.0";
-       sha256 = "05fb9vmx18dypfw6303y74cbag9vv187w6z402dv4vff35ya4bvh";
+       version = "0.1.6.0";
+       sha256 = "0ksjwdk36i8c90dzp9l24ynd2647ihv20kgv8412qcg3g3wplzpz";
        libraryHaskellDepends = [
          async base containers random stm time unagi-chan
        ];
···
      }:
      mkDerivation {
        pname = "cicero-api";
-       version = "0.1.1.3";
-       sha256 = "1wsvdi0hfsa6p70a9yag998iyzn3irbydrs17nfxalq5cnzwg0y4";
+       version = "0.1.2.0";
+       sha256 = "1y8dvv9ly64kwnx15ln5gidmab3wdwjclsbf719ajczvaxfkic0z";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        description = "Generates citations and bibliography from CSL styles";
        license = lib.licenses.bsd2;
+       maintainers = [ lib.maintainers.sternenseemann ];
      }) {};
 
   "citeproc_0_8_0_2" = callPackage
···
        description = "Generates citations and bibliography from CSL styles";
        license = lib.licenses.bsd2;
        hydraPlatforms = lib.platforms.none;
+       maintainers = [ lib.maintainers.sternenseemann ];
      }) {};
 
   "citeproc-hs" = callPackage
···
      }:
      mkDerivation {
        pname = "clash-shake";
-       version = "0.3.1";
-       sha256 = "1paym4vsihwggml62m0ijlln9349p4yrcpg6bvh6i199h3qs78id";
+       version = "0.3.1.2";
+       sha256 = "1nj9vhzfybm43jcns8nr3ka4gjc1xyn0ccv6xiqdyjipzldx4a1n";
        libraryHaskellDepends = [
          aeson base bytestring clash-ghc clash-lib clash-prelude directory
          shake split stache text unordered-containers
···
      }:
      mkDerivation {
        pname = "cloudi";
-       version = "2.0.4";
-       sha256 = "0d53ya6mqjl74yj1skmlbir5vvrfisrliahilm2jkaj3l8awyr2h";
+       version = "2.0.5";
+       sha256 = "0ry89sh969p0zhgchnciidacbkjkzs25mfnv07fm740lzzvh5isb";
        libraryHaskellDepends = [
          array base binary bytestring containers network time unix zlib
        ];
···
      }:
      mkDerivation {
        pname = "codeworld-api";
-       version = "0.7.0";
-       sha256 = "1l1w4mrw4b2njz4kmfvd94mlwn776vryy1y9x9cb3r69fw5qy2f3";
-       revision = "4";
-       editedCabalFile = "06qa2djbzfdwlvgbr2k8667fipyrkdvp8a1vac75fla99pdwp7yi";
+       version = "0.8.0";
+       sha256 = "0iaiw3gngpg2cwm0pgckn9vb0hjm7xm8szsii0k2s4d8fkl4k5rv";
        libraryHaskellDepends = [
          aeson base base64-bytestring blank-canvas bytestring cereal
          cereal-text containers deepseq dependent-sum ghc-prim hashable
···
        ];
        description = "Generate CSV & XLSX files for importing into CoinTracking";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "colada" = callPackage
···
        pname = "conduit";
        version = "1.3.4.3";
        sha256 = "0zchhxcpciq4nr7ll4z4c7wshlngphr0dz0y3xfml1pfls3a18mc";
+       revision = "1";
+       editedCabalFile = "0fsvnlx8gd9d8f70f6gl68ljhmff790anrifrixcflz0j2kfxwjh";
        libraryHaskellDepends = [
          base bytestring directory exceptions filepath mono-traversable mtl
          primitive resourcet text transformers unix unliftio-core vector
···
        license = lib.licenses.mit;
      }) {};
 
-  "core-program_0_6_1_0" = callPackage
+  "core-program_0_6_1_1" = callPackage
     ({ mkDerivation, base, bytestring, core-data, core-text, directory
      , exceptions, filepath, fsnotify, hashable, hourglass, mtl
      , prettyprinter, safe-exceptions, stm, template-haskell
···
      }:
      mkDerivation {
        pname = "core-program";
-       version = "0.6.1.0";
-       sha256 = "0gbahw4gwgj4ms5dg2142jmmhwrb9w6bc3ivpqg0h4cnd7ai20fr";
+       version = "0.6.1.1";
+       sha256 = "1qc9acs4jcrs80677fkd42h7nzwx8n7falrnxjsqpslh6i900hzc";
        libraryHaskellDepends = [
          base bytestring core-data core-text directory exceptions filepath
          fsnotify hashable hourglass mtl prettyprinter safe-exceptions stm
···
      }:
      mkDerivation {
        pname = "core-telemetry";
-       version = "0.2.6.1";
-       sha256 = "0i74ij12q99dap4yvwf4rkirq9wwib9w6ygwav29j2rv8rni6pim";
+       version = "0.2.7.0";
+       sha256 = "148ij7rdnjh4fl84b8r20vffm0564afj101zn7xkji653fv1ha0s";
        libraryHaskellDepends = [
          base bytestring core-data core-program core-text exceptions
          http-streams io-streams mtl network-info random safe-exceptions
···
      }:
      mkDerivation {
        pname = "core-webserver-servant";
-       version = "0.1.1.2";
-       sha256 = "084m2lisd9gwhasnxd2yc98f75zpa2zy3rq6sgj56f6aq7vnl0vv";
+       version = "0.1.1.3";
+       sha256 = "1bp7b6v96lqvsa39j9z1010yg4zjbl8v30anil12803ayc2ilvw3";
        libraryHaskellDepends = [
          base core-program core-telemetry core-webserver-warp mtl
          safe-exceptions servant servant-server vault wai
···
      }) {};
 
   "core-webserver-warp" = callPackage
-    ({ mkDerivation, async, base, bytestring, core-data, core-program
-     , core-telemetry, core-text, http-types, http2, mtl
-     , safe-exceptions, vault, wai, warp
+    ({ mkDerivation, async, base, bytestring, bytestring-trie
+     , core-data, core-program, core-telemetry, core-text, http-types
+     , http2, mtl, safe-exceptions, vault, wai, warp
      }:
      mkDerivation {
        pname = "core-webserver-warp";
-       version = "0.1.1.6";
-       sha256 = "05r4y1fywxxf4mi3i319vis67b2kdxf3caxq3nnlpc1ssyw37hc0";
+       version = "0.2.0.0";
+       sha256 = "0z0jjcj5gdcgxnnsjay5g2nw0ls43qslm3345n6732l515czivk7";
        libraryHaskellDepends = [
-         async base bytestring core-data core-program core-telemetry
-         core-text http-types http2 mtl safe-exceptions vault wai warp
+         async base bytestring bytestring-trie core-data core-program
+         core-telemetry core-text http-types http2 mtl safe-exceptions vault
+         wai warp
        ];
        description = "Interoperability with Wai/Warp";
        license = lib.licenses.mit;
···
        pname = "dbmonitor";
        version = "0.1.0";
        sha256 = "02j2f6r7jkgmmxqxysz45api0ai8wic4dffhw0y1xxhwfw5cx023";
+       revision = "1";
+       editedCabalFile = "0ks4sch746lvy4da4hh5mmxan487i6y0bjm5sw8vxcm6xa5jvqfg";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.asl20;
      }) {};
 
-  "dbus_1_2_26" = callPackage
+  "dbus_1_2_27" = callPackage
     ({ mkDerivation, base, bytestring, cereal, conduit, containers
      , criterion, deepseq, directory, exceptions, extra, filepath, lens
      , network, parsec, process, QuickCheck, random, resourcet, split
···
      }:
      mkDerivation {
        pname = "dbus";
-       version = "1.2.26";
-       sha256 = "1c9ljbwcrnzlbrjjp7bgpwbwykm03qvha05h55yp8k11za03wh9i";
+       version = "1.2.27";
+       sha256 = "0lkk9hd78h2ilvi0bj5jqq5q5lwyxzdlknwvckhwyxnlf3y6dz8z";
        libraryHaskellDepends = [
          base bytestring cereal conduit containers deepseq exceptions
          filepath lens network parsec random split template-haskell text
···
        pname = "deepseq-generics";
        version = "0.2.0.0";
        sha256 = "17bwghc15mc9pchfd1w46jh2p3wzc86aj6a537wqwxn08rayzcxh";
-       revision = "7";
-       editedCabalFile = "1issqf30ykabjpk7f66k8pfyylxw7bxa39b5iq72s76nxi392lig";
+       revision = "8";
+       editedCabalFile = "0dcv4kf2g4xyacjpci9kql1gm706lkzhcyz9ks9jkbdvyvs8lf90";
        libraryHaskellDepends = [ base deepseq ghc-prim ];
        testHaskellDepends = [
          base deepseq ghc-prim HUnit test-framework test-framework-hunit
···
      }:
      mkDerivation {
        pname = "dep-t-advice";
-       version = "0.6.1.0";
-       sha256 = "1l3zphhyb55da4jrkbhgynwb72s1lm63iyi4p35np1jffwfcc9mg";
-       revision = "1";
-       editedCabalFile = "09rszbs5l4z8zzhizipiqk8g11h9gr7brn03ylhci716mkzwkzw5";
+       version = "0.6.2.0";
+       sha256 = "0kzrk3fp68phdlz2snqzgma2b7997j06gwpg3cb0m8s9rpkkszmw";
        libraryHaskellDepends = [
          base dep-t mtl sop-core transformers unliftio-core
        ];
···
        pname = "dhall";
        version = "1.41.2";
        sha256 = "14m5rrvkid76qnvg0l14xw1mnqclhip3gjrz20g1lp4fd5p056ka";
-       revision = "1";
-       editedCabalFile = "1gi2j6d3mh0wqx6756cp04c676843wdibfwv3i2wypvsk74dlvjm";
+       revision = "2";
+       editedCabalFile = "18jh1c2zinwglih5gc8av2szicyywq5q0kl2h5200sm67nxmask9";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        pname = "dhall-docs";
        version = "1.0.10";
        sha256 = "1rh6nxmjin8kvbscbhbcjsgxnlkw1r19plzpps6wkx86zfjd2ms2";
-       revision = "1";
-       editedCabalFile = "06778mcqzqspy60jciy4vn2b8cbvv8dr5y0hcd560jr1yhjn0n8p";
+       revision = "2";
+       editedCabalFile = "1zm07bnaf6j0h5x2rlyvi4fs5d42w2v5z11qxc7gysqp1k2p99m1";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
      }:
      mkDerivation {
        pname = "distribution-nixpkgs";
-       version = "1.7.0";
-       sha256 = "007riyq6irmzzmf3gynaa5hpz8a4khg8wl4blyz78c59bqblpw69";
-       revision = "1";
-       editedCabalFile = "0xzrh7kfla9c43jjjnd2r13xsp994gdkxkwgav2kl50qxzdb88nx";
+       version = "1.7.0.1";
+       sha256 = "0yaha7arm9cn9sxacqwmr2qcnw2cxn53xww11im00mx7gk127rh2";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base bytestring Cabal containers deepseq language-nix lens
···
      }) {};
 
   "dnf-repo" = callPackage
-    ({ mkDerivation, base, directory, extra, filepath, simple-cmd
+    ({ mkDerivation, base, directory, extra, filepath, Glob, simple-cmd
      , simple-cmd-args
      }:
      mkDerivation {
        pname = "dnf-repo";
-       version = "0.3";
-       sha256 = "0x2x6sapghvm4006iplk750ihign5akl1mlrga79k8f81krb3i3s";
+       version = "0.5";
+       sha256 = "1adpbm76kra59jgbrx2b1lzi06lq3znwqy8wapx0p5qsf630kilw";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
        executableHaskellDepends = [
-         base directory extra filepath simple-cmd simple-cmd-args
+         base directory extra filepath Glob simple-cmd simple-cmd-args
        ];
+       testHaskellDepends = [ base simple-cmd ];
        description = "DNF wrapper tool to control repos";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "dnf-repo";
+       broken = true;
      }) {};
 
   "dns" = callPackage
···
        mainProgram = "doctest";
      }) {};
 
-  "doctest_0_20_0" = callPackage
+  "doctest_0_20_1" = callPackage
     ({ mkDerivation, base, base-compat, code-page, deepseq, directory
      , exceptions, filepath, ghc, ghc-paths, hspec, hspec-core
      , hspec-discover, HUnit, mockery, process, QuickCheck, setenv
···
      }:
      mkDerivation {
        pname = "doctest";
-       version = "0.20.0";
-       sha256 = "0sk50b8zxq4hvc8qphlmfha1lsv3xha7q7ka081jgswf1qpg34y4";
-       revision = "5";
-       editedCabalFile = "0d7xgi71zdfbg3an6v2ss4lj6lvlmvq36hy788nd94ja2bgfsmpx";
+       version = "0.20.1";
+       sha256 = "00jbpqvcqxx1nmf41li947d9d3ifwchzzp37mlag68hgnza6z9a4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        maintainers = [ lib.maintainers.turion ];
      }) {};
 
-  "dunai_0_9_0" = callPackage
+  "dunai_0_9_1" = callPackage
     ({ mkDerivation, base, MonadRandom, simple-affine-space, tasty
      , tasty-hunit, transformers, transformers-base
      }:
      mkDerivation {
        pname = "dunai";
-       version = "0.9.0";
-       sha256 = "0p93c1h5bggvabx4vvd95khmjrq4qh46rvxkm4cqcdfd0601lyy5";
+       version = "0.9.1";
+       sha256 = "0krgbs9xqar78815xrgqbj63678jm0mjbsvnqdayh0c2awf9i8bj";
        libraryHaskellDepends = [
          base MonadRandom simple-affine-space transformers transformers-base
        ];
···
     ({ mkDerivation, base, dunai, normaldistribution, QuickCheck }:
      mkDerivation {
        pname = "dunai-test";
-       version = "0.9.0";
-       sha256 = "0j007pd475fmxhnvvwh6z8awrxfcfgwmph1z412k332lrj46nhv7";
+       version = "0.9.1";
+       sha256 = "0p78yvn98vp3qjd6dx23nwwzq6v6sks2gp9cycmcnjk3yn8470j9";
        libraryHaskellDepends = [
          base dunai normaldistribution QuickCheck
        ];
···
        pname = "ed25519";
        version = "0.0.5.0";
        sha256 = "0v8msqvgzimhs7p5ri25hrb1ni2wvisl5rmdxy89fc59py79b9fq";
-       revision = "5";
-       editedCabalFile = "1ckyssya3vw8nf4w324zhbyyf92zlzr2kcv20bvw58wz7mgppb14";
+       revision = "6";
+       editedCabalFile = "0qyx6cl52fnll8lp6v9133wfvv3zhvq7v2crn441mng520j9wp48";
        libraryHaskellDepends = [ base bytestring ghc-prim ];
        testHaskellDepends = [
          base bytestring directory doctest filepath hlint QuickCheck
···
 
   "effectful" = callPackage
     ({ mkDerivation, async, base, bytestring, containers, directory
-     , effectful-core, exceptions, lifted-base, process, stm, tasty
-     , tasty-bench, tasty-hunit, text, time, unix, unliftio
+     , effectful-core, exceptions, lifted-base, primitive, process, stm
+     , tasty, tasty-bench, tasty-hunit, text, time, unix, unliftio
      }:
      mkDerivation {
        pname = "effectful";
-       version = "2.1.0.0";
-       sha256 = "16vkxjmlwmyrvp3gdjma73jqlbmvbj9cawazg9h6fchxfr6ps53n";
+       version = "2.2.0.0";
+       sha256 = "0zymvpg7bbvgwpziqj3bfpxbb77d45kph0qcrdilfi9w1bbjg63r";
        libraryHaskellDepends = [
          async base bytestring directory effectful-core process stm time
          unliftio
        ];
        testHaskellDepends = [
-         base containers effectful-core exceptions lifted-base tasty
-         tasty-hunit unliftio
+         base containers effectful-core exceptions lifted-base primitive
+         tasty tasty-hunit unliftio
        ];
        benchmarkHaskellDepends = [
          async base tasty-bench text unix unliftio
···
      }:
      mkDerivation {
        pname = "effectful-core";
-       version = "2.1.0.0";
-       sha256 = "1lgg8f66jrs206b4zvkplq7w8d8sd91mxj9333sr4v4dnnshp4lk";
+       version = "2.2.0.0";
+       sha256 = "0i4ybsqkamsg91vp4pkr7pxpscfk5n44far9c53cbnh49nx14jqg";
        libraryHaskellDepends = [
          base containers exceptions monad-control primitive
          transformers-base unliftio-core
···
        libraryHaskellDepends = [ base effectful-core primitive ];
        description = "`ST`-style mutation for `effectful`";
        license = lib.licenses.cc0;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "effectful-th" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "enummapset_0_7_0_0" = callPackage
+  "enummapset_0_7_1_0" = callPackage
     ({ mkDerivation, aeson, array, base, containers, deepseq, ghc-prim
-     , HUnit, QuickCheck, semigroups, test-framework
-     , test-framework-hunit, test-framework-quickcheck2
+     , HUnit, QuickCheck, test-framework, test-framework-hunit
+     , test-framework-quickcheck2
      }:
      mkDerivation {
        pname = "enummapset";
-       version = "0.7.0.0";
-       sha256 = "194x78axmihq9r83w8dj4z0299aa63zkkbq82f7ybgr2ckgvqcd5";
-       libraryHaskellDepends = [
-         aeson base containers deepseq semigroups
-       ];
+       version = "0.7.1.0";
+       sha256 = "1zhfl1qrm7r124v0xphh50lnll7cgmlacdmxwwlwhmzyrp1bwf69";
+       libraryHaskellDepends = [ aeson base containers deepseq ];
        testHaskellDepends = [
          aeson array base containers deepseq ghc-prim HUnit QuickCheck
-         semigroups test-framework test-framework-hunit
-         test-framework-quickcheck2
+         test-framework test-framework-hunit test-framework-quickcheck2
        ];
        description = "IntMap and IntSet with Enum keys/elements";
        license = lib.licenses.bsd3;
···
      }) {};
 
   "eventuo11y" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, exceptions, primitive
-     , resourcet, text, time, unliftio-core, uuid
+    ({ mkDerivation, base, exceptions, primitive, resourcet
+     , safe-exceptions, transformers, unliftio-core
      }:
      mkDerivation {
        pname = "eventuo11y";
-       version = "0.3.2.0";
-       sha256 = "1dx6q09bymvr7f4l7bnmb8c9gn46yp95qfhf9dml5i33x4scr2s8";
+       version = "0.5.0.0";
+       sha256 = "19rsw7xs8hy1yl145fgsfd3rddvpxjgxv05kd557hgv35ipkklmz";
        libraryHaskellDepends = [
-         aeson base bytestring exceptions primitive resourcet text time
-         unliftio-core uuid
+         base exceptions primitive resourcet safe-exceptions transformers
+         unliftio-core
        ];
        description = "An event-oriented observability library";
        license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "eventuo11y-batteries" = callPackage
     ({ mkDerivation, aeson, base, binary, bytestring, case-insensitive
-     , containers, eventuo11y, exceptions, http-media, http-types
-     , monad-control, mtl, network, semigroupoids, servant-client
-     , servant-client-core, text, transformers-base, wai, warp
+     , containers, eventuo11y, eventuo11y-json, http-media, http-types
+     , monad-control, mtl, network, safe-exceptions, semigroupoids
+     , servant-client, servant-client-core, text, transformers-base, wai
+     , warp
      }:
      mkDerivation {
        pname = "eventuo11y-batteries";
-       version = "0.2.1.0";
-       sha256 = "0hdhryk7srb0dcjbqfk6ah2l7x3bbl3rqhncwx0wc3nfcx97dr0v";
+       version = "0.2.1.1";
+       sha256 = "1s3mwr9cnfsn1kh63dq6djwvvj4sx256w47r9s6wsii9ibgqig8v";
        libraryHaskellDepends = [
          aeson base binary bytestring case-insensitive containers eventuo11y
-         exceptions http-media http-types monad-control mtl network
-         semigroupoids servant-client servant-client-core text
-         transformers-base wai warp
+         eventuo11y-json http-media http-types monad-control mtl network
+         safe-exceptions semigroupoids servant-client servant-client-core
+         text transformers-base wai warp
        ];
        description = "Grab bag of eventuo11y-enriched functionality";
        license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "eventuo11y-dsl" = callPackage
+    ({ mkDerivation, base, template-haskell, th-compat }:
+     mkDerivation {
+       pname = "eventuo11y-dsl";
+       version = "0.1.0.0";
+       sha256 = "0nm0q8p5qbnx56gvpsbzz5vwkx08sn8wcdyb6hli4ihq407ml8qz";
+       libraryHaskellDepends = [ base template-haskell th-compat ];
+       description = "DSL for defining eventuo11y fields and selectors";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "eventuo11y-json" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, eventuo11y
+     , eventuo11y-dsl, template-haskell, text, th-compat, time, uuid
+     }:
+     mkDerivation {
+       pname = "eventuo11y-json";
+       version = "0.1.0.0";
+       sha256 = "1bl4lqxq38nvwnm6s9w27ja4x571y6lvjvx7amc2i498i3mr5jzq";
+       libraryHaskellDepends = [
+         aeson base bytestring eventuo11y eventuo11y-dsl template-haskell
+         text th-compat time uuid
+       ];
+       description = "aeson-based rendering for eventuo11y";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "every" = callPackage
···
      }:
      mkDerivation {
        pname = "experimenter";
-       version = "0.1.0.12";
-       sha256 = "0sam7wl4gha9midkgj15h0q68g121pihxxvv8dlx3wgd9as1h5d6";
-       libraryHaskellDepends = [
-         aeson base bytestring cereal cereal-vector conduit containers
-         deepseq directory esqueleto filepath HaTeX hostname lens matrix
-         monad-logger mtl mwc-random parallel persistent
-         persistent-postgresql persistent-template process resource-pool
-         resourcet stm text time transformers unix unliftio-core vector
-       ];
-       testHaskellDepends = [
-         aeson base bytestring cereal cereal-vector conduit containers
-         deepseq directory esqueleto filepath foundation HaTeX hostname
-         hspec lens matrix monad-logger mtl mwc-random parallel persistent
-         persistent-postgresql persistent-template process QuickCheck
-         resource-pool resourcet stm text time transformers unix
-         unliftio-core vector
-       ];
-       description = "Perform scientific experiments stored in a DB, and generate reports";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "experimenter_0_1_0_14" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, cereal, cereal-vector
-     , conduit, containers, deepseq, directory, esqueleto, filepath
-     , foundation, HaTeX, hostname, hspec, lens, matrix, monad-logger
-     , mtl, mwc-random, parallel, persistent, persistent-postgresql
-     , persistent-template, process, QuickCheck, resource-pool
-     , resourcet, stm, text, time, transformers, unix, unliftio-core
-     , vector
-     }:
-     mkDerivation {
-       pname = "experimenter";
        version = "0.1.0.14";
        sha256 = "11m832x42xgd679zwnsykggp9afk7kwkis1s04iq4hdxbcylh7kc";
        libraryHaskellDepends = [
···
        ];
        description = "Perform scientific experiments stored in a DB, and generate reports";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "expiring-cache-map" = callPackage
···
      }:
      mkDerivation {
        pname = "extensions";
-       version = "0.0.0.1";
-       sha256 = "0wxkkdvsq8pqirw5w8ss20iyblw9197q420cpwnqzbl2xb0cjk6n";
+       version = "0.1.0.0";
+       sha256 = "1b4wiw228hlk0ywjzpgw7rg9nwfmav82c976ipn0ql0gyh7v27xc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        description = "Parse Haskell Language Extensions";
        license = lib.licenses.mpl20;
-       hydraPlatforms = lib.platforms.none;
        mainProgram = "extensions";
-       broken = true;
      }) {};
 
   "external-sort" = callPackage
···
      }:
      mkDerivation {
        pname = "faktory";
-       version = "1.1.2.3";
-       sha256 = "1mihcmz3wzw2f6vfwv7xkvzhiql1fbb5v2llpkx5y455z939xl37";
+       version = "1.1.2.4";
+       sha256 = "0mn888cjk8ag94il7zcbk6q5cq2vf2dxf1b8ba8ki2rypxld5m7a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "fastmemo_0_1_1" = callPackage
+    ({ mkDerivation, base, bytestring, containers, QuickCheck
+     , utf8-string, vector
+     }:
+     mkDerivation {
+       pname = "fastmemo";
+       version = "0.1.1";
+       sha256 = "0jjsfdadf1dz516dhqd42bvbd230dymzpav7kzzvkn2yr81p456s";
+       libraryHaskellDepends = [
+         base bytestring containers utf8-string vector
+       ];
+       testHaskellDepends = [
+         base bytestring containers QuickCheck utf8-string vector
+       ];
+       description = "Memoize functions on Generic types";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "fastparser" = callPackage
     ({ mkDerivation, base, bytestring, bytestring-lexing, containers
      , criterion, kan-extensions, microlens, thyme, transformers
···
        pname = "fastsum";
        version = "0.2.0.0";
        sha256 = "1yjsmk8ws6y5rbv23d3jqyqz4pvkzn44dmx1gflldgdfm9xi31ac";
+       revision = "1";
+       editedCabalFile = "14xrvz46f5ngj1jzdlcabg342ixczcfc3rx1hryil8rv976bdidr";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "filepath-bytestring_1_4_2_1_11" = callPackage
+  "filepath-bytestring_1_4_2_1_12" = callPackage
     ({ mkDerivation, base, bytestring, criterion, filepath, QuickCheck
      , unix
      }:
      mkDerivation {
        pname = "filepath-bytestring";
-       version = "1.4.2.1.11";
-       sha256 = "1y906vb9p51awzgd5s1bq718kw03gpw7z8i8bdznlw7i9r40shbk";
+       version = "1.4.2.1.12";
+       sha256 = "0i8j724fz8h1bcqvlvp3sxmgyrvx2sim74cvzkpc9m05yn9p27sq";
        libraryHaskellDepends = [ base bytestring unix ];
        testHaskellDepends = [ base bytestring filepath QuickCheck ];
        benchmarkHaskellDepends = [ base criterion filepath ];
···
      }) {};
 
   "findhttp" = callPackage
-    ({ mkDerivation, base, basic-prelude, bytestring, directory
-     , filepath, Glob, http-directory, simple-cmd-args, text
+    ({ mkDerivation, base, bytestring, directory, filepath, Glob
+     , http-directory, simple-cmd-args, text
      }:
      mkDerivation {
        pname = "findhttp";
-       version = "0.1";
-       sha256 = "1hw7cbmy0b01kfpfxavq3gc17vnq4vr2fy3bcvh4jnz9rizfmr9w";
+       version = "0.1.1";
+       sha256 = "1rsgdj3fm5zcvby8wms4lslr5bzj5n8rkdxckva7px4sks02fg2n";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
-         base basic-prelude bytestring directory filepath Glob
-         http-directory simple-cmd-args text
+         base bytestring directory filepath Glob http-directory
+         simple-cmd-args text
        ];
        description = "List http/html files";
        license = lib.licenses.gpl3Only;
···
        maintainers = [ lib.maintainers.sternenseemann ];
      }) {};
 
-  "flat_0_5" = callPackage
+  "flat_0_5_2" = callPackage
     ({ mkDerivation, array, base, bytestring, containers, deepseq
      , dlist, filepath, ghc-prim, hashable, list-t, mono-traversable
      , pretty, primitive, QuickCheck, quickcheck-text, tasty
···
      }:
      mkDerivation {
        pname = "flat";
-       version = "0.5";
-       sha256 = "1338h8w2s1vpjl019rv1qmc5s0xlpn3jdi4jzycc805l9cxdqa7w";
+       version = "0.5.2";
+       sha256 = "189jgx5zd1m3wgn2mal93ak1p6qp9mkaz38gkfzvgv6nwgywxxix";
        libraryHaskellDepends = [
          array base bytestring containers deepseq dlist ghc-prim hashable
          list-t mono-traversable pretty primitive text unordered-containers
···
        mainProgram = "fortran-src";
      }) {};
 
-  "fortran-src_0_11_0" = callPackage
+  "fortran-src_0_12_0" = callPackage
     ({ mkDerivation, alex, array, base, binary, bytestring, containers
      , deepseq, directory, either, fgl, filepath, GenericPretty, happy
      , hspec, hspec-discover, mtl, pretty, QuickCheck, singletons
···
      }:
      mkDerivation {
        pname = "fortran-src";
-       version = "0.11.0";
-       sha256 = "0rh7zpnykm30y5jlr6077jdzpbf6qsccdmbs083wb1lv5gijza7k";
+       version = "0.12.0";
+       sha256 = "02n9s5an0z39gx8ks9pr3vrj6h683yra2djwi2m62rl76yw9nsmw";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "fortran-src-extras" = callPackage
-    ({ mkDerivation, aeson, base, binary, bytestring, containers
-     , directory, either, filepath, fortran-src, GenericPretty, hspec
-     , hspec-discover, optparse-applicative, silently, text, uniplate
-     , yaml
+       sha256 = "1l3pq6i9npbyzh0bv8qb315l50zhv81s5rqqnc8k27rlrabirndb";
+     , filepath, fortran-src, GenericPretty, hspec, hspec-discover
+     , optparse-applicative, silently, text, uniplate, yaml
      }:
      mkDerivation {
        pname = "fortran-src-extras";
-       version = "0.3.2";
-       sha256 = "1b8vcg86pq92r1012s6fpnnkr489zs9x202rdjkjnyrmzm9v8rrx";
+       version = "0.4.0";
+       sha256 = "064cszvqn1p3r4fjldi7yibm7dd7iahanfld02z7if4l5w8l6dyc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         aeson base binary bytestring containers directory either filepath
-         fortran-src GenericPretty optparse-applicative text uniplate
+         aeson base bytestring containers either filepath fortran-src
+         GenericPretty optparse-applicative text uniplate
        ];
        executableHaskellDepends = [
          aeson base bytestring containers fortran-src GenericPretty
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "fsnotify_0_4_0_1" = callPackage
+  "fsnotify_0_4_1_0" = callPackage
     ({ mkDerivation, async, base, bytestring, containers, directory
      , exceptions, filepath, hinotify, monad-control, random, retry
      , safe-exceptions, sandwich, temporary, text, time, unix
···
      }:
      mkDerivation {
        pname = "fsnotify";
-       version = "0.4.0.1";
-       sha256 = "02gnbwxgs5b4rnqpgprvqxw9d2vw2yi276dn6ync3czrxyqliz78";
-       revision = "1";
-       editedCabalFile = "00yspy6jwriwgr0zi806z31q082kx1gfihfspf3izlxcm5qinyjh";
-       isLibrary = true;
-       isExecutable = true;
+       version = "0.4.1.0";
+       sha256 = "1vzpx91n2qml0628zq1c0bwnz7d4bal4vwl52hyil60shx5gnc6i";
        libraryHaskellDepends = [
          async base bytestring containers directory filepath hinotify
          monad-control safe-exceptions text time unix unix-compat
        ];
-       executableHaskellDepends = [
+       testHaskellDepends = [
          async base directory exceptions filepath random retry
          safe-exceptions sandwich temporary unix-compat unliftio
        ];
        description = "Cross platform library for file change notification";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
-       mainProgram = "tests";
      }) {};
 
   "fsnotify-conduit" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
-  "generic-functor_1_0_0_0" = callPackage
+  "generic-functor_1_1_0_0" = callPackage
     ({ mkDerivation, ap-normalize, base, transformers }:
      mkDerivation {
        pname = "generic-functor";
-       version = "1.0.0.0";
-       sha256 = "0cnwzz7303z55nr64bi56w2bqxh7wxmv8wxzmh5xb37k674qjgz6";
+       version = "1.1.0.0";
+       sha256 = "1hh5p7bk4pkq7095wiwiw5v53abh6csc4g0q47f3kgpavkf83d8c";
        libraryHaskellDepends = [ ap-normalize base ];
        testHaskellDepends = [ base transformers ];
        description = "Deriving generalized functors with GHC.Generics";
···
     ({ mkDerivation, base, containers, transformers }:
      mkDerivation {
        pname = "generic-trie";
-       version = "0.3.1";
-       sha256 = "1x7f5bp7d13g737198l43y2mf9mzngg9vmhyh1yaxg8xfpzc3anh";
-       revision = "2";
-       editedCabalFile = "1dxf7c66vncw8zn0848g0bk2i2msbrb4njzvkzwvlaiphq0gqg10";
+       version = "0.3.2";
+       sha256 = "19027g8xqy99x0gg5a8cnvyf6n1jnk7qvpgn4d0b3ha168fa2k0l";
+       isLibrary = true;
+       isExecutable = true;
        libraryHaskellDepends = [ base containers transformers ];
+       executableHaskellDepends = [ base ];
        description = "A map, where the keys may be complex structured data";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
+       mainProgram = "bogus";
        broken = true;
      }) {};
 
···
      }:
      mkDerivation {
        pname = "ghc-typelits-extra";
-       version = "0.4.3";
-       sha256 = "06g40q0n2d10c2zksx5rrjkvm5ywi3rh41hbiwy4zs28x9idsv18";
-       revision = "1";
-       editedCabalFile = "0m6z24zmi169zifz1jg4zri0izr5z37qx33c9mphy74vd6ds3zzz";
+       version = "0.4.4";
+       sha256 = "1pjai171y374569xzqnp6amf7dvj57pcfykh3g48m5jij2b8jbc6";
        libraryHaskellDepends = [
          base containers ghc ghc-bignum ghc-prim ghc-tcplugins-extra
          ghc-typelits-knownnat ghc-typelits-natnormalise transformers
···
      }:
      mkDerivation {
        pname = "ghc-typelits-knownnat";
-       version = "0.7.6";
-       sha256 = "10m4y0hf25w2i40464pz85lqs5dr8cznl191icnibc5fjynyzd9v";
-       libraryHaskellDepends = [
-         base ghc ghc-prim ghc-tcplugins-extra ghc-typelits-natnormalise
-         template-haskell transformers
-       ];
-       testHaskellDepends = [
-         base ghc-typelits-natnormalise tasty tasty-hunit tasty-quickcheck
-       ];
-       description = "Derive KnownNat constraints from other KnownNat constraints";
-       license = lib.licenses.bsd2;
-     }) {};
-
-  "ghc-typelits-knownnat_0_7_7" = callPackage
-    ({ mkDerivation, base, ghc, ghc-prim, ghc-tcplugins-extra
-     , ghc-typelits-natnormalise, tasty, tasty-hunit, tasty-quickcheck
-     , template-haskell, transformers
-     }:
-     mkDerivation {
-       pname = "ghc-typelits-knownnat";
        version = "0.7.7";
        sha256 = "0b7rhnij3i74baqm7ban92sfdiscbjvrypfi6wwipkc8graii467";
        libraryHaskellDepends = [
···
        ];
        description = "Derive KnownNat constraints from other KnownNat constraints";
        license = lib.licenses.bsd2;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ghc-typelits-natnormalise" = callPackage
···
      }:
      mkDerivation {
        pname = "ghc-typelits-natnormalise";
-       version = "0.7.6";
-       sha256 = "09d70iw58m5g6yi8k2b52f1g0pfdqm5fzhs8rd7fgrgmi70np9bx";
-       revision = "1";
-       editedCabalFile = "1b587pryjkbvgayqwm8cn7ljmcyd4jikrxxkgm6zq1v9qhi7xy22";
-       libraryHaskellDepends = [
-         base containers ghc ghc-bignum ghc-tcplugins-extra transformers
-       ];
-       testHaskellDepends = [ base tasty tasty-hunit template-haskell ];
-       description = "GHC typechecker plugin for types of kind GHC.TypeLits.Nat";
-       license = lib.licenses.bsd2;
-     }) {};
-
-  "ghc-typelits-natnormalise_0_7_7" = callPackage
-    ({ mkDerivation, base, containers, ghc, ghc-bignum
-     , ghc-tcplugins-extra, tasty, tasty-hunit, template-haskell
-     , transformers
-     }:
-     mkDerivation {
-       pname = "ghc-typelits-natnormalise";
        version = "0.7.7";
        sha256 = "0pqpsy3j4brpg2hrq9qrnjzr1bishycny5gvsdncvhaq3m53gslh";
        libraryHaskellDepends = [
···
        testHaskellDepends = [ base tasty tasty-hunit template-haskell ];
        description = "GHC typechecker plugin for types of kind GHC.TypeLits.Nat";
        license = lib.licenses.bsd2;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ghc-typelits-presburger" = callPackage
···
      }:
      mkDerivation {
        pname = "ghci-dap";
-       version = "0.0.18.0";
-       sha256 = "1mkw7h7zzjd7kx9345rnkvh70qwkg8q6h5am2lgaybxmxkig8wlc";
+       version = "0.0.19.0";
+       sha256 = "07f0q83pcma3c0v7sdkkb1nzx40f55v47v44gaa2pg6clkl7p1gx";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
 
   "gi-adwaita" = callPackage
     ({ mkDerivation, base, bytestring, Cabal, containers, gi-gdk
-     , gi-gio, gi-gobject, gi-gtk, haskell-gi, haskell-gi-base
+     , gi-gio, gi-gobject, gi-gtk, gi-pango, haskell-gi, haskell-gi-base
      , haskell-gi-overloading, libadwaita, text, transformers
      }:
      mkDerivation {
        pname = "gi-adwaita";
-       version = "1.0.1";
-       sha256 = "0l0n19ap2hvvl6kpwhqqr4n01xjc8rj9fl49ya2pbvxpjy97yqha";
+       version = "1.0.3";
+       sha256 = "1j5gccj480h2ms2spg7an0mdhb1mlm5hz7kkyga5smkfkc8pbj8h";
        setupHaskellDepends = [
-         base Cabal gi-gdk gi-gio gi-gobject gi-gtk haskell-gi
+         base Cabal gi-gdk gi-gio gi-gobject gi-gtk gi-pango haskell-gi
        ];
        libraryHaskellDepends = [
-         base bytestring containers gi-gdk gi-gio gi-gobject gi-gtk
+         base bytestring containers gi-gdk gi-gio gi-gobject gi-gtk gi-pango
          haskell-gi haskell-gi-base haskell-gi-overloading text transformers
        ];
        libraryPkgconfigDepends = [ libadwaita ];
···
      }:
      mkDerivation {
        pname = "gi-atk";
-       version = "2.0.24";
-       sha256 = "1xhjzjcdbnfk7b6r035ch3plpgk9yk2qawq7iffc47y67dxhcd6b";
+       version = "2.0.25";
+       sha256 = "0x3qwz8576c1m2y6sxjjzxi0q5x47lbaawipsiaiimk51x4p4div";
        setupHaskellDepends = [ base Cabal gi-glib gi-gobject haskell-gi ];
        libraryHaskellDepends = [
          base bytestring containers gi-glib gi-gobject haskell-gi
···
      }:
      mkDerivation {
        pname = "gi-cairo";
-       version = "1.0.26";
-       sha256 = "1f3gfhqg03b64n4ipg3q96wkwsisrs79bbg7335nwg92frkv1j79";
+       version = "1.0.27";
+       sha256 = "1f074s37fw1wjd2ycmji8vhvl1lzaclqh7n2pippdfvhfidrkbxf";
        setupHaskellDepends = [ base Cabal haskell-gi ];
        libraryHaskellDepends = [
          base bytestring containers haskell-gi haskell-gi-base
···
      }:
      mkDerivation {
        pname = "gi-cairo-render";
-       version = "0.1.1";
-       sha256 = "09gxykx633xvwcqx1cjl9kj2748jdq49ayy6z5p3hz7bxqlna952";
+       version = "0.1.2";
+       sha256 = "07h3k8bzb6qhk7x2v68dg5gsxxpjpr7k3vvh2fyqb9zj9rq8lyfc";
        libraryHaskellDepends = [
          array base bytestring haskell-gi-base mtl text utf8-string
        ];
···
      }:
      mkDerivation {
        pname = "gi-clutter";
-       version = "1.0.2";
-       sha256 = "1fyqpgj2q7mnlvqp60203mnl797vvsrfmgildp3zdi4dmqsv4vws";
+       version = "1.0.3";
+       sha256 = "1mbpk0s37sifpydww4qh6m7nyz8p323i2r2zr4h4cnvb6vpfvaqy";
        setupHaskellDepends = [
          base Cabal gi-atk gi-cairo gi-cogl gi-gio gi-glib gi-gobject
          gi-json gi-pango haskell-gi
···
      }:
      mkDerivation {
        pname = "gi-cogl";
-       version = "1.0.2";
-       sha256 = "0y7inkzp3vxck4para77dzd4qczl3r61nv5y5hcyycmlpzlwfjzj";
+       version = "1.0.3";
+       sha256 = "1kzf9sqa9glhiaka6qajx0mdm8qfp30j6612l8v98vc312bly6dp";
        setupHaskellDepends = [ base Cabal gi-glib gi-gobject haskell-gi ];
        libraryHaskellDepends = [
          base bytestring containers gi-glib gi-gobject haskell-gi
···
      }:
      mkDerivation {
        pname = "gi-coglpango";
-       version = "1.0.2";
-       sha256 = "0yx0nqnpkkx0wcbljx02ivwf9749d02xqpwpp2zck2cpc9ll7xca";
+       version = "1.0.3";
+       sha256 = "193nblss2d4xlj4kiaz8745797lfpqxm65knzr6al1rdqikc6gdc";
        setupHaskellDepends = [
          base Cabal gi-cogl gi-glib gi-gobject gi-pango gi-pangocairo
          haskell-gi
···
      }:
      mkDerivation {
        pname = "gi-dbusmenu";
-       version = "0.4.10";
-       sha256 = "05q3sijfsma2rinyw1rb7z4fphdqakbg18zlpf8jpv89c1329d3q";
+       version = "0.4.11";
+       sha256 = "06mzjyn1l97n171c92kvsnhhz2fs1pz48n1bwk1b58wnjdrhhscd";
        setupHaskellDepends = [ base Cabal gi-glib gi-gobject haskell-gi ];
        libraryHaskellDepends = [
          base bytestring containers gi-glib gi-gobject haskell-gi
···
      }:
      mkDerivation {
        pname = "gi-dbusmenugtk3";
-       version = "0.4.11";
-       sha256 = "1ipq8irzqswpak6zip9ghpkvk29mwnym8d70md3an0idlq0gcnw6";
+       version = "0.4.12";
+       sha256 = "1ky4x665p5f7zlfckz7fykgnl9n839vz5pv4l0lprhp0l04f32hz";
        setupHaskellDepends = [
          base Cabal gi-atk gi-dbusmenu gi-gdk gi-gdkpixbuf gi-glib
          gi-gobject gi-gtk haskell-gi
···
      }:
      mkDerivation {
        pname = "gi-freetype2";
-       version = "2.0.1";
-       sha256 = "00sgy9ppwf7im98vrcjp0ihb3zgaxcsm8klqv4h3z8n8ypv44ir2";
+       version = "2.0.2";
+       sha256 = "066xpysbzzfjd0gpjxvhfbgy1zwhqd14gibs4daycszk09d9kspp";
        setupHaskellDepends = [ base Cabal haskell-gi ];
        libraryHaskellDepends = [
          base bytestring containers haskell-gi haskell-gi-base
···
      }:
      mkDerivation {
        pname = "gi-gdk";
-       version = "3.0.25";
-       sha256 = "1flgsm7sqsfp53pqbc8fv9pnsc84qnjmhircsqnx8jvkg5iyvxnx";
+       version = "3.0.26";
+       sha256 = "14271bbi1dy0r1krxg0ry3hqmqv10v55ja55a912qknsq1ya8nka";
        setupHaskellDepends = [
          base Cabal gi-cairo gi-gdkpixbuf gi-gio gi-glib gi-gobject gi-pango
          haskell-gi
···
        license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) gtk3;};
 
-  "gi-gdk_4_0_4" = callPackage
+  "gi-gdk_4_0_5" = callPackage
     ({ mkDerivation, base, bytestring, Cabal, containers, gi-cairo
      , gi-gdkpixbuf, gi-gio, gi-glib, gi-gobject, gi-pango, gtk4
      , haskell-gi, haskell-gi-base, haskell-gi-overloading, text
···
      }:
      mkDerivation {
        pname = "gi-gdk";
-       version = "4.0.4";
-       sha256 = "1ah515cakq6w9bbwq393xbpx326v9xincvhgihqsc67gjcqpbva4";
+       version = "4.0.5";
+       sha256 = "1pa8vbm931xq3rb9xr441sccga9h1y03lzf6hp2rwkhyhs006hax";
        setupHaskellDepends = [
          base Cabal gi-cairo gi-gdkpixbuf gi-gio gi-glib gi-gobject gi-pango
          haskell-gi
···
      }:
      mkDerivation {
        pname = "gi-gdkpixbuf";
-       version = "2.0.28";
-       sha256 = "01fjx8nwy27mlhhh3p8qi1z8xcbzi7cs07x01hk8kxrmvd71a2pf";
+       version = "2.0.29";
+       sha256 = "16j3pilr5ffcgxp598svdsbjsgh3ds9a24frkp4ph2g2sjmzdcrk";
        setupHaskellDepends = [
          base Cabal gi-gio gi-glib gi-gmodule gi-gobject haskell-gi
        ];
···
      }:
      mkDerivation {
        pname = "gi-gdkx11";
-       version = "3.0.12";
-       sha256 = "0lx5c13i4g4jy47zpkhd3nn714d7n2ljqib4p4ylgs9cyj145hd4";
+       version = "3.0.13";
+       sha256 = "0qakqwx59r389nnp2zxcknsri8lm9bzgm9nk7vx4mpsrff65138i";
        setupHaskellDepends = [
          base Cabal gi-cairo gi-gdk gi-gio gi-gobject gi-xlib haskell-gi
        ];
···
        license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) gtk3;};
 
-  "gi-gdkx11_4_0_4" = callPackage
+  "gi-gdkx11_4_0_5" = callPackage
     ({ mkDerivation, base, bytestring, Cabal, containers, gi-cairo
      , gi-gdk, gi-gio, gi-gobject, gi-xlib, gtk4-x11, haskell-gi
      , haskell-gi-base, haskell-gi-overloading, text, transformers
      }:
      mkDerivation {
        pname = "gi-gdkx11";
-       version = "4.0.4";
-       sha256 = "1bbwy8sqn642y0yv10l65p2f7zc3nb14mcdwfd2k3cqpmyyhq0ns";
+       version = "4.0.5";
+       sha256 = "0pzsacizbxljl7fm0939fr9vpi6zgl6by89glvklv8imln59pl78";
        setupHaskellDepends = [
          base Cabal gi-cairo gi-gdk gi-gio gi-gobject gi-xlib haskell-gi
        ];
···
      }:
      mkDerivation {
        pname = "gi-ges";
-       version = "1.0.1";
-       sha256 = "1xx6n88bdfxp8xjgvwwrgam8ky7gaswg3kdpz817g7x2l2j2d14n";
+       version = "1.0.2";
+       sha256 = "1qmf1f2a9lmhzbif638r1npbjzv6bpm2r7j51nb4bpbv5vmggl6j";
        setupHaskellDepends = [
          base Cabal gi-gio gi-glib gi-gobject gi-gst gi-gstpbutils
          gi-gstvideo haskell-gi
···
      }:
      mkDerivation {
        pname = "gi-ggit";
-       version = "1.0.11";
-       sha256 = "06hkq87q8a69ini8drwld4pd8z26mlysk9vkigpkigwlbsizjjm7";
+       version = "1.0.12";
+       sha256 = "13n717b5f0p156yvwp9hnp3ma31blgdc3b378cx0b97h0533msyl";
        setupHaskellDepends = [
          base Cabal gi-gio gi-glib gi-gobject haskell-gi
        ];
···
      }:
      mkDerivation {
        pname = "gi-gio";
-       version = "2.0.29";
-       sha256 = "14kh1qdayi55flf2108ivq7sc1k9qd8dish19jbdij198hsjgria";
+       version = "2.0.30";
+       sha256 = "186a8bk2s94awnq4w50w2msdjs08a1mknxb2417qpwzc5yy1f9q3";
        setupHaskellDepends = [ base Cabal gi-glib gi-gobject haskell-gi ];
        libraryHaskellDepends = [
          base bytestring containers gi-glib gi-gobject haskell-gi
···
      }:
      mkDerivation {
        pname = "gi-girepository";
-       version = "1.0.25";
-       sha256 = "0xpydz66vmb8f46ql2h8rq486i4pf5nbjm98839iyhsv653plxp0";
+       version = "1.0.26";
+       sha256 = "0nlxzs5i1wjli5bczlvab6ch4d2lwai1zab2yiz1l9bw3qkzkbiz";
        setupHaskellDepends = [ base Cabal gi-glib gi-gobject haskell-gi ];
        libraryHaskellDepends = [
          base bytestring containers gi-glib gi-gobject haskell-gi
···
      }:
      mkDerivation {
        pname = "gi-glib";
-       version = "2.0.26";
-       sha256 = "0i38ch8giqs92kkfzyw4wlz8y0r5kn2h94b6y33nj4ja3ggrg1qm";
+       version = "2.0.27";
+       sha256 = "0cd0kbl7lsk5jjilhcs8969xaa7ncm81ilpdsqpxvdm2hgrg06y2";
        setupHaskellDepends = [ base Cabal haskell-gi ];
        libraryHaskellDepends = [
          base bytestring containers haskell-gi haskell-gi-base
···
      }:
      mkDerivation {
        pname = "gi-gmodule";
-       version = "2.0.2";
-       sha256 = "1jbplvicc6jsjcz8gqkiq71b8cx57m010wbq2ilirv4rif90ggnx";
+       version = "2.0.3";
+       sha256 = "043n3nyxy29chzc7xzhinp40yxazlikqcjdbm3pvh344jv7m5xjx";
        setupHaskellDepends = [ base Cabal gi-glib haskell-gi ];
        libraryHaskellDepends = [
          base bytestring containers gi-glib haskell-gi haskell-gi-base
···
      }:
      mkDerivation {
        pname = "gi-gobject";
-       version = "2.0.27";
-       sha256 = "1xfw8jg81pbhgb20kw2jvhbxcs8d0sl4zf3dsar9sy7gl4lgwh0g";
+       version = "2.0.28";
+       sha256 = "0av574yvvbky1pm187fmjkmy52lssvv74zad30818qbkzpkwfdx8";
        setupHaskellDepends = [ base Cabal gi-glib haskell-gi ];
        libraryHaskellDepends = [
          base bytestring containers gi-glib haskell-gi haskell-gi-base
···
      }:
      mkDerivation {
        pname = "gi-graphene";
-       version = "1.0.4";
-       sha256 = "0c1dh5jzmqm5ysv296c37ma8miscpba1z1kq7b4l9sfmnhi4blsa";
+       version = "1.0.5";
+       sha256 = "0633cf1n4lzrh0v5ksip4y4qizahyi3cv2njsg0bix802c4pd8rs";
        setupHaskellDepends = [ base Cabal gi-glib gi-gobject haskell-gi ];
        libraryHaskellDepends = [
          base bytestring containers gi-glib gi-gobject haskell-gi
···
      }:
      mkDerivation {
        pname = "gi-gsk";
-       version = "4.0.4";
-       sha256 = "0y2gpxy4bl3k1br3d6lm7javzw1q5r499lqhas028gawbfba6s4x";
+       version = "4.0.5";
+       sha256 = "02zmzywk0yyrg1rffwsiq6whxwk8f4mpg3vmybrr91iih9pv36g3";
        setupHaskellDepends = [
          base Cabal gi-cairo gi-gdk gi-gdkpixbuf gi-glib gi-gobject
          gi-graphene gi-pango haskell-gi
···
      }:
      mkDerivation {
        pname = "gi-gst";
-       version = "1.0.25";
-       sha256 = "1rx7arlghfvkh4ccl5dd40a108d4kmr2fmwrrgl22z7k2xgl0wqp";
+       version = "1.0.26";
+       sha256 = "1d1sidmhszdpcka3bf4xiph2896z1ipvjfvlyjy50lahz9igr2lq";
        setupHaskellDepends = [ base Cabal gi-glib gi-gobject haskell-gi ];
        libraryHaskellDepends = [
          base bytestring containers gi-glib gi-gobject haskell-gi
···
      }:
      mkDerivation {
        pname = "gi-gstaudio";
-       version = "1.0.24";
-       sha256 = "09xfss2q4bywnidfqyq57zdma3qwhx7sl40qg7qdqhma36axxryk";
+       version = "1.0.25";
+       sha256 = "1brrhplrahbhyk4yn1bmxlz6pf9ynwbrr1yvblz35x8lrinw9086";
        setupHaskellDepends = [
          base Cabal gi-glib gi-gobject gi-gst gi-gstbase haskell-gi
        ];
···
      }:
      mkDerivation {
        pname = "gi-gstbase";
-       version = "1.0.25";
-       sha256 = "179qi645giqkfdrig07l54wn2dj5wicjfhyy7m9132imxh8czcg9";
+       version = "1.0.26";
+       sha256 = "0n4szf0mf1hnylh30k16x7af7kzvsqbk9niyanqa73i7bh972j3m";
        setupHaskellDepends = [
          base Cabal gi-glib gi-gobject gi-gst haskell-gi
        ];
···
      }:
      mkDerivation {
        pname = "gi-gstpbutils";
-       version = "1.0.24";
-       sha256 = "18sxnrx5wbr1fbmvrjk6v09nc5q2xxm36vmlbd331314fpr0ic7m";
+       version = "1.0.25";
+       sha256 = "1ymm8qi4w72qqdwlb6ynmbhfdh47biijjp361vkax0d66rjjlz8l";
        setupHaskellDepends = [
          base Cabal gi-glib gi-gobject gi-gst gi-gstaudio gi-gsttag
          gi-gstvideo haskell-gi
···
      }:
      mkDerivation {
        pname = "gi-gsttag";
-       version = "1.0.24";
-       sha256 = "0l7h2r2q3sn8li1qq7bidplh1vic9w4054qnrimxhpndkcd8gxsk";
+       version = "1.0.25";
+       sha256 = "1k6fwddap8y2iy32aihf1771kwjb2xmqxs0jgvl4pqh7z1gk1xhf";
        setupHaskellDepends = [
          base Cabal gi-glib gi-gobject gi-gst gi-gstbase haskell-gi
        ];
···
      }:
      mkDerivation {
        pname = "gi-gstvideo";
-       version = "1.0.25";
-       sha256 = "1zkzs7qkzfp8ixkagbqkmgylla7msdjg83sdf2qwmgcmzfk480c7";
+       version = "1.0.26";
+       sha256 = "1bwfqxq4h2c2n7bl3hxrv7ykd97kxnhdck5w9wvd6abm2p18r4w0";
        setupHaskellDepends = [
          base Cabal gi-glib gi-gobject gi-gst gi-gstbase haskell-gi
        ];
···
      }:
      mkDerivation {
        pname = "gi-gtk";
-       version = "3.0.38";
-       sha256 = "0xnz5969v9nz6llg7856zdn3pcn1llvr1p0jl8vxk4n5wrwgqjms";
+       version = "3.0.39";
+       sha256 = "0ib53hq6wds44z636frbph2pmzy1bjpkc1kyxx9y09yj5bg3mm6k";
        setupHaskellDepends = [
          base Cabal gi-atk gi-cairo gi-gdk gi-gdkpixbuf gi-gio gi-glib
          gi-gobject gi-pango haskell-gi
···
        license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) gtk3;};
 
-  "gi-gtk_4_0_5" = callPackage
+  "gi-gtk_4_0_6" = callPackage
     ({ mkDerivation, base, bytestring, Cabal, containers, gi-atk
      , gi-cairo, gi-gdk, gi-gdkpixbuf, gi-gio, gi-glib, gi-gobject
      , gi-graphene, gi-gsk, gi-pango, gtk4, haskell-gi, haskell-gi-base
···
      }:
      mkDerivation {
        pname = "gi-gtk";
-       version = "4.0.5";
-       sha256 = "04ph4adisr51j5dy2lpp0kxp06m332dfxmq92rnq3w0l810z2hi8";
+       version = "4.0.6";
+       sha256 = "146x3xp12jl416gl75mdx6jgnh0ayh9s64f7nl5ccw5r7dw8fz6f";
        setupHaskellDepends = [
          base Cabal gi-atk gi-cairo gi-gdk gi-gdkpixbuf gi-gio gi-glib
          gi-gobject gi-graphene gi-gsk gi-pango haskell-gi
···
      }:
      mkDerivation {
        pname = "gi-gtk-hs";
-       version = "0.3.12";
-       sha256 = "1ph9fq2lwa16pq68vkmp2843n0hjx89zfjmxs80lsv41bkvza8qy";
+       version = "0.3.13";
+       sha256 = "0w9bjhny6l2ll83ffcdmdzgnza0gfgyqv8v161pj080lsq00fdli";
        libraryHaskellDepends = [
          base base-compat containers gi-gdk gi-gdkpixbuf gi-glib gi-gobject
          gi-gtk haskell-gi-base mtl text transformers
···
      }:
      mkDerivation {
        pname = "gi-gtk-layer-shell";
-       version = "0.1.2";
-       sha256 = "0sdf71nqk3yxpyh7qdk65glg97nwc2almk852rqjlgjnlmjnyyx0";
+       version = "0.1.3";
+       sha256 = "0ywv7qy50hi1a1dc83zj2zwvilsvz69v8dld1cvs9njp3y83wai6";
        setupHaskellDepends = [ base Cabal gi-gdk gi-gtk haskell-gi ];
        libraryHaskellDepends = [
          base bytestring containers gi-gdk gi-gtk haskell-gi haskell-gi-base
···
      }:
      mkDerivation {
        pname = "gi-gtksource";
-       version = "3.0.25";
-       sha256 = "0fxfl1gc75ffp7h1dmqwig681zw578rplhpb87bhhb811sw11ibd";
+       version = "3.0.26";
+       sha256 = "0xax0w5zxiqw2nhz3ndl6kyxfa61n1ldwq3r6s1i0khz0xx79k5q";
        setupHaskellDepends = [
          base Cabal gi-atk gi-cairo gi-gdk gi-gdkpixbuf gi-gio gi-glib
          gi-gobject gi-gtk gi-pango haskell-gi
···
      }:
      mkDerivation {
        pname = "gi-handy";
-       version = "1.0.1";
-       sha256 = "0i8lvwb4kzfnqnlj7bdy4pvif4hhaxpdkn2rga3i8l78cmm8y4kh";
+       version = "1.0.2";
+       sha256 = "1kr135nnyxik670arjm0h8d9mrwm1a002grmiivayzggcxx22625";
        setupHaskellDepends = [
          base Cabal gi-atk gi-gdk gi-gdkpixbuf gi-gio gi-glib gi-gobject
          gi-gtk gi-pango haskell-gi
···
      }:
      mkDerivation {
        pname = "gi-harfbuzz";
-       version = "0.0.6";
-       sha256 = "05jmh8mhx17jys9620shbkz1nc9jvfjr7snmpq2lxpvq2fw813ss";
+       version = "0.0.7";
+       sha256 = "05w123b1w3bjbaj0wq82b51bx4vnfbb6qcsd94svbhxgi705sjfx";
        setupHaskellDepends = [
          base Cabal gi-freetype2 gi-glib gi-gobject haskell-gi
        ];
···
      }:
      mkDerivation {
        pname = "gi-ibus";
-       version = "1.5.4";
-       sha256 = "0lrczkck1w0pydzsrjlf25m6pxri1kjd9hw7rz1wis36ahqvhbvr";
+       version = "1.5.5";
+       sha256 = "0chppwjmz2bqjwga62q6sbdkhjahyw4cmp6w9p8kyra40dwr97mv";
        setupHaskellDepends = [
          base Cabal gi-gio gi-glib gi-gobject haskell-gi
        ];
···
      }:
      mkDerivation {
        pname = "gi-javascriptcore";
-       version = "4.0.24";
-       sha256 = "1jr7yp6hxcp2vqaa0s320hqhdfaflyby6rvgb2pfm9qs1dqzafsn";
+       version = "4.0.25";
+       sha256 = "1dcg3c9df2gg6vqrv7ai18lnxw6zlwn6qyn2k10p4d4h0dpq9ck8";
        setupHaskellDepends = [ base Cabal gi-glib gi-gobject haskell-gi ];
        libraryHaskellDepends = [
          base bytestring containers gi-glib gi-gobject haskell-gi
···
      }:
      mkDerivation {
        pname = "gi-json";
-       version = "1.0.2";
-       sha256 = "00qxmkdr9rl77aimfqk2s8m56anpy4fcn0b6m2k5dr4f9xf1i4nq";
+       version = "1.0.3";
+       sha256 = "1vmrliim4czlb35y44nxc3rxsrb3cp02c0v8niaps6kmiyv93hg9";
        setupHaskellDepends = [
          base Cabal gi-gio gi-glib gi-gobject haskell-gi
        ];
···
      }:
      mkDerivation {
        pname = "gi-notify";
-       version = "0.7.24";
-       sha256 = "1dgjj1nqy2b37si8y5g5m12nrbqkfx8z6hir0gsvymfkbzfcx7j1";
+       version = "0.7.25";
+       sha256 = "034kya0mmzr9djnhrpwqpp02x4bmv681w1bcl2bga3napp4ayirv";
        setupHaskellDepends = [
          base Cabal gi-gdkpixbuf gi-glib gi-gobject haskell-gi
        ];
···
      }:
      mkDerivation {
        pname = "gi-ostree";
-       version = "1.0.15";
-       sha256 = "1lrblmsn91an1mqv4iml235bbwx1yz0llhyzf62jr65krs11jhwd";
+       version = "1.0.16";
+       sha256 = "0sq9nphsap5q9fryk2vpd6r67y791gcrzcap3w2b4n6i34ziv7rm";
        setupHaskellDepends = [
          base Cabal gi-gio gi-glib gi-gobject haskell-gi
        ];
···
      }:
      mkDerivation {
        pname = "gi-pango";
-       version = "1.0.26";
-       sha256 = "1x1d4v5g6sxw12pcq7qrv4kyr7wkv755wqzdal2z9l2qzr1bqssz";
+       version = "1.0.27";
+       sha256 = "00v6kn1k9rzlncl867xwbis1jqy5vc12gkmbsij4hxfjr9h0h1cq";
        setupHaskellDepends = [
          base Cabal gi-gio gi-glib gi-gobject gi-harfbuzz haskell-gi
        ];
···
 
   "gi-pangocairo" = callPackage
     ({ mkDerivation, base, bytestring, Cabal, cairo, containers
-     , gi-cairo, gi-glib, gi-gobject, gi-pango, haskell-gi
+     , gi-cairo, gi-gio, gi-glib, gi-gobject, gi-pango, haskell-gi
      , haskell-gi-base, haskell-gi-overloading, pango, text
      , transformers
      }:
      mkDerivation {
        pname = "gi-pangocairo";
-       version = "1.0.26";
-       sha256 = "0alm4v7dl44pv3ydw5fg4x6w6yzghjscnzd1qi6jbv1pqrv0f3xm";
+       version = "1.0.28";
+       sha256 = "06jld35ncq6yharggvdbcsy2g13gh5mq4j26w88yik0x4jiqz2j1";
        setupHaskellDepends = [
-         base Cabal gi-cairo gi-glib gi-gobject gi-pango haskell-gi
+         base Cabal gi-cairo gi-gio gi-glib gi-gobject gi-pango haskell-gi
        ];
        libraryHaskellDepends = [
-         base bytestring containers gi-cairo gi-glib gi-gobject gi-pango
-         haskell-gi haskell-gi-base haskell-gi-overloading text transformers
+         base bytestring containers gi-cairo gi-gio gi-glib gi-gobject
+         gi-pango haskell-gi haskell-gi-base haskell-gi-overloading text
+         transformers
        ];
        libraryPkgconfigDepends = [ cairo pango ];
        preCompileBuildDriver = ''
···
      }:
      mkDerivation {
        pname = "gi-poppler";
-       version = "0.18.26";
-       sha256 = "1wxm7fx1xjj2a332mh2sr1pz994aici888x69a197ccnn8p3g75k";
+       version = "0.18.27";
+       sha256 = "1qg81j5b40hics97diafqjxk7sw32fvlqv277awnym24m6f96lj3";
        setupHaskellDepends = [
          base Cabal gi-cairo gi-gio gi-glib gi-gobject haskell-gi
        ];
···
      }:
      mkDerivation {
        pname = "gi-rsvg";
-       version = "2.0.2";
-       sha256 = "1c9rmawsz12i6rlq8s3mhsj8q5a7q3809y8bf1yq6nzvzkm8gsrj";
+       version = "2.0.3";
+       sha256 = "1j7mqfl6f0zs1yhw6z0sai6ckc9hgmqqwbqifr08yfshzfsp951v";
        setupHaskellDepends = [
          base Cabal gi-cairo gi-gdkpixbuf gi-gio gi-glib gi-gobject
          haskell-gi
···
      }:
      mkDerivation {
        pname = "gi-secret";
-       version = "0.0.14";
-       sha256 = "1n03lk4x7inkq68z9krv3jgkpjsya8jjyim09qzb83cj77wb67m8";
+       version = "0.0.15";
+       sha256 = "11lg3lj731d0xajr5dhw5dpgws894q78nvvlj3g5i6w3y2dn9x05";
        setupHaskellDepends = [
          base Cabal gi-gio gi-glib gi-gobject haskell-gi
        ];
···
      }:
      mkDerivation {
        pname = "gi-soup";
-       version = "2.4.25";
-       sha256 = "1rpl5q9xwfbbhzg7220855mb15qpdpx668gs7lxj7w26arp8xzcs";
+       version = "2.4.26";
+       sha256 = "1kxkbhllc04klg570ziwwgybsp97a7xq6gb8ggzf9hyr1ys77rq4";
        setupHaskellDepends = [
          base Cabal gi-gio gi-glib gi-gobject haskell-gi
        ];
···
      }:
      mkDerivation {
        pname = "gi-vips";
-       version = "8.0.2";
-       sha256 = "055vlgxnvvdsq86d09jcv7d7fp0msw0gg95fm2vkpx3n1zx00z6j";
+       version = "8.0.3";
+       sha256 = "1vzrnmifisyxakvkp6mgwgn0gqr8gwfa06cwyzhslma0snlnrk3v";
        setupHaskellDepends = [ base Cabal gi-glib gi-gobject haskell-gi ];
        libraryHaskellDepends = [
          base bytestring containers gi-glib gi-gobject haskell-gi
···
      }:
      mkDerivation {
        pname = "gi-vte";
-       version = "2.91.29";
-       sha256 = "15c1vmkk4h723qjvmq30rcqfk5b5kihcjdqmncmgshi2qv80aa2q";
+       version = "2.91.30";
+       sha256 = "1n787xacng9279y7vi2g4lmxvx8xgb967v55fxvmxhjyds35fy4w";
        setupHaskellDepends = [
          base Cabal gi-atk gi-gdk gi-gio gi-glib gi-gobject gi-gtk gi-pango
          haskell-gi
···
      }:
      mkDerivation {
        pname = "gi-webkit2";
-       version = "4.0.28";
-       sha256 = "0k6y33vg6641a4qis2ypnj8xms40a203y0as299rsj0l5rk9ykaw";
+       version = "4.0.29";
+       sha256 = "1ccpa6dvl68drpbpi372arjx3rw5ypgbdifvl5cd4c822hvjbq4h";
        setupHaskellDepends = [
          base Cabal gi-atk gi-cairo gi-gdk gi-gio gi-glib gi-gobject gi-gtk
          gi-javascriptcore gi-soup haskell-gi
···
      }:
      mkDerivation {
        pname = "gi-webkit2webextension";
-       version = "4.0.27";
-       sha256 = "1m00h1yrnq6b5h635rpwhcdhvls3rg6lcp5gq3n22rqr131fsrr9";
+       version = "4.0.28";
+       sha256 = "0zrpma7vxg5x375w1avw8s7cw9s9psh79z846czjpkidxh66995f";
        setupHaskellDepends = [
          base Cabal gi-gio gi-gobject gi-gtk gi-javascriptcore gi-soup
          haskell-gi
···
 
   "gi-wnck" = callPackage
     ({ mkDerivation, base, bytestring, Cabal, containers, gi-atk
-     , gi-gdk, gi-gdkpixbuf, gi-gobject, gi-gtk, haskell-gi
-     , haskell-gi-base, haskell-gi-overloading, libwnck, text
-     , transformers
+     , gi-cairo, gi-gdk, gi-gdkpixbuf, gi-glib, gi-gobject, gi-gtk
+     , haskell-gi, haskell-gi-base, haskell-gi-overloading, libwnck
+     , text, transformers
      }:
      mkDerivation {
        pname = "gi-wnck";
-       version = "3.0.11";
-       sha256 = "0jhsr7skjn7i3klnfm9z2fg2gfl5mqsp7hd8ajlkjv7z8xk25j1w";
+       version = "3.0.13";
+       sha256 = "19m259gnh7haq9kaa60z3wnd3x0s2ir49g6jjc499l4rmmvga5gp";
        setupHaskellDepends = [
-         base Cabal gi-atk gi-gdk gi-gdkpixbuf gi-gobject gi-gtk haskell-gi
+         base Cabal gi-atk gi-cairo gi-gdk gi-gdkpixbuf gi-glib gi-gobject
+         gi-gtk haskell-gi
        ];
        libraryHaskellDepends = [
-         base bytestring containers gi-atk gi-gdk gi-gdkpixbuf gi-gobject
-         gi-gtk haskell-gi haskell-gi-base haskell-gi-overloading text
-         transformers
+         base bytestring containers gi-atk gi-cairo gi-gdk gi-gdkpixbuf
+         gi-glib gi-gobject gi-gtk haskell-gi haskell-gi-base
+         haskell-gi-overloading text transformers
        ];
        libraryPkgconfigDepends = [ libwnck ];
        description = "Wnck bindings";
···
      }:
      mkDerivation {
        pname = "gi-xlib";
-       version = "2.0.11";
-       sha256 = "0l6xr26asmy3rvzi5lazkfpik1n41v9a7bg2pypssc26130amp1f";
+       version = "2.0.12";
+       sha256 = "0dy1xfzbhkyh7nj270mmz1acnwdf0f7c3rzz31lw9zrjyf9670gj";
        setupHaskellDepends = [ base Cabal haskell-gi ];
        libraryHaskellDepends = [
          base bytestring containers haskell-gi haskell-gi-base
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "githash_0_1_6_3" = callPackage
+    ({ mkDerivation, base, bytestring, directory, filepath, hspec
+     , process, template-haskell, temporary, th-compat, unliftio
+     }:
+     mkDerivation {
+       pname = "githash";
+       version = "0.1.6.3";
+       sha256 = "06zg1rif1rcxni1vacmr2bh1nbm6i62rjbikfr4xsyzq1sv7kfpw";
+       libraryHaskellDepends = [
+         base bytestring directory filepath process template-haskell
+         th-compat
+       ];
+       testHaskellDepends = [
+         base bytestring directory filepath hspec process template-haskell
+         temporary th-compat unliftio
+       ];
+       description = "Compile git revision info into Haskell projects";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "github" = callPackage
     ({ mkDerivation, aeson, base, base-compat, base16-bytestring
      , binary, binary-instances, bytestring, containers, cryptohash-sha1
···
      }:
      mkDerivation {
        pname = "githud";
-       version = "3.2.2";
-       sha256 = "19z21w6qxfndh381gcyi1ap14map886pkkc3nax8s417mv744ag3";
+       version = "3.3.0";
+       sha256 = "0pwjh87kk3kvlan16mk0ki4pvz5iyb3r4dnb51z0y8xzdccwisaz";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "gitson";
        version = "0.5.2";
        sha256 = "15i1xj3z0gxvxqgwh5902cna6ig5pixxkcrdgsvhpsk4mbkxc7b7";
+       revision = "1";
+       editedCabalFile = "1ddjx87n53r6nawgidig3xfv9a13gpxj915fjbglk9ps2pp4dckm";
        libraryHaskellDepends = [
          aeson aeson-pretty base base-compat bytestring conduit-combinators
          conduit-extra directory errors filepath flock lifted-base
···
      }:
      mkDerivation {
        pname = "glabrous";
-       version = "2.0.5";
-       sha256 = "1yxyyjjhfi30ymd0v80xrn4m81m2hs3v5slbdd2hc856k91lmghg";
-       libraryHaskellDepends = [
-         aeson aeson-pretty attoparsec base bytestring cereal cereal-text
-         either text unordered-containers
-       ];
-       testHaskellDepends = [
-         base directory either hspec text unordered-containers
-       ];
-       description = "A template DSL library";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "glabrous_2_0_6" = callPackage
-    ({ mkDerivation, aeson, aeson-pretty, attoparsec, base, bytestring
-     , cereal, cereal-text, directory, either, hspec, text
-     , unordered-containers
-     }:
-     mkDerivation {
-       pname = "glabrous";
        version = "2.0.6";
        sha256 = "1yz2h8x8hhy8nqy2pppax0mbb3k2ydcspbyngy19afphxxd5bbkz";
        libraryHaskellDepends = [
···
        ];
        description = "A template DSL library";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "glade" = callPackage
···
      }:
      mkDerivation {
        pname = "grammatical-parsers";
-       version = "0.6";
-       sha256 = "1ck7zv110yrwz04q10j38wx6ipap88np9px6l94rxbha1m1k7nhi";
+       version = "0.7";
+       sha256 = "0582mr13z5bq71s76ngvm01dfrg68mw968mad0m4nbfx147za0ih";
        isLibrary = true;
        isExecutable = true;
        setupHaskellDepends = [ base Cabal cabal-doctest ];
···
        testToolDepends = [ markdown-unlit ];
        description = "A simple interface for generating persistent data and linking its dependencies";
        license = lib.licenses.mit;
+     }) {};
+
+  "graphula_2_0_2_2" = callPackage
+    ({ mkDerivation, base, containers, directory, generic-arbitrary
+     , generics-eot, hspec, HUnit, markdown-unlit, monad-logger, mtl
+     , persistent, persistent-sqlite, QuickCheck, random, resourcet
+     , semigroups, temporary, text, transformers, unliftio
+     , unliftio-core
+     }:
+     mkDerivation {
+       pname = "graphula";
+       version = "2.0.2.2";
+       sha256 = "066lcn262x4l826sglybrz4mp58ishcj0h1r5h41aiy09mcf4g3v";
+       libraryHaskellDepends = [
+         base containers directory generics-eot HUnit mtl persistent
+         QuickCheck random semigroups temporary text unliftio unliftio-core
+       ];
+       testHaskellDepends = [
+         base generic-arbitrary hspec markdown-unlit monad-logger persistent
+         persistent-sqlite QuickCheck resourcet transformers unliftio-core
+       ];
+       testToolDepends = [ markdown-unlit ];
+       description = "A simple interface for generating persistent data and linking its dependencies";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "graphula-core" = callPackage
···
        broken = true;
      }) {};
 
+  "h-raylib" = callPackage
+    ({ mkDerivation, base, c, libGL, libX11 }:
+     mkDerivation {
+       pname = "h-raylib";
+       version = "4.5.0.1";
+       sha256 = "1bb0g8gn08pp2s763d0ic7hj46whpb6xdq0hvpar26srxlkxnzjl";
+       libraryHaskellDepends = [ base ];
+       librarySystemDepends = [ c libGL libX11 ];
+       description = "Raylib bindings for Haskell";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {c = null; inherit (pkgs) libGL; inherit (pkgs.xorg) libX11;};
+
   "h-reversi" = callPackage
     ({ mkDerivation, base, blank-canvas, containers, hspec, QuickCheck
      , split, stm, text
···
      }) {};
 
   "hanabi-dealer" = callPackage
-    ({ mkDerivation, base, containers, random }:
+    ({ mkDerivation, array, base, containers, random, tf-random }:
      mkDerivation {
        pname = "hanabi-dealer";
-       version = "0.11.0.2";
-       sha256 = "1ndg8zmcc5a9z9qcc5z5nwssywxighnqxa4pzc5iy7kw4x9bm3kn";
+       version = "0.15.1.1";
+       sha256 = "1ldyr5jqlr97kjk4pgqrc15rh11cx5wy3fydmzk6laknpqyshvr3";
        isLibrary = true;
        isExecutable = true;
-       libraryHaskellDepends = [ base containers random ];
+       libraryHaskellDepends = [ array base containers random tf-random ];
        description = "Hanabi card game";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
···
      }:
      mkDerivation {
        sha256 = "1l3pq6i9npbyzh0bv8qb315l50zhv81s5rqqnc8k27rlrabirndb";
-       sha256 = "1l3pq6i9npbyzh0bv8qb315l50zhv81s5rqqnc8k27rlrabirndb";
-       sha256 = "1l3pq6i9npbyzh0bv8qb315l50zhv81s5rqqnc8k27rlrabirndb";
+       version = "0.0.37.0";
+       sha256 = "1srinycpz3zb86r6b1kyn0ikc8hd62vzgig9ki0lddrxjxc637gg";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.lgpl21Only;
        sha256 = "1l3pq6i9npbyzh0bv8qb315l50zhv81s5rqqnc8k27rlrabirndb";
 
+  "haskell-gi_0_26_2" = callPackage
+       sha256 = "1l3pq6i9npbyzh0bv8qb315l50zhv81s5rqqnc8k27rlrabirndb";
+       sha256 = "1l3pq6i9npbyzh0bv8qb315l50zhv81s5rqqnc8k27rlrabirndb";
+       sha256 = "1l3pq6i9npbyzh0bv8qb315l50zhv81s5rqqnc8k27rlrabirndb";
+       sha256 = "1l3pq6i9npbyzh0bv8qb315l50zhv81s5rqqnc8k27rlrabirndb";
+     }:
+     mkDerivation {
+       sha256 = "1l3pq6i9npbyzh0bv8qb315l50zhv81s5rqqnc8k27rlrabirndb";
+       version = "0.26.2";
+       sha256 = "05r84czb05n69g7p7jazljh95yzdh2lpzgjjypgpg75mh83igr2w";
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
+       libraryHaskellDepends = [
+       sha256 = "1l3pq6i9npbyzh0bv8qb315l50zhv81s5rqqnc8k27rlrabirndb";
+       sha256 = "1l3pq6i9npbyzh0bv8qb315l50zhv81s5rqqnc8k27rlrabirndb";
+       sha256 = "1l3pq6i9npbyzh0bv8qb315l50zhv81s5rqqnc8k27rlrabirndb";
+       ];
+       sha256 = "1l3pq6i9npbyzh0bv8qb315l50zhv81s5rqqnc8k27rlrabirndb";
+       sha256 = "1l3pq6i9npbyzh0bv8qb315l50zhv81s5rqqnc8k27rlrabirndb";
+       sha256 = "1l3pq6i9npbyzh0bv8qb315l50zhv81s5rqqnc8k27rlrabirndb";
+       license = lib.licenses.lgpl21Only;
+       hydraPlatforms = lib.platforms.none;
+       sha256 = "1l3pq6i9npbyzh0bv8qb315l50zhv81s5rqqnc8k27rlrabirndb";
+
        sha256 = "1l3pq6i9npbyzh0bv8qb315l50zhv81s5rqqnc8k27rlrabirndb";
        sha256 = "1l3pq6i9npbyzh0bv8qb315l50zhv81s5rqqnc8k27rlrabirndb";
      mkDerivation {
        sha256 = "1l3pq6i9npbyzh0bv8qb315l50zhv81s5rqqnc8k27rlrabirndb";
-       sha256 = "1l3pq6i9npbyzh0bv8qb315l50zhv81s5rqqnc8k27rlrabirndb";
-       sha256 = "1l3pq6i9npbyzh0bv8qb315l50zhv81s5rqqnc8k27rlrabirndb";
+       version = "0.26.2";
+       sha256 = "1jlc8hwpg2mbhmv6ra8b2dsf1wqsfn0hrphikrbgvbcls2wd6xw0";
        libraryHaskellDepends = [ base bytestring containers text ];
        libraryPkgconfigDepends = [ glib ];
        sha256 = "1l3pq6i9npbyzh0bv8qb315l50zhv81s5rqqnc8k27rlrabirndb";
        license = lib.licenses.lgpl21Only;
+     }) {inherit (pkgs) glib;};
+
+  "haskell-gi-base_0_26_3" = callPackage
+       sha256 = "1l3pq6i9npbyzh0bv8qb315l50zhv81s5rqqnc8k27rlrabirndb";
+     mkDerivation {
+       sha256 = "1l3pq6i9npbyzh0bv8qb315l50zhv81s5rqqnc8k27rlrabirndb";
+       version = "0.26.3";
+       sha256 = "1n0pgyd5gm4lic3c48cvl10chk15jdd1d381f3fcizp61rhslvfs";
+       libraryHaskellDepends = [ base bytestring containers text ];
+       libraryPkgconfigDepends = [ glib ];
+       sha256 = "1l3pq6i9npbyzh0bv8qb315l50zhv81s5rqqnc8k27rlrabirndb";
+       license = lib.licenses.lgpl21Only;
+       hydraPlatforms = lib.platforms.none;
      }) {inherit (pkgs) glib;};
 
        sha256 = "1l3pq6i9npbyzh0bv8qb315l50zhv81s5rqqnc8k27rlrabirndb";
···
        license = lib.licenses.mit;
      }) {};
 
-  "hasql_1_6_1_4" = callPackage
+  "hasql_1_6_2" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, bytestring
      , bytestring-strict-builder, contravariant, contravariant-extras
      , dlist, gauge, hashable, hashtables, mtl, network-ip
···
      }:
      mkDerivation {
        pname = "hasql";
-       version = "1.6.1.4";
-       sha256 = "1x3frmckky3yxi5p2p76v4cx9gv0hd2iyvd2mgd359cgdcvnlvzp";
+       version = "1.6.2";
+       sha256 = "1ph1di36lhhi2y542cc5mm0pprq1j6yb2i69bwms59173amh8gcx";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring bytestring-strict-builder
          contravariant dlist hashable hashtables mtl network-ip
···
        license = lib.licenses.mit;
      }) {};
 
-  "hasql-pool_0_8_0_4" = callPackage
-    ({ mkDerivation, async, base, hasql, hspec, rerebase, stm, time
+  "hasql-pool_0_8_0_6" = callPackage
+    ({ mkDerivation, async, base, hasql, hspec, rerebase, stm
      , transformers
      }:
      mkDerivation {
        pname = "hasql-pool";
-       version = "0.8.0.4";
-       sha256 = "1zpc79k63pysc5zj7lcj81qm48gs0f6zqv455dpwgyipj7g0ba65";
-       libraryHaskellDepends = [ base hasql stm time transformers ];
+       version = "0.8.0.6";
+       sha256 = "0scpgynr20j8qkhi5gjl0mh7iq713vz7r1zr4xa0jv0s2nd14j2v";
+       libraryHaskellDepends = [ base hasql stm transformers ];
        testHaskellDepends = [ async hasql hspec rerebase stm ];
        description = "Pool of connections for Hasql";
        license = lib.licenses.mit;
···
        pname = "hlrdb-core";
        version = "0.2.0.0";
        sha256 = "0hkjll4v4kxc133b19kk9k4dkrbag6qdw24gwrhikrxlk666jsbl";
+       revision = "1";
+       editedCabalFile = "15pcz7f2alsyccz5id162ka4win9j6l98ygpgaycl6n57vcd3nsv";
        libraryHaskellDepends = [
          base bytestring hashable hedis lens mtl profunctors random time
          unordered-containers
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "hpc_0_6_0_3" = callPackage
-    ({ mkDerivation, base, containers, directory, filepath, time }:
+  "hpc_0_6_2_0" = callPackage
+    ({ mkDerivation, base, containers, deepseq, directory, filepath
+     , time
+     }:
      mkDerivation {
        pname = "hpc";
-       version = "0.6.0.3";
-       sha256 = "1am2fcxg7d3j3kpyhz48wzbpg83dk2jmzhqm4yiib649alzcgnhn";
-       revision = "3";
-       editedCabalFile = "06dbiaf0sangq3zdyr3x9wkvs2fgyas3ipqkfwfmycax6j17jgyy";
+       version = "0.6.2.0";
+       sha256 = "0igq0x3hsdfh4sw40ac8ld5xmsdqxykfz1jmzmwf142za6q7k964";
        libraryHaskellDepends = [
-         base containers directory filepath time
+         base containers deepseq directory filepath time
        ];
        description = "Code Coverage Library for Haskell";
        license = lib.licenses.bsd3;
···
        broken = true;
      }) {inherit (pkgs) postgresql;};
 
-  "hpqtypes_1_10_0_1" = callPackage
-    ({ mkDerivation, aeson, async, base, bytestring, Cabal, containers
-     , directory, exceptions, filepath, HUnit, lifted-base
-     , monad-control, mtl, postgresql, QuickCheck, random, resource-pool
-     , scientific, semigroups, test-framework, test-framework-hunit
-     , text, text-show, time, transformers, transformers-base
-     , unordered-containers, uuid-types, vector
+  "hpqtypes_1_10_0_2" = callPackage
+    ({ mkDerivation, aeson, async, base, bytestring, containers
+     , exceptions, HUnit, libpq, lifted-base, monad-control, mtl
+     , QuickCheck, random, resource-pool, scientific, semigroups
+     , test-framework, test-framework-hunit, text, text-show, time
+     , transformers, transformers-base, unordered-containers, uuid-types
+     , vector
      }:
      mkDerivation {
        pname = "hpqtypes";
-       version = "1.10.0.1";
-       sha256 = "19lakc0m4fgv36kiw9ziyr3abq6jrb6rij443s7a2n3xfrjwy0b8";
-       setupHaskellDepends = [ base Cabal directory filepath ];
+       version = "1.10.0.2";
+       sha256 = "0rrsd16cxh8p0ssayxla99svapkbbl2sn5n9hi8vcf9hazfh8nlw";
        libraryHaskellDepends = [
          aeson async base bytestring containers exceptions lifted-base
          monad-control mtl resource-pool semigroups text text-show time
          transformers transformers-base uuid-types vector
        ];
-       librarySystemDepends = [ postgresql ];
+       libraryPkgconfigDepends = [ libpq ];
        testHaskellDepends = [
          aeson base bytestring exceptions HUnit lifted-base monad-control
          mtl QuickCheck random scientific test-framework
···
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        broken = true;
-     }) {inherit (pkgs) postgresql;};
+     }) {libpq = null;};
+
+  "hpqtypes-effectful" = callPackage
+    ({ mkDerivation, base, effectful-core, exceptions, hpqtypes, tasty
+     , tasty-hunit, text
+     }:
+     mkDerivation {
+       pname = "hpqtypes-effectful";
+       version = "1.0.0.0";
+       sha256 = "0jfg20n5cai2rrx2g2rl2ndamylg31bjf0i66jc7qcwqwp1l1r5j";
+       libraryHaskellDepends = [
+         base effectful-core exceptions hpqtypes
+       ];
+       testHaskellDepends = [
+         base effectful-core exceptions hpqtypes tasty tasty-hunit text
+       ];
+       description = "Adaptation of the hpqtypes library for the effectful ecosystem";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
 
   "hpqtypes-extras" = callPackage
     ({ mkDerivation, base, base16-bytestring, bytestring, containers
···
      }:
      mkDerivation {
        pname = "hpqtypes-extras";
-       version = "1.16.1.0";
-       sha256 = "1kl9miwarrr69h2b3mmx65ypbfflhhw117k42d9k6jrxbibj7fqq";
+       version = "1.16.2.0";
+       sha256 = "0vb96dm8w089j8zc0i5k8abr7dx5nbrmlpjwhpi2vshhmmihkja3";
        libraryHaskellDepends = [
          base base16-bytestring bytestring containers cryptohash exceptions
          extra hpqtypes log-base mtl text text-show
···
        pname = "hs-duktape";
        version = "1.0.0";
        sha256 = "1bbxp7285vw39jbqpl80jqg46vwycva5fzn4prk3a2fs419xdxzm";
+       revision = "1";
+       editedCabalFile = "09lmnx2i5gq601sj9byzbcq5idppj3gg44ns522xd25rcxn40d8a";
        setupHaskellDepends = [ base Cabal directory process ];
        libraryHaskellDepends = [
          aeson base bytestring text transformers unordered-containers vector
···
      }) {};
 
   "hslua-list" = callPackage
-    ({ mkDerivation, base, bytestring, hslua-core, hslua-marshalling
-     , tasty, tasty-lua
-     }:
+    ({ mkDerivation, base, bytestring, hslua-core, tasty, tasty-lua }:
      mkDerivation {
        pname = "hslua-list";
-       version = "1.0.0";
-       sha256 = "05fkxplc8ayvzidv8z5fv8cns19p96vmzh7v794qh5wksllkb08q";
-       libraryHaskellDepends = [
-         base bytestring hslua-core hslua-marshalling
-       ];
+       version = "1.1.0";
+       sha256 = "1437ff2vqhaymiabp31qhr5ixb99h93cp6qz6z82c4d9c5wvl0q6";
+       libraryHaskellDepends = [ base bytestring hslua-core ];
        testHaskellDepends = [ base hslua-core tasty tasty-lua ];
        description = "Opinionated, but extensible Lua list type";
        license = lib.licenses.mit;
···
        license = lib.licenses.mit;
      }) {};
 
+  "hslua-module-zip" = callPackage
+    ({ mkDerivation, base, bytestring, filepath, hslua-core, hslua-list
+     , hslua-marshalling, hslua-module-system, hslua-packaging, tasty
+     , tasty-hunit, tasty-lua, text, time, zip-archive
+     }:
+     mkDerivation {
+       pname = "hslua-module-zip";
+       version = "1.0.0";
+       sha256 = "0fxqrzfh9iq801pj965pws3cj8gm3wl642ilmy30kriczdvjsny6";
+       libraryHaskellDepends = [
+         base bytestring filepath hslua-core hslua-list hslua-marshalling
+         hslua-packaging text time zip-archive
+       ];
+       testHaskellDepends = [
+         base bytestring filepath hslua-core hslua-list hslua-marshalling
+         hslua-module-system hslua-packaging tasty tasty-hunit tasty-lua
+         text time zip-archive
+       ];
+       description = "Lua module to work with file zips";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "hslua-objectorientation" = callPackage
     ({ mkDerivation, base, bytestring, containers, exceptions
      , hslua-core, hslua-marshalling, lua-arbitrary, mtl, QuickCheck
···
     ({ mkDerivation, base, vector }:
      mkDerivation {
        pname = "hsnoise";
-       version = "0.0.2";
-       sha256 = "0f8xpmzmg71l7qn1vjvzncsx8r7vfpzvlnlq0029ixf64gshbmzl";
+       version = "0.0.3";
+       sha256 = "0wdkq9c39x0ma90bdi5m85sx4crfkv4k0zg8l3371q4sik931ixr";
        libraryHaskellDepends = [ base vector ];
        description = "A coherent 3d noise library";
        license = lib.licenses.bsd3;
···
        pname = "http-client-rustls";
        version = "0.0.0.0";
        sha256 = "1rwiclqc1hpxgaqz6y8pxl96g68bg8d8m1clapg60fgmyj0zjnha";
+       revision = "1";
+       editedCabalFile = "0qhs7zbkw0zp1rv96da484kxizlx9vkc8n7zr8rz9w55gszb2bcf";
        libraryHaskellDepends = [
          base bytestring http-client network resourcet rustls text
        ];
···
        pname = "http-link-header";
        version = "1.2.1";
        sha256 = "15pcav5k7j4pvqwkyyrqgcm7yxqippx4yiprsg9fpml4kywcr2ca";
-       revision = "1";
-       editedCabalFile = "13r2gkvn0v1077xhpinlqfbq8hdpgasm5p895mxi72mqlwnqcrc6";
+       revision = "3";
+       editedCabalFile = "16xbv4cz8b9gh42za6bhz73qcqrd5ix330cs4prj2jn124hb9xwx";
        libraryHaskellDepends = [
          attoparsec base bytestring errors http-api-data network-uri text
        ];
···
        testHaskellDepends = [ base hedgehog hspec hw-hspec-hedgehog ];
        description = "Avro support for Kafka infrastructure";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "hw-kafka-client" = callPackage
···
      }) {};
 
   "implicit-hie" = callPackage
-    ({ mkDerivation, attoparsec, base, directory, filepath, filepattern
-     , hspec, hspec-attoparsec, text, transformers, yaml
+    ({ mkDerivation, attoparsec, base, bytestring, Cabal-syntax
+     , directory, filepath, filepattern, hspec, hspec-attoparsec, text
+     , transformers, yaml
      }:
      mkDerivation {
        pname = "implicit-hie";
-       version = "0.1.2.7";
-       sha256 = "0yb457n26455kbq6kv8g48q66pmmaxcpikmpg9gm00sd6adgq6gl";
+       version = "0.1.3.0";
+       sha256 = "0s2h09gp1z81fxc9j5vcxvzyvf5nvqyhkw7mwq4sg8jjpm0r4gn3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         attoparsec base directory filepath filepattern text transformers
-         yaml
+         attoparsec base bytestring Cabal-syntax directory filepath
+         filepattern text transformers yaml
        ];
        executableHaskellDepends = [
          attoparsec base directory filepath filepattern text transformers
···
      }:
      mkDerivation {
        pname = "incipit";
-       version = "0.3.1.0";
-       sha256 = "00x6g4ngcyak0dh7ms2wx0kh1ckm8laanfp823yskkg9gc71blqy";
+       version = "0.4.0.0";
+       sha256 = "0w4wipaq0iscfnv68x5insjbcqcrnfx6r75lkq6v7nxj1y124yqa";
        libraryHaskellDepends = [
          base incipit-core polysemy-conc polysemy-log polysemy-resume
          polysemy-time
···
 
   "indieweb-algorithms" = callPackage
     ({ mkDerivation, aeson, aeson-qq, base, bytestring, containers
-     , data-default, either, hspec, hspec-expectations-pretty-diff
-     , http-link-header, lens, lens-aeson, microformats2-parser, mtl
-     , network-uri, raw-strings-qq, safe, template-haskell, text, time
-     , transformers, unordered-containers, vector
+     , data-default, either, errors, hspec
+     , hspec-expectations-pretty-diff, http-link-header, lens
+     , lens-aeson, microformats2-parser, mtl, network-uri
+     , raw-strings-qq, safe, template-haskell, text, time, transformers
+     , unordered-containers, vector, xml-conduit, xml-conduit-writer
+     , xml-lens
      }:
      mkDerivation {
        pname = "indieweb-algorithms";
-       version = "0.1.0";
-       sha256 = "1cl0rjfhgb6fn8nlm09qs1jg9xd01507x7ii65vrp98c4zfc85rl";
+       version = "0.1.1";
+       sha256 = "15hh4xkkqycv74grjfssma2h3prvax00y8fpgqh8wyb3laq5n75g";
        libraryHaskellDepends = [
-         aeson base bytestring containers data-default either
+         aeson base bytestring containers data-default either errors
          http-link-header lens lens-aeson microformats2-parser network-uri
-         safe text time transformers unordered-containers vector
+         safe text time transformers unordered-containers vector xml-conduit
+         xml-conduit-writer xml-lens
        ];
        testHaskellDepends = [
          aeson aeson-qq base bytestring data-default hspec
-         hspec-expectations-pretty-diff microformats2-parser mtl network-uri
-         raw-strings-qq template-haskell text time
+         hspec-expectations-pretty-diff http-link-header lens lens-aeson
+         microformats2-parser mtl network-uri raw-strings-qq
+         template-haskell text time xml-conduit
        ];
        description = "A collection of implementations of IndieWeb algorithms";
        license = lib.licenses.publicDomain;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "indigo" = callPackage
···
      }:
      mkDerivation {
        pname = "infernal";
-       version = "0.6.0";
-       sha256 = "1qk0d5k7kjkhqxpkm1fnah1syd0la1z88l5mwv3z6ly5njvj78fl";
+       version = "0.7.0";
+       sha256 = "0jbmcwdpnqxvfcbcd2xqybmz69mycwbzxrj9hlgas365y4m2rlka";
        libraryHaskellDepends = [
          aeson base binary bytestring case-insensitive exceptions hashable
          http-client http-types little-logger little-rio microlens
···
      }:
      mkDerivation {
        pname = "language-Modula2";
-       version = "0.1.2";
-       sha256 = "0sag6wayg9c6rzdb2n3wbvqq0ncs6pk0pdbpvgx1pr84gfxlg1i6";
+       version = "0.1.3";
+       sha256 = "0izh9scx1hky2f47qq0gbfwwcvn984h3icpbw475z5qbid0j3856";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        description = "Language definition and parser for AVRO files";
        license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "language-bash" = callPackage
···
      }:
      mkDerivation {
        pname = "language-oberon";
-       version = "0.3.1";
-       sha256 = "0x54bbdaxmz8z09hipvf5f30d0h3cvnppm47ra7xn4iycf2vbrkd";
+       version = "0.3.2";
+       sha256 = "0k4r2h02znhs4l5nm88pwva0d7d3p9bga1rrdjga6rjd1ihhbfx1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "leancheck-instances";
-       version = "0.0.4";
-       sha256 = "1l1hwkhxgmy7ssqhrbi8xngb99zhdfnchzq4668gi35a932a1id7";
-       libraryHaskellDepends = [
-         array base bytestring containers leancheck nats text time
-       ];
-       testHaskellDepends = [
-         base bytestring containers leancheck nats text
-       ];
-       description = "Common LeanCheck instances";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "leancheck-instances_0_0_5" = callPackage
-    ({ mkDerivation, array, base, bytestring, containers, leancheck
-     , nats, text, time
-     }:
-     mkDerivation {
-       pname = "leancheck-instances";
        version = "0.0.5";
        sha256 = "111dgr7ivd36v5fqcvnx2jq7iyn9akz5css6mzb5h72rc0sxwq6q";
        libraryHaskellDepends = [
···
        ];
        description = "Common LeanCheck instances";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "leankit-api" = callPackage
···
        pname = "libfuse3";
        version = "0.2.0.0";
        sha256 = "10i92xy8bl36ymmdq3yp9lh7rbzwbk7gff6cqnijchddllj7maca";
+       revision = "1";
+       editedCabalFile = "10nv0lgd9494dp9ipmjlqsgwc91hv4mhcqmxglwmalf0lhmbw9cw";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "libyaml";
        version = "0.1.2";
        sha256 = "1dcpbsjg6n305l07isxmavgp01lbv1qggy16acjyxjlz35pxchlg";
+       revision = "1";
+       editedCabalFile = "00f1rag6sd7c8kza2agw9089p9vf21iiga2aq41nbf6d3yqn7dkz";
        libraryHaskellDepends = [ base bytestring conduit resourcet ];
        description = "Low-level, streaming YAML interface";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "lifx-lan";
-       version = "0.7";
-       sha256 = "00lci0mj75pyrimzcbyq088pg7k6xx1p9pps09l7m3y4dhbnsyyf";
+       version = "0.7.1";
+       sha256 = "1apzp7pkd2vl7nxmdcmdnpa89wrs1fmaii8gd01bjcmjkk7qxgli";
        libraryHaskellDepends = [
          ansi-terminal base binary bytestring colour composition containers
          extra monad-loops mtl network random safe text time transformers
···
        license = lib.licenses.mit;
      }) {};
 
-  "linear-base_0_2_0" = callPackage
+  "linear-base_0_3_0" = callPackage
     ({ mkDerivation, base, containers, deepseq, gauge, ghc-prim
      , hashable, hashtables, hedgehog, inspection-testing
      , linear-generics, mmorph, MonadRandom, primitive, random
···
      }:
      mkDerivation {
        pname = "linear-base";
-       version = "0.2.0";
-       sha256 = "0s6z21b71pbqjmbz1r2d6xk90a9wbpa4f1dhlia209avhr1wsv26";
+       version = "0.3.0";
+       sha256 = "0b1hs26a9av8vml10kw1jjsliwwhj3h2cmfnkiqbrqpm47yxmr35";
        libraryHaskellDepends = [
          base containers ghc-prim hashable linear-generics primitive
          storable-tuple text transformers vector
···
        pname = "liquid-fixpoint";
        version = "8.10.7";
        sha256 = "02zih8q3kv94s1l4m9d8f3d60idm1an23kxx0ahjfg8cdqgi3gym";
+       revision = "1";
+       editedCabalFile = "0ddqrx1ffihwmfw1jy9cycj253zq0f9f7n7xvwl6k07q58nadaf4";
        configureFlags = [ "-fbuild-external" ];
        isLibrary = true;
        isExecutable = true;
···
      }:
      mkDerivation {
        pname = "lucid2";
-       version = "0.0.20220526";
-       sha256 = "004bmzwzxfq2pmp7wn1mrdwkw9fnyfnmvzymnwn8fczkq17w4csd";
-       revision = "1";
-       editedCabalFile = "1b4vh46z3imkxmw6mg5mh12zhckrjlkbw7m5ix75l5ryl26lqlsc";
+       version = "0.0.20221012";
+       sha256 = "00r3qmxrs3jh3v4gl5m38j86ihh78q4vmsk4bz2pbcc8gh2yficj";
        libraryHaskellDepends = [
          base blaze-builder bytestring containers mtl text transformers
        ];
···
        pname = "magicbane";
        version = "0.5.1";
        sha256 = "18kxixk0cj32pjpwp96mpnppy21xn4gy4xksb97m31j30kmlas91";
+       revision = "1";
+       editedCabalFile = "0hay0nfaxlvm5l7jywd08779j9vcpjjrflx4cy62krsqmw9vnybm";
        libraryHaskellDepends = [
          aeson aeson-qq attoparsec base bytestring conduit
          conduit-combinators data-has ekg-core ekg-wai envy errors
···
        mainProgram = "mega-sdist";
      }) {};
 
+  "mega-sdist_0_4_3_0" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, optparse-simple, pantry
+     , path, path-io, rio, rio-orphans, yaml
+     }:
+     mkDerivation {
+       pname = "mega-sdist";
+       version = "0.4.3.0";
+       sha256 = "0bv490zs2a25r0kwb7kqmami3xfxmjg9fqb1j4azn7jyf14jg367";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         aeson base bytestring optparse-simple pantry path path-io rio
+         rio-orphans yaml
+       ];
+       description = "Handles uploading to Hackage from mega repos";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "mega-sdist";
+     }) {};
+
   "megalisp" = callPackage
     ({ mkDerivation, base, megaparsec, mtl, text }:
      mkDerivation {
···
      }) {};
 
   "microformats2-parser" = callPackage
-    ({ mkDerivation, aeson, aeson-pretty, aeson-qq, attoparsec
-     , aws-lambda-haskell-runtime, aws-lambda-haskell-runtime-wai, base
-     , base-compat, blaze-html, blaze-markup, bytestring
-     , case-insensitive, containers, data-default, either, errors
-     , githash, hspec, hspec-expectations-pretty-diff, html-conduit
-     , lens, lens-aeson, mtl, network, network-uri, options, pcre-heavy
-     , raw-strings-qq, safe, scotty, tagsoup, template-haskell, text
-     , time, transformers, unordered-containers, vector, wai, wai-cli
-     , wai-extra, xml-lens, xss-sanitize
+    ({ mkDerivation, aeson, aeson-qq, attoparsec, base, base-compat
+     , blaze-markup, bytestring, case-insensitive, containers
+     , data-default, either, errors, hspec
+     , hspec-expectations-pretty-diff, html-conduit, lens, lens-aeson
+     , mtl, network-uri, pcre-heavy, raw-strings-qq, safe, tagsoup
+     , template-haskell, text, time, transformers, unordered-containers
+     , vector, xml-lens, xss-sanitize
      }:
      mkDerivation {
        pname = "microformats2-parser";
-       version = "1.0.2.0";
-       sha256 = "1vrw60az8jb3m9kk2vsn1v5l68jmwxsfw3p7lfwl9a8d4gk5m1gp";
+       version = "1.0.2.2";
+       sha256 = "0r1j0ky2kqc1qkvdhmcxxjwc7gplmsr0pdra2fc0xb0k7ccb2hvc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          lens lens-aeson network-uri pcre-heavy safe tagsoup text time
          transformers unordered-containers vector xml-lens xss-sanitize
        ];
-       executableHaskellDepends = [
-         aeson aeson-pretty aws-lambda-haskell-runtime
-         aws-lambda-haskell-runtime-wai base base-compat blaze-html
-         blaze-markup data-default githash network network-uri options
-         scotty text wai wai-cli wai-extra
-       ];
        testHaskellDepends = [
          aeson-qq base base-compat bytestring data-default hspec
          hspec-expectations-pretty-diff html-conduit mtl network-uri
···
        ];
        description = "A Microformats 2 parser";
        license = lib.licenses.publicDomain;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "microformats2-types" = callPackage
···
        pname = "microformats2-types";
        version = "0.4.1";
        sha256 = "1p2s2g78bnqbcf0www0x11pz5nyxjfac7q7sbd2qfn1v777ylv7b";
+       revision = "1";
+       editedCabalFile = "0z6gx7zv3xc88n1x9z4ihrc8yb8x1j3klyan2xplfq6c6khhqa6f";
        libraryHaskellDepends = [
          aeson base data-default-class pandoc-types setters text time
        ];
···
      }:
      mkDerivation {
        pname = "mit-3qvpPyAi6mH";
-       version = "10";
-       sha256 = "1kwwklq8bd2ckq2djlw21hiv2sr723s3nh873hs8f7rapjsrnv23";
+       version = "11";
+       sha256 = "0p5v2spwd8rz5h5zclbr7wq5m4qvsihvp91p52d2vd3jdd6xaszx";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
 
   "modern-uri" = callPackage
     ({ mkDerivation, base, bytestring, containers, contravariant
-     , criterion, deepseq, exceptions, hspec, hspec-discover
+     , criterion, deepseq, exceptions, hashable, hspec, hspec-discover
      , hspec-megaparsec, megaparsec, mtl, profunctors, QuickCheck
      , reflection, tagged, template-haskell, text, weigh
      }:
      mkDerivation {
        pname = "modern-uri";
-       version = "0.3.4.4";
-       sha256 = "19fffy7kb7ibajagdryjy872x56045zi6c1div8wvr8aisd55qsz";
-       revision = "2";
-       editedCabalFile = "0izxigj0rvzz25gg3k1y09hcx7rx1xvq6dc5awi4kzdw323nvmv4";
+       version = "0.3.5.0";
+       sha256 = "09pxr1im78fg8024my34qhcj25w3hjq585l3k5qxl81dcypkjhdb";
        libraryHaskellDepends = [
          base bytestring containers contravariant deepseq exceptions
-         megaparsec mtl profunctors QuickCheck reflection tagged
+         hashable megaparsec mtl profunctors QuickCheck reflection tagged
          template-haskell text
        ];
        testHaskellDepends = [
···
      }) {};
 
   "monad-bayes" = callPackage
-    ({ mkDerivation, abstract-par, base, containers, criterion, free
-     , hspec, ieee754, log-domain, math-functions, monad-coroutine, mtl
-     , mwc-random, optparse-applicative, process, QuickCheck, safe
-     , statistics, time, transformers, vector
+    ({ mkDerivation, abstract-par, base, brick, containers, criterion
+     , foldl, free, histogram-fill, hspec, ieee754, integration, lens
+     , linear, log-domain, math-functions, matrix, monad-coroutine
+     , monad-extras, mtl, mwc-random, optparse-applicative, pipes
+     , pretty-simple, primitive, process, profunctors, QuickCheck
+     , random, safe, scientific, statistics, text, time, transformers
+     , typed-process, vector, vty
      }:
      mkDerivation {
        pname = "monad-bayes";
-       version = "0.1.1.0";
-       sha256 = "1pmhj377h8jwaxh6pv3s8fq2sm82lrilyxys2m84a2ln6g0aw664";
+       version = "1.0.0";
+       sha256 = "1s5niiss16a5lgw2jhda3c34r1ylcjb5k14bk0n7p7l117xpxsza";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         base containers free ieee754 log-domain math-functions
-         monad-coroutine mtl mwc-random safe statistics transformers vector
+         base brick containers foldl free histogram-fill ieee754 integration
+         lens linear log-domain math-functions matrix monad-coroutine
+         monad-extras mtl mwc-random pipes pretty-simple primitive random
+         safe scientific statistics text vector vty
        ];
        executableHaskellDepends = [
-         base containers log-domain mwc-random optparse-applicative time
-         vector
+         base containers log-domain math-functions mwc-random
+         optparse-applicative pipes pretty-simple random text time vector
        ];
        testHaskellDepends = [
-         base hspec ieee754 log-domain math-functions mtl QuickCheck
-         transformers vector
+         base containers foldl hspec ieee754 lens linear log-domain
+         math-functions matrix mtl mwc-random pipes pretty-simple
+         profunctors QuickCheck random statistics text transformers vector
        ];
        benchmarkHaskellDepends = [
-         abstract-par base containers criterion log-domain mwc-random
-         process vector
+         abstract-par base containers criterion log-domain mwc-random pipes
+         pretty-simple process random text typed-process vector
        ];
        description = "A library for probabilistic programming";
        license = lib.licenses.mit;
···
        pname = "monad-logger";
        version = "0.3.37";
        sha256 = "1z275a428zcj73zz0cpfha2adwiwqqqp7klx3kbd3i9rl20xa106";
-       revision = "1";
-       editedCabalFile = "1w6awsn2fw0fca17lv92gcp3sk25yv9gkg68ll39iznkq6xblcdf";
+       revision = "2";
+       editedCabalFile = "1kkw07kk8gv7d9iarradqcqzjpdfh5shjlhfbf2v25mmcpchp6hd";
        libraryHaskellDepends = [
          base bytestring conduit conduit-extra exceptions fast-logger
          lifted-base monad-control monad-loops mtl resourcet stm stm-chans
···
        pname = "monad-logger-prefix";
        version = "0.1.12";
        sha256 = "00gsp7mhvqvfbdh75lgr73j5adw3hd4cp969h241gaw892z3qvws";
+       revision = "1";
+       editedCabalFile = "0vrksfi4l7djn8z0kbknidp8g1kcahy938f9dmp27fkydwrjv14i";
        libraryHaskellDepends = [
          base exceptions monad-control monad-logger mtl resourcet text
          transformers transformers-base unliftio-core
···
        license = lib.licenses.asl20;
      }) {};
 
+  "mongoDB_2_7_1_2" = callPackage
+    ({ mkDerivation, array, base, base16-bytestring, base64-bytestring
+     , binary, bson, bytestring, conduit, conduit-extra, containers
+     , criterion, cryptohash, data-default-class, dns, fail, hashtables
+     , hspec, http-types, lifted-base, monad-control, mtl, network
+     , nonce, old-locale, parsec, pureMD5, random, random-shuffle
+     , resourcet, stm, tagged, text, time, tls, transformers
+     , transformers-base
+     }:
+     mkDerivation {
+       pname = "mongoDB";
+       version = "2.7.1.2";
+       sha256 = "0csjhvsvy534lq7lvqx96dw6ia3737rg7q96174067k7mhkxwf9m";
+       libraryHaskellDepends = [
+         array base base16-bytestring base64-bytestring binary bson
+         bytestring conduit conduit-extra containers cryptohash
+         data-default-class dns fail hashtables http-types lifted-base
+         monad-control mtl network nonce parsec pureMD5 random
+         random-shuffle resourcet stm tagged text time tls transformers
+         transformers-base
+       ];
+       testHaskellDepends = [ base hspec mtl old-locale text time ];
+       benchmarkHaskellDepends = [
+         array base base16-bytestring base64-bytestring binary bson
+         bytestring containers criterion cryptohash data-default-class dns
+         fail hashtables http-types lifted-base monad-control mtl network
+         nonce parsec random random-shuffle stm text tls transformers-base
+       ];
+       description = "Driver (client) for MongoDB, a free, scalable, fast, document DBMS";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "mongodb-queue" = callPackage
     ({ mkDerivation, base, data-default, hspec, lifted-base
      , monad-control, mongoDB, network, text, transformers
···
      }:
      mkDerivation {
        pname = "monoidal-containers";
-       version = "0.6.2.0";
-       sha256 = "0rnhlm77zrql42z3zsn3ag279q0vrz2idygc0x4p50q3780670p3";
-       revision = "1";
-       editedCabalFile = "07l42gkixdpamqqzdwqfcd62yga5cvhbxz5l0jpgs8kgf6prna4p";
-       libraryHaskellDepends = [
-         aeson base containers deepseq hashable lens newtype semialign these
-         unordered-containers witherable
-       ];
-       description = "Containers with monoidal accumulation";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "monoidal-containers_0_6_3_0" = callPackage
-    ({ mkDerivation, aeson, base, containers, deepseq, hashable, lens
-     , newtype, semialign, these, unordered-containers, witherable
-     }:
-     mkDerivation {
-       pname = "monoidal-containers";
        version = "0.6.3.0";
        sha256 = "0m41z50r3jvr8vvfry99kamb2h3knm0g7bqfwspchmhwsgqqczh4";
        libraryHaskellDepends = [
···
        ];
        description = "Containers with monoidal accumulation";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "monoidal-functors" = callPackage
···
        pname = "monomer";
        version = "1.5.0.0";
        sha256 = "0asp7j9xmysspyv2l8fcr36flcayqyhp41139kzg00b7jglpbpyg";
+       revision = "1";
+       editedCabalFile = "1ig93calrshb8q4jp8iw0y2yqkxmd5n7xg1nabc9bp0ypacba13m";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
      }) {inherit (pkgs) glew;};
+
+  "monomer-hagrid" = callPackage
+    ({ mkDerivation, base, bytestring, containers, data-default
+     , data-default-class, hspec, hspec-discover, ilist, lens, monomer
+     , mtl, stm, text, time
+     }:
+     mkDerivation {
+       pname = "monomer-hagrid";
+       version = "0.1.0.0";
+       sha256 = "0mr4fnzlrci1qnyl7rdiklzz3l5sqzgax5lqx66n209221a7pnki";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base containers data-default-class ilist lens monomer text
+       ];
+       executableHaskellDepends = [
+         base containers data-default-class ilist lens monomer text time
+       ];
+       testHaskellDepends = [
+         base bytestring containers data-default data-default-class hspec
+         ilist lens monomer mtl stm text
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "A datagrid widget for the Monomer library";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "examples";
+       broken = true;
+     }) {};
 
   "monomorphic" = callPackage
     ({ mkDerivation, base }:
···
      }) {};
 
   "morpheus-graphql" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, containers, file-embed
+    ({ mkDerivation, aeson, base, bytestring, containers
      , morpheus-graphql-app, morpheus-graphql-code-gen
-     , morpheus-graphql-core, morpheus-graphql-subscriptions
-     , morpheus-graphql-tests, mtl, relude, tasty, tasty-hunit
-     , template-haskell, text, transformers, unordered-containers
-     , vector
+     , morpheus-graphql-core, morpheus-graphql-server
+     , morpheus-graphql-subscriptions, morpheus-graphql-tests, mtl
+     , relude, tasty, tasty-hunit, template-haskell, text, transformers
+     , unordered-containers, vector
      }:
      mkDerivation {
        pname = "morpheus-graphql";
-       version = "0.21.0";
-       sha256 = "1xvhrgjdfxqn8ck75b3hpgj12i4y94fkcp0gr7bvyh3cbhrbycnk";
+       version = "0.24.3";
+       sha256 = "0z1kxwkflwzn6xqv8a046biv16a4fq8sxma7n4hbby7zqmzbwpj5";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base bytestring containers morpheus-graphql-app
-         morpheus-graphql-code-gen morpheus-graphql-core mtl relude
-         template-haskell text transformers unordered-containers vector
+         morpheus-graphql-code-gen morpheus-graphql-core
+         morpheus-graphql-server mtl relude template-haskell text
+         transformers unordered-containers vector
        ];
        testHaskellDepends = [
-         aeson base bytestring containers file-embed morpheus-graphql-app
+         aeson base bytestring containers morpheus-graphql-app
          morpheus-graphql-code-gen morpheus-graphql-core
-         morpheus-graphql-subscriptions morpheus-graphql-tests mtl relude
-         tasty tasty-hunit template-haskell text transformers
-         unordered-containers vector
+         morpheus-graphql-server morpheus-graphql-subscriptions
+         morpheus-graphql-tests mtl relude tasty tasty-hunit
+         template-haskell text transformers unordered-containers vector
        ];
        description = "Morpheus GraphQL";
        license = lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "morpheus-graphql-app";
-       version = "0.21.0";
-       sha256 = "041a6rdbvs9g5ia384qgyppdkyq71xrlcqwz8szyyw2ra97sy0pg";
+       version = "0.24.3";
+       sha256 = "1hm4v3x6p718zjgk4svfslvqm6nca5kg30rhh2ax63gkfvp1i2xr";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base bytestring containers hashable megaparsec
···
 
   "morpheus-graphql-client" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, directory
-     , file-embed, modern-uri, morpheus-graphql-code-gen
+     , file-embed, modern-uri, morpheus-graphql-code-gen-utils
      , morpheus-graphql-core, morpheus-graphql-subscriptions, mtl
-     , relude, req, tasty, tasty-hunit, template-haskell, text
-     , transformers, unliftio-core, unordered-containers, websockets
-     , wuss
+     , prettyprinter, relude, req, tasty, tasty-hunit, template-haskell
+     , text, transformers, unliftio-core, unordered-containers
+     , websockets, wuss
      }:
      mkDerivation {
        pname = "morpheus-graphql-client";
-       version = "0.21.0";
-       sha256 = "1mn520aj62i9spby3ik0ynmjbj6baw6hmc3lcv4zp2v1ywypycci";
+       version = "0.24.3";
+       sha256 = "1xfwah79w0akg0fhz7xkhwmik5bfz4c9kwbscxf08w99669k1lwd";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base bytestring containers file-embed modern-uri
-         morpheus-graphql-code-gen morpheus-graphql-core
-         morpheus-graphql-subscriptions mtl relude req template-haskell text
-         transformers unliftio-core unordered-containers websockets wuss
+         morpheus-graphql-code-gen-utils morpheus-graphql-core
+         morpheus-graphql-subscriptions mtl prettyprinter relude req
+         template-haskell text transformers unliftio-core
+         unordered-containers websockets wuss
        ];
        testHaskellDepends = [
          aeson base bytestring containers directory file-embed modern-uri
-         morpheus-graphql-code-gen morpheus-graphql-core
-         morpheus-graphql-subscriptions mtl relude req tasty tasty-hunit
-         template-haskell text transformers unliftio-core
+         morpheus-graphql-code-gen-utils morpheus-graphql-core
+         morpheus-graphql-subscriptions mtl prettyprinter relude req tasty
+         tasty-hunit template-haskell text transformers unliftio-core
          unordered-containers websockets wuss
        ];
        description = "Morpheus GraphQL Client";
···
      }) {};
 
   "morpheus-graphql-code-gen" = callPackage
-    ({ mkDerivation, base, bytestring, containers, filepath
-     , morpheus-graphql-core, optparse-applicative, prettyprinter
-     , relude, template-haskell, text, unordered-containers
+    ({ mkDerivation, base, bytestring, containers, file-embed, filepath
+     , Glob, morpheus-graphql-client, morpheus-graphql-code-gen-utils
+     , morpheus-graphql-core, morpheus-graphql-server
+     , optparse-applicative, prettyprinter, relude, template-haskell
+       sha256 = "1l3pq6i9npbyzh0bv8qb315l50zhv81s5rqqnc8k27rlrabirndb";
      }:
      mkDerivation {
        pname = "morpheus-graphql-code-gen";
-       version = "0.21.0";
-       sha256 = "17z3zyk47pfs94i9lxjylxmx5c2m38nkhs4g3pf9qn129czjb48y";
+       version = "0.24.3";
+       sha256 = "040grsj1q9b2jy5y7pxy2islfaa6jd0winkg2dvzg1dwwh74rayc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         base bytestring containers morpheus-graphql-core prettyprinter
-         relude template-haskell text unordered-containers
+         base bytestring containers file-embed
+         morpheus-graphql-code-gen-utils morpheus-graphql-core
+         morpheus-graphql-server prettyprinter relude template-haskell text
+         unordered-containers
        ];
        executableHaskellDepends = [
-         base bytestring containers filepath morpheus-graphql-core
-         optparse-applicative prettyprinter relude template-haskell text
-         unordered-containers
+         base bytestring containers file-embed filepath Glob
+         morpheus-graphql-client morpheus-graphql-code-gen-utils
+         morpheus-graphql-core morpheus-graphql-server optparse-applicative
+         prettyprinter relude template-haskell text unordered-containers
+         yaml
        ];
        description = "Morpheus GraphQL CLI";
        license = lib.licenses.bsd3;
···
        mainProgram = "morpheus";
      }) {};
 
+  "morpheus-graphql-code-gen-utils" = callPackage
+    ({ mkDerivation, base, bytestring, containers
+     , morpheus-graphql-core, prettyprinter, relude, template-haskell
+     , text, unordered-containers
+     }:
+     mkDerivation {
+       pname = "morpheus-graphql-code-gen-utils";
+       version = "0.24.3";
+       sha256 = "1ss36qkf47zgwwivi70bjq5l5mkqin5181yc7dxg865sgdm9jc5z";
+       libraryHaskellDepends = [
+         base bytestring containers morpheus-graphql-core prettyprinter
+         relude template-haskell text unordered-containers
+       ];
+       description = "Morpheus GraphQL CLI";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "morpheus-graphql-core" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, directory
      , hashable, megaparsec, morpheus-graphql-tests, mtl, relude
···
      }:
      mkDerivation {
        pname = "morpheus-graphql-core";
-       version = "0.21.0";
-       sha256 = "1p5cirgqiv73ka0k4rb7dwky57dwj7nr0vpr6frfgvjsnmpbqq0s";
+       version = "0.24.3";
+       sha256 = "0nh7nvdgqj95g1fafisjg9dxfk2hd9x0mb7da6lwcrsyb005iald";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base bytestring containers hashable megaparsec mtl relude
···
        broken = true;
      }) {};
 
+  "morpheus-graphql-server" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, file-embed
+     , morpheus-graphql-app, morpheus-graphql-core
+     , morpheus-graphql-subscriptions, morpheus-graphql-tests, mtl
+     , relude, tasty, tasty-hunit, template-haskell, text, transformers
+     , unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "morpheus-graphql-server";
+       version = "0.24.3";
+       sha256 = "1xiy43pxmgh5kh2c1vk6g7ay0kinh7rx5xb1lrjw5wkl9sw2l7dg";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         aeson base bytestring containers morpheus-graphql-app
+         morpheus-graphql-core mtl relude template-haskell text transformers
+         unordered-containers vector
+       ];
+       testHaskellDepends = [
+         aeson base bytestring containers file-embed morpheus-graphql-app
+         morpheus-graphql-core morpheus-graphql-subscriptions
+         morpheus-graphql-tests mtl relude tasty tasty-hunit
+         template-haskell text transformers unordered-containers vector
+       ];
+       description = "Morpheus GraphQL";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "morpheus-graphql-subscriptions" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, directory
-     , morpheus-graphql-app, morpheus-graphql-core, mtl, relude, tasty
-     , tasty-hunit, text, transformers, unliftio-core
-     , unordered-containers, uuid, websockets
+    ({ mkDerivation, aeson, base, bytestring, morpheus-graphql-app
+     , morpheus-graphql-core, mtl, relude, text, transformers
+     , unliftio-core, unordered-containers, uuid, websockets
      }:
      mkDerivation {
        pname = "morpheus-graphql-subscriptions";
-       version = "0.21.0";
-       sha256 = "0qf1jw8lgjph0is7irbj07f4dina9aqznzr18wp9gwywxn0mzvgi";
+       version = "0.24.3";
+       sha256 = "1cky0br7nkpnjgk0j0qxfz4gd7z14badhpll51yakysxz8y5clsf";
        libraryHaskellDepends = [
          aeson base bytestring morpheus-graphql-app morpheus-graphql-core
          mtl relude text transformers unliftio-core unordered-containers
          uuid websockets
-       ];
-       testHaskellDepends = [
-         aeson base bytestring directory morpheus-graphql-app
-         morpheus-graphql-core mtl relude tasty tasty-hunit text
-         transformers unliftio-core unordered-containers uuid websockets
        ];
        description = "Morpheus GraphQL Subscriptions";
        license = lib.licenses.mit;
···
        license = lib.licenses.mit;
      }) {};
 
-  "morpheus-graphql-tests_0_21_0" = callPackage
+  "morpheus-graphql-tests_0_24_3" = callPackage
     ({ mkDerivation, aeson, base, bytestring, directory, relude, tasty
      , tasty-hunit, text, unordered-containers
      }:
      mkDerivation {
        pname = "morpheus-graphql-tests";
-       version = "0.21.0";
-       sha256 = "13xf8q7p32c549bih2133lcsikspnv4ay6c7bcm433dwvxf13rcm";
+       version = "0.24.3";
+       sha256 = "0kgzwjg0jr44rfa2pz9k80pvj22spj2qmp6l31fyy54bi89z98vh";
        libraryHaskellDepends = [
          aeson base bytestring directory relude tasty tasty-hunit text
          unordered-containers
···
      }:
      mkDerivation {
        pname = "mywork";
-       version = "1.0.0.0";
-       sha256 = "0xmisv0680g7840a1hwiw9fw5fzkqss6qxaw4wck6qix98aaqm0a";
-       isLibrary = false;
+       version = "1.0.1.0";
+       sha256 = "0mcgc2f8d3v29l940n5pmw2l4na7nz9098w6krc37yl8rddgfjn6";
+       isLibrary = true;
        isExecutable = true;
-       executableHaskellDepends = [
+       libraryHaskellDepends = [
          aeson base brick brick-panes bytestring containers ini lens mtl
          path path-io template-haskell text text-zipper time
          unordered-containers vector vty
        ];
+       executableHaskellDepends = [
+         base brick brick-panes lens mtl text vty
+       ];
        description = "Tool to keep track of what you have been working on and where";
        license = lib.licenses.isc;
        hydraPlatforms = lib.platforms.none;
···
      }:
      mkDerivation {
        pname = "network-transport-tcp";
-       version = "0.8.0";
-       sha256 = "09zjk3ydnm7v8ryjy60p0jnd18sgf3z2yklyxp6ga5llnyzsv53a";
+       version = "0.8.1";
+       sha256 = "1ia7985pngbmg6cvgw9xkqdyrgbsg98hzzcjzg5ksfsh6jddrvgx";
        libraryHaskellDepends = [
          async base bytestring containers data-accessor network
          network-transport uuid
···
      }:
      mkDerivation {
        pname = "network-transport-tests";
-       version = "0.3.0";
-       sha256 = "1552mgccfyyvvnplhflkfxgg3246jgx9iiv71a0gwblllbsh5y8p";
-       revision = "1";
-       editedCabalFile = "0kk8kib742s3iiah6d9g94ma776m4nyh14syvibsssfj1immf3jd";
+       version = "0.3.1";
+       sha256 = "0md91zi8g4vfbj53w1ghbgw50mlgvpnd1pya9y98i8ab8flhk923";
        libraryHaskellDepends = [
          ansi-terminal base bytestring containers mtl network-transport
          random
···
      }:
      mkDerivation {
        pname = "ngx-export-log";
-       version = "1.5";
-       sha256 = "0jixskgyv4f31qhxqlhdbg93ib7lj9vwgrbqh4ha1z74gsyx4axv";
+       version = "1.5.1";
+       sha256 = "03wr3v7x26c0cm01rclc5fkj2a66pamcjikx8wgariljdzfzr7qs";
        libraryHaskellDepends = [
          base bytestring ngx-export ngx-export-tools template-haskell
        ];
···
      }:
      mkDerivation {
        pname = "nix-tree";
-       version = "0.2.0";
-       sha256 = "1m8ahqdm9ivgc1l1mk3s9q8gviklpq6kckn7jhdzx2mbzx7gf2vj";
+       version = "0.2.1";
+       sha256 = "1ca4a6mmbb8kvja3ipiifj7kfxayq9ik3ip10m6nkf99a56060jw";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        pname = "nonempty-vector";
        version = "0.2.1.0";
        sha256 = "0w6fn8dinf8lcbhr5797i5kyixpasylpwn97ljmkjc6n3ad1b21y";
+       revision = "1";
+       editedCabalFile = "18w57f8sdix71a27gwbifw7hmg34lms22c99gp7i7j7g154f3cn3";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [ base deepseq primitive vector ];
        testHaskellDepends = [ base doctest ];
···
        pname = "o-clock";
        version = "1.3.0";
        sha256 = "1swayrdhz10b67m6ipa75qz9ycz6r7xbk9fdq3ajlhp9bry31l7i";
+       revision = "1";
+       editedCabalFile = "1fis58d0r7yvznmgijc2878gjv0261apb748d5pcphmgk9i5kzf3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
···
      }:
      mkDerivation {
        pname = "om-fork";
-       version = "0.7.1.6";
-       sha256 = "0lj26k234vqn9q536v0lbgzrdag83yjdczjp48v9jhwjj02y8m24";
+       version = "0.7.1.7";
+       sha256 = "1fpgyh44had11yxarhdavscf12693kgal0js9j3mdj8115dv53nz";
        libraryHaskellDepends = [
          aeson base exceptions ki monad-logger om-show text unliftio
        ];
···
        ];
        description = "Concurrency utilities";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "om-http" = callPackage
···
        pname = "openapi3";
        version = "3.2.2";
        sha256 = "0d31ilv2ivwswzbpfibqwnld8697vk63wyr6yl80brjx60g4jp9j";
-       revision = "1";
-       editedCabalFile = "01cqwjmv4y4d4d3v7rn2jm7l0vmqha2xfph9c6jq2ia0xl90z7a1";
+       revision = "2";
+       editedCabalFile = "1yc3wlc8j84glav3hzx1l4yq33k05bll252a8yl6ld275jjswn8p";
        isLibrary = true;
        isExecutable = true;
        setupHaskellDepends = [ base Cabal cabal-doctest ];
···
      }:
      mkDerivation {
        pname = "package-version";
-       version = "0.2";
-       sha256 = "0381k1s0gc5wqxx21fg3nk7cgg821qlszdnwp1gl9jrykbfqak44";
+       version = "0.3";
+       sha256 = "01d0345qs5c02gmh3ccsl0xbmiqwcbdpzlqgx2pwj6iv9vvjrf5l";
        libraryHaskellDepends = [
          base bytestring deepseq prettyprinter safe-exceptions
          template-haskell text
···
      }:
      mkDerivation {
        pname = "pact-time";
-       version = "0.2.0.0";
-       sha256 = "04d8hd4hnbsjvzjjvnyabc68srhyp8k9459pp0y1sdc7z6c0qq1m";
+       version = "0.2.0.1";
+       sha256 = "1k55bwf7crkr16szyjyzwc5f4h2r0x3yxaajvvffnqkbjpq3zwy0";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring cereal clock Decimal deepseq
          microlens mtl text vector vector-space
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "pantry_0_7_0" = callPackage
+    ({ mkDerivation, aeson, ansi-terminal, base, bytestring, Cabal
+     , casa-client, casa-types, conduit, conduit-extra, containers
+     , cryptonite, cryptonite-conduit, digest, exceptions, filelock
+     , generic-deriving, hackage-security, hedgehog, hpack, hspec
+     , http-client, http-client-tls, http-conduit, http-download
+     , http-types, memory, mtl, network-uri, path, path-io, persistent
+     , persistent-sqlite, persistent-template, primitive, QuickCheck
+     , raw-strings-qq, resourcet, rio, rio-orphans, rio-prettyprint
+     , tar-conduit, text, text-metrics, time, transformers, unix-compat
+     , unliftio, unordered-containers, vector, yaml, zip-archive
+     }:
+     mkDerivation {
+       pname = "pantry";
+       version = "0.7.0";
+       sha256 = "19jb1gmpypdv4mdn3gp6fwgwhrynx5w7dy666yr4k23zdbkcrz1v";
+       libraryHaskellDepends = [
+         aeson ansi-terminal base bytestring Cabal casa-client casa-types
+         conduit conduit-extra containers cryptonite cryptonite-conduit
+         digest filelock generic-deriving hackage-security hpack http-client
+         http-client-tls http-conduit http-download http-types memory mtl
+         network-uri path path-io persistent persistent-sqlite
+         persistent-template primitive resourcet rio rio-orphans
+         rio-prettyprint tar-conduit text text-metrics time transformers
+         unix-compat unliftio unordered-containers vector yaml zip-archive
+       ];
+       testHaskellDepends = [
+         aeson ansi-terminal base bytestring Cabal casa-client casa-types
+         conduit conduit-extra containers cryptonite cryptonite-conduit
+         digest exceptions filelock generic-deriving hackage-security
+         hedgehog hpack hspec http-client http-client-tls http-conduit
+         http-download http-types memory mtl network-uri path path-io
+         persistent persistent-sqlite persistent-template primitive
+         QuickCheck raw-strings-qq resourcet rio rio-orphans rio-prettyprint
+         tar-conduit text text-metrics time transformers unix-compat
+         unliftio unordered-containers vector yaml zip-archive
+       ];
+       description = "Content addressable Haskell package management";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "pantry-tmp" = callPackage
     ({ mkDerivation, aeson, ansi-terminal, array, base, base-orphans
      , base64-bytestring, bytestring, Cabal, conduit, conduit-extra
···
      }:
      mkDerivation {
        pname = "password";
-       version = "3.0.1.0";
-       sha256 = "1kdc1lwya9sq3vb5wvvs2bz0z38mqn9cpim4f6awym99c57g01rk";
-       revision = "3";
-       editedCabalFile = "151z62mwqzblddcwj83dhwz2qfj53g0nl6sbdcsf489xbb9z3vk9";
-       setupHaskellDepends = [ base Cabal cabal-doctest ];
-       libraryHaskellDepends = [
-         base base64 bytestring cryptonite memory password-types
-         template-haskell text
-       ];
-       testHaskellDepends = [
-         base base-compat bytestring cryptonite doctest memory
-         password-types QuickCheck quickcheck-instances scrypt tasty
-         tasty-hunit tasty-quickcheck template-haskell text
-       ];
-       description = "Hashing and checking of passwords";
-       license = lib.licenses.bsd3;
-       platforms = lib.platforms.x86;
-       maintainers = [ lib.maintainers.cdepillabout ];
-     }) {};
-
-  "password_3_0_2_0" = callPackage
-    ({ mkDerivation, base, base-compat, base64, bytestring, Cabal
-     , cabal-doctest, cryptonite, doctest, memory, password-types
-     , QuickCheck, quickcheck-instances, scrypt, tasty, tasty-hunit
-     , tasty-quickcheck, template-haskell, text
-     }:
-     mkDerivation {
-       pname = "password";
        version = "3.0.2.0";
        sha256 = "092cryk5xsmq86l9i7yyjxrq83mi9q61grwdkw2n8c1dxijbdi8l";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
···
        description = "Hashing and checking of passwords";
        license = lib.licenses.bsd3;
        platforms = lib.platforms.x86;
-       hydraPlatforms = lib.platforms.none;
        maintainers = [ lib.maintainers.cdepillabout ];
      }) {};
 
···
      }:
      mkDerivation {
        pname = "patat";
-       version = "0.8.7.0";
-       sha256 = "05bg36lbhqlh80w952hrpy88n99qddv86hiqqbc6p3bc89rlzg1w";
+       version = "0.8.8.0";
+       sha256 = "13y2cj01yl1pq9gdbzjq1mc4qp8ljnmf3hdb13sc5058y0054zy1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "pcre-heavy";
-       version = "1.0.0.2";
-       sha256 = "1lfbjgvl55jh226n307c2w8mrb3l1myzbkjh4j0jfcb8nybzcp4a";
+       version = "1.0.0.3";
+       sha256 = "03wqr7q242j23g910l0qgagqyy8fi3b5gv7xsaym7m41zki1bw9y";
        revision = "1";
-       editedCabalFile = "14pprgwxkiaji3rqhsm0fv454wic6qxm7vy4a475yigadb1vz1ls";
+       editedCabalFile = "0wa517agsib2q658bfsb9fdm12yz3pqzj204v9jf9rz4fm4y8q81";
        libraryHaskellDepends = [
          base base-compat bytestring pcre-light semigroups
          string-conversions template-haskell
···
        pname = "persistent";
        version = "2.14.3.0";
        sha256 = "06cs30886s0y50kw4p2x8jw1k173il4mfqdfbkkdnd6kc97j920j";
+       revision = "1";
+       editedCabalFile = "1qbi74kmjk07wgib2y6pscjbr8mazlj490928h5bvahw10jx3611";
        libraryHaskellDepends = [
          aeson attoparsec base base64-bytestring blaze-html bytestring
          conduit containers fast-logger http-api-data lift-type monad-logger
···
        pname = "persistent-mongoDB";
        version = "2.13.0.1";
        sha256 = "1ck74kpzkz623c43qb8r1cjq8chi2p721vx95zrpciz8jm496235";
+       revision = "1";
+       editedCabalFile = "1h007vh9cx0y963xacxhf3rn2wjnc22ygil9c0z13mljmqssf5h6";
        libraryHaskellDepends = [
          aeson base bson bytestring cereal conduit http-api-data mongoDB
          network path-pieces persistent resource-pool resourcet text time
···
        license = lib.licenses.mit;
      }) {};
 
-  "persistent-qq_2_12_0_3" = callPackage
+  "persistent-qq_2_12_0_5" = callPackage
     ({ mkDerivation, aeson, base, bytestring, fast-logger
      , haskell-src-meta, hspec, HUnit, monad-logger, mtl, persistent
      , persistent-sqlite, resourcet, template-haskell, text, unliftio
      }:
      mkDerivation {
        pname = "persistent-qq";
-       version = "2.12.0.3";
-       sha256 = "0iv9x73g846grhb4vdh1xhpbwmk6hg5jh1xl2i7yh986pnqbl23g";
+       version = "2.12.0.5";
+       sha256 = "1mkgrczllayf8mq773rqp11d677fqjxcblmb3l97m0k1qyvpjq1h";
        libraryHaskellDepends = [
          base haskell-src-meta mtl persistent template-haskell text
        ];
···
      }:
      mkDerivation {
        pname = "pinch";
-       version = "0.4.1.2";
-       sha256 = "0khgx08mpj16lzqkk3xmxf5a6a68fc6x1vfg1r0lgj5lx2dgl89j";
-       revision = "1";
-       editedCabalFile = "1hpcwjgp12kp5hny74xjhrj7dj89pa4gin84b24arqlvmz5w9anq";
+       version = "0.4.2.0";
+       sha256 = "107zxrmhf8bdvjk5yy438xxg7015k1b0zvpkfvh7dif7l3j9c4cm";
        libraryHaskellDepends = [
          array base bytestring cereal containers deepseq ghc-prim hashable
          network semigroups text unordered-containers vector
···
        pname = "pipes";
        version = "4.3.16";
        sha256 = "163lx5sf68zx5kik5h1fjsyckwr9shdsn5k2dsjq3mhg077nxqgl";
-       revision = "5";
-       editedCabalFile = "1wjpz0anr4cpf8x5ffw2cpzcz9y4qvxa1qacdc576hyawkshfbj6";
+       revision = "6";
+       editedCabalFile = "16s8a1ijakhsk73ny2vrw6a8r2dszgncd0wk735ii6csg3l2c9pm";
        libraryHaskellDepends = [
          base exceptions mmorph mtl transformers void
        ];
···
        pname = "pipes-group";
        version = "1.0.12";
        sha256 = "1issfj3syi6lfbcdn3bhlbnlh86s92ldsb04c4ac69xipsgyhwqk";
-       revision = "6";
-       editedCabalFile = "19yzgmwv8vnx2jqsybs5h2cwfxnfc6xi2wzl96hi4jbf3cnkayyj";
+       revision = "7";
+       editedCabalFile = "0g6xrp4xi4gzar5l4jhpfi617zvy1hv0i9rg7gg23fcqfyc1kh22";
        libraryHaskellDepends = [
          base free pipes pipes-parse transformers
        ];
···
        mainProgram = "pkgtreediff";
      }) {};
 
+  "pkgtreediff_0_6_0" = callPackage
+    ({ mkDerivation, async, base, bytestring, directory, extra
+     , filepath, Glob, http-client, http-client-tls, http-directory
+     , http-types, koji, rpm-nvr, simple-cmd, simple-cmd-args, text
+     }:
+     mkDerivation {
+       pname = "pkgtreediff";
+       version = "0.6.0";
+       sha256 = "1n7dvv0c2hx90hv7fm1crhl8wn3krryv602msa7klzdl9syd9s1f";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base rpm-nvr ];
+       executableHaskellDepends = [
+         async base bytestring directory extra filepath Glob http-client
+         http-client-tls http-directory http-types koji rpm-nvr simple-cmd
+         simple-cmd-args text
+       ];
+       testHaskellDepends = [ base simple-cmd ];
+       description = "RPM package tree diff tool";
+       license = lib.licenses.gpl3Only;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "pkgtreediff";
+     }) {};
+
   "pktree" = callPackage
     ({ mkDerivation, base, containers }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "polysemy-conc";
-       version = "0.9.0.0";
-       sha256 = "0nmnc3h4np742yf0c196q3d0bfdvm9k3dp0482712ka1zjk8ck1k";
+       version = "0.10.0.0";
+       sha256 = "17683p4j54kapg279cbdxl7j0gyrshcsxcs0xngyaplgajwq6pnk";
        libraryHaskellDepends = [
          async base containers incipit-core polysemy polysemy-resume
          polysemy-time stm stm-chans torsor unagi-chan unix
···
   "polysemy-http" = callPackage
     ({ mkDerivation, aeson, base, case-insensitive, exon, hedgehog
      , http-client, http-client-tls, http-types, network, polysemy
-     , polysemy-plugin, polysemy-time, prelate, servant, servant-client
-     , servant-server, tasty, tasty-hedgehog, time, warp
+     , polysemy-plugin, prelate, servant-client, servant-server, tasty
+     , tasty-hedgehog, time, warp
      }:
      mkDerivation {
        pname = "polysemy-http";
-       version = "0.8.0.0";
-       sha256 = "1ccd45ln80b0pbdpk2wmky3hlz89f8jjlrfbnxd4ycf2crap8wzl";
+       version = "0.9.0.0";
+       sha256 = "13d5ydyaq6jjinq8h8slxj0iw6bfpg7cdv0lj0kl8kpvikr6livg";
        libraryHaskellDepends = [
          aeson base case-insensitive exon http-client http-client-tls
          http-types polysemy polysemy-plugin prelate time
        ];
        testHaskellDepends = [
          aeson base exon hedgehog http-client network polysemy
-         polysemy-plugin polysemy-time prelate servant servant-client
-         servant-server tasty tasty-hedgehog warp
+         polysemy-plugin prelate servant-client servant-server tasty
+         tasty-hedgehog warp
        ];
        description = "Polysemy effects for HTTP clients";
        license = "BSD-2-Clause-Patent";
···
      }:
      mkDerivation {
        pname = "polysemy-process";
-       version = "0.9.0.0";
-       sha256 = "1jd3iryv3vwy8zv328sfwh1ifrj788fhs63vgppr503wgkqzmwbn";
+       version = "0.10.0.0";
+       sha256 = "1f0bnpzd1k1aj9f3100z240ljvlw9b5ikafif05bwzcpavsy7zli";
        libraryHaskellDepends = [
          base incipit-core path path-io polysemy polysemy-conc
          polysemy-resume polysemy-time posix-pty process stm-chans
···
     ({ mkDerivation, base, polysemy, polysemy-methodology }:
      mkDerivation {
        pname = "polysemy-uncontrolled";
-       version = "0.1.1.0";
-       sha256 = "08q69sn1ac4xhpffiabayw2l5j1jy9iz1y37ww84kx32njas9c2b";
-       revision = "1";
-       editedCabalFile = "09j8fw0m1i0zp33v7pg3g2550blwajksvwbfnqq1slhmbyigd2jr";
+       version = "0.1.1.1";
+       sha256 = "01z19dy9gb78iwanszyipszq05piaa3n4qjmyj0yg22a1xsm02mi";
        libraryHaskellDepends = [ base polysemy polysemy-methodology ];
        description = "Uncontrolled toy effect for polysemy";
        license = lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "prelate";
-       version = "0.1.0.0";
-       sha256 = "149x6hmb25dd140kkpmcx60zqi6r4wc8yaj0jk75374b3gfqdvwz";
+       version = "0.2.0.0";
+       sha256 = "03620awa3yh3jfzqzr2i6gbhg4wfq33v7m42rzwnr6j83pkd59im";
        libraryHaskellDepends = [
          aeson base exon extra generic-lens incipit microlens microlens-ghc
          polysemy-chronos polysemy-conc polysemy-log polysemy-process
···
        maintainers = [ lib.maintainers.cdepillabout ];
      }) {};
 
-  "pretty-simple_4_1_1_0" = callPackage
+  "pretty-simple_4_1_2_0" = callPackage
     ({ mkDerivation, base, Cabal, cabal-doctest, containers, criterion
      , doctest, Glob, mtl, optparse-applicative, prettyprinter
      , prettyprinter-ansi-terminal, QuickCheck, template-haskell, text
···
      }:
      mkDerivation {
        pname = "pretty-simple";
-       version = "4.1.1.0";
-       sha256 = "0jjxlb0psj5wj7h8dsmqbx8qwdyzmgsv7r9my51x9qb7m6qpkqfs";
+       version = "4.1.2.0";
+       sha256 = "0di7n3kq2bl0xqj9b1xxf3jznyy6cfyjs6hf6g0bi72rf4wprd1w";
        isLibrary = true;
        isExecutable = true;
        setupHaskellDepends = [ base Cabal cabal-doctest ];
···
        license = lib.licenses.mit;
      }) {};
 
-  "process_1_6_15_0" = callPackage
+  "process_1_6_16_0" = callPackage
     ({ mkDerivation, base, bytestring, deepseq, directory, filepath
      , unix
      }:
      mkDerivation {
        pname = "process";
-       version = "1.6.15.0";
-       sha256 = "1azpl6qhi3ym4s2i1vh6z9kydpb9vgg76x803an9760jsdn1pcs4";
+       version = "1.6.16.0";
+       sha256 = "0a4kr9vndm7wxv9yw9ras5n3y3vr9xx0nkwkazfs06i7s6017hmv";
        libraryHaskellDepends = [ base deepseq directory filepath unix ];
        testHaskellDepends = [ base bytestring directory ];
        description = "Process libraries";
···
      }:
      mkDerivation {
        pname = "propellor";
-       version = "5.13";
-       sha256 = "0hr2n5kxc7l6a0h5fs6i5hspni7ymw5dzgxwfdsa8j6mpzrw5yd4";
+       version = "5.14.1";
+       sha256 = "1lbqd4mj8mjk1l2pcqjw214w9znnp9mbs8z7dxi5spd819vw0d2d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
 
   "purescript" = callPackage
     ({ mkDerivation, aeson, aeson-better-errors, aeson-pretty
-     , ansi-terminal, ansi-wl-pprint, array, base, base-compat
-     , blaze-html, bower-json, boxes, bytestring, Cabal, cborg
-     , cheapskate, clock, containers, cryptonite, data-ordlist, deepseq
-     , directory, dlist, edit-distance, exceptions, file-embed, filepath
-     , fsnotify, generic-random, gitrev, Glob, happy, haskeline, hspec
+     , ansi-terminal, ansi-wl-pprint, array, base, blaze-html
+     , bower-json, boxes, bytestring, Cabal, cborg, cheapskate, clock
+     , containers, cryptonite, data-ordlist, deepseq, directory, dlist
+     , edit-distance, exceptions, file-embed, filepath, fsnotify
+     , generic-random, gitrev, Glob, happy, haskeline, hspec
      , hspec-discover, http-types, HUnit, language-javascript, lens
      , lifted-async, lifted-base, memory, monad-control, monad-logger
      , monoidal-containers, mtl, network, newtype, optparse-applicative
···
      , serialise, sourcemap, split, stm, stringsearch, syb, text, these
      , time, transformers, transformers-base, transformers-compat
      , typed-process, unordered-containers, utf8-string, vector
+     , witherable
      }:
      mkDerivation {
        pname = "purescript";
-       version = "0.15.4";
-       sha256 = "13w604knmazp8bhbdcb7smfpyy4nwsbng10km0gmp367lxwr09yz";
+       version = "0.15.6";
+       sha256 = "19p8jzn76vc5w4g95y36vfhih1s5kq12dvczvfb7zkmn3n6n3g3m";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson aeson-better-errors aeson-pretty ansi-terminal array base
-         base-compat blaze-html bower-json boxes bytestring Cabal cborg
-         cheapskate clock containers cryptonite data-ordlist deepseq
-         directory dlist edit-distance file-embed filepath fsnotify Glob
-         haskeline language-javascript lens lifted-async lifted-base memory
+         blaze-html bower-json boxes bytestring Cabal cborg cheapskate clock
+         containers cryptonite data-ordlist deepseq directory dlist
+         edit-distance file-embed filepath fsnotify Glob haskeline
+         language-javascript lens lifted-async lifted-base memory
          monad-control monad-logger monoidal-containers mtl parallel parsec
          pattern-arrows process protolude regex-tdfa safe scientific
          semialign semigroups serialise sourcemap split stm stringsearch syb
          text these time transformers transformers-base transformers-compat
-         typed-process unordered-containers utf8-string vector
+         typed-process unordered-containers utf8-string vector witherable
        ];
        libraryToolDepends = [ happy ];
        executableHaskellDepends = [
          aeson aeson-better-errors aeson-pretty ansi-terminal ansi-wl-pprint
-         array base base-compat blaze-html bower-json boxes bytestring Cabal
-         cborg cheapskate clock containers cryptonite data-ordlist deepseq
+         array base blaze-html bower-json boxes bytestring Cabal cborg
+         cheapskate clock containers cryptonite data-ordlist deepseq
          directory dlist edit-distance exceptions file-embed filepath
          fsnotify gitrev Glob haskeline http-types language-javascript lens
          lifted-async lifted-base memory monad-control monad-logger
···
          parsec pattern-arrows process protolude regex-tdfa safe scientific
          semialign semigroups serialise sourcemap split stm stringsearch syb
          text these time transformers transformers-base transformers-compat
-         typed-process unordered-containers utf8-string vector
+         typed-process unordered-containers utf8-string vector witherable
        ];
        executableToolDepends = [ happy ];
        testHaskellDepends = [
          aeson aeson-better-errors aeson-pretty ansi-terminal array base
-         base-compat blaze-html bower-json boxes bytestring Cabal cborg
-         cheapskate clock containers cryptonite data-ordlist deepseq
-         directory dlist edit-distance file-embed filepath fsnotify
-         generic-random Glob haskeline hspec HUnit language-javascript lens
-         lifted-async lifted-base memory monad-control monad-logger
-         monoidal-containers mtl newtype parallel parsec pattern-arrows
-         process protolude QuickCheck regex-base regex-tdfa safe scientific
-         semialign semigroups serialise sourcemap split stm stringsearch syb
-         text these time transformers transformers-base transformers-compat
-         typed-process unordered-containers utf8-string vector
+         blaze-html bower-json boxes bytestring Cabal cborg cheapskate clock
+         containers cryptonite data-ordlist deepseq directory dlist
+         edit-distance file-embed filepath fsnotify generic-random Glob
+         haskeline hspec HUnit language-javascript lens lifted-async
+         lifted-base memory monad-control monad-logger monoidal-containers
+         mtl newtype parallel parsec pattern-arrows process protolude
+         QuickCheck regex-base regex-tdfa safe scientific semialign
+         semigroups serialise sourcemap split stm stringsearch syb text
+         these time transformers transformers-base transformers-compat
+         typed-process unordered-containers utf8-string vector witherable
        ];
        testToolDepends = [ happy hspec-discover ];
        doCheck = false;
        description = "PureScript Programming Language Compiler";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "purs";
+       broken = true;
      }) {};
 
   "purescript-ast" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "rank2classes_1_4_6" = callPackage
+    ({ mkDerivation, base, Cabal, cabal-doctest, data-functor-logistic
+     , distributive, doctest, markdown-unlit, tasty, tasty-hunit
+     , template-haskell, transformers
+     }:
+     mkDerivation {
+       pname = "rank2classes";
+       version = "1.4.6";
+       sha256 = "09wpjan20m6icrw7v41dn85kapy6ijz2mm17iw2pp51c4h9c09ci";
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
+       libraryHaskellDepends = [
+         base data-functor-logistic distributive template-haskell
+         transformers
+       ];
+       testHaskellDepends = [
+         base data-functor-logistic distributive doctest tasty tasty-hunit
+       ];
+       testToolDepends = [ markdown-unlit ];
+       description = "standard type constructor class hierarchy, only with methods of rank 2 types";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "rapid" = callPackage
     ({ mkDerivation, async, base, containers, foreign-store, stm }:
      mkDerivation {
···
        broken = true;
      }) {};
 
-  "rattletrap_11_2_12" = callPackage
+  "rattletrap_11_2_14" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, array, base, bytestring
      , containers, filepath, http-client, http-client-tls, text
      }:
      mkDerivation {
        pname = "rattletrap";
-       version = "11.2.12";
-       sha256 = "1c3mpcjx2yl1w5myrqsdcsgr5x2hiv4pw5qd3ghlxkhl15rxbkzv";
+       version = "11.2.14";
+       sha256 = "0r879vbdhv77l14wzv03s8hlhmmzzfl6igkwnclr9lq8ncbafrxm";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "registry";
-       version = "0.3.3.0";
-       sha256 = "12xj9wrqp3wfg1kjql6l6l4avk2mf40n1z7mhhsrc457v7br1lfc";
+       version = "0.3.3.4";
+       sha256 = "1x5ilikd9xxdhkzvvm5mklxrzx8vbyzzji4rqnw8lsgrxpzwca9d";
        libraryHaskellDepends = [
          base containers exceptions hashable mmorph mtl protolude resourcet
          semigroupoids semigroups template-haskell text transformers-base
···
      }:
      mkDerivation {
        pname = "registry-aeson";
-       version = "0.2.2.0";
-       sha256 = "1p5imwr93hx4nid57f2qfad3s2q0b667ns2hl0vs9y54fqvy79ra";
+       version = "0.2.3.3";
+       sha256 = "03wh6sl921hsqk32749y4gklpfjxjbhyw0dwk0zw6ja28jzpny7g";
        libraryHaskellDepends = [
          aeson base bytestring containers protolude registry
          template-haskell text transformers unordered-containers vector
···
      }:
      mkDerivation {
        pname = "registry-hedgehog";
-       version = "0.7.0.5";
-       sha256 = "1mc8m74mx5119b6k7ac4ysilnwm0163a4c57gc15620mw3f0w0dl";
+       version = "0.7.2.0";
+       sha256 = "07lynkbwcjjlhh7v7rxa7s1b3m3vh1lfamdq4iwqy8b54p7fybs5";
        libraryHaskellDepends = [
          base containers hedgehog mmorph multimap protolude registry tasty
          tasty-discover tasty-hedgehog tasty-th template-haskell text
···
        pname = "req-conduit";
        version = "1.0.1";
        sha256 = "0zyy9j6iiz8z2jdx25vp77arfbmrck7bjndm3p4s9l9399c5bm62";
+       revision = "1";
+       editedCabalFile = "0gbm1c95ml7binmazn15737a8ls5p21f9d0d6pzc3fla0rz91ic1";
        libraryHaskellDepends = [
          base bytestring conduit http-client req resourcet transformers
        ];
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "resourcet_1_3_0" = callPackage
+    ({ mkDerivation, base, containers, exceptions, hspec, mtl
+     , primitive, transformers, unliftio-core
+     }:
+     mkDerivation {
+       pname = "resourcet";
+       version = "1.3.0";
+       sha256 = "0swrz7h73m86x3937gdiay3z30y9hn35n86v5brh38j2xs2ifq7c";
+       libraryHaskellDepends = [
+         base containers exceptions mtl primitive transformers unliftio-core
+       ];
+       testHaskellDepends = [ base exceptions hspec transformers ];
+       description = "Deterministic allocation and freeing of scarce resources";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "resourcet-effectful" = callPackage
     ({ mkDerivation, base, effectful-core, resourcet }:
      mkDerivation {
···
        description = "Test tools for Ribosome";
        license = "BSD-2-Clause-Patent";
        hydraPlatforms = lib.platforms.none;
-       broken = true;
-     }) {chiasma-test = null;};
+     }) {};
 
   "richreports" = callPackage
     ({ mkDerivation, ascetic, base, MissingH }:
···
        pname = "rustls";
        version = "0.0.0.0";
        sha256 = "1j7qxmapz9znmbd02359qxbsh1pkprzcg2jjpsz80kfyb6bjj766";
+       revision = "1";
+       editedCabalFile = "18jh00sbyixqjm2y6048f83qpqq4jlbzrik5i62is93rmn4pnnc2";
        libraryHaskellDepends = [
          base bytestring derive-storable derive-storable-plugin network
          resourcet text transformers
···
        license = lib.licenses.asl20;
      }) {};
 
+  "scalpel_0_6_2_1" = callPackage
+    ({ mkDerivation, base, bytestring, case-insensitive, data-default
+     , http-client, http-client-tls, scalpel-core, tagsoup, text
+     }:
+     mkDerivation {
+       pname = "scalpel";
+       version = "0.6.2.1";
+       sha256 = "0w3l38czfsgbyd3x6yir7qw9bl8nmhclrbpbwfyhs39728jlscnc";
+       libraryHaskellDepends = [
+         base bytestring case-insensitive data-default http-client
+         http-client-tls scalpel-core tagsoup text
+       ];
+       description = "A high level web scraping library for Haskell";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "scalpel-core" = callPackage
     ({ mkDerivation, base, bytestring, containers, criterion
      , data-default, fail, HUnit, mtl, pointedlist, regex-base
···
        license = lib.licenses.asl20;
      }) {};
 
+  "scalpel-core_0_6_2_1" = callPackage
+    ({ mkDerivation, base, bytestring, containers, criterion
+     , data-default, fail, HUnit, mtl, pointedlist, regex-base
+     , regex-tdfa, tagsoup, text, transformers, vector
+     }:
+     mkDerivation {
+       pname = "scalpel-core";
+       version = "0.6.2.1";
+       sha256 = "1yl1lsi5xm3qdlww2sb6vyppjiisj54f4yzvffv3qg8dgkfjfdra";
+       libraryHaskellDepends = [
+         base bytestring containers data-default fail mtl pointedlist
+         regex-base regex-tdfa tagsoup text transformers vector
+       ];
+       testHaskellDepends = [ base HUnit regex-base regex-tdfa tagsoup ];
+       benchmarkHaskellDepends = [ base criterion tagsoup text ];
+       description = "A high level web scraping library for Haskell";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "scalpel-search" = callPackage
     ({ mkDerivation, base, hspec, scalpel, scalpel-core, tagsoup, text
      , uri
···
        pname = "sdl2";
        version = "2.5.4.0";
        sha256 = "1g35phifz49kxk48s8jmgglxhxl79cbzc1cg2qlgk0vdpxpin8ym";
+       revision = "1";
+       editedCabalFile = "19kr714da3lp064h1ky1bxwgkcrjy2ks5qby6214fj99dg7rxipr";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        pname = "serialise";
        version = "0.2.6.0";
        sha256 = "05m5h5vfjp4wvh6y7j2f3d4c3l6gxww2n1v38vqrjacpw641izwk";
+       revision = "1";
+       editedCabalFile = "0rlsi4jq2d1dak2fps5flcn27lywjlhvsi0x2k2lvnjqawnfb3f9";
        libraryHaskellDepends = [
          array base bytestring cborg containers ghc-prim half hashable
          primitive strict text these time unordered-containers vector
···
        pname = "servant";
        version = "0.19";
        sha256 = "1rahn436vc3xajn563ni25jqkg87fvhqkpswan1xy6qsfr0ikdjb";
-       revision = "4";
-       editedCabalFile = "0g0y6xj9wa8fl62slqfpimx2c6xadqvyqhl661pbbk3f1p11j4cd";
+       revision = "5";
+       editedCabalFile = "0hn8qkvzazjncnawzzx7l0kdhzj35fy1387b00znirz6kx9w5vqp";
        libraryHaskellDepends = [
          aeson attoparsec base base-compat bifunctors bytestring
          case-insensitive constraints deepseq http-api-data http-media
···
        pname = "servant-auth-client";
        version = "0.4.1.0";
        sha256 = "16rmwdrx0qyqa821ipayczzl3gv8gvqgx8k9q8qaw19w87hwkh83";
-       revision = "5";
-       editedCabalFile = "19y15pn7h1gv22y4yww33ri27plfwblygh5alfznsjdnmfzij3v4";
+       revision = "6";
+       editedCabalFile = "0d6mi3w3gx9h21awf1gy2wx7dwh5l9ichww21a3p5rfd8a8swypf";
        libraryHaskellDepends = [
          base bytestring containers servant servant-auth servant-client-core
        ];
···
        pname = "servant-auth-docs";
        version = "0.2.10.0";
        sha256 = "0j1ynnrb6plrhpb2vzs2p7a9jb41llp0j1jwgap7hjhkwhyc7wxd";
-       revision = "10";
-       editedCabalFile = "0c77b23wxqw168sk11s897pjnq4ma4cjvw99b0ny2ggf0v83hw6n";
+       revision = "11";
+       editedCabalFile = "1xk6j4l5jccwzk0xkiv6ny6w33g92wziacqvqgc5rvy2mzyff4fl";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          base lens servant servant-auth servant-docs text
···
        pname = "servant-client";
        version = "0.19";
        sha256 = "1bdapsr6il0f019ss8wsxndpc8cd5czj40xczay5qhl7fqnxg5pa";
-       revision = "3";
-       editedCabalFile = "16a3lsm2w4jvnisy0n38jx8a1974qywg569fml6zhx9fvz741dd8";
+       revision = "4";
+       editedCabalFile = "0j2i3fvqkhf80hada6vga3674z3bnnl1n3k655alfwnxl7zlgppa";
        libraryHaskellDepends = [
          base base-compat bytestring containers deepseq exceptions
          http-client http-media http-types kan-extensions monad-control mtl
···
        pname = "servant-client-core";
        version = "0.19";
        sha256 = "0cisc5cyl367cwrch1gr812aspd36a21hkwi6mwj708rpspwvrmc";
-       revision = "3";
-       editedCabalFile = "1sk2nf0w9wxd7sqn3kla65kk91rk03xz8ll297wg2b2xqybvy8ph";
+       revision = "4";
+       editedCabalFile = "1qhqab6akfw6ay4rlrbwmii1s8flbkgp9b9bfzkdhwng7nvwdc80";
        libraryHaskellDepends = [
          aeson base base-compat base64-bytestring bytestring constraints
          containers deepseq exceptions free http-media http-types
···
        pname = "servant-js";
        version = "0.9.4.2";
        sha256 = "15n5s3i491cxjxj70wa8yhpipaz47q46s04l4ysc64wgijlnm8xy";
-       revision = "2";
-       editedCabalFile = "1wi3q1rn384h9gvxv6dmk31h0wwb6j4yjimz01cz6sgs7fs77ndj";
+       revision = "3";
+       editedCabalFile = "1i8ngrrdnql03hlv07wfwbswfwm6zfj66n3byg647hcl71q67ppc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "servant-multipart";
        version = "0.12.1";
        sha256 = "1p55kb3zhq25ncp7wimhggssn68abfgsnlldk13rk1iajaj6y8y5";
-       revision = "3";
-       editedCabalFile = "1wkbwd6gypmv7aziaag3gzwgvvqx4bw8i4qp2vpmc7ip2ydm10ml";
+       revision = "4";
+       editedCabalFile = "0z4n3a1cdb082nwh3ig68wjk617cvwpq0n9ivsab55nvsr2wsm8q";
        libraryHaskellDepends = [
          base bytestring directory lens resourcet servant servant-docs
          servant-foreign servant-multipart-api servant-server
···
        pname = "servant-openapi3";
        version = "2.0.1.5";
        sha256 = "0zcyqga4hbdyk34368108vv9vavzdhv26xphas7yppada2sshfay";
+       revision = "1";
+       editedCabalFile = "0bscnxbw1zd0f7ycjr54kxfdcxzndgbxpamc75r1yzly262xrc1b";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          aeson aeson-pretty base base-compat bytestring hspec http-media
···
        pname = "servant-server";
        version = "0.19.1";
        sha256 = "1g88vdwacwli79y5idqlrbhl2k9r463h560f2lk5abhqsmsm9bhd";
-       revision = "2";
-       editedCabalFile = "18as15x192ila9cqiff1yliidwlihx9kvjgji2sml11ahwhqyy75";
+       revision = "3";
+       editedCabalFile = "16jqzkrf9r7lz7y48dnl4v8s4hfn7hmfsmfbj7d96h53r2v4pz5g";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        mainProgram = "test";
      }) {};
 
+  "signal-messaging-dbus" = callPackage
+    ({ mkDerivation, base, bytestring, dbus, unliftio }:
+     mkDerivation {
+       pname = "signal-messaging-dbus";
+       version = "1.0.0.2";
+       sha256 = "0xlsrbx92vdxn1wa3za3pana7z1py0lfp4fyjrpyqp0m66rl81s1";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base bytestring dbus unliftio ];
+       executableHaskellDepends = [ base bytestring dbus unliftio ];
+       description = "Bindings for signal-cli's DBus interface";
+       license = "AGPL";
+       mainProgram = "signal-dbus-example";
+     }) {};
+
   "signals" = callPackage
     ({ mkDerivation, base, containers, hashable, imperative-edsl-vhdl
      , language-vhdl, mtl, observable-sharing, operational-alacarte
···
      }) {};
 
   "significant-figures" = callPackage
-    ({ mkDerivation, base, HasBigDecimal, haskeline, HUnit, parsec
-     , tasty, tasty-hunit, terminfo, text
+    ({ mkDerivation, base, HasBigDecimal, haskeline, parsec, tasty
+     , tasty-hunit, tasty-quickcheck, terminfo, text
      }:
      mkDerivation {
        pname = "significant-figures";
-       version = "0.1.0.1";
-       sha256 = "0ry17vy8mvwd5z4i8vnk86gqxli5lgbmhgp1209qivx3y3pha5p6";
+       version = "0.2.0.0";
+       sha256 = "07x4sgjcnjf7hmq7x17lc2qwd1vsnybm6s620y0cwaawr81rhlxx";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base HasBigDecimal parsec text ];
···
          base HasBigDecimal haskeline parsec terminfo text
        ];
        testHaskellDepends = [
-         base HasBigDecimal HUnit tasty tasty-hunit text
+         base HasBigDecimal tasty tasty-hunit tasty-quickcheck text
        ];
        description = "Calculate expressions involving significant figures";
        license = lib.licenses.gpl3Plus;
···
        maintainers = [ lib.maintainers.turion ];
      }) {};
 
+  "simple-affine-space_0_2" = callPackage
+    ({ mkDerivation, base, deepseq, directory, filepath, hlint, process
+     , regex-posix
+     }:
+     mkDerivation {
+       pname = "simple-affine-space";
+       version = "0.2";
+       sha256 = "1wxsbw1l5ynff3df6yvz22zwnnm77bhr67yccpkfsz9l9l566a3w";
+       libraryHaskellDepends = [ base deepseq ];
+       testHaskellDepends = [
+         base directory filepath hlint process regex-posix
+       ];
+       description = "A simple library for affine and vector spaces";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = [ lib.maintainers.turion ];
+     }) {};
+
   "simple-amount" = callPackage
     ({ mkDerivation, aeson, base, data-default, gmp, hedgehog, HUnit
      , lens, mpfr, pretty, pretty-show, profunctors, split, tasty
···
      }:
      mkDerivation {
        pname = "sitepipe";
-       version = "0.4.0.1";
-       sha256 = "1iq7i2zs1bqnxqjp5bwsx8q2vvp1kngwg45mzsiwmhzq4m88x80h";
+       version = "0.4.0.2";
+       sha256 = "11v2135a92jcxi4nssds76ki25rdbrdp0q2fl6nnq5sw4ickk7ar";
        libraryHaskellDepends = [
          aeson base bytestring containers directory exceptions filepath Glob
          lens lens-aeson megaparsec MissingH mtl mustache
···
        mainProgram = "skylighting";
      }) {};
 
-  "skylighting_0_13" = callPackage
+  "skylighting_0_13_1" = 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";
-       sha256 = "0gjafmiqah9d7a6h3qx7jmkih6yc47bks5r6hgl5911vhjgifm7k";
+       version = "0.13.1";
+       sha256 = "0azlnrms9cp6vfp33mrzlhv2vv8v3257hri8j3r37x8h2ml3i6h9";
        configureFlags = [ "-fexecutable" ];
        isLibrary = true;
        isExecutable = true;
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "skylighting-core_0_13" = callPackage
+  "skylighting-core_0_13_1" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, base64-bytestring, binary
      , bytestring, case-insensitive, colour, containers, criterion, Diff
      , directory, filepath, mtl, pretty-show, QuickCheck, safe, tasty
···
      }:
      mkDerivation {
        pname = "skylighting-core";
-       version = "0.13";
-       sha256 = "01j6v2dy04lsmrx98hvgpb6vnirs1h0gbiy7q5ck5q3k37cqys7p";
-       revision = "1";
-       editedCabalFile = "1kbwbkjgilr0m0hfiq94rlvk691wgrmlrbd916mkv5h869qdyjrr";
+       version = "0.13.1";
+       sha256 = "1cfc03684pwxydms5ld7y75msaw5w4y5hhdpyi36xj17y4wf1drw";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "skylighting-extensions";
        version = "1.0.0.0";
        sha256 = "1wi9vai606gf25m3q4p4ilwm8d2m7p5xk0wczq34h9pamfhcaqic";
+       revision = "2";
+       editedCabalFile = "0i1rwlvy92dlr71wl9n6rly4kry90lynbs3gn1l0gg75d0scbpkq";
        libraryHaskellDepends = [
          base containers skylighting skylighting-modding text
        ];
···
        ];
        description = "Generate CSV Exports of your Solana Staking Rewards";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "solana-staking-csvs";
      }) {};
 
···
      }:
      mkDerivation {
        pname = "spade";
-       version = "0.1.0.7";
-       sha256 = "02pih7d5jv231gj674rilyfkbc27his7ibs50whkjqnfbf673fzl";
+       version = "0.1.0.8";
+       sha256 = "000cpyz9bvjf7rw2w0vwi4m6jj1hmdiq1qxs1039yrnfx7pq36r1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "stack";
        version = "2.9.1";
        sha256 = "01020dx89m07qmjs58vs2kidhkzq3106md08w6c65bzxvlf6kcwk";
-       revision = "2";
-       editedCabalFile = "14k4b8cn52bdl4n181afq8zqycl8nb4mv8vsg636c6b4s9yc053w";
+       revision = "3";
+       editedCabalFile = "1i0ddb17kzxvlv3xpgyi3acsi21h6iadwwv21ih063cdk9ilysxg";
        configureFlags = [
          "-fdisable-git-info" "-fhide-dependency-versions"
          "-fsupported-build"
···
        license = lib.licenses.mit;
      }) {};
 
+  "streaming-commons_0_2_2_5" = callPackage
+    ({ mkDerivation, array, async, base, bytestring, deepseq, directory
+     , gauge, hspec, hspec-discover, network, process, QuickCheck
+     , random, stm, text, transformers, unix, zlib
+     }:
+     mkDerivation {
+       pname = "streaming-commons";
+       version = "0.2.2.5";
+       sha256 = "0157xjz8nhr65y9rm7rdf3pnjlrsgaqam7qfg7nqq91bvfdq2l6a";
+       libraryHaskellDepends = [
+         array async base bytestring directory network process random stm
+         text transformers unix zlib
+       ];
+       testHaskellDepends = [
+         array async base bytestring deepseq hspec network QuickCheck text
+         unix zlib
+       ];
+       testToolDepends = [ hspec-discover ];
+       benchmarkHaskellDepends = [ base bytestring deepseq gauge text ];
+       description = "Common lower-level functions needed by various streaming data libraries";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "streaming-concurrency" = callPackage
     ({ mkDerivation, base, exceptions, hspec, HUnit, lifted-async
      , monad-control, QuickCheck, quickcheck-instances, stm, streaming
···
      }:
      mkDerivation {
        pname = "swagger2";
-       version = "2.8.4";
-       sha256 = "11gpnh7dg6bqbvgwfw9xri3l08kvxply698arpz62ix38qyf14iv";
+       version = "2.8.5";
+       sha256 = "16r9657sp6zvj4jcs0yp7nvgnhjfsla29knaimkddsqa3k8qf1v6";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          aeson aeson-pretty base base-compat-batteries bytestring containers
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "swagger2_2_8_6" = 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, network, optics-core
+     , optics-th, QuickCheck, quickcheck-instances, scientific
+     , template-haskell, text, time, transformers, unordered-containers
+     , utf8-string, uuid-types, vector
+     }:
+     mkDerivation {
+       pname = "swagger2";
+       version = "2.8.6";
+       sha256 = "1cvz98cn4xzr7fx8q7rwr22l7l95z1cvq7qpm1shwca5j4gq5084";
+       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
+       ];
+       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 = "Swagger 2.0 data model";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "swapper" = callPackage
     ({ mkDerivation, base, binary, bytestring, deepseq, happstack-data
      , happstack-state, parallel, tokyocabinet
···
      }:
      mkDerivation {
        pname = "swarm";
-       version = "0.1.0.1";
-       sha256 = "1zcyyi1vd0y21qyfcx3kcbp6bwcn6n33my44g1jkqqvfxigp4zya";
+       version = "0.1.1.0";
+       sha256 = "18w84a0hb975qcwsd9kcji88h6xyrf7dbqcvfjdhhgbbd4y8pv9h";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
      }:
      mkDerivation {
        pname = "sydtest";
-       version = "0.12.0.1";
-       sha256 = "0psnv1kpai4sn7z8g0lgpmzf0myp71wp5sganvyawi8iwk88cw8w";
+       version = "0.13.0.0";
+       sha256 = "0msa5y6fl00qjrj08c6bccbav179f05jk9hb9lmfbffq6bc86rc5";
        libraryHaskellDepends = [
          async autodocodec autodocodec-yaml base bytestring containers Diff
          dlist envparse filepath MonadRandom mtl optparse-applicative path
···
      }) {};
 
   "taffybar" = callPackage
-    ({ mkDerivation, ansi-terminal, base, broadcast-chan, bytestring
-     , ConfigFile, containers, dbus, dbus-hslogger, directory, dyre
-     , either, enclosed-exceptions, filepath, gi-cairo
-     , gi-cairo-connector, gi-cairo-render, gi-gdk, gi-gdkpixbuf
-     , gi-gdkx11, gi-glib, gi-gtk, gi-gtk-hs, gi-pango, gtk-sni-tray
-     , gtk-strut, gtk3, haskell-gi, haskell-gi-base, hslogger
-     , HStringTemplate, http-client, http-client-tls, http-types
-     , multimap, old-locale, optparse-applicative, parsec, process
-     , rate-limit, regex-compat, safe, scotty, split
-     , status-notifier-item, stm, template-haskell, text, time
-     , time-locale-compat, time-units, transformers, transformers-base
-     , tuple, unix, utf8-string, X11, xdg-basedir, xdg-desktop-entry
-     , xml, xml-helpers, xmonad
+    ({ mkDerivation, aeson, ansi-terminal, base, broadcast-chan
+     , bytestring, conduit, ConfigFile, containers, data-default, dbus
+     , dbus-hslogger, directory, dyre, either, enclosed-exceptions
+     , filepath, gi-cairo, gi-cairo-connector, gi-cairo-render, gi-gdk
+     , gi-gdkpixbuf, gi-gdkx11, gi-glib, gi-gtk, gi-gtk-hs, gi-pango
+     , gtk-sni-tray, gtk-strut, gtk3, haskell-gi, haskell-gi-base
+     , hslogger, HStringTemplate, http-client, http-client-tls
+     , http-conduit, http-types, multimap, old-locale
+     , optparse-applicative, parsec, process, rate-limit, regex-compat
+     , safe, scotty, split, status-notifier-item, stm, template-haskell
+     , text, time, time-locale-compat, time-units, transformers
+     , transformers-base, tuple, unix, utf8-string, X11, xdg-basedir
+     , xdg-desktop-entry, xml, xml-helpers, xmonad
      }:
      mkDerivation {
        pname = "taffybar";
-       version = "3.3.0";
-       sha256 = "17ggcv1y3md11sccbb9mpss2qdanlkv7wy098qh28gra9kq4ibgm";
+       version = "4.0.0";
+       sha256 = "1rwir1jlqxby2gj4pxbhz9khn6pfgn4bn3wca6q8zyzn0vs3i2wg";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
-         ansi-terminal base broadcast-chan bytestring ConfigFile containers
-         dbus dbus-hslogger directory dyre either enclosed-exceptions
-         filepath gi-cairo gi-cairo-connector gi-cairo-render gi-gdk
-         gi-gdkpixbuf gi-gdkx11 gi-glib gi-gtk gi-gtk-hs gi-pango
-         gtk-sni-tray gtk-strut haskell-gi haskell-gi-base hslogger
-         HStringTemplate http-client http-client-tls http-types multimap
-         old-locale parsec process rate-limit regex-compat safe scotty split
+         aeson ansi-terminal base broadcast-chan bytestring conduit
+         ConfigFile containers data-default dbus dbus-hslogger directory
+         dyre either enclosed-exceptions filepath gi-cairo
+         gi-cairo-connector gi-cairo-render gi-gdk gi-gdkpixbuf gi-gdkx11
+         gi-glib gi-gtk gi-gtk-hs gi-pango gtk-sni-tray gtk-strut haskell-gi
+         haskell-gi-base hslogger HStringTemplate http-client
+         http-client-tls http-conduit http-types multimap old-locale parsec
+         process rate-limit regex-compat safe scotty split
          status-notifier-item stm template-haskell text time
          time-locale-compat time-units transformers transformers-base tuple
          unix utf8-string X11 xdg-basedir xdg-desktop-entry xml xml-helpers
···
        ];
        libraryPkgconfigDepends = [ gtk3 ];
        executableHaskellDepends = [
-         base directory hslogger optparse-applicative
+         base data-default directory hslogger optparse-applicative
        ];
        executablePkgconfigDepends = [ gtk3 ];
        description = "A desktop bar similar to xmobar, but with more GUI";
        license = lib.licenses.bsd3;
        badPlatforms = lib.platforms.darwin;
-       hydraPlatforms = lib.platforms.none;
        mainProgram = "taffybar";
        maintainers = [ lib.maintainers.rvl ];
-       broken = true;
      }) {inherit (pkgs) gtk3;};
 
   "tag-bits" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "tasty-hedgehog_1_3_1_0" = callPackage
+  "tasty-hedgehog_1_4_0_0" = callPackage
     ({ mkDerivation, base, hedgehog, tagged, tasty
      , tasty-expected-failure
      }:
      mkDerivation {
        pname = "tasty-hedgehog";
-       version = "1.3.1.0";
-       sha256 = "1iq452mvd9wc9pfmjsmm848jwp3cvsk1faf2mlr21vcs0yaxvq3m";
+       version = "1.4.0.0";
+       sha256 = "1gcwbiqnxv7bkq48sh1d7ra3i53kdflzhpqrx4vlmhd7i69h1r4k";
        libraryHaskellDepends = [ base hedgehog tagged tasty ];
        testHaskellDepends = [
          base hedgehog tasty tasty-expected-failure
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "termbox_1_0_0" = callPackage
+    ({ mkDerivation, base, ki, termbox-bindings-hs }:
+     mkDerivation {
+       pname = "termbox";
+       version = "1.0.0";
+       sha256 = "0diqjxam4vvw8prycjrq7qvn44lihda5rwibhwwp87vn840z0j3s";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base ki termbox-bindings-hs ];
+       description = "termbox";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "termbox-banana" = callPackage
     ({ mkDerivation, base, reactive-banana, termbox }:
      mkDerivation {
···
        hydraPlatforms = lib.platforms.none;
        mainProgram = "example";
        broken = true;
+     }) {};
+
+  "termbox-bindings-c" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "termbox-bindings-c";
+       version = "0.1.0";
+       sha256 = "1q7frripz88zgcfmx2lab2vrj19gywnskng07zf7icsj9j6bdwyw";
+       libraryHaskellDepends = [ base ];
+       description = "termbox bindings";
+       license = lib.licenses.bsd3;
+     }) {};
+
+  "termbox-bindings-hs" = callPackage
+    ({ mkDerivation, base, termbox-bindings-c }:
+     mkDerivation {
+       pname = "termbox-bindings-hs";
+       version = "0.1.0";
+       sha256 = "07m6lp997skqp04a430ynsrzdpwcczblxawvlcbizffsznkmnl64";
+       libraryHaskellDepends = [ base termbox-bindings-c ];
+       description = "termbox bindings";
+       license = lib.licenses.bsd3;
      }) {};
 
   "termcolor" = callPackage
···
      }) {inherit (pkgs) gtk3; inherit (pkgs) pcre2; 
          vte_291 = pkgs.vte;};
 
+  "termonad_4_4_0_0" = callPackage
+    ({ mkDerivation, adjunctions, aeson, base, Cabal, cabal-doctest
+     , classy-prelude, colour, constraints, containers, data-default
+     , directory, distributive, doctest, dyre, file-embed, filepath
+     , focuslist, genvalidity-containers, genvalidity-hspec, gi-gdk
+     , gi-gio, gi-glib, gi-gtk, gi-pango, gi-vte, gtk3, haskell-gi-base
+     , hedgehog, inline-c, lens, mono-traversable, pcre2, pretty-simple
+     , QuickCheck, tasty, tasty-hedgehog, tasty-hspec, template-haskell
+     , text, transformers, unordered-containers, vte_291, xml-conduit
+     , xml-html-qq, yaml
+     }:
+     mkDerivation {
+       pname = "termonad";
+       version = "4.4.0.0";
+       sha256 = "0xyb0z0k16mpsr5nc7a4k7w04k6skfwja25f5w329w1djrkvqfyx";
+       isLibrary = true;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
+       libraryHaskellDepends = [
+         adjunctions aeson base classy-prelude colour constraints containers
+         data-default directory distributive dyre file-embed filepath
+         focuslist gi-gdk gi-gio gi-glib gi-gtk gi-pango gi-vte
+         haskell-gi-base inline-c lens mono-traversable pretty-simple
+         QuickCheck text transformers unordered-containers xml-conduit
+         xml-html-qq yaml
+       ];
+       libraryPkgconfigDepends = [ gtk3 pcre2 vte_291 ];
+       executableHaskellDepends = [ base ];
+       testHaskellDepends = [
+         base doctest genvalidity-containers genvalidity-hspec hedgehog lens
+         QuickCheck tasty tasty-hedgehog tasty-hspec template-haskell
+       ];
+       description = "Terminal emulator configurable in Haskell";
+       license = lib.licenses.bsd3;
+       badPlatforms = lib.platforms.darwin;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "termonad";
+       maintainers = [ lib.maintainers.cdepillabout ];
+     }) {inherit (pkgs) gtk3; inherit (pkgs) pcre2; 
+         vte_291 = pkgs.vte;};
+
   "termplot" = callPackage
     ({ mkDerivation, base, brick, data-default, optparse-applicative
      , process, split, time-units, transformers, unix, vty
···
      }) {};
 
   "the-snip" = callPackage
-    ({ mkDerivation, attoparsec, base, bytestring, hspec
-     , optparse-simple, path, path-io, rio, text, unix
+    ({ mkDerivation, attoparsec, base, hspec, optparse-simple, path
+     , path-io, rio, unix
      }:
      mkDerivation {
        pname = "the-snip";
-       version = "0.0.0.1";
-       sha256 = "087wddnzz9hxjqd057wjjvlmbzr1x65bhycnhm45aqpxcbzy63i1";
+       version = "0.1.0.0";
+       sha256 = "18jn9f317ayhxymr8mvjcfid4gblsjw6db04q3ah9pifarz78snx";
        isLibrary = true;
        isExecutable = true;
-       libraryHaskellDepends = [
-         attoparsec base bytestring path path-io rio text unix
-       ];
+       libraryHaskellDepends = [ attoparsec base path path-io rio unix ];
        executableHaskellDepends = [
-         attoparsec base bytestring optparse-simple path path-io rio text
-         unix
+         attoparsec base optparse-simple path path-io rio unix
        ];
        testHaskellDepends = [
-         attoparsec base bytestring hspec path path-io rio text unix
+         attoparsec base hspec path path-io rio unix
        ];
        description = "Command line tool for extracting demarcated snippets from text files";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "twitchapi";
-       version = "0.0.1";
-       sha256 = "14yy5hbz1mxrr4pxwy62vslyx0rjkq7flmglrx5h7vzijc240jf7";
+       version = "0.0.2";
+       sha256 = "0lw7lr41lnm0jz3ig3y7y23348sp7mvpnihz90nh8j5iv74j7z12";
        libraryHaskellDepends = [
          aeson base bytestring hoauth2 http-client text time timerep
          uri-bytestring
        ];
        testHaskellDepends = [
-         aeson base bytestring hspec QuickCheck text time timerep
+         aeson base bytestring hspec http-client QuickCheck text time
+         timerep
        ];
        description = "Client access to Twitch.tv API endpoints";
        license = lib.licenses.bsd3;
···
        pname = "type-level-sets";
        version = "0.8.9.0";
        sha256 = "1acsr7g9ssli9yil9kws47gc6h3csmk2afncyki41pipa1vsriv4";
-       revision = "1";
-       editedCabalFile = "0cc0ws2plharq0gvindgmkp1fs82zd43zijkh7wf0ilfnr2l17z2";
+       revision = "2";
+       editedCabalFile = "1pd7lblyz7frgwm473is7phv7rm9cj5ypyf2z1n1jwj0aj8mb11p";
        libraryHaskellDepends = [ base ghc-prim ];
        description = "Type-level sets and finite maps (with value-level counterparts)";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "tzdata";
-       version = "0.2.20220923.0";
-       sha256 = "0wzk15hlrjpdqh796h1v120223kn1327qr0rzp13ak0y5hm1fqrw";
+       version = "0.2.20221011.0";
+       sha256 = "118k2zbn71cri9f7b7293hsj5vyrmz7v60a7rl0r2abgkxkf39d2";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base bytestring containers deepseq vector
···
        license = lib.licenses.asl20;
      }) {};
 
+  "unicode-data_0_4_0" = callPackage
+    ({ mkDerivation, base, deepseq, hspec, hspec-discover, tasty
+     , tasty-bench
+     }:
+     mkDerivation {
+       pname = "unicode-data";
+       version = "0.4.0";
+       sha256 = "09s1chc7g9sgvjxs6ld5m4vrkm1shf7401ywffjrx1xfdjidb428";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base hspec ];
+       testToolDepends = [ hspec-discover ];
+       benchmarkHaskellDepends = [ base deepseq tasty tasty-bench ];
+       description = "Access Unicode Character Database (UCD)";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "unicode-data-names" = callPackage
     ({ mkDerivation, base, deepseq, hspec, hspec-discover, tasty
      , tasty-bench, unicode-data
      }:
      mkDerivation {
        pname = "unicode-data-names";
-       version = "0.1.0";
-       sha256 = "08f071i6p13q6n9aqlibdn0zsl4b6079lml341bfydd5qj9kjmgv";
+       version = "0.2.0";
+       sha256 = "0i28rp5g6wmnga6i95a6cq3dhkjg3v477xwycbcl38dfwdj3iy2c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base ];
···
        benchmarkHaskellDepends = [ base deepseq tasty tasty-bench ];
        description = "Unicode characters names and aliases";
        license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "unicode-data-scripts" = callPackage
···
      }:
      mkDerivation {
        pname = "unicode-data-scripts";
-       version = "0.1.0";
-       sha256 = "0qj2wlk85cflmpxzhgsbykqvxfis8jnp4ylpiag5wvn7ppn05040";
+       version = "0.2.0";
+       sha256 = "13igfgjqkkh5az5cxkqlp51ix34d9m8hgsjqc342hcbbal51zc82";
        libraryHaskellDepends = [ base unicode-data ];
        testHaskellDepends = [ base hspec unicode-data ];
        testToolDepends = [ hspec-discover ];
···
        ];
        description = "Unicode characters scripts";
        license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "unicode-data-security" = callPackage
···
      }:
      mkDerivation {
        pname = "unicode-data-security";
-       version = "0.1.0";
-       sha256 = "0vi1mvlzk6w11dc77hr5yq5aficisszf4mig5nrq0kp68s2jk5lv";
+       version = "0.2.0";
+       sha256 = "10x58l62i7bj9kmnchp1rggln40sfbsyw4pxlzbk8dmhkh5zmdlx";
        libraryHaskellDepends = [ base unicode-data ];
        testHaskellDepends = [ base hspec ];
        testToolDepends = [ hspec-discover ];
        benchmarkHaskellDepends = [ base deepseq tasty tasty-bench ];
        description = "Unicode security mechanisms database";
        license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "unicode-general-category" = callPackage
···
        pname = "unicode-transforms";
        version = "0.4.0.1";
        sha256 = "1z29jvli2rqkynfxni1gibl81458j7h8lrb8fg6lpnj8svhy2y1j";
-       revision = "1";
-       editedCabalFile = "0ml5j3j3dan7fgbyd3vgmlrij7bgszgfh244b1sppciis1v4m94p";
+       revision = "2";
+       editedCabalFile = "1imm3svpz2shilj2kmmmcyy5yd4c1mpmz5v1gvjrr98hrab2i9x7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        description = "The MonadUnliftIO typeclass for unlifting monads to IO (batteries included)";
        license = lib.licenses.mit;
+     }) {};
+
+  "unliftio_0_2_23_0" = callPackage
+    ({ mkDerivation, async, base, bytestring, containers, deepseq
+     , directory, filepath, gauge, hspec, process, QuickCheck
+     , safe-exceptions, stm, time, transformers, unix, unliftio-core
+     }:
+     mkDerivation {
+       pname = "unliftio";
+       version = "0.2.23.0";
+       sha256 = "1zg4ddi4z85550abw9ijycbbjg8ddig7r0vcma8ik03dxzga71id";
+       libraryHaskellDepends = [
+         async base bytestring deepseq directory filepath process
+         safe-exceptions stm time transformers unix unliftio-core
+       ];
+       testHaskellDepends = [
+         async base bytestring containers deepseq directory filepath hspec
+         process QuickCheck safe-exceptions stm time transformers unix
+         unliftio-core
+       ];
+       benchmarkHaskellDepends = [
+         async base bytestring deepseq directory filepath gauge process
+         safe-exceptions stm time transformers unix unliftio-core
+       ];
+       description = "The MonadUnliftIO typeclass for unlifting monads to IO (batteries included)";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "unliftio-core" = callPackage
···
        pname = "verifiable-expressions";
        version = "0.6.2";
        sha256 = "1nrlcbimng6qf4g7h4hxg3j05kd0hlihkhp8hj5js44n29vg89qk";
+       revision = "1";
+       editedCabalFile = "15h6zdzqvfkh480y5yp1sfjw79pkc6iv5b8mz785p3bgrspdlvn9";
        libraryHaskellDepends = [
          base containers lens mtl sbv transformers union vinyl
        ];
···
      }:
      mkDerivation {
        pname = "versions";
-       version = "5.0.3";
-       sha256 = "1ca3m9rvx89mniipbkxz3nm49mz7s4nhqc11hpsa6hjw9ff5kcjv";
+       version = "5.0.4";
+       sha256 = "1zny1kkk42nxwsbjfg87kwgcz4amjbihzqqpwmr3vcwqgx06lx19";
        libraryHaskellDepends = [
          base deepseq hashable megaparsec parser-combinators text
        ];
···
        pname = "wai-cli";
        version = "0.2.3";
        sha256 = "0fflvxfc9ibkrrgqdsr89gl77b0b706a8g7ylydaqqz6z089qbi3";
-       revision = "1";
-       editedCabalFile = "04w3gm1fcsxlrx7px5i737g61pgf2mlw8jyn2p6nczcyrwdvvicj";
+       revision = "2";
+       editedCabalFile = "1dv6lvfrsjpg733ssxgxghlfddqmnm8h2lp99wxyc8iiliy62vl9";
        libraryHaskellDepends = [
          ansi-terminal base http-types iproute monads-tf network options stm
          streaming-commons transformers unix wai wai-extra warp warp-tls
···
        pname = "wai-extra";
        version = "3.1.12.1";
        sha256 = "1ya4m0c2p3wxzjlmk3yasc3pm61z309hzry9d39lj5wqv93a4wn6";
+       revision = "1";
+       editedCabalFile = "15v9m9af34s2iz9836bd1xi0s27sffviai4ywb2g3cv33fnpnljh";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "wd" = callPackage
+    ({ mkDerivation, base, directory, process }:
+     mkDerivation {
+       pname = "wd";
+       version = "0.1.0.0";
+       sha256 = "06ilhp2mcjs66hbjnzbkbmxagi0lqg0galv6jshin77dzml8vxqq";
+       isLibrary = false;
+       isExecutable = true;
+       sha256 = "1l3pq6i9npbyzh0bv8qb315l50zhv81s5rqqnc8k27rlrabirndb";
+       description = "Run a command on a specified directory";
+       license = lib.licenses.asl20;
+       mainProgram = "wd";
+     }) {};
+
   "weak" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
        maintainers = [ lib.maintainers.maralorn ];
      }) {};
 
-  "witch_1_1_1_0" = callPackage
+  "witch_1_1_2_0" = callPackage
     ({ mkDerivation, base, bytestring, containers, HUnit, tagged
      , template-haskell, text, time, transformers
      }:
      mkDerivation {
        pname = "witch";
-       version = "1.1.1.0";
-       sha256 = "0zxrwl2dyx3p701anh29czw3fp7pk68i32g5cd1z8806zdy0c1hv";
+       version = "1.1.2.0";
+       sha256 = "1ahikszzypycjilz0749wwcfppk8xdc1n4q97nxbf33h13jpaxax";
        libraryHaskellDepends = [
          base bytestring containers tagged template-haskell text time
        ];
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "xdg-basedir-compliant" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, filepath, hspec, polysemy
+     , polysemy-plugin, polysemy-zoo, QuickCheck, split
+     }:
+     mkDerivation {
+       pname = "xdg-basedir-compliant";
+       version = "1.0.2";
+       sha256 = "0451z9w6607ci2s3bx8q73j3fw3ff3lnjf3i4h4nkscf76m84zzl";
+       libraryHaskellDepends = [
+         base bytestring filepath polysemy polysemy-plugin polysemy-zoo
+         split
+       ];
+       testHaskellDepends = [
+         aeson base bytestring filepath hspec polysemy polysemy-plugin
+         polysemy-zoo QuickCheck split
+       ];
+       description = "XDG Basedir";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "xdg-desktop-entry" = callPackage
     ({ mkDerivation, base, ConfigFile, directory, either, filepath
      , multimap, safe, transformers, unix
···
      }:
      mkDerivation {
        pname = "xlsx";
-       version = "1.0.0.1";
-       sha256 = "1fs2xks7wcbr0idgd50kxlb35l5xy1icvkiyxm8q8772bq2zvadl";
+       version = "1.1.0";
+       sha256 = "09h2z1qys01lmddkacs4z3gm36dd1ndn0hw8cn3mmciyczawn2w1";
        libraryHaskellDepends = [
          attoparsec base base64-bytestring binary-search bytestring conduit
          containers data-default deepseq dlist errors exceptions extra
···
        testHaskellDepends = [ base ];
        description = "Xlsx table cell value extraction utility";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "xlsx-templater" = callPackage
···
 
   "xmobar" = callPackage
     ({ mkDerivation, aeson, alsa-core, alsa-mixer, async, base
-     , bytestring, containers, dbus, directory, extensible-exceptions
-     , filepath, gauge, hinotify, hspec, http-client-tls, http-conduit
-     , http-types, iwlib, libmpd, libXpm, libXrandr, libXrender, mtl
-     , old-locale, parsec, parsec-numbers, process, regex-compat, stm
-     , temporary, time, timezone-olson, timezone-series, transformers
-     , unix, utf8-string, wirelesstools, X11, X11-xft
+     , bytestring, cairo, colour, containers, dbus, directory
+     , extensible-exceptions, filepath, gauge, hinotify, hspec
+     , http-client-tls, http-conduit, http-types, iwlib, libmpd, libXpm
+     , libXrandr, libXrender, mtl, old-locale, pango, parsec
+     , parsec-numbers, process, regex-compat, stm, temporary, time
+     , timezone-olson, timezone-series, transformers, unix, utf8-string
+     , wirelesstools, X11, X11-xft
      }:
      mkDerivation {
        pname = "xmobar";
-       version = "0.44.2";
-       sha256 = "0gdphjn5ll5lkb2psdsb34563wsz6g0y2gg3z8cj4jy8lvbbv808";
+       version = "0.45";
+       sha256 = "0p64z535lk338f247gvddc6c4326xs41ar817whdvzj2910pyn86";
        configureFlags = [
          "-fwith_alsa" "-fwith_conduit" "-fwith_datezone" "-fwith_dbus"
          "-fwith_inotify" "-fwith_iwlib" "-fwith_mpd" "-fwith_mpris"
···
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         aeson alsa-core alsa-mixer async base bytestring containers dbus
-         directory extensible-exceptions filepath hinotify http-client-tls
-         http-conduit http-types iwlib libmpd mtl old-locale parsec
-         parsec-numbers process regex-compat stm time timezone-olson
-         timezone-series transformers unix utf8-string X11 X11-xft
+         aeson alsa-core alsa-mixer async base bytestring cairo colour
+         containers dbus directory extensible-exceptions filepath hinotify
+         http-client-tls http-conduit http-types iwlib libmpd mtl old-locale
+         pango parsec parsec-numbers process regex-compat stm time
+         timezone-olson timezone-series transformers unix utf8-string X11
+         X11-xft
        ];
        librarySystemDepends = [
          libXpm libXrandr libXrender wirelesstools
···
   "xrefcheck" = callPackage
     ({ mkDerivation, aeson, aeson-casing, async, base, bytestring
      , case-insensitive, cmark-gfm, containers, data-default, directory
-     , directory-tree, dlist, exceptions, filepath, firefly, fmt
-     , ftp-client, Glob, hspec, hspec-discover, hspec-expectations
-     , http-client, http-types, HUnit, lens, modern-uri, mtl, o-clock
-     , optparse-applicative, pretty-terminal, QuickCheck, raw-strings-qq
-     , regex-tdfa, req, roman-numerals, tagged, tagsoup, tasty
-     , tasty-discover, tasty-hunit, text, text-metrics
+     , dlist, exceptions, filepath, firefly, fmt, ftp-client, Glob
+     , http-client, http-types, lens, modern-uri, mtl, o-clock
+     , optparse-applicative, pretty-terminal, process, raw-strings-qq
+     , reflection, regex-tdfa, req, tagged, tagsoup, tasty
+     , tasty-discover, tasty-hunit, tasty-quickcheck, text, text-metrics
      , th-lift-instances, time, transformers, universum, uri-bytestring
      , with-utf8, yaml
      }:
      mkDerivation {
        pname = "xrefcheck";
-       version = "0.2.1";
-       sha256 = "1xvz2qbchkb9p7prhc89gsmcwyl77spb0gxy9mw89c44wd12b9ns";
+       version = "0.2.2";
+       sha256 = "0qyl2wislma25s3n5aaqd732a2p7i9lsv4fvydm121a4r5sc5j4h";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson aeson-casing async base bytestring cmark-gfm containers
-         data-default directory directory-tree dlist exceptions filepath fmt
-         ftp-client Glob http-client http-types lens modern-uri mtl o-clock
-         optparse-applicative pretty-terminal raw-strings-qq regex-tdfa req
-         roman-numerals tagsoup text text-metrics th-lift-instances time
-         transformers universum uri-bytestring yaml
+         data-default directory dlist exceptions filepath fmt ftp-client
+         Glob http-client http-types lens modern-uri mtl o-clock
+         optparse-applicative pretty-terminal process raw-strings-qq
+         reflection regex-tdfa req tagsoup text text-metrics
+         th-lift-instances time transformers universum uri-bytestring yaml
        ];
        executableHaskellDepends = [ base bytestring universum with-utf8 ];
        testHaskellDepends = [
          base bytestring case-insensitive cmark-gfm containers directory
-         firefly fmt hspec hspec-expectations http-types HUnit modern-uri
-         o-clock optparse-applicative QuickCheck regex-tdfa tagged tasty
-         tasty-hunit time universum uri-bytestring yaml
+         firefly fmt http-types modern-uri o-clock optparse-applicative
+         reflection regex-tdfa tagged tasty tasty-hunit tasty-quickcheck
+         time universum uri-bytestring yaml
        ];
-       testToolDepends = [ hspec-discover tasty-discover ];
+       testToolDepends = [ tasty-discover ];
        license = lib.licenses.mpl20;
        hydraPlatforms = lib.platforms.none;
        mainProgram = "xrefcheck";
···
        pname = "yaml";
        version = "0.11.8.0";
        sha256 = "1s0arllihjjqp65jbc8c1w5106i2infppsirvbsifpmpkf14w6pn";
+       revision = "2";
+       editedCabalFile = "1dix5jm3d380vjr9l6wqz54zk883kilk8rijlvjp6b13mjxwcj1l";
        configureFlags = [ "-fsystem-libyaml" ];
        isLibrary = true;
        isExecutable = true;
···
        pname = "zip";
        version = "1.7.2";
        sha256 = "1c5pr3hv11dpn4ybd4742qkpqmvb9l3l7xmzlsf65wm2p8071dvj";
-       revision = "1";
-       editedCabalFile = "1hazf2p31rzjycci8y40zm302msr0mgvb242lww21rxrpicbzl8d";
+       revision = "2";
+       editedCabalFile = "0gacj2fp0yg45l5vxby0n03lza91zfykk74p6a2r3abrfmvw7kq8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [

pkgs/development/libraries/flatbuffers/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "flatbuffers";
-  version = "2.0.7";
+  version = "22.10.26";
 
   src = fetchFromGitHub {
     owner = "google";
     repo = "flatbuffers";
     rev = "v${version}";
-    sha256 = "sha256-tIM6CdIPq++xFbpA22zDm3D4dT9soNDe/9GRY/FyLrw=";
+    sha256 = "sha256-Kub076FkWwHNlphGtTx2c3Jojv8otKLo492uN6Oq1F0=";
   };
 
   nativeBuildInputs = [ cmake python3 ];

pkgs/development/libraries/intel-gmmlib/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "intel-gmmlib";
-  version = "22.2.1";
+  version = "22.3.0";
 
   src = fetchFromGitHub {
     owner = "intel";
     repo = "gmmlib";
     rev = "intel-gmmlib-${version}";
-    sha256 = "sha256-/v2RUn/s3wrBdfClXkm6MM9KfSEWjbE2Njs3fDqXaj8=";
+    sha256 = "sha256-ZJQ4KLKWA9SIXqKffU/uxUU+aXgfDdxQ5Wejgcfowgs=";
   };
 
   nativeBuildInputs = [ cmake ];

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

···
 , fetchFromGitHub
 , poetry-core
 , pythonOlder
+, setuptools
 }:
 
 buildPythonPackage rec {
···
   nativeBuildInputs = [
     cython
     poetry-core
+    setuptools
   ];
 
-  # Not running tests as aiomysql is missing support for
-  # pymysql>=0.9.3
+  # Not running tests as aiomysql is missing support for pymysql>=0.9.3
   doCheck = false;
 
   pythonImportsCheck = [

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

···
+{ lib
+, fetchFromGitHub
+, buildPythonPackage
+, pythonOlder
+, cryptography
+, jinja2
+, Mako
+, passlib
+, pytest
+, pyyaml
+, requests
+, rtoml
+, setuptools
+, tomlkit
+, librouteros
+, pytestCheckHook
+}:
+
+buildPythonPackage rec {
+  pname = "bundlewrap";
+  version = "4.15.0";
+
+  disabled = pythonOlder "3.7";
+
+  src = fetchFromGitHub {
+    owner = "bundlewrap";
+    repo = "bundlewrap";
+    rev = version;
+    sha256 = "sha256-O31lh43VyaFnd/IUkx44wsgxkWubZKzjsKXzHwcGox0";
+  };
+
+  nativeBuildInputs = [ setuptools ];
+  propagatedBuildInputs = [
+    cryptography jinja2 Mako passlib pyyaml requests tomlkit librouteros
+  ] ++ lib.optional (pythonOlder "3.11") [ rtoml ];
+
+  pythonImportsCheck = [ "bundlewrap" ];
+
+  checkInputs = [ pytestCheckHook ];
+
+  pytestFlagsArray = [
+    # only unit tests as integration tests need a OpenSSH client/server setup
+    "tests/unit"
+  ];
+
+  meta = with lib; {
+    homepage = "https://bundlewrap.org/";
+    description = "Easy, Concise and Decentralized Config management with Python";
+    license = [ licenses.gpl3 ] ;
+    maintainers = with maintainers; [ wamserma ];
+  };
+}

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

···
 , osqp
 , scipy
 , scs
+, setuptools
 , useOpenmp ? (!stdenv.isDarwin)
   # Check inputs
 , pytestCheckHook
···
     osqp
     scipy
     scs
+    setuptools
   ];
 
   # Required flags from https://github.com/cvxgrp/cvxpy/releases/tag/v1.1.11
···
   disabledTests = [
     "test_tv_inpainting"
     "test_diffcp_sdp_example"
+    "test_huber"
+    "test_partial_problem"
   ] ++ lib.optionals stdenv.isAarch64 [
     "test_ecos_bb_mi_lp_2" # https://github.com/cvxgrp/cvxpy/issues/1241#issuecomment-780912155
   ];

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

···
 , fetchFromGitHub
 , pytestCheckHook
 , cython
+, pythonOlder
 }:
 
 buildPythonPackage rec {
   pname = "editdistance";
-  version = "0.6.0";
+  version = "0.6.1";
+  format = "setuptools";
 
+  disabled = pythonOlder "3.7";
 
   src = fetchFromGitHub {
     owner = "roy-ht";
     repo = pname;
     rev = "v${version}";
-    sha256 = "17xkndwdyf14nfxk25z1qnhkzm0yxw65fpj78c01haq241zfzjr5";
+    hash = "sha256-c0TdH1nJAKrepatCSCTLaKsDv9NKruMQadCjclKGxBw=";
   };
 
-  nativeBuildInputs = [ cython ];
+  nativeBuildInputs = [
+    cython
+  ];
 
   preBuild = ''
     cythonize --inplace editdistance/bycython.pyx
   '';
 
-  checkInputs = [ pytestCheckHook ];
+  checkInputs = [
+   pytestCheckHook
+  ];
 
-  pythonImportsCheck = [ "editdistance" ];
+  pythonImportsCheck = [
+    "editdistance"
+  ];
 
   meta = with lib; {
     description = "Python implementation of the edit distance (Levenshtein distance)";

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

···
 , parts
 , pytestCheckHook
 , pythonOlder
+, setuptools
 }:
 
 buildPythonPackage rec {
···
     inherit pname version;
     hash = "sha256-y9Nv59pLWk1kRjZG3EmalT34Mjx7RLZ4WkvJlRrK5LI=";
   };
+
+  nativeBuildInputs = [
+    setuptools
+  ];
 
   propagatedBuildInputs = [
     fe25519

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

···
 
 buildPythonPackage rec {
   pname = "meshtastic";
-  version = "1.3.43";
+  version = "1.3.44";
   format = "setuptools";
 
   disabled = pythonOlder "3.7";
···
     owner = "meshtastic";
     repo = "Meshtastic-python";
     rev = "refs/tags/${version}";
-    hash = "sha256-Gy9fnYUbv5jR+YeFjbNGdng+loM/J71Yn9Y1mKERVUA=";
+    hash = "sha256-3OINNcdyZyhofGJDvAVyDLv/ylomM6LP4cEBkmeYwn4=";
   };
 
   propagatedBuildInputs = [

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

···
     hash = "sha256-svoXquQqftSY7CYbM/Jiu0s2BefoRkBiFZ2froF/DWE=";
   };
 
+  postPatch = ''
+    sed -i 's/sp.random/np.random/g' src/osqp/tests/*.py
+  '';
+
   SETUPTOOLS_SCM_PRETEND_VERSION = version;
 
   dontUseCmakeConfigure = true;

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

···
 
 buildPythonPackage rec {
   pname = "pysqueezebox";
-  version = "0.6.0";
+  version = "0.6.1";
   format = "setuptools";
 
   disabled = pythonOlder "3.6";
···
   src = fetchFromGitHub {
     owner = "rajlaud";
     repo = pname;
-    rev = "v${version}";
-    hash = "sha256-0ArKVRy4H0NWShlQMziKvbHp9OjpAkEKp4zrvpVlXOk=";
+    rev = "refs/tags/v${version}";
+    hash = "sha256-NCADVSsnaOJfLJ7i18i7d7wlWcyt1DoRFGOVXEEYHPI=";
   };
 
   propagatedBuildInputs = [

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

···
 
 buildPythonPackage rec {
   pname = "pyswitchbee";
-  version = "1.6.0";
+  version = "1.6.1";
   format = "pyproject";
 
   disabled = pythonOlder "3.9";
···
     owner = "jafar-atili";
     repo = "pySwitchbee";
     rev = "refs/tags/${version}";
-    hash = "sha256-ZAe47Oxw5n6OM/PRKz7OR8yzi/c9jnXeOYNjCbs0j1E=";
+    hash = "sha256-5Mc70yi9Yj+8ye81v9NbKZnNoD5PQmBVAiYF5IM5ix8=";
   };
 
   postPatch = ''
···
   meta = with lib; {
     description = "Library to control SwitchBee smart home device";
     homepage = "https://github.com/jafar-atili/pySwitchbee/";
-    # https://github.com/jafar-atili/pySwitchbee/issues/1
-    license = with licenses; [ unfree ];
+    license = with licenses; [ asl20 ];
     maintainers = with maintainers; [ fab ];
   };
 }

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

···
 , pyyaml
 , ruamel-yaml
 , toml
+, tomli
+, tomli-w
 }:
 
 buildPythonPackage rec {
···
   version = "6.0.2";
   format = "setuptools";
 
-  disabled = pythonOlder "3.6";
+  disabled = pythonOlder "3.7";
 
   src = fetchFromGitHub {
     owner = "cdgriffith";
···
     hash = "sha256-IE2qyRzvrOTymwga+hCwE785sAVTqQtcN1DL/uADpbQ=";
   };
 
-  propagatedBuildInputs = [
-    msgpack
-    pyyaml
-    ruamel-yaml
-    toml
-  ];
+  passthru.optional-dependencies = {
+    all = [
+      msgpack
+      ruamel-yaml
+      toml
+    ];
+    yaml = [
+      ruamel-yaml
+    ];
+    ruamel-yaml = [
+      ruamel-yaml
+    ];
+    PyYAML = [
+      pyyaml
+    ];
+    tomli = [
+      tomli-w
+    ] ++ lib.optionals (pythonOlder "3.11") [
+      tomli
+    ];
+    toml = [
+      toml
+    ];
+    msgpack = [
+      msgpack
+    ];
+  };
 
   checkInputs = [
     pytestCheckHook
-  ];
+  ] ++ passthru.optional-dependencies.all;
 
   pythonImportsCheck = [
     "box"

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

···
 
 buildPythonPackage rec {
   pname = "python-gitlab";
-  version = "3.10.0";
+  version = "3.11.0";
   format = "setuptools";
 
   disabled = pythonOlder "3.7";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "sha256-FJMKFv3X829nuTc+fU1HIOjjdIAAKDgCidszBun3RhQ=";
+    hash = "sha256-25Rytq5PupaLQJ3DL67iDdZQiQZdqpPgjSG3lqZdZXg=";
   };
 
   propagatedBuildInputs = [
-    argcomplete
-    pyyaml
     requests
     requests-toolbelt
   ];
 
-  # tests rely on a gitlab instance on a local docker setup
+  passthru.optional-dependencies = {
+    autocompletion = [
+      argcomplete
+    ];
+    yaml = [
+      pyyaml
+    ];
+  };
+
+  # Tests rely on a gitlab instance on a local docker setup
   doCheck = false;
 
   pythonImportsCheck = [
···
   meta = with lib; {
     description = "Interact with GitLab API";
     homepage = "https://github.com/python-gitlab/python-gitlab";
-    license = licenses.lgpl3;
+    license = licenses.lgpl3Only;
     maintainers = with maintainers; [ nyanloutre ];
   };
 }

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

···
 , buildPythonPackage
 , fetchFromGitHub
 , loguru
-, pytestCheckHook
-, six
+, pytest-asyncio
 , pytest-mypy
+, pytestCheckHook
+, pythonOlder
 }:
 
 buildPythonPackage rec {
   pname = "python-utils";
-  version = "3.3.3";
+  version = "3.4.5";
+  format = "setuptools";
+
+  disabled = pythonOlder "3.7";
 
   src = fetchFromGitHub {
     owner = "WoLpH";
     repo = pname;
-    rev = "v${version}";
-    hash = "sha256-U6yamXbG8CUrNnFmGTBpHUelZSgoaNyB2CdUSH9WdMA=";
+    rev = "refs/tags/v${version}";
+    hash = "sha256-O/+jvdzzxUFaQdAfUM9p40fPPDNN+stTauCD993HH6Y=";
   };
 
-  # disable coverage and linting
   postPatch = ''
     sed -i '/--cov/d' pytest.ini
-    sed -i '/--flake8/d' pytest.ini
   '';
 
-  propagatedBuildInputs = [
-    loguru
-    six
-  ];
+  passthru.optional-dependencies = {
+    loguru = [
+      loguru
+    ];
+  };
 
   checkInputs = [
+    pytest-asyncio
     pytest-mypy
     pytestCheckHook
+  ] ++ passthru.optional-dependencies.loguru;
+
+  pythonImportsCheck = [
+    "python_utils"
   ];
 
   pytestFlagsArray = [
···
     description = "Module with some convenient utilities";
     homepage = "https://github.com/WoLpH/python-utils";
     license = licenses.bsd3;
+    maintainers = with maintainers; [ ];
   };
 }

pkgs/development/python-modules/robotframework-requests/default.nix

···
 { lib
 , buildPythonPackage
-, fetchPypi
-, unittest2
-, robotframework
+, fetchFromGitHub
 , lxml
+, pytestCheckHook
+, pythonOlder
 , requests
+, robotframework
 }:
 
 buildPythonPackage rec {
-  version = "0.9.3";
   pname = "robotframework-requests";
+  version = "0.9.4";
+  format = "setuptools";
 
-  src = fetchPypi {
-    inherit pname version;
-    sha256 = "sha256-C754uOezq5vsSWilG/N5XiZxABp4Cyt+vyriFSmI2jU=";
+  disabled = pythonOlder "3.7";
+
+  src = fetchFromGitHub {
+    owner = "MarketSquare";
+    repo = pname;
+    rev = "refs/tags/v${version}";
+    hash = "sha256-XjcR29dH9K9XEnJZlQ4UUDI1MG92dRO1puiB6fcN58k=";
   };
 
-  buildInputs = [ unittest2 ];
-  propagatedBuildInputs = [ robotframework lxml requests ];
+  propagatedBuildInputs = [
+    lxml
+    requests
+    robotframework
+  ];
+
+  buildInputs = [
+    pytestCheckHook
+  ];
+
+  pythonImportsCheck = [
+    "RequestsLibrary"
+  ];
+
+  pytestFlagsArray = [
+    "utests"
+  ];
 
   meta = with lib; {
     description = "Robot Framework keyword library wrapper around the HTTP client library requests";
     homepage = "https://github.com/bulkan/robotframework-requests";
     license = licenses.mit;
+    maintainers = with maintainers; [ ];
   };
-
 }

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

···
-{ buildPythonPackage, fetchFromGitHub, lib, isPyPy
+{ buildPythonPackage, fetchFromGitHub, stdenv, lib, isPyPy
 , pycrypto, ecdsa # TODO
 , tox, mock, coverage, can, brotli
 , withOptionalDeps ? true, tcpdump, ipython
···
 , withPlottingSupport ? true, matplotlib
 , withGraphicsSupport ? false, pyx, texlive, graphviz, imagemagick
 , withManufDb ? false, wireshark
+, libpcap
 # 2D/3D graphics and graphs TODO: VPython
 # TODO: nmap, numpy
 }:
···
     sha256 = "0nxci1v32h5517gl9ic6zjq8gc8drwr0n5pz04c91yl97xznnw94";
   };
 
+  patches = [
+    ./find-library.patch
+  ];
+
   postPatch = ''
     printf "${version}" > scapy/VERSION
+
+    libpcap_file="${lib.getLib libpcap}/lib/libpcap${stdenv.hostPlatform.extensions.sharedLibrary}"
+    if ! [ -e "$libpcap_file" ]; then
+        echo "error: $libpcap_file not found" >&2
+        exit 1
+    fi
+    substituteInPlace "scapy/libs/winpcapy.py" \
+        --replace "@libpcap_file@" "$libpcap_file"
   '' + lib.optionalString withManufDb ''
     substituteInPlace scapy/data.py --replace "/opt/wireshark" "${wireshark}"
   '';

pkgs/development/python-modules/scapy/find-library.patch

···
+diff -uNr a/scapy/libs/winpcapy.py b/scapy/libs/winpcapy.py
+--- a/scapy/libs/winpcapy.py	1970-01-01 01:00:01.000000000 +0100
++++ b/scapy/libs/winpcapy.py	2022-08-12 17:57:52.830224862 +0200
+@@ -33,7 +33,7 @@
+ else:
+     # Try to load libpcap
+     SOCKET = c_int
+-    _lib_name = find_library("pcap")
++    _lib_name = "@libpcap_file@"
+     if not _lib_name:
+         raise OSError("Cannot find libpcap.so library")
+     _lib = CDLL(_lib_name)

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

···
 { lib
 , buildPythonPackage
 , fetchPypi
+, pythonOlder
 , redis
 , requests
 , six
+, urllib3
 }:
 
 buildPythonPackage rec {
   pname = "spotipy";
-  version = "2.20.0";
+  version = "2.21.0";
+  format = "setuptools";
+
+  disabled = pythonOlder "3.7";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "sha256-4mqZt1vi/EI3WytLNV3ET6Hlnvx3OvoXt4ThpMCoGMk=";
+    hash = "sha256-YhFhqbWqAVaBwu4buIc87i7mtEDYQEDanSpXzWf31eU=";
   };
 
   propagatedBuildInputs = [
     redis
     requests
     six
+    urllib3
   ];
 
-  # tests want to access the spotify API
+  # Tests want to access the spotify API
   doCheck = false;
+
   pythonImportsCheck = [
     "spotipy"
     "spotipy.oauth2"
   ];
 
   meta = with lib; {
+    description = "Library for the Spotify Web API";
     homepage = "https://spotipy.readthedocs.org/";
     changelog = "https://github.com/plamere/spotipy/blob/${version}/CHANGELOG.md";
-    description = "A light weight Python library for the Spotify Web API";
     license = licenses.mit;
     maintainers = with maintainers; [ rvolosatovs ];
   };

pkgs/development/python-modules/tensorflow/bin.nix

···
     (
       cd unpacked/tensorflow*
       # Adjust dependency requirements:
-      # - Relax flatbuffers, gast and tensorflow-estimator version requirements that don't match what we have packaged
+      # - Relax flatbuffers, gast, protobuf, tensorboard, and tensorflow-estimator version requirements that don't match what we have packaged
       # - The purpose of python3Packages.libclang is not clear at the moment and we don't have it packaged yet
       # - keras and tensorlow-io-gcs-filesystem will be considered as optional for now.
       sed -i *.dist-info/METADATA \
         -e "/Requires-Dist: flatbuffers/d" \
         -e "/Requires-Dist: gast/d" \
-        -e "/Requires-Dist: libclang/d" \
         -e "/Requires-Dist: keras/d" \
+        -e "/Requires-Dist: libclang/d" \
+        -e "/Requires-Dist: protobuf/d" \
+        -e "/Requires-Dist: tensorboard/d" \
         -e "/Requires-Dist: tensorflow-estimator/d" \
         -e "/Requires-Dist: tensorflow-io-gcs-filesystem/d"
     )

pkgs/development/tools/analysis/cppcheck/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "cppcheck";
-  version = "2.9";
+  version = "2.9.1";
 
   src = fetchFromGitHub {
     owner = "danmar";
     repo = "cppcheck";
     rev = version;
-    sha256 = "sha256-UkmtW/3CLU9tFNjVLhQPhYkYflFLOBc/7Qc8lSBOo3I=";
+    sha256 = "sha256-8vwuNK7qQg+pkUnWpEe8272BuHJUaidm8MoGsXVt1X8=";
   };
 
   buildInputs = [ pcre

pkgs/development/tools/ruff/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "ruff";
-  version = "0.0.89";
+  version = "0.0.91";
 
   src = fetchFromGitHub {
     owner = "charliermarsh";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-S+lnIzwdh3xv5Hoprl1gElD91zSa63TnAavIeT8XmKQ=";
+    sha256 = "sha256-KAifSlIFJPw0A83pH6kZz2fCmYf6QVmuhAwZWtXEV3o=";
   };
 
-  cargoSha256 = "sha256-v7hR7t0mVwiF/CAd221ZQSncM7c05bltUB7w3+5xxjM=";
+  cargoSha256 = "sha256-Zy6RQwRc3IYzK+pFs/CsZXZoRmnUfWeZTGpxjHTl6dY=";
 
   buildInputs = lib.optionals stdenv.isDarwin [
     CoreServices

pkgs/development/tools/rust/cargo-lambda/default.nix

···
+{ stdenv, lib, rustPlatform, fetchFromGitHub, makeWrapper, cargo-watch, zig, Security }:
+
+rustPlatform.buildRustPackage rec {
+  pname = "cargo-lambda";
+  version = "0.11.2";
+
+  src = fetchFromGitHub {
+    owner = pname;
+    repo = pname;
+    rev = "v${version}";
+    sha256 = "sha256-IK4HVj8Y8Vz+mza8G9C+m5JRfNT3BWWdlbQQkJPu6RI=";
+  };
+
+  cargoSha256 = "sha256-oSqoSvv8IiChtduQQA31wItHcsnRBAQgOCrQN4sjcx8=";
+
+  buildInputs = lib.optionals stdenv.isDarwin [ Security ];
+
+  nativeBuildInputs = [ makeWrapper ];
+
+  postInstall = ''
+    wrapProgram $out/bin/cargo-lambda --prefix PATH : ${lib.makeBinPath [ cargo-watch zig ]}
+  '';
+
+  checkFlags = [
+    # Disabled because it accesses the network.
+    "--skip test_download_example"
+    # Disabled because it makes assumptions about the file system.
+    "--skip test_target_dir_from_env"
+  ];
+
+  meta = with lib; {
+    description = "A Cargo subcommand to help you work with AWS Lambda";
+    homepage = "https://cargo-lambda.info";
+    license = licenses.mit;
+    maintainers = with maintainers; [ taylor1791 ];
+  };
+}

pkgs/development/web/flyctl/default.nix

···
 
 buildGoModule rec {
   pname = "flyctl";
-  version = "0.0.424";
+  version = "0.0.425";
 
   src = fetchFromGitHub {
     owner = "superfly";
     repo = "flyctl";
     rev = "v${version}";
-    sha256 = "sha256-VipCiWSuC1SSJPWk9WXgcMd0G0C2TsUSQgW2GM9yAII=";
+    sha256 = "sha256-SIvJQbPCQhZ9zPQI5QSCOrJNlCNL+S9U2v41ik3h4HU=";
   };
 
-  vendorSha256 = "sha256-a0ZnZlKB/Uotrm4npXB1dd1+oWHRhJVW7ofMSKlqcvM=";
+  vendorSha256 = "sha256-wMVvDB/6ZDY3EwTWRJ1weCIlRZM+Ye24UnRl1YZzAcA=";
 
   subPackages = [ "." ];
 

pkgs/games/dwarf-fortress/default.nix

···
             inherit dwarf-fortress-unfuck;
           };
 
-          # unfuck is linux-only right now, we will only use it there.
-          dwarf-fortress-unfuck =
-            if stdenv.isLinux then callPackage ./unfuck.nix { inherit dfVersion; }
-            else null;
+          dwarf-fortress-unfuck = callPackage ./unfuck.nix { inherit dfVersion; };
 
           twbt = callPackage ./twbt { inherit dfVersion; };
 
···
         in
         callPackage ./wrapper {
           inherit (self) themes;
-
-          dwarf-fortress = dwarf-fortress;
-          twbt = twbt;
-          dfhack = dfhack;
-          dwarf-therapist = dwarf-therapist;
+          inherit dwarf-fortress twbt dfhack dwarf-therapist;
 
           jdk = jdk8; # TODO: remove override https://github.com/NixOS/nixpkgs/pull/89731
         };

pkgs/games/dwarf-fortress/game.nix

···
 let
   libpath = makeLibraryPath [ stdenv.cc.cc stdenv.cc.libc dwarf-fortress-unfuck SDL ];
 
-  homepage = "http://www.bay12games.com/dwarves/";
-
   # Map Dwarf Fortress platform names to Nixpkgs platform names.
   # Other srcs are avilable like 32-bit mac & win, but I have only
   # included the ones most likely to be needed by Nixpkgs users.
···
   version = dfVersion;
 
   src = fetchurl {
-    url = "${homepage}df_${baseVersion}_${patchVersion}_${dfPlatform}.tar.bz2";
+    url = "https://www.bay12games.com/dwarves/df_${baseVersion}_${patchVersion}_${dfPlatform}.tar.bz2";
     inherit sha256;
   };
 
···
 
   meta = {
     description = "A single-player fantasy game with a randomly generated adventure world";
-    inherit homepage;
+    homepage = "https://www.bay12games.com/dwarves/";
     license = licenses.unfreeRedistributable;
     platforms = attrNames platforms;
     maintainers = with maintainers; [ a1russell robbinch roconnor abbradar numinit shazow ];

pkgs/games/dwarf-fortress/wrapper/default.nix

···
   '';
 
   preferLocalBuild = true;
+
+  inherit (dwarf-fortress) meta;
 }

pkgs/games/xivlauncher/default.nix

···
 , useSteamRun ? true }:
 
 let
-  rev = "6246fde6b54f8c7e340057fe2d940287c437153f";
+  rev = "1.0.2";
 in
   buildDotnetModule rec {
     pname = "XIVLauncher";
-    version = "1.0.1.0";
+    version = rev;
 
     src = fetchFromGitHub {
       owner = "goatcorp";
-      repo = "FFXIVQuickLauncher";
+      repo = "XIVLauncher.Core";
       inherit rev;
-      sha256 = "sha256-sM909/ysrlwsiVSBrMo4cOZUWxjRA3ZSwlloGythOAY=";
+      sha256 = "DlSMxIbgzL5cy+A5nm7ZaA2A0TdINtq2GHW27uxORKI=";
+      fetchSubmodules = true;
     };
 
     nativeBuildInputs = [ copyDesktopItems ];
···
     ];
 
     postPatch = ''
-      substituteInPlace src/XIVLauncher.Common/Game/Patch/Acquisition/Aria/AriaHttpPatchAcquisition.cs \
+      substituteInPlace lib/FFXIVQuickLauncher/src/XIVLauncher.Common/Game/Patch/Acquisition/Aria/AriaHttpPatchAcquisition.cs \
         --replace 'ariaPath = "aria2c"' 'ariaPath = "${aria2}/bin/aria2c"'
     '';
 
···
         desktopName = "XIVLauncher";
         comment = meta.description;
         categories = [ "Game" ];
+        startupWMClass = "XIVLauncher.Core";
       })
     ];
 
···
       license = licenses.gpl3;
       maintainers = with maintainers; [ ashkitten sersorrel ];
       platforms = [ "x86_64-linux" ];
+      mainProgram = "XIVLauncher.Core";
     };
   }

pkgs/games/xivlauncher/deps.nix

···
 { fetchNuGet }: [
   (fetchNuGet { pname = "Castle.Core"; version = "4.4.1"; sha256 = "13dja1jxl5zwhi0ghkgvgmqdrixn57f9hk52jy5vpaaakzr550r7"; })
   (fetchNuGet { pname = "CheapLoc"; version = "1.1.6"; sha256 = "1m6cgx9yh7h3vrq2d4f99xyvsxc9jvz8zjq1q14qgylfmyq4hx4l"; })
+  (fetchNuGet { pname = "CommandLineParser"; version = "2.9.1"; sha256 = "1sldkj8lakggn4hnyabjj1fppqh50fkdrr1k99d4gswpbk5kv582"; })
   (fetchNuGet { pname = "Config.Net"; version = "4.19.0"; sha256 = "17iv0vy0693s6d8626lbz3w1ppn5abn77aaki7h4qi4izysizgim"; })
   (fetchNuGet { pname = "Downloader"; version = "2.2.8"; sha256 = "0farwh3pc6m8hsgqywigdpcb4gr2m9myyxm2idzjmhhkzfqghj28"; })
   (fetchNuGet { pname = "goaaats.NativeLibraryLoader"; version = "4.9.0-beta1-g70f642e82e"; sha256 = "1bjjgsw4ry9cz8dzsgwx428hn06wms194pqz8nclwrqcwfx7gmxk"; })
···
   (fetchNuGet { pname = "goaaats.Veldrid.StartupUtilities"; version = "4.9.0-beta1-g70f642e82e"; sha256 = "03r3x9h0fyb07d6d28ny6r5s688m50xc0lgc6zf2cy684kfnvmp5"; })
   (fetchNuGet { pname = "ImGui.NET"; version = "1.87.2"; sha256 = "0rv0n18fvz1gbh45crhzn1f8xw8zkc8qyiyj91vajjcry8mq1x7q"; })
   (fetchNuGet { pname = "KeySharp"; version = "1.0.5"; sha256 = "1ic10v0a174fw6w89iyg4yzji36bsj15573y676cj5n09n6s75d4"; })
+  (fetchNuGet { pname = "Microsoft.Bcl.AsyncInterfaces"; version = "6.0.0"; sha256 = "15gqy2m14fdlvy1g59207h5kisznm355kbw010gy19vh47z8gpz3"; })
   (fetchNuGet { pname = "Microsoft.CodeAnalysis.Analyzers"; version = "3.3.3"; sha256 = "09m4cpry8ivm9ga1abrxmvw16sslxhy2k5sl14zckhqb1j164im6"; })
   (fetchNuGet { pname = "Microsoft.CodeAnalysis.BannedApiAnalyzers"; version = "3.3.3"; sha256 = "1z6x0d8lpcfjr3sxy25493i17vvcg5bsay6c03qan6mnj5aqzw2k"; })
   (fetchNuGet { pname = "Microsoft.CodeAnalysis.Common"; version = "4.0.1"; sha256 = "0axjv1nhk1z9d4c51d9yxdp09l8yqqnqaifhqcwnxnv0r4y5cka9"; })
   (fetchNuGet { pname = "Microsoft.CodeAnalysis.CSharp"; version = "4.0.1"; sha256 = "1h6jfifg7pw2vacpdds4v4jqnaydg9b108irf315wzx6rh8yv9cb"; })
   (fetchNuGet { pname = "Microsoft.CodeAnalysis.NetAnalyzers"; version = "6.0.0"; sha256 = "06zy947m5lrbwb684g42ijb07r5jsqycvfnphc6cqfdrfnzqv6k9"; })
-  (fetchNuGet { pname = "Microsoft.NETCore.Platforms"; version = "1.0.1"; sha256 = "01al6cfxp68dscl15z7rxfw9zvhm64dncsw09a1vmdkacsa2v6lr"; })
   (fetchNuGet { pname = "Microsoft.NETCore.Platforms"; version = "1.1.0"; sha256 = "08vh1r12g6ykjygq5d3vq09zylgb84l63k49jc4v8faw9g93iqqm"; })
-  (fetchNuGet { pname = "Microsoft.NETCore.Targets"; version = "1.0.1"; sha256 = "0ppdkwy6s9p7x9jix3v4402wb171cdiibq7js7i13nxpdky7074p"; })
   (fetchNuGet { pname = "Microsoft.NETCore.Targets"; version = "1.1.0"; sha256 = "193xwf33fbm0ni3idxzbr5fdq3i2dlfgihsac9jj7whj0gd902nh"; })
   (fetchNuGet { pname = "Microsoft.Win32.Primitives"; version = "4.3.0"; sha256 = "0j0c1wj4ndj21zsgivsc24whiya605603kxrbiw6wkfdync464wq"; })
   (fetchNuGet { pname = "Microsoft.Win32.Registry"; version = "6.0.0-preview.5.21301.5"; sha256 = "02712s86n2i8s5j6vxdayqwcc7r538yw3frhf1gfrc6ah6hvqnzc"; })
···
   (fetchNuGet { pname = "runtime.unix.System.Net.Sockets"; version = "4.3.0"; sha256 = "03npdxzy8gfv035bv1b9rz7c7hv0rxl5904wjz51if491mw0xy12"; })
   (fetchNuGet { pname = "runtime.unix.System.Private.Uri"; version = "4.3.0"; sha256 = "1jx02q6kiwlvfksq1q9qr17fj78y5v6mwsszav4qcz9z25d5g6vk"; })
   (fetchNuGet { pname = "runtime.unix.System.Runtime.Extensions"; version = "4.3.0"; sha256 = "0pnxxmm8whx38dp6yvwgmh22smknxmqs5n513fc7m4wxvs1bvi4p"; })
-  (fetchNuGet { pname = "Serilog"; version = "2.10.0"; sha256 = "08bih205i632ywryn3zxkhb15dwgyaxbhmm1z3b5nmby9fb25k7v"; })
-  (fetchNuGet { pname = "Serilog"; version = "2.9.0"; sha256 = "0z0ib82w9b229a728bbyhzc2hnlbl0ki7nnvmgnv3l741f2vr4i6"; })
+  (fetchNuGet { pname = "Serilog"; version = "2.12.0"; sha256 = "0lqxpc96qcjkv9pr1rln7mi4y7n7jdi4vb36c2fv3845w1vswgr4"; })
   (fetchNuGet { pname = "Serilog.Enrichers.Thread"; version = "3.1.0"; sha256 = "1y75aiv2k1sxnh012ixkx92fq1yl8srqggy8l439igg4p223hcqi"; })
-  (fetchNuGet { pname = "Serilog.Sinks.Async"; version = "1.4.0"; sha256 = "00kqrn3xmfzg469y155vihsiby8dbbs382fi6qg8p2zg3i5dih1d"; })
+  (fetchNuGet { pname = "Serilog.Sinks.Async"; version = "1.5.0"; sha256 = "0bcb3n6lmg5wfj806mziybfmbb8gyiszrivs3swf0msy8w505gyg"; })
   (fetchNuGet { pname = "Serilog.Sinks.Console"; version = "3.1.1"; sha256 = "0j99as641y1k6havwwkhyr0n08vibiblmfjj6nz051mz8g3864fn"; })
   (fetchNuGet { pname = "Serilog.Sinks.Console"; version = "4.0.1"; sha256 = "080vh9kcyn9lx4j7p34146kp9byvhqlaz5jn9wzx70ql9cwd0hlz"; })
   (fetchNuGet { pname = "Serilog.Sinks.Debug"; version = "1.0.1"; sha256 = "0969mb254kr59bgkq01ybyzca89z3f4n9ng5mdj8m53d5653zf22"; })
-  (fetchNuGet { pname = "Serilog.Sinks.File"; version = "4.1.0"; sha256 = "1ry7p9hf1zlnai1j5zjhjp4dqm2agsbpq6cvxgpf5l8m26x6mgca"; })
   (fetchNuGet { pname = "Serilog.Sinks.File"; version = "5.0.0"; sha256 = "097rngmgcrdfy7jy8j7dq3xaq2qky8ijwg0ws6bfv5lx0f3vvb0q"; })
   (fetchNuGet { pname = "SharedMemory"; version = "2.3.2"; sha256 = "078qaab0j8p2fjcc9n7r4sr5pr7567a9bspfiikkc85bsx7vfm8w"; })
   (fetchNuGet { pname = "SharpGen.Runtime"; version = "2.0.0-beta.10"; sha256 = "0yxq0b4m96z71afc7sywfrlwz2pgr5nilacmssjk803v70f0ydr1"; })
···
   (fetchNuGet { pname = "System.Globalization"; version = "4.3.0"; sha256 = "1cp68vv683n6ic2zqh2s1fn4c2sd87g5hpp6l4d4nj4536jz98ki"; })
   (fetchNuGet { pname = "System.Globalization.Calendars"; version = "4.3.0"; sha256 = "1xwl230bkakzzkrggy1l1lxmm3xlhk4bq2pkv790j5lm8g887lxq"; })
   (fetchNuGet { pname = "System.Globalization.Extensions"; version = "4.3.0"; sha256 = "02a5zfxavhv3jd437bsncbhd2fp1zv4gxzakp1an9l6kdq1mcqls"; })
-  (fetchNuGet { pname = "System.IO"; version = "4.1.0"; sha256 = "1g0yb8p11vfd0kbkyzlfsbsp5z44lwsvyc0h3dpw6vqnbi035ajp"; })
   (fetchNuGet { pname = "System.IO"; version = "4.3.0"; sha256 = "05l9qdrzhm4s5dixmx68kxwif4l99ll5gqmh7rqgw554fx0agv5f"; })
   (fetchNuGet { pname = "System.IO.Compression"; version = "4.3.0"; sha256 = "084zc82yi6yllgda0zkgl2ys48sypiswbiwrv7irb3r0ai1fp4vz"; })
   (fetchNuGet { pname = "System.IO.Compression.ZipFile"; version = "4.3.0"; sha256 = "1yxy5pq4dnsm9hlkg9ysh5f6bf3fahqqb6p8668ndy5c0lk7w2ar"; })
-  (fetchNuGet { pname = "System.IO.FileSystem"; version = "4.0.1"; sha256 = "0kgfpw6w4djqra3w5crrg8xivbanh1w9dh3qapb28q060wb9flp1"; })
   (fetchNuGet { pname = "System.IO.FileSystem"; version = "4.3.0"; sha256 = "0z2dfrbra9i6y16mm9v1v6k47f0fm617vlb7s5iybjjsz6g1ilmw"; })
-  (fetchNuGet { pname = "System.IO.FileSystem.Primitives"; version = "4.0.1"; sha256 = "1s0mniajj3lvbyf7vfb5shp4ink5yibsx945k6lvxa96r8la1612"; })
   (fetchNuGet { pname = "System.IO.FileSystem.Primitives"; version = "4.3.0"; sha256 = "0j6ndgglcf4brg2lz4wzsh1av1gh8xrzdsn9f0yznskhqn1xzj9c"; })
   (fetchNuGet { pname = "System.Linq"; version = "4.3.0"; sha256 = "1w0gmba695rbr80l1k2h4mrwzbzsyfl2z4klmpbsvsg5pm4a56s7"; })
   (fetchNuGet { pname = "System.Linq.Expressions"; version = "4.3.0"; sha256 = "0ky2nrcvh70rqq88m9a5yqabsl4fyd17bpr63iy2mbivjs2nyypv"; })
···
   (fetchNuGet { pname = "System.Reflection.Primitives"; version = "4.3.0"; sha256 = "04xqa33bld78yv5r93a8n76shvc8wwcdgr1qvvjh959g3rc31276"; })
   (fetchNuGet { pname = "System.Reflection.TypeExtensions"; version = "4.3.0"; sha256 = "0y2ssg08d817p0vdag98vn238gyrrynjdj4181hdg780sif3ykp1"; })
   (fetchNuGet { pname = "System.Resources.ResourceManager"; version = "4.3.0"; sha256 = "0sjqlzsryb0mg4y4xzf35xi523s4is4hz9q4qgdvlvgivl7qxn49"; })
-  (fetchNuGet { pname = "System.Runtime"; version = "4.1.0"; sha256 = "02hdkgk13rvsd6r9yafbwzss8kr55wnj8d5c7xjnp8gqrwc8sn0m"; })
   (fetchNuGet { pname = "System.Runtime"; version = "4.3.0"; sha256 = "066ixvgbf2c929kgknshcxqj6539ax7b9m570cp8n179cpfkapz7"; })
   (fetchNuGet { pname = "System.Runtime.CompilerServices.Unsafe"; version = "4.4.0"; sha256 = "0a6ahgi5b148sl5qyfpyw383p3cb4yrkm802k29fsi4mxkiwir29"; })
   (fetchNuGet { pname = "System.Runtime.CompilerServices.Unsafe"; version = "4.5.0"; sha256 = "17labczwqk3jng3kkky73m0jhi8wc21vbl7cz5c0hj2p1dswin43"; })
···
   (fetchNuGet { pname = "System.Runtime.CompilerServices.Unsafe"; version = "5.0.0"; sha256 = "02k25ivn50dmqx5jn8hawwmz24yf0454fjd823qk6lygj9513q4x"; })
   (fetchNuGet { pname = "System.Runtime.CompilerServices.Unsafe"; version = "6.0.0"; sha256 = "0qm741kh4rh57wky16sq4m0v05fxmkjjr87krycf5vp9f0zbahbc"; })
   (fetchNuGet { pname = "System.Runtime.Extensions"; version = "4.3.0"; sha256 = "1ykp3dnhwvm48nap8q23893hagf665k0kn3cbgsqpwzbijdcgc60"; })
-  (fetchNuGet { pname = "System.Runtime.Handles"; version = "4.0.1"; sha256 = "1g0zrdi5508v49pfm3iii2hn6nm00bgvfpjq1zxknfjrxxa20r4g"; })
   (fetchNuGet { pname = "System.Runtime.Handles"; version = "4.3.0"; sha256 = "0sw2gfj2xr7sw9qjn0j3l9yw07x73lcs97p8xfc9w1x9h5g5m7i8"; })
   (fetchNuGet { pname = "System.Runtime.InteropServices"; version = "4.3.0"; sha256 = "00hywrn4g7hva1b2qri2s6rabzwgxnbpw9zfxmz28z09cpwwgh7j"; })
   (fetchNuGet { pname = "System.Runtime.InteropServices.RuntimeInformation"; version = "4.3.0"; sha256 = "0q18r1sh4vn7bvqgd6dmqlw5v28flbpj349mkdish2vjyvmnb2ii"; })
···
   (fetchNuGet { pname = "System.Security.Principal.Windows"; version = "4.3.0"; sha256 = "00a0a7c40i3v4cb20s2cmh9csb5jv2l0frvnlzyfxh848xalpdwr"; })
   (fetchNuGet { pname = "System.Security.Principal.Windows"; version = "5.0.0"; sha256 = "1mpk7xj76lxgz97a5yg93wi8lj0l8p157a5d50mmjy3gbz1904q8"; })
   (fetchNuGet { pname = "System.Security.Principal.Windows"; version = "6.0.0-preview.5.21301.5"; sha256 = "1q3iikvjcfrm5p89p1j7qlw1szvryq680qypk023wgy9phmlwi57"; })
-  (fetchNuGet { pname = "System.Text.Encoding"; version = "4.0.11"; sha256 = "1dyqv0hijg265dwxg6l7aiv74102d6xjiwplh2ar1ly6xfaa4iiw"; })
   (fetchNuGet { pname = "System.Text.Encoding"; version = "4.3.0"; sha256 = "1f04lkir4iladpp51sdgmis9dj4y8v08cka0mbmsy0frc9a4gjqr"; })
   (fetchNuGet { pname = "System.Text.Encoding.CodePages"; version = "4.5.1"; sha256 = "1z21qyfs6sg76rp68qdx0c9iy57naan89pg7p6i3qpj8kyzn921w"; })
-  (fetchNuGet { pname = "System.Text.Encoding.Extensions"; version = "4.0.11"; sha256 = "08nsfrpiwsg9x5ml4xyl3zyvjfdi4mvbqf93kjdh11j4fwkznizs"; })
   (fetchNuGet { pname = "System.Text.Encoding.Extensions"; version = "4.3.0"; sha256 = "11q1y8hh5hrp5a3kw25cb6l00v5l5dvirkz8jr3sq00h1xgcgrxy"; })
+  (fetchNuGet { pname = "System.Text.Encodings.Web"; version = "6.0.0"; sha256 = "06n9ql3fmhpjl32g3492sj181zjml5dlcc5l76xq2h38c4f87sai"; })
+  (fetchNuGet { pname = "System.Text.Json"; version = "6.0.6"; sha256 = "0bkfrnr9618brbl1gvhyqrf5720syawf9dvpk8xfvkxbg7imlpjx"; })
   (fetchNuGet { pname = "System.Text.RegularExpressions"; version = "4.3.0"; sha256 = "1bgq51k7fwld0njylfn7qc5fmwrk2137gdq7djqdsw347paa9c2l"; })
   (fetchNuGet { pname = "System.Threading"; version = "4.3.0"; sha256 = "0rw9wfamvhayp5zh3j7p1yfmx9b5khbf4q50d8k5rk993rskfd34"; })
-  (fetchNuGet { pname = "System.Threading.Tasks"; version = "4.0.11"; sha256 = "0nr1r41rak82qfa5m0lhk9mp0k93bvfd7bbd9sdzwx9mb36g28p5"; })
   (fetchNuGet { pname = "System.Threading.Tasks"; version = "4.3.0"; sha256 = "134z3v9abw3a6jsw17xl3f6hqjpak5l682k2vz39spj4kmydg6k7"; })
   (fetchNuGet { pname = "System.Threading.Tasks.Extensions"; version = "4.3.0"; sha256 = "1xxcx2xh8jin360yjwm4x4cf5y3a2bwpn2ygkfkwkicz7zk50s2z"; })
   (fetchNuGet { pname = "System.Threading.Tasks.Extensions"; version = "4.5.4"; sha256 = "0y6ncasgfcgnjrhynaf0lwpkpkmv4a07sswwkwbwb5h7riisj153"; })
   (fetchNuGet { pname = "System.Threading.ThreadPool"; version = "4.3.0"; sha256 = "027s1f4sbx0y1xqw2irqn6x161lzj8qwvnh2gn78ciiczdv10vf1"; })
-  (fetchNuGet { pname = "System.Threading.Timer"; version = "4.0.1"; sha256 = "15n54f1f8nn3mjcjrlzdg6q3520571y012mx7v991x2fvp73lmg6"; })
   (fetchNuGet { pname = "System.Threading.Timer"; version = "4.3.0"; sha256 = "1nx773nsx6z5whv8kaa1wjh037id2f1cxhb69pvgv12hd2b6qs56"; })
   (fetchNuGet { pname = "System.Windows.Extensions"; version = "6.0.0"; sha256 = "1wy9pq9vn1bqg5qnv53iqrbx04yzdmjw4x5yyi09y3459vaa1sip"; })
   (fetchNuGet { pname = "System.Xml.ReaderWriter"; version = "4.3.0"; sha256 = "0c47yllxifzmh8gq6rq6l36zzvw4kjvlszkqa9wq3fr59n0hl3s1"; })

pkgs/os-specific/linux/prl-tools/default.nix

···
 assert (!libsOnly) -> kernel != null;
 
 stdenv.mkDerivation rec {
-  version = "18.0.2-53077";
+  version = "18.0.3-53079";
   pname = "prl-tools";
 
   # We download the full distribution to extract prl-tools-lin.iso from
   # => ${dmg}/Parallels\ Desktop.app/Contents/Resources/Tools/prl-tools-lin.iso
   src = fetchurl {
     url = "https://download.parallels.com/desktop/v${lib.versions.major version}/${version}/ParallelsDesktop-${version}.dmg";
-    sha256 = "sha256-yrCg3qr96SUCHmT3IAF79/Ha+L82V3nIC6Hb5ugXoGk=";
+    sha256 = "sha256-z9B2nhcTSZr3L30fa54zYi6WnonQ2wezHoneT2tQWAc=";
   };
 
   patches = lib.optionals (lib.versionAtLeast kernel.version "6.0") [

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

···
   py = python3.override {
     packageOverrides = final: prev: {
       django = prev.django_4;
-      fido2 = prev.fido2.overridePythonAttrs (old: rec {
-        version = "0.9.3";
-        src = prev.fetchPypi {
-          pname = "fido2";
-          inherit version;
-          sha256 = "sha256-tF6JphCc/Lfxu1E3dqotZAjpXEgi+DolORi5RAg0Zuw=";
-        };
-      });
     };
   };
 in
 py.pkgs.buildPythonApplication rec {
   pname = "healthchecks";
-  version = "2.2.1";
+  version = "2.4.1";
   format = "other";
 
   src = fetchFromGitHub {
     owner = "healthchecks";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-C+NUvs5ijbj/l8G1sjSXvUJDNSOTVFAStfS5KtYFpUs=";
+    sha256 = "sha256-K2zA0ZkAPMgm+IofNiCf+mVTF/RIoorTupWLOowT29g=";
   };
 
   propagatedBuildInputs = with py.pkgs; [
     apprise
-    cffi
     cron-descriptor
     cronsim
-    cryptography
     django
     django-compressor
     fido2
     minio
     psycopg2
-    py
+    pycurl
     pyotp
-    requests
     segno
     statsd
     whitenoise

pkgs/tools/misc/hyfetch/default.nix

···
 
 buildPythonPackage rec {
   pname = "HyFetch";
-  version = "1.4.1";
+  version = "1.4.2";
 
   src = fetchFromGitHub {
     repo = "hyfetch";
     owner = "hykilpikonna";
     rev = "refs/tags/${version}";
-    sha256 = "sha256-aVALjuFXg3ielDfxEDMTOtaPghsBg9+vKRbR3aDTalQ=";
+    sha256 = "sha256-5TzIhbyrhQmuxR/Vs3XpOj/8FnykmBiDj6sXfFZK0uM=";
   };
 
   propagatedBuildInputs = [

pkgs/tools/networking/hysteria/default.nix

···
 }:
 buildGoModule rec {
   pname = "hysteria";
-  version = "1.2.1";
+  version = "1.2.2";
 
   src = fetchFromGitHub {
     owner = "HyNetwork";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-xL8xRVJdCyaP39TO+cJLAPbdc7WHxgBQMEyxkyhWlA8=";
+    sha256 = "sha256-XAf835p2a7ThGgYL62pcEWqjp0rs/cRYfzTJsV6j2oA=";
   };
 
-  vendorSha256 = "sha256-VCQHkkYmGU0ZPmTuYu2XFa5ezDJ3x7dZGN+Usmq4sOY=";
+  vendorSha256 = "sha256-nVUS3KquKUSN/8OHPlcMK9gDJmrxvWS8nHYE7m6hZPQ=";
   proxyVendor = true;
 
   ldflags = [
     "-s"
     "-w"
     "-X main.appVersion=${version}"
-    "-X main.appCommit=${version}"
   ];
 
   postInstall = ''

pkgs/tools/networking/xray/default.nix

···
+{ lib
+, fetchFromGitHub
+, fetchurl
+, symlinkJoin
+, buildGoModule
+, runCommand
+, makeWrapper
+, nix-update-script
+, v2ray-geoip
+, v2ray-domain-list-community
+, assets ? [ v2ray-geoip v2ray-domain-list-community ]
+}:
+
+let
+  assetsDrv = symlinkJoin {
+    name = "v2ray-assets";
+    paths = assets;
+  };
+
+in
+buildGoModule rec {
+  pname = "xray";
+  version = "1.6.1";
+
+  src = fetchFromGitHub {
+    owner = "XTLS";
+    repo = "Xray-core";
+    rev = "v${version}";
+    sha256 = "0g2bmy522lhip0rgb3hqyi3bidf4ljyjvvv3n1kb6lvm0p3br51b";
+  };
+
+  vendorSha256 = "sha256-QAF/05/5toP31a/l7mTIetFhXuAKsT69OI1K/gMXei0=";
+
+  nativeBuildInputs = [ makeWrapper ];
+
+  doCheck = false;
+
+  ldflags = [ "-s" "-w" "-buildid=" ];
+  subPackages = [ "main" ];
+
+   installPhase = ''
+    runHook preInstall
+    install -Dm555 "$GOPATH"/bin/main $out/bin/xray
+    runHook postInstall
+  '';
+
+  assetsDrv = symlinkJoin {
+    name = "v2ray-assets";
+    paths = assets;
+  };
+
+  postFixup = ''
+    wrapProgram $out/bin/xray \
+      --suffix XRAY_LOCATION_ASSET : $assetsDrv/share/v2ray
+  '';
+
+  passthru = {
+    updateScript = nix-update-script {
+      attrPath = pname;
+    };
+  };
+
+  meta = {
+    description = "A platform for building proxies to bypass network restrictions. A replacement for v2ray-core, with XTLS support and fully compatible configuration";
+    homepage = "https://github.com/XTLS/Xray-core";
+    license = with lib.licenses; [ mpl20 ];
+    maintainers = with lib.maintainers; [ iopq ];
+  };
+}

pkgs/top-level/all-packages.nix

···
 
   xplr = callPackage ../applications/misc/xplr {};
 
+  xray = callPackage ../tools/networking/xray { };
+
   testdisk = libsForQt5.callPackage ../tools/system/testdisk { };
 
   testdisk-qt = testdisk.override { enableQt = true; };
···
 
   fasmg = callPackage ../development/compilers/fasmg { };
 
+  fbc = if stdenv.hostPlatform.isDarwin then
+    callPackage ../development/compilers/fbc/mac-bin.nix { }
+  else
+    callPackage ../development/compilers/fbc { };
+
   filecheck = with python3Packages; toPythonApplication filecheck;
 
   firrtl = callPackage ../development/compilers/firrtl { };
···
     inherit (darwin.apple_sdk.frameworks) Security;
   };
   cargo-insta = callPackage ../development/tools/rust/cargo-insta { };
+  cargo-lambda = callPackage ../development/tools/rust/cargo-lambda {
+    inherit (darwin.apple_sdk.frameworks) Security;
+  };
   cargo-limit = callPackage ../development/tools/rust/cargo-limit { };
   cargo-make = callPackage ../development/tools/rust/cargo-make {
     inherit (darwin.apple_sdk.frameworks) Security SystemConfiguration;
···
   libbpf_0 = callPackage ../os-specific/linux/libbpf/0.x.nix { };
   # until more issues are fixed default to libbpf 0.x
   libbpf = libbpf_0;
+
+  bundlewrap = with python3.pkgs; toPythonApplication bundlewrap;
 
   bpftools = callPackage ../os-specific/linux/bpftools { };
 
···
     # customConfig = builtins.readFile ./tabbed.config.h;
   };
 
-  # Use GHC 9.0 when this asserts starts to fire
-  taffybar = assert haskellPackages.taffybar.version == "3.3.0";
-  callPackage ../applications/window-managers/taffybar {
-    inherit (haskell.packages.ghc810) ghcWithPackages taffybar;
+  taffybar = callPackage ../applications/window-managers/taffybar {
+    inherit (haskellPackages) ghcWithPackages taffybar;
   };
 
   tagainijisho = libsForQt5.callPackage ../applications/office/tagainijisho {};
···
   };
 
   zcash = callPackage ../applications/blockchains/zcash {
-    stdenv = if stdenv.isDarwin then stdenv else llvmPackages_13.stdenv;
+    inherit (darwin.apple_sdk.frameworks) Security;
+    stdenv = llvmPackages_14.stdenv;
   };
 
   zecwallet-lite = callPackage ../applications/blockchains/zecwallet-lite { };
···
   minisat = callPackage ../applications/science/logic/minisat {};
 
   monosat = callPackage ../applications/science/logic/monosat {};
+
+  nusmv = callPackage ../applications/science/logic/nusmv { };
 
   nuXmv = callPackage ../applications/science/logic/nuXmv {};
 

pkgs/top-level/python-packages.nix

···
 
   bunch = callPackage ../development/python-modules/bunch { };
 
+  bundlewrap = callPackage ../development/python-modules/bundlewrap { };
+
   bx-python = callPackage ../development/python-modules/bx-python { };
 
   bwapy = callPackage ../development/python-modules/bwapy { };

pkgs/top-level/release-haskell.nix

···
         compilerNames.ghc902
         compilerNames.ghc924
       ];
+      purescript = [
+        compilerNames.ghc924
+      ];
       purescript-cst = [
         compilerNames.ghc8107
       ];