Merge staging-next into staging

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

···
       </listitem>
       <listitem>
         <para>
+          <link xlink:href="https://github.com/tmate-io/tmate-ssh-server">tmate-ssh-server</link>,
+          server side part of
+          <link xlink:href="https://tmate.io/">tmate</link>. Available
+          as
+          <link linkend="opt-services.tmate-ssh-server.enable">services.tmate-ssh-server</link>.
+        </para>
+      </listitem>
+      <listitem>
+        <para>
           <link xlink:href="https://www.grafana.com/oss/tempo/">Grafana
           Tempo</link>, a distributed tracing store. Available as
           <link linkend="opt-services.tempo.enable">services.tempo</link>.

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

···
 
 - [go-autoconfig](https://github.com/L11R/go-autoconfig), IMAP/SMTP autodiscover server. Available as [services.go-autoconfig](#opt-services.go-autoconfig.enable).
 
+- [tmate-ssh-server](https://github.com/tmate-io/tmate-ssh-server), server side part of [tmate](https://tmate.io/). Available as [services.tmate-ssh-server](#opt-services.tmate-ssh-server.enable).
+
 - [Grafana Tempo](https://www.grafana.com/oss/tempo/), a distributed tracing store. Available as [services.tempo](#opt-services.tempo.enable).
 
 - [AusweisApp2](https://www.ausweisapp.bund.de/), the authentication software for the German ID card. Available as [programs.ausweisapp](#opt-programs.ausweisapp.enable).

nixos/modules/module-list.nix

···
   ./services/networking/tinc.nix
   ./services/networking/tinydns.nix
   ./services/networking/tftpd.nix
+  ./services/networking/tmate-ssh-server.nix
   ./services/networking/trickster.nix
   ./services/networking/tox-bootstrapd.nix
   ./services/networking/tox-node.nix

nixos/modules/services/networking/tmate-ssh-server.nix

···
+{ config, lib, pkgs, ... }:
+with lib;
+let
+  cfg = config.services.tmate-ssh-server;
+
+  defaultKeysDir = "/etc/tmate-ssh-server-keys";
+  edKey = "${defaultKeysDir}/ssh_host_ed25519_key";
+  rsaKey = "${defaultKeysDir}/ssh_host_rsa_key";
+
+  keysDir =
+    if cfg.keysDir == null
+    then defaultKeysDir
+    else cfg.keysDir;
+
+  domain = config.networking.domain;
+in
+{
+  options.services.tmate-ssh-server = {
+    enable = mkEnableOption (mdDoc "tmate ssh server");
+
+    package = mkOption {
+      type = types.package;
+      description = mdDoc "The package containing tmate-ssh-server";
+      defaultText = literalExpression "pkgs.tmate-ssh-server";
+      default = pkgs.tmate-ssh-server;
+    };
+
+    host = mkOption {
+      type = types.str;
+      description = mdDoc "External host name";
+      defaultText = lib.literalExpression "config.networking.domain or config.networking.hostName ";
+      default =
+        if domain == null then
+          config.networking.hostName
+        else
+          domain;
+    };
+
+    port = mkOption {
+      type = types.port;
+      description = mdDoc "Listen port for the ssh server";
+      default = 2222;
+    };
+
+    openFirewall = mkOption {
+      type = types.bool;
+      default = true;
+      description = mdDoc "Whether to automatically open the specified ports in the firewall.";
+    };
+
+    advertisedPort = mkOption {
+      type = types.port;
+      description = mdDoc "External port advertised to clients";
+    };
+
+    keysDir = mkOption {
+      type = with types; nullOr str;
+      description = mdDoc "Directory containing ssh keys, defaulting to auto-generation";
+      default = null;
+    };
+  };
+
+  config = mkIf cfg.enable {
+
+    networking.firewall.allowedTCPPorts = optionals cfg.openFirewall [ cfg.port ];
+
+    services.tmate-ssh-server = {
+      advertisedPort = mkDefault cfg.port;
+    };
+
+    environment.systemPackages =
+      let
+        tmate-config = pkgs.writeText "tmate.conf"
+          ''
+            set -g tmate-server-host "${cfg.host}"
+            set -g tmate-server-port ${toString cfg.port}
+            set -g tmate-server-ed25519-fingerprint "@ed25519_fingerprint@"
+            set -g tmate-server-rsa-fingerprint "@rsa_fingerprint@"
+          '';
+      in
+      [
+        (pkgs.writeShellApplication {
+          name = "tmate-client-config";
+          runtimeInputs = with pkgs;[ openssh coreutils sd ];
+          text = ''
+            RSA_SIG="$(ssh-keygen -l -E SHA256 -f "${keysDir}/ssh_host_rsa_key.pub" | cut -d ' ' -f 2)"
+            ED25519_SIG="$(ssh-keygen -l -E SHA256 -f "${keysDir}/ssh_host_ed25519_key.pub" | cut -d ' ' -f 2)"
+            sd -sp '@ed25519_fingerprint@' "$ED25519_SIG" ${tmate-config} | \
+              sd -sp '@rsa_fingerprint@' "$RSA_SIG"
+          '';
+        })
+      ];
+
+    systemd.services.tmate-ssh-server = {
+      description = "tmate SSH Server";
+      after = [ "network.target" ];
+      wantedBy = [ "multi-user.target" ];
+      serviceConfig = {
+        ExecStart = "${cfg.package}/bin/tmate-ssh-server -h ${cfg.host} -p ${toString cfg.port} -q ${toString cfg.advertisedPort} -k ${keysDir}";
+      };
+      preStart = mkIf (cfg.keysDir == null) ''
+        if [[ ! -d ${defaultKeysDir} ]]
+        then
+          mkdir -p ${defaultKeysDir}
+        fi
+        if [[ ! -f ${edKey} ]]
+        then
+          ${pkgs.openssh}/bin/ssh-keygen -t ed25519 -f ${edKey} -N ""
+        fi
+        if [[ ! -f ${rsaKey} ]]
+        then
+          ${pkgs.openssh}/bin/ssh-keygen -t rsa -f ${rsaKey} -N ""
+        fi
+      '';
+    };
+  };
+
+  meta = {
+    maintainers = with maintainers; [ jlesquembre ];
+  };
+
+}

nixos/tests/all-tests.nix

···
   tinc = handleTest ./tinc {};
   tinydns = handleTest ./tinydns.nix {};
   tinywl = handleTest ./tinywl.nix {};
+  tmate-ssh-server = handleTest ./tmate-ssh-server.nix { };
   tomcat = handleTest ./tomcat.nix {};
   tor = handleTest ./tor.nix {};
   # traefik test relies on docker-containers

nixos/tests/tmate-ssh-server.nix

···
+import ./make-test-python.nix ({ pkgs, lib, ... }:
+let
+  inherit (import ./ssh-keys.nix pkgs)
+    snakeOilPrivateKey snakeOilPublicKey;
+
+  setUpPrivateKey = name: ''
+    ${name}.succeed(
+        "mkdir -p /root/.ssh",
+        "chown 700 /root/.ssh",
+        "cat '${snakeOilPrivateKey}' > /root/.ssh/id_snakeoil",
+        "chown 600 /root/.ssh/id_snakeoil",
+    )
+    ${name}.wait_for_file("/root/.ssh/id_snakeoil")
+  '';
+
+  sshOpts = "-oStrictHostKeyChecking=no -oUserKnownHostsFile=/dev/null -oIdentityFile=/root/.ssh/id_snakeoil";
+
+in
+{
+  name = "tmate-ssh-server";
+  nodes =
+    {
+      server = { ... }: {
+        services.tmate-ssh-server = {
+          enable = true;
+          port = 2223;
+        };
+      };
+      client = { ... }: {
+        environment.systemPackages = [ pkgs.tmate ];
+        services.openssh.enable = true;
+        users.users.root.openssh.authorizedKeys.keys = [ snakeOilPublicKey ];
+      };
+      client2 = { ... }: {
+        environment.systemPackages = [ pkgs.openssh ];
+      };
+    };
+  testScript = ''
+    start_all()
+
+    server.wait_for_unit("tmate-ssh-server.service")
+    server.wait_for_open_port(2223)
+    server.wait_for_file("/etc/tmate-ssh-server-keys/ssh_host_ed25519_key.pub")
+    server.wait_for_file("/etc/tmate-ssh-server-keys/ssh_host_rsa_key.pub")
+    server.succeed("tmate-client-config > /tmp/tmate.conf")
+    server.wait_for_file("/tmp/tmate.conf")
+
+    ${setUpPrivateKey "server"}
+    client.wait_for_unit("sshd.service")
+    client.wait_for_open_port(22)
+    server.succeed("scp ${sshOpts} /tmp/tmate.conf client:/tmp/tmate.conf")
+
+    client.wait_for_file("/tmp/tmate.conf")
+    client.send_chars("root\n")
+    client.sleep(2)
+    client.send_chars("tmate -f /tmp/tmate.conf\n")
+    client.sleep(2)
+    client.send_chars("q")
+    client.sleep(2)
+    client.send_chars("tmate display -p '#{tmate_ssh}' > /tmp/ssh_command\n")
+    client.wait_for_file("/tmp/ssh_command")
+    ssh_cmd = client.succeed("cat /tmp/ssh_command")
+
+    client2.succeed("mkdir -p ~/.ssh; ssh-keyscan -p 2223 server > ~/.ssh/known_hosts")
+    client2.send_chars("root\n")
+    client2.sleep(2)
+    client2.send_chars(ssh_cmd.strip() + "\n")
+    client2.sleep(2)
+    client2.send_chars("touch /tmp/client_2\n")
+
+    client.wait_for_file("/tmp/client_2")
+  '';
+})

pkgs/applications/audio/gmpc/default.nix

···
   version = "11.8.16";
 
   libmpd = stdenv.mkDerivation {
-    name = "libmpd-11.8.17";
+    pname = "libmpd";
+    version = "11.8.17";
     src = fetchurl {
-      url = "http://download.sarine.nl/Programs/gmpc/11.8/libmpd-11.8.17.tar.gz";
+      url = "https://download.sarine.nl/Programs/gmpc/${lib.versions.majorMinor version}/libmpd-${version}.tar.gz";
       sha256 = "10vspwsgr8pwf3qp2bviw6b2l8prgdiswgv7qiqiyr0h1mmk487y";
     };
     patches = [ ./libmpd-11.8.17-remove-strndup.patch ];

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

···
 
   SchemaStore-nvim = buildVimPluginFrom2Nix {
     pname = "SchemaStore.nvim";
-    version = "2022-09-28";
+    version = "2022-10-04";
     src = fetchFromGitHub {
       owner = "b0o";
       repo = "SchemaStore.nvim";
-      rev = "33873c71335a31988b62025c3b2224f3a9fe8e15";
-      sha256 = "134z58jhi343ylr6nip8f180cqvyf2l7gxrzygxyv55d2iz182qk";
+      rev = "faf602afe86b4cc33a4471371f128d80328cacf2";
+      sha256 = "1ilgdzjcqmplk81xx89rsspvvp7mhzrpcv9lwb9dk3drgnvlzza2";
     };
     meta.homepage = "https://github.com/b0o/SchemaStore.nvim/";
   };
···
 
   SpaceVim = buildVimPluginFrom2Nix {
     pname = "SpaceVim";
-    version = "2022-10-01";
+    version = "2022-10-04";
     src = fetchFromGitHub {
       owner = "SpaceVim";
       repo = "SpaceVim";
-      rev = "46f53be2f8e538e5b5aa5344bd9f9dd1a9ef1679";
-      sha256 = "1c02vql960mfpgj96zmzkij8yc2xpsxwgs7dfqphkmwq3b02r1nx";
+      rev = "0026ba28a52156e8e965f131a060b8bdaed2769e";
+      sha256 = "1cph6c7x5sdx5gbmszl9w0blspnjwfzg3pf42gyvnph1c3hacqwk";
     };
     meta.homepage = "https://github.com/SpaceVim/SpaceVim/";
   };
···
 
   ale = buildVimPluginFrom2Nix {
     pname = "ale";
-    version = "2022-09-30";
+    version = "2022-10-04";
     src = fetchFromGitHub {
       owner = "dense-analysis";
       repo = "ale";
-      rev = "a33960eb51b638f232dff71cfeac5ede87b38312";
+      rev = "4094426c707dda404754487bf496db1b4c7d05f1";
       sha256 = "1v56lzs9i29bwzb1iqwanzv3khr9gd9lmwv5v5ddhg9b3bq55rnv";
     };
     meta.homepage = "https://github.com/dense-analysis/ale/";
···
 
   barbar-nvim = buildVimPluginFrom2Nix {
     pname = "barbar.nvim";
-    version = "2022-10-02";
+    version = "2022-10-03";
     src = fetchFromGitHub {
       owner = "romgrk";
       repo = "barbar.nvim";
-      rev = "95f2c58c84726eac14fd6e86dbcab599d7ecaedd";
-      sha256 = "19nja82dcv7gr0sc1404zjak00wb5n7k3plnnnndl0siah3i4d7k";
+      rev = "61424a6211431a42458bc755b3e7e982e671c438";
+      sha256 = "1xg7wm3prq2vj0jg2knb96lc7mlh7l6fw6c23s0i9vqrbz4b8jr2";
     };
     meta.homepage = "https://github.com/romgrk/barbar.nvim/";
   };
···
 
   bufferline-nvim = buildVimPluginFrom2Nix {
     pname = "bufferline.nvim";
-    version = "2022-09-19";
+    version = "2022-10-04";
     src = fetchFromGitHub {
       owner = "akinsho";
       repo = "bufferline.nvim";
-      rev = "83bf4dc7bff642e145c8b4547aa596803a8b4dc4";
-      sha256 = "1wlwm75c1ngk4dkzynl7p5av6ydxagcmx82bg7l9037h2ijvqhv2";
+      rev = "0606ceeea77e85428ba06e21c9121e635992ccc7";
+      sha256 = "099ad6vxlmplzvzrykl2rnbamgacriasa2pab8fv8q9hmdd0nbc2";
     };
     meta.homepage = "https://github.com/akinsho/bufferline.nvim/";
   };
···
 
   ccc-nvim = buildVimPluginFrom2Nix {
     pname = "ccc.nvim";
-    version = "2022-10-02";
+    version = "2022-10-04";
     src = fetchFromGitHub {
       owner = "uga-rosa";
       repo = "ccc.nvim";
-      rev = "0a8a6f1b42dd3c8031fe5d96cc835998169e1ac9";
-      sha256 = "01k31s7mpl3kkh2yl078915yq78ga9x0rhawbz03s0kjssvlsfyd";
+      rev = "81dd97874eb63ac719c372bdeb1cd15d9ddcca15";
+      sha256 = "1rpj7qlwwycq8znxa1v369mbbirhgkj81whrhcm5vrwmkhy9j1w7";
     };
     meta.homepage = "https://github.com/uga-rosa/ccc.nvim/";
   };
···
 
   clangd_extensions-nvim = buildVimPluginFrom2Nix {
     pname = "clangd_extensions.nvim";
-    version = "2022-09-28";
+    version = "2022-10-02";
     src = fetchFromGitHub {
       owner = "p00f";
       repo = "clangd_extensions.nvim";
-      rev = "7fa598a4a1bfd61a8f194d7db1e4d820221e9ea9";
+      rev = "756a12b1604aa86368f2078ab44bfa788a29ece4";
       sha256 = "1wxyy98gal3zdwrh6z92044yyj3nbw2bzq9diwa1h5waraf9jg7r";
     };
     meta.homepage = "https://github.com/p00f/clangd_extensions.nvim/";
···
 
   cmp-path = buildVimPluginFrom2Nix {
     pname = "cmp-path";
-    version = "2022-07-26";
+    version = "2022-10-03";
     src = fetchFromGitHub {
       owner = "hrsh7th";
       repo = "cmp-path";
-      rev = "447c87cdd6e6d6a1d2488b1d43108bfa217f56e1";
-      sha256 = "0nmxwfn0gp70z26w9x03dk2myx9bbjxqw7zywzvdm28lgr43dwhv";
+      rev = "91ff86cd9c29299a64f968ebb45846c485725f23";
+      sha256 = "18ixx14ibc7qrv32nj0ylxrx8w4ggg49l5vhcqd35hkp4n56j6mn";
     };
     meta.homepage = "https://github.com/hrsh7th/cmp-path/";
   };
···
 
   cmp-spell = buildVimPluginFrom2Nix {
     pname = "cmp-spell";
-    version = "2021-10-19";
+    version = "2022-10-03";
     src = fetchFromGitHub {
       owner = "f3fora";
       repo = "cmp-spell";
-      rev = "5602f1a0de7831f8dad5b0c6db45328fbd539971";
-      sha256 = "1pk6izww8canfqpiyrqd6qx1p3j18pwfzkfx4ynbng8kl9nh6nv5";
+      rev = "5c32dd5c23ec31e88ed28c74231eec0c55dc8307";
+      sha256 = "1w0658jgn5v1018by1912dpnxa6y25pv929awaimgzd3wlsfm89p";
     };
     meta.homepage = "https://github.com/f3fora/cmp-spell/";
   };
···
 
   cmp-zsh = buildVimPluginFrom2Nix {
     pname = "cmp-zsh";
-    version = "2022-01-18";
+    version = "2022-10-03";
     src = fetchFromGitHub {
       owner = "tamago324";
       repo = "cmp-zsh";
-      rev = "1d8133e5637c73b3eb392682ae9661d521738268";
-      sha256 = "0122lf44yqjp01znp7gnc682yx7fikjkzc5njp73lmys76321lz3";
+      rev = "c24db8e58fac9006ec23d93f236749288d00dec9";
+      sha256 = "1rifl2rhrbnq3hnwmn19fky3ibv1qf4pb0hx81pl38dgq6lfm2s6";
     };
     meta.homepage = "https://github.com/tamago324/cmp-zsh/";
   };
···
 
   compiler-explorer-nvim = buildVimPluginFrom2Nix {
     pname = "compiler-explorer.nvim";
-    version = "2022-10-02";
+    version = "2022-10-03";
     src = fetchFromGitHub {
       owner = "krady21";
       repo = "compiler-explorer.nvim";
-      rev = "737ec0937c2e3f8279bedb6e308a1c183b81f08a";
-      sha256 = "1jawin6rvz5rkmh1vh3l980zghnc5hmppqginnj82n8s0lz1dl0d";
+      rev = "018d04971eb5939c01637e23377449b61f68f363";
+      sha256 = "072y39crph99mb1wzij480nmylh1llcfg0lf9smb90xabiads7sr";
     };
     meta.homepage = "https://github.com/krady21/compiler-explorer.nvim/";
   };
···
 
   coq-artifacts = buildVimPluginFrom2Nix {
     pname = "coq.artifacts";
-    version = "2022-10-02";
+    version = "2022-10-04";
     src = fetchFromGitHub {
       owner = "ms-jpq";
       repo = "coq.artifacts";
-      rev = "a72ed519665c483706e99c8e080b6333fece6030";
-      sha256 = "1im5lrpz7b3nhc53sy7nn0i4ngiy47l2l3h8c0yjrbqz9j3gcjcm";
+      rev = "72a41cd2fa99c577ffa998321af38951655cc43c";
+      sha256 = "051vsxqxh6snv2awkh0jyx8pa43z94z2dpng463dsiw89fss2va0";
     };
     meta.homepage = "https://github.com/ms-jpq/coq.artifacts/";
   };
 
   coq-thirdparty = buildVimPluginFrom2Nix {
     pname = "coq.thirdparty";
-    version = "2022-10-02";
+    version = "2022-10-04";
     src = fetchFromGitHub {
       owner = "ms-jpq";
       repo = "coq.thirdparty";
-      rev = "563bdd935c282d1d380bd98d53923c2f7d02eae9";
-      sha256 = "06lh0rm15frv741fv21hc8gwjahbp49iz03h944abqfh69cf4a35";
+      rev = "67342598dd2628a19e272acaf773b5b9f1a72248";
+      sha256 = "077agh0gzflrc7955xnbgzghf0kr1la1n3xfjydg6plb70kjqlri";
     };
     meta.homepage = "https://github.com/ms-jpq/coq.thirdparty/";
   };
···
 
   coq_nvim = buildVimPluginFrom2Nix {
     pname = "coq_nvim";
-    version = "2022-10-02";
+    version = "2022-10-04";
     src = fetchFromGitHub {
       owner = "ms-jpq";
       repo = "coq_nvim";
-      rev = "55b4222262ad8e826ce1c144a7b2b35f16f8a8e5";
-      sha256 = "0bmcv72nw0vk8qlzhs5lfirh4jq13azva1wm2w2a8hlvnfg764ij";
+      rev = "8b165521046a05320c478f2a129a1310415bd7b6";
+      sha256 = "1c1iyi17qld3q0c275yzjwxrqjkynbmx000jsrsmgjh63xjzslg0";
     };
     meta.homepage = "https://github.com/ms-jpq/coq_nvim/";
   };
···
 
   diffview-nvim = buildVimPluginFrom2Nix {
     pname = "diffview.nvim";
-    version = "2022-09-24";
+    version = "2022-10-04";
     src = fetchFromGitHub {
       owner = "sindrets";
       repo = "diffview.nvim";
-      rev = "6baa30d0a6f63da254c2d2c0638a426166973976";
-      sha256 = "0jhs3nkxjkp0w26yx6p9qx7la9sr4pxp2vgcdj6jbgrwifxaqp3y";
+      rev = "7c149a4df943c05846d3f552b89b47df50f009c9";
+      sha256 = "0660pvik5hzv8m42zwm67cm73rk1kln3ig2kpqyidbihpaxx95ay";
     };
     meta.homepage = "https://github.com/sindrets/diffview.nvim/";
   };
···
 
   dressing-nvim = buildVimPluginFrom2Nix {
     pname = "dressing.nvim";
-    version = "2022-09-20";
+    version = "2022-10-03";
     src = fetchFromGitHub {
       owner = "stevearc";
       repo = "dressing.nvim";
-      rev = "76477792b34f8fed167b5aa61a325e4dab26c3d7";
-      sha256 = "10ma1k67c36jy38j3mx3s57scflmja7m68cgf5dzh0icg7h4viyi";
+      rev = "12b808a6867e8c38015488ad6cee4e3d58174182";
+      sha256 = "037sxvq9ywdnmy9f2gw89q52a76rmg4gwbn62i669ca95wvkhzxa";
     };
     meta.homepage = "https://github.com/stevearc/dressing.nvim/";
   };
···
 
   feline-nvim = buildVimPluginFrom2Nix {
     pname = "feline.nvim";
-    version = "2022-10-01";
+    version = "2022-10-03";
     src = fetchFromGitHub {
       owner = "feline-nvim";
       repo = "feline.nvim";
-      rev = "83fcde2853a8881ea1b59cca80a5285662c1706c";
-      sha256 = "0v3xmvk8jgad29wpxqdkqq95s1cap7gdz07i299hcz94l1y5fiqz";
+      rev = "5d6a054c476f2c2e3de72022d8f59764e53946ee";
+      sha256 = "1376p6hjwl3dd4fsc93qhc19dcnycp2gkz3nz684var2nk9rxanq";
     };
     meta.homepage = "https://github.com/feline-nvim/feline.nvim/";
   };
···
 
   friendly-snippets = buildVimPluginFrom2Nix {
     pname = "friendly-snippets";
-    version = "2022-09-18";
+    version = "2022-10-03";
     src = fetchFromGitHub {
       owner = "rafamadriz";
       repo = "friendly-snippets";
-      rev = "2be79d8a9b03d4175ba6b3d14b082680de1b31b1";
-      sha256 = "0hbvqcmfgkdww6gwdx3xaim2bx5xvw825slh3wi69wkqa5qbjasx";
+      rev = "9f4ffd17ade26815cad52ba90f478a4e6e2d80df";
+      sha256 = "18saq9cswki4ny1ihvng1bgfc2zl69vngdm5c2hh7vszra95ql3s";
     };
     meta.homepage = "https://github.com/rafamadriz/friendly-snippets/";
   };
···
 
   legendary-nvim = buildVimPluginFrom2Nix {
     pname = "legendary.nvim";
-    version = "2022-09-26";
+    version = "2022-10-03";
     src = fetchFromGitHub {
       owner = "mrjones2014";
       repo = "legendary.nvim";
-      rev = "59309190f3c80a41160e29d644a15ceb5c64e239";
-      sha256 = "17zg7hpabnb0bc9y78i358nasixmznimp44z097xw5h3fkz2z2aq";
+      rev = "aeb8ac4976094c9fb8741b623c301e3da9221edb";
+      sha256 = "01lz5p8mjjrfx6hm2s678ydixyxa3hqpmc7jv3j612lkk13hypms";
     };
     meta.homepage = "https://github.com/mrjones2014/legendary.nvim/";
   };
···
 
   lua-dev-nvim = buildVimPluginFrom2Nix {
     pname = "lua-dev.nvim";
-    version = "2022-10-02";
+    version = "2022-10-04";
     src = fetchFromGitHub {
       owner = "folke";
       repo = "lua-dev.nvim";
-      rev = "2ffe2f6de00360f13ac939b7f7257e6de5e80132";
-      sha256 = "04nks3j6ah2dn4hlqabz0cvlwam86ig0a89mzpnw52injl95k9a1";
+      rev = "e651a72bd045f3d82efdd7d20f3630379af784b0";
+      sha256 = "140211vdac3khf082jfdfr6jixbl2s5x5g8z9j8ga6qyw0apdk95";
     };
     meta.homepage = "https://github.com/folke/lua-dev.nvim/";
   };
···
 
   material-nvim = buildVimPluginFrom2Nix {
     pname = "material.nvim";
-    version = "2022-09-25";
+    version = "2022-10-03";
     src = fetchFromGitHub {
       owner = "marko-cerovac";
       repo = "material.nvim";
-      rev = "548761ecc9f23423186dfeee293807f957b45185";
-      sha256 = "0drcda1mipyia6pll6k2pns1sniwhsxs5hpc3671i77fwqw4synb";
+      rev = "88e1d132cc7b27a8304b897873384bee343b2d2c";
+      sha256 = "1jg2vqrbd1m94gqbdc3nwp6lbgb578vrw3nkh2a2p8694gp8ha5g";
     };
     meta.homepage = "https://github.com/marko-cerovac/material.nvim/";
   };
···
     meta.homepage = "https://github.com/mcchrish/nnn.vim/";
   };
 
+  noice-nvim = buildVimPluginFrom2Nix {
+    pname = "noice.nvim";
+    version = "2022-10-04";
+    src = fetchFromGitHub {
+      owner = "folke";
+      repo = "noice.nvim";
+      rev = "15f3bbd607feee3dd4ea255ea2344c3d7d647406";
+      sha256 = "0kps8h4wrlidkjlklmhwdxabgfkb57qr5qmmn3b0bzlqamph21f7";
+    };
+    meta.homepage = "https://github.com/folke/noice.nvim/";
+  };
+
   nord-vim = buildVimPluginFrom2Nix {
     pname = "nord-vim";
     version = "2022-05-31";
···
 
   nui-nvim = buildVimPluginFrom2Nix {
     pname = "nui.nvim";
-    version = "2022-09-12";
+    version = "2022-10-04";
     src = fetchFromGitHub {
       owner = "MunifTanjim";
       repo = "nui.nvim";
-      rev = "e9889bbd9919544697d497537acacd9c67d0de99";
-      sha256 = "0gd2kha6hi6z3y8g0wrgi9lnslchmldhxc5vbd6iak47csi7h7gr";
+      rev = "4715f6092443f0b8fb9a3bcb0cfd03202bb03477";
+      sha256 = "1ddqwifszbdl8yzi0sj8dh20cb4hg6rk3s6qjy4l4sgslzxgsnk9";
     };
     meta.homepage = "https://github.com/MunifTanjim/nui.nvim/";
   };
 
   null-ls-nvim = buildVimPluginFrom2Nix {
     pname = "null-ls.nvim";
-    version = "2022-10-01";
+    version = "2022-10-04";
     src = fetchFromGitHub {
       owner = "jose-elias-alvarez";
       repo = "null-ls.nvim";
-      rev = "c0c19f32b614b3921e17886c541c13a72748d450";
-      sha256 = "1dvxpbl5jkzwcq1hk0b4r09qmjh5dxknbfmsyjxb6d4pzwv795xh";
+      rev = "c333ecce37ee5f096f17754901e4ec4827041166";
+      sha256 = "10nrgr1jqh3rqanakx2pary4yqlnjk2lz5bslbaznbv1jgxh2zj6";
     };
     meta.homepage = "https://github.com/jose-elias-alvarez/null-ls.nvim/";
   };
···
 
   nvim-bqf = buildVimPluginFrom2Nix {
     pname = "nvim-bqf";
-    version = "2022-09-21";
+    version = "2022-10-04";
     src = fetchFromGitHub {
       owner = "kevinhwang91";
       repo = "nvim-bqf";
-      rev = "aea31569d1b20aa6a35fa84ec756cb205a4a7134";
-      sha256 = "105iz6m3hp2qqxhmgnz17rydcbbvwyn3yvrlfr5jsj0r8qxfs0yj";
+      rev = "90b00664709bc799bfa7cccde6dc34004499a089";
+      sha256 = "09nahj79xqira309dm84vm012n2b8q2k47z8wjib7a4zf2gqfmds";
     };
     meta.homepage = "https://github.com/kevinhwang91/nvim-bqf/";
   };
···
 
   nvim-jdtls = buildVimPluginFrom2Nix {
     pname = "nvim-jdtls";
-    version = "2022-09-29";
+    version = "2022-10-04";
     src = fetchFromGitHub {
       owner = "mfussenegger";
       repo = "nvim-jdtls";
-      rev = "75d27daa061458dd5735b5eb5bbc48d3baad1186";
-      sha256 = "12yr1awyjl3chifq02yk3477vylli6vx4d2jkypqy7z91c1xf5jf";
+      rev = "0422245fdef57aa4eddba3d99aee1afaaf425da7";
+      sha256 = "0h43bqf5n0l8f1jyzp7splsvcdran9j4arafpvli4pkfd9qx3h38";
     };
     meta.homepage = "https://github.com/mfussenegger/nvim-jdtls/";
   };
···
 
   nvim-lspconfig = buildVimPluginFrom2Nix {
     pname = "nvim-lspconfig";
-    version = "2022-10-02";
+    version = "2022-10-03";
     src = fetchFromGitHub {
       owner = "neovim";
       repo = "nvim-lspconfig";
-      rev = "f11fdff7e8b5b415e5ef1837bdcdd37ea6764dda";
-      sha256 = "0nr58hq0ywid1ickzs6wqx3dsiggh2384kqp8gr3325p9ygkmkgx";
+      rev = "fc2f44dc6024bddb75b82e471c642ad1f4483094";
+      sha256 = "197d6xjsp8cn8ff1awvv0yb3qqbb5kvyj8ddwdkvrfkm1a4hkbf6";
     };
     meta.homepage = "https://github.com/neovim/nvim-lspconfig/";
   };
···
 
   nvim-metals = buildVimPluginFrom2Nix {
     pname = "nvim-metals";
-    version = "2022-10-02";
+    version = "2022-10-03";
     src = fetchFromGitHub {
       owner = "scalameta";
       repo = "nvim-metals";
-      rev = "2b795eed773d4d693bee9feae1ade84a5e9a39e7";
-      sha256 = "12kdn7xg5j6flqafnfx98zv3cr2166730qwmkh48jb18p8pwci3b";
+      rev = "1284bbf8d79fe010909e65abdd849f047ff51914";
+      sha256 = "121h5whwdyv3svby6qsjp893lwc98b6bs18jy58y5xzdzqv2lrd3";
     };
     meta.homepage = "https://github.com/scalameta/nvim-metals/";
   };
···
 
   nvim-treesitter = buildVimPluginFrom2Nix {
     pname = "nvim-treesitter";
-    version = "2022-10-02";
+    version = "2022-10-04";
     src = fetchFromGitHub {
       owner = "nvim-treesitter";
       repo = "nvim-treesitter";
-      rev = "8e763332b7bf7b3a426fd8707b7f5aa85823a5ac";
-      sha256 = "1ah1ywrdcqzqd8jm2rhb9k4wpkq0xcm011vnalkiw1xiax251ndv";
+      rev = "ffd4525fd9e61950520cea4737abc1800ad4aabb";
+      sha256 = "0v73bdkmcnmm9j44w94hly2c6vnqfm375h1bss2vvw0whnk3in94";
     };
     meta.homepage = "https://github.com/nvim-treesitter/nvim-treesitter/";
   };
···
 
   nvim-web-devicons = buildVimPluginFrom2Nix {
     pname = "nvim-web-devicons";
-    version = "2022-09-30";
+    version = "2022-10-03";
     src = fetchFromGitHub {
       owner = "kyazdani42";
       repo = "nvim-web-devicons";
-      rev = "563f3635c2d8a7be7933b9e547f7c178ba0d4352";
-      sha256 = "0lfhv9pd9a9q5qy45f9zag2fzfjlsisrf5h4xd64033331a67pgg";
+      rev = "a8cf88cbdb5c58e2b658e179c4b2aa997479b3da";
+      sha256 = "1946azhr3rq702mvidzby9jvq7h2zs45d6k9j7clxw2g9xbx0k6a";
     };
     meta.homepage = "https://github.com/kyazdani42/nvim-web-devicons/";
   };
···
 
   onedark-vim = buildVimPluginFrom2Nix {
     pname = "onedark.vim";
-    version = "2022-07-18";
+    version = "2022-10-03";
     src = fetchFromGitHub {
       owner = "joshdick";
       repo = "onedark.vim";
-      rev = "1fe54f212f09a03c2b5e277f0fe5b7b9d0b0a4ed";
-      sha256 = "19jhpfwidwigrcwz20qgm4gf5znz61xslfsf90fkr7k45vgwsk4q";
+      rev = "0c23bb090f14580c924323ef1d3ccb1f9d2fa001";
+      sha256 = "1fylkscj2iz4p89807xzzaj21lqi6621afsa8p3pms5vcn0hi8jm";
     };
     meta.homepage = "https://github.com/joshdick/onedark.vim/";
   };
 
   onedarkpro-nvim = buildVimPluginFrom2Nix {
     pname = "onedarkpro.nvim";
-    version = "2022-09-29";
+    version = "2022-10-04";
     src = fetchFromGitHub {
       owner = "olimorris";
       repo = "onedarkpro.nvim";
-      rev = "a8cac3f8634edf16fb0fa855329b48ef3a8eea8d";
-      sha256 = "1siwvam38mlcazv6kq1qvrc7rkxs817zah4pkk0107821z38hpyr";
+      rev = "11f6050c85e42d3f24bafd42ea20c4ab5540266f";
+      sha256 = "0iq5ajrfs1iqxnd4x1hm1d0321czvqbkfrig796ih3qcnglhn26s";
     };
     meta.homepage = "https://github.com/olimorris/onedarkpro.nvim/";
   };
···
 
   orgmode = buildVimPluginFrom2Nix {
     pname = "orgmode";
-    version = "2022-09-29";
+    version = "2022-10-04";
     src = fetchFromGitHub {
       owner = "nvim-orgmode";
       repo = "orgmode";
-      rev = "95f927355d4c275a9aad1e7fcc576cdb59f42d60";
-      sha256 = "197ijymf7ad36zpk9d62nm4nb54d4n1ai17yimx7ji2a2z0qc845";
+      rev = "017570f58c6316982ecc6ddfe6fefd28b55a4092";
+      sha256 = "0bbvdraxslg8k2m2ldglmspaawrrrp3plglzri7hm8scnw7mz58n";
     };
     meta.homepage = "https://github.com/nvim-orgmode/orgmode/";
   };
···
 
   registers-nvim = buildVimPluginFrom2Nix {
     pname = "registers.nvim";
-    version = "2022-10-02";
+    version = "2022-10-03";
     src = fetchFromGitHub {
       owner = "tversteeg";
       repo = "registers.nvim";
-      rev = "d155742d5727373be0b484e87a0635348bbe2895";
-      sha256 = "047c1nirs4qldxikx70dgchb8clmqac8255hbwrcydlbqrv6b66y";
+      rev = "29af8cd89822d4eeadbd3410bcb0c6ae1ce83307";
+      sha256 = "06xilrcsya49p59bnyg1958ipa2avzjavnih9md0h89ks3k93rs7";
     };
     meta.homepage = "https://github.com/tversteeg/registers.nvim/";
   };
···
 
   tokyonight-nvim = buildVimPluginFrom2Nix {
     pname = "tokyonight.nvim";
-    version = "2022-10-02";
+    version = "2022-10-04";
     src = fetchFromGitHub {
       owner = "folke";
       repo = "tokyonight.nvim";
-      rev = "66bfc2e8f754869c7b651f3f47a2ee56ae557764";
-      sha256 = "1ld3cddnp7hl2zv86b2y2b2fjb3pivq3vlfn2mmnyy5vgflpq0w5";
+      rev = "d6a0adfe3f914efa06ca6e662f0b1398f3522783";
+      sha256 = "0d7ps1cya20i32d19qy93ycjwb57w2kid5wg2scg88kdi4g46q4v";
     };
     meta.homepage = "https://github.com/folke/tokyonight.nvim/";
   };
···
 
   vim-clap = buildVimPluginFrom2Nix {
     pname = "vim-clap";
-    version = "2022-10-01";
+    version = "2022-10-04";
     src = fetchFromGitHub {
       owner = "liuchengxu";
       repo = "vim-clap";
-      rev = "dc7089bef1e9759a219dc7df7efe39053f20fad3";
-      sha256 = "1brkxd0yjrpkv9wzd42dzg5xqy3xifd7590f27lqjz2z0fymzgcy";
+      rev = "e2df4b83764f816d517563229b0f1c48d2610b3f";
+      sha256 = "13iy41x595nw5k8xd93v04xdbvnsx5s254v1mh5ima300abmx27w";
     };
     meta.homepage = "https://github.com/liuchengxu/vim-clap/";
   };
···
 
   vim-illuminate = buildVimPluginFrom2Nix {
     pname = "vim-illuminate";
-    version = "2022-09-21";
+    version = "2022-10-04";
     src = fetchFromGitHub {
       owner = "RRethy";
       repo = "vim-illuminate";
-      rev = "a2e8476af3f3e993bb0d6477438aad3096512e42";
-      sha256 = "1wk0gxvljzl6c0vrwb99mvxj755ck1c6jhvn16r1d68kva1f0nkj";
+      rev = "0603e75fc4ecde1ee5a1b2fc8106ed6704f34d14";
+      sha256 = "01361ss6g7kcap7hjma9ij8xa75zlvy878s4p7r5sxxbdwwpqarg";
     };
     meta.homepage = "https://github.com/RRethy/vim-illuminate/";
   };
···
 
   vim-sexp-mappings-for-regular-people = buildVimPluginFrom2Nix {
     pname = "vim-sexp-mappings-for-regular-people";
-    version = "2020-01-16";
+    version = "2022-10-04";
     src = fetchFromGitHub {
       owner = "tpope";
       repo = "vim-sexp-mappings-for-regular-people";
-      rev = "7c3de2f13422fb4b62b4c34a660532c7b3d240c7";
-      sha256 = "0malswal9hnbq2wf1rx2lp1r69wpwsvyhgi46xbg079x2n857bmj";
+      rev = "ffe645ff61e22d0b7c282d53b8745be4298104e6";
+      sha256 = "1g0zi26lppgp35f9q12484c00q7yj58d7wrpfs57v4six02292dc";
     };
     meta.homepage = "https://github.com/tpope/vim-sexp-mappings-for-regular-people/";
   };
···
 
   vim-tpipeline = buildVimPluginFrom2Nix {
     pname = "vim-tpipeline";
-    version = "2022-09-26";
+    version = "2022-10-03";
     src = fetchFromGitHub {
       owner = "vimpostor";
       repo = "vim-tpipeline";
-      rev = "c9a050e10d95461e344f7908fdb5e2d93156601a";
-      sha256 = "1xz5ycnai7iy94xiq1xp1l1c66g0p39pndb09bkxmfxrdqi8pmyd";
+      rev = "5b9701c5b2c9d90a304f10aaf75c85cc91678d57";
+      sha256 = "09174syh0yd85xwc9kv8jv6h7zsd5ds8hrvzk7qryacb95vgv8mv";
     };
     meta.homepage = "https://github.com/vimpostor/vim-tpipeline/";
   };
···
 
   vimtex = buildVimPluginFrom2Nix {
     pname = "vimtex";
-    version = "2022-09-29";
+    version = "2022-10-03";
     src = fetchFromGitHub {
       owner = "lervag";
       repo = "vimtex";
-      rev = "54fd9f5ba70ba907e683a42e2b1903133a98dd60";
-      sha256 = "04ksc7kw8w84ck7j1v7j16f0n85g6sv66cv4k6v8wdr3zm544zhl";
+      rev = "06ae45a2aa9fdee5d479b2ccd1be145d225852e2";
+      sha256 = "086qima9v821raw2mbm3wxkfj5l58mwwlbgjnnx5sz9msw7qg7dc";
     };
     meta.homepage = "https://github.com/lervag/vimtex/";
   };
···
 
   chad = buildVimPluginFrom2Nix {
     pname = "chad";
-    version = "2022-10-02";
+    version = "2022-10-04";
     src = fetchFromGitHub {
       owner = "ms-jpq";
       repo = "chadtree";
-      rev = "f58e1b82cf3c2f2b89d9f9c41a9fa3215880ad5c";
-      sha256 = "02dzhfwmvqrkj19cgsinbvzdha6w1nw287dr0b1r6j5i5aqkqapa";
+      rev = "588c7e471f80666a3796cd432b192182238181c5";
+      sha256 = "1sig0gpgdj7qgpd889h5iabmz8x33niyd0jqfspsbw256vy6mki0";
     };
     meta.homepage = "https://github.com/ms-jpq/chadtree/";
   };
···
 
   rose-pine = buildVimPluginFrom2Nix {
     pname = "rose-pine";
-    version = "2022-09-20";
+    version = "2022-10-03";
     src = fetchFromGitHub {
       owner = "rose-pine";
       repo = "neovim";
-      rev = "3723a16f99955ab274777cc27323b75f2515420f";
-      sha256 = "1mx6vkii6rhi7lv5l50kc7rqmi9rxvhw9bm7i8450d0258c987ak";
+      rev = "69dca24ba7f8e74f1e6f0bacbc93481ac4047f2e";
+      sha256 = "1n6q7h53zbbybyi219hamagpycasvnnxjgvifsdrxw7825zdnlsy";
     };
     meta.homepage = "https://github.com/rose-pine/neovim/";
   };

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

···
     dependencies = with self; [ plenary-nvim ];
   });
 
+  noice-nvim = super.noice-nvim.overrideAttrs(old: {
+    dependencies = with self; [ nui-nvim nvim-notify ];
+  });
+
   null-ls-nvim = super.null-ls-nvim.overrideAttrs (old: {
     dependencies = with self; [ plenary-nvim ];
   });

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

···
 https://github.com/zah/nim.vim/,,
 https://github.com/tjdevries/nlua.nvim/,,
 https://github.com/mcchrish/nnn.vim/,,
+https://github.com/folke/noice.nvim/,HEAD,
 https://github.com/arcticicestudio/nord-vim/,,
 https://github.com/shaunsingh/nord.nvim/,,
 https://github.com/andersevenrud/nordic.nvim/,,

pkgs/applications/science/chemistry/jmol/default.nix

···
   };
 in
 stdenv.mkDerivation rec {
-  version = "14.32.75";
+  version = "14.32.76";
   pname = "jmol";
 
   src = let
     baseVersion = "${lib.versions.major version}.${lib.versions.minor version}";
   in fetchurl {
     url = "mirror://sourceforge/jmol/Jmol/Version%20${baseVersion}/Jmol%20${version}/Jmol-${version}-binary.tar.gz";
-    sha256 = "sha256-2D2WBrBmmA84RVLsICFMeQKLvv5nIekbS/EGlmlvtYQ=";
+    sha256 = "sha256-KdQZKiAJFKE2PW0/DdZGIOC8QQ1icQR+TY4hoXCQdxg=";
   };
 
   patchPhase = ''

pkgs/data/fonts/libertine/default.nix

···
 { lib, stdenv, fetchurl, fontforge }:
 
 stdenv.mkDerivation {
-  name = "linux-libertine-5.3.0";
+  pname = "linux-libertine";
+  version = "5.3.0";
 
   src = fetchurl {
     url = "mirror://sourceforge/linuxlibertine/5.3.0/LinLibertineSRC_5.3.0_2012_07_02.tgz";
-    sha256 = "0x7cz6hvhpil1rh03rax9zsfzm54bh7r4bbrq8rz673gl9h47v0v";
+    hash = "sha256-G+xDYKJvHPMzwnktkg9cpNTv9E9d5QFgDjReuKH57HQ=";
   };
 
   sourceRoot = ".";
 
   nativeBuildInputs = [ fontforge ];
+
+  dontConfigure = true;
 
   buildPhase = ''
+    runHook preBuild
     for i in *.sfd; do
       fontforge -lang=ff -c \
         'Open($1);
···
         Generate($1:r + ".enc");
         ' $i;
     done
+    runHook postBuild
   '';
 
   installPhase = ''
+    runHook preInstall
     install -m444 -Dt $out/share/fonts/opentype/public *.otf
     install -m444 -Dt $out/share/fonts/truetype/public *.ttf
     install -m444 -Dt $out/share/fonts/type1/public    *.pfb
     install -m444 -Dt $out/share/texmf/fonts/enc       *.enc
     install -m444 -Dt $out/share/texmf/fonts/map       *.map
+    runHook postInstall
   '';
 
   meta = with lib; {
     description = "Linux Libertine Fonts";
     homepage = "http://linuxlibertine.sf.net";
-    maintainers = [ ];
+    maintainers = with maintainers; [ erdnaxe ];
     license = licenses.ofl;
   };
 }

pkgs/data/fonts/proggyfonts/default.nix

···
 { lib, stdenv, fetchurl, mkfontscale }:
 
-stdenv.mkDerivation {
-  name = "proggyfonts-0.1";
+stdenv.mkDerivation rec {
+  pname = "proggyfonts";
+  version = "0.1";
 
   src = fetchurl {
-    url = "https://web.archive.org/web/20150801042353/http://kaictl.net/software/proggyfonts-0.1.tar.gz";
-    sha256 = "1plcm1sjpa3hdqhhin48fq6zmz3ndm4md72916hd8ff0w6596q0n";
+    url = "https://web.archive.org/web/20150801042353/http://kaictl.net/software/proggyfonts-${version}.tar.gz";
+    hash = "sha256-SsLzZdR5icVJNbr5rcCPbagPPtWghbqs2Jxmrtufsa4=";
   };
 
   nativeBuildInputs = [ mkfontscale ];
 
-  installPhase =
-    ''
-      # compress pcf fonts
-      mkdir -p $out/share/fonts/misc
-      rm Speedy.pcf # duplicated as Speedy11.pcf
-      for f in *.pcf; do
-        gzip -n -9 -c "$f" > $out/share/fonts/misc/"$f".gz
-      done
+  dontConfigure = true;
+  dontBuild = true;
+
+  installPhase = ''
+    runHook preInstall
+
+    # compress pcf fonts
+    mkdir -p $out/share/fonts/misc
+    rm Speedy.pcf # duplicated as Speedy11.pcf
+    for f in *.pcf; do
+      gzip -n -9 -c "$f" > $out/share/fonts/misc/"$f".gz
+    done
 
-      install -D -m 644 *.bdf -t "$out/share/fonts/misc"
-      install -D -m 644 *.ttf -t "$out/share/fonts/truetype"
-      install -D -m 644 Licence.txt -t "$out/share/doc/$name"
+    install -D -m 644 *.bdf -t "$out/share/fonts/misc"
+    install -D -m 644 *.ttf -t "$out/share/fonts/truetype"
+    install -D -m 644 Licence.txt -t "$out/share/doc/$name"
 
-      mkfontscale "$out/share/fonts/truetype"
-      mkfontdir   "$out/share/fonts/misc"
-    '';
+    mkfontscale "$out/share/fonts/truetype"
+    mkfontdir   "$out/share/fonts/misc"
 
-  outputHashAlgo = "sha256";
-  outputHashMode = "recursive";
-  outputHash = "1x196rp3wqjd7m57bgp5kfy5jmj97qncxi1vwibs925ji7dqzfgf";
+    runHook postInstall
+  '';
 
   meta = with lib; {
-    homepage = "http://upperbounds.net";
+    homepage = "http://www.upperbounds.net";
     description = "A set of fixed-width screen fonts that are designed for code listings";
     license = licenses.mit;
     platforms = platforms.all;

pkgs/data/misc/hackage/pin.json

···
 {
-  "commit": "7cabb43eb4c2b1e025cae32532e7c4a9dcc6b349",
-  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/7cabb43eb4c2b1e025cae32532e7c4a9dcc6b349.tar.gz",
-  "sha256": "0zlqb1s7cyrnl2dmasv2h8lbjxmb27vzlac2adkcnd9r0zfgxl1p",
-  "msg": "Update from Hackage at 2022-09-28T11:00:39Z"
+  "commit": "3f8bc936ca1b36ede05f3cec8166c6ae6c61808d",
+  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/3f8bc936ca1b36ede05f3cec8166c6ae6c61808d.tar.gz",
+  "sha256": "0bjd6znvwipc8gd0s4bryjbcj29h1lryxc2cqy0xgy07b7dpz245",
+  "msg": "Update from Hackage at 2022-10-01T15:28:21Z"
 }

pkgs/data/themes/adw-gtk3/default.nix

···
 
 stdenvNoCC.mkDerivation rec {
   pname = "adw-gtk3";
-  version = "3.7";
+  version = "4.0";
 
   src = fetchFromGitHub {
     owner = "lassekongo83";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-hHmNRPUJOXa//aKgAYhGBVX6usRsObWbzcfOa1uwbqM=";
+    sha256 = "sha256-PR0MmTOXGrMicRLXqIOUpCVSu68HeCaG2z/o+lbHnjk=";
   };
 
   nativeBuildInputs = [

pkgs/development/compilers/dotnet/build-dotnet.nix

···
 
   installPhase = ''
     runHook preInstall
+
     mkdir -p $out/bin
     cp -r ./ $out
+
+    mkdir -p $out/share/doc/$pname/$version
+    mv $out/LICENSE.txt $out/share/doc/$pname/$version/
+    mv $out/ThirdPartyNotices.txt $out/share/doc/$pname/$version/
+
     ln -s $out/dotnet $out/bin/dotnet
+
     runHook postInstall
   '';
 

pkgs/development/coq-modules/category-theory/default.nix

···
   pname = "category-theory";
   owner = "jwiegley";
 
+  release."1.0.0".sha256 = "sha256-qPgho4/VcL3vyMPJAMXXdqhYPEbNeXSZsoWbA/lGek4=";
   release."20211213".rev    = "449e30e929d56f6f90c22af2c91ffcc4d79837be";
   release."20211213".sha256 = "sha256:0vgfmph5l1zn6j4b851rcm43s8y9r83swsz07rpzhmfg34pk0nl0";
   release."20210730".rev    = "d87937faaf7460bcd6985931ac36f551d67e11af";
···
 
   inherit version;
   defaultVersion = with versions; switch coq.coq-version [
+    { case = range "8.14" "8.16"; out = "1.0.0"; }
     { case = range "8.10" "8.15"; out = "20211213"; }
     { case = range "8.8" "8.9"; out = "20190414"; }
     { case = range "8.6" "8.7"; out = "20180709"; }

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

···
     url = "https://github.com/hackage-trustees/text-format/pull/4/commits/949383aa053497b8c251219c10506136c29b4d32.patch";
     sha256 = "QzpZ7lDedsz1mZcq6DL4x7LBnn58rx70+ZVvPh9shRo=";
   }) super.text-format;
+
+  # 2022-10-04: Needs newer tasty-dejafu than (currently) in stackage
+  rec-def = super.rec-def.override { tasty-dejafu = self.tasty-dejafu_2_1_0_0; };
 })

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

···
   # lens >= 5.1 supports 9.2.1
   lens = doDistribute self.lens_5_2;
 
-  # Syntax error in tests fixed in https://github.com/simonmar/alex/commit/84b29475e057ef744f32a94bc0d3954b84160760
-  alex = dontCheck super.alex;
-
   # Apply patches from head.hackage.
   language-haskell-extract = appendPatch (pkgs.fetchpatch {
     url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/dfd024c9a336c752288ec35879017a43bd7e85a0/patches/language-haskell-extract-0.2.4.patch";

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

···
 
 let
   inherit (pkgs) fetchpatch lib;
-  inherit (lib) throwIfNot versionOlder;
+  checkAgainAfter = pkg: ver: msg: act:
+    if builtins.compareVersions pkg.version ver <= 0 then act
+    else
+      builtins.throw "Check if '${msg}' was resolved in ${pkg.pname} ${pkg.version} and update or remove this";
 in
 
-self: super: {
+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;
 
   # Disable GHC core libraries.
···
   # GHC only bundles the xhtml library if haddock is enabled, check if this is
   # still the case when updating: https://gitlab.haskell.org/ghc/ghc/-/blob/0198841877f6f04269d6050892b98b5c3807ce4c/ghc.mk#L463
   xhtml = if self.ghc.hasHaddock or true then null else self.xhtml_3000_2_2_1;
+
+  # Tests fail because of typechecking changes
+  conduit = dontCheck super.conduit;
+
+  # 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 = dontCheck super.cabal2nix;
+  cabal2nix-unstable = dontCheck super.cabal2nix-unstable;
+
+  # 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;
+  # 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);
+  ghc-source-gen = checkAgainAfter super.ghc-source-gen "0.4.3.0" "fails to build" (markBroken super.ghc-source-gen);
+
+  lucid = jailbreakForCurrentVersion super.lucid "2.11.1";
+  invariant = jailbreakForCurrentVersion super.invariant "0.5.6";
+  implicit-hie-cradle = jailbreakForCurrentVersion super.implicit-hie-cradle "0.5.0.0";
+
+  haskell-src-meta = doJailbreak super.haskell-src-meta;
+
+  # Tests fail in GHC 9.2
+  extra = dontCheck super.extra;
+
+  # 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;
+  async = doJailbreak super.async;
+  base64-bytestring = doJailbreak super.base64-bytestring;
+  base-compat = self.base-compat_0_12_2;
+  base-compat-batteries = self.base-compat-batteries_0_12_2;
+  binary-instances = doJailbreak super.binary-instances;
+  ChasingBottoms = doJailbreak super.ChasingBottoms;
+  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;
+  dec = doJailbreak super.dec;
+  ed25519 = doJailbreak super.ed25519;
+  ghc-byteorder = doJailbreak super.ghc-byteorder;
+  ghc-lib = doDistribute self.ghc-lib_9_4_2_20220822;
+  ghc-lib-parser = doDistribute self.ghc-lib-parser_9_4_2_20220822;
+  ghc-lib-parser-ex = doDistribute self.ghc-lib-parser-ex_9_4_0_0;
+  hackage-security = doJailbreak super.hackage-security;
+  hashable = super.hashable_1_4_1_0;
+  hashable-time = doJailbreak super.hashable-time;
+  HTTP = overrideCabal (drv: { postPatch = "sed -i -e 's,! Socket,!Socket,' Network/TCP.hs"; }) (doJailbreak super.HTTP);
+  integer-logarithms = overrideCabal (drv: { postPatch = "sed -i -e 's, <1.1, <1.3,' integer-logarithms.cabal"; }) (doJailbreak super.integer-logarithms);
+  indexed-traversable = doJailbreak super.indexed-traversable;
+  indexed-traversable-instances = doJailbreak super.indexed-traversable-instances;
+  lifted-async = doJailbreak super.lifted-async;
+  lukko = doJailbreak super.lukko;
+  lzma-conduit = doJailbreak super.lzma-conduit;
+  parallel = doJailbreak super.parallel;
+  path = doJailbreak super.path;
+  polyparse = overrideCabal (drv: { postPatch = "sed -i -e 's, <0.11, <0.12,' polyparse.cabal"; }) (doJailbreak super.polyparse);
+  primitive = dontCheck (doJailbreak self.primitive_0_7_4_0);
+  regex-posix = doJailbreak super.regex-posix;
+  resolv = doJailbreak super.resolv;
+  singleton-bool = doJailbreak super.singleton-bool;
+
+  # 2022-09-02: Too strict bounds on lens
+  # https://github.com/GetShopTV/swagger2/pull/242
+  swagger2 = doctest_0_20_broken (dontCheck (doJailbreak super.swagger2));
+
+  base-orphans = dontCheck super.base-orphans;
+
+  # Note: Any compilation fixes need to be done on the versioned attributes,
+  # since those are used for the internal dependencies between the versioned
+  # hspec packages in configuration-common.nix.
+  hspec = self.hspec_2_10_6;
+  hspec-core = self.hspec-core_2_10_6;
+  hspec-meta = self.hspec-meta_2_10_5;
+  hspec-discover = self.hspec-discover_2_10_6;
+
+  # the dontHaddock is due to a GHC panic. might be this bug, not sure.
+  # https://gitlab.haskell.org/ghc/ghc/-/issues/21619
+  #
+  # We need >= 1.1.2 for ghc-9.4 support, but we don't have 1.1.x in
+  # hackage-packages.nix
+  hedgehog = doDistribute (dontHaddock super.hedgehog_1_2);
+  # does not work with hedgehog 1.2 yet:
+  # https://github.com/qfpl/tasty-hedgehog/pull/63
+  tasty-hedgehog = markBroken super.tasty-hedgehog;
+  # due to tasty-hedgehog
+  retry = checkAgainAfter super.tasty-hedgehog "1.3.0.0" "tasty-hedgehog broken" (dontCheck super.retry);
+
+  # https://github.com/dreixel/syb/issues/38
+  syb = dontCheck super.syb;
+
+  splitmix = doJailbreak super.splitmix;
+  th-desugar = self.th-desugar_1_14;
+  time-compat = doJailbreak super.time-compat;
+  tomland = doJailbreak super.tomland;
+  type-equality = doJailbreak super.type-equality;
+  unordered-containers = doJailbreak super.unordered-containers;
+  vector = dontCheck super.vector;
+  vector-binary-instances = doJailbreak super.vector-binary-instances;
+
+  # fixed in 1.16.x but it's not in hackage-packages yet.
+  rebase = jailbreakForCurrentVersion super.rebase "1.15.0.3";
+  rerebase = jailbreakForCurrentVersion super.rerebase "1.15.0.3";
+
+  hpack = overrideCabal (drv: {
+    # Cabal 3.6 seems to preserve comments when reading, which makes this test fail
+    # 2021-10-10: 9.2.1 is not yet supported (also no issue)
+    testFlags = [
+      "--skip=/Hpack/renderCabalFile/is inverse to readCabalFile/"
+    ] ++ drv.testFlags or [];
+  }) (doJailbreak super.hpack);
+
+  # lens >= 5.1 supports 9.2.1
+  lens = doDistribute self.lens_5_2;
+
+  # Apply patches from head.hackage.
+  language-haskell-extract = appendPatch (pkgs.fetchpatch {
+    url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/dfd024c9a336c752288ec35879017a43bd7e85a0/patches/language-haskell-extract-0.2.4.patch";
+    sha256 = "0w4y3v69nd3yafpml4gr23l94bdhbmx8xky48a59lckmz5x9fgxv";
+  }) (doJailbreak super.language-haskell-extract);
+
+  # Tests depend on `parseTime` which is no longer available
+  hourglass = dontCheck super.hourglass;
+
+  memory = super.memory_0_18_0;
+
+  # https://github.com/sjakobi/bsb-http-chunked/issues/38
+  bsb-http-chunked = dontCheck super.bsb-http-chunked;
+
+  # need bytestring >= 0.11 which is only bundled with GHC >= 9.2
+  regex-rure = doDistribute (markUnbroken super.regex-rure);
+  jacinda = doDistribute super.jacinda;
+  some = doJailbreak super.some;
+
+  # 1.3 introduced support for GHC 9.2.x, so when this assert fails, the jailbreak can be removed
+  hashtables = assert super.hashtables.version == "1.2.4.2"; doJailbreak super.hashtables;
+
+  # 2022-08-01: Tests are broken on ghc 9.2.4: https://github.com/wz1000/HieDb/issues/46
+  hiedb = dontCheck super.hiedb;
+
 }

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

···
   - bottom
   - boundingboxes
   - bowntz
+  - box
   - bpath
   - BPS
   - braid
···
   - platinum-parsing
   - PlayingCards
   - playlists
+  - plex
   - plist
   - plist-buddy
   - plivo
···
   - reanimate-svg
   - reasonable-lens
   - reason-export
-  - rec-def
   - record
   - record-encode
   - record-impl
···
   - sandman
   - sarasvati
   - sat
-  - satchmo
   - Saturnin
   - satyros
   - savage
···
   - singnal
   - singular-factory
   - sink
-  - sint
   - sitepipe
   - sixfiguregroup
   - sized-grid
···
   - tasty-mgolden
   - tasty-stats
   - tasty-test-vector
+  - TastyTLT
   - TBC
   - TBit
   - tcache-AWS
···
   - time-w3c
   - timezone-detect
   - tintin
+  - tinyid
   - TinyLaunchbury
   - tiny-scheduler
   - tinytemplate
···
   - web3-ipfs
   - webapi
   - webapp
-  - webauthn
   - WebBits
   - webcloud
   - webcrank

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

···
     - leb128-cereal
     - tasty-expected-failure
     - lhs2tex
+    - rec-def
   pacien:
     - ldgallery-compiler
   peti:

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

···
  - boots-cloud
  - boots-web
  - borel
+ - box-csv
+ - box-socket
  - breakout
  - bricks
  - bricks-internal-test
···
  - dep-t-advice
  - dep-t-dynamic
  - dep-t-value
- - dependent-literals
  - dependent-literals-plugin
  - dependent-state
  - depends
···
  - fallingblocks
  - family-tree
  - fast-bech32
+ - fastcdc
  - fastirc
  - fastly
  - fastparser
···
  - filepath-io-access
  - filesystem-abstractions
  - filesystem-enumerator
- - fin-int
  - find-clumpiness
  - findhttp
  - finitary-derive
···
  - gbu
  - gdax
  - gdiff-ig
+ - gearhash
  - gedcom
  - geek
  - geek-server
···
  - peparser
  - perdure
  - perf-analysis
- - perf_0_10_0
  - perfecthash
  - periodic-client
  - periodic-client-exe
···
  - pred-trie
  - prednote-test
  - prefork
+ - prelate
  - presto-hdbc
  - preview
  - primal-memory
···
  - rfc-redis
  - rfc-servant
  - rhythm-game-tutorial
+ - ribosome
+ - ribosome-app
+ - ribosome-host
+ - ribosome-host-test
  - ribosome-root
  - ridley-extras
  - rio-process-pool
···
  - sarsi
  - sasl
  - sat-micro-hs
- - satchmo-backends
- - satchmo-examples
  - satchmo-funsat
- - satchmo-minisat
  - satchmo-toysat
  - sauron
  - sc2-lowlevel

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

···
      }:
      mkDerivation {
        pname = "C-structs";
-       version = "0.2.0.2";
-       sha256 = "0v70j2wlhj91cmlc2247z7i3yak04b28ig093xaihawlqyb6hxjg";
+       version = "0.2.0.3";
+       sha256 = "0r6clyl3vycdpwy55c37zlz4yvvl2xjgxc1fn3vwal83jp7cm74a";
        libraryHaskellDepends = [ base template-haskell ];
        testHaskellDepends = [
          base doctest Glob HUnit QuickCheck template-haskell test-framework
···
      }:
      mkDerivation {
        pname = "ConClusion";
-       version = "0.2.0";
-       sha256 = "1nz7xax1llc0v775kx0g6hsrfbmgy1gj0pgalwpblqms1ccpy04s";
+       version = "0.2.1";
+       sha256 = "095ygqh0si6ahv41hjkwnwfxwkz16pgriwwnw0v53bvbryjqfvja";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "TLT";
-       version = "0.3.0.0";
-       sha256 = "0pl9ga3vr9yj4f4k2pisq8yarhbsbfvj9q3n24f0db8csq363yc5";
+       version = "0.5.0.0";
+       sha256 = "10hman41jgzkdllcps0yabbym08ar9xislxk2dpj5y4ad5ajcyqy";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        description = "Run TLT tests from Tasty";
        license = lib.licenses.lgpl3Only;
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "TLT-exe";
+       broken = true;
      }) {};
 
   "Taxonomy" = callPackage
···
        pname = "ValveValueKeyvalue";
        version = "1.1.0.0";
        sha256 = "1hcgyv5fhpqvccpplrpi192vlk8dh1ds3w455fy3yvz14g5rfvkp";
+       revision = "1";
+       editedCabalFile = "0zgmnnh5dlsxlrqprz4q47s29jr9mdmc0pmaaplkn1x8q8xcl43k";
        libraryHaskellDepends = [ base parsec ];
        description = "A Valve Value-keyvalue parser for Haskell made with Parsec";
        license = lib.licenses.mit;
···
     ({ mkDerivation, base, bytestring, transformers, vector, vulkan }:
      mkDerivation {
        pname = "VulkanMemoryAllocator";
-       version = "0.10.2";
-       sha256 = "122r9za1vlgkm03lbq8yvpngacinick88vs9dpizd80rb2z4dy6k";
+       version = "0.10.3.1";
+       sha256 = "1ncjrn2dcxpi8gykn0axi7wwi35frpp5wqvbm7zyd2pp2wfi2f3i";
        libraryHaskellDepends = [
          base bytestring transformers vector vulkan
        ];
···
   "aeson-match-qq" = callPackage
     ({ mkDerivation, aeson, aeson-qq, attoparsec, base, bytestring
      , case-insensitive, containers, either, haskell-src-meta, hspec
-     , scientific, template-haskell, text, unordered-containers, vector
+     , pretty, scientific, template-haskell, text, unordered-containers
+     , vector
      }:
      mkDerivation {
        pname = "aeson-match-qq";
-       version = "1.5.1";
-       sha256 = "1m2brw8c1i0p32llng904lb893vkjfcqbmljkcx5m7iab0hvpvaw";
+       version = "1.5.3";
+       sha256 = "0j4qddxxr0pfjz2d4hwvxdgmb4vb343ysw6g1fms4shdk41h1kz5";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring case-insensitive containers either
-         haskell-src-meta scientific template-haskell text
+         haskell-src-meta pretty scientific template-haskell text
          unordered-containers vector
        ];
        testHaskellDepends = [
···
      }) {};
 
   "box" = callPackage
-    ({ mkDerivation, base, concurrency, containers, contravariant
+    ({ mkDerivation, async, base, bytestring, containers, contravariant
      , dlist, exceptions, kan-extensions, mtl, profunctors
-     , semigroupoids, text, time, transformers
+     , semigroupoids, stm, text, time, transformers
      }:
      mkDerivation {
        pname = "box";
-       version = "0.8.1";
-       sha256 = "18f7waxmnrfk205aacwlzzv18bhyff9vpq3xcna955p9qgm47lg5";
+       version = "0.9.0";
+       sha256 = "1b4lbagj0pp19sms4q6p4gq27sf7yrzlcgcgl3zlmh3hh0wrrw14";
        libraryHaskellDepends = [
-         base concurrency containers contravariant dlist exceptions
-         kan-extensions mtl profunctors semigroupoids text time transformers
+         async base bytestring containers contravariant dlist exceptions
+         kan-extensions mtl profunctors semigroupoids stm text time
+         transformers
        ];
        description = "boxes";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "box-csv" = callPackage
···
        libraryHaskellDepends = [ attoparsec base box text time ];
        description = "CSV parsing in a box";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "box-socket" = callPackage
-    ({ mkDerivation, async, base, box, bytestring, concurrency
-     , exceptions, network, network-simple, optparse-generic, text
-     , websockets
+    ({ mkDerivation, async, base, box, bytestring, exceptions, network
+     , network-simple, optparse-generic, text, websockets
      }:
      mkDerivation {
        pname = "box-socket";
-       version = "0.3.0";
-       sha256 = "1z9qlmpbq2ppc13viyf0sha95d7cm0jswnabjvg5fvx9ln1c5ivp";
+       version = "0.4.0";
+       sha256 = "0svbqs00db6kvd81b5zk7k6v7fmy12c11d933z12zsslxp8ncp91";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         async base box bytestring concurrency exceptions network
-         network-simple text websockets
+         async base box bytestring exceptions network network-simple text
+         websockets
        ];
        executableHaskellDepends = [ base optparse-generic ];
        description = "Box websockets";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "box-socket";
      }) {};
 
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "brick_1_2" = callPackage
+  "brick_1_3" = callPackage
     ({ mkDerivation, base, bimap, bytestring, config-ini, containers
-     , contravariant, data-clist, deepseq, directory, dlist, exceptions
+     , contravariant, data-clist, deepseq, directory, exceptions
      , filepath, microlens, microlens-mtl, microlens-th, mtl, QuickCheck
      , stm, template-haskell, text, text-zipper, unix, vector, vty
      , word-wrap
      }:
      mkDerivation {
        pname = "brick";
-       version = "1.2";
-       sha256 = "1gz42k0wb4adff3ddjfgc6jp3b5zrp8bg4jwksih6mbn6124zpyf";
+       version = "1.3";
+       sha256 = "0lpd6685ya0va0a6n7cw70f5b1s13y8ynzac0gkxyqb1ivzj0hsb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          base bimap bytestring config-ini containers contravariant
-         data-clist deepseq directory dlist exceptions filepath microlens
+         data-clist deepseq directory exceptions filepath microlens
          microlens-mtl microlens-th mtl stm template-haskell text
          text-zipper unix vector vty word-wrap
        ];
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "commonmark-extensions_0_2_3_3" = callPackage
+    ({ mkDerivation, base, commonmark, containers, emojis, filepath
+     , network-uri, parsec, tasty, tasty-bench, tasty-hunit, text
+     , transformers
+     }:
+     mkDerivation {
+       pname = "commonmark-extensions";
+       version = "0.2.3.3";
+       sha256 = "009yrsb2xxna73q6nnijfx5ngffaz369mildvqvn91qbrkrzq7pl";
+       libraryHaskellDepends = [
+         base commonmark containers emojis filepath network-uri parsec text
+         transformers
+       ];
+       testHaskellDepends = [
+         base commonmark parsec tasty tasty-hunit text
+       ];
+       benchmarkHaskellDepends = [ base commonmark tasty-bench text ];
+       description = "Pure Haskell commonmark parser";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "commonmark-pandoc" = callPackage
     ({ mkDerivation, base, commonmark, commonmark-extensions
      , pandoc-types, text
···
        ];
        description = "Library for dependent-literals-plugin";
        license = lib.licenses.asl20;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "dependent-literals-plugin" = callPackage
···
      }:
      mkDerivation {
        pname = "elsa";
-       version = "0.2.1.2";
-       sha256 = "0qg80wck4zsia9fsih06283c47f3waiskgj1r5s0s4fms9rwg06y";
+       version = "0.2.2.0";
+       sha256 = "0389g6i5jkwlh218ywlysvadm4qqsk1kz4manjsz7xwnmz3m7jlm";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        broken = true;
      }) {};
 
+  "eventuo11y" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, exceptions, resourcet
+     , text, time, unliftio-core, uuid
+     }:
+     mkDerivation {
+       pname = "eventuo11y";
+       version = "0.1.0.1";
+       sha256 = "1mrjmyn2dscn05n6il1h0n09kim1mihh9v6jimvipsfbm4kjxsb9";
+       libraryHaskellDepends = [
+         aeson base bytestring exceptions resourcet text time unliftio-core
+         uuid
+       ];
+       description = "An event-oriented observability library";
+       license = lib.licenses.asl20;
+     }) {};
+
+  "eventuo11y-batteries" = callPackage
+    ({ mkDerivation, aeson, async, 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
+     , unliftio-core, wai, warp
+     }:
+     mkDerivation {
+       pname = "eventuo11y-batteries";
+       version = "0.1.0.1";
+       sha256 = "135976nic8ficph20dani0m4clsv361324jwmhw8hywrla56mz36";
+       libraryHaskellDepends = [
+         aeson async 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 unliftio-core wai warp
+       ];
+       description = "Grab bag of eventuo11y-enriched functionality";
+       license = lib.licenses.asl20;
+     }) {};
+
   "every" = callPackage
     ({ mkDerivation, async, base, stm }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "exon";
-       version = "1.0.1.0";
-       sha256 = "17yfbj1hc2vm1vgsz3nngj06i67w6m0nzq1hm40n4q9w9fzaspvv";
+       version = "1.2.0.0";
+       sha256 = "1cayih5rp386cn1ig5g7flxjfh47451h095zx4av4i0c72j6q7s1";
        libraryHaskellDepends = [
          base flatparse generics-sop ghc-hs-meta incipit-base
          template-haskell type-errors-pretty
···
        broken = true;
      }) {};
 
+  "fastcdc" = callPackage
+    ({ mkDerivation, base, bv-little, bytestring, conduit, gearhash }:
+     mkDerivation {
+       pname = "fastcdc";
+       version = "0.0.0";
+       sha256 = "1rq2z5nf24za6a23bc75lsy96ab65xlhk2wr5lvvwsa24pr2miz5";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bv-little bytestring conduit gearhash
+       ];
+       executableHaskellDepends = [
+         base bv-little bytestring conduit gearhash
+       ];
+       description = "An implementation of FastCDC, a content-defined chunking algorithm based on the Gear hash rolling hash algorithm";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "fastcdc";
+     }) {};
+
   "fastcgi" = callPackage
     ({ mkDerivation, base, bytestring, cgi, fcgi }:
      mkDerivation {
···
        ];
        description = "Finite sets of static size";
        license = lib.licenses.asl20;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "final" = callPackage
···
        mainProgram = "gearbox";
      }) {};
 
+  "gearhash" = callPackage
+    ({ mkDerivation, array, base, bv-little, bytestring, conduit
+     , cryptonite, mtl, template-haskell, th-lift-instances
+     }:
+     mkDerivation {
+       pname = "gearhash";
+       version = "1.0.0";
+       sha256 = "1cwyl8pn1hq7gphg752qdc45x8vhcc0cnv2z26ymwyw8gw9p09xw";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         array base bv-little bytestring conduit cryptonite mtl
+         template-haskell th-lift-instances
+       ];
+       executableHaskellDepends = [
+         array base bv-little bytestring conduit cryptonite mtl
+         template-haskell th-lift-instances
+       ];
+       description = "An implementation of Gear hash, a fast rolling hash algorithm";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "gedcom" = callPackage
     ({ mkDerivation, array, base, bytestring, containers, hspec
      , megaparsec, monad-loops, mtl, text-all, time
···
      }:
      mkDerivation {
        pname = "gopro-plus";
-       version = "0.6.5.1";
-       sha256 = "06sasqagh4xa6gkhgjxf7jpvwfp9q27r0qnpr7rq0dxwsbrpqgnp";
+       version = "0.6.5.2";
+       sha256 = "0wxgwgsybc9vp4v4vx6064zh27kc3gn6rfclgpfavgvk3l9y5mrq";
        libraryHaskellDepends = [
          aeson base bytestring containers exceptions filepath
          generic-deriving generic-random lens lens-aeson monad-logger mtl
···
        pname = "graphviz";
        version = "2999.20.1.0";
        sha256 = "0l0zxgb938hh09qirggbaskq79mgj3s081cnr42y5vm1rp1jir2s";
-       revision = "1";
-       editedCabalFile = "1i0ayvs8iaq5vg38ximc23w1f1qvgmwmn5znqkjsrb96x0ssmdiw";
+       revision = "2";
+       editedCabalFile = "110yp1h2jrswllnx2ks772g10v9h4vqxc07b33wfaksyim9769bp";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "gridtables";
-       version = "0.0.3.0";
-       sha256 = "1akix9flnax6dx3s9c7yyzb19nw13y8rmh0kz7y3hpjlkaz659xy";
-       revision = "1";
-       editedCabalFile = "0m2651z81n8s6hb8id7y6k2kprsgwnj7pcd6p8lmdpkzzz3wwd0c";
+       version = "0.1.0.0";
+       sha256 = "1smhbb2jxysbqhxww5rikjfnhsdbf0gq3kgnn6ikjzcrqwdk9b6n";
        libraryHaskellDepends = [
          array base containers doclayout parsec text
        ];
···
      }:
      mkDerivation {
     ({ mkDerivation, base, old-time }:
-       version = "0.2.2.0";
-    ({ mkDerivation, base, old-time }:
+       version = "0.2.2.1";
+       sha256 = "0ni9z93k89nsswzs4xmb78l7cq7142mg841b70lxgbf69i1wd8z8";
        libraryHaskellDepends = [ base bytestring ];
        librarySystemDepends = [ openssl ];
        testHaskellDepends = [
···
 
   "mealy" = callPackage
     ({ mkDerivation, adjunctions, base, containers, mwc-probability
-     , numhask, optics-core, primitive, profunctors, tdigest, text
-     , vector, vector-algorithms
+     , numhask, numhask-array, optics-core, primitive, profunctors
+     , tdigest, text, vector, vector-algorithms
      }:
      mkDerivation {
        pname = "mealy";
-       version = "0.3.0";
-       sha256 = "15p60a4kywazy5dlcs66bzyq8phcrpkrfl655p22bnqq1lsl7yjh";
+       version = "0.4.0";
+       sha256 = "06pl768xlg0jiqjs1m79zhdqk29sdh1jmcywdn7whq1sxwc5hlhn";
        libraryHaskellDepends = [
-         adjunctions base containers mwc-probability numhask optics-core
-         primitive profunctors tdigest text vector vector-algorithms
+         adjunctions base containers mwc-probability numhask numhask-array
+         optics-core primitive profunctors tdigest text vector
+         vector-algorithms
        ];
        description = "Mealy machines for processing time-series and ordered data";
        license = lib.licenses.bsd3;
···
        pname = "mmark-cli";
        version = "0.0.5.1";
        sha256 = "1an1rc7gdl2209d3agxx1dfl61zsc2wg5nx9cwdf50spmlgs3cr0";
-       revision = "1";
-       editedCabalFile = "0x4lpxga127f37z43w4rgccw9w05j23ppy7k19kz6gh3p43gnx1m";
+       revision = "2";
+       editedCabalFile = "1raxvhsv3b3lni4d2fqf9b1rs7lsqha13baizpg9hv7w0f8zss8m";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        pname = "mmark-ext";
        version = "0.2.1.5";
        sha256 = "1dy3xnzpbbnp03k3r04q8y10pcj2r708dk8bff0pxzkvypm75g88";
-       revision = "1";
-       editedCabalFile = "1bfsbcxz0bvnhjcrismzkpaza8qn8g7hwswdb0gzyqj1hv6yv1nx";
+       revision = "2";
+       editedCabalFile = "0kz0389rrjd4wy6a5m89w7a4pcd4765kah7rwa7i649l8h5a5asm";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base foldl ghc-syntax-highlighter lucid microlens mmark modern-uri
···
      }) {};
 
   "morpheus-graphql" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, containers
+    ({ mkDerivation, aeson, base, bytestring, containers, file-embed
      , morpheus-graphql-app, morpheus-graphql-code-gen
      , morpheus-graphql-core, morpheus-graphql-subscriptions
      , morpheus-graphql-tests, mtl, relude, tasty, tasty-hunit
···
      }:
      mkDerivation {
        pname = "morpheus-graphql";
-       version = "0.20.1";
-       sha256 = "0y1c43010spp70z2srfmln1nd7r286b8nprq851f2zgp0g3lbkfi";
+       version = "0.21.0";
+       sha256 = "1xvhrgjdfxqn8ck75b3hpgj12i4y94fkcp0gr7bvyh3cbhrbycnk";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base bytestring containers morpheus-graphql-app
···
          template-haskell text transformers unordered-containers vector
        ];
        testHaskellDepends = [
-         aeson base bytestring containers morpheus-graphql-app
+         aeson base bytestring containers file-embed 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
···
      }:
      mkDerivation {
        pname = "morpheus-graphql-app";
-       version = "0.20.1";
-       sha256 = "0dc84pswgjl401nqx3127zn2r43a1n9kmhwx4xqy5l1favm1lfv0";
+       version = "0.21.0";
+       sha256 = "041a6rdbvs9g5ia384qgyppdkyq71xrlcqwz8szyyw2ra97sy0pg";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base bytestring containers hashable megaparsec
···
 
   "morpheus-graphql-client" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, directory
-     , file-embed, morpheus-graphql-code-gen, morpheus-graphql-core, mtl
-     , relude, tasty, tasty-hunit, template-haskell, text, transformers
-     , unordered-containers
+     , 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, unordered-containers, websockets
+     , wuss
      }:
      mkDerivation {
        pname = "morpheus-graphql-client";
-       version = "0.20.1";
-       sha256 = "0r2qp9nin5hlk1adflgn6s2x831d3g6y5d1pvdiahgjbn0mm580w";
+       version = "0.21.0";
+       sha256 = "1mn520aj62i9spby3ik0ynmjbj6baw6hmc3lcv4zp2v1ywypycci";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
-         aeson base bytestring containers file-embed
-         morpheus-graphql-code-gen morpheus-graphql-core mtl relude
-         template-haskell text transformers unordered-containers
+         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
        ];
        testHaskellDepends = [
-         aeson base bytestring containers directory file-embed
-         morpheus-graphql-code-gen morpheus-graphql-core mtl relude tasty
-         tasty-hunit template-haskell text transformers unordered-containers
+         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
+         unordered-containers websockets wuss
        ];
        description = "Morpheus GraphQL Client";
        license = lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "morpheus-graphql-code-gen";
-       version = "0.20.1";
-       sha256 = "08hzxxvnbrqnkhaahh5npjy637pjkhcf8dnh2zswq1c2pmyaw10s";
+       version = "0.21.0";
+       sha256 = "17z3zyk47pfs94i9lxjylxmx5c2m38nkhs4g3pf9qn129czjb48y";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "morpheus-graphql-core";
-       version = "0.20.1";
-       sha256 = "0rinp9zkdls07lr0606jxxijybq89xwxl6vgkx9wgfkrcd014wng";
+       version = "0.21.0";
+       sha256 = "1p5cirgqiv73ka0k4rb7dwky57dwj7nr0vpr6frfgvjsnmpbqq0s";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base bytestring containers hashable megaparsec mtl relude
···
      }:
      mkDerivation {
        pname = "morpheus-graphql-subscriptions";
-       version = "0.20.1";
-       sha256 = "1wad97zjw8766920q26069qb1fi4w25i9pxibkadvc42j4vzkv0p";
+       version = "0.21.0";
+       sha256 = "0qf1jw8lgjph0is7irbj07f4dina9aqznzr18wp9gwywxn0mzvgi";
        libraryHaskellDepends = [
          aeson base bytestring morpheus-graphql-app morpheus-graphql-core
          mtl relude text transformers unliftio-core unordered-containers
···
        license = lib.licenses.mit;
      }) {};
 
-  "morpheus-graphql-tests_0_20_1" = callPackage
+  "morpheus-graphql-tests_0_21_0" = callPackage
     ({ mkDerivation, aeson, base, bytestring, directory, relude, tasty
      , tasty-hunit, text, unordered-containers
      }:
      mkDerivation {
        pname = "morpheus-graphql-tests";
-       version = "0.20.1";
-       sha256 = "1z977hyf1hsaal45m4jh938q3srw3kh75xhgb9m0zrph085wzr7f";
+       version = "0.21.0";
+       sha256 = "13xf8q7p32c549bih2133lcsikspnv4ay6c7bcm433dwvxf13rcm";
        libraryHaskellDepends = [
          aeson base bytestring directory relude tasty tasty-hunit text
          unordered-containers
···
        pname = "numeric-logarithms";
        version = "0.1.0.0";
        sha256 = "1izd7gc9xdrs7a1wbzmhhkv8s9rw2mcq77agvr351dc5jyzdnwiy";
-       revision = "4";
-       editedCabalFile = "0i4y8p6xyk7vnk9qwf496jb3y40fn8jxhkcszqfsgf7znjvlbhn2";
+       revision = "5";
+       editedCabalFile = "005n9ax9dkkcqx9qm5kbga1a69rf78zqf3ld486136379h6qdi0h";
        libraryHaskellDepends = [ base integer-gmp ];
        testHaskellDepends = [
          base integer-gmp QuickCheck test-framework
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "perf_0_10_0" = callPackage
-    ({ mkDerivation, attoparsec, base, box, box-csv, chart-svg
-     , containers, deepseq, formatn, gauge, mtl, numhask-space
-     , optics-core, optparse-applicative, rdtsc, recursion-schemes, text
-     , time, vector
+  "perf_0_10_1" = callPackage
+    ({ mkDerivation, base, containers, deepseq, formatn, gauge, mtl
+     , numhask-space, optparse-applicative, rdtsc, recursion-schemes
+     , text, time, vector
      }:
      mkDerivation {
        pname = "perf";
-       version = "0.10.0";
-       sha256 = "1igdghqn80dxgx182yb89zm685wi6xka7gjcwqws1bq8p36v7i5j";
+       version = "0.10.1";
+       sha256 = "0r103y4xkl99ypiq3ps9cfplfpkd4lbs5w5cf6my2fpcza259zv2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         attoparsec base box box-csv chart-svg containers deepseq formatn
-         mtl numhask-space optics-core optparse-applicative rdtsc
-         recursion-schemes text time vector
+         base containers deepseq formatn mtl numhask-space
+         optparse-applicative rdtsc recursion-schemes text time vector
        ];
        executableHaskellDepends = [
          base containers deepseq formatn gauge mtl optparse-applicative text
···
        ];
        description = "run a subprocess, combining stdout and stderr";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "plist" = callPackage
···
      }) {};
 
   "polysemy-http" = callPackage
-    ({ mkDerivation, aeson, ansi-terminal, base, case-insensitive
-     , data-default, exon, hedgehog, http-client, http-client-tls
-     , http-types, incipit, lens, network, polysemy, polysemy-log
-     , polysemy-plugin, polysemy-time, servant, servant-client
-     , servant-server, tasty, tasty-hedgehog, template-haskell, time
-     , warp
+    ({ 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
      }:
      mkDerivation {
        pname = "polysemy-http";
-       version = "0.7.0.0";
-       sha256 = "07p518xs4v1ca8p2bd394hbid6jqlkhpmz0cg9svagb48zg5bf96";
+       version = "0.8.0.0";
+       sha256 = "1ccd45ln80b0pbdpk2wmky3hlz89f8jjlrfbnxd4ycf2crap8wzl";
        libraryHaskellDepends = [
-         aeson ansi-terminal base case-insensitive data-default exon
-         http-client http-client-tls http-types incipit lens polysemy
-         polysemy-log polysemy-plugin polysemy-time template-haskell time
+         aeson base case-insensitive exon http-client http-client-tls
+         http-types polysemy polysemy-plugin prelate time
        ];
        testHaskellDepends = [
-         aeson base exon hedgehog http-client incipit lens network polysemy
-         polysemy-plugin polysemy-time servant servant-client servant-server
-         tasty tasty-hedgehog warp
+         aeson base exon hedgehog http-client network polysemy
+         polysemy-plugin polysemy-time prelate servant servant-client
+         servant-server tasty tasty-hedgehog warp
        ];
-       description = "Polysemy Effects for HTTP clients";
+       description = "Polysemy effects for HTTP clients";
        license = "BSD-2-Clause-Patent";
        hydraPlatforms = lib.platforms.none;
      }) {};
···
        broken = true;
      }) {};
 
+  "prelate" = callPackage
+    ({ mkDerivation, aeson, base, exon, extra, generic-lens, incipit
+     , microlens, microlens-ghc, polysemy-chronos, polysemy-conc
+     , polysemy-log, polysemy-process, polysemy-resume, polysemy-time
+     , template-haskell
+     }:
+     mkDerivation {
+       pname = "prelate";
+       version = "0.1.0.0";
+       sha256 = "149x6hmb25dd140kkpmcx60zqi6r4wc8yaj0jk75374b3gfqdvwz";
+       libraryHaskellDepends = [
+         aeson base exon extra generic-lens incipit microlens microlens-ghc
+         polysemy-chronos polysemy-conc polysemy-log polysemy-process
+         polysemy-resume polysemy-time template-haskell
+       ];
+       description = "A Prelude";
+       license = "BSD-2-Clause-Patent";
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "preliminaries" = callPackage
     ({ mkDerivation, abstract-par, base, bifunctors
      , classy-prelude-conduit, data-default, microlens-contra
···
      }:
      mkDerivation {
        pname = "prolude";
-       version = "0.0.0.26";
-       sha256 = "1pj6hk545jk2z2nxv9ian8y1057bziq72cljbv433zkvacb8j3dh";
+       version = "0.0.0.27";
+       sha256 = "14av500898qy24kjwnhlnllh6mdmwi458843wsmii2xc7c29rg4c";
        libraryHaskellDepends = [
          aeson base bytestring cassava containers esqueleto generic-random
          lens mongoDB network-uri persistent persistent-mongoDB QuickCheck
···
        hydraPlatforms = lib.platforms.none;
        mainProgram = "proteome";
        broken = true;
-     }) {prelate = null; ribosome-menu = null;};
+     }) {ribosome-menu = null;};
 
   "proto-lens" = callPackage
     ({ mkDerivation, base, bytestring, containers, deepseq, ghc-prim
···
        ];
        description = "Recursively defined values";
        license = lib.licenses.bsd2;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
+       maintainers = [ lib.maintainers.nomeata ];
      }) {};
 
   "rec-smallarray" = callPackage
···
      }:
      mkDerivation {
        pname = "registry-messagepack";
-       version = "0.3.0.2";
-       sha256 = "1xp6b3w8gs702q27cg50gh5mcakgxdc23ahnbbgg2cw4mg4l9nqz";
+       version = "0.3.1.0";
+       sha256 = "0v1cwgcvs31vpwxpbrbbhfvql7ch99ifs47008wrcdvmahb9h9qz";
        libraryHaskellDepends = [
          base containers msgpack protolude registry template-haskell text
          transformers vector
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "retry-effectful" = callPackage
+    ({ mkDerivation, base, effectful-core, exceptions, retry, tasty
+     , tasty-hunit
+     }:
+     mkDerivation {
+       pname = "retry-effectful";
+       version = "0.1.0.0";
+       sha256 = "0d9ja583y6vi4i1mcbyr85k7ffcnrzb23axnpl7khmbgiybwr85w";
+       libraryHaskellDepends = [ base effectful-core exceptions retry ];
+       testHaskellDepends = [ base effectful-core tasty tasty-hunit ];
+       description = "Adaptation of the retry library for the effectful ecosystem";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "retryer" = callPackage
     ({ mkDerivation, base, optparse-applicative, process }:
      mkDerivation {
···
        description = "Neovim plugin framework for Polysemy";
        license = "BSD-2-Clause-Patent";
        hydraPlatforms = lib.platforms.none;
-       broken = true;
-     }) {prelate = null;};
+     }) {};
 
   "ribosome-app" = callPackage
     ({ mkDerivation, base, chronos, exon, optparse-applicative, path
···
        license = "BSD-2-Clause-Patent";
        hydraPlatforms = lib.platforms.none;
        mainProgram = "ribosome";
-       broken = true;
-     }) {prelate = null;};
+     }) {};
 
   "ribosome-host" = callPackage
     ({ mkDerivation, aeson, base, casing, cereal, chronos, deepseq
···
        description = "Neovim plugin host for Polysemy";
        license = "BSD-2-Clause-Patent";
        hydraPlatforms = lib.platforms.none;
-       broken = true;
-     }) {prelate = null;};
+     }) {};
 
   "ribosome-host-test" = callPackage
     ({ mkDerivation, base, chronos, hedgehog, polysemy
···
        description = "Test tools for Ribosome";
        license = "BSD-2-Clause-Patent";
        hydraPlatforms = lib.platforms.none;
-       broken = true;
-     }) {prelate = null;};
+     }) {};
 
   "ribosome-root" = callPackage
     ({ mkDerivation, aeson, ansi-terminal, base-noprelude, bytestring
···
        license = "BSD-2-Clause-Patent";
        hydraPlatforms = lib.platforms.none;
        broken = true;
-     }) {chiasma-test = null; prelate = null;};
+     }) {chiasma-test = null;};
 
   "richreports" = callPackage
     ({ mkDerivation, ascetic, base, MissingH }:
···
        pname = "rle";
        version = "0.1.0.1";
        sha256 = "05rbhm0lxrq7vdbq9s0q21m0f0hlzmknljmampcmdjnwbl4nvf3d";
-       revision = "3";
-       editedCabalFile = "1gl5igmac6qhfanfnr65i5g9y9cqpzrr429hkriqyp5xvsgg3qka";
+       revision = "4";
+       editedCabalFile = "10spdlsywcfljy0fxygd3ny0bw8g6icny9ymcbyvmvpihswqz7wi";
        libraryHaskellDepends = [
          base cereal deepseq portray portray-diff wrapped
        ];
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "sandwich_0_1_1_1" = callPackage
+    ({ mkDerivation, aeson, ansi-terminal, async, base, brick
+     , bytestring, colour, containers, directory, exceptions, filepath
+     , free, haskell-src-exts, lifted-async, microlens, microlens-th
+     , monad-control, monad-logger, mtl, optparse-applicative
+     , pretty-show, process, safe, safe-exceptions, stm
+     , string-interpolate, template-haskell, text, time, transformers
+     , transformers-base, unix, unliftio-core, vector, vty
+     }:
+     mkDerivation {
+       pname = "sandwich";
+       version = "0.1.1.1";
+       sha256 = "0dbbjd0q5nilb40qmjl5ddcwpm1p00pclh53brnr6v4jypvxhj0z";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson ansi-terminal async base brick bytestring colour containers
+         directory exceptions filepath free haskell-src-exts lifted-async
+         microlens microlens-th monad-control monad-logger mtl
+         optparse-applicative pretty-show process safe safe-exceptions stm
+         string-interpolate template-haskell text time transformers
+         transformers-base unix unliftio-core vector vty
+       ];
+       executableHaskellDepends = [
+         aeson ansi-terminal async base brick bytestring colour containers
+         directory exceptions filepath free haskell-src-exts lifted-async
+         microlens microlens-th monad-control monad-logger mtl
+         optparse-applicative pretty-show process safe safe-exceptions stm
+         string-interpolate template-haskell text time transformers
+         transformers-base unix unliftio-core vector vty
+       ];
+       testHaskellDepends = [
+         aeson ansi-terminal async base brick bytestring colour containers
+         directory exceptions filepath free haskell-src-exts lifted-async
+         microlens microlens-th monad-control monad-logger mtl
+         optparse-applicative pretty-show process safe safe-exceptions stm
+         string-interpolate template-haskell text time transformers
+         transformers-base unix unliftio-core vector vty
+       ];
+       description = "Yet another test framework for Haskell";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "sandwich-hedgehog" = callPackage
     ({ mkDerivation, base, free, hedgehog, monad-control, mtl
      , safe-exceptions, sandwich, string-interpolate, text, time, vty
···
      }:
      mkDerivation {
        pname = "sandwich-hedgehog";
-       version = "0.1.0.10";
-       sha256 = "1yb27zfq1a2320bqxjqjfhyalgk6fy6lwaim1zddwpcw95cbc19g";
+       version = "0.1.1.0";
+       sha256 = "05zzsf3m2lc050aafb16x94dgprmhs8f5fx5l5nfrinki0zyjg04";
        libraryHaskellDepends = [
          base free hedgehog monad-control mtl safe-exceptions sandwich
          string-interpolate text time vty wl-pprint-annotated
···
        mainProgram = "sandwich-slack-exe";
      }) {};
 
+  "sandwich-slack_0_1_1_0" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, lens
+     , lens-aeson, monad-logger, mtl, safe, safe-exceptions, sandwich
+     , stm, string-interpolate, text, time, vector, wreq
+     }:
+     mkDerivation {
+       pname = "sandwich-slack";
+       version = "0.1.1.0";
+       sha256 = "1ffvkqxffyrl02w22xa3rg8y3lnsq57dhmprp9h6sgp5xwxyrhcb";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base bytestring containers lens lens-aeson monad-logger mtl
+         safe safe-exceptions sandwich stm string-interpolate text time
+         vector wreq
+       ];
+       executableHaskellDepends = [
+         aeson base bytestring containers lens lens-aeson monad-logger mtl
+         safe safe-exceptions sandwich stm string-interpolate text time
+         vector wreq
+       ];
+       testHaskellDepends = [
+         aeson base bytestring containers lens lens-aeson monad-logger mtl
+         safe safe-exceptions sandwich stm string-interpolate text time
+         vector wreq
+       ];
+       description = "Sandwich integration with Slack";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "sandwich-slack-exe";
+     }) {};
+
   "sandwich-webdriver" = callPackage
     ({ mkDerivation, aeson, base, containers, data-default, directory
      , exceptions, filepath, http-client, http-client-tls, http-conduit
···
      }:
      mkDerivation {
        pname = "sandwich-webdriver";
-       version = "0.1.0.6";
-       sha256 = "1x8f9jvfcqwhjly9gnqsb9lv9b8dvyj4rd21x9alsqk44jlxhzkf";
+       version = "0.1.1.0";
+       sha256 = "01y8jy2fvph9kmh42zwnf8y9rca82arn2a6wgh3mzylfijni74lj";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        testHaskellDepends = [ array base ];
        description = "SAT encoding monad";
        license = lib.licenses.gpl2Only;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "satchmo-backends" = callPackage
···
        ];
        description = "driver for external satchmo backends";
        license = "GPL";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "satchmo-examples" = callPackage
···
        ];
        description = "examples that show how to use satchmo";
        license = "GPL";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "satchmo-funsat" = callPackage
···
        libraryHaskellDepends = [ base containers process satchmo ];
        description = "minisat driver as backend for satchmo";
        license = "GPL";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "satchmo-toysat" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
-  "sbp_4_7_0" = callPackage
+  "sbp_4_8_0" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, array, base
      , base64-bytestring, basic-prelude, binary, binary-conduit
      , bytestring, cmdargs, conduit, conduit-extra, data-binary-ieee754
···
      }:
      mkDerivation {
        pname = "sbp";
-       version = "4.7.0";
-       sha256 = "0xr9fxikhjnrbsvkfs591is0f0frcbn03dk1m7zs4imhxmvs2jsm";
+       version = "4.8.0";
+       sha256 = "11089yi2bj495h515la8bf9pwrsgbaffnx60kw2d6zk2xc312pic";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        description = "Nat singletons represented by Int";
        license = lib.licenses.asl20;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "siphash" = callPackage
···
      }:
      mkDerivation {
        pname = "skylighting-format-blaze-html";
-       version = "0.1";
-       sha256 = "0s996fn7acq3fign0kz2pg1rdw1cw5qs5l422s7rv33r41hrm67b";
+       version = "0.1.1";
+       sha256 = "04zg92x1jnzv6hac6wdgksgma7gi5g82x2kdxk8r7pk9yd6rn4xi";
        libraryHaskellDepends = [
          base blaze-html containers skylighting-core text
        ];
···
        description = "Type-level Chars and Strings, with decidable equality";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "string-variants" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, mono-traversable
+     , QuickCheck, refined, refinery, string-conversions
+     , template-haskell, text
+     }:
+     mkDerivation {
+       pname = "string-variants";
+       version = "0.1.0.1";
+       sha256 = "12frxk86kk3rmg927i381qajwsanz2iwhf5ryvdd1af2km4dl76a";
+       libraryHaskellDepends = [
+         aeson base bytestring mono-traversable QuickCheck refined refinery
+         string-conversions template-haskell text
+       ];
+       description = "Constrained text newtypes";
+       license = lib.licenses.mit;
      }) {};
 
   "stringable" = callPackage
···
     ({ mkDerivation, base, blaze-markup, blaze-svg, directory, text }:
      mkDerivation {
        pname = "svg-icons";
-       version = "2.1.0.1";
-       sha256 = "1xa9pyw567qcrphzr0srbxvmczdmg961gybaw66cv94l121h2bkl";
+       version = "2.2.0.0";
+       sha256 = "1paqpv99kwdphm508bka610g6wkm12yq8mfs20q6ayx1i9akm0rh";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "ten";
        version = "0.1.0.2";
        sha256 = "0djvcb2l9dnnjbhivchi6yyaj5i96jmy7yhr9x3paiz1l54brrqx";
-       revision = "3";
-       editedCabalFile = "10ip8dcilycknr64nfhgki30xr73m19jbmv66dpslflkbrkx8ig3";
+       revision = "4";
+       editedCabalFile = "10gr23x4693nh4a3hd94gpf7mra2ghj9qzj9wpfxhl4ip65dc470";
        libraryHaskellDepends = [
          adjunctions base data-default-class deepseq distributive hashable
          portray portray-diff some text transformers wrapped
···
        pname = "ten-unordered-containers";
        version = "0.1.0.3";
        sha256 = "1kfww8xs5m802jcx309pp6lx9f7pn1hsbqq3mln4g9rcf0r24mwy";
-       revision = "1";
-       editedCabalFile = "051w5krkb6yyn9c28b3csvpikc6i02dypnkx4hmyylvan7bfdz6r";
+       revision = "2";
+       editedCabalFile = "1yv6255n2k4dl3hwrsrw76gf4gcf1k67j1sbk59z7la4jrscngww";
        libraryHaskellDepends = [
          base hashable portray portray-diff some ten unordered-containers
          wrapped
···
        license = lib.licenses.gpl2Only;
      }) {};
 
-  "texmath_0_12_5_2" = callPackage
+  "texmath_0_12_5_3" = callPackage
     ({ mkDerivation, base, bytestring, containers, directory, filepath
      , mtl, pandoc-types, parsec, pretty-show, split, syb, tagged, tasty
      , tasty-golden, text, xml
      }:
      mkDerivation {
        pname = "texmath";
-       version = "0.12.5.2";
-       sha256 = "13sfjm9yhasszjjaw7lc3gbglpnq6ga8gnq3b5x1kzjsm80nazzg";
+       version = "0.12.5.3";
+       sha256 = "1wv4cld2g1xb6qdbha85g4jjv07l9prcjpp72bwkrp33xyjizmhb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "tinyid" = callPackage
+    ({ mkDerivation, base, bytestring, entropy }:
+     mkDerivation {
+       pname = "tinyid";
+       version = "0.1.0.0";
+       sha256 = "01863iq39skw38x1c7v809shfgmxdnj680a6zxjviraqfzyk8h0z";
+       libraryHaskellDepends = [ base bytestring entropy ];
+       description = "A secure URL-friendly string ID generator";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "tinylog" = callPackage
     ({ mkDerivation, base, bytestring, containers, criterion
      , double-conversion, fast-logger, text, transformers, unix-time
···
        pname = "unix-compat";
        version = "0.5.4";
        sha256 = "1cd4lh2c16h7y5hzrcn5l9vir8aq2wcizwksppnagklsdsfmf942";
-       revision = "1";
-       editedCabalFile = "0v2cp1p7vswbwclai1c74vbwdapczlaqgshcb6l1j49jph1w1vnm";
+       revision = "2";
+       editedCabalFile = "0mik6xb1jdmb2jlxlmzf0517mxfj0c1j2i4r6h5212m4q6znqqcm";
        libraryHaskellDepends = [ base unix ];
        description = "Portable POSIX-compatibility layer";
        license = lib.licenses.bsd3;
···
        pname = "unix-compat";
        version = "0.6";
        sha256 = "1y6m8ix8np6vambabdaj2h7ydgda8igwy3kliv53mba3clx85kdl";
+       revision = "1";
+       editedCabalFile = "0g5mi6rh977idajgxnnlsd7dp28vf4xwiiwpsc4pj1rqv0lhjp8g";
        libraryHaskellDepends = [ base unix ];
        testHaskellDepends = [
          base directory extra hspec HUnit monad-parallel temporary
···
      }:
      mkDerivation {
        pname = "vulkan";
-       version = "3.22";
-       sha256 = "074qg7r78p427gar1zqx98r7ypy3b0r9flvpsqpm27w1d7rlxl21";
+       version = "3.22.1";
+       sha256 = "0v5x3kbw0z7cvw4s10f79i50i4yk415v0jdn0rw4m50bgl9y2icd";
        libraryHaskellDepends = [ base bytestring transformers vector ];
        libraryPkgconfigDepends = [ vulkan ];
        testHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "vulkan-utils";
-       version = "0.5.9";
-       sha256 = "114kx06i58d6pzgd86qxqih7nv845nvf04isl83xbfzij4bf1p06";
+       version = "0.5.10";
+       sha256 = "0pa0vmwjjqwyiyrzz2bhzlbvv8y4wcwky51bnmshj7xsnqp755n5";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          base bytestring containers dependent-map dependent-sum extra
···
      }) {};
 
   "web-rep" = callPackage
-    ({ mkDerivation, attoparsec, base, bifunctors, box, box-socket
-     , clay, concurrency, interpolatedstring-perl6, language-javascript
-     , lucid, mtl, optics-core, optics-extra, optparse-generic, scotty
-     , text, transformers, unordered-containers, wai-middleware-static
-     , wai-websockets, websockets
+    ({ mkDerivation, async, attoparsec, base, bifunctors, box
+     , box-socket, clay, interpolatedstring-perl6, language-javascript
+     , lucid, mtl, optics-core, optics-extra, optparse-applicative
+     , profunctors, scotty, text, transformers, unordered-containers
+     , wai-middleware-static, wai-websockets, websockets
      }:
      mkDerivation {
        pname = "web-rep";
-       version = "0.9.0";
-       sha256 = "1xcrmm5yk19nh08gllnfg6ck0jijkxzl3ma4klwlnxp2ky75q7ds";
+       version = "0.10.0";
+       sha256 = "02fm2bi0gd9nh9kp8a00d66b2g8fzgw9rjawydbifr0g3c3pv7v0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         attoparsec base bifunctors box box-socket clay concurrency
+         async attoparsec base bifunctors box box-socket clay
          interpolatedstring-perl6 language-javascript lucid mtl optics-core
-         optics-extra scotty text transformers unordered-containers
-         wai-middleware-static wai-websockets websockets
+         optics-extra profunctors scotty text transformers
+         unordered-containers wai-middleware-static wai-websockets
+         websockets
        ];
-       executableHaskellDepends = [ base optparse-generic ];
+       executableHaskellDepends = [
+         base box lucid optics-core optparse-applicative text
+       ];
        description = "representations of a web page";
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
···
        ];
        description = "Relying party (server) implementation of the WebAuthn 2 specification";
        license = lib.licenses.asl20;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "webby" = callPackage

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

···
 , buildPythonPackage
 , fetchFromGitHub
 , jupyterhub
-, isPy27
+, pythonOlder
 }:
 
 buildPythonPackage rec {
   pname = "batchspawner";
-  version = "1.1.0";
-  disabled = isPy27;
+  version = "1.2.0";
+  format = "setuptools";
+
+  disabled = pythonOlder "3.5";
 
   src = fetchFromGitHub {
     owner = "jupyterhub";
     repo = "batchspawner";
-    rev = "v${version}";
-    sha256 = "0zv485b7fk5zlwgp5fyibanqzbpisdl2a0gz70fwdj4kl462axnw";
+    rev = "refs/tags/v${version}";
+    hash = "sha256-oyS47q+gsO7JmRsbVJXglZsSRfits5rS/nrHW5E7EV0=";
   };
 
   propagatedBuildInputs = [
     jupyterhub
   ];
 
-  # tests require a job scheduler e.g. slurm, pbs, etc.
+  # Tests require a job scheduler e.g. slurm, pbs, etc.
   doCheck = false;
 
-  pythonImportsCheck = [ "batchspawner" ];
+  pythonImportsCheck = [
+    "batchspawner"
+  ];
 
   meta = with lib; {
     description = "A spawner for Jupyterhub to spawn notebooks using batch resource managers";

pkgs/development/python-modules/django/4.nix

···
 
 buildPythonPackage rec {
   pname = "Django";
-  version = "4.1.1";
+  version = "4.1.2";
   format = "pyproject";
 
   disabled = pythonOlder "3.8";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-oVP/1RQ78mqHe/ri9Oxzbr2JJKRmAMoImtlrVKHU4o4=";
+    hash = "sha256-uNhDcUgQq4jVk0RQfURHvoss8SpJAxNjtu7Z8bmyKA8=";
   };
 
   patches = [

pkgs/development/tools/build-managers/sbt-extras/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "sbt-extras";
-  rev = "ddc1c0a9e9df598ad60edbd004e5abb51b32e42c";
-  version = "2022-09-23";
+  rev = "52fa7de64091bc687fe11e3a8c660bbbfb42742f";
+  version = "2022-10-03";
 
   src = fetchFromGitHub {
     owner = "paulp";
     repo = "sbt-extras";
     inherit rev;
-    sha256 = "SsqxDipM6B2w1kT1yuNc+PXYDE8qpUSwaXqItYuCgRU=";
+    sha256 = "TMp5qxUf7U3re8HKXvtArEJMtn4iZy4zs4SqFTxX5X4=";
   };
 
   dontBuild = true;

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

···
 
 stdenv.mkDerivation rec {
   pname = "sbt";
-  version = "1.7.1";
+  version = "1.7.2";
 
   src = fetchurl {
     url = "https://github.com/sbt/sbt/releases/download/v${version}/sbt-${version}.tgz";
-    sha256 = "sha256-ihg6/bNRkpDd4vjIHJsrrRnd14c17zEftfub3PaNP+Q=";
+    sha256 = "sha256-vWSDnIzWPy3sMdbqJODeFsYTyEqSeh9FiuQBmyujENc=";
   };
 
   postPatch = ''

pkgs/os-specific/linux/kernel/linux-5.19.nix

···
 with lib;
 
 buildLinux (args // rec {
-  version = "5.19.12";
+  version = "5.19.14";
 
   # modDirVersion needs to be x.y.z, will automatically add .0 if needed
   modDirVersion = if (modDirVersionArg == null) then concatStringsSep "." (take 3 (splitVersion "${version}.0")) else modDirVersionArg;
···
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v5.x/linux-${version}.tar.xz";
-    sha256 = "1fmhwbgqpr6q3z3ygys153szivlmv3mcnwilbbyfcb1iqx4aadn4";
+    sha256 = "1h8srn3fw4vw61qi0xxlk9fq0fqq4wl7fbrzz7sivdd8qkhjgv8x";
   };
 } // (args.argsOverride or { }))

pkgs/servers/mail/rspamd/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "rspamd";
-  version = "3.2";
+  version = "3.3";
 
   src = fetchFromGitHub {
     owner = "rspamd";
     repo = "rspamd";
     rev = version;
-    sha256 = "122d5m1nfxxz93bhsk8lm4dazvdknzphb0a1188m7bsa4iynbfv2";
+    sha256 = "sha256-VBNRdkJxO3OSl6ap0BZl4bxJdu0cUNxiH+TrseyGZ1s=";
   };
 
   hardeningEnable = [ "pie" ];

pkgs/servers/roon-server/default.nix

···
 , stdenv
 }:
 let
-  version = "1.8-1105";
+  version = "2.0-1128";
   urlVersion = builtins.replaceStrings [ "." "-" ] [ "00" "0" ] version;
 in
 stdenv.mkDerivation {
···
   inherit version;
 
   src = fetchurl {
-    url = "https://download.roonlabs.com/builds/RoonServer_linuxx64_${urlVersion}.tar.bz2";
-    hash = "sha256-YijqoJ0JqAhaNQ7GNaOilEhbVqmd62Plp1ykjwQw3aw=";
+    url = "https://download.roonlabs.com/updates/production/RoonServer_linuxx64_${urlVersion}.tar.bz2";
+    hash = "sha256-PR3LR7u9X6eUAyoAW1tXv3LzqoVz3RQ0MZwdF0iAXJ8=";
   };
 
   dontConfigure = true;

pkgs/servers/tmate-ssh-server/default.nix

···
-{ lib, stdenv, fetchFromGitHub, autoreconfHook, cmake, libtool, pkg-config
-, zlib, openssl, libevent, ncurses, ruby, msgpack, libssh }:
+{ lib
+, stdenv
+, fetchFromGitHub
+, autoreconfHook
+, cmake
+, libtool
+, pkg-config
+, zlib
+, openssl
+, libevent
+, ncurses
+, ruby
+, msgpack
+, libssh
+, nixosTests
+}:
 
 stdenv.mkDerivation rec {
   pname = "tmate-ssh-server";
   version = "unstable-2021-10-17";
 
   src = fetchFromGitHub {
-    owner  = "tmate-io";
-    repo   = "tmate-ssh-server";
-    rev    = "1f314123df2bb29cb07427ed8663a81c8d9034fd";
+    owner = "tmate-io";
+    repo = "tmate-ssh-server";
+    rev = "1f314123df2bb29cb07427ed8663a81c8d9034fd";
     sha256 = "sha256-9/xlMvtkNWUBRYYnJx20qEgtEcjagH2NtEKZcDOM1BY=";
   };
 
···
   buildInputs = [ libtool zlib openssl libevent ncurses ruby msgpack libssh ];
   nativeBuildInputs = [ autoreconfHook cmake pkg-config ];
 
+  passthru.tests.tmate-ssh-server = nixosTests.tmate-ssh-server;
+
   meta = with lib; {
-    homepage    = "https://tmate.io/";
+    homepage = "https://tmate.io/";
     description = "tmate SSH Server";
-    license     = licenses.mit;
-    platforms   = platforms.unix;
+    license = licenses.mit;
+    platforms = platforms.unix;
     maintainers = with maintainers; [ ck3d ];
   };
 }
-

pkgs/tools/misc/bash_unit/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "bash_unit";
-  version = "2.0.0";
+  version = "2.0.1";
 
   src = fetchFromGitHub {
     owner = "pgrange";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-ekkyyp280YRXMuNXbiV78Hrfd/zk2nESE1bRCpUP1eE=";
+    sha256 = "sha256-P3fDfv7SexrNMynZBbgwwZcH2H/t4bwFM4HULlLaiM4=";
   };
 
   installPhase = ''

pkgs/tools/misc/hdl-dump/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "hdl-dump";
-  version = "unstable-2021-08-20";
+  version = "unstable-2022-09-19";
 
   src = fetchFromGitHub {
     owner = "ps2homebrew";
     repo = pname;
-    rev = "1e760d7672dc12a36c09690b8c9b20d6642a2926";
-    sha256 = "sha256-NMExi2pUyj8vRn9beT2YvnEogRw/xzgqE+roaZ/vNZs=";
+    rev = "87d3099d2ba39a15e86ebc7dc725e8eaa49f2d5f";
+    hash = "sha256-eBqF4OGEaLQXQ4JMtD/Yn+f97RzKVsnC+4oyiEhLTUM=";
   };
 
   makeFlags = [ "RELEASE=yes" ];

pkgs/tools/system/uefitool/variants.nix

···
   common = opts: libsForQt5.callPackage (import ./common.nix opts) {};
 in rec {
   new-engine = common rec {
-    version = "A61";
-    sha256 = "sha256-6RxWAR0KY6o98RwOLRHy6wShTHAaQlvYYbCNLa5FzH4=";
+    version = "A62";
+    sha256 = "sha256-U89j0BV57luv1c9hoYJtisKLxFezuaGFokZ29/NJ0xg=";
     installFiles = [ "build/UEFITool/UEFITool" "build/UEFIFind/UEFIFind" "build/UEFIExtract/UEFIExtract" ];
   };
   old-engine = common rec {

pkgs/top-level/release-haskell.nix

···
     ghc8107
     ghc902
     ghc924
+    ghc942
   ];
 
   # packagePlatforms applied to `haskell.packages.*`
···
       # working as expected.
       cabal-install = released;
       Cabal_3_6_3_0 = released;
+      Cabal_3_8_1_0 = released;
       cabal2nix = released;
       cabal2nix-unstable = released;
       funcmp = released;
-      haskell-language-server = released;
+      haskell-language-server = [
+        compilerNames.ghc884
+        compilerNames.ghc8107
+        compilerNames.ghc902
+        compilerNames.ghc924
+        # https://github.com/haskell/haskell-language-server/issues/3190
+      ];
       hoogle = released;
-      hlint = released;
+      hlint = [
+        compilerNames.ghc884
+        compilerNames.ghc8107
+        compilerNames.ghc902
+        compilerNames.ghc924
+        # https://github.com/ndmitchell/hlint/issues/1413
+      ];
+      hpack = released;
       hsdns = released;
       jailbreak-cabal = released;
       language-nix = released;