Merge staging-next into staging

doc/languages-frameworks/haskell.section.md

···
 
 All of these packages are originally defined in the `haskellPackages` package
 set and are re-exposed with a reduced dependency closure for convenience.
-(see `justStaticExecutables` below)
+(see `justStaticExecutables` or `separateBinOutput` below)
 
 The `haskellPackages` set includes at least one version of every package from
 Hackage as well as some manually injected packages. This amounts to a lot of

maintainers/maintainer-list.nix

···
   };
   cafkafk = {
     email = "[e-mail]";
-    matrix = "@cafkafk:matrix.cafkafk.com";
+    matrix = "@cafkafk:m.cafkafk.com";
     name = "Christina Sørensen";
     github = "cafkafk";
     githubId = 89321978;
···
     github = "progval";
     githubId = 406946;
     name = "Valentin Lorentz";
+  };
+  proofconstruction = {
+    email = "[e-mail]";
+    github = "proofconstruction";
+    githubId = 74747193;
+    name = "Alexander Groleau";
   };
   proofofkeags = {
     email = "[e-mail]";

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

···
 
 - `services.lemmy.settings.federation` was removed in 0.17.0 and no longer has any effect. To enable federation, the hostname must be set in the configuration file and then federation must be enabled in the admin web UI. See the [release notes](https://github.com/LemmyNet/lemmy/blob/c32585b03429f0f76d1e4ff738786321a0a9df98/RELEASES.md#upgrade-instructions) for more details.
 
+- The following packages in `haskellPackages` have now a separate bin output: `cabal-fmt`, `calligraphy`, `eventlog2html`, `ghc-debug-brick`, `hindent`, `nixfmt`, `releaser`. This means you need to replace e.g. `"${pkgs.haskellPackages.nixfmt}/bin/nixfmt"` with `"${lib.getBin pkgs.haskellPackages.nixfmt}/bin/nixfmt"` or `"${lib.getExe pkgs.haskellPackages.nixfmt}"`. The binaries also won’t be in scope if you rely on them being installed e.g. via `ghcWithPackages`. `environment.packages` picks the `bin` output automatically, so for normal installation no intervention is required. Also, toplevel attributes like `pkgs.nixfmt` are not impacted negatively by this change.
+
 - `spamassassin` no longer supports the `Hashcash` module. The module needs to be removed from the `loadplugin` list if it was copied over from the default `initPreConf` option.
 
 ## Other Notable Changes {#sec-release-23.11-notable-changes}
···
 - `services.nginx` gained a `defaultListen` option at server-level with support for PROXY protocol listeners, also `proxyProtocol` is now exposed in `services.nginx.virtualHosts.<name>.listen` option. It is now possible to run PROXY listeners and non-PROXY listeners at a server-level, see [#213510](https://github.com/NixOS/nixpkgs/pull/213510/) for more details.
 
 - `services.prometheus.exporters` has a new exporter to monitor electrical power consumption based on PowercapRAPL sensor called [Scaphandre](https://github.com/hubblo-org/scaphandre), see [#239803](https://github.com/NixOS/nixpkgs/pull/239803) for more details.
+
+- The module `services.calibre-server` has new options to configure the `host`, `port`, `auth.enable`, `auth.mode` and `auth.userDb` path, see [#216497](https://github.com/NixOS/nixpkgs/pull/216497/) for more details.
 
 ## Nixpkgs internals {#sec-release-23.11-nixpkgs-internals}
 

nixos/modules/config/fonts/fontdir.nix

···
 
   x11Fonts = pkgs.runCommand "X11-fonts" { preferLocalBuild = true; } ''
     mkdir -p "$out/share/X11/fonts"
-    font_regexp='.*\.\(ttf\|ttc\|otf\|pcf\|pfa\|pfb\|bdf\)\(\.gz\)?'
+    font_regexp='.*\.\(ttf\|ttc\|otb\|otf\|pcf\|pfa\|pfb\|bdf\)\(\.gz\)?'
     find ${toString config.fonts.fonts} -regex "$font_regexp" \
       -exec ln -sf -t "$out/share/X11/fonts" '{}' \;
     cd "$out/share/X11/fonts"

nixos/modules/services/misc/calibre-server.nix

···
 
   cfg = config.services.calibre-server;
 
+  documentationLink = "https://manual.calibre-ebook.com";
+  generatedDocumentationLink = documentationLink + "/generated/en/calibre-server.html";
+
+  execFlags = (concatStringsSep " "
+    (mapAttrsToList (k: v: "${k} ${toString v}") (filterAttrs (name: value: value != null) {
+      "--listen-on" = cfg.host;
+      "--port" = cfg.port;
+      "--auth-mode" = cfg.auth.mode;
+      "--userdb" = cfg.auth.userDb;
+    }) ++ [(optionalString (cfg.auth.enable == true) "--enable-auth")])
+  );
 in
 
 {
···
     )
   ];
 
-  ###### interface
-
   options = {
     services.calibre-server = {
 
       enable = mkEnableOption (lib.mdDoc "calibre-server");
+      package = lib.mkPackageOptionMD pkgs "calibre" { };
 
       libraries = mkOption {
+        type = types.listOf types.path;
+        default = [ "/var/lib/calibre-server" ];
         description = lib.mdDoc ''
+          Make sure each library path is initialized before service startup.
           The directories of the libraries to serve. They must be readable for the user under which the server runs.
+          See the [calibredb documentation](${documentationLink}/generated/en/calibredb.html#add) for details.
         '';
-        type = types.listOf types.path;
       };
 
       user = mkOption {
-        description = lib.mdDoc "The user under which calibre-server runs.";
         type = types.str;
         default = "calibre-server";
+        description = lib.mdDoc "The user under which calibre-server runs.";
       };
 
       group = mkOption {
-        description = lib.mdDoc "The group under which calibre-server runs.";
         type = types.str;
         default = "calibre-server";
+        description = lib.mdDoc "The group under which calibre-server runs.";
       };
 
-    };
-  };
+      host = mkOption {
+        type = types.str;
+        default = "0.0.0.0";
+        example = "::1";
+        description = lib.mdDoc ''
+          The interface on which to listen for connections.
+          See the [calibre-server documentation](${generatedDocumentationLink}#cmdoption-calibre-server-listen-on) for details.
+        '';
+      };
 
+      port = mkOption {
+        default = 8080;
+        type = types.port;
+        description = lib.mdDoc ''
+          The port on which to listen for connections.
+          See the [calibre-server documentation](${generatedDocumentationLink}#cmdoption-calibre-server-port) for details.
+        '';
+      };
 
-  ###### implementation
+      auth = {
+        enable = mkOption {
+          type = types.bool;
+          default = false;
+          description = lib.mdDoc ''
+            Password based authentication to access the server.
+            See the [calibre-server documentation](${generatedDocumentationLink}#cmdoption-calibre-server-enable-auth) for details.
+          '';
+        };
+
+        mode = mkOption {
+          type = types.enum [ "auto" "basic" "digest" ];
+          default = "auto";
+          description = lib.mdDoc ''
+            Choose the type of authentication used.
+            Set the HTTP authentication mode used by the server.
+            See the [calibre-server documentation](${generatedDocumentationLink}#cmdoption-calibre-server-auth-mode) for details.
+          '';
+        };
+
+        userDb = mkOption {
+          default = null;
+          type = types.nullOr types.path;
+          description = lib.mdDoc ''
+            Choose users database file to use for authentication.
+            Make sure users database file is initialized before service startup.
+            See the [calibre-server documentation](${documentationLink}/server.html#managing-user-accounts-from-the-command-line-only) for details.
+          '';
+        };
+      };
+    };
+  };
 
   config = mkIf cfg.enable {
 
     systemd.services.calibre-server = {
-        description = "Calibre Server";
-        after = [ "network.target" ];
-        wantedBy = [ "multi-user.target" ];
-        serviceConfig = {
-          User = cfg.user;
-          Restart = "always";
-          ExecStart = "${pkgs.calibre}/bin/calibre-server ${lib.concatStringsSep " " cfg.libraries}";
-        };
+      description = "Calibre Server";
+      after = [ "network.target" ];
+      wantedBy = [ "multi-user.target" ];
+      serviceConfig = {
+        User = cfg.user;
+        Restart = "always";
+        ExecStart = "${cfg.package}/bin/calibre-server ${lib.concatStringsSep " " cfg.libraries} ${execFlags}";
+      };
 
-      };
+    };
 
     environment.systemPackages = [ pkgs.calibre ];
 
···
 
   };
 
+  meta.maintainers = with lib.maintainers; [ gaelreyrol ];
 }

nixos/modules/services/misc/paperless.nix

···
     SupplementaryGroups = optional enableRedis redisServer.user;
     SystemCallArchitectures = "native";
     SystemCallFilter = [ "@system-service" "~@privileged @setuid @keyring" ];
-    # Does not work well with the temporary root
-    #UMask = "0066";
+    UMask = "0066";
   };
 in
 {

nixos/modules/services/monitoring/grafana.nix

···
                 It will notify, via the UI, when a new version is available.
                 The check itself will not prompt any auto-updates of the Grafana software, nor will it send any sensitive information.
               '';
-              default = true;
+              default = false;
               type = types.bool;
             };
 

nixos/tests/all-tests.nix

···
   cage = handleTest ./cage.nix {};
   cagebreak = handleTest ./cagebreak.nix {};
   calibre-web = handleTest ./calibre-web.nix {};
+  calibre-server = handleTest ./calibre-server.nix {};
   cassandra_3_0 = handleTest ./cassandra.nix { testPackage = pkgs.cassandra_3_0; };
   cassandra_3_11 = handleTest ./cassandra.nix { testPackage = pkgs.cassandra_3_11; };
   cassandra_4 = handleTest ./cassandra.nix { testPackage = pkgs.cassandra_4; };

nixos/tests/calibre-server.nix

···
+{ system ? builtins.currentSystem
+, config ? { }
+, pkgs ? import ../.. { inherit system config; }
+}:
+
+let
+  inherit (import ../lib/testing-python.nix { inherit system pkgs; }) makeTest;
+  inherit (pkgs.lib) concatStringsSep maintainers mapAttrs mkMerge
+    removeSuffix splitString;
+
+  tests = {
+    default = {
+      calibreConfig = {};
+      calibreScript = ''
+        wait_for_unit("calibre-server.service")
+      '';
+    };
+    customLibrary = {
+      calibreConfig = {
+        libraries = [ "/var/lib/calibre-data" ];
+      };
+      calibreScript = ''
+        succeed("ls -la /var/lib/calibre-data")
+        wait_for_unit("calibre-server.service")
+      '';
+    };
+    multipleLibraries = {
+      calibreConfig = {
+        libraries = [ "/var/lib/calibre-data" "/var/lib/calibre-server" ];
+      };
+      calibreScript = ''
+        succeed("ls -la /var/lib/calibre-data")
+        succeed("ls -la /var/lib/calibre-server")
+        wait_for_unit("calibre-server.service")
+      '';
+    };
+    hostAndPort = {
+      calibreConfig = {
+        host = "127.0.0.1";
+        port = 8888;
+      };
+      calibreScript = ''
+        wait_for_unit("calibre-server.service")
+        wait_for_open_port(8888)
+        succeed("curl --fail http://127.0.0.1:8888")
+      '';
+    };
+    basicAuth = {
+      calibreConfig = {
+        host = "127.0.0.1";
+        port = 8888;
+        auth = {
+          enable = true;
+          mode = "basic";
+        };
+      };
+      calibreScript = ''
+        wait_for_unit("calibre-server.service")
+        wait_for_open_port(8888)
+        fail("curl --fail http://127.0.0.1:8888")
+      '';
+    };
+  };
+in
+mapAttrs
+  (test: testConfig: (makeTest (
+    let
+      nodeName = testConfig.nodeName or test;
+      calibreConfig = {
+        enable = true;
+        libraries = [ "/var/lib/calibre-server" ];
+      } // testConfig.calibreConfig or {};
+      librariesInitScript = path: ''
+        ${nodeName}.execute("touch /tmp/test.epub")
+        ${nodeName}.execute("zip -r /tmp/test.zip /tmp/test.epub")
+        ${nodeName}.execute("mkdir -p ${path}")
+        ${nodeName}.execute("calibredb add -d --with-library ${path} /tmp/test.zip")
+      '';
+    in
+    {
+      name = "calibre-server-${test}";
+
+      nodes.${nodeName} = mkMerge [{
+        environment.systemPackages = [ pkgs.zip ];
+        services.calibre-server = calibreConfig;
+      } testConfig.calibreProvider or { }];
+
+      testScript = ''
+        ${nodeName}.start()
+        ${concatStringsSep "\n" (map librariesInitScript calibreConfig.libraries)}
+        ${concatStringsSep "\n" (map (line:
+          if (builtins.substring 0 1 line == " " || builtins.substring 0 1 line == ")")
+          then line
+          else "${nodeName}.${line}"
+        ) (splitString "\n" (removeSuffix "\n" testConfig.calibreScript)))}
+        ${nodeName}.shutdown()
+      '';
+
+      meta = with maintainers; {
+        maintainers = [ gaelreyrol ];
+      };
+    }
+  )))
+  tests

pkgs/applications/audio/waylyrics/default.nix

···
+{ lib, fetchFromGitHub, rustPlatform, gtk4, pkg-config, openssl, dbus, wrapGAppsHook4, glib, makeDesktopItem, copyDesktopItems }:
+
+rustPlatform.buildRustPackage rec {
+  pname = "waylyrics";
+  version = "unstable-2023-05-14";
+
+  src = fetchFromGitHub {
+    owner = "poly000";
+    repo = pname;
+    rev = "7e8bd99e1748a5448c1a5c49f0664bd96fbf965e";
+    hash = "sha256-vSYtLsLvRHCCHxomPSHifXFZKjkFrlskNp7IlFflrUU=";
+  };
+
+  cargoHash = "sha256-dpJa0T6xapCBPM5fWbSDEhBlZ55c3Sr5oTnu58B/voM=";
+
+  nativeBuildInputs = [ pkg-config wrapGAppsHook4 copyDesktopItems ];
+  buildInputs = [ gtk4 openssl dbus glib ];
+
+  RUSTC_BOOTSTRAP = 1;
+
+  doCheck = false; # No tests defined in the project.
+
+  WAYLYRICS_DEFAULT_CONFIG = "${placeholder "out"}/share/waylyrics/config.toml";
+  WAYLYRICS_THEME_PRESETS_DIR = "${placeholder "out"}/share/waylyrics/themes";
+
+  desktopItems = [
+    (makeDesktopItem {
+      name = "io.poly000.waylyrics";
+      exec = "waylyrics";
+      comment = "Simple on screen lyrics for MPRIS-friendly players";
+      type = "Application";
+      icon = "io.poly000.waylyrics";
+      desktopName = "Waylyrics";
+      terminal = false;
+      categories = [ "Audio" "AudioVideo" ];
+    })
+  ];
+
+  postInstall = ''
+    $out/bin/gen_config_example
+    mkdir -p $out/share/waylyrics
+    install -Dm644 config.toml $WAYLYRICS_DEFAULT_CONFIG
+    cp -vr themes $out/share/waylyrics/
+    rm $out/bin/gen_config_example # Unnecessary for end users
+    # Install schema
+    install -Dm644 io.poly000.waylyrics.gschema.xml -t $out/share/gsettings-schemas/$name/glib-2.0/schemas
+    glib-compile-schemas $out/share/gsettings-schemas/$name/glib-2.0/schemas/
+    # Install icons
+    cp -vr res/icons $out/share/
+  '';
+
+  meta = with lib; {
+    description = "On screen lyrics for Wayland with NetEase Music source";
+    homepage = "https://github.com/poly000/waylyrics";
+    license = licenses.mit;
+    maintainers = [ maintainers.shadowrz ];
+    platforms = platforms.linux;
+  };
+}

pkgs/applications/blockchains/bisq-desktop/default.nix

···
 }:
 
 let
-  bisq-launcher = writeScript "bisq-launcher" ''
+  bisq-launcher = args: writeScript "bisq-launcher" ''
     #! ${bash}/bin/bash
 
     # This is just a comment to convince Nix that Tor is a
···
     # whereas Nix only scans for hashes in uncompressed text.
     # ${bisq-tor}
 
-    JAVA_TOOL_OPTIONS="-XX:+UseG1GC -XX:MaxHeapFreeRatio=10 -XX:MinHeapFreeRatio=5 -XX:+UseStringDeduplication" bisq-desktop-wrapped "$@"
+    JAVA_TOOL_OPTIONS="-XX:+UseG1GC -XX:MaxHeapFreeRatio=10 -XX:MinHeapFreeRatio=5 -XX:+UseStringDeduplication ${args}" bisq-desktop-wrapped "$@"
   '';
 
   bisq-tor = writeScript "bisq-tor" ''
···
 in
 stdenv.mkDerivation rec {
   pname = "bisq-desktop";
-  version = "1.9.9";
+  version = "1.9.10";
 
   src = fetchurl {
     url = "https://github.com/bisq-network/bisq/releases/download/v${version}/Bisq-64bit-${version}.deb";
-    sha256 = "0jisxzajsc4wfvxabvfzd0x9y1fxzg39fkhap1781q7wyi4ry9kd";
+    sha256 = "1p6hwamc3vzhfg4dgrmh0vf8cxi9s46a14pjnjdyg9zgn4dyr1nm";
   };
 
   nativeBuildInputs = [
···
       genericName = "Decentralized bitcoin exchange";
       categories = [ "Network" "P2P" ];
     })
+
+    (makeDesktopItem {
+      name = "Bisq-hidpi";
+      exec = "bisq-desktop-hidpi";
+      icon = "bisq";
+      desktopName = "Bisq ${version} (HiDPI)";
+      genericName = "Decentralized bitcoin exchange";
+      categories = [ "Network" "P2P" ];
+    })
   ];
 
   unpackPhase = ''
···
     makeWrapper ${openjdk11}/bin/java $out/bin/bisq-desktop-wrapped \
       --add-flags "-jar $out/lib/desktop-${version}-all.jar bisq.desktop.app.BisqAppMain"
 
-    makeWrapper ${bisq-launcher} $out/bin/bisq-desktop \
+    makeWrapper ${bisq-launcher ""} $out/bin/bisq-desktop \
+      --prefix PATH : $out/bin
+
+    makeWrapper ${bisq-launcher "-Dglass.gtk.uiScale=2.0"} $out/bin/bisq-desktop-hidpi \
       --prefix PATH : $out/bin
 
     for n in 16 24 32 48 64 96 128 256; do

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

···
         mktplcRef = {
           name = "ruff";
           publisher = "charliermarsh";
-          version = "2023.26.0";
-          sha256 = "sha256-5JaOo0BqTWo3NAdzS9DSClTwB9YiBhICEPOqWmBv270=";
+          version = "2023.30.0";
+          sha256 = "sha256-E/zgKNxKH05qzLkoyq66qBDbkNJ7liBvU+ZSxw825c0=";
         };
         meta = {
           license = lib.licenses.mit;

pkgs/applications/emulators/mame/default.nix

···
 in
 stdenv.mkDerivation rec {
   pname = "mame";
-  version = "0.255";
+  version = "0.256";
   srcVersion = builtins.replaceStrings [ "." ] [ "" ] version;
 
   src = fetchFromGitHub {
     owner = "mamedev";
     repo = "mame";
     rev = "mame${srcVersion}";
-    hash = "sha256-pdPKxEHxynBIB2lUG6yjKNcY8MlOlk4pfr7WwqaA9Dk=";
+    hash = "sha256-rQ1GQks3Nni6ALxfiJzdkKUgbZrXaLu9vJtEDPjgP3Q=";
   };
 
   outputs = [ "out" "tools" ];

pkgs/applications/file-managers/projectable/default.nix

···
+{ lib
+, rustPlatform
+, fetchFromGitHub
+, pkg-config
+, libgit2_1_5
+, openssl
+, zlib
+, stdenv
+, darwin
+}:
+
+rustPlatform.buildRustPackage rec {
+  pname = "projectable";
+  version = "1.2.0";
+
+  src = fetchFromGitHub {
+    owner = "dzfrias";
+    repo = "projectable";
+    rev = version;
+    hash = "sha256-mN8kqh17qGJWOwrdH9fCPApFQBbgCs6FaVg38SNJGP0=";
+  };
+
+  cargoHash = "sha256-SQ117gFkqex3GFl7RnorSfPo7e0Eefg1l3L0Vyi/tpU=";
+
+  nativeBuildInputs = [
+    pkg-config
+  ];
+
+  buildInputs = [
+    libgit2_1_5
+    openssl
+    zlib
+  ] ++ lib.optionals stdenv.isDarwin [
+    darwin.apple_sdk.frameworks.CoreServices
+  ];
+
+  env = {
+    OPENSSL_NO_VENDOR = true;
+  };
+
+  meta = with lib; {
+    description = "A TUI file manager built for projects";
+    homepage = "https://github.com/dzfrias/projectable";
+    changelog = "https://github.com/dzfrias/projectable/releases/tag/${src.rev}";
+    license = licenses.mit;
+    maintainers = with maintainers; [ figsoda ];
+    mainProgram = "prj";
+  };
+}

pkgs/applications/graphics/deskew/default.nix

···
   buildPhase = ''
     runHook preBuild
     patchShebangs ./Scripts
+
+    # Deskew insists on using dlopen to load libtiff, we insist it links against it.
+    sed -i -e 's/{$DEFINE DYNAMIC_DLL_LOADING}//' Imaging/LibTiff/LibTiffDynLib.pas
+    sed -i -e 's/if LibTiffDynLib\.LoadTiffLibrary then//' Imaging/LibTiff/ImagingTiffLib.pas
+    # Make sure libtiff is in the RPATH, so that Nix can find and track the runtime dependency
+    export NIX_LDFLAGS="$NIX_LDFLAGS -rpath ${lib.getLib libtiff}/lib"
     pushd Scripts && ./compile.sh && popd
     runHook postBuild
   '';

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

···
 
 let
   pname = "joplin-desktop";
-  version = "2.10.19";
+  version = "2.11.11";
   name = "${pname}-${version}";
 
   inherit (stdenv.hostPlatform) system;
···
   src = fetchurl {
     url = "https://github.com/laurent22/joplin/releases/download/v${version}/Joplin-${version}.${suffix}";
     sha256 = {
-      x86_64-linux = "sha256-+QvaEB+4eA3grnqbLfFMEtNyizlvovtV/BvTa9gSZGU=";
-      x86_64-darwin = "sha256-BK951HLf+L1x9TDlqW11mNnnrnHfZ4qbKk25OIVXnuM=";
+      x86_64-linux = "sha256-r64+y+LfMrJnUdabVdak5+LQB50YLOuMXftlZ4s3C/w=";
+      x86_64-darwin = "sha256-/dvaYHa7PT6FA63kmtjrErJZI9O+hIlKvHnf5RnfeZg=";
     }.${system} or throwSystem;
   };
 

pkgs/applications/misc/leetcode-cli/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "leetcode-cli";
-  version = "0.3.11";
+  version = "0.4.1";
 
   src = fetchCrate {
     inherit pname version;
-    sha256 = "sha256-DHtIhiRPRGuO6Rf1d9f8r0bMOHqAaJleUvYNyPiX6mc=";
+    sha256 = "sha256-8v10Oe3J0S9xp4b2UDOnv+W0UDgveK+mAyV3I/zZUGw=";
   };
 
-  cargoSha256 = "sha256-Suk/nQ+JcoD9HO9x1lYp+p4qx0DZ9dt0p5jPz0ZQB+k=";
+  cargoHash = "sha256-MdHk8i/murKcWi9gydyPyq/6r1SovKP04PMJyXXrCiQ=";
 
   nativeBuildInputs = [
     pkg-config

pkgs/applications/misc/logseq/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "logseq";
-  version = "0.9.9";
+  version = "0.9.10";
 
   src = fetchurl {
     url = "https://github.com/logseq/logseq/releases/download/${version}/logseq-linux-x64-${version}.AppImage";
-    hash = "sha256-DwxRhC8HKJnu1F9mfU3+UdpTjtKLhxs4LJY9A0cZvBo=";
+    hash = "sha256-en8ws0qdMY5j1o8oTkKcIHHQV+kCuQZzQbdFU97qAQE=";
     name = "${pname}-${version}.AppImage";
   };
 

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

···
 
 buildGoModule rec {
   pname = "glooctl";
-  version = "1.14.8";
+  version = "1.14.9";
 
   src = fetchFromGitHub {
     owner = "solo-io";
     repo = "gloo";
     rev = "v${version}";
-    hash = "sha256-OnoOZw85RffGiAPiAM8WLg2TjW1REgirvfAjFYt8/yY=";
+    hash = "sha256-PJvr62slTW3IoauLtRH88BDMpf3qGOWADjj4L4wQBLo=";
   };
 
   subPackages = [ "projects/gloo/cli/cmd" ];

pkgs/applications/networking/cluster/helm-dashboard/default.nix

···
 
 buildGoModule rec {
   pname = "helm-dashboard";
-  version = "1.3.2";
+  version = "1.3.3";
 
   src = fetchFromGitHub {
     owner = "komodorio";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-ukapQRTn19sNTnJ0PHc8sp8x+k1qFb3ioHZHvVtToVU=";
+    sha256 = "sha256-hjIo2AEXNcFK0z4op59NnC2R8GspF5t808DZ72AxgMw=";
   };
 
   vendorHash = "sha256-ROffm1SGYnhUcp46nzQ951eaeQdO1pb+f8AInm0eSq0=";

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

···
 
 buildGoModule rec {
   pname = "k8sgpt";
-  version = "0.3.6";
+  version = "0.3.8";
 
   src = fetchFromGitHub {
     owner = "k8sgpt-ai";
     repo = "k8sgpt";
     rev = "v${version}";
-    hash = "sha256-GAEAl59bzCffsh0XYa61R/AwwoGyFfG0M1m1U2aQiis=";
+    hash = "sha256-61u6iGz1cloIKJ2UyyQGPOZJvnAax05sI4XA9NCpJso=";
   };
 
-  vendorHash = "sha256-g0Lgu0aC25+/MYoRKMqTN8Iu8j/KA4G1DBjbhOfPpjg=";
+  vendorHash = "sha256-vmTfiUuuHHRzCwgWWzE80bq3VceRSHqpEYV7Zo7SJAI=";
 
   CGO_ENABLED = 0;
 

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

···
 
 buildGoModule rec {
   pname = "rke";
-  version = "1.4.5";
+  version = "1.4.6";
 
   src = fetchFromGitHub {
     owner = "rancher";
     repo = pname;
     rev = "v${version}";
-    hash = "sha256-ldN0Fqh0V6JziTy5ml/i/un4/1o8MSeIAvrH5EyOeiw=";
+    hash = "sha256-P/VvRoTcJuuRuoTT0zhebibBQrM6sz9Vv+qPrWY+B9Y=";
   };
 
-  vendorHash = "sha256-wuEsG2VKU4F/phSqpzUN3wChD93V4AE7poVLJu6kpF0=";
+  vendorHash = "sha256-MFXNwEEXtsEwB0Hcx8gn/Pz9dZM1zUUKhNYp5BlRUEk=";
 
   subPackages = [ "." ];
 

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

···
 
 buildGoModule rec {
   pname = "zarf";
-  version = "0.27.1";
+  version = "0.28.0";
 
   src = fetchFromGitHub {
     owner = "defenseunicorns";
     repo = "zarf";
     rev = "v${version}";
-    hash = "sha256-R9naPTipxok29wRwVNEV66tKDykGyVQPXoWs80+MyGc=";
+    hash = "sha256-TE7XP+qZkFxmms1iWDH8ziO8Rvkuo8cz8NdnMC/VU4s=";
   };
 
-  vendorHash = "sha256-6hd1OEmEQ6bYdYa1UCSXfNDFM1aAiBF6tvPmAMulRyc=";
+  vendorHash = "sha256-5HIRwOTZwElU2Ej8EhwmTtqtL6r+Hc7Vp8XjqCulo34=";
   proxyVendor = true;
 
   preBuild = ''

pkgs/applications/networking/seaweedfs/default.nix

···
 
 buildGoModule rec {
   pname = "seaweedfs";
-  version = "3.52";
+  version = "3.53";
 
   src = fetchFromGitHub {
     owner = "seaweedfs";
     repo = "seaweedfs";
     rev = version;
-    hash = "sha256-20z9gS4AWs0WiZir7fO/E1ou7H+sbySc1AX2IaPNng0=";
+    hash = "sha256-VfKzptMxT2ra1uVzbL52EWjEGHTxmnh5xZGiQpRivTU=";
   };
 
-  vendorHash = "sha256-sBvXNnZUblplDDHRy4agKSyafm2dBtS2PSMVO3MfckY=";
+  vendorHash = "sha256-kL6huukrM4YeU7uvj7abXOEAvRhm1Nfp4JODW4BTy0A=";
 
   subPackages = [ "weed" ];
 

pkgs/applications/science/machine-learning/streamlit/default.nix

···
 , rich
 , semver
 , setuptools
+, tenacity
 , toml
 , tornado
 , tzlocal
···
 
 buildPythonApplication rec {
   pname = "streamlit";
-  version = "1.21.0";
-  format = "wheel"; # source currently requires pipenv
+  version = "1.24.0";
+  format = "setuptools";
 
   src = fetchPypi {
     inherit pname version format;
-    hash = "sha256-BYYlmJUqkSbhZlLKpbyI7u6nsnc68lLi2szxyEzqrvQ=";
+    hash = "sha256-NSX6zpTHh5JzPFbWOja0iEUVDjume7UKGa20xZdagiU=";
   };
 
   propagatedBuildInputs = [
···
     rich
     semver
     setuptools
+    tenacity
     toml
     tornado
     tzlocal
···
     watchdog
   ];
 
+  # pypi package does not include the tests, but cannot be built with fetchFromGitHub
+  doCheck = false;
+
+  pythonImportsCheck = [
+    "streamlit"
+  ];
+
   postInstall = ''
     rm $out/bin/streamlit.cmd # remove windows helper
   '';
 
   meta = with lib; {
     homepage = "https://streamlit.io/";
+    changelog = "https://github.com/streamlit/streamlit/releases/tag/${version}";
     description = "The fastest way to build custom ML tools";
     maintainers = with maintainers; [ yrashk ];
     license = licenses.asl20;

pkgs/applications/science/misc/snakemake/default.nix

···
 
 python3.pkgs.buildPythonApplication rec {
   pname = "snakemake";
-  version = "7.25.3";
+  version = "7.29.0";
   format = "setuptools";
 
   src = fetchFromGitHub {
     owner = "snakemake";
     repo = pname;
     rev = "refs/tags/v${version}";
-    hash = "sha256-KrstajTocVX5Tw7aiPoJ9vxJ0nKF+jqJcYJKrJvBt0Q=";
+    hash = "sha256-Y/z7asYSRgDyDWmvfmX4y6fOMSpp0X9uhDx327YF2TI=";
   };
 
   propagatedBuildInputs = with python3.pkgs; [

pkgs/applications/version-management/git-graph/default.nix

···
+{ lib
+, rustPlatform
+, fetchFromGitHub
+, stdenv
+}:
+
+rustPlatform.buildRustPackage rec {
+  pname = "git-graph";
+  version = "unstable-2023-01-14";
+
+  src = fetchFromGitHub {
+    owner = "mlange-42";
+    repo = pname;
+    rev = "9bd54eb0aed6f108364bce9ad0bdff12077038fc";
+    hash = "sha256-tMM/mpt9yzZYSpnOGBuGLM0XTJiiyChfUrERMuyn3mQ=";
+  };
+
+  cargoHash = "sha256-ZLF/l2HnIbmkayWXhjYr01M6lGaGiK2UYyp654ncxgo=";
+
+  meta = with lib; {
+    description = "Command line tool to show clear git graphs arranged for your branching model";
+    homepage = "https://github.com/mlange-42/git-graph";
+    license = licenses.mit;
+    broken = stdenv.isDarwin;
+    maintainers = with maintainers; [ cafkafk ];
+  };
+}

pkgs/applications/version-management/git-quick-stats/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "git-quick-stats";
-  version = "2.4.0";
+  version = "2.5.0";
 
   src = fetchFromGitHub {
     repo = "git-quick-stats";
     owner = "arzzen";
     rev = version;
-    sha256 = "sha256-QmHb5MWZpbZjc93XgdPFabgzT7S522ZN27p6tdL46Y0=";
+    sha256 = "sha256-zUw0rjsYdH4mlqKXADvfqWCBM8tCL6BmVHq27JZLpd0=";
   };
 
   nativeBuildInputs = [ makeWrapper ];

pkgs/applications/video/cutecapture/default.nix

···
+{ lib
+, stdenv
+, fetchFromGitHub
+, autoreconfHook
+, libusb1
+, sfml
+}:
+
+stdenv.mkDerivation (finalAttrs: {
+  pname = "cutecapture";
+  version = "1.4.0";
+
+  src = fetchFromGitHub {
+    owner = "Gotos";
+    repo = "cutecapture";
+    rev = "v${finalAttrs.version}";
+    hash = "sha256-V8BlZykh9zOTcEypu96Ft9/6CtjsybtD8lBsg9sF5sQ=";
+  };
+
+  nativeBuildInputs = [
+    autoreconfHook
+  ];
+
+  buildInputs = [
+    libusb1
+    sfml
+  ];
+
+  postPatch = ''
+    cat > get_version.sh <<EOF
+    #!${stdenv.shell}
+    echo ${lib.escapeShellArg finalAttrs.version}
+    EOF
+  '';
+
+  postInstall = ''
+    install -Dm644 -t $out/lib/udev/rules.d 95-{3,}dscapture.rules
+  '';
+
+  meta = with lib; {
+    description = "A (3)DS capture software for Linux and Mac";
+    homepage = "https://github.com/Gotos/CuteCapture";
+    license = licenses.asl20;
+    platforms = platforms.linux ++ platforms.darwin;
+    maintainers = with maintainers; [ raphaelr ];
+  };
+})

pkgs/data/fonts/sarasa-gothic/default.nix

···
 
 stdenvNoCC.mkDerivation rec {
   pname = "sarasa-gothic";
-  version = "0.41.2";
+  version = "0.41.3";
 
   src = fetchurl {
     # Use the 'ttc' files here for a smaller closure size.
     # (Using 'ttf' files gives a closure size about 15x larger, as of November 2021.)
     url = "https://github.com/be5invis/Sarasa-Gothic/releases/download/v${version}/sarasa-gothic-ttc-${version}.7z";
-    hash = "sha256-AkfjtXeZkwzXLu81hS43vYPEMKl3TV1TnQ4ryUSnblc=";
+    hash = "sha256-/VC9zhWC3jJuIXQ2fel6moLzrdsguPaylgfkY9FoClQ=";
   };
 
   sourceRoot = ".";

pkgs/data/misc/hackage/pin.json

···
 {
-  "commit": "4744eb212287f09a540ba7de2a4837b504956ed4",
-  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/4744eb212287f09a540ba7de2a4837b504956ed4.tar.gz",
-  "sha256": "1lwdnjmndmixnv8saq68g45skf9yc3zq9npjm8gv9pdga7vy3m96",
-  "msg": "Update from Hackage at 2023-05-31T06:44:49Z"
+  "commit": "2951c03cb95b8892bd6d4eb89d135764c35a8d7f",
+  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/2951c03cb95b8892bd6d4eb89d135764c35a8d7f.tar.gz",
+  "sha256": "08sh9l9df2p51q4xhrl14jga48i0ad78fp7w3cccgcw1bqq4yxml",
+  "msg": "Update from Hackage at 2023-06-19T20:13:38Z"
 }

pkgs/development/compilers/ghc/9.6.1.nix

···
-import ./common-hadrian.nix rec {
-  version = "9.6.1";
-  sha256 = "fe5ac909cb8bb087e235de97fa63aff47a8ae650efaa37a2140f4780e21f34cb";
-}

pkgs/development/compilers/ghc/head.nix

···
 import ./common-hadrian.nix {
-  version = "9.7.20230505";
-  rev = "983ce55815f2dd57f84ee86eee97febf7d80b470";
-  sha256 = "sha256-U+LZIe9WbF/DF5Zn8w8wkRf4JJHxgdY2ahM517bwRo4=";
+  version = "9.7.20230527";
+  rev = "69fdbece5f6ca0a718bb9f1fef7b0ab57cf6b664";
+  sha256 = "13rf1d27wdich0kmbds55by9vj3wz0v9clba9p8qpwz7x7wpcjz2";
 }

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

···
       "vector-tests-O0"
       "vector-tests-O2"
     ];
+    patches = [
+      # Workaround almost guaranteed floating point errors in test suite with quickcheck 2.14.3
+      # https://github.com/haskell/vector/issues/460
+      (pkgs.fetchpatch {
+        name = "vector-quickcheck-2.14.3-float-workaround.patch";
+        url = "https://github.com/haskell/vector/commit/df8dd8e8e84005aa6b187b03cd502f3c6e18cf3c.patch";
+        sha256 = "040wg8mqlkdnrl5axy9wk0mlpn8rpc4vc4afpxignj9i7yc4pfjj";
+        stripLen = 1;
+     })
+   ];
   }) super.vector;
 
+  # Almost guaranteed failure due to floating point imprecision with QuickCheck-2.14.3
+  # https://github.com/haskell/math-functions/issues/73
+  math-functions = overrideCabal (drv: {
+    testFlags = drv.testFlags or [] ++ [ "-p" "! /Kahan.t_sum_shifted/" ];
+  }) super.math-functions;
+
+  # Deal with infinite and NaN values generated by QuickCheck-2.14.3
+  inherit (
+    let
+      aesonQuickCheckPatch = appendPatches [
+        (pkgs.fetchpatch {
+          name = "aeson-quickcheck-2.14.3-double-workaround.patch";
+          url = "https://github.com/haskell/aeson/commit/58766a1916b4980792763bab74f0c86e2a7ebf20.patch";
+          sha256 = "1jk2xyi9g6dfjsi6hvpvkpmag3ivimipwy1izpbidf3wvc9cixs3";
+        })
+      ];
+    in
+    {
+      aeson = aesonQuickCheckPatch super.aeson;
+      aeson_2_1_2_1 = aesonQuickCheckPatch super.aeson_2_1_2_1;
+    }
+  ) aeson
+    aeson_2_1_2_1
+    ;
+
+  # 2023-06-28: Test error: https://hydra.nixos.org/build/225565149
+  orbits = dontCheck super.orbits;
+
+  # 2023-06-28: Test error: https://hydra.nixos.org/build/225559546
+  monad-bayes = dontCheck super.monad-bayes;
+
+  # Disable tests failing on odd floating point numbers generated by QuickCheck 2.14.3
+  # https://github.com/haskell/statistics/issues/205
+  statistics = overrideCabal (drv: {
+    testFlags = [
+      "-p" "! (/Pearson correlation/ || /t_qr/ || /Tests for: FDistribution.1-CDF is correct/)"
+    ];
+  }) super.statistics;
+
   # There are numerical tests on random data, that may fail occasionally
   lapack = dontCheck super.lapack;
 
···
   # successfully with recent versions of the compiler).
   bin-package-db = null;
 
+  # Unnecessarily requires alex >= 3.3
+  # https://github.com/glguy/config-value/commit/c5558c8258598fab686c259bff510cc1b19a0c50#commitcomment-119514821
+  config-value = doJailbreak super.config-value;
+
   # waiting for release: https://github.com/jwiegley/c2hsc/issues/41
   c2hsc = appendPatch (fetchpatch {
     url = "https://github.com/jwiegley/c2hsc/commit/490ecab202e0de7fc995eedf744ad3cb408b53cc.patch";
···
   ghc-heap-view = disableLibraryProfiling super.ghc-heap-view;
   ghc-datasize = disableLibraryProfiling super.ghc-datasize;
   ghc-vis = disableLibraryProfiling super.ghc-vis;
+
+  # 2023-06-10: Too strict version bound on https://github.com/haskell/ThreadScope/issues/118
+  threadscope = doJailbreak super.threadscope;
 
   # patat main branch has an unreleased commit that fixes the build by
   # relaxing restrictive upper boundaries. This can be removed once there's a
···
   webdriver-angular = dontCheck super.webdriver-angular;
   xsd = dontCheck super.xsd;
   zip-archive = dontCheck super.zip-archive;  # https://github.com/jgm/zip-archive/issues/57
+
+  # 2023-06-26: Test failure: https://hydra.nixos.org/build/224869905
+  comfort-blas = dontCheck super.comfort-blas;
+
+  # 2022-06-26: Too strict lower bound on semialign.
+  trie-simple = doJailbreak super.trie-simple;
 
   # These test suites run for ages, even on a fast machine. This is nuts.
   Random123 = dontCheck super.Random123;
···
   # jailbreak tasty < 1.2 until servant-docs > 0.11.3 is on hackage.
   snap-templates = doJailbreak super.snap-templates; # https://github.com/snapframework/snap-templates/issues/22
 
-  # Copy hledger man pages from data directory into the proper place. This code
-  # should be moved into the cabal2nix generator.
-  hledger = overrideCabal (drv: {
-    postInstall = ''
-      # Don't install files that don't belong into this package to avoid
-      # conflicts when hledger and hledger-ui end up in the same profile.
-      rm embeddedfiles/hledger-{api,ui,web}.*
-      for i in $(seq 1 9); do
-        for j in embeddedfiles/*.$i; do
-          mkdir -p $out/share/man/man$i
-          cp -v $j $out/share/man/man$i/
-        done
-      done
-      mkdir -p $out/share/info
-      cp -v embeddedfiles/*.info* $out/share/info/
-    '';
-  }) super.hledger;
-  hledger_1_29_2 = doDistribute (super.hledger_1_29_2.override {
-    hledger-lib = self.hledger-lib_1_29_2;
-  });
-  hledger-ui = overrideCabal (drv: {
-    postInstall = ''
-      for i in $(seq 1 9); do
-        for j in *.$i; do
-          mkdir -p $out/share/man/man$i
-          cp -v $j $out/share/man/man$i/
-        done
-      done
-      mkdir -p $out/share/info
-      cp -v *.info* $out/share/info/
-    '';
-  }) super.hledger-ui;
-  hledger-web = overrideCabal (drv: {
-    preCheck = "export HOME=$TMPDIR";
-    postInstall = ''
-      for i in $(seq 1 9); do
-        for j in *.$i; do
-          mkdir -p $out/share/man/man$i
-          cp -v $j $out/share/man/man$i/
-        done
-      done
-      mkdir -p $out/share/info
-      cp -v *.info* $out/share/info/
-    '';
-  }) super.hledger-web;
-
-
   # https://github.com/haskell-hvr/resolv/pull/6
   resolv_0_1_1_2 = dontCheck super.resolv_0_1_1_2;
 
···
     });
   };
 
-
-  # 2023-04-16: https://github.com/ghcjs/jsaddle/pull/137
-  jsaddle-webkit2gtk = lib.pipe super.jsaddle-webkit2gtk
-    [
-      (appendPatch (fetchpatch {
-        url = "https://github.com/ghcjs/jsaddle/commit/f990366f19d23a8008d482572d52351c1a6f7215.patch";
-        hash = "sha256-IbkJrlyG6q5rqMIhn//Dt3u6T314Pug+mQMwwe0LK5w=";
-        relative = "jsaddle-webkit2gtk";
-      }))
-      (overrideCabal (old: {
-        postPatch = old.postPatch or "" + ''
-          sed -i 's/bytestring.*0.11/bytestring/' jsaddle-webkit2gtk.cabal
-        '';
-      }))
-    ];
+  # 2023-06-24: too strict upper bound on bytestring
+  jsaddle-webkit2gtk =
+    appendPatches [
+      (pkgs.fetchpatch {
+        name = "jsaddle-webkit2gtk-ghc-9.2.patch";
+        url = "https://github.com/ghcjs/jsaddle/commit/d2ce9e6be1dcba0ab417314a0b848012d1a47e03.diff";
+        stripLen = 1;
+        includes = [ "jsaddle-webkit2gtk.cabal" ];
+        sha256 = "16pcs3l7s8shhcnrhi80bwjgy7w23csd9b8qpmc5lnxn4wxr4c2r";
+      })
+      (pkgs.fetchpatch {
+        name = "jsaddle-webkit2gtk-ghc-9.6.patch";
+        url = "https://github.com/ghcjs/jsaddle/commit/99b23dac8b4c5b23f5ed7963e681a46c1abdd1a5.patch";
+        sha256 = "02rdifap9vzf6bhjp5siw68ghjrxh2phzd0kwjihf3hxi4a2xlp3";
+        stripLen = 1;
+        includes = [ "jsaddle-webkit2gtk.cabal" ];
+      })
+    ] super.jsaddle-webkit2gtk;
 
   # 2022-03-16: lens bound can be loosened https://github.com/ghcjs/jsaddle-dom/issues/19
   jsaddle-dom = overrideCabal (old: {
···
     url = "https://github.com/jkff/splot/commit/a6710b05470d25cb5373481cf1cfc1febd686407.patch";
     sha256 = "1c5ck2ibag2gcyag6rjivmlwdlp5k0dmr8nhk7wlkzq2vh7zgw63";
   }) super.splot;
+
+  # Fix build with newer monad-logger: https://github.com/obsidiansystems/monad-logger-extras/pull/5
+  monad-logger-extras = appendPatch (fetchpatch {
+    url = "https://github.com/obsidiansystems/monad-logger-extras/commit/55d414352e740a5ecacf313732074d9b4cf2a6b3.patch";
+    sha256 = "sha256-xsQbr/QIrgWR0uwDPtV0NRTbVvP0tR9bY9NMe1JzqOw=";
+  }) super.monad-logger-extras;
 
   # Fails with encoding problems, likely needs locale data.
   # Test can be executed by adding which to testToolDepends and
···
   #   so add them to build input and also wrap the resulting binary so they're in
   #   PATH.
   # - Patch can be removed on next package set bump (for v0.2.11)
-  update-nix-fetchgit = let deps = [ pkgs.git pkgs.nix pkgs.nix-prefetch-git ];
+
+  # 2023-06-26: Test failure: https://hydra.nixos.org/build/225081865
+  update-nix-fetchgit = dontCheck (let deps = [ pkgs.git pkgs.nix pkgs.nix-prefetch-git ];
   in self.generateOptparseApplicativeCompletions [ "update-nix-fetchgit" ] (overrideCabal
     (drv: {
       buildTools = drv.buildTools or [ ] ++ [ pkgs.buildPackages.makeWrapper ];
···
           lib.makeBinPath deps
         }"
       '';
-    }) (addTestToolDepends deps super.update-nix-fetchgit));
+    }) (addTestToolDepends deps super.update-nix-fetchgit)));
 
   # Raise version bounds: https://github.com/idontgetoutmuch/binary-low-level/pull/16
   binary-strict = appendPatches [
···
     sha256 = "1lpcz671mk5cwqffjfi9ncc0d67bmwgzypy3i37a2fhfmxd0y3nl";
   }) ((p: assert p.version == "4.0.0"; p) super.taffybar);
 
+  # Tests likely broke because of https://github.com/nick8325/quickcheck/issues/359,
+  # but fft is not on GitHub, so no issue reported.
+  fft = dontCheck super.fft;
+
   # lucid-htmx has restrictive upper bounds on lucid and servant:
   #
   #   Setup: Encountered missing or private dependencies:
···
 
   # Tests fail due to the newly-build fourmolu not being in PATH
   # https://github.com/fourmolu/fourmolu/issues/231
-  fourmolu_0_12_0_0 = dontCheck (super.fourmolu_0_12_0_0.overrideScope (lself: lsuper: {
+  fourmolu_0_13_0_0 = dontCheck (super.fourmolu_0_13_0_0.overrideScope (lself: lsuper: {
     Cabal-syntax = lself.Cabal-syntax_3_10_1_0;
     ghc-lib-parser = lself.ghc-lib-parser_9_6_2_20230523;
     parsec = lself.parsec_3_1_16_1;
···
     url = "https://github.com/vincenthz/hs-gauge/commit/3d7776f41187c70c4f0b4517e6a7dde10dc02309.patch";
     hash = "sha256-4osUMo0cvTvyDTXF8lY9tQbFqLywRwsc3RkHIhqSriQ=";
   }) super.gauge;
+
+  # Flaky QuickCheck tests
+  # https://github.com/Haskell-Things/ImplicitCAD/issues/441
+  implicit = dontCheck super.implicit;
 } // import ./configuration-tensorflow.nix {inherit pkgs haskellLib;} self super

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

···
   ghc-exactprint = overrideCabal (drv: {
     libraryHaskellDepends = with self; [ HUnit data-default fail filemanip free ghc-paths ordered-containers silently syb Diff ];
   })
-    self.ghc-exactprint_1_6_1_1;
+    self.ghc-exactprint_1_6_1_3;
 
   # needed to build servant
   http-api-data = super.http-api-data_0_5_1;

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

···
   turtle = doDistribute self.turtle_1_6_1;
   aeson = doDistribute self.aeson_2_1_2_1;
   memory = doDistribute self.memory_0_18_0;
+  semigroupoids = doDistribute self.semigroupoids_6_0_0_1;
+  bifunctors = doDistribute self.bifunctors_5_6_1;
+  cabal-plan = doDistribute self.cabal-plan_0_7_3_0;
+  base-compat = doDistribute self.base-compat_0_13_0;
+  base-compat-batteries = doDistribute self.base-compat-batteries_0_13_0;
+  semialign = doDistribute self.semialign_1_3;
+  assoc = doDistribute self.assoc_1_1;
+  strict = doDistribute self.strict_0_5;
 
   ghc-lib = doDistribute self.ghc-lib_9_6_2_20230523;
   ghc-lib-parser = doDistribute self.ghc-lib-parser_9_6_2_20230523;
···
   #
   # Too strict bounds, waiting on Hackage release in nixpkgs
   #
-
-  # base >= 4.18 is allowed in those newer versions
-  boring = assert !(self ? boring_0_2_1); doJailbreak super.boring;
-  these = assert !(self ? assoc_1_2); doJailbreak super.these;
-
-  # XXX: We probably should be using semigroupoids 6.0.1 which is intended for 9.6
-  semigroupoids = doJailbreak super.semigroupoids;
-  # XXX: 1.3 supports 9.6 properly, but is intended for bifunctors >= 5.6
-  semialign = doJailbreak super.semialign;
 
   #
   # Compilation failure workarounds
···
   hiedb = dontCheck super.hiedb;
   retrie = dontCheck (super.retrie);
 
+  # break infinite recursion with foldable1-classes-compat's test suite, which depends on 'these'.
+  these = doDistribute (super.these_1_2.override { foldable1-classes-compat = dontCheck super.foldable1-classes-compat; });
+
   ghc-exactprint = unmarkBroken (addBuildDepends (with self.ghc-exactprint.scope; [
    HUnit Diff data-default extra fail free ghc-paths ordered-containers silently syb
-  ]) super.ghc-exactprint_1_7_0_0);
+  ]) super.ghc-exactprint_1_7_0_1);
 
   inherit (pkgs.lib.mapAttrs (_: doJailbreak ) super)
     hls-cabal-plugin
···
     tree-diff
     implicit-hie-cradle
     focus
-    hie-compat;
+    hie-compat
+    xmonad-contrib              # mtl >=1 && <2.3
+    dbus       # template-haskell >=2.18 && <2.20, transformers <0.6, unix <2.8
+  ;
+
+  # Apply workaround for Cabal 3.8 bug https://github.com/haskell/cabal/issues/8455
+  # by making `pkg-config --static` happy. Note: Cabal 3.9 is also affected, so
+  # the GHC 9.6 configuration may need similar overrides eventually.
+  X11-xft = __CabalEagerPkgConfigWorkaround super.X11-xft;
+  # Jailbreaks for https://github.com/gtk2hs/gtk2hs/issues/323#issuecomment-1416723309
+  glib = __CabalEagerPkgConfigWorkaround (doJailbreak super.glib);
+  cairo = __CabalEagerPkgConfigWorkaround (doJailbreak super.cairo);
+  pango = __CabalEagerPkgConfigWorkaround (doJailbreak super.pango);
+
+  # Pending text-2.0 support https://github.com/gtk2hs/gtk2hs/issues/327
+  gtk = doJailbreak super.gtk;
+
+  # Doctest comments have bogus imports.
+  bsb-http-chunked = dontCheck super.bsb-http-chunked;
+
+  # Fix ghc-9.6.x build errors.
+  libmpd = appendPatch
+    (pkgs.fetchpatch { url = "https://github.com/vimus/libmpd-haskell/pull/138.patch";
+                       sha256 = "sha256-CvvylXyRmoCoRJP2MzRwL0SBbrEzDGqAjXS+4LsLutQ=";
+                     })
+    super.libmpd;
+
 }

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

···
   - agda-snippets
   - agda-unused
   - AGI
+  - ag-pictgen # failure in compileBuildDriverPhase in job https://hydra.nixos.org/build/225557198 at 2023-06-28
   - AhoCorasick
   - aig
   - airbrake
···
   - ascii-string
   - ascii-vector-avc
   - asif
+  - asil # failure in compileBuildDriverPhase in job https://hydra.nixos.org/build/225556674 at 2023-06-28
   - asn1-ber-syntax
   - asn1-codec
   - asn1-data
···
   - assumpta
   - ast-monad
   - astrds
+  - astro #  failure  in job https://hydra.nixos.org/build/225575437 at 2023-06-28
   - async-combinators
   - async-dejafu
   - asynchronous-exceptions
···
   - cabal2doap
   - cabal2ebuild
   - cabal2ghci
+  - cabal2json # dependency missing in job https://hydra.nixos.org/build/225572535 at 2023-06-28
   - cabal-audit
   - cabal-auto-expose
   - cabal-bundle-clib
···
   - chaselev-deque
   - chatty-text
   - chatwork
+  - check-cfg-ambiguity #  failure  in job https://hydra.nixos.org/build/225575902 at 2023-06-28
   - checked
   - Checked
   - checkmate
···
   - cipher-des
   - circle
   - circlehs
+  - circular-enum # dependency missing in job https://hydra.nixos.org/build/225566485 at 2023-06-28
   - citeproc-hs
   - cjk
   - cj-token
···
   - commodities
   - compact
   - Compactable
+  - compactable # dependency missing in job https://hydra.nixos.org/build/225560369 at 2023-06-28
   - compact-list
   - compact-map
   - compact-sequences
···
   - contiguous-checked
   - contiguous-fft
   - continue
+  - continued-fractions #  failure  in job https://hydra.nixos.org/build/225575101 at 2023-06-28
   - contracheck-applicative
   - Contract
   - contra-tracers
···
   - crypto-keys-ssh
   - crypto-multihash
   - crypto-numbers
+  - crypton-x509 # failure building test suite 'test-x509' in job https://hydra.nixos.org/build/225569131 at 2023-06-28
   - crypto-pubkey-openssh
   - crypto-random-effect
   - crypto-simple
···
   - ctkl
   - cuboid
   - cuckoo-filter
+  - cuckoo # test failure in job https://hydra.nixos.org/build/225558690 at 2023-06-28
   - curl-aeson
   - curl-runnings
   - curly-expander
···
   - datetime-sb
   - dawdle
   - dawg
+  - daytripper #  failure  in job https://hydra.nixos.org/build/225578117 at 2023-06-28
   - dbcleaner
   - dbf
   - DBlimited
···
   - eventsource-api
   - eventsourced
   - eventstore
+  - ewe # failure building executable 'ewe' in job https://hydra.nixos.org/build/225555839 at 2023-06-28
   - exact-cover
   - exact-real-positional
   - except-exceptions
···
   - Feval
   - fez-conf
   - ffeed
-  - fft
   - ffunctor
   - fgl-extras-decompositions
   - fib
···
   - fortran-src-extras
   - foscam-filename
   - fpe
+  - fp-ieee # test failure in job https://hydra.nixos.org/build/225561952 at 2023-06-28
   - FPretty
   - fptest
   - fquery
···
   - fresnel
   - friday-devil
   - friday-scale-dct
+  - friday # test failure in job https://hydra.nixos.org/build/225561573 at 2023-06-28
   - frown
   - frp-arduino
   - frpnow
···
   - hadoop-streaming
   - hafar
   - Haggressive
+  - HaGL # test failure in job https://hydra.nixos.org/build/225563740 at 2023-06-28
   - hahp
   - haiji
   - hail
···
   - HaLeX
   - halfs
   - half-space
-  - halide-haskell # failure in compileBuildDriverPhase in job https://hydra.nixos.org/build/212823532 at 2023-03-22
   - halipeto
   - halive
   - halma
···
   - instant-generics
   - instapaper-sender
   - instinct
+  - integer-conversion # dependency missing in job https://hydra.nixos.org/build/225563519 at 2023-06-28
   - integer-pure
   - integer-simple
   - intensional-datatys
···
   - keccak
   - keenser
   - keera-hails-reactivevalues
+  - keid-render-basic #  failure  in job https://hydra.nixos.org/build/225578420 at 2023-06-28
   - keid-ui-dearimgui
   - keiretsu
   - kempe
···
   - lookup-tables
   - loopbreaker
   - loop-dsl
+  - looper # failure building test suite 'looper-test' in job https://hydra.nixos.org/build/225553593 at 2023-06-28
   - loops
   - loop-while
   - loopy
···
   - midi-simple
   - midisurface # dependency missing in job https://hydra.nixos.org/build/217805409 at 2023-04-29
   - midi-utils
+  - mighttpd2 #  failure  in job https://hydra.nixos.org/build/225576224 at 2023-06-28
   - mighty-metropolis # test failure in job https://hydra.nixos.org/build/214599789 at 2023-04-07
   - migrant-postgresql-simple
   - mikmod
···
   - monad-stlike-io
   - monad-task
   - monad-throw-exit
+  - monad-time-effectful # failure building library in job https://hydra.nixos.org/build/225552858 at 2023-06-28
   - monad-timing
   - monad-tree
   - monad-tx
···
   - polysemy-socket
   - polysemy-video
   - polysemy-vinyl
+  - poly # test failure in job https://hydra.nixos.org/build/225574715 at 2023-06-28
   - polytypeable
   - pomaps
   - pomohoro
···
   - SableCC2Hs
   - safe-buffer-monad
   - safe-coerce
+  - safe-coloured-text-gen # test failure in job https://hydra.nixos.org/build/225565471 at 2023-06-28
+  - safe-coloured-text-layout # test failure in job https://hydra.nixos.org/build/225562935 at 2023-06-28
   - safecopy-migrate
   - safecopy-store
   - safe-freeze
···
   - signable
   - signable-haskell-protoc
   - signed-multiset
+  - significant-figures # test failure in job https://hydra.nixos.org/build/225555677 at 2023-06-28
   - simd
   - simfin
   - simple-actors
···
   - sousit
   - soyuz
   - spacepart
+  - spade # dependency missing in job https://hydra.nixos.org/build/225563353 at 2023-06-28
   - spake2
   - spanout
   - spars
···
   - statistics-dirichlet
   - statistics-fusion
   - statistics-hypergeometric-genvar
+  - statistics-skinny #  failure  in job https://hydra.nixos.org/build/225576019 at 2023-06-28
   - stats
   - statsd
   - statvfs
···
   - sws
   - syb-extras
   - syb-with-class-instances-text
-  - sydtest
+  - sydtest-hedis # test failure in job https://hydra.nixos.org/build/225562212 at 2023-06-28
+  - sydtest-mongo #  failure  in job https://hydra.nixos.org/build/225574398 at 2023-06-28
+  - sydtest-persistent-postgresql # test failure in job https://hydra.nixos.org/build/225560820 at 2023-06-28
+  - sydtest-persistent-sqlite # test failure in job https://hydra.nixos.org/build/225566898 at 2023-06-28
+  - sydtest-rabbitmq # test failure in job https://hydra.nixos.org/build/225569272 at 2023-06-28
+  - sydtest-webdriver # test failure in job https://hydra.nixos.org/build/225552802 at 2023-06-28
   - syfco
   - sym
   - symantic
···
   - thorn
   - th-pprint
   - threadmanager
-  - threadscope
   - thread-supervisor # test failure in job https://hydra.nixos.org/build/214156434 at 2023-03-29
   - threepenny-editors
   - threepenny-gui-contextmenu
···
   - tidal-vis
   - tie-knot
   - tiempo
+  - tiger # failure in compileBuildDriverPhase in job https://hydra.nixos.org/build/225568410 at 2023-06-28
   - TigerHash
   - tightrope
   - tikzsd
···
   - util-plus
   - util-primitive
   - uuagc-bootstrap
-  - uuagc-cabal
   - uuagc-diagrams
   - uu-cco
   - uuid-aeson

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

···
   - dhall-nixpkgs == 1.0.9
   - dhall-nix == 1.1.25
 
+  # 2023-06-24: HLS at large can't deal with lsp-2.0.0.0 yet
+  - lsp == 1.6.*
+  - lsp-types == 1.6.*
+  - lsp-test == 0.14.*
+
 extra-packages:
   - Cabal == 2.2.*                      # required for jailbreak-cabal etc.
   - Cabal == 2.4.*                      # required for cabal-install etc.
···
     - streamly
     - streamly-bytestring
     - taskwarrior
+    - threadscope
     - tz
     - weeder
     - witch
···
   gi-gtkosxapplication:                         [ platforms.darwin ]
   gtk-mac-integration:                          [ platforms.darwin ]
   gtk3-mac-integration:                         [ platforms.darwin ]
+  halide-haskell:                               [ platforms.linux ]
+  halide-JuicyPixels:                           [ platforms.linux ]
   hommage-ds:                                   [ platforms.windows ]
   hpapi:                                        [ platforms.linux ] # limited by pkgs.papi
   hsignal:                                      [ platforms.x86 ] # -msse2

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

···
-# Stackage LTS 20.23
+# Stackage LTS 20.26
 # This file is auto-generated by
 # maintainers/scripts/haskell/update-stackage.sh
 default-package-overrides:
···
   - ace ==0.6
   - acid-state ==0.16.1.2
   - action-permutations ==0.0.0.1
-  - active ==0.2.0.17
+  - active ==0.2.0.18
   - ad ==4.5.4
   - ad-delcont ==0.3.0.0
   - adjunctions ==4.4.2
···
   - aeson-picker ==0.1.0.6
   - aeson-pretty ==0.8.9
   - aeson-qq ==0.8.4
-  - aeson-schemas ==1.4.0.1
+  - aeson-schemas ==1.4.1.0
   - aeson-typescript ==0.4.2.0
   - aeson-value-parser ==0.19.7.1
   - aeson-yak ==0.1.1.3
···
   - base64-string ==0.2
   - base-compat ==0.12.2
   - base-compat-batteries ==0.12.2
-  - basement ==0.0.15
+  - basement ==0.0.16
   - base-orphans ==0.8.8.2
   - base-prelude ==1.6.1
   - base-unicode-symbols ==0.2.4.2
···
   - bazel-runfiles ==0.12
   - bbdb ==0.8
   - bcp47 ==0.2.0.6
-  - bcp47-orphans ==0.1.0.5
+  - bcp47-orphans ==0.1.0.6
   - bcrypt ==0.0.11
   - beam-core ==0.9.2.1
   - beam-migrate ==0.5.1.2
   - beam-postgres ==0.5.2.1
   - beam-sqlite ==0.5.1.2
-  - bech32 ==1.1.2
+  - bech32 ==1.1.3
   - bech32-th ==1.1.1
   - bench ==1.0.12
   - benchpress ==0.2.2.22
···
   - bitvec ==1.1.4.0
   - bitwise-enum ==1.0.1.0
   - blake2 ==0.3.0
-  - Blammo ==1.1.1.2
+  - Blammo ==1.1.2.0
   - blank-canvas ==0.7.3
   - blanks ==0.5.0
   - blas-carray ==0.1.0.2
···
   - blaze-builder ==0.4.2.2
   - blaze-html ==0.9.1.2
   - blaze-markup ==0.8.2.8
-  - blaze-svg ==0.3.6.1
+  - blaze-svg ==0.3.7
   - blaze-textual ==0.2.3.1
   - bloodhound ==0.21.0.0
   - bm ==0.1.1.0
···
   - c2hs ==0.28.8
   - cabal2spec ==2.6.3
   - cabal-appimage ==0.3.0.5
-  - cabal-clean ==0.2.20220819
+  - cabal-clean ==0.2.20230609
   - cabal-debian ==5.2.1
   - cabal-doctest ==1.0.9
   - cabal-file ==0.1.1
···
   - colour ==2.3.6
   - columnar ==1.0.0.0
   - combinatorial ==0.1.1
-  - comfort-array ==0.5.2.1
+  - comfort-array ==0.5.2.3
   - comfort-array-shape ==0.0
   - comfort-fftw ==0.0.0.1
   - comfort-graph ==0.0.3.2
···
   - composition-extra ==2.0.0
   - composition-prelude ==3.0.0.2
   - concise ==0.1.0.1
-  - concurrency ==1.11.0.2
+  - concurrency ==1.11.0.3
   - concurrent-extra ==0.7.0.12
   - concurrent-output ==1.10.18
   - concurrent-split ==0.0.1.1
···
   - copr-api ==0.1.0
   - core-data ==0.3.9.1
   - core-program ==0.6.8.0
-  - core-telemetry ==0.2.9.1
+  - core-telemetry ==0.2.9.3
   - core-text ==0.3.8.1
   - countable ==1.2
   - country ==0.2.3
···
   - data-default-instances-text ==0.0.1
   - data-default-instances-unordered-containers ==0.0.1
   - data-default-instances-vector ==0.0.1
-  - data-diverse ==4.7.0.0
+  - data-diverse ==4.7.1.0
   - datadog ==0.3.0.0
   - data-dword ==0.3.2.1
   - data-endian ==0.1.1
···
   - dawg-ord ==0.5.1.2
   - dbcleaner ==0.1.3
   - DBFunctor ==0.1.2.1
-  - dbus ==1.2.28
+  - dbus ==1.2.29
   - dbus-hslogger ==0.1.0.1
   - debian ==4.0.4
   - debian-build ==0.10.2.1
···
   - declarative ==0.5.4
   - deepseq-generics ==0.2.0.0
   - deferred-folds ==0.9.18.3
-  - dejafu ==2.4.0.4
+  - dejafu ==2.4.0.5
   - dense-linear-algebra ==0.1.0.0
   - dependent-map ==0.4.0.0
   - dependent-sum ==0.7.2.0
···
   - diagrams-core ==1.5.1
   - diagrams-lib ==1.4.5.2
   - diagrams-postscript ==1.5.1.1
-  - diagrams-rasterific ==1.4.2.2
+  - diagrams-rasterific ==1.4.2.3
   - diagrams-solve ==0.1.3
   - diagrams-svg ==1.4.3.1
   - di-core ==1.0.4
···
   - dlist ==1.0
   - dlist-instances ==0.1.1.1
   - dlist-nonempty ==0.1.2
-  - dns ==4.1.0
+  - dns ==4.1.1
   - docker ==0.7.0.1
   - dockerfile ==0.2.0
   - doclayout ==0.4.0.1
···
   - elm-bridge ==0.8.2
   - elm-core-sources ==1.0.0
   - elm-export ==0.6.0.1
-  - elynx ==0.7.2.0
-  - elynx-markov ==0.7.2.0
-  - elynx-nexus ==0.7.2.0
-  - elynx-seq ==0.7.2.0
-  - elynx-tools ==0.7.2.0
-  - elynx-tree ==0.7.2.0
+  - elynx ==0.7.2.1
+  - elynx-markov ==0.7.2.1
+  - elynx-nexus ==0.7.2.1
+  - elynx-seq ==0.7.2.1
+  - elynx-tools ==0.7.2.1
+  - elynx-tree ==0.7.2.1
   - emacs-module ==0.1.1.1
   - email-validate ==2.3.2.18
   - emojis ==0.1.2
···
   - errors ==2.3.0
   - errors-ext ==0.4.2
   - ersatz ==0.4.13
-  - esqueleto ==3.5.9.0
+  - esqueleto ==3.5.10.0
   - essence-of-live-coding ==0.2.7
   - essence-of-live-coding-gloss ==0.2.7
   - essence-of-live-coding-pulse ==0.2.7
···
   - FontyFruity ==0.5.3.5
   - force-layout ==0.4.0.6
   - foreign-store ==0.2
-  - ForestStructures ==0.0.1.0
+  - ForestStructures ==0.0.1.1
   - forkable-monad ==0.2.0.3
   - forma ==1.2.0
   - formatn ==0.2.2
   - format-numbers ==0.1.0.1
   - formatting ==7.1.3
   - fortran-src ==0.12.0
-  - foundation ==0.0.29
+  - foundation ==0.0.30
   - fourmolu ==0.9.0.0
   - freckle-app ==1.3.0.0
   - free ==5.1.10
···
   - funcmp ==1.9
   - function-builder ==0.3.0.1
   - functor-classes-compat ==2.0.0.2
-  - fused-effects ==1.1.2.1
+  - fused-effects ==1.1.2.2
   - fusion-plugin ==0.2.6
   - fusion-plugin-types ==0.1.0
   - fuzzcheck ==0.1.1
···
   - genvalidity-uuid ==1.0.0.1
   - genvalidity-vector ==1.0.0.0
   - geodetics ==0.1.2
-  - geojson ==4.1.0
+  - geojson ==4.1.1
   - getopt-generics ==0.13.1.0
   - ghc-bignum-orphans ==0.1.1
   - ghc-byteorder ==4.11.0.0.10
···
   - gi-gobject ==2.0.30
   - gi-graphene ==1.0.7
   - gi-gtk ==3.0.41
-  - gi-gtk-hs ==0.3.14
+  - gi-gtk-hs ==0.3.16
   - gi-gtksource ==3.0.28
   - gi-harfbuzz ==0.0.9
   - gi-javascriptcore ==4.0.27
···
   - githash ==0.1.6.3
   - github ==0.28.0.1
   - github-release ==2.0.0.6
-  - github-rest ==1.1.2
+  - github-rest ==1.1.3
   - github-types ==0.2.1
   - github-webhooks ==0.16.0
   - gitlab-haskell ==1.0.0.1
···
   - gpolyline ==0.1.0.1
   - graph-core ==0.3.0.0
   - graphite ==0.10.0.1
-  - graphql-client ==1.2.1
+  - graphql-client ==1.2.2
   - graphs ==0.7.2
   - graphula ==2.0.2.2
   - graphviz ==2999.20.1.0
···
   - hashmap ==1.3.3
   - hashtables ==1.3.1
   - haskeline ==0.8.2.1
-  - haskell-gi ==0.26.4
-  - haskell-gi-base ==0.26.3
+  - haskell-gi ==0.26.7
+  - haskell-gi-base ==0.26.4
   - haskell-gi-overloading ==1.0
   - haskell-lexer ==1.1.1
-  - HaskellNet ==0.6.0.2
+  - HaskellNet ==0.6.1.2
   - HaskellNet-SSL ==0.3.4.4
   - haskell-src ==1.0.4
   - haskell-src-exts ==1.23.1
···
   - hindent ==5.3.4
   - hinfo ==0.0.3.0
   - hinotify ==0.4.1
-  - hint ==0.9.0.6
+  - hint ==0.9.0.7
   - hip ==1.5.6.0
   - histogram-fill ==0.9.1.0
   - hjsmin ==0.2.0.4
···
   - http-client-restricted ==0.0.5
   - http-client-tls ==0.3.6.1
   - http-common ==0.8.3.4
-  - http-conduit ==2.3.8
+  - http-conduit ==2.3.8.1
   - http-date ==0.0.11
   - http-directory ==0.1.10
   - http-download ==0.2.0.0
···
   - interpolatedstring-perl6 ==1.0.2
   - interpolation ==0.1.1.2
   - Interpolation ==0.3.0
-  - IntervalMap ==0.6.2.0
+  - IntervalMap ==0.6.2.1
   - intervals ==0.9.2
   - intset-imperative ==0.1.0.0
   - invariant ==0.6.1
···
   - mcmc ==0.8.2.0
   - mcmc-types ==1.0.3
   - median-stream ==0.7.0.0
-  - med-module ==0.1.2.2
+  - med-module ==0.1.3
   - megaparsec ==9.2.2
   - megaparsec-tests ==9.2.2
   - mega-sdist ==0.4.2.1
···
   - monad-journal ==0.8.1
   - monadlist ==0.0.2
   - monadloc ==0.7.1
-  - monad-logger ==0.3.39
+  - monad-logger ==0.3.40
   - monad-logger-aeson ==0.4.0.4
   - monad-logger-json ==0.1.0.0
   - monad-logger-logstash ==0.2.0.2
···
   - nanospec ==0.2.2
   - nanovg ==0.8.1.0
   - nats ==1.1.2
-  - natural-arithmetic ==0.1.3.0
+  - natural-arithmetic ==0.1.4.0
   - natural-induction ==0.2.0.0
   - natural-sort ==0.1.2
   - natural-transformation ==0.4
···
   - netlib-carray ==0.1
   - netlib-comfort-array ==0.0.0.2
   - netlib-ffi ==0.1.1
-  - net-mqtt ==0.8.2.5
+  - net-mqtt ==0.8.3.0
   - net-mqtt-lens ==0.1.1.0
   - netpbm ==1.0.4
   - netrc ==0.2.0.0
···
   - network-messagepack-rpc-websocket ==0.1.1.1
   - network-multicast ==0.3.2
   - Network-NineP ==0.4.7.2
-  - network-run ==0.2.4
+  - network-run ==0.2.5
   - network-simple ==0.4.5
   - network-simple-tls ==0.4.1
   - network-transport ==0.5.6
···
   - NumInstances ==1.4
   - numtype-dk ==0.5.0.3
   - nuxeo ==0.3.2
-  - nvim-hs ==2.3.2.1
-  - nvim-hs-contrib ==2.0.0.1
+  - nvim-hs ==2.3.2.3
+  - nvim-hs-contrib ==2.0.0.2
   - nvim-hs-ghcid ==2.0.1.0
   - oauthenticated ==0.3.0.0
   - ObjectName ==1.1.0.2
···
   - OneTuple ==0.3.1
   - Only ==0.1
   - oo-prototypes ==0.1.0.0
-  - opaleye ==0.9.6.2
+  - opaleye ==0.9.7.0
   - OpenAL ==1.7.0.5
   - openapi3 ==3.2.3
   - open-browser ==0.2.1.0
···
   - polysemy-several ==0.1.1.0
   - polysemy-webserver ==0.2.1.1
   - polysemy-zoo ==0.8.1.0
-  - pontarius-xmpp ==0.5.6.5
+  - pontarius-xmpp ==0.5.6.6
   - pooled-io ==0.0.2.3
   - portable-lines ==0.1
   - port-utils ==0.2.1.0
···
   - qrcode-juicypixels ==0.8.5
   - quadratic-irrational ==0.1.1
   - QuasiText ==0.1.2.6
-  - QuickCheck ==2.14.2
+  - QuickCheck ==2.14.3
   - quickcheck-arbitrary-adt ==0.3.1.0
   - quickcheck-assertions ==0.3.0
   - quickcheck-classes ==0.6.5.0
···
   - quickcheck-io ==0.2.0
   - quickcheck-simple ==0.1.1.1
   - quickcheck-special ==0.1.0.6
-  - quickcheck-state-machine ==0.7.2
+  - quickcheck-state-machine ==0.7.3
   - quickcheck-text ==0.1.2.1
   - quickcheck-transformer ==0.3.1.2
   - quickcheck-unicode ==1.0.1.0
···
   - sample-frame-np ==0.0.5
   - sampling ==0.3.5
   - sandi ==0.5
-  - sandwich ==0.1.3.2
+  - sandwich ==0.1.4.0
   - sandwich-hedgehog ==0.1.3.0
   - sandwich-quickcheck ==0.1.0.7
   - sandwich-slack ==0.1.1.0
···
   - servant-static-th ==1.0.0.0
   - servant-subscriber ==0.7.0.0
   - servant-swagger ==1.1.11
-  - servant-swagger-ui ==0.3.5.4.5.0
+  - servant-swagger-ui ==0.3.5.5.0.0
   - servant-swagger-ui-core ==0.3.5
   - servant-swagger-ui-redoc ==0.3.4.1.22.3
   - servant-websockets ==2.0.0
···
   - skylighting-format-latex ==0.1
   - slack-progressbar ==0.1.0.1
   - slave-thread ==1.1.0.2
-  - slynx ==0.7.2.0
-  - smallcheck ==1.2.1
+  - slynx ==0.7.2.1
+  - smallcheck ==1.2.1.1
   - smtp-mail ==0.3.0.0
   - snowflake ==0.1.1.1
   - socket ==0.8.3.0
···
   - termbox-bindings-c ==0.1.0
   - termbox-bindings-hs ==0.1.0
   - termbox-tea ==0.1.0
-  - terminal-progress-bar ==0.4.1
+  - terminal-progress-bar ==0.4.2
   - terminal-size ==0.3.4
   - termonad ==4.4.0.0
   - test-framework ==0.8.2.0
···
   - text-regex-replace ==0.1.1.5
   - text-rope ==0.2
   - text-short ==0.1.5
-  - text-show ==3.10.2
+  - text-show ==3.10.3
   - text-show-instances ==3.9.5
   - text-zipper ==0.12
   - tfp ==1.0.2
···
   - tls ==1.5.8
   - tls-debug ==0.4.8
   - tls-session-manager ==0.0.4
-  - tlynx ==0.7.2.0
+  - tlynx ==0.7.2.1
   - tmapchan ==0.0.3
   - tmapmvar ==0.0.4
   - tmp-postgres ==1.34.1.0
···
   - tmp-proc-postgres ==0.5.2.2
   - tmp-proc-rabbitmq ==0.5.1.2
   - tmp-proc-redis ==0.5.1.2
-  - toml-reader ==0.2.0.0
+  - toml-reader ==0.2.1.0
   - tophat ==1.0.5.1
   - topograph ==1.0.0.2
   - torrent ==10000.1.3
···
   - tostring ==0.2.1.1
   - tracing ==0.0.7.3
   - tracing-control ==0.0.7.3
-  - transaction ==0.1.1.3
+  - transaction ==0.1.1.4
   - transformers-base ==0.4.6
   - transformers-compat ==0.7.2
   - transformers-either ==0.1.4
···
   - unix-compat ==0.5.4
   - unix-time ==0.4.9
   - unjson ==0.15.4
-  - unliftio ==0.2.24.0
+  - unliftio ==0.2.25.0
   - unliftio-core ==0.2.1.0
   - unliftio-path ==0.0.2.0
   - unliftio-pool ==0.2.2.0
···
   - vector-bytes-instances ==0.1.1
   - vector-circular ==0.1.4
   - vector-extras ==0.2.8
+  - vector-hashtables ==0.1.1.3
   - vector-instances ==3.4.2
   - vector-mmap ==0.0.3
   - vector-rotcev ==0.1.0.2
···
   - xor ==0.0.1.1
   - xss-sanitize ==0.3.7.2
   - xxhash-ffi ==0.2.0.0
-  - yaml ==0.11.11.0
+  - yaml ==0.11.11.1
   - yaml-unscrambler ==0.1.0.13
   - Yampa ==0.13.7
   - yarn-lock ==0.6.5

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

···
  - JsContracts
  - JsonGrammar
  - JuPyTer-notebook
- - JuicyPixels-scale-dct
  - JunkDB-driver-gdbm
  - JunkDB-driver-hashtables
  - KiCS
···
  - MuCheck-SmallCheck
  - MutationOrder
  - NGLess
+ - NTRU
  - NaperianNetCDF
  - NaturalLanguageAlphabets
  - NearContextAlgebra
···
  - aeson-native
  - affine
  - afv
- - ag-pictgen
  - agda-server
  - agda-snippets-hakyll
  - agentx
···
  - apiary-websockets
  - apis
  - apotiki
- - appendful-persistent
  - approx-rand-test
  - arbor-monad-metric-datadog
  - archive-tar-bytestring
···
  - ascii-th_1_2_0_0
  - ascii_1_7_0_0
  - asic
- - asil
  - assert4hs-hspec
  - assert4hs-tasty
  - assimp
···
  - bitcoin-tx
  - bitcoin-types
  - bitcoind-regtest
- - bitfield
  - bitly-cli
  - bitmaps
  - bittorrent
···
  - cabal-query
  - cabal-test
  - cabal2arch
- - cabal2json
  - cabalmdvrpm
  - cabalrpmdeps
  - caffegraph
···
  - compact-mutable
  - compact-mutable-vector
  - compact-socket
- - compactable
  - compdata-automata
  - compdata-dags
  - compdata-param
···
  - cryptoids
  - cryptoids-class
  - cryptol
+ - crypton-connection
+ - crypton-x509-store
+ - crypton-x509-system
+ - crypton-x509-validation
  - crystalfontz
  - csound-catalog
  - csound-controllers
···
  - csv-enumerator
  - ctpl
  - cube
- - cuckoo
  - cv-combinators
  - cypher
  - daino
···
  - eventuo11y-otel
  - eventuo11y-prometheus
  - every-bit-counts
- - ewe
  - exference
  - exinst-aeson
  - exinst-base
···
  - fpnla-examples
  - frame-markdown
  - freckle-app
- - freckle-app_1_9_0_2
+ - freckle-app_1_9_0_3
  - free-functors
  - free-game
  - free-theorems-counterexamples
···
  - freelude
  - freer-converse
  - fresnel-fused-effects
+ - friday-juicypixels
  - front
  - frpnow-gloss
  - frpnow-gtk
···
  - geni-util
  - geniconvert
  - geniserver
- - genvalidity-appendful
- - genvalidity-dirforest
  - genvalidity-network-uri
- - genvalidity-sydtest
- - genvalidity-sydtest-aeson
- - genvalidity-sydtest-hashable
- - genvalidity-sydtest-lens
- - genvalidity-sydtest-persistent
  - geo-uk
  - geodetic
  - geolite-csv
···
  - hakyll-ogmarkup
  - hakyll-shortcut-links
  - halberd
- - halide-JuicyPixels
  - halide-arrayfire
  - hall-symbols
  - halma-gui
···
  - hascat-setup
  - hascat-system
  - hashable-accelerate
- - hashes
  - hashflare
  - hask-home
  - haskdeep
···
  - htsn-import
  - http-client-auth
  - http-client-rustls
+ - http-client-tls_0_3_6_2
  - http-enumerator
  - http2-client-grpc
  - http2-grpc-proto-lens
···
  - ideas-math-types
  - ideas-statistics
  - ige-mac-integration
+ - igrf
  - ihaskell-rlangqq
  - ihttp
  - imap
···
  - loli
  - longshot
  - loop-effin
- - looper
  - lorentz
  - lostcities
  - loup
···
  - monetdb-mapi
  - mongrel2-handler
  - monky
+ - monoidmap
  - monte-carlo
  - moo
  - moonshine
···
  - nettle-openflow
  - network-anonymous-i2p
  - network-anonymous-tor
+ - network-conduit-tls_1_4_0
  - network-connection
  - network-enumerator
  - network-hans
···
  - nri-test-encoding
  - numerals-base
  - numeric-ode
+ - numeric-optimization-backprop
  - numerical
  - numhask-hedgehog
  - numhask-range
···
  - queryparser-presto
  - queryparser-vertica
  - queuelike
+ - quic
  - quickbench
  - quickcheck-poly
  - quickcheck-regex
···
  - remotion
  - repa-array
  - repa-convert
- - repa-fftw
  - repa-flow
  - repa-plugin
  - repa-stream
···
  - rose-trie
  - roshask
  - rosmsg-bin
+ - rounded-hw
  - roundtrip-xml
  - route-generator
  - route-planning
···
  - runtime-arbitrary
  - rv
  - s-expression
- - safe-coloured-text-gen
- - safe-coloured-text-layout
  - safe-coloured-text-layout-gen
  - safe-coupling
  - safe-plugins
···
  - swapper
  - sweet-egison
  - switch
- - sydtest-aeson
  - sydtest-amqp
- - sydtest-autodocodec
- - sydtest-hedgehog
- - sydtest-hedgehog_0_4_0_0
- - sydtest-hedis
- - sydtest-hspec
- - sydtest-hspec_0_4_0_0
- - sydtest-mongo
- - sydtest-persistent
- - sydtest-persistent-postgresql
- - sydtest-persistent-sqlite
- - sydtest-process
- - sydtest-rabbitmq
- - sydtest-servant
- - sydtest-typed-process
- - sydtest-wai
- - sydtest-webdriver
  - sydtest-webdriver-screenshot
  - sydtest-webdriver-yesod
  - sydtest-yesod
···
  - thumbnail-polish
  - tic-tac-toe
  - tickle
- - tiger
  - tighttp
  - timberc
  - time-exts
···
  - tlex-encoding
  - tlex-th
  - tls-extra
+ - tls_1_7_0
  - tn
  - to-string-instances
  - toboggan
  - todos
- - token-limiter-concurrent
  - toktok
  - tomlcheck
  - tonatona
···
  - uu-cco-hut-parsing
  - uu-cco-uu-parsinglib
  - uu-options
- - uuagc
  - uuid-crypto
  - uvector-algorithms
  - v4l2
···
  - waldo
  - warp-grpc
  - warp-quic
+ - warp_3_3_27
  - warped
  - wavesurfer
  - wavy
···
  - wumpus-drawing
  - wumpus-microprint
  - wumpus-tree
+ - wuss_2_0_1_4
  - wx
  - wxAsteroids
  - wxFruit

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

···
   # Link the proper version.
   zeromq4-haskell = super.zeromq4-haskell.override { zeromq = pkgs.zeromq4; };
 
+  threadscope = enableSeparateBinOutput super.threadscope;
+
   # Use the default version of mysql to build this package (which is actually mariadb).
   # test phase requires networking
   mysql = dontCheck super.mysql;
···
     '';
   }) super.nvvm;
 
+  # hledger* overrides
+  inherit (
+    let
+      # Copy hledger man pages from the source tarball into the proper place.
+      # It always contains the relevant man page(s) at the top level. For
+      # hledger it additionally has all the other man pages in embeddedfiles/
+      # which we ignore.
+      installHledgerManPages = overrideCabal (drv: {
+        buildTools = drv.buildTools or [] ++ [
+          pkgs.buildPackages.installShellFiles
+        ];
+        postInstall = ''
+          for i in $(seq 1 9); do
+            installManPage *.$i
+          done
+
+          install -v -Dm644 *.info* -t "$out/share/info/"
+        '';
+      });
+
+      hledgerWebTestFix = overrideCabal (drv: {
+        preCheck = ''
+          ${drv.preCheck or ""}
+          export HOME="$(mktemp -d)"
+        '';
+      });
+    in
+    {
+      hledger = installHledgerManPages super.hledger;
+      hledger-web = installHledgerManPages (hledgerWebTestFix super.hledger-web);
+      hledger-ui = installHledgerManPages super.hledger-ui;
+
+      hledger_1_30_1 = installHledgerManPages
+        (doDistribute (super.hledger_1_30_1.override {
+          hledger-lib = self.hledger-lib_1_30;
+        }));
+      hledger-web_1_30 = installHledgerManPages (hledgerWebTestFix
+        (doDistribute (super.hledger-web_1_30.override {
+          hledger = self.hledger_1_30_1;
+          hledger-lib = self.hledger-lib_1_30;
+        })));
+    }
+  ) hledger
+    hledger-web
+    hledger-ui
+    hledger_1_30_1
+    hledger-web_1_30
+    ;
+
   cufft = overrideCabal (drv: {
     preConfigure = ''
       export CUDA_PATH=${pkgs.cudatoolkit}
···
   sfml-audio = appendConfigureFlag "--extra-include-dirs=${pkgs.openal}/include/AL" super.sfml-audio;
 
   # avoid compiling twice by providing executable as a separate output (with small closure size)
+  cabal-fmt = enableSeparateBinOutput super.cabal-fmt;
+  hindent = enableSeparateBinOutput super.hindent;
+  releaser  = enableSeparateBinOutput super.releaser;
+  eventlog2html = enableSeparateBinOutput super.eventlog2html;
+  ghc-debug-brick  = enableSeparateBinOutput super.ghc-debug-brick;
+  nixfmt  = enableSeparateBinOutput super.nixfmt;
+  calligraphy = enableSeparateBinOutput super.calligraphy;
   niv = enableSeparateBinOutput (self.generateOptparseApplicativeCompletions [ "niv" ] super.niv);
   ghcid = enableSeparateBinOutput super.ghcid;
   ormolu = self.generateOptparseApplicativeCompletions [ "ormolu" ] (enableSeparateBinOutput super.ormolu);
···
   gio = lib.pipe super.gio
     [ (disableHardening ["fortify"])
       (addBuildTool self.buildHaskellPackages.gtk2hs-buildtools)
-      (addPkgconfigDepends (with pkgs; [ glib pcre2 util-linux pcre ]
-                                       ++ (if pkgs.stdenv.isLinux then [libselinux libsepol] else [])))
+      (addPkgconfigDepends (with pkgs; [ glib pcre2 pcre ]
+                                       ++ lib.optionals pkgs.stdenv.isLinux [ util-linux libselinux libsepol ]))
     ];
   glib = disableHardening ["fortify"] (addPkgconfigDepend pkgs.glib (addBuildTool self.buildHaskellPackages.gtk2hs-buildtools super.glib));
   gtk3 = disableHardening ["fortify"] (super.gtk3.override { inherit (pkgs) gtk3; });
   gtk = lib.pipe super.gtk (
     [ (disableHardening ["fortify"])
       (addBuildTool self.buildHaskellPackages.gtk2hs-buildtools)
-      (addPkgconfigDepends (with pkgs; [ gtk2 pcre2 util-linux pcre fribidi
+      (addPkgconfigDepends (with pkgs; [ gtk2 pcre2 pcre fribidi
                                          libthai libdatrie xorg.libXdmcp libdeflate
                                         ]
-                                       ++ (if pkgs.stdenv.isLinux then [libselinux libsepol] else [])))
+                                       ++ lib.optionals pkgs.stdenv.isLinux [ util-linux libselinux libsepol ]))
     ] ++
     ( if pkgs.stdenv.isDarwin then [(appendConfigureFlag "-fhave-quartz-gtk")] else [] )
   );
···
         wrapProgram "$out/bin/nvfetcher" --prefix 'PATH' ':' "${
           pkgs.lib.makeBinPath [
             pkgs.nvchecker
-            pkgs.nix-prefetch
+            pkgs.nix # nix-prefetch-url
+            pkgs.nix-prefetch-git
             pkgs.nix-prefetch-docker
           ]
         }"
···
   # Disable checks to break dependency loop with SCalendar
   scalendar = dontCheck super.scalendar;
 
+  halide-haskell = super.halide-haskell.override { Halide = pkgs.halide; };
+  # Sydtest has a brittle test suite that will only work with the exact
+
+  # versions that it ships with.
+  sydtest = dontCheck super.sydtest;
 }

pkgs/development/haskell-modules/generic-builder.nix

···
 , doInstallIntermediates ? false
 , editedCabalFile ? null
 # aarch64 outputs otherwise exceed 2GB limit
-, enableLibraryProfiling ? !(ghc.isGhcjs or stdenv.targetPlatform.isAarch64 or false)
+, enableLibraryProfiling ? !(ghc.isGhcjs or stdenv.hostPlatform.isAarch64 or false)
 , enableExecutableProfiling ? false
 , profilingDetail ? "exported-functions"
 # TODO enable shared libs for cross-compiling

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

···
      }:
      mkDerivation {
        pname = "Blammo";
-       version = "1.1.1.2";
-       sha256 = "156c3yx3gzyic5pnmzkk6fzvw74a2zw2vchf5j12j09qmjq6hyss";
+       version = "1.1.2.0";
+       sha256 = "1lp71amm5bzky8w6rw7lr551yrxhzaza0mq6ph4vb77864wnf959";
        libraryHaskellDepends = [
          aeson base bytestring case-insensitive clock containers dlist
          envparse exceptions fast-logger http-types lens monad-logger-aeson
···
        pname = "ChasingBottoms";
        version = "1.3.1.12";
        sha256 = "1vy9yq07p95qiap1pcp2bbbn1mqvp3spyrswpdz0qfcn06656650";
-       revision = "1";
-       editedCabalFile = "0ra041bg2m04niqzi0y468cfmv2bkjh8ckix2i8xf2shw7v2zn4r";
+       revision = "2";
+       editedCabalFile = "12sdz0xdifdl9gaz8nc7smdv6ldjzg423i5r5cw8myshh8s63rga";
        libraryHaskellDepends = [
          base containers mtl QuickCheck random syb
        ];
···
      }) {};
 
   "ForestStructures" = callPackage
-    ({ mkDerivation, base, bifunctors, containers, criterion, fgl, lens
-     , QuickCheck, tasty, tasty-quickcheck, tasty-th
+    ({ mkDerivation, aeson, base, bifunctors, containers, criterion
+     , deepseq, fgl, lens, QuickCheck, tasty, tasty-quickcheck, tasty-th
      , unordered-containers, vector, vector-th-unbox
      }:
      mkDerivation {
        pname = "ForestStructures";
-       version = "0.0.1.0";
-       sha256 = "1hhmcc0cpjbixqjgl35gv9dpymamdfb4vhhd5hard0qpg1xllnvw";
+       version = "0.0.1.1";
+       sha256 = "1fqw4vm3i76is9z5p7bw4pjlsqdcvsp71jadqmwdz53d0nfwrc33";
        libraryHaskellDepends = [
-         base bifunctors containers fgl lens QuickCheck unordered-containers
-         vector vector-th-unbox
+         aeson base bifunctors containers deepseq fgl lens QuickCheck
+         unordered-containers vector vector-th-unbox
        ];
        testHaskellDepends = [
          base containers QuickCheck tasty tasty-quickcheck tasty-th vector
···
        broken = true;
      }) {};
 
+  "HaGL" = callPackage
+    ({ mkDerivation, array, base, bytestring, containers
+     , cryptohash-md5, directory, gl-capture, GLUT, hashable, HUnit
+     , matrix, mtl, OpenGL, OpenGLRaw, template-haskell, time
+     , unordered-containers
+     }:
+     mkDerivation {
+       pname = "HaGL";
+       version = "0.1.0.0";
+       sha256 = "00h4p6hialbfhcdgspklaf9ncyg13rz5cspbngrpv3cm2pprii2q";
+       libraryHaskellDepends = [
+         array base bytestring containers cryptohash-md5 gl-capture GLUT
+         hashable matrix mtl OpenGL OpenGLRaw template-haskell time
+         unordered-containers
+       ];
+       testHaskellDepends = [ base bytestring directory GLUT HUnit ];
+       description = "Haskell-embedded OpenGL";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "HaLeX" = callPackage
     ({ mkDerivation, base, HUnit, mtl, QuickCheck }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "HaskellNet";
-       version = "0.6.0.2";
-       sha256 = "0lqdqch6qwfrf89hfmvvcna2wgvhzx02v0cwsm7bbhq258alfapj";
-       libraryHaskellDepends = [
-         array base base64 bytestring cryptohash-md5 mime-mail mtl network
-         network-bsd old-time pretty text
-       ];
-       description = "Client support for POP3, SMTP, and IMAP";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "HaskellNet_0_6_1_2" = callPackage
-    ({ mkDerivation, array, base, base64, bytestring, cryptohash-md5
-     , mime-mail, mtl, network, network-bsd, old-time, pretty, text
-     }:
-     mkDerivation {
-       pname = "HaskellNet";
        version = "0.6.1.2";
        sha256 = "0yd0n6c9favb6kv37flz2cn9wz5kapx3iqljq2h7l6qvx6kd92v5";
+       revision = "1";
+       editedCabalFile = "1j5g09v40rvsk4crfjabs0mma5nlwsbzbny25803bc6805jh9058";
        libraryHaskellDepends = [
          array base base64 bytestring cryptohash-md5 mime-mail mtl network
          network-bsd old-time pretty text
        ];
        description = "Client support for POP3, SMTP, and IMAP";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "HaskellNet-SSL" = callPackage
···
        license = lib.licenses.publicDomain;
      }) {inherit (pkgs) openssl;};
 
+  "HsOpenSSL_0_11_7_6" = callPackage
+    ({ mkDerivation, base, bytestring, Cabal, network, openssl, time }:
+     mkDerivation {
+       pname = "HsOpenSSL";
+       version = "0.11.7.6";
+       sha256 = "18n7yhffqhgl2favmwlky9j0xx61bhs1akhf7ccc3ajapf8y4bb6";
+       setupHaskellDepends = [ base Cabal ];
+       libraryHaskellDepends = [ base bytestring network time ];
+       librarySystemDepends = [ openssl ];
+       testHaskellDepends = [ base bytestring ];
+       description = "Partial OpenSSL binding for Haskell";
+       license = lib.licenses.publicDomain;
+       hydraPlatforms = lib.platforms.none;
+     }) {inherit (pkgs) openssl;};
+
   "HsOpenSSL-x509-system" = callPackage
     ({ mkDerivation, base, bytestring, HsOpenSSL, unix }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "IntervalMap";
-       version = "0.6.2.0";
-       sha256 = "03964pa13nap4gnhdagkfwjc8y74x0pikywa7pv8944a5v9ziwss";
+       version = "0.6.2.1";
+       sha256 = "17v9q1vnm3pzrr5xhv8xvxqh27facwwfladrr10l57fzibp82265";
        libraryHaskellDepends = [ base containers deepseq ];
        testHaskellDepends = [ base Cabal containers deepseq QuickCheck ];
        benchmarkHaskellDepends = [
···
        ];
        description = "Scale JuicyPixels images with DCT";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "JuicyPixels-stbir" = callPackage
···
        ];
        description = "NTRU Cryptography";
        license = "GPL";
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "NXT" = callPackage
···
      }:
      mkDerivation {
        pname = "QuickCheck";
-       version = "2.14.2";
-       sha256 = "1wrnrm9sq4s0bly0q58y80g4153q45iglqa34xsi2q3bd62nqyyq";
+       version = "2.14.3";
+       sha256 = "0085lwy14r7hk7ibmv8d7d54ja9zin0ijf0b27xai898dfrj43sw";
        libraryHaskellDepends = [
          base containers deepseq random splitmix template-haskell
          transformers
···
      }:
      mkDerivation {
        pname = "RtMidi";
-       version = "0.6.1.0";
-       sha256 = "0x2hk8bg3bwnhl1si7wll47xn2xq1dj3lakhg03is5j2692lpalk";
+       version = "0.7.0.0";
+       sha256 = "0gfhl9p961hpzljcx3cphl5wzhgjkbklnf5a1wikmm86xa5ziz1w";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base deepseq vector ];
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "Yampa_0_14_2" = callPackage
+  "Yampa_0_14_3" = callPackage
     ({ mkDerivation, base, deepseq, random, simple-affine-space }:
      mkDerivation {
        pname = "Yampa";
-       version = "0.14.2";
-       sha256 = "0d063a1giib89pm4d2v3y90dfjrldijff8izwgjazw0ivh515qqp";
+       version = "0.14.3";
+       sha256 = "0hsi2458m0wncb6khzjzplzxlmcwz3czm3q59fcqfz0c6yn8px7j";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "active";
-       version = "0.2.0.17";
-       sha256 = "1y2prarbrj6zpd7zp6cka5j6ylnbyv5a3f11i9ggj361z2y4r00f";
+       version = "0.2.0.18";
+       sha256 = "1fn3cyf43x18p2phs8bhacbp8zl8aifrh7ndzs0qi6n6g9sw95qn";
        libraryHaskellDepends = [
          base lens linear semigroupoids semigroups vector
        ];
···
      }:
      mkDerivation {
        pname = "aeson-schemas";
-       version = "1.4.0.1";
-       sha256 = "1yv4d4i8gmbv0mmlalhlafn9a6kv51wdwnpbksiajm6m47bajqym";
-       libraryHaskellDepends = [
-         aeson base first-class-families hashable megaparsec
-         template-haskell text unordered-containers
-       ];
-       testHaskellDepends = [
-         aeson aeson-qq base deepseq directory filepath interpolate process
-         QuickCheck raw-strings-qq tasty tasty-golden tasty-hunit
-         tasty-quickcheck template-haskell temporary text th-orphans
-         th-test-utils
-       ];
-       benchmarkHaskellDepends = [
-         aeson base criterion deepseq template-haskell th-test-utils
-       ];
-       description = "Easily consume JSON data on-demand with type-safety";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "aeson-schemas_1_4_1_0" = callPackage
-    ({ mkDerivation, aeson, aeson-qq, base, criterion, deepseq
-     , directory, filepath, first-class-families, hashable, interpolate
-     , megaparsec, process, QuickCheck, raw-strings-qq, tasty
-     , tasty-golden, tasty-hunit, tasty-quickcheck, template-haskell
-     , temporary, text, th-orphans, th-test-utils, unordered-containers
-     }:
-     mkDerivation {
-       pname = "aeson-schemas";
        version = "1.4.1.0";
        sha256 = "0l9qdzcx6fs661zn9vrkpflr5fl92s1w16nb94cabh8v1xzbagxh";
        libraryHaskellDepends = [
···
        ];
        description = "Easily consume JSON data on-demand with type-safety";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "aeson-serialize" = callPackage
···
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        mainProgram = "ag-pictgen";
+       broken = true;
      }) {};
 
   "agda-language-server" = callPackage
···
        pname = "agda2lagda";
        version = "0.2021.6.1";
        sha256 = "1108xzl4fv86qpasg1wbc26bypd06s41kmgzybrggc76pv15hbis";
+       revision = "1";
+       editedCabalFile = "0qba16r072www9544g30ahmlk8k3kiq8q18g3wn7b7sgz2jmp8mc";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        mainProgram = "agda2lagda";
      }) {};
 
-  "agda2lagda_0_2023_3_25" = callPackage
+  "agda2lagda_0_2023_6_9" = callPackage
     ({ mkDerivation, base, directory, filepath, goldplate
      , optparse-applicative, process
      }:
      mkDerivation {
        pname = "agda2lagda";
-       version = "0.2023.3.25";
-       sha256 = "0gvf5fd4xddhivmfv6lhra8y4qg18hpdw566avbdb8dz58g9gmvn";
+       version = "0.2023.6.9";
+       sha256 = "1zhzvahqrj5srxva8aq72fn0rlqfq27xvn17nwr19cq6a4ap9725";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "align-audio";
-       version = "0.0";
-       sha256 = "0sa7q5fzkc0z4vzibs5l21pvrkil0swdpbl27qn30vb6giy3yh7a";
-       revision = "2";
-       editedCabalFile = "1225s8vbwfblyzfbfv7b2v4xcxlp0aavaaivmx5154xlba56n10s";
+       version = "0.0.0.1";
+       sha256 = "1r1660igj6bmzhccw30vj0wsz7jjkd5k0vbr4nrcbpcwkxllshnb";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        pname = "apecs";
        version = "0.9.5";
        sha256 = "1n01kbyxgfk1jyc9adpmb4cglwz6i20i8wp9mg4nxsjpy93hbp1z";
+       revision = "1";
+       editedCabalFile = "1vpjwmyir3ivqzcalazzp4mczln5s2b23lb3rmaag0p1lrlxjxz0";
        libraryHaskellDepends = [
          array base containers exceptions mtl template-haskell vector
        ];
···
        ];
        testToolDepends = [ sydtest-discover ];
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "appendmap" = callPackage
···
        description = "Action Script Instrumentation Library";
        license = "LGPL";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "asn" = callPackage
···
        ];
        description = "Amateur astronomical computations";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "astview" = callPackage
···
        pname = "aws-cloudfront-signed-cookies";
        version = "0.2.0.12";
        sha256 = "1gdam3h8ir1lz8phhj03ckiv0f371xl79adi4kz2yqk2ayvcixhv";
+       revision = "1";
+       editedCabalFile = "0a9zvqjp6lvpn3xhlxxd73fpvgxx6vy5j0nkigqgc9wxsrmm1vk3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "aws-secrets" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, hspec, mtl
+     , scientific, stm, text, typed-process, validation
+     }:
+     mkDerivation {
+       pname = "aws-secrets";
+       version = "0.0.0.0";
+       sha256 = "1qbly27bcc74ngc7wcazsk7gq1w4c66cihpxbaxp4xvhc541fn5n";
+       revision = "1";
+       editedCabalFile = "163npspzl43f63xrqnq2l2x1h620vmrnh3wj6nshb05x0q1d5ljf";
+       libraryHaskellDepends = [
+         aeson base bytestring containers mtl scientific stm text
+         typed-process validation
+       ];
+       testHaskellDepends = [
+         aeson base bytestring containers hspec mtl scientific stm text
+         typed-process validation
+       ];
+       description = "Fetch data from AWS Secrets Manager";
+       license = lib.licenses.mit;
+     }) {};
+
   "aws-ses-easy" = callPackage
     ({ mkDerivation, amazonka, amazonka-ses, base, criterion
      , exceptions, lens, lucid, mtl, tasty, tasty-hspec, text
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "base32_0_3_1_0" = callPackage
+    ({ mkDerivation, base, bytestring, criterion, deepseq, memory
+     , QuickCheck, random-bytestring, tasty, tasty-hunit
+     , tasty-quickcheck, text, text-short
+     }:
+     mkDerivation {
+       pname = "base32";
+       version = "0.3.1.0";
+       sha256 = "1cp2xs1kl5bqs09jpyak4kfjr4pnqgbv5rksxx1z6r8hmi9akjrg";
+       libraryHaskellDepends = [
+         base bytestring deepseq text text-short
+       ];
+       testHaskellDepends = [
+         base bytestring memory QuickCheck random-bytestring tasty
+         tasty-hunit tasty-quickcheck text text-short
+       ];
+       benchmarkHaskellDepends = [
+         base bytestring criterion deepseq memory random-bytestring text
+       ];
+       description = "Fast RFC 4648-compliant Base32 encoding";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "base32-bytestring" = callPackage
     ({ mkDerivation, base, bits-extras, bytestring, cpu, criterion
      , hspec, QuickCheck
···
     ({ mkDerivation, base, ghc-prim }:
      mkDerivation {
        pname = "basement";
-       version = "0.0.15";
-       sha256 = "1d2xj5dmjps7nc7rwp5s0kyjcg9v8xfql6ik4yk1d3affnvazhjn";
+       version = "0.0.16";
+       sha256 = "00332i4n98gh06x8ii4p8mhjpq0ch1bdan9hxmdblxpgk8j7xdvz";
        libraryHaskellDepends = [ base ghc-prim ];
        description = "Foundation scrap box of array & string";
        license = lib.licenses.bsd3;
···
 
   "bcp47-orphans" = callPackage
     ({ mkDerivation, base, bcp47, cassava, errors, esqueleto, hashable
-     , hspec, http-api-data, path-pieces, persistent, QuickCheck, text
-     }:
-     mkDerivation {
-       pname = "bcp47-orphans";
-       version = "0.1.0.5";
-       sha256 = "1h5pqcb1snmbbvcfpjcqrfbk9l8wry6i0mlz6vm347arhfwc62cd";
-       libraryHaskellDepends = [
-         base bcp47 cassava errors esqueleto hashable http-api-data
-         path-pieces persistent text
-       ];
-       testHaskellDepends = [
-         base bcp47 cassava hspec path-pieces persistent QuickCheck
-       ];
-       description = "BCP47 orphan instances";
-       license = lib.licenses.mit;
-     }) {};
-
-  "bcp47-orphans_0_1_0_6" = callPackage
-    ({ mkDerivation, base, bcp47, cassava, errors, esqueleto, hashable
      , hspec, http-api-data, path-pieces, persistent, QuickCheck
      , serialise, text
      }:
···
        ];
        description = "BCP47 orphan instances";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "bcrypt" = callPackage
···
      }:
      mkDerivation {
        pname = "bech32";
-       version = "1.1.2";
-       sha256 = "1iyjnyy7l0jf2azbgg6lc5k7n25h1r41fyyqfagyaz79vhi1k7j8";
+       version = "1.1.3";
+       sha256 = "0pzsaj606hgm2j4c2jynnv46w6a13g2z8vsfywxkz90asy91mgwy";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "belgian-structured-communication" = callPackage
+    ({ mkDerivation, base, binary, hashable, hspec, hspec-discover
+     , parsec, QuickCheck, template-haskell, text, validity
+     }:
+     mkDerivation {
+       pname = "belgian-structured-communication";
+       version = "0.1.0.0";
+       sha256 = "03lic7a7z2jqvfq0ar4n0vx5l27hg8mkck91fzwbcna82fjjabpw";
+       libraryHaskellDepends = [
+         base binary hashable parsec QuickCheck template-haskell text
+         validity
+       ];
+       testHaskellDepends = [ base hspec parsec QuickCheck validity ];
+       testToolDepends = [ hspec-discover ];
+       description = "parsing, rendering and manipulating the structured communication of Belgian financial transactions";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "belka" = callPackage
     ({ mkDerivation, aeson, aeson-value-parser, attoparsec, base
      , base-prelude, base64-bytestring, bug, bytestring
···
        testToolDepends = [ sydtest-discover ];
        description = "Generic and easy to use haskell bitfields";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "bitly-cli" = callPackage
···
        pname = "bitwise";
        version = "1.0.0.1";
        sha256 = "03xyzdkyb99gvm9g5chl07rqbnm7qrxba7wgmrfmal0rkwm0ibkn";
-       revision = "6";
-       editedCabalFile = "0m4swiml8zggzvwzip2yw77y6crhf10a7imy6fj5yq0b9vd2mqkf";
+       revision = "8";
+       editedCabalFile = "0jmix0f28cvxg328b4wnf33sx36aa9j921hx3hd51by85lywkvrn";
        libraryHaskellDepends = [ array base bytestring ];
        testHaskellDepends = [ base QuickCheck ];
        benchmarkHaskellDepends = [ array base bytestring criterion ];
···
     ({ mkDerivation, base, blaze-markup, mtl }:
      mkDerivation {
        pname = "blaze-svg";
-       version = "0.3.6.1";
-       sha256 = "0q5a4wam0sidng0cfsivwkyph9snyilk7rsdx4vb6wz9l6xz397n";
-       revision = "1";
-       editedCabalFile = "1vb78d0nvk0909963pm0mnzklcm57w563lhgx1wv7qzdfznpi8f9";
+       version = "0.3.7";
+       sha256 = "0pqnx1zrvm2pliya76f4m8d6aycncfp08c2n1fiyzvl1fgk62z2c";
        libraryHaskellDepends = [ base blaze-markup mtl ];
        description = "SVG combinator library";
        license = lib.licenses.bsd3;
···
     ({ mkDerivation, base, brick, containers, microlens, vector }:
      mkDerivation {
        pname = "brick-list-skip";
-       version = "0.1.1.3";
-       sha256 = "0pa3k28qia4pjmiwv8zmzka7vmfgqwf570b6fjigxvid4wlh58d3";
+       version = "0.1.1.4";
+       sha256 = "09f6w8m0wpljfxksm4d09014jhf4hh0ngr5cgp3616nf7mp3cazr";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base brick containers microlens vector ];
···
      }:
      mkDerivation {
        pname = "brick-tabular-list";
-       version = "2.2.0.1";
-       sha256 = "0iplqfvvb5q7p99fgizj0py350sghmmd7pgyq87yx28rv4d4mbm3";
+       version = "2.2.0.2";
+       sha256 = "19kk4rr5h5a6cis2k6qvh7c8l7hixx3lmx79ax2qzfb1vps5ri5g";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "bugzilla-redhat";
        version = "1.0.1";
        sha256 = "19dir39yxqd5psf3gj4f3vhcbdad1np7374nkxfk0gg4xxvywcvi";
-       revision = "1";
-       editedCabalFile = "1yai855w6s9xjyswpx206hnryi1y6kda1310vcfff0ghl4gdxpxw";
+       revision = "2";
+       editedCabalFile = "0gqsmxrydy6isyfx4g8snpg50i3f0jcw9yyr385ys28zw7ak29qr";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.agpl3Only;
      }) {};
 
-  "cabal-appimage_0_4_0_0" = callPackage
+  "cabal-appimage_0_4_0_1" = callPackage
     ({ mkDerivation, base, Cabal, filepath }:
      mkDerivation {
        pname = "cabal-appimage";
-       version = "0.4.0.0";
-       sha256 = "1ws5alrffpzr6yikwsq6yvazdqbclbsa509rc4csc7dmka8xc4dp";
+       version = "0.4.0.1";
+       sha256 = "1fk5dz1gnd5rkf58m9m1ynildmajv1if3ymr2xg2gylvnygwr4rn";
        libraryHaskellDepends = [ base Cabal filepath ];
        description = "Cabal support for creating AppImage applications";
        license = lib.licenses.agpl3Only;
···
      }:
      mkDerivation {
        pname = "cabal-clean";
-       version = "0.2.20220819";
-       sha256 = "17zrny2wyqfvyjdsqj6z18cdq66ycj66i6mpr122paa08608kyrn";
+       version = "0.2.20230609";
+       sha256 = "0mncw7729lgyw9qy9gh3r22kmvxkz2pi6v62xypiqjjriljhhkp2";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        pname = "cabal-rpm";
        version = "2.1.1";
        sha256 = "0p75a9q4hjrvbiqq3h7730h1b400z7v5v9kns703d09hr2l0zgg0";
+       revision = "1";
+       editedCabalFile = "1a4r0h635wzrg27b2mg2lhnsy8d5vrn3ps4bc7qzflx82rxmpvvl";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
        mainProgram = "cabal2json";
+       broken = true;
      }) {};
 
   "cabal2nix" = callPackage
···
      }:
      mkDerivation {
        pname = "candid";
-       version = "0.4.0.1";
-       sha256 = "14np7yakm97d6scw5ldlsjacri317wwyingwsys7987zk01dfcln";
+       version = "0.4.0.2";
+       sha256 = "04gy0nlk28hd5glzbscfhh0f01kxvxvjy2pcis8m0n4r6n7l2qlr";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
   "cattrap" = callPackage
     ({ mkDerivation, balkon, base, bytestring, containers, css-syntax
      , fontconfig-pure, gl, GLUT, harfbuzz-pure, hspec, QuickCheck
-     , scientific, stylist-traits, text, xml
+     , scientific, stylist-traits, text, unordered-containers, xml
      }:
      mkDerivation {
        pname = "cattrap";
-       version = "0.1.0.0";
-       sha256 = "0qp9lpq95a967yvdnzbdy5jzd6v0pvrr43v244fh4rkr5gh11j11";
+       version = "0.2.0.0";
+       sha256 = "1xl4nv2p1qcxijpvd4lgxx5qggzxf75jv2lz51yqw6wj6237c09s";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          balkon base bytestring containers css-syntax fontconfig-pure
-         harfbuzz-pure scientific stylist-traits text
+         harfbuzz-pure scientific stylist-traits text unordered-containers
        ];
        executableHaskellDepends = [
          base css-syntax gl GLUT stylist-traits text xml
        ];
        testHaskellDepends = [
          base css-syntax hspec QuickCheck stylist-traits
+         unordered-containers
        ];
        description = "Lays out boxes according to the CSS Box Model";
        license = lib.licenses.gpl3Only;
···
        pname = "cgi";
        version = "3001.5.0.1";
        sha256 = "044gfqfdw5xdr6mzp5i3956a5fcj15j32zwzzd6ym15nxgrvjqh3";
+       revision = "1";
+       editedCabalFile = "0bl9lnqsm93hic23mdqfd9gykrk9fr3bbfm88qgyj07ycm6jbdaf";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        testHaskellDepends = [ base doctest QuickCheck ];
        description = "Checks context free grammar for ambiguity using brute force up to given limit";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "check-email" = callPackage
···
        maintainers = [ lib.maintainers.dschrempf ];
      }) {};
 
+  "circular-enum" = callPackage
+    ({ mkDerivation, base, hspec }:
+     mkDerivation {
+       pname = "circular-enum";
+       version = "0.1.0.0";
+       sha256 = "0d8p2xavgvlnvzh65zw99sbjirnsv4hmhgxm2v49z0fg847c8liq";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base hspec ];
+       description = "Make bounded enum types circular";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "circus" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, mtl, syb
      , text
···
        pname = "co-log-concurrent";
        version = "0.5.1.0";
        sha256 = "07qmx9z03vmgq2cgz4352fsav7r1nx8n7svmrhg2lkdiyp0j7a59";
-       revision = "2";
-       editedCabalFile = "1ldh0c0927ay8wpamybaw66cz4rz3jskv8iwvxlxw8mmr4pwyvk0";
+       revision = "3";
+       editedCabalFile = "17pmkgly1882hbwa6b2qb0y1wh4x4nawhw1vl8fsy252caxkck0s";
        libraryHaskellDepends = [ base co-log-core stm ];
        description = "Asynchronous backend for co-log library";
        license = lib.licenses.mpl20;
···
        pname = "coercible-subtypes";
        version = "0.3.0.0";
        sha256 = "14swbn5509wb46iwgp2lj8hqi3ca82jacgq028cmwz35zsc1zjds";
+       revision = "1";
+       editedCabalFile = "0b60xy5pcfkys6a2q6ykzva9ld1gsq09j3chnq9vab9bxx4r92dh";
        libraryHaskellDepends = [ base profunctors ];
        description = "Coercible but only in one direction";
        license = lib.licenses.bsd3;
···
     ({ mkDerivation, base, ChasingBottoms, containers, deepseq
      , doctest-exitcode-stdio, doctest-lib, guarded-allocation
      , non-empty, prelude-compat, primitive, QuickCheck, semigroups
-     , storable-record, storablevector, tagged, transformers, utility-ht
+     , storable-record, storablevector, tagged, transformers
+     , transformers-compat, utility-ht
      }:
      mkDerivation {
        pname = "comfort-array";
-       version = "0.5.2.1";
-       sha256 = "01vijksddhqmypikk0kgsw02fqdp3anvxvvmhimw11kg87n5dy7v";
-       revision = "1";
-       editedCabalFile = "1ly48lsdy806r323k7mxaz5wq5xhgiwlhvdmsg7qxa6jmb6iyx1n";
+       version = "0.5.2.3";
+       sha256 = "0x9pwk25bpq63nllqc00mmjbrvwzz0nw8pgxbdakpmm2ymyj9p14";
        libraryHaskellDepends = [
          base containers deepseq guarded-allocation non-empty prelude-compat
          primitive QuickCheck semigroups storable-record storablevector
-         tagged transformers utility-ht
+         tagged transformers transformers-compat utility-ht
        ];
        testHaskellDepends = [
          base ChasingBottoms containers deepseq doctest-exitcode-stdio
···
        maintainers = [ lib.maintainers.thielema ];
      }) {};
 
+  "comfort-blas" = callPackage
+    ({ mkDerivation, base, blas-ffi, comfort-array, containers, deepseq
+     , doctest-exitcode-stdio, doctest-lib, guarded-allocation
+     , netlib-ffi, QuickCheck, transformers, utility-ht
+     }:
+     mkDerivation {
+       pname = "comfort-blas";
+       version = "0.0";
+       sha256 = "0abaza4n7v2lq4pbpxw6208i7aazxg1x59a2yr28dky7ishlq4px";
+       libraryHaskellDepends = [
+         base blas-ffi comfort-array containers deepseq guarded-allocation
+         netlib-ffi transformers utility-ht
+       ];
+       testHaskellDepends = [
+         base comfort-array containers doctest-exitcode-stdio doctest-lib
+         netlib-ffi QuickCheck utility-ht
+       ];
+       description = "Numerical Basic Linear Algebra using BLAS";
+       license = lib.licenses.bsd3;
+       maintainers = [ lib.maintainers.thielema ];
+     }) {};
+
   "comfort-fftw" = callPackage
     ({ mkDerivation, base, comfort-array, deepseq
      , doctest-exitcode-stdio, doctest-lib, fftw-ffi, netlib-ffi
···
        description = "A typeclass for structures which can be catMaybed, filtered, and partitioned";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "compactmap" = callPackage
···
      }:
      mkDerivation {
        pname = "concurrency";
-       version = "1.11.0.2";
-       sha256 = "0c7nq4d29s49a3h9wzjdi3idm6r68vxn6ybphsbrk2vmwqyfq36y";
+       version = "1.11.0.3";
+       sha256 = "1qzwf71s5jgdmqqwzyzln5jhzp0rgzpwsi75nrbdjynby2lwvwn2";
        libraryHaskellDepends = [
          array atomic-primops base exceptions monad-control mtl stm
          transformers
···
        pname = "config-value";
        version = "0.8.3";
        sha256 = "0pkcwxg91wali7986k03d7q940hb078hlsxfknqhkp2spr3d1f3w";
-       revision = "1";
-       editedCabalFile = "0j5prsqs7sq6sdpylphrym4r6p78circ6ixw7r55bwp92knqr5h8";
+       revision = "2";
+       editedCabalFile = "1phsi1a7j307kk2qw6a1l8kps2jicmxv1dc3j8yl9yy0v9q2v6j4";
        libraryHaskellDepends = [ array base containers pretty text ];
        libraryToolDepends = [ alex happy ];
        testHaskellDepends = [ base text ];
···
        pname = "connection";
        version = "0.3.1";
        sha256 = "1nbmafhlg0wy4aa3p7amjddbamdz6avzrxn4py3lvhrjqn4raxax";
-       revision = "1";
-       editedCabalFile = "08f1n38zryd0jklyv3yillilp040zxfxha6jphrmf28haq2irnk5";
+       revision = "2";
+       editedCabalFile = "1z6v1mhq3wvkbbvhaazlxli3d494iarsqvbx4qwx6xqn1pqz5jrx";
        libraryHaskellDepends = [
          base basement bytestring containers data-default-class network
          socks tls x509 x509-store x509-system x509-validation
···
        ];
        description = "Continued fractions";
        license = lib.licenses.publicDomain;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "continuum" = callPackage
···
      }:
      mkDerivation {
        pname = "core-telemetry";
-       version = "0.2.9.1";
-       sha256 = "0x36wzm4akxd5lq67hqmfrm1pddriw1mvq455bz308nabjdd65vl";
+       version = "0.2.9.3";
+       sha256 = "05q5rfsljmpf6v1v7r4gh8niqda6i6jrc2xgh54d7pfwmbqfzcm6";
        libraryHaskellDepends = [
          base bytestring core-data core-program core-text exceptions
          http-streams io-streams mtl network-info random safe-exceptions
···
        pname = "credentials";
        version = "0.0.2";
        sha256 = "12637ggwm4g81r2ilsjxvdcyj7di74fxaxsfwz9rrs80659h2myd";
+       revision = "1";
+       editedCabalFile = "1rvz915rzf3qifdlhjdkhi3qciwm5m3a84p5viskbmklwvd3rz8h";
        libraryHaskellDepends = [
          aeson amazonka amazonka-core amazonka-dynamodb amazonka-kms base
          bytestring conduit cryptonite exceptions lens memory retry
···
      }) {};
 
   "crypto-token" = callPackage
-    ({ mkDerivation, array, base, cryptonite, memory }:
+    ({ mkDerivation, array, base, crypton, memory }:
      mkDerivation {
        pname = "crypto-token";
-       version = "0.0.1";
-       sha256 = "1djn3fhxm639qarjjrax60p3kva54baj8sdcdlng02034kjzx6i6";
-       libraryHaskellDepends = [ array base cryptonite memory ];
+       version = "0.0.2";
+       sha256 = "04rdbfdvnf8wdfzqg32rzxjp1gbk7yjzhdiyf5rmzym2qb7y8jpf";
+       libraryHaskellDepends = [ array base crypton memory ];
        description = "crypto tokens";
        license = lib.licenses.bsd3;
      }) {};
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "crypton" = callPackage
+    ({ mkDerivation, base, basement, bytestring, deepseq, gauge
+     , ghc-prim, integer-gmp, memory, random, tasty, tasty-hunit
+     , tasty-kat, tasty-quickcheck
+     }:
+     mkDerivation {
+       pname = "crypton";
+       version = "0.31";
+       sha256 = "1vjar7nvjc7gbyv0ij0sjlaqkd4nlxibs2asxpb4div844xm20ls";
+       libraryHaskellDepends = [
+         base basement bytestring deepseq ghc-prim integer-gmp memory
+       ];
+       testHaskellDepends = [
+         base bytestring memory tasty tasty-hunit tasty-kat tasty-quickcheck
+       ];
+       benchmarkHaskellDepends = [
+         base bytestring deepseq gauge memory random
+       ];
+       description = "Cryptography Primitives sink";
+       license = lib.licenses.bsd3;
+     }) {};
+
+  "crypton-connection" = callPackage
+    ({ mkDerivation, base, basement, bytestring, containers
+     , crypton-x509, crypton-x509-store, crypton-x509-system
+     , crypton-x509-validation, data-default-class, network, socks, tls
+     }:
+     mkDerivation {
+       pname = "crypton-connection";
+       version = "0.3.1";
+       sha256 = "1k0xv14yzikxlyix8qzqbjwjgfw99v1ngg4dnxfrfpsjysa3c1q3";
+       libraryHaskellDepends = [
+         base basement bytestring containers crypton-x509 crypton-x509-store
+         crypton-x509-system crypton-x509-validation data-default-class
+         network socks tls
+       ];
+       description = "Simple and easy network connections API";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "crypton-x509" = callPackage
+    ({ mkDerivation, asn1-encoding, asn1-parse, asn1-types, base
+     , bytestring, containers, crypton, hourglass, memory, mtl, pem
+     , tasty, tasty-quickcheck, transformers, x509
+     }:
+     mkDerivation {
+       pname = "crypton-x509";
+       version = "1.7.6";
+       sha256 = "1zyaz0krf08g36g30zr5wn8f2x51l4dj2zcjnhpiw9h05p54mdzb";
+       revision = "1";
+       editedCabalFile = "10a2x47znhbayyfr6fqgq27623akpycyjbfxz4hnavavf1x6ary5";
+       libraryHaskellDepends = [
+         asn1-encoding asn1-parse asn1-types base bytestring containers
+         crypton hourglass memory pem transformers
+       ];
+       testHaskellDepends = [
+         asn1-types base bytestring crypton hourglass mtl tasty
+         tasty-quickcheck x509
+       ];
+       description = "X509 reader and writer";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "crypton-x509-store" = callPackage
+    ({ mkDerivation, asn1-encoding, asn1-types, base, bytestring
+     , containers, crypton, crypton-x509, directory, filepath, mtl, pem
+     , tasty, tasty-hunit
+     }:
+     mkDerivation {
+       pname = "crypton-x509-store";
+       version = "1.6.9";
+       sha256 = "0vr5b9cyf9x016wn1g0bryslf5nz8jq2sy8r3llwqfg02apihqiy";
+       libraryHaskellDepends = [
+         asn1-encoding asn1-types base bytestring containers crypton
+         crypton-x509 directory filepath mtl pem
+       ];
+       testHaskellDepends = [
+         base bytestring crypton-x509 tasty tasty-hunit
+       ];
+       description = "X.509 collection accessing and storing methods";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "crypton-x509-system" = callPackage
+    ({ mkDerivation, base, bytestring, containers, crypton-x509
+     , crypton-x509-store, directory, filepath, mtl, pem, process
+     }:
+     mkDerivation {
+       pname = "crypton-x509-system";
+       version = "1.6.7";
+       sha256 = "1jilnr9715njlx1hqvg5lrsrwk12r04maypmh18di0sybwg2cdm4";
+       libraryHaskellDepends = [
+         base bytestring containers crypton-x509 crypton-x509-store
+         directory filepath mtl pem process
+       ];
+       description = "Handle per-operating-system X.509 accessors and storage";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "crypton-x509-validation" = callPackage
+    ({ mkDerivation, asn1-encoding, asn1-types, base, bytestring
+     , containers, crypton, crypton-x509, crypton-x509-store
+     , data-default-class, hourglass, memory, mtl, pem, tasty
+     , tasty-hunit
+     }:
+     mkDerivation {
+       pname = "crypton-x509-validation";
+       version = "1.6.12";
+       sha256 = "1xjhwvmkcy47a6xiqxb3xy944ca7g660203jdrz5xzd46zibfq0f";
+       libraryHaskellDepends = [
+         asn1-encoding asn1-types base bytestring containers crypton
+         crypton-x509 crypton-x509-store data-default-class hourglass memory
+         mtl pem
+       ];
+       testHaskellDepends = [
+         asn1-encoding asn1-types base bytestring crypton crypton-x509
+         crypton-x509-store data-default-class hourglass memory tasty
+         tasty-hunit
+       ];
+       description = "X.509 Certificate and CRL validation";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "cryptonite" = callPackage
     ({ mkDerivation, base, basement, bytestring, deepseq, gauge
      , ghc-prim, integer-gmp, memory, random, tasty, tasty-hunit
···
        description = "Haskell Implementation of Cuckoo Filters";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "cuckoo-filter" = callPackage
···
 
   "data-diverse" = callPackage
     ({ mkDerivation, base, containers, criterion, deepseq, ghc-prim
-     , hspec, tagged
-     }:
-     mkDerivation {
-       pname = "data-diverse";
-       version = "4.7.0.0";
-       sha256 = "0ccbb8kf2spaa2h6k10y26zzaij1w28vrifhc8c1ljlvsmc9dkf3";
-       libraryHaskellDepends = [
-         base containers deepseq ghc-prim tagged
-       ];
-       testHaskellDepends = [ base hspec tagged ];
-       benchmarkHaskellDepends = [ base criterion ];
-       description = "Extensible records and polymorphic variants";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
-     }) {};
-
-  "data-diverse_4_7_1_0" = callPackage
-    ({ mkDerivation, base, containers, criterion, deepseq, ghc-prim
      , hashable, hspec, tagged
      }:
      mkDerivation {
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "daytripper" = callPackage
+    ({ mkDerivation, base, bytestring, directory, falsify
+     , optparse-applicative, tagged, tasty, tasty-hunit
+     }:
+     mkDerivation {
+       pname = "daytripper";
+       version = "0.2.1";
+       sha256 = "15bx4hla164cv328hv26fghpwjay3h96flfl7yajcfs9vfyamjyq";
+       libraryHaskellDepends = [
+         base bytestring directory falsify optparse-applicative tagged tasty
+         tasty-hunit
+       ];
+       testHaskellDepends = [
+         base bytestring directory falsify optparse-applicative tagged tasty
+         tasty-hunit
+       ];
+       description = "Helpers for round-trip tests";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "dbcleaner" = callPackage
     ({ mkDerivation, base, hspec, postgresql-simple, text }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "dbus";
-       version = "1.2.28";
-       sha256 = "0j2acn3i85v22vdf1kcjnwx2bagghdv5lil8h4i5v5wnydlaf4vw";
+       version = "1.2.29";
+       sha256 = "0c2c2lfckhzgf9n5hf2w39ryyb2q0wxsymrxr54y4j95353wdsn2";
        libraryHaskellDepends = [
          base bytestring cereal conduit containers deepseq exceptions
          filepath lens network parsec random split template-haskell text
···
        pname = "decision-diagrams";
        version = "0.2.0.0";
        sha256 = "0l03mwig95h300rn1cfhd5ahwrlap6zsw09lwmkx6wkw6rjf4a5s";
-       revision = "2";
-       editedCabalFile = "0hp3k385p5lngfa3v3g8rnf34d3x0drk8i76mlk2c9bmbsl9dmfh";
+       revision = "3";
+       editedCabalFile = "11gb1dm0rladnjr8y2w15pba8dp4hr4kb2gshikq7xiiffgx70lz";
        libraryHaskellDepends = [
          base containers hashable hashtables intern mwc-random primitive
          random reflection unordered-containers vector
···
      }:
      mkDerivation {
        pname = "dejafu";
-       version = "2.4.0.4";
-       sha256 = "0nf89l7ps8wrm97skkn8nmi7wmmnr3dxmvjmhs69abnlahj7zjqh";
+       version = "2.4.0.5";
+       sha256 = "1w38gxq3l4ch4g8rjm9wxlsf06a0334ln681jmrc27h3axn5fgh9";
        libraryHaskellDepends = [
          base concurrency containers contravariant deepseq exceptions
          leancheck profunctors random transformers
···
      }:
      mkDerivation {
        pname = "desktop-portal";
-       version = "0.2.0.0";
-       sha256 = "0h5zdkr165jgpg5v2r16d4d77k3brqyn99imnfd6gavgddm41r1r";
+       version = "0.2.1.0";
+       sha256 = "0fa1d5fqvfixbvl50yrqhqiw1dc4wkjlh7qdd9iavn44iz4b06zq";
        libraryHaskellDepends = [
          base binary bytestring containers data-default-class dbus
          modern-uri random text
···
      }:
      mkDerivation {
        pname = "diagrams-input";
-       version = "0.1.1";
-       sha256 = "0wad5xdvw33dp5fzqq9h52px3m81nsic35k9wd27ss23bfzgbb6b";
+       version = "0.1.2";
+       sha256 = "0p16anpvi627w89aqiz9hi1d8wi22pj35lsmk65gmrzbvp7hyzf3";
        libraryHaskellDepends = [
          attoparsec base base64-bytestring blaze-builder blaze-markup
          bytestring colour conduit conduit-extra containers css-text
···
      }:
      mkDerivation {
        pname = "diagrams-rasterific";
-       version = "1.4.2.2";
-       sha256 = "1q0b3yh7wbi3yq0y8qswhvfmcz52f6njl4dawq9gl71jyfb2g8nq";
-       revision = "2";
-       editedCabalFile = "1vkk5r4k2myfdrvg3s7l8cmwi3wz1nydnj0011747s1qhgzx3fjf";
-       libraryHaskellDepends = [
-         base bytestring containers data-default-class diagrams-core
-         diagrams-lib file-embed filepath FontyFruity hashable JuicyPixels
-         lens mtl optparse-applicative Rasterific
-       ];
-       testHaskellDepends = [ base diagrams-core diagrams-lib ];
-       description = "Rasterific backend for diagrams";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "diagrams-rasterific_1_4_2_3" = callPackage
-    ({ mkDerivation, base, bytestring, containers, data-default-class
-     , diagrams-core, diagrams-lib, file-embed, filepath, FontyFruity
-     , hashable, JuicyPixels, lens, mtl, optparse-applicative
-     , Rasterific
-     }:
-     mkDerivation {
-       pname = "diagrams-rasterific";
        version = "1.4.2.3";
        sha256 = "0n46scybjs8mnhrnh5z3nkrah6f8v1rv4cca8k8mqzsf8ss30q5l";
        libraryHaskellDepends = [
···
        testHaskellDepends = [ base diagrams-core diagrams-lib ];
        description = "Rasterific backend for diagrams";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "diagrams-reflex" = callPackage
···
        pname = "diagrams-svg";
        version = "1.4.3.1";
        sha256 = "002lgmq78c6rsvds9bgm6m4w8j6qpg260mc52hf97wj6m050l237";
-       revision = "4";
-       editedCabalFile = "026mkj9fz64rdrap25mp8cwdrzwj90h35qg9kkn078fac93aaq10";
+       revision = "5";
+       editedCabalFile = "00hjvv9ncf5il7a09g2gh45bwah4jbnfnhb523jz9lhqqbzxfxny";
        libraryHaskellDepends = [
          base base64-bytestring bytestring colour containers diagrams-core
          diagrams-lib filepath hashable JuicyPixels lens monoid-extras mtl
···
 
   "dns" = callPackage
     ({ mkDerivation, array, async, attoparsec, auto-update, base
-     , base16-bytestring, base64-bytestring, bytestring, containers
-     , cryptonite, doctest, hourglass, hspec, hspec-discover, iproute
-     , mtl, network, psqueues, QuickCheck, word8
+     , base16-bytestring, base64-bytestring, bytestring
+     , case-insensitive, containers, cryptonite, doctest, hourglass
+     , hspec, hspec-discover, iproute, mtl, network, psqueues
+     , QuickCheck, word8
      }:
      mkDerivation {
        pname = "dns";
-       version = "4.1.0";
-       sha256 = "1l80y48s9ryqcap587w41wrr2jzwh55gi16k7yib58xpqarcxqs5";
+       version = "4.1.1";
+       sha256 = "0f1i0w509qdzl3lpvkwrmkgfj3z694sac30ac4n46w1wx80b7cm9";
        libraryHaskellDepends = [
          array async attoparsec auto-update base base16-bytestring
-         base64-bytestring bytestring containers cryptonite hourglass
-         iproute mtl network psqueues
+         base64-bytestring bytestring case-insensitive containers cryptonite
+         hourglass iproute mtl network psqueues
        ];
        testHaskellDepends = [
-         base bytestring doctest hspec iproute network QuickCheck word8
+         base bytestring case-insensitive doctest hspec iproute network
+         QuickCheck word8
        ];
        testToolDepends = [ hspec-discover ];
        doHaddock = false;
···
      }:
      mkDerivation {
        pname = "doctest-extract";
-       version = "0.1";
-       sha256 = "1ncrq67d6zcqw5al5m2g7q6ys8rxhsq8rrzbj1dlsyl4q63vyrms";
-       revision = "4";
-       editedCabalFile = "021s7c8zj5b2ssva02ssnhcrn7avrshidj29zdpccipr4xy1vd0v";
+       version = "0.1.1";
+       sha256 = "15hizi4m879c2rahxxl78smpr5iqwry05jma58ldsypmwrlyxniz";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        mainProgram = "dotenv";
      }) {};
 
-  "dotenv_0_11_0_0" = callPackage
-    ({ mkDerivation, base, base-compat, containers, directory
-     , exceptions, hspec, hspec-discover, hspec-megaparsec, megaparsec
-     , mtl, optparse-applicative, process, shellwords, text
+  "dotenv_0_11_0_1" = callPackage
+    ({ mkDerivation, base, base-compat, containers, data-default-class
+     , directory, exceptions, hspec, hspec-discover, hspec-megaparsec
+     , megaparsec, mtl, optparse-applicative, process, shellwords, text
      }:
      mkDerivation {
        pname = "dotenv";
-       version = "0.11.0.0";
-       sha256 = "0cw24w6vkc17ahf0s5l2bgvv7yi0j5rlr549gz1wwa462qm9mlgi";
+       version = "0.11.0.1";
+       sha256 = "0z09l3dmj9dhq8vgkdiz07wjmn3i0d9fg6zqs9ryjnqdfa27yy4i";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
-         base containers directory exceptions megaparsec mtl process
-         shellwords text
+         base containers data-default-class directory exceptions megaparsec
+         mtl process shellwords text
        ];
        executableHaskellDepends = [
          base base-compat megaparsec optparse-applicative process text
        ];
        testHaskellDepends = [
-         base base-compat containers directory exceptions hspec
-         hspec-megaparsec megaparsec mtl process shellwords text
+         base hspec hspec-megaparsec megaparsec process text
        ];
        testToolDepends = [ hspec-discover ];
        description = "Loads environment variables from dotenv files";
···
      }:
      mkDerivation {
        pname = "dprox";
-       version = "0.4.1";
-       sha256 = "1gqx18pfq749hzgq5q7c146cfkdw688l2398pxm59wz65g19bvl4";
+       version = "0.4.2";
+       sha256 = "1l0bnhhprx944kwn3k7acyh1129wi9bim9rikc86raws8nmfqzwp";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "elasticsearch-interchange";
-       version = "0.1.0.0";
-       sha256 = "0js90hcq3m1b928fywcvm8yyc1d35ya630zxdxpbylmqv4h0yz6y";
+       version = "0.2.0.0";
+       sha256 = "0mh8fb6x99xx3hz41g90pah5zj3dns5q8jy310klsh615hym72bp";
        libraryHaskellDepends = [
          base bytebuild json-query json-syntax primitive text-short
          unpacked-maybe-text
···
      }:
      mkDerivation {
        pname = "elynx";
-       version = "0.7.2.0";
-       sha256 = "0dx2s3p1c59mg6wyw2g2gjr3q32gqmzycrhg98f48v9g2zy8icy3";
+       version = "0.7.2.1";
+       sha256 = "031wmjf9vbfkvcrkqjy0c27g9c7qkmcdnldq51zc9jpxnhy03s6y";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "elynx-markov";
-       version = "0.7.2.0";
-       sha256 = "1qwizz89cckmp6xfn88g2psqs9ajirj26qpyp488ilvmcckgj91g";
+       version = "0.7.2.1";
+       sha256 = "0zp3xjvbpnd6i2j8aviil82zah0qf2j8m4ys22xbggsmr2jmcyfr";
        libraryHaskellDepends = [
          async attoparsec base bytestring containers elynx-seq hmatrix
          integration math-functions mwc-random random statistics vector
···
     ({ mkDerivation, attoparsec, base, bytestring, hspec }:
      mkDerivation {
        pname = "elynx-nexus";
-       version = "0.7.2.0";
-       sha256 = "051nqb3sppppymhs022srmbxndzjvp4slwjb1swhvp0f5njwi3xg";
+       version = "0.7.2.1";
+       sha256 = "1lfadvw43m97jv4if1prb4xnnsbva96fjplhbzgvvc2anpaarfy0";
        libraryHaskellDepends = [ attoparsec base bytestring ];
        testHaskellDepends = [ base hspec ];
        description = "Import and export Nexus files";
···
      }:
      mkDerivation {
        pname = "elynx-seq";
-       version = "0.7.2.0";
-       sha256 = "1xj27aw1w6pbaalk1xkl1v9q3b8asklr60j5hcpp823cc395wz4p";
+       version = "0.7.2.1";
+       sha256 = "0cp44r66cb3vw5dahlzxk7gqqb2dafy4diygc28k0h9az4iv7w8k";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring containers matrices parallel
          primitive random vector vector-th-unbox word8
···
      }:
      mkDerivation {
        pname = "elynx-tools";
-       version = "0.7.2.0";
-       sha256 = "1cj139n51gr372aj2d8ahqrinlif7b3zyza6dqqa16nb01xh9qi5";
+       version = "0.7.2.1";
+       sha256 = "01cw6n3br15alrjhwf3bx7mn0vbxkdwn51cdg004i0s35fzb5dxn";
        libraryHaskellDepends = [
          aeson attoparsec base base16-bytestring bytestring
          cryptohash-sha256 directory hmatrix optparse-applicative random
···
      }:
      mkDerivation {
        pname = "elynx-tree";
-       version = "0.7.2.0";
-       sha256 = "16ryvri7maxzsd61f0vim2lqw6xplnpyaa0lbyjalvrdqiaqb4is";
+       version = "0.7.2.1";
+       sha256 = "018hk2gsh1qf6vk4vcs76mc7sakvq34a2lamlwasgw8q155mc45g";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring comonad containers
          data-default-class deepseq elynx-nexus math-functions parallel
···
      }:
      mkDerivation {
        pname = "esqueleto";
-       version = "3.5.9.0";
-       sha256 = "0r9p4kg3m9g4cpd9lcw9ljzf9wrl8wwdcp4gqwidg75wbpy3fy47";
+       version = "3.5.10.0";
+       sha256 = "0nbb6l4q22y8rwcjsrwqri3ndjn4rslpnglj3nkh00rixdm9jhsr";
        libraryHaskellDepends = [
          aeson attoparsec base blaze-html bytestring conduit containers
          monad-logger persistent resourcet tagged template-haskell text time
···
        pname = "evdev-streamly";
        version = "0.0.2.0";
        sha256 = "0vrkg3d1171lsr71k3vrcf9vbl18mdnvpi02sxvzjp2zbv3gs7v6";
+       revision = "1";
+       editedCabalFile = "11w831ml0dn9v3gchv8465w43ml8cgcfwgxmpwnjy6v8p34q14qm";
        libraryHaskellDepends = [
          base bytestring containers evdev extra filepath-bytestring
          rawfilepath streamly streamly-fsnotify unix
···
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        mainProgram = "ewe";
+       broken = true;
      }) {};
 
   "ex-pool" = callPackage
···
 
   "fastparser" = callPackage
     ({ mkDerivation, base, bytestring, bytestring-lexing, containers
-     , criterion, kan-extensions, microlens, thyme, transformers
-     , vector-space
+     , kan-extensions, microlens, thyme, transformers, vector-space
      }:
      mkDerivation {
        pname = "fastparser";
-       version = "0.5.0";
-       sha256 = "0pxd2f6f0a6kckqmkkafh9zx11x75x1zx1z90snzj3j8s4jcfg4y";
-       revision = "1";
-       editedCabalFile = "0h64i8z71h0hfdc89bpqqamjn733mxshmlpapa4gvlnbzylm3cwr";
+       version = "0.6.0";
+       sha256 = "0y0s1p4kzwgcmmdxybi8sp3jc68g95nbya12xd0afqxw1li6qabs";
        libraryHaskellDepends = [
          base bytestring bytestring-lexing containers kan-extensions
          microlens thyme transformers vector-space
        ];
-       benchmarkHaskellDepends = [ base bytestring criterion ];
+       benchmarkHaskellDepends = [ base bytestring ];
        description = "A fast, but bare bones, bytestring parser combinators library";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
···
        pname = "fft";
        version = "0.1.8.7";
        sha256 = "1kkdw08qzsgjgg9z7pf5876cn2hlq22cgvc3k2amidn317n2d6vz";
+       revision = "1";
+       editedCabalFile = "12zcr05lgc78jvpwhvsxzmcra1x7rrzlxgqlq8hh2jw4r72589lz";
        libraryHaskellDepends = [
          array base carray ix-shapable storable-complex syb transformers
        ];
···
        testHaskellDepends = [ base carray QuickCheck storable-complex ];
        description = "Bindings to the FFTW library";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
        maintainers = [ lib.maintainers.thielema ];
-       broken = true;
      }) {inherit (pkgs) fftw; inherit (pkgs) fftwFloat;};
 
   "fftw-ffi" = callPackage
···
     ({ mkDerivation, base, basement, gauge, ghc-prim }:
      mkDerivation {
        pname = "foundation";
-       version = "0.0.29";
-       sha256 = "1hbkh6a3g6wsj2z48pjimd7djkm82mdxfwc24bnmmzag8amrp0rl";
+       version = "0.0.30";
+       sha256 = "11hdqd01ggdr7fjw3w00giay06bzz97qqiiq60vi1l1dzz1wrwzn";
        libraryHaskellDepends = [ base basement ghc-prim ];
        testHaskellDepends = [ base basement ];
        benchmarkHaskellDepends = [ base basement gauge ];
···
        mainProgram = "fourmolu";
      }) {};
 
-  "fourmolu_0_12_0_0" = callPackage
+  "fourmolu_0_13_0_0" = callPackage
     ({ mkDerivation, aeson, ansi-terminal, array, base, binary
      , bytestring, Cabal-syntax, containers, deepseq, Diff, directory
      , file-embed, filepath, ghc-lib-parser, hspec, hspec-discover
···
      }:
      mkDerivation {
        pname = "fourmolu";
-       version = "0.12.0.0";
-       sha256 = "0689w4h3y9qr8sxzphklns59jk31ld8y6dzk424xav5zaharmjjp";
-       revision = "2";
-       editedCabalFile = "0xwfsxn8n7bz47yivab2yjvmww51b2fmvbwm2wbrni11c8fh89z3";
+       version = "0.13.0.0";
+       sha256 = "0mx2zmr8i9qvqajri1sc7hzl9swz9s7qswi8vqf90hcz2lfc80ji";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          ghc-lib-parser megaparsec MemoTrie mtl scientific syb text yaml
        ];
        executableHaskellDepends = [
-         base containers directory filepath ghc-lib-parser
+         base Cabal-syntax containers directory filepath ghc-lib-parser
          optparse-applicative text th-env yaml
        ];
        testHaskellDepends = [
          base Cabal-syntax containers Diff directory filepath ghc-lib-parser
-         hspec hspec-megaparsec path path-io pretty process QuickCheck
-         temporary text
+         hspec hspec-megaparsec megaparsec path path-io pretty process
+         QuickCheck temporary text
        ];
        testToolDepends = [ hspec-discover ];
        description = "A formatter for Haskell source code";
···
        benchmarkHaskellDepends = [ base tasty-bench ];
        description = "IEEE 754-2019 compliant operations";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "fpco-api" = callPackage
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "freckle-app_1_9_0_2" = callPackage
+  "freckle-app_1_9_0_3" = callPackage
     ({ mkDerivation, aeson, aws-xray-client-persistent
      , aws-xray-client-wai, base, Blammo, bugsnag, bytestring
      , case-insensitive, cassava, conduit, conduit-extra, containers
···
      }:
      mkDerivation {
        pname = "freckle-app";
-       version = "1.9.0.2";
-       sha256 = "13hsccdflfpwkjbr6420s6c9pzp2irszj1gah6n54kiirsfw44h0";
+       version = "1.9.0.3";
+       sha256 = "15fih8ky1cg9sn25hkwxi5iwy0zn76lbs308saaby6kkgifqm8yv";
        libraryHaskellDepends = [
          aeson aws-xray-client-persistent aws-xray-client-wai base Blammo
          bugsnag bytestring case-insensitive cassava conduit conduit-extra
···
      }:
      mkDerivation {
        pname = "free-algebras";
-       version = "0.1.0.2";
-       sha256 = "0n7zika42ljdkn5yyn70hs6p5l49n60f5cl7azpxkzvzv97l8ih8";
+       version = "0.1.1.0";
+       sha256 = "16y0jvvsz1wr1w0hibnh94r438576ciq5snwjha8ca5b4c9ym980";
        libraryHaskellDepends = [
          base containers data-fix dlist free groups kan-extensions mtl
          transformers
···
      }:
      mkDerivation {
        pname = "free-category";
-       version = "0.0.4.4";
-       sha256 = "17xv80scr6pdyzkynk56mlcz4inbfd673095j7z9914s0d31c6cf";
+       version = "0.0.4.5";
+       sha256 = "0ag52rmxrlhf5afk6nhrcpqwknvqrk9rhfn977zn1i0ad5b6ghag";
        libraryHaskellDepends = [ base free-algebras ];
        testHaskellDepends = [
          base free-algebras QuickCheck tasty tasty-quickcheck
···
        ];
        description = "A functional image processing library for Haskell";
        license = lib.licenses.lgpl3Only;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "friday-devil" = callPackage
···
        ];
        description = "Converts between the Friday and JuicyPixels image types";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "friday-scale-dct" = callPackage
···
      }:
      mkDerivation {
        pname = "fused-effects";
-       version = "1.1.2.1";
-       sha256 = "1h9nnfn0i89gr8151dlxcyjh9467l25y6glyy5zbqkhwxglmjns0";
+       version = "1.1.2.2";
+       sha256 = "00m1lnn8zsb6iniyjmmbgiz7kd5c5kl7rxqqxlc2dkb4hpyrm4v5";
        libraryHaskellDepends = [ base transformers unliftio-core ];
        testHaskellDepends = [
          base containers hedgehog hedgehog-fn inspection-testing
···
        pname = "futhark";
        version = "0.24.3";
        sha256 = "0y83phng77asca4pk66w8grx8b4d1ip7xi77vrfjc04yjagrj1ba";
-       revision = "1";
-       editedCabalFile = "10784arp172kdq69a33fcdrzxy0p9ymf0i2vr1ywjrsbcl05sln9";
+       revision = "2";
+       editedCabalFile = "0pzhdg410mnxz0116lpr9ax8x0skg2gymhqhm730dn17sd7z6y56";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          appendful base criterion genvalidity-criterion
        ];
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "genvalidity-bytestring" = callPackage
···
        ];
        description = "Generators for typed directory forests";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "genvalidity-hspec" = callPackage
···
        testToolDepends = [ sydtest-discover ];
        description = "Standard properties for functions on `Validity` types for the sydtest framework";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "genvalidity-sydtest-aeson" = callPackage
···
        testToolDepends = [ sydtest-discover ];
        description = "Standard spec's for aeson-related instances in sydtest";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "genvalidity-sydtest-hashable" = callPackage
···
        testToolDepends = [ sydtest-discover ];
        description = "Standard spec's for Hashable instances for sydtest";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "genvalidity-sydtest-lens" = callPackage
···
        testToolDepends = [ sydtest-discover ];
        description = "Standard spec's for lens for sydtest";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "genvalidity-sydtest-persistent" = callPackage
···
        testToolDepends = [ sydtest-discover ];
        description = "Standard spec's for persistent-related instances for sydtest";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "genvalidity-text" = callPackage
···
      }) {};
 
   "geojson" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, containers, deepseq, lens
-     , scientific, semigroups, tasty, tasty-hspec, tasty-quickcheck
-     , text, transformers, validation, vector
+    ({ mkDerivation, aeson, base, bytestring, containers, deepseq
+     , hspec, lens, scientific, semigroups, tasty, tasty-hspec
+     , tasty-quickcheck, text, transformers, validation, vector
      }:
      mkDerivation {
        pname = "geojson";
-       version = "4.1.0";
-       sha256 = "1p8vl13g9axbqqj3qbl453p4qwwmz0xjhpa5vmlk1fjznr04mdx6";
+       version = "4.1.1";
+       sha256 = "16b5mvn4as3xi620n6wr3gfd138p48c4sif2bxqw915fwm4z10sl";
        libraryHaskellDepends = [
          aeson base containers deepseq lens scientific semigroups text
          transformers validation vector
        ];
        testHaskellDepends = [
-         aeson base bytestring containers tasty tasty-hspec tasty-quickcheck
-         text validation
+         aeson base bytestring containers hspec tasty tasty-hspec
+         tasty-quickcheck text validation
        ];
        description = "A thin GeoJSON Layer above the aeson library";
        license = lib.licenses.bsd3;
···
      }) {};
 
   "geomancy" = callPackage
-    ({ mkDerivation, base, containers, criterion, deepseq, hedgehog
-     , linear, mono-traversable, ptrdiff, simple-affine-space
+    ({ mkDerivation, base, containers, criterion, deepseq, gl-block
+     , hedgehog, linear, mono-traversable, ptrdiff, simple-affine-space
      }:
      mkDerivation {
        pname = "geomancy";
-       version = "0.2.5.0";
-       sha256 = "0mpp2cl5404kxsk2ci8hqawrv6w57adjp92x6jraxf5xghrcs2d6";
+       version = "0.2.6.0";
+       sha256 = "14imwg21ig2n1g4l6z55wbkrjg9mzswgqdirzbdvp2y0krk6259q";
        libraryHaskellDepends = [
-         base containers deepseq mono-traversable ptrdiff
+         base containers deepseq gl-block mono-traversable ptrdiff
          simple-affine-space
        ];
        testHaskellDepends = [
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "gev-lib" = callPackage
+    ({ mkDerivation, base, gev-dist, HUnit, random }:
+     mkDerivation {
+       pname = "gev-lib";
+       version = "0.2.0.1";
+       sha256 = "1ql1m2ywcma6dpchg255q9r2dq612kx03jwa6vgzinh8va51mc9l";
+       libraryHaskellDepends = [ base random ];
+       testHaskellDepends = [ base gev-dist HUnit ];
+       description = "The family of Extreme Value Distributions";
+       license = lib.licenses.isc;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {gev-dist = null;};
+
   "gf" = callPackage
     ({ mkDerivation, alex, array, base, bytestring, Cabal, cgi
      , containers, directory, exceptions, filepath, ghc-prim, happy
···
      }:
      mkDerivation {
        pname = "ghc-debug-brick";
-       version = "0.4.0.1";
-       sha256 = "0qnx34yasr0f0bwpnm1qsybxp5aqjfhrhxxzr0477rhz5simnbys";
+       version = "0.5.0.0";
+       sha256 = "1k5gl9paz5z8w9h49ilpjxk0k73qyk2rwncnfhx11b64y2n74w2m";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
 
   "ghc-debug-client" = callPackage
     ({ mkDerivation, async, base, binary, bitwise, bytestring
-     , containers, contra-tracer, directory, dom-lt, eventlog2html
-     , filepath, ghc-debug-common, ghc-debug-convention, ghc-prim
-     , hashable, language-dot, monoidal-containers, mtl, network
-     , process, psqueues, stm, text, unordered-containers
+     , containers, contra-tracer, directory, dom-lt, filepath
+     , ghc-debug-common, ghc-debug-convention, ghc-prim, hashable
+     , language-dot, monoidal-containers, mtl, network, process
+     , psqueues, stm, text, unordered-containers
      }:
      mkDerivation {
        pname = "ghc-debug-client";
-       version = "0.4.0.1";
-       sha256 = "0yfcl2hz9pzbyavp6xc08my1q37cngdqq85bdf4d1xkb5hvschib";
+       version = "0.5.0.0";
+       sha256 = "0djv1y0fxg0vzr0baxml023i3a9di2zy0xhyxqg8wb0j9k5pszh0";
        libraryHaskellDepends = [
          async base binary bitwise bytestring containers contra-tracer
-         directory dom-lt eventlog2html filepath ghc-debug-common
-         ghc-debug-convention ghc-prim hashable language-dot
-         monoidal-containers mtl network process psqueues stm text
-         unordered-containers
+         directory dom-lt filepath ghc-debug-common ghc-debug-convention
+         ghc-prim hashable language-dot monoidal-containers mtl network
+         process psqueues stm text unordered-containers
        ];
        description = "Useful functions for writing heap analysis tools which use ghc-debug";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "ghc-debug-common";
-       version = "0.4.0.0";
-       sha256 = "1h3a1j97xnfpki25nsc80kql751xz59i3cvcf12qh97ii2vziwk5";
+       version = "0.5.0.0";
+       sha256 = "0x2phkcnbfybkfy94g6jyc1s4wcls1r8ws4b5wnjl58pf8q09ni2";
        libraryHaskellDepends = [
          array base binary bytestring containers cpu deepseq directory
          dom-lt filepath ghc-debug-convention ghc-heap hashable transformers
···
     ({ mkDerivation, base, directory, filepath }:
      mkDerivation {
        pname = "ghc-debug-convention";
-       version = "0.4.0.0";
-       sha256 = "0mmghsf4g4hwls1cldmqzjq9sfnwwp0d94ahxryxd0dla7x423s6";
+       version = "0.5.0.0";
+       sha256 = "1hg2b3g7nqba5y4s1imaikx9y8vm4i6cb47nbnp07zwqg9zjlq3k";
        libraryHaskellDepends = [ base directory filepath ];
        description = "Definitions needed by ghc-debug-stub and ghc-debug-common";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "ghc-debug-stub";
-       version = "0.4.0.0";
-       sha256 = "0qnshkk3cw26l6x8c415l4s99qkpq5hgl1p7n85w8kbi1xzlgm0w";
+       version = "0.5.0.0";
+       sha256 = "1ykwfp841wbnqgsvvspixr95ars1np2khjlzycmb3q7cxv2xn2lw";
        libraryHaskellDepends = [
          base directory filepath ghc-debug-convention ghc-prim
        ];
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "ghc-exactprint_1_6_1_1" = callPackage
+  "ghc-exactprint_1_6_1_3" = callPackage
     ({ mkDerivation }:
      mkDerivation {
        pname = "ghc-exactprint";
-       version = "1.6.1.1";
-       sha256 = "0dzl5nhiwi6a5jq226qjq0vlb70iq50hk0kv0h675j4pr93v50w8";
+       version = "1.6.1.3";
+       sha256 = "1qsb799dr4hl0f5m1yhrk50nc29w3wiadkvlzgn2426zsg0ixfpy";
        isLibrary = true;
        isExecutable = true;
        description = "ExactPrint for GHC";
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "ghc-exactprint_1_7_0_0" = callPackage
+  "ghc-exactprint_1_7_0_1" = callPackage
     ({ mkDerivation }:
      mkDerivation {
        pname = "ghc-exactprint";
-       version = "1.7.0.0";
-       sha256 = "05api7p0rq1dzkcwqv43sff9qdl44gidgz6p75lal9pp394g10v5";
+       version = "1.7.0.1";
+       sha256 = "0lf3grridkx5xb5zz8shx3vkzwqsc3y5rbgw7w6hbsgp7ac90jjz";
        isLibrary = true;
        isExecutable = true;
        description = "ExactPrint for GHC";
···
      }:
      mkDerivation {
        pname = "ghc-hs-meta";
-       version = "0.1.1.0";
-       sha256 = "0yrrf0lx626rl4b14jaqmkab1vf4vymi81jkjm91y5vas8zc276i";
+       version = "0.1.2.0";
+       sha256 = "13i4fcc3wfx94n75cxp00p62mnm0raf2xqj2afrzcw3q6mc0l0y4";
        libraryHaskellDepends = [
          base bytestring ghc ghc-boot template-haskell
        ];
···
 
   "gi-adwaita" = callPackage
     ({ mkDerivation, base, bytestring, Cabal, containers, gi-gdk
-     , gi-gio, gi-gobject, gi-gtk, gi-pango, haskell-gi, haskell-gi-base
-     , haskell-gi-overloading, libadwaita, text, transformers
+     , gi-gio, gi-glib, gi-gobject, gi-gtk, gi-pango, haskell-gi
+     , haskell-gi-base, haskell-gi-overloading, libadwaita, text
+     , transformers
      }:
      mkDerivation {
        pname = "gi-adwaita";
-       version = "1.0.5";
-       sha256 = "1nm9mp0qisvrysygb8p7x9m7v15lak4qkps6ypwrxvwldx21ncsy";
+       version = "1.0.6";
+       sha256 = "0d5qswxbr8hl0mykjifgxivcbv55viva0gfw5zmgmswkp7my56q2";
        setupHaskellDepends = [
-         base Cabal gi-gdk gi-gio gi-gobject gi-gtk gi-pango haskell-gi
+         base Cabal gi-gdk gi-gio gi-glib gi-gobject gi-gtk gi-pango
+         haskell-gi
        ];
        libraryHaskellDepends = [
-         base bytestring containers gi-gdk gi-gio gi-gobject gi-gtk gi-pango
-         haskell-gi haskell-gi-base haskell-gi-overloading text transformers
+         base bytestring containers gi-gdk gi-gio gi-glib gi-gobject gi-gtk
+         gi-pango haskell-gi haskell-gi-base haskell-gi-overloading text
+         transformers
        ];
        libraryPkgconfigDepends = [ libadwaita ];
        description = "Adwaita bindings";
···
      }:
      mkDerivation {
        pname = "gi-gtk-hs";
-       version = "0.3.14";
-       sha256 = "1c4aqyv104m06k1hl5fpfbgyvmqb5pkhzibqbkia2ngf6mdpqy2m";
+       version = "0.3.16";
+       sha256 = "1zdkxhvy4i99p6qcrc53qlxv71vh05w9xd0j1qh20aci05n1nnha";
        libraryHaskellDepends = [
          base base-compat containers gi-gdk gi-gdkpixbuf gi-glib gi-gobject
          gi-gtk haskell-gi-base mtl text transformers
···
      }:
      mkDerivation {
        pname = "github-rest";
-       version = "1.1.2";
-       sha256 = "139ysq1m1ndy6z1znfd1np25ynxankkfm6xmwabhdr7yiqzi2v1b";
-       revision = "2";
-       editedCabalFile = "0390zxa270d8x8a0imd71z72l6hxnn1ip6jjgrrvrs3zj20c7adp";
+       version = "1.1.3";
+       sha256 = "0na4kfwlxfqd7d99vc1hkqrp9nlp21a3xpiwhlm3vzcgzrmk2f0v";
        libraryHaskellDepends = [
          aeson base bytestring http-client http-client-tls http-types jwt
          mtl scientific text time transformers unliftio unliftio-core
        ];
        testHaskellDepends = [
-         aeson aeson-qq base bytestring http-client http-client-tls
-         http-types jwt mtl scientific tasty tasty-golden tasty-hunit
-         tasty-quickcheck text time transformers unliftio unliftio-core
+         aeson aeson-qq base bytestring http-types mtl tasty tasty-golden
+         tasty-hunit tasty-quickcheck text
        ];
        description = "Query the GitHub REST API programmatically";
        license = lib.licenses.bsd3;
···
        badPlatforms = lib.platforms.darwin;
      }) {inherit (pkgs) libGL;};
 
+  "gl-block" = callPackage
+    ({ mkDerivation, base, ptrdiff, tasty, tasty-bench, tasty-discover
+     , tasty-hunit, vector
+     }:
+     mkDerivation {
+       pname = "gl-block";
+       version = "1.0";
+       sha256 = "1knx5lvbjlwxs2g9w6fk39xzpypv3v66173sf48d6mfln2v2551f";
+       libraryHaskellDepends = [ base ptrdiff ];
+       testHaskellDepends = [ base tasty tasty-hunit ];
+       testToolDepends = [ tasty-discover ];
+       benchmarkHaskellDepends = [ base tasty tasty-bench vector ];
+       description = "OpenGL standard memory layouts";
+       license = "(BSD-2-Clause OR Apache-2.0)";
+     }) {};
+
   "gl-capture" = callPackage
     ({ mkDerivation, base, bytestring, OpenGL }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "glabrous";
-       version = "2.0.6";
-       sha256 = "1yz2h8x8hhy8nqy2pppax0mbb3k2ydcspbyngy19afphxxd5bbkz";
+       version = "2.0.6.1";
+       sha256 = "1y6hkih8qc7ld6sxfarcjd1yyqvgv7s4d2fch62m0gzcq77f9gsg";
        libraryHaskellDepends = [
          aeson aeson-pretty attoparsec base bytestring cereal cereal-text
          either text unordered-containers
···
        mainProgram = "gltf-loader";
      }) {};
 
+  "glualint" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, deepseq
+     , directory, effectful, filemanip, filepath, optparse-applicative
+     , parsec, pretty, signal, uu-parsinglib, uuagc, uuagc-cabal
+     }:
+     mkDerivation {
+       pname = "glualint";
+       version = "1.24.6";
+       sha256 = "0br2732xikwcv2q2x1xk5d1ly71khfxy7d23hz2f66h0sl7vsl3w";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base bytestring containers parsec pretty uu-parsinglib uuagc
+         uuagc-cabal
+       ];
+       executableHaskellDepends = [
+         aeson base bytestring containers deepseq directory effectful
+         filemanip filepath optparse-applicative signal
+       ];
+       description = "Attempts to fix your syntax erroring Lua files";
+       license = lib.licenses.lgpl21Plus;
+       mainProgram = "glualint";
+     }) {};
+
   "glue" = callPackage
     ({ mkDerivation, async, base, ekg-core, hashable, hspec
      , lifted-base, monad-control, monad-loops, QuickCheck
···
      }:
      mkDerivation {
        pname = "google-maps-geocoding";
-       version = "0.7.0.1";
-       sha256 = "01330l7z0s30mk0vh4j0kcl5xmfyahr16is7ldxf4h3y9w8b3ajg";
+       version = "0.7.0.2";
+       sha256 = "1y05vlfn1wrzb6hcfg2wrlwbcz63xr7w6mqb2zq86yww5i1xpkvx";
        libraryHaskellDepends = [
          aeson base google-static-maps http-client servant servant-client
          text
···
      }:
      mkDerivation {
        pname = "google-static-maps";
-       version = "0.7.0.1";
-       sha256 = "0cs5hwll03liqml504kw7zzyk1ah5lbpxpqzwhfhkzz5a9swigqa";
+       version = "0.7.0.2";
+       sha256 = "05dcy6vswh4b5cz4pf0aa3x1fwzv6q35xfv80978ncp6hpzvb1d1";
        libraryHaskellDepends = [
          aeson base base64-bytestring bytedump bytestring cryptonite
          double-conversion http-client JuicyPixels memory network-uri
···
      }:
      mkDerivation {
        pname = "gothic";
-       version = "0.1.8";
-       sha256 = "1gicw2g86xz68a8qvj0p2nxw42rwibr0qqi53nily5yvlc40v4qd";
+       version = "0.1.8.1";
+       sha256 = "08d80gv55vfxyy88b0wdzwvxi8kzjv1pgfknffxsvnbk2bf0nmgf";
        libraryHaskellDepends = [
          aeson base binary bytestring connection exceptions hashable
          http-client http-client-tls http-conduit http-types lens lens-aeson
···
        pname = "grab";
        version = "0.0.0.8";
        sha256 = "0g3b79q985r6r6dfd97x1fhdj8fh35qnz9b34b78982qg60pl6y6";
+       revision = "1";
+       editedCabalFile = "1qyd89ijz7scz6pzqhqddypsbc9xpn2kaw5hcvbsk6rhl4pdkgqs";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base hedgehog ];
        benchmarkHaskellDepends = [ base criterion ];
···
        pname = "grab-form";
        version = "0.0.0.8";
        sha256 = "0q1lx6lybariwhnlbg49m683jppn6da5q8h3xmg795m420x1dk5a";
+       revision = "1";
+       editedCabalFile = "0hmf6pl19frv3839vr60w72azb8pnf2mvpyv707kg51c4zgk79fw";
        libraryHaskellDepends = [ base containers grab text ];
        testHaskellDepends = [ base containers grab hedgehog text ];
        description = "Applicative parsers for form parameter lists";
···
      }:
      mkDerivation {
        pname = "graphql-client";
-       version = "1.2.1";
-       sha256 = "02wrwb5vgj4px6m178wmfzzy1d2h6018wj106n0j4lzbxyh107iy";
-       revision = "2";
-       editedCabalFile = "0mmknz40l40jb4xnz8z3bzzl3aq243zpiqkyz9kfsmhq6hwzkidb";
+       version = "1.2.2";
+       sha256 = "0m89j9caawijfmq8r0drh16psc82nnwj6sg256hls6539pxxza6k";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "h-raylib";
-       version = "4.6.0.3";
-       sha256 = "0796hlc63pmbs861316xh6wrw72zczjkl9wx6mwjfcpq1jg4b5fp";
+       version = "4.6.0.4";
+       sha256 = "1x9fz0ilvzj75nh4lcwz6w2fjmmbxymd7bfqivc04zz6d4wscli3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers lens ];
···
   "hackport" = callPackage
     ({ mkDerivation, array, async, base, base16-bytestring
      , base64-bytestring, binary, bytestring, containers
-     , cryptohash-sha256, deepseq, directory, echo, ed25519
-     , edit-distance, exceptions, extensible-exceptions, filepath
-     , ghc-prim, hashable, hspec, hspec-discover, HTTP, lifted-base
-     , lukko, monad-control, mtl, network, network-uri
-     , optparse-applicative, parallel, parsec, parser-combinators
-     , pretty, process, QuickCheck, random, regex-base, regex-posix
-     , resolv, safe-exceptions, split, stm, tar, template-haskell, text
-     , time, transformers, unix, xml, zlib
+     , cryptohash-sha256, deepseq, directory, dlist, doctest, echo
+     , ed25519, edit-distance, exceptions, extensible-exceptions
+     , filepath, ghc-compact, ghc-prim, hashable, hspec, hspec-discover
+     , HTTP, lifted-base, lukko, monad-control, mtl, network
+     , network-uri, optparse-applicative, parallel, parsec
+     , parser-combinators, pretty, prettyprinter, process, QuickCheck
+     , random, regex-base, regex-posix, resolv, safe-exceptions, split
+     , stm, tar, template-haskell, text, time, transformers, unix, xml
+     , zlib
      }:
      mkDerivation {
        pname = "hackport";
-       version = "0.8.3.0";
-       sha256 = "09vvp8w6nlbs41mbdbzhg49lqa941mb74n59gvmi6kjii3cmhlis";
+       version = "0.8.4.0";
+       sha256 = "1bg5cb3sfpp59sk4cswk4dr2dsjx9qh3sf3yj3x39ha3q5bdrgvd";
        isLibrary = false;
        isExecutable = true;
        libraryHaskellDepends = [
          array async base base16-bytestring base64-bytestring binary
-         bytestring containers cryptohash-sha256 deepseq directory echo
-         ed25519 edit-distance exceptions extensible-exceptions filepath
-         ghc-prim hashable HTTP lifted-base lukko monad-control mtl network
-         network-uri parallel parsec pretty process QuickCheck random
-         regex-base regex-posix resolv safe-exceptions split stm tar
-         template-haskell text time transformers unix xml zlib
+         bytestring containers cryptohash-sha256 deepseq directory dlist
+         echo ed25519 edit-distance exceptions extensible-exceptions
+         filepath ghc-compact ghc-prim hashable HTTP lifted-base lukko
+         monad-control mtl network network-uri optparse-applicative parallel
+         parsec pretty process QuickCheck random regex-base regex-posix
+         resolv safe-exceptions split stm tar template-haskell text time
+         transformers unix xml zlib
        ];
        executableHaskellDepends = [
          base directory filepath optparse-applicative parsec
-         parser-combinators
+         parser-combinators prettyprinter process
        ];
        testHaskellDepends = [
          async base bytestring containers deepseq directory
          extensible-exceptions filepath hspec network-uri parallel parsec
          pretty process QuickCheck split text time xml
        ];
-       testToolDepends = [ hspec-discover ];
+       testToolDepends = [ doctest hspec-discover ];
        doHaddock = false;
        description = "Hackage and Portage integration tool";
        license = lib.licenses.gpl3Plus;
···
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        broken = true;
+     }) {};
+
+  "halfsplit" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "halfsplit";
+       version = "0.1.0.0";
+       sha256 = "1idrik8w0z913n4jdba7m58i63krzxf4kv35rm5k8yr8w30xxr7i";
+       libraryHaskellDepends = [ base ];
+       description = "A library to provide special kind of two-column terminal output for Phladiprelio";
+       license = lib.licenses.mit;
      }) {};
 
        description = "PID control loop";
···
        description = "PID control loop";
        description = "PID control loop";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
+       platforms = lib.platforms.linux;
      }) {};
 
        description = "PID control loop";
···
        ];
        description = "PID control loop";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
+       platforms = lib.platforms.linux;
        description = "PID control loop";
 
        description = "PID control loop";
···
        benchmarkSystemDepends = [ openssl ];
        description = "PID control loop";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {inherit (pkgs) openssl;};
 
        description = "PID control loop";
···
      }:
      mkDerivation {
        description = "PID control loop";
-       description = "PID control loop";
-       description = "PID control loop";
+       version = "0.26.7";
+       sha256 = "1h19cli06ava1z3w1y7d7cvcjdw5hhwqa9yh102rrnpxq6rblrm9";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
        description = "PID control loop";
···
        license = lib.licenses.lgpl21Only;
        description = "PID control loop";
 
-       description = "PID control loop";
-       description = "PID control loop";
-       description = "PID control loop";
-       description = "PID control loop";
-       description = "PID control loop";
-     }:
-     mkDerivation {
-       description = "PID control loop";
-       description = "PID control loop";
-       description = "PID control loop";
-       setupHaskellDepends = [ base Cabal cabal-doctest ];
-       libraryHaskellDepends = [
-       description = "PID control loop";
-       description = "PID control loop";
-       description = "PID control loop";
-       ];
-       description = "PID control loop";
-       description = "PID control loop";
-       description = "PID control loop";
-       license = lib.licenses.lgpl21Only;
-       hydraPlatforms = lib.platforms.none;
-       description = "PID control loop";
-
-       description = "PID control loop";
-       description = "PID control loop";
-     mkDerivation {
-       description = "PID control loop";
-       description = "PID control loop";
-       description = "PID control loop";
-       libraryHaskellDepends = [ base bytestring containers text ];
-       libraryPkgconfigDepends = [ glib ];
-       description = "PID control loop";
-       license = lib.licenses.lgpl21Only;
-     }) {inherit (pkgs) glib;};
-
        description = "PID control loop";
        description = "PID control loop";
      mkDerivation {
···
        libraryPkgconfigDepends = [ glib ];
        description = "PID control loop";
        license = lib.licenses.lgpl21Only;
-       hydraPlatforms = lib.platforms.none;
      }) {inherit (pkgs) glib;};
 
        description = "PID control loop";
···
        pname = "hasktags";
        version = "0.72.0";
        sha256 = "09p79w16fgpqi6bwq162769xdrnyb7wnmz56k00nz6dj1a0bbbdd";
-       revision = "2";
-       editedCabalFile = "0f3v6k3bvsczz0z5i09286c0i74wz782vayzyp5lndqvrx3b4g0x";
+       revision = "3";
+       editedCabalFile = "0jb7pzfihdwyn9kbby6bb8ddh7v3x85ca9rr8ldsjn34acyal3hs";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "hetzner";
-       version = "0.2.0.0";
-       sha256 = "1narsc9wflf4s7jl784jzyw0hjms82avcpbgwd5aplp0fmh4zqgh";
+       version = "0.2.1.1";
+       sha256 = "1h02iwrxnb1apqkbac210laxdr5cq2gw12pjjs9w9pnk44r8scgs";
        libraryHaskellDepends = [
          aeson base bytestring conduit containers country http-conduit ip
          megaparsec scientific text time yaml
        ];
+       testHaskellDepends = [ base ];
        description = "Hetzner Cloud and DNS library";
        license = lib.licenses.mit;
      }) {};
···
      }:
      mkDerivation {
        pname = "hevm";
-       version = "0.51.0";
-       sha256 = "1c0y0mbdb0p9h1x9fsfd6zwnf2kh3nh24dh8rayhqk77c4wwasvl";
+       version = "0.51.1";
+       sha256 = "1q9yxkp8zvi31gi38snny6n906sdwnfbrxiammrh18gj2h0f1jxq";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "hint";
-       version = "0.9.0.6";
-       sha256 = "1j7jzx8i1rc66xw4c6gf4kjv0a8ma96j25kfz6rzswik4vp5xmky";
+       version = "0.9.0.7";
+       sha256 = "1pq1va24vnizw79c3k0f432srfplx5lbmndqhhw3xzvxc1m48q96";
        libraryHaskellDepends = [
          base containers directory exceptions filepath ghc ghc-boot
          ghc-paths random temporary transformers unix
···
        ];
      }) {};
 
-  "hledger_1_29_2" = callPackage
+  "hledger_1_30_1" = callPackage
     ({ mkDerivation, aeson, ansi-terminal, base, bytestring, cmdargs
      , containers, data-default, Decimal, Diff, directory, extra
      , filepath, githash, hashable, haskeline, hledger-lib, lucid
···
      }:
      mkDerivation {
        pname = "hledger";
-       version = "1.29.2";
-       sha256 = "0q6l7mk0x8f0p0gjb3fgvm73xspp7ls1pac9a45yqaivblqxm0kr";
+       version = "1.30.1";
+       sha256 = "0ri8zg1pq011cbry5cxj2rc5g19vgl3rjcl5b2qk4bhdgxy7na98";
+       revision = "1";
+       editedCabalFile = "1pw204xcv71873rfv0xrnfsbhqnpjb5azr4jqiak6b21w31ky26q";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "hledger-interest";
        version = "1.6.5";
        sha256 = "0znrypimfcr4immy3x5651cfkny1n8yi8isfh72mv2px70994pm1";
-       revision = "1";
-       editedCabalFile = "0shzd7g84s5jrwgvw2nk8b1mhf7dm7id7w18rnfzb41d5pyjq5l8";
+       revision = "2";
+       editedCabalFile = "0qfvbs25dir3xra9pgi5fd41vm0hji666ws8sikb01ik4w5mmj7z";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        license = lib.licenses.gpl3Only;
      }) {};
 
-  "hledger-lib_1_29_2" = callPackage
+  "hledger-lib_1_30" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, array, base
      , base-compat, blaze-markup, bytestring, call-stack, cassava
      , cassava-megaparsec, cmdargs, colour, containers, data-default
···
      , file-embed, filepath, Glob, hashtables, megaparsec, microlens
      , microlens-th, mtl, pager, parser-combinators, pretty-simple
      , regex-tdfa, safe, tabular, tasty, tasty-hunit, template-haskell
-     , text, text-ansi, time, timeit, transformers, uglymemo
-     , unordered-containers, utf8-string
+     , terminal-size, text, text-ansi, time, timeit, transformers
+     , uglymemo, unordered-containers, utf8-string
      }:
      mkDerivation {
        pname = "hledger-lib";
-       version = "1.29.2";
-       sha256 = "0nyc32prc4s0v4fi6m8s0r2dnk15cf5xgdwm7mpy3mmij83pjyym";
+       version = "1.30";
+       sha256 = "0qyhkx1bhrmnwwxqbqa4pqghg7j2vn63829j5s2zdn8ys2mm8s64";
+       revision = "1";
+       editedCabalFile = "09b8liifim9rj6l1s0jwfnnfigjhy3cwaadx017m97igm1mpc7f0";
        libraryHaskellDepends = [
          aeson aeson-pretty ansi-terminal array base base-compat
          blaze-markup bytestring call-stack cassava cassava-megaparsec
          cmdargs colour containers data-default Decimal deepseq directory
          doclayout extra file-embed filepath Glob hashtables megaparsec
          microlens microlens-th mtl pager parser-combinators pretty-simple
-         regex-tdfa safe tabular tasty tasty-hunit template-haskell text
-         text-ansi time timeit transformers uglymemo unordered-containers
-         utf8-string
+         regex-tdfa safe tabular tasty tasty-hunit template-haskell
+         terminal-size text text-ansi time timeit transformers uglymemo
+         unordered-containers utf8-string
        ];
        testHaskellDepends = [
          aeson aeson-pretty ansi-terminal array base base-compat
···
          doclayout doctest extra file-embed filepath Glob hashtables
          megaparsec microlens microlens-th mtl pager parser-combinators
          pretty-simple regex-tdfa safe tabular tasty tasty-hunit
-         template-haskell text text-ansi time timeit transformers uglymemo
-         unordered-containers utf8-string
+         template-haskell terminal-size text text-ansi time timeit
+         transformers uglymemo unordered-containers utf8-string
        ];
        description = "A reusable library providing the core functionality of hledger";
        license = lib.licenses.gpl3Only;
···
        maintainers = [ lib.maintainers.maralorn ];
      }) {};
 
-  "hledger-ui_1_29_2" = callPackage
+  "hledger-ui_1_30" = callPackage
     ({ mkDerivation, ansi-terminal, async, base, brick, cmdargs
      , containers, data-default, directory, doclayout, extra, filepath
      , fsnotify, hledger, hledger-lib, megaparsec, microlens
···
      }:
      mkDerivation {
        pname = "hledger-ui";
-       version = "1.29.2";
-       sha256 = "1q9k44gzgls6yzn9nv9mlg4xzr1mc7dy64p1bkykr8f9z20ljh8r";
+       version = "1.30";
+       sha256 = "1il3849rn8zimn79d7b81v6yb916w5w8lp4ykxkyc3fwwyjcc2q5";
+       revision = "1";
+       editedCabalFile = "05h4adyf7h48fgihpq9swp92j255s4dhgp0q5fg2kdis78i24p7d";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        maintainers = [ lib.maintainers.maralorn ];
      }) {};
 
-  "hledger-web_1_29_2" = callPackage
+  "hledger-web_1_30" = callPackage
     ({ mkDerivation, aeson, base, base64, blaze-html, blaze-markup
      , bytestring, case-insensitive, clientsession, cmdargs, conduit
      , conduit-extra, containers, data-default, Decimal, directory
···
      }:
      mkDerivation {
        pname = "hledger-web";
-       version = "1.29.2";
-       sha256 = "16q5jxd7dpr3rqklgd9v73ilpbz2075nzlhk0hdciw9sarq6jc0y";
+       version = "1.30";
+       sha256 = "0lcw8qigh1507hn287zwmp00vsccsm6lw6r87c5rp0ikxsxmwbds";
+       revision = "1";
+       editedCabalFile = "11id6v6h86zmvqbkx45kdr1q1c5maka6iackk6b2jw9icyv9g6hb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.mit;
      }) {};
 
-  "hoauth2_2_8_0" = callPackage
+  "hoauth2_2_8_1" = callPackage
     ({ mkDerivation, aeson, base, base64, binary, bytestring
      , containers, cryptonite, data-default, exceptions, hspec
      , hspec-discover, http-conduit, http-types, memory, microlens, text
···
      }:
      mkDerivation {
        pname = "hoauth2";
-       version = "2.8.0";
-       sha256 = "1xndl9cl0j1mn18lgjrp7crys9vlz0gznp7fijazawa5x84xjfpp";
+       version = "2.8.1";
+       sha256 = "134fvq9aasp3dmwj50wr8y7i3i292q68pr41dapdqq5mx4b77w8r";
        libraryHaskellDepends = [
          aeson base base64 binary bytestring containers cryptonite
          data-default exceptions http-conduit http-types memory microlens
···
      }:
      mkDerivation {
        pname = "hpqtypes-extras";
-       version = "1.16.4.2";
-       sha256 = "1j7xyj5rw2j5drrrw64pjv75dbf3sbzs14qqi3kxbvmkhg8jgb5a";
+       version = "1.16.4.3";
+       sha256 = "0xb9igkwmkcqjv7a8mvsjcsgglbd4jgwn4cbw4s1frsb7bnibm4w";
        libraryHaskellDepends = [
          base base16-bytestring bytestring containers cryptohash exceptions
          extra hpqtypes log-base mtl text text-show
···
      }:
      mkDerivation {
        pname = "hprox";
-       version = "0.5.2";
-       sha256 = "00ms3kvirrnpy6w5ngykfzrv4777n2pw8ppwb76myjrkylj7ygws";
+       version = "0.5.3";
+       sha256 = "05z4zcskagak04mfj3grp89vjiw8vmx0ppszl1j6p201y5zmpx6n";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
     ({ mkDerivation, base, containers, emojis, text }:
      mkDerivation {
        pname = "hs-openmoji-data";
-       version = "13.0.0";
-       sha256 = "1jgs4iv0zv2dr5izd6d95mflyk4fnagmrdxw70m17jvknl5x1fa5";
+       version = "14.0.0";
+       sha256 = "1slaaahm22mrc91g8j3c3m1ln5hjhin0cr8nspi53ykl7h4rb41h";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base text ];
···
      }:
      mkDerivation {
        pname = "hsblst";
-       version = "0.0.1";
-       sha256 = "1ab8ncgpwvsj6x1ggp0rck6n7fs37wsf8i83z29xbd20dzyralm0";
+       version = "0.0.2";
+       sha256 = "08sj5r714rzkdbvx8bzhk3lvim7jiaxbpj4xpz58bxx13ds2dxni";
        libraryHaskellDepends = [ base deepseq memory ];
        libraryToolDepends = [ c2hs ];
        testHaskellDepends = [
···
        pname = "hsini";
        version = "0.5.1.2";
        sha256 = "1r6qksnrmk18ndxs5zaga8b7kvmk34kp0kh5hwqmq797qrlax9pa";
-       revision = "2";
-       editedCabalFile = "1b83g6jk9hcm2h17f1h9vyzm34bmr7w4j5888rbv9k8gpi97f8i7";
+       revision = "3";
+       editedCabalFile = "0wkx1syrx45ivs9lqhh7wfzwr1a0a3fq3km83amvl2a877yaqrjm";
        libraryHaskellDepends = [ base bytestring containers mtl parsec ];
        testHaskellDepends = [
          base bytestring containers mtl parsec tasty tasty-hunit
···
      }:
      mkDerivation {
        pname = "hspec-webdriver";
-       version = "1.2.1";
-       sha256 = "1cch0jzl2dmd7c45z9j1kl6bv0qzydwcvdfkfkvv8s0x9p11k4g4";
+       version = "1.2.2";
+       sha256 = "10dxdiv77yb5xb6aqqjdp54lbkc2sj7b2jb4ckjk1mvjz9gdc1wa";
        libraryHaskellDepends = [
          aeson base data-default hashable hspec hspec-core HUnit lifted-base
          stm text transformers unordered-containers webdriver
···
        pname = "http-api-data-qq";
        version = "0.1.0.0";
        sha256 = "1lvfdbprdwq09k1wkjfvvkpi79053dc4kzkv4g1cx94qb1flbd7a";
-       revision = "2";
-       editedCabalFile = "03gwjxnd0kcnh18bzlwkb8yivmcjrl8wb0v82y4jqvjy19d61d0n";
+       revision = "3";
+       editedCabalFile = "1ywq3kl32rp57rb2p3y79jrbi99p32j30w9nrm94jgf4m2jdahc5";
        libraryHaskellDepends = [
          base http-api-data template-haskell text
        ];
···
        license = lib.licenses.mit;
      }) {};
 
+  "http-client-tls_0_3_6_2" = callPackage
+    ({ mkDerivation, base, bytestring, case-insensitive, containers
+     , crypton, crypton-connection, data-default-class, exceptions
+     , gauge, hspec, http-client, http-types, memory, network
+     , network-uri, text, tls, transformers
+     }:
+     mkDerivation {
+       pname = "http-client-tls";
+       version = "0.3.6.2";
+       sha256 = "19mbjh1rh46zmra4s7ybqvmwffmp3z5x7xlw9hsv55rbxsz8whr8";
+       libraryHaskellDepends = [
+         base bytestring case-insensitive containers crypton
+         crypton-connection data-default-class exceptions http-client
+         http-types memory network network-uri text tls transformers
+       ];
+       testHaskellDepends = [ base hspec http-client http-types ];
+       benchmarkHaskellDepends = [ base gauge http-client ];
+       doCheck = false;
+       description = "http-client backend using the connection package and tls library";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "http-client-websockets" = callPackage
     ({ mkDerivation, async, base, bytestring, hspec, http-client
      , network-uri, text, websockets
···
 
   "http-conduit" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, blaze-builder, bytestring
-     , case-insensitive, conduit, conduit-extra, connection, cookie
+     , case-insensitive, conduit, conduit-extra, cookie
      , data-default-class, hspec, http-client, http-client-tls
      , http-types, HUnit, mtl, network, resourcet, streaming-commons
      , temporary, text, time, tls, transformers, unliftio, unliftio-core
···
      }:
      mkDerivation {
        pname = "http-conduit";
-       version = "2.3.8";
-       sha256 = "1bj24phbcb7s3k6v48l5gk82m3m23j8zy9l7c5ccxp3ghn9z5gng";
+       version = "2.3.8.1";
+       sha256 = "11zf4hyw8f1gpj0w1cmgc9g62xwy2v4hhzqazdsla4q49iqbzxgd";
+       libraryHaskellDepends = [
+         aeson attoparsec base bytestring conduit conduit-extra http-client
+         http-client-tls http-types mtl resourcet transformers unliftio-core
+       ];
+       testHaskellDepends = [
+         aeson base blaze-builder bytestring case-insensitive conduit
+         conduit-extra cookie data-default-class hspec http-client
+         http-types HUnit network resourcet streaming-commons temporary text
+         time tls transformers unliftio utf8-string wai wai-conduit warp
+         warp-tls
+       ];
+       doCheck = false;
+       description = "HTTP client package with conduit interface and HTTPS support";
+       license = lib.licenses.bsd3;
+     }) {};
+
+  "http-conduit_2_3_8_2" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, blaze-builder, bytestring
+     , case-insensitive, conduit, conduit-extra, cookie
+     , crypton-connection, data-default-class, hspec, http-client
+     , http-client-tls, http-types, HUnit, mtl, network, resourcet
+     , streaming-commons, temporary, text, time, tls, transformers
+     , unliftio, unliftio-core, utf8-string, wai, wai-conduit, warp
+     , warp-tls
+     }:
+     mkDerivation {
+       pname = "http-conduit";
+       version = "2.3.8.2";
+       sha256 = "019sl85c4skksc3hl1mq9j4sw47pffgv53dl0nln3vaci09pfigd";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring conduit conduit-extra http-client
          http-client-tls http-types mtl resourcet transformers unliftio-core
        ];
        testHaskellDepends = [
          aeson base blaze-builder bytestring case-insensitive conduit
-         conduit-extra connection cookie data-default-class hspec
+         conduit-extra cookie crypton-connection data-default-class hspec
          http-client http-types HUnit network resourcet streaming-commons
          temporary text time tls transformers unliftio utf8-string wai
          wai-conduit warp warp-tls
···
        doCheck = false;
        description = "HTTP client package with conduit interface and HTTPS support";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "http-conduit-browser" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "http2_4_1_2" = callPackage
+  "http2_4_1_4" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, array, async, base
      , base16-bytestring, bytestring, case-insensitive, containers
-     , cryptonite, directory, filepath, gauge, Glob, hspec
-     , hspec-discover, http-types, network, network-byte-order
-     , network-run, psqueues, stm, text, time-manager, typed-process
-     , unix-time, unliftio, unordered-containers, vector
+     , crypton, directory, filepath, gauge, Glob, hspec, hspec-discover
+     , http-types, network, network-byte-order, network-run, psqueues
+     , stm, text, time-manager, typed-process, unix-time, unliftio
+     , unordered-containers, vector
      }:
      mkDerivation {
        pname = "http2";
-       version = "4.1.2";
-       sha256 = "0q4wn0qqswbrw92ypkwzis3nb0jlp8hv9ly5s79mz5n069h2kz0m";
+       version = "4.1.4";
+       sha256 = "1mi0nahsbv0amcb9r21d8p4j1nk8y75vli8a9axjg2y3yi3i95bx";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          unliftio
        ];
        testHaskellDepends = [
-         aeson aeson-pretty async base base16-bytestring bytestring
-         cryptonite directory filepath Glob hspec http-types network
-         network-byte-order network-run text typed-process
-         unordered-containers vector
+         aeson aeson-pretty async base base16-bytestring bytestring crypton
+         directory filepath Glob hspec http-types network network-byte-order
+         network-run text typed-process unordered-containers vector
        ];
        testToolDepends = [ hspec-discover ];
        benchmarkHaskellDepends = [
···
   "http3" = callPackage
     ({ mkDerivation, array, attoparsec, base, base16-bytestring
      , bytestring, case-insensitive, conduit, conduit-extra, containers
-     , cryptonite, hspec, hspec-discover, http-types, http2, iproute
+     , crypton, hspec, hspec-discover, http-types, http2, iproute
      , network, network-byte-order, quic, QuickCheck, sockaddr, stm
      , time-manager, tls, unliftio
      }:
      mkDerivation {
        pname = "http3";
-       version = "0.0.3";
-       sha256 = "0fn0qbhqly9saqidkp20wnz4f8afp9zjamly1pm0ryqg2kjlhvvy";
+       version = "0.0.4";
+       sha256 = "02w2f17m6n46rr0212c7fp33vrgb13zj41mncm9wyvwkmmm47gmv";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        testHaskellDepends = [
          attoparsec base base16-bytestring bytestring conduit conduit-extra
-         cryptonite hspec http-types http2 iproute network quic QuickCheck
-         stm tls unliftio
+         crypton hspec http-types http2 iproute network quic QuickCheck stm
+         tls unliftio
        ];
        testToolDepends = [ hspec-discover ];
        description = "HTTP/3 library";
···
      }) {};
 
   "httpstan" = callPackage
-    ({ mkDerivation, aeson, base, base64-bytestring, bytestring
-     , case-insensitive, containers, deepseq, exceptions, hspec
-     , http-api-data, http-client, http-client-tls, http-media
-     , http-types, iso8601-time, katip, microlens, mtl, network
-     , QuickCheck, random, safe-exceptions, semigroups, text, time
-     , transformers, unordered-containers, vector
+    ({ mkDerivation, aeson, base, containers, exceptions, http-api-data
+     , http-client, http-client-tls, http-types, mtl, network-uri
+     , servant, servant-client, servant-client-core, servant-server
+     , swagger2, text, time, transformers, uuid, wai, warp
      }:
      mkDerivation {
        pname = "httpstan";
-       version = "0.2.0.0";
-       sha256 = "08wpigjaqjdbml7bp4rpikldzv7qkkzbxlmngp9p99zxr75d86vf";
+       version = "0.3.0.0";
+       sha256 = "11wba17y4d59cymsrll3zpv6axiadfnpjfpg8rrkyms2wsc44qad";
        libraryHaskellDepends = [
-         aeson base base64-bytestring bytestring case-insensitive containers
-         deepseq exceptions http-api-data http-client http-client-tls
-         http-media http-types iso8601-time katip microlens mtl network
-         random safe-exceptions text time transformers unordered-containers
-         vector
-       ];
-       testHaskellDepends = [
-         aeson base bytestring containers hspec iso8601-time mtl QuickCheck
-         semigroups text time transformers unordered-containers vector
+         aeson base containers exceptions http-api-data http-client
+         http-client-tls http-types mtl network-uri servant servant-client
+         servant-client-core servant-server swagger2 text time transformers
+         uuid wai warp
        ];
-       description = "Auto-generated httpstan API Client";
+       description = "Auto-generated API bindings for httpstan";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        broken = true;
···
        ];
        description = "International Geomagnetic Reference Field";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ihaskell" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "input-parsers_0_3" = callPackage
+  "input-parsers_0_3_0_1" = callPackage
     ({ mkDerivation, attoparsec, base, binary, bytestring
      , monoid-subclasses, parsec, parsers, text, transformers
      }:
      mkDerivation {
        pname = "input-parsers";
-       version = "0.3";
-       sha256 = "00xiaxf135v3g8l8gn0lzhfkc1lffvjblrij6lwyfigicm2ggff0";
+       version = "0.3.0.1";
+       sha256 = "1f7q6m0wi6pa9j7mw8gsbc16drgcw8sh6ghq9hdgcrkqzbhp990g";
        libraryHaskellDepends = [
          attoparsec base binary bytestring monoid-subclasses parsec parsers
          text transformers
···
        license = lib.licenses.isc;
      }) {};
 
+  "integer-conversion" = callPackage
+    ({ mkDerivation, base, bytestring, primitive, QuickCheck
+     , quickcheck-instances, tasty, tasty-bench, tasty-quickcheck, text
+     }:
+     mkDerivation {
+       pname = "integer-conversion";
+       version = "0.1";
+       sha256 = "07fry6pwxlq4jrlnl9klp0xfxc9zhgsv34jkzbcywcgdm9dk1jgh";
+       libraryHaskellDepends = [ base bytestring primitive text ];
+       testHaskellDepends = [
+         base bytestring QuickCheck quickcheck-instances tasty
+         tasty-quickcheck text
+       ];
+       benchmarkHaskellDepends = [ base bytestring tasty-bench text ];
+       description = "Conversion from strings to Integer";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "integer-gmp_1_1" = callPackage
     ({ mkDerivation, base, ghc-bignum, ghc-prim }:
      mkDerivation {
···
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
      }) {intel_aes = null;};
+
+  "intel-powermon" = callPackage
+    ({ mkDerivation, base, posix-timer, streaming, unix }:
+     mkDerivation {
+       pname = "intel-powermon";
+       version = "0";
+       sha256 = "036g1lm3n5zm67yr151xvwq8134a0n6wbfzp3avqkjpn478khiyq";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [ base posix-timer streaming unix ];
+       description = "Poll modern Intel/AMD CPU power consumption on Linux via RAPL";
+       license = lib.licenses.agpl3Only;
+       mainProgram = "intel-powermon";
+     }) {};
 
   "intensional-datatys" = callPackage
     ({ mkDerivation, aeson, base, containers, directory, extra
···
      }) {};
 
   "interval-patterns" = callPackage
-    ({ mkDerivation, base, containers, groups, hspec, lattices
+    ({ mkDerivation, base, containers, groups, heaps, hspec, lattices
      , QuickCheck, semirings, time, time-compat
      }:
      mkDerivation {
        pname = "interval-patterns";
-       version = "0.6.0.1";
-       sha256 = "0i4wwch90842dkbrjh5ikclwxgzs9wx9s2v2hgcv9zzqi4z8pn4x";
+       version = "0.7.0.2";
+       sha256 = "0sa2v7z3ryx45by6zcgfi56n53f3akf4xifj9sp69rhc4mlqj735";
        libraryHaskellDepends = [
-         base containers groups lattices semirings time time-compat
+         base containers groups heaps lattices semirings time time-compat
        ];
        testHaskellDepends = [
-         base containers groups hspec lattices QuickCheck semirings time
-         time-compat
+         base containers groups heaps hspec lattices QuickCheck semirings
+         time time-compat
        ];
        description = "Intervals, and monoids thereof";
        license = lib.licenses.bsd3;
···
        pname = "invertible-grammar";
        version = "0.1.3.4";
        sha256 = "19x9bzc1cvz5zc03iglf42vyngnjkspzfd2jpl9y6pwp2sf66325";
+       revision = "1";
+       editedCabalFile = "059i4v6kmsrry2lw7m2ricg2ls14v4b2k554l7cmpa46g28yakyn";
        libraryHaskellDepends = [
          base bifunctors containers mtl prettyprinter profunctors semigroups
          tagged template-haskell text transformers
···
      }:
      mkDerivation {
        pname = "journalctl-stream";
-       version = "0.6.0.2";
-       sha256 = "1yw2n93iqz35r33qbyg7z5xxricsqlyql8hmj5adm5q86fil97kk";
+       version = "0.6.0.4";
+       sha256 = "0ckaxaja4152mvlhypd36x2cqw4wiiid11ph6ih9w4c0g9244njf";
        libraryHaskellDepends = [
          aeson base bytestring conduit process text time
          unordered-containers
···
        description = "Basic rendering programs for Keid engine";
        license = lib.licenses.bsd3;
        platforms = [ "x86_64-linux" ];
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "keid-resource-gltf" = callPackage
···
      }:
      mkDerivation {
        pname = "keter";
-       version = "2.1.0";
-       sha256 = "1yfql7cb8xmny52gid5zbav96b7j0cys3fgcxy5qg8scgs5ri43v";
+       version = "2.1.1";
+       sha256 = "1wsg1jd8gllbkxw6czh02c03s6lbfmw05giq2d4jp6vckpq3yqla";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "language-lua";
        version = "0.11.0.1";
        sha256 = "0712xbijag03n61d80bnd9xw94fzywc76l8ya9ijv684ls0qymy2";
+       revision = "1";
+       editedCabalFile = "185q2xk8q17q29hcph3s94gy7jpzm46s4qls589jsicvas7gnl4d";
        libraryHaskellDepends = [
          alex-tools array base bytestring deepseq text
        ];
···
      }:
      mkDerivation {
        pname = "language-toolkit";
-       version = "1.0.1.0";
-       sha256 = "0wkx4sbzirfi07hsmafzliwri40amq3m1ry6lmwd2sjpbgrbd81g";
+       version = "1.1.0.0";
+       sha256 = "0ffr53jggh3c01v802xywy387jv5wa5vwwyvipiqpxwqcspr4nd7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers deepseq parallel ];
···
 
   "lapack" = callPackage
     ({ mkDerivation, base, blas-ffi, blaze-html, boxes, ChasingBottoms
-     , comfort-array, comfort-array-shape, data-ref, deepseq
-     , doctest-exitcode-stdio, guarded-allocation, hyper, lapack-ffi
-     , lazyio, monoid-transformer, netlib-ffi, non-empty, QuickCheck
-     , quickcheck-transformer, random, semigroups, Stream, tagged, text
-     , tfp, transformers, unique-logic-tf, utility-ht
+     , comfort-array, comfort-array-shape, comfort-blas, data-ref
+     , deepseq, doctest-exitcode-stdio, guarded-allocation, hyper
+     , lapack-ffi, lazyio, monoid-transformer, netlib-ffi, non-empty
+     , QuickCheck, quickcheck-transformer, random, semigroups, Stream
+     , tagged, text, tfp, transformers, unique-logic-tf, utility-ht
      }:
      mkDerivation {
        pname = "lapack";
-       version = "0.5.0.3";
-       sha256 = "0461rzz8qp5vqna7rha3qa89pm7clkmx1vqmkmqb9i50znfr0sc0";
+       version = "0.5.1";
+       sha256 = "0lknvjhdn1gqxp6cc8iyiwqdvd2nxby3csfvprkbn5b7x6c6f58k";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          base blas-ffi blaze-html boxes comfort-array comfort-array-shape
-         deepseq guarded-allocation hyper lapack-ffi lazyio netlib-ffi
-         non-empty semigroups Stream tagged text tfp transformers utility-ht
+         comfort-blas deepseq guarded-allocation hyper lapack-ffi lazyio
+         netlib-ffi non-empty semigroups Stream tagged text tfp transformers
+         utility-ht
        ];
        testHaskellDepends = [
          base ChasingBottoms comfort-array comfort-array-shape data-ref
···
      }:
      mkDerivation {
        pname = "large-anon";
-       version = "0.2";
-       sha256 = "0ym7awxla6lq4gxx6j110cgc3mmfh286nhm7cis7vail8fzbqqf3";
+       version = "0.2.1";
+       sha256 = "192cs2pby5pxl1668b4s4sm0ppc3qnk189x2i3fv9y3fb8fqjq66";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "leanpub-concepts";
        version = "1.1.0.2";
        sha256 = "0xlnpn48zsm5pgjghj6cnfvfzaq6mkrph23b0l8zf66wvw8gbvc0";
+       revision = "1";
+       editedCabalFile = "0lxs2x6nadb1cyyxjr9b32c9dmmjgmfy2j99dg9qfdhp7a9ih5y2";
        libraryHaskellDepends = [ base bytestring text ];
        description = "Types for the Leanpub API";
        license = lib.licenses.mit;
···
        pname = "leanpub-wreq";
        version = "1.1.0.4";
        sha256 = "0p9wyj3dsm8mif9wfg9m9gwdnisg19gvjxmrkkrk0ymrjpvgq5ha";
+       revision = "1";
+       editedCabalFile = "14qqaxwb0jmswnrs38mnbzfs98hbzqshsnnw0xzvnp80rdw5mr10";
        libraryHaskellDepends = [
          aeson base bytestring exceptions leanpub-concepts mwc-random text
          time transformers unordered-containers wreq
···
        pname = "lentil";
        version = "1.5.5.4";
        sha256 = "04srkha0nv4k7gxma3q09p9zph6z6v0blpvqivn46g071zdf76cj";
+       revision = "1";
+       editedCabalFile = "1hnx82b18hys661im4gdv19nr5ngdhip23lrb2m61qqng473g83r";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        pname = "libyaml-streamly";
        version = "0.2.1";
        sha256 = "0jh980ilaxhdhyp3vbmg0s3c2vf5ckxlkyj6n45vqb56847mg5bk";
+       revision = "1";
+       editedCabalFile = "0lf4zz6li7g4nz6gspvs0f14fkg9bkgdzz6bclhsnv36ksbr1h8w";
        libraryHaskellDepends = [
          base bytestring deepseq safe-exceptions streamly
        ];
···
      }:
      mkDerivation {
        pname = "lima";
-       version = "0.2.1.2";
-       sha256 = "1x937qrxzzi0g6fdk36mbxlrb0zf5m38s6in6g1p15nzr88p50dx";
+       version = "0.2.1.3";
+       sha256 = "0834lh5yaynfyy2k6lqbb43dsrgsrmpi11w73js8p08zhzkhndnr";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "list-transformer";
        version = "1.0.9";
        sha256 = "1lvdyrxflssayq14x36a0ix7q3hfzlq924mjg21b7f6s3j9262xr";
-       revision = "1";
-       editedCabalFile = "1d41pbd7kg8im5bvzhkndr6lr106rpd7m1pqb39zgnj5cbmgaql3";
+       revision = "2";
+       editedCabalFile = "0356ca6kb6r8j2lc9vbzxz0chdzplc3v6m4sbsm4p7vanjjl1zgf";
        libraryHaskellDepends = [ base mmorph mtl ];
        testHaskellDepends = [ base doctest ];
        description = "List monad transformer";
···
        pname = "logic-TPTP";
        version = "0.5.0.0";
        sha256 = "0sqzf332c7zdwkdi1346dxljrdammiz1vc332j85487nb0ypnxwi";
-       revision = "1";
-       editedCabalFile = "108fql6laqwvxvnk7h4jjl9652bhz7ja2z2296svjhhjz5pvar8g";
+       revision = "4";
+       editedCabalFile = "012aqairsbxqrl0ak5i11wqr1rcdpwi5m4f5nww8glxi3jglnnyb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        mainProgram = "longshot";
      }) {};
 
+  "looksee" = callPackage
+    ({ mkDerivation, base, bifunctors, containers, errata, mmorph, mtl
+     , recursion-schemes, scientific, tasty, tasty-hunit, text, vector
+     }:
+     mkDerivation {
+       pname = "looksee";
+       version = "0.5.0";
+       sha256 = "0da272255k0lj7y5vmi8y3zx015rhwsac7isvmywzhmgf7b6g3nv";
+       libraryHaskellDepends = [
+         base bifunctors containers errata mmorph mtl recursion-schemes
+         scientific text vector
+       ];
+       testHaskellDepends = [
+         base bifunctors containers errata mmorph mtl recursion-schemes
+         scientific tasty tasty-hunit text vector
+       ];
+       description = "parser with looksee";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "lookup-tables" = callPackage
     ({ mkDerivation, base, primitive, tasty, tasty-hunit
      , template-haskell
···
        testToolDepends = [ sydtest-discover ];
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "loops" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
+  "lsp_2_0_0_0" = callPackage
+    ({ mkDerivation, aeson, async, attoparsec, base, bytestring
+     , co-log-core, containers, data-default, directory, exceptions
+     , filepath, hashable, hspec, hspec-discover, lens, lsp-types, mtl
+     , prettyprinter, random, row-types, sorted-list, stm, temporary
+     , text, text-rope, transformers, unliftio-core
+     , unordered-containers, uuid
+     }:
+     mkDerivation {
+       pname = "lsp";
+       version = "2.0.0.0";
+       sha256 = "1rhibq4s0d9vxsfnwa35nm5xll693k0hbfp6b2c9478s8wg32wxg";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson async attoparsec base bytestring co-log-core containers
+         data-default directory exceptions filepath hashable lens lsp-types
+         mtl prettyprinter random row-types sorted-list stm temporary text
+         text-rope transformers unliftio-core unordered-containers uuid
+       ];
+       testHaskellDepends = [
+         base containers hspec row-types sorted-list text text-rope
+         unordered-containers
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Haskell library for the Microsoft Language Server Protocol";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "lsp-test" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, async, base
      , bytestring, co-log-core, conduit, conduit-parse, containers
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "lsp-test_0_15_0_0" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, async, base
+     , bytestring, co-log-core, conduit, conduit-parse, containers
+     , data-default, Diff, directory, exceptions, extra, filepath, Glob
+     , hspec, lens, lsp, lsp-types, mtl, parser-combinators, process
+     , row-types, some, text, time, transformers, unix, unliftio
+     }:
+     mkDerivation {
+       pname = "lsp-test";
+       version = "0.15.0.0";
+       sha256 = "0fg1nc1xkv5cl26vbny97r1w755qim9hcmzfxdx38wklrishrvcx";
+       libraryHaskellDepends = [
+         aeson aeson-pretty ansi-terminal async base bytestring co-log-core
+         conduit conduit-parse containers data-default Diff directory
+         exceptions filepath Glob lens lsp lsp-types mtl parser-combinators
+         process row-types some text time transformers unix
+       ];
+       testHaskellDepends = [
+         aeson base co-log-core containers data-default directory filepath
+         hspec lens lsp mtl parser-combinators process text unliftio
+       ];
+       testToolDepends = [ lsp ];
+       benchmarkHaskellDepends = [ base extra lsp process ];
+       description = "Functional test framework for LSP servers";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "lsp-types_1_4_0_1" = callPackage
     ({ mkDerivation, aeson, base, binary, bytestring, containers
      , data-default, deepseq, Diff, directory, dlist, filepath, hashable
···
        license = lib.licenses.mit;
      }) {};
 
+  "lsp-types_2_0_0_1" = callPackage
+    ({ mkDerivation, aeson, base, binary, containers, data-default
+     , deepseq, Diff, directory, dlist, exceptions, file-embed, filepath
+     , hashable, hspec, hspec-discover, lens, mod, mtl, network-uri
+     , prettyprinter, QuickCheck, quickcheck-instances, regex, row-types
+     , safe, some, template-haskell, text, unordered-containers
+     }:
+     mkDerivation {
+       pname = "lsp-types";
+       version = "2.0.0.1";
+       sha256 = "119w6crys6jh680gm2pdpvxxqxs0fwqfdmzlr274qlj00sa51wc7";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base binary containers data-default deepseq Diff dlist
+         exceptions file-embed filepath hashable lens mod mtl network-uri
+         row-types safe some template-haskell text unordered-containers
+       ];
+       executableHaskellDepends = [
+         base containers directory filepath mtl prettyprinter regex text
+       ];
+       testHaskellDepends = [
+         aeson base filepath hspec lens network-uri QuickCheck
+         quickcheck-instances row-types text
+       ];
+       testToolDepends = [ hspec-discover ];
+       doHaddock = false;
+       description = "Haskell library for the Microsoft Language Server Protocol, data types";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "generator";
+     }) {};
+
   "lss" = callPackage
     ({ mkDerivation, attoparsec, base, containers, directory, filepath
      , hspec2, language-css, language-css-attoparsec, text, xmlhtml
···
      }:
      mkDerivation {
        pname = "med-module";
-       version = "0.1.2.2";
-       sha256 = "0qvwz49xz4bbhkkh9c7zjqzvbdhmgnraxpj8a4fc5lf0yb1k79ba";
+       version = "0.1.3";
+       sha256 = "04p1aj85hsr3wpnnfg4nxbqsgq41ga63mrg2w39d8ls8ljvajvna";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.bsd2;
      }) {};
 
-  "megaparsec_9_3_1" = callPackage
+  "megaparsec_9_4_1" = callPackage
     ({ mkDerivation, base, bytestring, case-insensitive, containers
      , criterion, deepseq, mtl, parser-combinators, scientific, text
      , transformers, weigh
      }:
      mkDerivation {
        pname = "megaparsec";
-       version = "9.3.1";
-       sha256 = "00dp79sssb2j9w0sbzphkqjn49xzrafd16gkqda5ngqhbjdniw73";
+       version = "9.4.1";
+       sha256 = "0a8s4i2vi1q9l75nf65jdjfkf25dhra4ij9y35a5fi5vk9848sf1";
        libraryHaskellDepends = [
          base bytestring case-insensitive containers deepseq mtl
          parser-combinators scientific text transformers
···
        license = lib.licenses.bsd2;
      }) {};
 
-  "megaparsec-tests_9_3_1" = callPackage
+  "megaparsec-tests_9_4_1" = callPackage
     ({ mkDerivation, base, bytestring, case-insensitive, containers
      , hspec, hspec-discover, hspec-expectations, hspec-megaparsec
      , megaparsec, mtl, parser-combinators, QuickCheck, scientific
···
      }:
      mkDerivation {
        pname = "megaparsec-tests";
-       version = "9.3.1";
-       sha256 = "01gd6xlqfazpbawzwgbk0ag86dq8nv5qdrhny9b7hrks3i3b558m";
+       version = "9.4.1";
+       sha256 = "08lvya4c1vbwyi1130rhm3xd8aq4x1m3wnyphwzal2p556hzlr2g";
        libraryHaskellDepends = [
          base bytestring containers hspec hspec-expectations
          hspec-megaparsec megaparsec mtl QuickCheck text transformers
···
      }) {};
 
   "merkle-log" = callPackage
-    ({ mkDerivation, base, bytestring, criterion, cryptonite, deepseq
-     , exceptions, hash-tree, memory, mwc-random, QuickCheck, random
-     , random-bytestring, text
+    ({ mkDerivation, base, bytestring, criterion, crypton, cryptonite
+     , deepseq, exceptions, hash-tree, memory, mwc-random, QuickCheck
+     , random, random-bytestring, text
      }:
      mkDerivation {
        pname = "merkle-log";
-       version = "0.1.1";
-       sha256 = "17a6s9xbv460289avbwdnf8c4vhw9qzj5xddxvfmnjjwp58qxvj1";
+       version = "0.2.0";
+       sha256 = "0v4rga0g2xfk10g0gd8f0if03skl7gqx4n44msdbcnyx3pn6ydl0";
        libraryHaskellDepends = [
-         base bytestring cryptonite deepseq exceptions memory text
+         base bytestring crypton deepseq exceptions memory text
        ];
        testHaskellDepends = [
-         base bytestring cryptonite deepseq exceptions memory QuickCheck
+         base bytestring crypton deepseq exceptions memory QuickCheck
        ];
        benchmarkHaskellDepends = [
-         base bytestring criterion cryptonite deepseq hash-tree memory
-         mwc-random QuickCheck random random-bytestring
+         base bytestring criterion crypton cryptonite deepseq hash-tree
+         memory mwc-random QuickCheck random random-bytestring
        ];
        description = "Merkle Tree Logs";
        license = lib.licenses.bsd3;
···
      , filepath, hspec, http-client, http-date, http-types, network
      , old-locale, parsec, resourcet, split, streaming-commons, text
      , time, time-manager, transformers, unix, unix-time, unliftio
-     , unordered-containers, wai, wai-app-file-cgi, wai-http2-extra
-     , wai-logger, warp
+     , unordered-containers, wai, wai-app-file-cgi, wai-logger, warp
      }:
      mkDerivation {
        pname = "mighttpd2";
-       version = "4.0.2";
-       sha256 = "0q09adyhaa9mxajj5fg3fsdpckdh3icp2bvm1f64l1m3jqxw8k8x";
+       version = "4.0.3";
+       sha256 = "1qgr5giks32xmcnkq973cs20lzgjvjr6bgymffsb3c8sj873jhqs";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        executableHaskellDepends = [
          base bytestring conduit-extra directory filepath http-client
          http-date http-types network old-locale streaming-commons time
-         time-manager transformers unix wai wai-app-file-cgi wai-http2-extra
-         wai-logger warp
+         time-manager transformers unix wai wai-app-file-cgi wai-logger warp
        ];
        testHaskellDepends = [ base hspec http-client ];
        description = "High performance web server on WAI/warp";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "mighty-metropolis" = callPackage
···
     ({ mkDerivation, base, doctest }:
      mkDerivation {
        pname = "modular-arithmetic";
-       version = "2.0.0.2";
-       sha256 = "1bbn3pwvpl9v7a8gkxx83w2s8mk2q9gin7yvkkr97f64rdf8lnrq";
-       revision = "1";
-       editedCabalFile = "035z6pjgbgcb39dh6zd822d1yxvjs5j684cx7mn14wq0q1l0q295";
+       version = "2.0.0.3";
+       sha256 = "0s73xcql2kmmvyxh9jsg2wjjs9d1f8cnbgzq659g28qsa47qdic7";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base doctest ];
        description = "A type for integers modulo some constant";
···
      }:
      mkDerivation {
        pname = "monad-logger";
-       version = "0.3.39";
-       sha256 = "19992zh63axs0q86fgznk04dan8h3hbs72cjp1s3yynsgl23pwnk";
-       revision = "1";
-       editedCabalFile = "0nj4qpmp6i5lmfbk7f1shljx8g2062fq6y857y4f9avp1cb9zm7d";
+       version = "0.3.40";
+       sha256 = "1aff4ks9615x51841l8g906702xk2g3pn4n5x9ndxppnrxkqdvfb";
        libraryHaskellDepends = [
          base bytestring conduit conduit-extra exceptions fast-logger
          lifted-base monad-control monad-loops mtl resourcet stm stm-chans
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "monad-time-effectful" = callPackage
+    ({ mkDerivation, base, effectful-core, monad-time, time }:
+     mkDerivation {
+       pname = "monad-time-effectful";
+       version = "1.0.0.0";
+       sha256 = "1gxmgr8vrpdncrnw9q5i3vqbi7llrah34gpfyq3qcb15sqi44gk9";
+       libraryHaskellDepends = [ base effectful-core monad-time time ];
+       description = "Adaptation of the monad-time library for the effectful ecosystem";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "monad-timing" = callPackage
     ({ mkDerivation, base, containers, exceptions, hlint, hspec
      , monad-control, mtl, time, transformers, transformers-base
···
        license = lib.licenses.mit;
      }) {};
 
+  "monoidmap" = callPackage
+    ({ mkDerivation, base, containers, deepseq, groups, hspec
+     , hspec-discover, monoid-subclasses, nonempty-containers, nothunks
+     , pretty-show, QuickCheck, quickcheck-classes, quickcheck-groups
+     , quickcheck-instances, quickcheck-monoid-subclasses, tasty-bench
+     , tasty-hunit, text
+     }:
+     mkDerivation {
+       pname = "monoidmap";
+       version = "0.0.0.1";
+       sha256 = "0qq1q8xk0bf32lx4hnsh45kkj2fkjfskc2krggmcrbnapnxmcb56";
+       libraryHaskellDepends = [
+         base containers deepseq groups monoid-subclasses
+         nonempty-containers nothunks
+       ];
+       testHaskellDepends = [
+         base containers groups hspec monoid-subclasses pretty-show
+         QuickCheck quickcheck-classes quickcheck-groups
+         quickcheck-instances quickcheck-monoid-subclasses text
+       ];
+       testToolDepends = [ hspec-discover ];
+       benchmarkHaskellDepends = [
+         base containers deepseq tasty-bench tasty-hunit
+       ];
+       doHaddock = false;
+       description = "Monoidal map type";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "monoidplus" = callPackage
     ({ mkDerivation, base, contravariant, semigroups, transformers }:
      mkDerivation {
···
 
   "monomer-flatpak-example" = callPackage
     ({ mkDerivation, base, containers, data-default-class, dbus
-     , desktop-portal, directory, monomer, monomer-hagrid, random, text
+     , desktop-portal, directory, modern-uri, monomer, monomer-hagrid
+     , random, text
      }:
      mkDerivation {
        pname = "monomer-flatpak-example";
-       version = "0.0.8.0";
-       sha256 = "0xasnb61x6ixl57hsbsx134msbwlfma3b6szq1ndp5aj149r0fl7";
+       version = "0.0.9.0";
+       sha256 = "1cvvqhc86q0589yh6g1p1pgvcp5dzvjnqbbln8pkq4fqcl4n7cwd";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
        executableHaskellDepends = [
          base containers data-default-class dbus desktop-portal directory
-         monomer monomer-hagrid random text
+         modern-uri monomer monomer-hagrid random text
        ];
        description = "Monomer Flatpak Example Application";
        license = lib.licenses.mit;
···
        license = lib.licenses.bsd2;
        hydraPlatforms = lib.platforms.none;
        broken = true;
+     }) {};
+
+  "ms-graph-api" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, hoauth2
+     , http-client, http-types, jwt, modern-uri, req, scientific, scotty
+     , text, time, transformers, unliftio, uri-bytestring
+     , validation-micro, wai, warp
+     }:
+     mkDerivation {
+       pname = "ms-graph-api";
+       version = "0.6.0.0";
+       sha256 = "1wnl8kww7byzhyvswxf743cwnwmbg71vkck9rk5q82kdv7dxq8jc";
+       libraryHaskellDepends = [
+         aeson base bytestring containers hoauth2 http-client http-types jwt
+         modern-uri req scientific scotty text time transformers unliftio
+         uri-bytestring validation-micro wai warp
+       ];
+       description = "Microsoft Graph API";
+       license = lib.licenses.bsd3;
      }) {};
 
   "ms-tds" = callPackage
···
        pname = "nat-optics";
        version = "1.0.1.0";
        sha256 = "146q35ni26fq02f7pdzjp2h0kwp9593r2dzg4bxl1zvlrb850c1a";
+       revision = "1";
+       editedCabalFile = "0h2ljxc5kmhgnfphqwsvqb1pcyka12966js51bm78jf5ly7jlhqc";
        libraryHaskellDepends = [ base optics-core text ];
        testHaskellDepends = [ base hspec optics-core text ];
        description = "Refinement types for natural numbers with an optics interface";
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "natural-arithmetic";
-       version = "0.1.3.0";
-       sha256 = "13ihizfvkl5bjy5rn966y22lgs8f1dgwyqky3k9gjsqxczlg44xa";
+       version = "0.1.4.0";
+       sha256 = "12c29cjr59ws3x88bvpxkxigxvbf0yg6pvz5ypja8b4zqgb0rzy4";
        libraryHaskellDepends = [ base ];
        description = "Arithmetic of natural numbers";
        license = lib.licenses.bsd3;
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "neolua" = callPackage
+    ({ mkDerivation, base, optparse-applicative, process, text }:
+     mkDerivation {
+       pname = "neolua";
+       version = "1.0.0";
+       sha256 = "1b8fccxd29f8q7sp0xrrigsaa7887r2dmpzk5qwbvl23nblkv8jn";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         base optparse-applicative process text
+       ];
+       description = "A CLI adapter to map Lua's CLI to Neovim's CLI for lua interpretation";
+       license = lib.licenses.gpl2Only;
+       mainProgram = "neolua";
+     }) {};
+
   "neptune-backend" = callPackage
     ({ mkDerivation, aeson, base, base64-bytestring, bytestring
      , case-insensitive, concurrent-extra, containers, deepseq, envy
···
      }:
      mkDerivation {
        pname = "net-mqtt";
-       version = "0.8.2.5";
-       sha256 = "0k6yghgj693hbyk2zsjh3ns1yx9ypjjfj3mrrandn6lvpif08h9x";
+       version = "0.8.3.0";
+       sha256 = "02y2bsxr23vkg8xp0aa4mz1dpy37zsgyqkl6yd80ldm7h4vmj8fl";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.mit;
      }) {};
 
+  "network-conduit-tls_1_4_0" = callPackage
+    ({ mkDerivation, base, bytestring, conduit, conduit-extra
+     , crypton-connection, data-default-class, HUnit, mtl, network
+     , streaming-commons, tls, transformers, unliftio-core
+     }:
+     mkDerivation {
+       pname = "network-conduit-tls";
+       version = "1.4.0";
+       sha256 = "16addjifgsvyjsapl3a6nfkcab5znffxyy5lifrmkn9r69s7l5f5";
+       libraryHaskellDepends = [
+         base bytestring conduit conduit-extra crypton-connection
+         data-default-class network streaming-commons tls transformers
+         unliftio-core
+       ];
+       testHaskellDepends = [
+         base bytestring conduit conduit-extra crypton-connection HUnit mtl
+       ];
+       description = "Create TLS-aware network code with conduits";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "network-connection" = callPackage
     ({ mkDerivation, base, bytestring, containers, network
      , network-bytestring, stm
···
     ({ mkDerivation, base, bytestring, network }:
      mkDerivation {
        pname = "network-run";
-       version = "0.2.4";
-       sha256 = "0w3dmwk03j4n01xkiq8m4sqa27bskh239mpw7m4ihjmkxqcwc5gl";
-       libraryHaskellDepends = [ base bytestring network ];
-       description = "Simple network runner library";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "network-run_0_2_5" = callPackage
-    ({ mkDerivation, base, bytestring, network }:
-     mkDerivation {
-       pname = "network-run";
        version = "0.2.5";
        sha256 = "08662w7ja9w4a4fwikaawxnxcszkd0mdmaajmshas2dd25xyikwi";
        libraryHaskellDepends = [ base bytestring network ];
        description = "Simple network runner library";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "network-server" = callPackage
···
        mainProgram = "Kepler";
      }) {};
 
+  "numeric-optimization" = callPackage
+    ({ mkDerivation, base, constraints, containers, data-default-class
+     , hmatrix, hspec, HUnit, lbfgs, primitive, vector
+     }:
+     mkDerivation {
+       pname = "numeric-optimization";
+       version = "0.1.0.1";
+       sha256 = "158ww5bnm2yblb3c8azd4cxb3vdc6ckkc3k0a5mdksr2d0lj1j20";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base constraints data-default-class hmatrix lbfgs primitive vector
+       ];
+       testHaskellDepends = [
+         base containers data-default-class hspec HUnit vector
+       ];
+       description = "Unified interface to various numerical optimization algorithms";
+       license = lib.licenses.bsd3;
+     }) {};
+
+  "numeric-optimization-ad" = callPackage
+    ({ mkDerivation, ad, base, containers, data-default-class, hmatrix
+     , hspec, HUnit, numeric-optimization, primitive, reflection, vector
+     }:
+     mkDerivation {
+       pname = "numeric-optimization-ad";
+       version = "0.1.0.1";
+       sha256 = "09lcvmgx6vy6sf9vwph5vfr2amasqkcvywbgif0nh6mpbwrhjj8w";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         ad base data-default-class hmatrix numeric-optimization primitive
+         reflection vector
+       ];
+       testHaskellDepends = [
+         base containers data-default-class hspec HUnit numeric-optimization
+       ];
+       description = "Wrapper of numeric-optimization package for using with AD package";
+       license = lib.licenses.bsd3;
+     }) {};
+
+  "numeric-optimization-backprop" = callPackage
+    ({ mkDerivation, backprop, base, containers, data-default-class
+     , hspec, HUnit, microlens, mono-traversable, mtl
+     , numeric-optimization, primitive, reflection, vector
+     }:
+     mkDerivation {
+       pname = "numeric-optimization-backprop";
+       version = "0.1.0.1";
+       sha256 = "09nb6v2rl102glivi6x1m92jlb4d9w74r85mrd1l0h7k3lz44nma";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         backprop base containers data-default-class mono-traversable mtl
+         numeric-optimization primitive reflection vector
+       ];
+       testHaskellDepends = [
+         base containers data-default-class hspec HUnit microlens
+         numeric-optimization
+       ];
+       description = "Wrapper of numeric-optimization package for using with backprop package";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "numeric-prelude" = callPackage
     ({ mkDerivation, array, base, containers, deepseq
      , doctest-exitcode-stdio, doctest-lib, non-negative, parsec
···
      }:
      mkDerivation {
        pname = "nvim-hs";
-       version = "2.3.2.1";
-       sha256 = "1rq4n453hc3890n4mmxkiaddfpamj4af66f9wx2hqfi40ammfgna";
+       version = "2.3.2.3";
+       sha256 = "03s0fsws7f8mld6kpmymagrmajfnxzi9isgdzik4kdrx8fzygin8";
        libraryHaskellDepends = [
          base bytestring cereal cereal-conduit conduit containers
          data-default deepseq foreign-store hslogger megaparsec messagepack
···
      }:
      mkDerivation {
        pname = "nvim-hs-contrib";
-       version = "2.0.0.1";
-       sha256 = "15ds92qxhax0y9d9zl1sz061ali1rj9vwvcjn415ph1cyqgr3ink";
+       version = "2.0.0.2";
+       sha256 = "03syv1fsickcmgk9qagavidgh9hyy0v00df29jd5wia631xc60a6";
        libraryHaskellDepends = [
          base bytestring data-default directory filepath messagepack mtl
          nvim-hs prettyprinter prettyprinter-ansi-terminal text time
···
      }:
      mkDerivation {
        pname = "opaleye";
-       version = "0.9.6.2";
-       sha256 = "1pq0n3n686bbh6abjagxjkx4whkj1mw7nqvh1f4bkp9f3l4h7a3v";
+       version = "0.9.7.0";
+       sha256 = "1njmns4myrjyfbmd4qrkrwqp6jyaridxkf4n0n8bgw3z5hr64jhv";
        libraryHaskellDepends = [
          aeson base base16-bytestring bytestring case-insensitive
          contravariant postgresql-simple pretty product-profunctors
···
   "openai-hs" = callPackage
     ({ mkDerivation, aeson, base, bytestring, casing, containers, cpphs
      , hspec, http-client, http-client-tls, http-types, openai-servant
-     , servant, servant-client, servant-client-core
+     , servant, servant-auth-client, servant-client, servant-client-core
      , servant-multipart-client, text, vector
      }:
      mkDerivation {
        pname = "openai-hs";
-       version = "0.2.2.0";
-       sha256 = "07jyz6bgz2s21j5w5avpi7hllcxw9ix3m3r1lyjb0kwa5rvvpl7d";
+       version = "0.3.0.0";
+       sha256 = "0mimxdmfsfnplsnihyavv6cf07hz0nxryikff3xidd4ac4lfr87b";
        libraryHaskellDepends = [
          aeson base bytestring casing cpphs http-client http-types
-         openai-servant servant servant-client servant-multipart-client text
+         openai-servant servant servant-auth-client servant-client
+         servant-multipart-client text
        ];
+       libraryToolDepends = [ cpphs ];
        testHaskellDepends = [
          aeson base bytestring casing containers cpphs hspec http-client
-         http-client-tls http-types openai-servant servant servant-client
-         servant-client-core servant-multipart-client text vector
+         http-client-tls http-types openai-servant servant
+         servant-auth-client servant-client servant-client-core
+         servant-multipart-client text vector
        ];
+       testToolDepends = [ cpphs ];
        description = "Unofficial OpenAI client";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
···
      }) {};
 
   "openai-servant" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, casing, servant
-     , servant-multipart-api, text, time, vector
+    ({ mkDerivation, aeson, base, bytestring, casing, mime-types
+     , servant, servant-auth, servant-auth-client, servant-multipart-api
+     , text, time, vector
      }:
      mkDerivation {
        pname = "openai-servant";
-       version = "0.2.3.0";
-       sha256 = "19029qqbdvs5a9a41cncff3fmy4s02654bxjjw9kc84z5cp67s7i";
+       version = "0.3.0.0";
+       sha256 = "1ilmfaj465ly9fjcgmp1nwd08n0p35sg9jgidw5qvyl4s60j7br2";
        libraryHaskellDepends = [
-         aeson base bytestring casing servant servant-multipart-api text
-         time vector
+         aeson base bytestring casing mime-types servant servant-auth
+         servant-auth-client servant-multipart-api text time vector
        ];
        description = "Unofficial OpenAI servant types";
        license = lib.licenses.bsd3;
···
        mainProgram = "ormolu";
      }) {};
 
-  "ormolu_0_7_0_0" = callPackage
+  "ormolu_0_7_1_0" = callPackage
     ({ mkDerivation, ansi-terminal, array, base, binary, bytestring
      , Cabal-syntax, containers, deepseq, Diff, directory, file-embed
      , filepath, ghc-lib-parser, hspec, hspec-discover, hspec-megaparsec
···
      }:
      mkDerivation {
        pname = "ormolu";
-       version = "0.7.0.0";
-       sha256 = "07bwcki2xp2g5q3jpll8675yawr1x6nk3zg1yns8mdw085a98g7s";
-       revision = "1";
-       editedCabalFile = "1fm3vi1nk18p623vxw197inlqfb8gwg4jiy88s63id0j7sdlvzqh";
+       version = "0.7.1.0";
+       sha256 = "175pjxbys6l94rzm9bzwymvh5fhclxwq9vj592m8zcga4bcaa6iv";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "ory-hydra-client";
-       version = "2.0.3";
-       sha256 = "03yyxgd9b6fkvbj53a39qi0mc2x29vizsj4j75i80nzp713bj18v";
+       version = "2.1.2.1";
+       sha256 = "1x2kdqlapc8fx1iwhry1cgkpmy5p2ingqf2rp691vy1id8ibhdp5";
        libraryHaskellDepends = [
          aeson base base64-bytestring bytestring case-insensitive containers
          deepseq exceptions http-api-data http-client http-client-tls
···
          aeson base bytestring containers hspec iso8601-time mtl QuickCheck
          semigroups text time transformers unordered-containers vector
        ];
-       description = "Auto-generated ory-hydra-client API Client";
+       description = "Auto-generated ory-hydra API Client";
        license = lib.licenses.mit;
      }) {};
 
···
      }) {};
 
   "pa-json" = callPackage
-    ({ mkDerivation, aeson, aeson-better-errors, base, containers
-     , hspec-core, hspec-expectations, pa-error-tree, pa-label
-     , pa-prelude, scientific, text, time, vector
+    ({ mkDerivation, aeson, aeson-better-errors, aeson-pretty, base
+     , bytestring, containers, hspec-core, hspec-expectations
+     , pa-error-tree, pa-label, pa-prelude, scientific, text, time
+     , vector
      }:
      mkDerivation {
        pname = "pa-json";
-       version = "0.1.0.0";
-       sha256 = "0lka7viqsbrh2vb1snhs1ryi6mcxf5l404rjmq65mqbh5y6gf0pc";
+       version = "0.2.0.0";
+       sha256 = "1r3nsbdlpbrmfj9zaql7zjbd5hzvmzbcqpk74l4j78wfif4g6zmm";
        libraryHaskellDepends = [
-         aeson aeson-better-errors base containers hspec-core
-         hspec-expectations pa-error-tree pa-label pa-prelude scientific
-         text time vector
+         aeson aeson-better-errors aeson-pretty base bytestring containers
+         hspec-core hspec-expectations pa-error-tree pa-label pa-prelude
+         scientific text time vector
        ];
        description = "Our JSON parsers/encoders";
        license = lib.licenses.bsd3;
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "pa-pretty" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, base, hscolour
+     , nicify-lib, pa-prelude, text
+     }:
+     mkDerivation {
+       pname = "pa-pretty";
+       version = "0.1.1.0";
+       sha256 = "1jgn7rip71kw9nzhdmdk8pz7wlwvb710igbykmvcajdcy9y5m4ns";
+       libraryHaskellDepends = [
+         aeson aeson-pretty ansi-terminal base hscolour nicify-lib
+         pa-prelude text
+       ];
+       description = "Some pretty-printing helpers";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "pack" = callPackage
     ({ mkDerivation, array, base, bytestring, lens, transformers
      , vector
···
        ];
      }) {};
 
-  "pandoc_3_1_2" = callPackage
+  "pandoc_3_1_3" = callPackage
        description = "PID control loop";
      , base64, binary, blaze-html, blaze-markup, bytestring
      , case-insensitive, citeproc, commonmark, commonmark-extensions
···
      , parsec, pretty, pretty-show, process, random, safe, scientific
      , SHA, skylighting, skylighting-core, split, syb, tagsoup, tasty
      , tasty-bench, tasty-golden, tasty-hunit, tasty-quickcheck
-     , temporary, texmath, text, text-conversions, time
-     , unicode-collation, unicode-transforms, unix, xml, xml-conduit
-     , xml-types, yaml, zip-archive, zlib
+     , temporary, texmath, text, text-conversions, time, typst
+     , unicode-collation, unicode-transforms, unix, vector, xml
+     , xml-conduit, xml-types, yaml, zip-archive, zlib
      }:
      mkDerivation {
        pname = "pandoc";
-       version = "3.1.2";
-       sha256 = "1v0wds8jvp2yln39npcgcdsmhndlv4wifbgpq3x9r5pa8qdx50mn";
+       version = "3.1.3";
+       sha256 = "070rx611v1kg3gcvp267h68m0dh3zfi0v3r6r2lkadmfw45sxrvd";
        configureFlags = [ "-f-trypandoc" ];
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
···
          JuicyPixels mime-types mtl network network-uri pandoc-types parsec
          pretty pretty-show process random safe scientific SHA skylighting
          skylighting-core split syb tagsoup temporary texmath text
-         text-conversions time unicode-collation unicode-transforms unix xml
-         xml-conduit xml-types yaml zip-archive zlib
+         text-conversions time typst unicode-collation unicode-transforms
+         unix vector xml xml-conduit xml-types yaml zip-archive zlib
        ];
        testHaskellDepends = [
          base bytestring containers Diff directory doctemplates filepath
···
      }:
      mkDerivation {
        pname = "pandoc-lua-engine";
-       version = "0.2";
-       sha256 = "0rm6yrk4al7gr7q1dqbkw38skrpn7r1x3hn1mbklvq3jpz8dvpxr";
+       version = "0.2.0.1";
+       sha256 = "1y1il2lx4bhpby6nk9wam84gmjq2knz4ynm28ckb27mgih99jf4a";
        libraryHaskellDepends = [
          aeson base bytestring citeproc containers data-default doclayout
          doctemplates exceptions hslua hslua-module-doclayout
···
        mainProgram = "pandoc-plot";
      }) {};
 
-  "pandoc-plot_1_6_2" = callPackage
+  "pandoc-plot_1_7_0" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, data-default
      , directory, filepath, gitrev, hashable, hspec-expectations
      , lifted-async, lifted-base, mtl, optparse-applicative, pandoc
···
      }:
      mkDerivation {
        pname = "pandoc-plot";
-       version = "1.6.2";
-       sha256 = "12rl3smn1llqbbdkhjqn9qman8mngaaxmvhlf0v7saq36magnlya";
+       version = "1.7.0";
+       sha256 = "01f99mjav3w5c0vixr80a6vykabwk9ap8wj4lnh3c6k681i5nnq6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "persistent-mtl";
        version = "0.5.0.1";
        sha256 = "17sxwa8p95nrkacjr1wnpihwfq121z1pkyh1nvlfjy76b4aalqhi";
-       revision = "2";
-       editedCabalFile = "1aq30hqpdcsf7llmfwnn061qa2id4b8fncd9k0f53kmgvys2xivd";
+       revision = "3";
+       editedCabalFile = "1slwcn2iafg1gffhj02hlbgpv2v719f26a608bli2hkd9v96s720";
        testHaskellDepends = [
          base bytestring conduit containers esqueleto explainable-predicates
          monad-logger persistent persistent-postgresql persistent-sqlite
···
      }) {};
 
   "phladiprelio-general-simple" = callPackage
-    ({ mkDerivation, base, cli-arguments, phladiprelio-general-shared
-     , phonetic-languages-constraints-array
+    ({ mkDerivation, base, cli-arguments, directory, halfsplit
+     , phladiprelio-general-shared, phonetic-languages-constraints-array
      , phonetic-languages-permutations-array
      , phonetic-languages-phonetics-basics
      , phonetic-languages-simplified-base, rhythmic-sequences
      }:
      mkDerivation {
        pname = "phladiprelio-general-simple";
-       version = "0.4.1.0";
-       sha256 = "12wz9rydy16glwwj621ai74grghj5qjc6pahj17wdw6ip99p89hb";
+       version = "0.6.0.0";
+       sha256 = "0wagsvc2wf6qk46lvvs84zb1cn8qvhvvwghc2qzs6bdk1jv8nk1a";
        libraryHaskellDepends = [
-         base cli-arguments phladiprelio-general-shared
+         base cli-arguments directory halfsplit phladiprelio-general-shared
          phonetic-languages-constraints-array
          phonetic-languages-permutations-array
          phonetic-languages-phonetics-basics
···
      }) {};
 
   "phladiprelio-ukrainian-simple" = callPackage
-    ({ mkDerivation, base, cli-arguments, phladiprelio-ukrainian-shared
+    ({ mkDerivation, base, cli-arguments, directory, halfsplit
+     , phladiprelio-ukrainian-shared
      , phonetic-languages-constraints-array
      , phonetic-languages-permutations-array
      , phonetic-languages-simplified-base
···
      }:
      mkDerivation {
        pname = "phladiprelio-ukrainian-simple";
-       version = "0.5.1.1";
-       sha256 = "0swzv9zyixdbffxnszy92g8fdhcp5a177yi583mxix13m253xd32";
+       version = "0.7.0.0";
+       sha256 = "1x68wygghy825nigyqpi1lfqd89vdgiy91zdsvyzg42bdwraskjv";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
-         base cli-arguments phladiprelio-ukrainian-shared
-         phonetic-languages-constraints-array
+         base cli-arguments directory halfsplit
+         phladiprelio-ukrainian-shared phonetic-languages-constraints-array
          phonetic-languages-permutations-array
          phonetic-languages-simplified-base
          phonetic-languages-ukrainian-array rhythmic-sequences
···
     ({ mkDerivation, base, subG }:
      mkDerivation {
        pname = "phonetic-languages-constraints-array";
-       version = "0.6.2.0";
-       sha256 = "0b5w7va3b77fld9sij4jpb378bmqp7l918cxw0yh514lbkyawzgk";
+       version = "0.7.3.0";
+       sha256 = "1iykr6d1gfrvkfxfd5dipmd45y5frg8j3lp8xxlvwhsakzxp6vsy";
        libraryHaskellDepends = [ base subG ];
        description = "Constraints to filter the needed permutations";
        license = lib.licenses.mit;
···
        pname = "pipes-extras";
        version = "1.0.15";
        sha256 = "1cyb05bv5xkarab3090ikpjiqm79lr46n3nalplliz8jr4x67a82";
-       revision = "6";
-       editedCabalFile = "0gqqhvq5h6kkz6k4dpvlky7lbrfbgqp30whn7cglaplrqzlfwbvd";
+       revision = "7";
+       editedCabalFile = "1mhhm4k605p6qb8m7zn97as4fj4kzy386i8k47lghlh806w7lghn";
        libraryHaskellDepends = [ base foldl lens pipes transformers ];
        testHaskellDepends = [
          base HUnit pipes test-framework test-framework-hunit transformers
···
        ];
        description = "Polynomials";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "poly-arity" = callPackage
···
   "pontarius-xmpp" = callPackage
     ({ mkDerivation, async, attoparsec, base, base64-bytestring, binary
      , bytestring, Cabal, conduit, containers, criterion, crypto-api
-     , crypto-random, cryptohash, cryptohash-cryptoapi, data-default
-     , dns, exceptions, generic-arbitrary, hslogger, hspec
+     , cryptohash, cryptohash-cryptoapi, cryptonite, data-default, dns
+     , exceptions, generic-arbitrary, hslogger, hspec
      , hspec-expectations, iproute, lens, lens-family, lifted-base, mtl
      , network, profunctors, pureMD5, QuickCheck, quickcheck-instances
      , random, ranges, resourcet, smallcheck, split, stm, stringprep
···
      }:
      mkDerivation {
        pname = "pontarius-xmpp";
-       version = "0.5.6.5";
-       sha256 = "1k01mmd19wcv5gzavnh81fhdiq8rlhvnv63f6n3s582qlsdc2lhi";
+       version = "0.5.6.6";
+       sha256 = "1dzr965amv2909h4r5pc4qxhgrzp79cmv5grq79w5qjjfmj6iv65";
        libraryHaskellDepends = [
          attoparsec base base64-bytestring binary bytestring conduit
-         containers crypto-api crypto-random cryptohash cryptohash-cryptoapi
+         containers crypto-api cryptohash cryptohash-cryptoapi cryptonite
          data-default dns exceptions hslogger iproute lens lens-family
          lifted-base mtl network profunctors pureMD5 random resourcet split
          stm stringprep template-haskell text tls transformers
···
        ];
        testHaskellDepends = [
          async attoparsec base base64-bytestring binary bytestring Cabal
-         conduit containers crypto-api crypto-random cryptohash
-         cryptohash-cryptoapi data-default dns exceptions generic-arbitrary
-         hslogger hspec hspec-expectations iproute lens lens-family
-         lifted-base mtl network profunctors pureMD5 QuickCheck
-         quickcheck-instances random ranges resourcet smallcheck split stm
-         stringprep tasty tasty-hspec tasty-hunit tasty-quickcheck tasty-th
-         template-haskell text tls transformers unbounded-delays void
-         x509-system xml-conduit xml-picklers xml-types
+         conduit containers crypto-api cryptohash cryptohash-cryptoapi
+         cryptonite data-default dns exceptions generic-arbitrary hslogger
+         hspec hspec-expectations iproute lens lens-family lifted-base mtl
+         network profunctors pureMD5 QuickCheck quickcheck-instances random
+         ranges resourcet smallcheck split stm stringprep tasty tasty-hspec
+         tasty-hunit tasty-quickcheck tasty-th template-haskell text tls
+         transformers unbounded-delays void x509-system xml-conduit
+         xml-picklers xml-types
        ];
        benchmarkHaskellDepends = [
          attoparsec base base64-bytestring binary bytestring conduit
-         containers criterion crypto-api crypto-random cryptohash
-         cryptohash-cryptoapi data-default dns exceptions hslogger iproute
-         lens lens-family lifted-base mtl network profunctors pureMD5 random
+         containers criterion crypto-api cryptohash cryptohash-cryptoapi
+         cryptonite data-default dns exceptions hslogger iproute lens
+         lens-family lifted-base mtl network profunctors pureMD5 random
          resourcet split stm stringprep template-haskell text tls
          transformers unbounded-delays void x509-system xml-conduit
          xml-picklers xml-types
···
      }) {};
 
   "postgresql-simple-interpolate" = callPackage
-    ({ mkDerivation, base, haskell-src-meta, mtl, parsec
+    ({ mkDerivation, base, criterion, haskell-src-meta, mtl, parsec
      , postgresql-simple, template-haskell
      }:
      mkDerivation {
        pname = "postgresql-simple-interpolate";
-       version = "0.1";
-       sha256 = "0nq4j1lbylklsz3fhc4y7rh6c4lfzzfyha65g6i22mbpx51vdf30";
+       version = "0.1.1.0";
+       sha256 = "0g7b8mccy8ajx8l94s7xd0mrhyn11xjb9m9g2jqbsv6fklzkg0qy";
        libraryHaskellDepends = [
          base haskell-src-meta mtl parsec postgresql-simple template-haskell
        ];
+       benchmarkHaskellDepends = [ base criterion template-haskell ];
        description = "Interpolated SQL queries via quasiquotation";
        license = lib.licenses.bsd3;
      }) {};
···
      }:
      mkDerivation {
        pname = "propellor";
-       version = "5.16";
-       sha256 = "12ywc4riq4wr1ylm4gqp4fcszssfz1a6n1xa5da0mwxydklmw6l1";
+       version = "5.17";
+       sha256 = "0g5f3vywbdh6hl6rkzprpnldr9c8cc2lzz2xb31l6dni6ymyns5a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
     ({ mkDerivation, base, bytestring, cereal, containers, criterion
      , deepseq, doctest, ghc-prim, hashable, parameterized, primitive
      , QuickCheck, random, safe, tasty, tasty-hunit, tasty-quickcheck
-     , text, transformers, unordered-containers, vector, word-compat
+     , template-haskell, text, text-short, transformers
+     , unordered-containers, vector, word-compat
      }:
      mkDerivation {
        pname = "proto3-wire";
-       version = "1.4.0";
-       sha256 = "1byjv249w3vm1298dqqjpmrwpzcdmz8dh7bykn981zxyn9qhf55y";
+       version = "1.4.1";
+       sha256 = "0liy2qnx9y10ad79nfw0idp2c5mz37pwb1h07f82g4rbg66qn465";
        libraryHaskellDepends = [
          base bytestring cereal containers deepseq ghc-prim hashable
-         parameterized primitive QuickCheck safe text transformers
-         unordered-containers vector word-compat
+         parameterized primitive QuickCheck safe template-haskell text
+         text-short transformers unordered-containers vector word-compat
        ];
        testHaskellDepends = [
          base bytestring cereal doctest QuickCheck tasty tasty-hunit
-         tasty-quickcheck text transformers vector
+         tasty-quickcheck text text-short transformers vector
        ];
        benchmarkHaskellDepends = [ base bytestring criterion random ];
        description = "A low-level implementation of the Protocol Buffers (version 3) wire format";
···
        pname = "protolude";
        version = "0.3.3";
        sha256 = "0ihsjx48p9dgsp0i0l73h16mycnba40hyh7412jv3xz9qz9dwfbc";
+       revision = "1";
+       editedCabalFile = "07hfs830nc1lvcmsw1hhmrmhzq0b8z25dc090wfn25ss2cvrjkjv";
        libraryHaskellDepends = [
          array async base bytestring containers deepseq ghc-prim hashable
          mtl mtl-compat stm text transformers transformers-compat
···
        pname = "pseudo-boolean";
        version = "0.1.10.0";
        sha256 = "1p9w1d80d2kp7wp7wp6xf9dz1iv9knhy8b75mklz7zq3cf5gvnrh";
-       revision = "3";
-       editedCabalFile = "0cn7v9r8kd9xcfhkzd2ln5kqfwv4dc81c4lmv402sa1w82sbbf2h";
+       revision = "4";
+       editedCabalFile = "1l1ribvz1vz9037ymxa6iqr3ilj6mkrwbap93vm84ywa2xxni77c";
        libraryHaskellDepends = [
          attoparsec base bytestring bytestring-builder containers deepseq
          dlist hashable megaparsec parsec void
···
        pname = "qsem";
        version = "0.1.0.0";
        sha256 = "1y9c22jr0frflgzmpzpz4d7zgcz7wbql8xwr6bx912rh6gm4gx9h";
+       revision = "1";
+       editedCabalFile = "13djn4hd8vhic60hrax1cnlly6d108mmdhg0x5x94y6d8g08mgp1";
        libraryHaskellDepends = [ base ghc-prim ];
        description = "quantity semaphores";
        license = lib.licenses.bsd3;
···
        pname = "quadratic-irrational";
        version = "0.1.1";
        sha256 = "11nksvr6wnbrphq3ymg93w2xpqw6in3j1qpgbl2f3x9bgiss2l7s";
+       revision = "1";
+       editedCabalFile = "0br41cjzrl08ma9kgnhh2vp3ixad0gvvvv9751wpc6chr7a59ic8";
        libraryHaskellDepends = [
          arithmoi base containers integer-roots transformers
        ];
···
 
   "quic" = callPackage
     ({ mkDerivation, array, async, base, base16-bytestring, bytestring
-     , containers, crypto-token, cryptonite, data-default-class
-     , fast-logger, filepath, hspec, hspec-discover, iproute, memory
-     , network, network-byte-order, network-udp, psqueues, QuickCheck
-     , random, stm, tls, unix-time, unliftio, unliftio-core, x509
-     , x509-system
+     , containers, crypto-token, crypton, crypton-x509
+     , crypton-x509-system, data-default-class, fast-logger, filepath
+     , hspec, hspec-discover, iproute, memory, network
+     , network-byte-order, network-udp, psqueues, QuickCheck, random
+     , stm, tls, unix-time, unliftio, unliftio-core
      }:
      mkDerivation {
        pname = "quic";
-       version = "0.1.1";
-       sha256 = "02slgbrz3n6ga335sya6625xvsn6i1k8wnw6avipc48q6fmwzw29";
+       version = "0.1.2";
+       sha256 = "04ag4lvrlylr1qks6mvhp1pbbz66yy44s2c0z6wz49nc30x8qq8n";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          array base base16-bytestring bytestring containers crypto-token
-         cryptonite data-default-class fast-logger filepath iproute memory
-         network network-byte-order network-udp psqueues random stm tls
-         unix-time unliftio unliftio-core x509 x509-system
+         crypton crypton-x509 crypton-x509-system data-default-class
+         fast-logger filepath iproute memory network network-byte-order
+         network-udp psqueues random stm tls unix-time unliftio
+         unliftio-core
        ];
        testHaskellDepends = [
-         async base base16-bytestring bytestring containers cryptonite hspec
+         async base base16-bytestring bytestring containers crypton hspec
          network network-udp QuickCheck tls unix-time unliftio
        ];
        testToolDepends = [ hspec-discover ];
        description = "QUIC";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "quick-generator" = callPackage
···
        pname = "quickcheck-instances";
        version = "0.3.29.1";
        sha256 = "0jx2wfy7y5dr14s9i457g2aah4isjxry4mlbqhj7vlav6ib84gdj";
-       revision = "1";
-       editedCabalFile = "0yl09mp9phfka70z0dl0lg1c0kmf1qyh3rmbc8nzakdbs77l9fj3";
+       revision = "2";
+       editedCabalFile = "118xy4z4dy4bpkzsp98daiv3l4n5j7ph9my0saca7cqjybqwkcip";
        libraryHaskellDepends = [
          array base bytestring case-insensitive containers data-array-byte
          data-fix hashable integer-logarithms old-time OneTuple primitive
···
      }:
      mkDerivation {
        pname = "quickcheck-state-machine";
-       version = "0.7.2";
-       sha256 = "0q3lw0qbaffcq7rs882dyc9mdaj5rkpq51ybq84i9gwcaiz1vipd";
+       version = "0.7.3";
+       sha256 = "1x3bdi4xyvxl8mfxzkqa7v4aqmr1mjk5hg2wh9c5jdaysqj9400h";
        libraryHaskellDepends = [
          ansi-wl-pprint base containers directory exceptions filepath
          generic-data graphviz markov-chain-usage-model matrix mtl
···
      }:
      mkDerivation {
        pname = "recover-rtti";
-       version = "0.4.2";
-       sha256 = "1cfpnyjibamhfsxs9x3dz2m995zvj7w5lp65lq8g7nsk1chhs7fi";
+       version = "0.4.3";
+       sha256 = "044qrvq4js03w916d9imyjbq4x0dwwm68d56l0fjsjzzvzin76v7";
        libraryHaskellDepends = [
-         aeson base bytestring containers ghc-heap mtl primitive sop-core
-         stm text unordered-containers vector
+         aeson base bytestring containers ghc-heap ghc-prim mtl primitive
+         sop-core stm text unordered-containers vector
        ];
        testHaskellDepends = [
          aeson base bytestring containers ghc-heap ghc-prim mtl primitive
···
        ];
        description = "Perform fft with repa via FFTW";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "repa-flow" = callPackage
···
        license = lib.licenses.gpl2Plus;
      }) {};
 
-  "resolv_0_2_0_1" = callPackage
+  "resolv_0_2_0_2" = callPackage
     ({ mkDerivation, base, base16-bytestring, binary, bytestring
      , containers, directory, filepath, tasty, tasty-hunit
      }:
      mkDerivation {
        pname = "resolv";
-       version = "0.2.0.1";
-       sha256 = "1gkn4lnp1gx8r19l04hbf8fg7a8y4s9iph4bxqmq2n9zz0k3gaz6";
+       version = "0.2.0.2";
+       sha256 = "0jz798kliih4lb16s9bjk7sa9034x1qhyrr8z9sp6ahkz4yjh3c8";
        libraryHaskellDepends = [
          base base16-bytestring binary bytestring containers
        ];
···
        ];
        description = "Directed rounding for built-in floating types";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "rounding" = callPackage
···
        pname = "row-types";
        version = "1.0.1.2";
        sha256 = "05vfnhcfi7wsidxiknl8a28xvlid2q095qhah08r7mj9zq38da8f";
+       revision = "1";
+       editedCabalFile = "0r1vjdwnvavlv1pkl27gjpvc3d165bam4y4pp8l2p8q6bnwpqk2d";
        libraryHaskellDepends = [
          base constraints deepseq generic-lens hashable profunctors text
          unordered-containers
···
        testToolDepends = [ sydtest-discover ];
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "safe-coloured-text-layout" = callPackage
···
        description = "Safely layout output coloured text";
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "safe-coloured-text-layout-gen" = callPackage
···
      }:
      mkDerivation {
        pname = "sandwich";
-       version = "0.1.3.2";
-       sha256 = "0ijxvyd73xsaaci1kxwgs2k5gj9ax697bd84f7i068g8rc18nyak";
+       version = "0.1.4.0";
+       sha256 = "01bw9pn78kspb2qp58k4dxrp21395zb7459mcw5gn3xkp8r2z634";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        broken = true;
      }) {inherit (pkgs) z3;};
 
-  "sbv_10_1" = callPackage
+  "sbv_10_2" = callPackage
     ({ mkDerivation, array, async, base, bytestring, containers
      , deepseq, directory, filepath, libBF, mtl, pretty, process
      , QuickCheck, random, syb, tasty, tasty-bench, tasty-golden
···
      }:
      mkDerivation {
        pname = "sbv";
-       version = "10.1";
-       sha256 = "1hi3pz404ffaihv7h8svakjdzn7hypvissprpw1iz1ckfws5bf6s";
+       version = "10.2";
+       sha256 = "1qairjjffy3di61gdav8p1h3zdz4967g13z64xahhd4f2agmr0kz";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          array async base containers deepseq directory filepath libBF mtl
···
      }:
      mkDerivation {
        pname = "sdr";
-       version = "0.1.0.13";
-       sha256 = "1ip89ddkzzfq2qvpm0ha321hhgx50lphf0s1yd84gw458fsw0ma7";
+       version = "0.1.0.14";
+       sha256 = "0nxwhyl5am14k6n7vvih4wr0n646pgbkxwyifr210wz763f5qgyx";
        libraryHaskellDepends = [
          array base bytestring bytestring-to-vector cairo cereal Chart
          Chart-cairo colour containers Decimal dynamic-graph fftwRaw GLFW-b
···
      }:
      mkDerivation {
        pname = "servant-swagger-ui";
-       version = "0.3.5.4.5.0";
-       sha256 = "12w75z23bnygyr3ki9w3zfy9nhxyjawf9pyzhfg6rp2mq3nji9gg";
-       revision = "4";
-       editedCabalFile = "0nxyp77vqmwd7br5ag0zwc0rjwkxcriqcbfbg9cvlfdkp5d26wsp";
+       version = "0.3.5.5.0.0";
+       sha256 = "1sjgakdln2nx9ki13vk557rfqwqjksagl32q7y3m8mc9y9s80py7";
        libraryHaskellDepends = [
          aeson base bytestring file-embed-lzma servant servant-server
          servant-swagger-ui-core text
···
        ];
        description = "Calculate expressions involving significant figures";
        license = lib.licenses.gpl3Plus;
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "significant-figures-cli";
+       broken = true;
      }) {};
 
   "signify-hs" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "simple-sendfile_0_2_32" = callPackage
+    ({ mkDerivation, base, bytestring, conduit, conduit-extra
+     , directory, easy-file, hspec, hspec-discover, HUnit, network
+     , process, resourcet, unix
+     }:
+     mkDerivation {
+       pname = "simple-sendfile";
+       version = "0.2.32";
+       sha256 = "18r8d1in3x9r1p9fmvmypf9922icjbm1ksvqvp95dnf3gakd0a4z";
+       libraryHaskellDepends = [ base bytestring network unix ];
+       testHaskellDepends = [
+         base bytestring conduit conduit-extra directory easy-file hspec
+         HUnit network process resourcet
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Cross platform library for the sendfile system call";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "simple-server" = callPackage
     ({ mkDerivation, base, bytestring, concurrent-extra, containers
      , hashtables, network, time, unbounded-delays
···
      }:
      mkDerivation {
        pname = "slynx";
-       version = "0.7.2.0";
-       sha256 = "0gz5sqcghr930d77rfwagl5xcx7v9x87y7ivw89frn3ykblssr3x";
+       version = "0.7.2.1";
+       sha256 = "1jff263if0f3013qlh06dvmisnqvmlq2ld4rqb159x6vz59iablk";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
     ({ mkDerivation, base, logict, mtl, pretty }:
      mkDerivation {
        pname = "smallcheck";
-       version = "1.2.1";
-       sha256 = "0sf87zjlrgjw7q6a0499g2ywx66zvpv6rg6953fjc18fnl8rs7z4";
-       revision = "1";
-       editedCabalFile = "141lvb58hy94gywchaaf2dbh1dncnj951q5l6xkg1drvm94dvj1b";
+       version = "1.2.1.1";
+       sha256 = "07zyb3hnq242mdwak5briqc48wakp9pjsfizl78l06070i824hz0";
        libraryHaskellDepends = [ base logict mtl pretty ];
        description = "A property-based testing library";
        license = lib.licenses.bsd3;
···
      , exceptions, file-embed, filepath, hedgehog, hex-text, hspec
      , hspec-discover, hspec-hedgehog, memory, monad-loops, mtl
      , neat-interpolation, ordered-containers, process, random
-     , regex-tdfa, scientific, sdl2, sdl2-mixer, stm, strip-ansi-escape
-     , template-haskell, terminal, text, time, unix
-     , unordered-containers, vector, WAVE, with-utf8
+     , regex-tdfa, scientific, sdl2, sdl2-gfx, sdl2-mixer, sdl2-ttf, stm
+     , strip-ansi-escape, template-haskell, terminal, text, time, unix
+     , unliftio, unliftio-core, unordered-containers, vector, WAVE
+     , with-utf8
      }:
      mkDerivation {
        pname = "spade";
-       version = "0.1.0.8";
-       sha256 = "000cpyz9bvjf7rw2w0vwi4m6jj1hmdiq1qxs1039yrnfx7pq36r1";
+       version = "0.1.0.9";
+       sha256 = "0m11a7nszp3i6wg73274pj5hd7m6sw45n2h6rdrfbxc4xm08vs64";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson ansi-terminal base bytestring constraints containers
          cryptonite Decimal directory exceptions file-embed filepath
-         hedgehog hex-text hspec hspec-hedgehog memory monad-loops mtl
-         ordered-containers process random regex-tdfa scientific sdl2
-         sdl2-mixer stm template-haskell terminal text time unix
-         unordered-containers vector WAVE with-utf8
+         hedgehog hex-text hspec hspec-discover hspec-hedgehog memory
+         monad-loops mtl neat-interpolation ordered-containers process
+         random regex-tdfa scientific sdl2 sdl2-gfx sdl2-mixer sdl2-ttf stm
+         strip-ansi-escape template-haskell terminal text time unix unliftio
+         unliftio-core unordered-containers vector WAVE with-utf8
        ];
        executableHaskellDepends = [
          aeson ansi-terminal base bytestring constraints containers
          cryptonite Decimal directory exceptions file-embed filepath
-         hedgehog hex-text hspec hspec-hedgehog memory monad-loops mtl
-         ordered-containers process random regex-tdfa scientific sdl2
-         sdl2-mixer stm template-haskell terminal text time unix
-         unordered-containers vector WAVE with-utf8
+         hedgehog hex-text hspec hspec-discover hspec-hedgehog memory
+         monad-loops mtl neat-interpolation ordered-containers process
+         random regex-tdfa scientific sdl2 sdl2-gfx sdl2-mixer sdl2-ttf stm
+         strip-ansi-escape template-haskell terminal text time unix unliftio
+         unliftio-core unordered-containers vector WAVE with-utf8
        ];
        testHaskellDepends = [
          aeson ansi-terminal base bytestring constraints containers
          cryptonite Decimal directory exceptions file-embed filepath
          hedgehog hex-text hspec hspec-discover hspec-hedgehog memory
          monad-loops mtl neat-interpolation ordered-containers process
-         random regex-tdfa scientific sdl2 sdl2-mixer stm strip-ansi-escape
-         template-haskell terminal text time unix unordered-containers
-         vector WAVE with-utf8
+         random regex-tdfa scientific sdl2 sdl2-gfx sdl2-mixer sdl2-ttf stm
+         strip-ansi-escape template-haskell terminal text time unix unliftio
+         unliftio-core unordered-containers vector WAVE with-utf8
        ];
        testToolDepends = [ hspec-discover ];
        description = "A simple programming and debugging environment";
        license = lib.licenses.gpl3Only;
        badPlatforms = lib.platforms.darwin;
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "spade";
+       broken = true;
      }) {};
 
   "spake2" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "stateWriter_0_4_0" = callPackage
+    ({ mkDerivation, base, containers, criterion, deepseq, dlist, free
+     , hspec, lens, mtl, QuickCheck, transformers, vector
+     }:
+     mkDerivation {
+       pname = "stateWriter";
+       version = "0.4.0";
+       sha256 = "0jilpcfbg1gx66c4wwkrzy52df450vhm0l3fyqlbj4li31q4h4q4";
+       libraryHaskellDepends = [ base mtl transformers ];
+       testHaskellDepends = [ base free hspec mtl QuickCheck ];
+       benchmarkHaskellDepends = [
+         base containers criterion deepseq dlist lens mtl transformers
+         vector
+       ];
+       description = "A faster variant of the RWS monad transformers";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "statechart" = callPackage
     ({ mkDerivation, base, polyparse }:
      mkDerivation {
···
        ];
        description = "A library of statistical types, data, and functions";
        license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "stats" = callPackage
···
     ({ mkDerivation, base, blaze-markup, blaze-svg, directory, text }:
      mkDerivation {
        pname = "svg-icons";
-       version = "2.10.0";
-       sha256 = "0r1xm2vn62crrhzn9kb64lz9d16ra9gj0qq208wmhz6906hz0kbf";
+       version = "3.0.0";
+       sha256 = "1p29mwyy8hln0npmg14q0vyll6wyk3fakcskb2prgmy44k54wbxn";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        testToolDepends = [ sydtest-discover ];
        description = "A modern testing framework for Haskell with good defaults and advanced testing features";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "sydtest_0_15_0_0" = callPackage
···
        description = "A modern testing framework for Haskell with good defaults and advanced testing features";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "sydtest-aeson" = callPackage
···
        testToolDepends = [ sydtest-discover ];
        description = "An aeson companion library for sydtest";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "sydtest-amqp" = callPackage
···
        testToolDepends = [ sydtest-discover ];
        description = "An autodocodec companion library for sydtest";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "sydtest-discover" = callPackage
···
        testToolDepends = [ sydtest-discover ];
        description = "A Hedgehog companion library for sydtest";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "sydtest-hedgehog_0_4_0_0" = callPackage
···
        description = "An hedis companion library for sydtest";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "sydtest-hspec" = callPackage
···
        testToolDepends = [ sydtest-discover ];
        description = "An Hspec companion library for sydtest";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "sydtest-hspec_0_4_0_0" = callPackage
···
        description = "An mongoDB companion library for sydtest";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "sydtest-persistent" = callPackage
···
        ];
        description = "A persistent companion library for sydtest";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "sydtest-persistent-postgresql" = callPackage
···
        description = "An persistent-postgresql companion library for sydtest";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "sydtest-persistent-sqlite" = callPackage
···
        description = "A persistent-sqlite companion library for sydtest";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "sydtest-process" = callPackage
···
        testToolDepends = [ sydtest-discover ];
        description = "A typed-process companion library for sydtest";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "sydtest-rabbitmq" = callPackage
···
        description = "An rabbitmq companion library for sydtest";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "sydtest-servant" = callPackage
···
        testToolDepends = [ sydtest-discover ];
        description = "A servant companion library for sydtest";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "sydtest-typed-process" = callPackage
···
        testToolDepends = [ sydtest-discover ];
        description = "A typed-process companion library for sydtest";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "sydtest-wai" = callPackage
···
        testToolDepends = [ sydtest-discover ];
        description = "A wai companion library for sydtest";
        license = "unknown";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "sydtest-webdriver" = callPackage
···
        description = "A webdriver companion library for sydtest";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "sydtest-webdriver-screenshot" = callPackage
···
        pname = "systemd-socket-activation";
        version = "1.1.0.1";
        sha256 = "0cmpwklq2jdn8ax8b27zlcf40wzrvnjghfzbkqfaq2711ln47w6q";
+       revision = "1";
+       editedCabalFile = "0k8grxj45yyc9liixlhr0wi9gfqbzdzpnbd35qygc9xnylw0zm1b";
        libraryHaskellDepends = [
          base containers network quaalude text transformers unix
        ];
···
        broken = true;
      }) {};
 
-  "tasty-autocollect_0_4_0" = callPackage
+  "tasty-autocollect_0_4_1" = callPackage
     ({ mkDerivation, base, bytestring, containers, directory
      , explainable-predicates, filepath, ghc, tasty
        description = "PID control loop";
···
      }:
      mkDerivation {
        pname = "tasty-autocollect";
-       version = "0.4.0";
-       sha256 = "1nq5zaf3ly7n4mqprdgvgw2ixdxk7qdrl108ppncid43dfj560ik";
+       version = "0.4.1";
+       sha256 = "0b374x2m2rx1zzqb1i5wr36d6nxs1wx1cxyggjszlwxssz0vqzcj";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "terminal-progress-bar";
-       version = "0.4.1";
-       sha256 = "092yx9hal3xxcvpjwyqbfqww277l4gf83272pcnp3k6aj86a2756";
+       version = "0.4.2";
+       sha256 = "0li0w2wlbmq7mrg57ddnd33vqwndlxyl501bp0wkwyy9k14xmjgy";
        libraryHaskellDepends = [ base deepseq terminal-size text time ];
        testHaskellDepends = [
          base HUnit test-framework test-framework-hunit text time
···
        license = lib.licenses.gpl2Only;
      }) {};
 
-  "texmath_0_12_7_1" = callPackage
+  "texmath_0_12_8" = callPackage
     ({ mkDerivation, base, bytestring, containers, directory, filepath
      , mtl, pandoc-types, parsec, pretty-show, split, syb, tagged, tasty
-     , tasty-golden, text, xml
+     , tasty-golden, text, typst-symbols, xml
      }:
      mkDerivation {
        pname = "texmath";
-       version = "0.12.7.1";
-       sha256 = "0hpkc3vhwbn0ir7ri5a58pkjjybzcb6j4gm38bz3n2lj837ib9vx";
+       version = "0.12.8";
+       sha256 = "1i15hqzmvb00rhwiz7yiqbccg7zknk7rrx9xk16arf6rf43g0kq3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         base containers mtl pandoc-types parsec split syb text xml
+         base containers mtl pandoc-types parsec split syb text
+         typst-symbols xml
        ];
        testHaskellDepends = [
          base bytestring directory filepath pretty-show tagged tasty
···
      }:
      mkDerivation {
        pname = "text-show";
-       version = "3.10.2";
-       sha256 = "00vpyf753322fad02phkhc5njc3l2pnmw12lhyq67vganspsyd4w";
-       revision = "2";
-       editedCabalFile = "1scjd7gcl3kwv214hyyz6pppy8i46nigvy22945pi89n3ga0fqaz";
+       version = "3.10.3";
+       sha256 = "0f59cr1bqy2kbhdxxz1a86lf6masyy67f1i8kj1815df6rpgnshy";
        libraryHaskellDepends = [
          array base base-compat-batteries bifunctors bytestring
          bytestring-builder containers generic-deriving ghc-boot-th ghc-prim
···
        pname = "threadscope";
        version = "0.2.14.1";
        sha256 = "0hfn90299mp18p2bjj2bgfi1pk3ndxz4nv2ac6z52kvh00sr9drq";
+       revision = "1";
+       editedCabalFile = "11qpwvsic884nx2v2g2fw7i6n9905rjpj6lp150insh6cs88kqfc";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        ];
        description = "A graphical tool for profiling parallel Haskell programs";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
        mainProgram = "threadscope";
-       broken = true;
+       maintainers = [ lib.maintainers.maralorn ];
      }) {};
 
   "threefish" = callPackage
···
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        mainProgram = "tiger";
+       broken = true;
      }) {};
 
   "tight-apply" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "tls_1_6_0" = callPackage
+  "tls_1_7_0" = callPackage
     ({ mkDerivation, asn1-encoding, asn1-types, async, base, bytestring
-     , cereal, cryptonite, data-default-class, gauge, hourglass, memory
-     , mtl, network, QuickCheck, tasty, tasty-quickcheck, transformers
-     , x509, x509-store, x509-validation
+     , cereal, crypton, crypton-x509, crypton-x509-store
+     , crypton-x509-validation, data-default-class, gauge, hourglass
+     , memory, mtl, network, QuickCheck, tasty, tasty-quickcheck
+     , transformers, unix-time
      }:
      mkDerivation {
        pname = "tls";
-       version = "1.6.0";
-       sha256 = "1674i73dwha42ia1wlngi346lnfbag46w1wvqfim5f61q6pj17fj";
+       version = "1.7.0";
+       sha256 = "0y20ab42pa6ls799w8s6zda6r7q4bw25jghimzv68s6j0b4m0aiw";
        libraryHaskellDepends = [
-         asn1-encoding asn1-types async base bytestring cereal cryptonite
-         data-default-class hourglass memory mtl network transformers x509
-         x509-store x509-validation
+         asn1-encoding asn1-types async base bytestring cereal crypton
+         crypton-x509 crypton-x509-store crypton-x509-validation
+         data-default-class memory mtl network transformers unix-time
        ];
        testHaskellDepends = [
-         asn1-types async base bytestring cryptonite data-default-class
-         hourglass QuickCheck tasty tasty-quickcheck x509 x509-validation
+         asn1-types async base bytestring crypton crypton-x509
+         crypton-x509-validation data-default-class hourglass QuickCheck
+         tasty tasty-quickcheck
        ];
        benchmarkHaskellDepends = [
-         asn1-types async base bytestring cryptonite data-default-class
-         gauge hourglass QuickCheck tasty-quickcheck x509 x509-validation
+         asn1-types async base bytestring crypton crypton-x509
+         crypton-x509-validation data-default-class gauge hourglass
+         QuickCheck tasty-quickcheck
        ];
        description = "TLS/SSL protocol native implementation (Server and Client)";
        license = lib.licenses.bsd3;
···
   "tlynx" = callPackage
     ({ mkDerivation, aeson, async, attoparsec, base, bytestring
      , comonad, containers, data-default-class, elynx-tools, elynx-tree
-     , optparse-applicative, parallel, random, statistics, text
+     , gnuplot, optparse-applicative, parallel, random, statistics, text
      , transformers, vector
      }:
      mkDerivation {
        pname = "tlynx";
-       version = "0.7.2.0";
-       sha256 = "0zlm9hclhbfz9r31wrflx095p9qydq8qjg4fzrfyqmplvlqjwq62";
+       version = "0.7.2.1";
+       sha256 = "0v3lcmvd036mjsjyxlcixrxbf33f3bp4ijjcx2c1jhir109yvzxp";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson async attoparsec base bytestring comonad containers
-         data-default-class elynx-tools elynx-tree optparse-applicative
-         parallel random statistics text transformers vector
+         data-default-class elynx-tools elynx-tree gnuplot
+         optparse-applicative parallel random statistics text transformers
+         vector
        ];
        executableHaskellDepends = [ base ];
        description = "Handle phylogenetic trees";
···
        testToolDepends = [ sydtest-discover ];
        description = "A thread-safe concurrent token-bucket rate limiter that guarantees fairness";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "token-search" = callPackage
···
      }:
      mkDerivation {
        pname = "toml-reader";
-       version = "0.2.0.0";
-       sha256 = "0pajlx405cbb7c5bcq3r8hgqlmn16nqvraskplq9n9cc5xhw04xk";
-       revision = "1";
-       editedCabalFile = "0v03ssaa4kqa0i3wvl460028qhvlzfsqrqk6vbgcvsw6vxsnbh80";
+       version = "0.2.1.0";
+       sha256 = "1nq4f1a1gkm0xv1crq3fwp6xmr79kz6m4ls0nkj75mkcqk0mpd05";
        libraryHaskellDepends = [
          base containers megaparsec parser-combinators text time
        ];
···
        pname = "toysolver";
        version = "0.8.1";
        sha256 = "00f3x4rq8334g2923l338vzdz9jmf4amab16awr29bkj90h1ay5a";
+       revision = "1";
+       editedCabalFile = "05pgz4yqi5n2mqjsrzqqs7m2c2h7kis8d24map5arh385d0f9xwf";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "transaction";
-       version = "0.1.1.3";
-       sha256 = "1if04fm2kvkd25ksk1llqqkwaqy8y7pafbywmz70mrr68wrb2r6j";
+       version = "0.1.1.4";
+       sha256 = "0da6ahz08bay7qmqmsjdb5yqfxdxpjzkz6vhma1dbcf7c7qc89mf";
        libraryHaskellDepends = [ base mono-traversable ];
        testHaskellDepends = [
          base doctest Glob hspec mono-traversable QuickCheck
···
      }) {};
 
   "trie-simple" = callPackage
-    ({ mkDerivation, base, containers, criterion, deepseq, hspec, mtl
-     , mwc-random, QuickCheck, vector
+    ({ mkDerivation, base, containers, deepseq, gauge, hashable, hspec
+     , hspec-discover, indexed-traversable, matchable, mtl, mwc-random
+     , QuickCheck, semialign, these, vector, witherable
      }:
      mkDerivation {
        pname = "trie-simple";
-       version = "0.4.1.1";
-       sha256 = "0h3wfq4fjakkwvrv35l25709xv528h1c08cr754gvk4l8vqnk6k7";
-       revision = "6";
-       editedCabalFile = "0kzvdlp671x2bvab3scmv2pm805gdb33dw18cspdzgslrwr99ql4";
-       libraryHaskellDepends = [ base containers deepseq mtl ];
+       version = "0.4.2";
+       sha256 = "1ai4fn35312z6ydwadi0rxscglwqawjrzq6p1i2kpbf7vmflznjg";
+       libraryHaskellDepends = [
+         base containers deepseq hashable indexed-traversable matchable mtl
+         semialign these witherable
+       ];
        testHaskellDepends = [ base containers hspec QuickCheck vector ];
+       testToolDepends = [ hspec-discover ];
        benchmarkHaskellDepends = [
-         base containers criterion deepseq mwc-random vector
+         base containers deepseq gauge mwc-random vector
        ];
        description = "Simple Map-based Trie";
        license = lib.licenses.bsd3;
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "typst" = callPackage
+    ({ mkDerivation, aeson, array, base, bytestring, cassava
+     , containers, filepath, mtl, ordered-containers, parsec, pretty
+     , pretty-show, regex-tdfa, scientific, tasty, tasty-golden, text
+     , typst-symbols, vector, xml-conduit, yaml
+     }:
+     mkDerivation {
+       pname = "typst";
+       version = "0.1.0.0";
+       sha256 = "1vsfl9lijx01raz6fdi9mn5rvlpxbgb2q6ky37ahqn2pcd3r82m4";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson array base bytestring cassava containers filepath mtl
+         ordered-containers parsec pretty regex-tdfa scientific text
+         typst-symbols vector xml-conduit yaml
+       ];
+       testHaskellDepends = [
+         base bytestring filepath pretty-show tasty tasty-golden text
+       ];
+       description = "Parsing and evaluating typst syntax";
+       license = lib.licenses.bsd3;
+     }) {};
+
+  "typst-symbols" = callPackage
+    ({ mkDerivation, base, text }:
+     mkDerivation {
+       pname = "typst-symbols";
+       version = "0.1.0.1";
+       sha256 = "0kwdsp3j5qpfwaf2z91k7x9844bnb2wdm3v5ii9zkpnjmpxvbqph";
+       revision = "1";
+       editedCabalFile = "1z4f2ypk6askn5m9zcpla5cib7xliff2akp0bcs34lwqnr0ycjvr";
+       libraryHaskellDepends = [ base text ];
+       description = "Symbol and emoji lookup for typst language";
+       license = lib.licenses.mit;
+     }) {};
+
   "tyro" = callPackage
     ({ mkDerivation, aeson, base, bytestring, HUnit, protolude
      , reflection, singletons, test-framework, test-framework-hunit
···
        broken = true;
      }) {};
 
+  "unlifted" = callPackage
+    ({ mkDerivation, base, bytestring, text-short }:
+     mkDerivation {
+       pname = "unlifted";
+       version = "0.1.0.0";
+       sha256 = "1b8ms0im0d9y1lv76ap6255hf3sp7p6hbi0glf3jq5fk601mc6sy";
+       libraryHaskellDepends = [ base bytestring text-short ];
+       description = "Unlifted and levity-polymorphic types";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "unlifted-list" = callPackage
     ({ mkDerivation, base, ghc-prim, semigroups }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "unliftio";
-       version = "0.2.24.0";
-       sha256 = "16r2a26ig4j8crmvzbkbavszfaxghg7qhgm5z9q4aygc9jwbk2px";
+       version = "0.2.25.0";
+       sha256 = "0aqiia15p5y0jddk6fsb00das035f8x5cpkzrmc9x3z7j4ia51gv";
        libraryHaskellDepends = [
          async base bytestring deepseq directory filepath process
          safe-exceptions stm time transformers unix unliftio-core
···
        executableHaskellDepends = [ base uuagc-cabal ];
        description = "Attribute Grammar System of Universiteit Utrecht";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
        mainProgram = "uuagc";
      }) {};
 
···
        ];
        description = "Cabal plugin for UUAGC";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "uuagc-diagrams" = callPackage
···
        ];
        testHaskellDepends = [ base hedgehog HUnit lens semigroups ];
        description = "A data-type like Either but with an accumulating Applicative";
+       license = lib.licenses.bsd3;
+     }) {};
+
+  "validation-micro" = callPackage
+    ({ mkDerivation, base, deepseq }:
+     mkDerivation {
+       pname = "validation-micro";
+       version = "1.0.0.0";
+       sha256 = "1s51ln9iynfl8mm2x9mv2q5cwz6681df1569aaqj51jkw4fscgnz";
+       revision = "1";
+       editedCabalFile = "01x8dv57gi7p04s9mi14xik512j4mp1xjbqyabqda6x5vi6my6gw";
+       libraryHaskellDepends = [ base deepseq ];
+       description = "Lighweight pure data validation based on Applicative";
        license = lib.licenses.bsd3;
      }) {};
 
···
      }:
      mkDerivation {
        pname = "wai-token-bucket-ratelimiter";
-       version = "0.1.0.0";
-       sha256 = "1rgg6r3wym7l13b79yy0davl1isibrmfvn7yv4h6wv65s4iwvrjm";
+       version = "0.1.0.1";
+       sha256 = "1s5l0blfiyyj28qb3qrj4jb35xf1nwhgd1vsmnm8m9l9zjh04hch";
        libraryHaskellDepends = [
          base clock hashable http-types unordered-containers wai
        ];
···
        license = lib.licenses.mit;
      }) {};
 
-  "warp_3_3_25" = callPackage
+  "warp_3_3_27" = callPackage
     ({ mkDerivation, array, auto-update, base, bsb-http-chunked
-     , bytestring, case-insensitive, containers, directory, gauge
-     , ghc-prim, hashable, hspec, hspec-discover, http-client, http-date
-     , http-types, http2, iproute, network, process, QuickCheck, recv
-     , simple-sendfile, stm, streaming-commons, text, time-manager, unix
-     , unix-compat, unliftio, vault, wai, word8, x509
+     , bytestring, case-insensitive, containers, crypton-x509, directory
+     , gauge, ghc-prim, hashable, hspec, hspec-discover, http-client
+     , http-date, http-types, http2, iproute, network, process
+     , QuickCheck, recv, simple-sendfile, stm, streaming-commons, text
+     , time-manager, unix, unliftio, vault, wai, word8
      }:
      mkDerivation {
        pname = "warp";
-       version = "3.3.25";
-       sha256 = "1wa62inv7ai32jb88gr2vjiv1mh8gb96wc521y6mv2w967q1hzga";
+       version = "3.3.27";
+       sha256 = "067qxjsr9wkizv1dzpdsn48lgbrjrn35c1v4dwxv51wy48hbqzdv";
        libraryHaskellDepends = [
          array auto-update base bsb-http-chunked bytestring case-insensitive
-         containers ghc-prim hashable http-date http-types http2 iproute
-         network recv simple-sendfile stm streaming-commons text
-         time-manager unix unix-compat unliftio vault wai word8 x509
+         containers crypton-x509 ghc-prim hashable http-date http-types
+         http2 iproute network recv simple-sendfile stm streaming-commons
+         text time-manager unix unliftio vault wai word8
        ];
        testHaskellDepends = [
          array auto-update base bsb-http-chunked bytestring case-insensitive
-         containers directory ghc-prim hashable hspec http-client http-date
-         http-types http2 iproute network process QuickCheck recv
-         simple-sendfile stm streaming-commons text time-manager unix
-         unix-compat unliftio vault wai word8 x509
+         containers crypton-x509 directory ghc-prim hashable hspec
+         http-client http-date http-types http2 iproute network process
+         QuickCheck recv simple-sendfile stm streaming-commons text
+         time-manager unix unliftio vault wai word8
        ];
        testToolDepends = [ hspec-discover ];
        benchmarkHaskellDepends = [
-         auto-update base bytestring containers gauge hashable http-date
-         http-types network recv time-manager unix unix-compat unliftio x509
+         auto-update base bytestring containers crypton-x509 gauge hashable
+         http-date http-types network recv time-manager unix unliftio
        ];
        description = "A fast, light-weight web server for WAI applications";
        license = lib.licenses.mit;
···
        license = lib.licenses.mit;
      }) {};
 
-  "warp-tls_3_3_6" = callPackage
-       description = "PID control loop";
-     , network, recv, streaming-commons, tls, tls-session-manager
-     , unliftio, wai, warp
+  "warp-tls_3_4_0" = callPackage
+    ({ mkDerivation, base, bytestring, data-default-class, network
+     , recv, streaming-commons, tls, tls-session-manager, unliftio, wai
+     , warp
      }:
      mkDerivation {
        pname = "warp-tls";
-       version = "3.3.6";
-       sha256 = "1davjsbfvybcd78scaqzxfwnaqmja4j7j3qbcdbb50gv1d87105f";
+       version = "3.4.0";
+       sha256 = "1pf3dlqjdybzza9sfs14r4vn63s15m7rpv83v27illbv2fs4a0b2";
        libraryHaskellDepends = [
-         base bytestring cryptonite data-default-class network recv
-         streaming-commons tls tls-session-manager unliftio wai warp
+         base bytestring data-default-class network recv streaming-commons
+         tls tls-session-manager unliftio wai warp
        ];
        description = "HTTP over TLS support for Warp via the TLS package";
        license = lib.licenses.mit;
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "webdriver_0_11_0_0" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
+     , bytestring, call-stack, data-default-class, directory
+     , directory-tree, exceptions, filepath, http-client, http-types
+     , lifted-base, monad-control, network, network-uri, scientific
+     , temporary, text, time, transformers, transformers-base
+     , unordered-containers, vector, zip-archive
+     }:
+     mkDerivation {
+       pname = "webdriver";
+       version = "0.11.0.0";
+       sha256 = "0d9j0bw6znjsgxz2rqjrpcyybrn50nyz9pj5ajmpgs0pmgx0zbc2";
+       libraryHaskellDepends = [
+         aeson attoparsec base base64-bytestring bytestring call-stack
+         data-default-class directory directory-tree exceptions filepath
+         http-client http-types lifted-base monad-control network
+         network-uri scientific temporary text time transformers
+         transformers-base unordered-containers vector zip-archive
+       ];
+       description = "a Haskell client for the Selenium WebDriver protocol";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "webdriver-angular" = callPackage
     ({ mkDerivation, aeson, base, hspec, hspec-webdriver
      , language-javascript, template-haskell, text, transformers
···
        pname = "wizards";
        version = "1.0.3";
        sha256 = "1clvbd1ckhvy29qrbmpkn7bya7300fq6znnps23nn3nxyrxhsr85";
-       revision = "1";
-       editedCabalFile = "095qd17zrdhqmcvmslbyzfa5sh9glvvsnsvnlz31gzsmi8nnsgim";
+       revision = "2";
+       editedCabalFile = "0bnqz6slm3hr98ihhlkmivcd12bda6lf0j7l6dfdz30fl4xqpijl";
        libraryHaskellDepends = [
          base containers control-monad-free haskeline mtl transformers
        ];
···
        license = lib.licenses.mit;
      }) {};
 
+  "wuss_2_0_1_4" = callPackage
+    ({ mkDerivation, base, bytestring, crypton-connection, exceptions
+     , network, websockets
+     }:
+     mkDerivation {
+       pname = "wuss";
+       version = "2.0.1.4";
+       sha256 = "0hm4rj7mx5zjmg2yr3zq462zw60nqaqrs91k71kgnxhnkcpbszav";
+       libraryHaskellDepends = [
+         base bytestring crypton-connection exceptions network websockets
+       ];
+       description = "Secure WebSocket (WSS) clients";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "wx" = callPackage
     ({ mkDerivation, base, stm, time, wxcore }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "xcffib";
-       version = "1.3.0";
-       sha256 = "0qj3h8j3qjqxjv2jjcywns7lb9xpnmm4rkz4gxczn9h0i868pbch";
+       version = "1.4.0";
+       sha256 = "08066j1rvinkifnak22w78p4lf7war607vfk1qj6j90glr0nzs45";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "xrefcheck";
        version = "0.2.2";
        sha256 = "0qyl2wislma25s3n5aaqd732a2p7i9lsv4fvydm121a4r5sc5j4h";
+       revision = "1";
+       editedCabalFile = "1ph8x7clk3i6y8bvqn2v0fpkbvr3afna7qwx7rnc015rs8jdyalm";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "yaml";
-       version = "0.11.11.0";
-       sha256 = "08q0b0qq98ip2v34lygdp2i0yc5cmny34w4w59fcsd71s85w15ac";
+       version = "0.11.11.1";
+       sha256 = "0j7xa3bgznaj35x3x184c0dy6hjflxkdwp3iprfnhmz2ds2dr790";
        configureFlags = [ "-fsystem-libyaml" ];
        isLibrary = true;
        isExecutable = true;
···
        pname = "yaml-streamly";
        version = "0.12.2";
        sha256 = "0bjagj6bg884xchx8dkrhqikjmwqzpb8hkjlxvbxnsmsmwnc22cx";
+       revision = "1";
+       editedCabalFile = "1b600ki3w67xi9jfbmrfzf9q3d3wz1dc0hgl9lyq6vjfm6ngdrg2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "yampa-test";
-       version = "0.14.2";
-       sha256 = "08j923m374jr3kv6jyfrq7kba8y7hcq80xw8a7mhkif0l8w2rgxa";
+       version = "0.14.3";
+       sha256 = "1r4kjf1ww4gfw310c1srcglxyd34c5qf3rb7xqpncjagvsh027xy";
        libraryHaskellDepends = [
          base normaldistribution QuickCheck Yampa
        ];
···
      }) {};
 
   "yesod-auth-oidc" = callPackage
-    ({ mkDerivation, aeson, base, base64-bytestring, blaze-html, broch
-     , bytestring, classy-prelude, classy-prelude-yesod, containers
-     , cryptonite, directory, email-validate, fast-logger, hspec
-     , hspec-discover, http-client, http-conduit, http-types, jose-jwt
-     , lens, lens-regex-pcre, memory, monad-logger, oidc-client
-     , persistent, persistent-sqlite, postgresql-simple, reroute
-     , resource-pool, shakespeare, sqlite-simple, text, time
-     , unordered-containers, wai-app-static, wai-extra, warp, yesod
-     , yesod-auth, yesod-core, yesod-form, yesod-persistent, yesod-test
+    ({ mkDerivation, aeson, base, base64-bytestring
+     , classy-prelude-yesod, containers, cryptonite, http-client
+     , jose-jwt, oidc-client, shakespeare, text, time
+     , unordered-containers, yesod-auth, yesod-core, yesod-form
      }:
      mkDerivation {
        pname = "yesod-auth-oidc";
-       version = "0.1.1";
-       sha256 = "12x4wypjmqvlz2y59j1p9ckf7pgl1sz3zz45xzhqa6axzzf6ln20";
-       isLibrary = true;
-       isExecutable = true;
+       version = "0.1.4";
+       sha256 = "0f58ppi96d1jhxydingxg1fi9iwz8f10fsg0795j65kwcf5rwkhm";
        libraryHaskellDepends = [
          aeson base base64-bytestring classy-prelude-yesod containers
          cryptonite http-client jose-jwt oidc-client shakespeare text time
          unordered-containers yesod-auth yesod-core yesod-form
        ];
-       executableHaskellDepends = [
-         aeson base base64-bytestring blaze-html broch bytestring
-         classy-prelude classy-prelude-yesod containers cryptonite directory
-         email-validate fast-logger hspec http-client http-conduit
-         http-types jose-jwt lens lens-regex-pcre memory monad-logger
-         oidc-client persistent persistent-sqlite postgresql-simple reroute
-         resource-pool shakespeare sqlite-simple text time
-         unordered-containers wai-app-static wai-extra warp yesod yesod-auth
-         yesod-core yesod-form yesod-persistent yesod-test
-       ];
-       testHaskellDepends = [
-         aeson base base64-bytestring blaze-html broch bytestring
-         classy-prelude classy-prelude-yesod containers cryptonite directory
-         email-validate fast-logger hspec http-client http-conduit
-         http-types jose-jwt lens lens-regex-pcre memory monad-logger
-         oidc-client persistent persistent-sqlite postgresql-simple reroute
-         resource-pool shakespeare sqlite-simple text time
-         unordered-containers wai-app-static wai-extra warp yesod yesod-auth
-         yesod-core yesod-form yesod-persistent yesod-test
-       ];
-       testToolDepends = [ hspec-discover ];
        description = "A yesod-auth plugin for multi-tenant SSO via OpenID Connect";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       mainProgram = "yesod-auth-oidc-test";
-       broken = true;
-     }) {broch = null;};
+     }) {};
 
   "yesod-auth-pam" = callPackage
     ({ mkDerivation, base, hamlet, pam, text, yesod-auth, yesod-core
···
      }:
      mkDerivation {
        pname = "yesod-middleware-csp";
-       version = "1.1.0";
-       sha256 = "1jrfd8r7xvyc556q04qvrib1rwwlsy0rnbc7nxrnqpvn1wv1pb0q";
+       version = "1.2.0";
+       sha256 = "1mjcz9qx5pichmi19m5bdibv8945l781xkyiyr3mbvyxab3f79w8";
        libraryHaskellDepends = [
          base base64-bytestring bytestring classy-prelude conduit containers
          directory filepath http-client network-uri template-haskell text

pkgs/development/haskell-modules/with-packages-wrapper.nix

···
   libDir        = if isHaLVM then "$out/lib/HaLVM-${ghc.version}"
                   else "$out/lib/${ghc.targetPrefix}${ghc.haskellCompilerName}"
                     + lib.optionalString (ghc ? hadrian) "/lib";
+  # Boot libraries for GHC are present in a separate directory.
+  bootLibDir    = let arch = if stdenv.targetPlatform.isAarch64
+                             then "aarch64"
+                             else "x86_64";
+                      platform = if stdenv.targetPlatform.isDarwin then "osx" else "linux";
+                  in "${ghc}/lib/${ghc.haskellCompilerName}/lib/${arch}-${platform}-${ghc.haskellCompilerName}";
   docDir        = "$out/share/doc/ghc/html";
   packageCfgDir = "${libDir}/package.conf.d";
   paths         = lib.concatLists (
···
   '' + (lib.optionalString (stdenv.targetPlatform.isDarwin && !isGhcjs && !stdenv.targetPlatform.isiOS) ''
     # Work around a linker limit in macOS Sierra (see generic-builder.nix):
     local packageConfDir="${packageCfgDir}";
-    local dynamicLinksDir="$out/lib/links"
+    local dynamicLinksDir="$out/lib/links";
     mkdir -p $dynamicLinksDir
     # Clean up the old links that may have been (transitively) included by
     # symlinkJoin:
     rm -f $dynamicLinksDir/*
+
+    # Boot libraries are located differently than other libraries since GHC 9.6, so handle them separately.
+    if [[ -x "${bootLibDir}" ]]; then
+      ln -s "${bootLibDir}"/*.dylib $dynamicLinksDir
+    fi
+
     for d in $(grep -Poz "dynamic-library-dirs:\s*\K .+\n" $packageConfDir/*|awk '{print $2}'|sort -u); do
       ln -s $d/*.dylib $dynamicLinksDir
     done
···
       # $dynamicLinksDir
       cp $f $f-tmp
       rm $f
-      sed "N;s,dynamic-library-dirs:\s*.*,dynamic-library-dirs: $dynamicLinksDir," $f-tmp > $f
+      sed "N;s,dynamic-library-dirs:\s*.*\n,dynamic-library-dirs: $dynamicLinksDir\n," $f-tmp > $f
       rm $f-tmp
     done
   '') + ''

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

···
+{ lib
+, buildPythonPackage
+, fetchFromGitHub
+, looseversion
+, mmtf-python
+, nose
+, numpy
+, pandas
+, pythonRelaxDepsHook
+}:
+
+buildPythonPackage rec {
+  pname = "biopandas";
+  version = "0.4.1";
+  format = "setuptools";
+
+  src = fetchFromGitHub {
+    owner = "BioPandas";
+    repo = "biopandas";
+    rev = "refs/tags/v${version}";
+    hash = "sha256-PRdemBo+bB2xJWmF2NylFTfNwEEo67i6XSaeDAFmQ/c=";
+  };
+
+  nativeBuildInputs = [
+    pythonRelaxDepsHook
+  ];
+
+  pythonRelaxDeps = [
+    "looseversion"
+  ];
+
+  propagatedBuildInputs = [
+    numpy
+    pandas
+    mmtf-python
+    looseversion
+  ];
+
+  nativeCheckInputs = [
+    nose
+  ];
+
+  checkPhase = ''
+    runHook preCheck
+
+    nosetests
+
+    runHook postCheck
+  '';
+
+  pythonImportsCheck = [
+    "biopandas"
+  ];
+
+  meta = {
+    description = "Working with molecular structures in pandas DataFrames";
+    homepage = "https://github.com/BioPandas/biopandas";
+    changelog = "https://github.com/BioPandas/biopandas/releases/tag/${src.rev}";
+    license = lib.licenses.bsd3;
+    maintainers = with lib.maintainers; [ natsukium ];
+  };
+}

pkgs/development/python-modules/clarifai-grpc/default.nix

···
+{ lib
+, buildPythonPackage
+, fetchPypi
+, pythonOlder
+, googleapis-common-protos
+, grpcio
+, protobuf
+, requests
+}:
+
+buildPythonPackage rec {
+  pname = "clarifai-grpc";
+  version = "9.5.0";
+  format = "setuptools";
+
+  disabled = pythonOlder "3.8";
+
+  src = fetchPypi {
+    inherit pname version;
+    hash = "sha256-amMUgRXtvcrALfWwat7W0W60FJQnEeMvHhyxxBCMqUg=";
+  };
+
+  propagatedBuildInputs = [
+    googleapis-common-protos
+    grpcio
+    protobuf
+    requests
+  ];
+
+  # almost all tests require network access
+  doCheck = false;
+
+  pythonImportsCheck = [ "clarifai_grpc" ];
+
+  meta = with lib; {
+    description = "Clarifai gRPC API Client";
+    homepage = "https://github.com/Clarifai/clarifai-python-grpc";
+    changelog = "https://github.com/Clarifai/clarifai-python-grpc/releases/tag/${version}";
+    license = licenses.asl20;
+    maintainers = with maintainers; [ natsukium ];
+  };
+}

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

···
+{ lib
+, buildPythonPackage
+, fetchFromGitHub
+, pythonOlder
+, clarifai-grpc
+, pytestCheckHook
+}:
+
+buildPythonPackage rec {
+  pname = "clarifai";
+  version = "9.5.2";
+  format = "setuptools";
+
+  disabled = pythonOlder "3.8";
+
+  src = fetchFromGitHub {
+    owner = "Clarifai";
+    repo = "clarifai-python-utils";
+    rev = "refs/tags/${version}";
+    hash = "sha256-29by0YAQ7qc0gL/3lAFOk4FLDB5Qv4X9QDyK49gfyAo=";
+  };
+
+  propagatedBuildInputs = [
+    clarifai-grpc
+  ];
+
+  nativeCheckInputs = [
+    pytestCheckHook
+  ];
+
+  pythonImportsCheck = [ "clarifai" ];
+
+  meta = with lib; {
+    description = "Clarifai Python Utilities";
+    homepage = "https://github.com/Clarifai/clarifai-python-utils";
+    changelog = "https://github.com/Clarifai/clarifai-python-utils/releases/tag/${src.rev}";
+    license = licenses.asl20;
+    maintainers = with maintainers; [ natsukium ];
+  };
+}

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

···
 , bash
   # optional dependencies
 , anthropic
+, clarifai
 , cohere
 , openai
 , nlpcloud
···
 , faiss
 , spacy
 , nltk
+, wikipedia
 , beautifulsoup4
 , tiktoken
 , jinja2
···
 
 buildPythonPackage rec {
   pname = "langchain";
-  version = "0.0.216";
+  version = "0.0.218";
   format = "pyproject";
 
   disabled = pythonOlder "3.8";
···
     owner = "hwchase17";
     repo = "langchain";
     rev = "refs/tags/v${version}";
-    hash = "sha256-g01EMquASxXl9drLhKtTwG9+gSa17aBq0c8UXcErCjI=";
+    hash = "sha256-8ru3Rp1bRLVivfXAFNfZYfV3DgHuHNEuCrKoqL1O0zo=";
   };
 
   postPatch = ''
···
   passthru.optional-dependencies = {
     llms = [
       anthropic
+      clarifai
       cohere
       openai
       nlpcloud
···
     text_helpers = [
       chardet
     ];
+    clarifai = [
+      clarifai
+    ];
     cohere = [
       cohere
     ];
···
     ];
     all = [
       anthropic
+      clarifai
       cohere
       openai
       nlpcloud
···
       transformers
       spacy
       nltk
-      # wikipedia
+      wikipedia
       beautifulsoup4
       tiktoken
       torch

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

···
+{ lib
+, buildPythonPackage
+, fetchFromGitHub
+, pythonOlder
+, setuptools
+, typing-extensions
+, orjson
+, msgpack
+, pyyaml
+, tomli-w
+, tomli
+, pytestCheckHook
+, ciso8601
+, pendulum
+, pytest-mock
+}:
+
+buildPythonPackage rec {
+  pname = "mashumaro";
+  version = "3.8.1";
+  format = "pyproject";
+  disabled = pythonOlder "3.7";
+
+  src = fetchFromGitHub {
+    owner = "Fatal1ty";
+    repo = pname;
+    rev = "refs/tags/v${version}";
+    hash = "sha256-WDKohmcdVlQR/6AMSISN0y6UQx4tmOf1fANCPLRYiqI=";
+  };
+
+  nativeBuildInputs = [
+    setuptools
+  ];
+
+  propagatedBuildInputs = [
+    typing-extensions
+  ];
+
+  passthru.optional-dependencies = {
+    orjson = [ orjson ];
+    msgpack = [ msgpack ];
+    yaml = [ pyyaml ];
+    toml = [ tomli-w ] ++ lib.optionals (pythonOlder "3.11") [ tomli ];
+  };
+
+  nativeCheckInputs = [
+    ciso8601
+    pendulum
+    pytest-mock
+    pytestCheckHook
+  ] ++ lib.flatten (lib.attrValues passthru.optional-dependencies);
+
+  pythonImportsCheck = [
+    "mashumaro"
+  ];
+
+  meta = with lib; {
+    description = "Fast and well tested serialization library on top of dataclasses";
+    homepage = "https://github.com/Fatal1ty/mashumaro";
+    changelog = "https://github.com/Fatal1ty/mashumaro/releases/tag/v${version}";
+    license = licenses.asl20;
+    maintainers = with maintainers; [ tjni ];
+  };
+}

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

···
+{ lib
+, buildPythonPackage
+, fetchPypi
+, msgpack
+, numpy
+, unittestCheckHook
+}:
+
+buildPythonPackage rec {
+  pname = "mmtf-python";
+  version = "1.1.3";
+  format = "setuptools";
+
+  src = fetchPypi {
+    inherit pname version;
+    hash = "sha256-EqAv4bcTHworjORbRvHgzdKLmBj+RJlVTCaISYfqDDI=";
+  };
+
+  propagatedBuildInputs = [
+    msgpack
+    numpy
+  ];
+
+  nativeCheckInputs = [
+    unittestCheckHook
+  ];
+
+  unittestFlagsArray = [
+    "-s mmtf/tests"
+    "-p \"*_tests.py\""
+  ];
+
+  pythonImportsCheck = [
+    "mmtf"
+  ];
+
+  meta = {
+    description = "The python implementation of the MMTF API, decoder and encoder";
+    homepage = "https://github.com/rcsb/mmtf-python";
+    changelog = "https://github.com/rcsb/mmtf-python/releases/tag/v${version}";
+    license = lib.licenses.asl20;
+    maintainers = with lib.maintainers; [ natsukium ];
+  };
+}

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

···
 
 buildPythonPackage rec {
   pname = "openhomedevice";
-  version = "2.1";
+  version = "2.2";
   format = "setuptools";
 
   disabled = pythonOlder "3.5";
···
     owner = "bazwilliams";
     repo = pname;
     rev = "refs/tags/${version}";
-    hash = "sha256-KNQelldqHx4m8IfgGUwWw/+AVzBotIa7cJGy1SfbRy0=";
+    hash = "sha256-GGp7nKFH01m1KW6yMkKlAdd26bDi8JDWva6OQ0CWMIw=";
   };
 
   propagatedBuildInputs = [

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

···
-{ lib
-, buildPythonPackage
-, fetchFromGitHub
-, scipy
-, numpy
-, numba
-, scikit-learn
-, pytest
-, pythonOlder
-}:
-
-buildPythonPackage rec {
-  pname = "pygbm";
-  version = "0.1.0";
-  disabled = pythonOlder "3.6";
-
-  src = fetchFromGitHub {
-    owner = "ogrisel";
-    repo = pname;
-    rev = "v${version}";
-    sha256 = "1qg2md86d0z5aa6jn8kj3rxsippsqsccx1dbraspdsdkycncvww3";
-  };
-
-  propagatedBuildInputs = [
-    scipy
-    numpy
-    numba
-    scikit-learn
-  ];
-
-  nativeCheckInputs = [
-    pytest
-  ];
-
-  checkPhase = ''
-    # numerical rounding error in test
-    pytest -k "not test_derivatives"
-  '';
-
-  meta = with lib; {
-    description = "Experimental Gradient Boosting Machines in Python";
-    homepage = "https://github.com/ogrisel/pygbm";
-    license = licenses.mit;
-    maintainers = [ maintainers.costrouc ];
-    broken = true;
-  };
-}

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

···
 , mpi4py
 , numpy
 , precice
+, pkgconfig
 , pythonOlder
 }:
 
···
 
   nativeBuildInputs = [
     cython
+    pkgconfig
   ];
 
   propagatedBuildInputs = [

pkgs/development/python-modules/pytest-ordering/default.nix

···
-{ lib, fetchFromGitHub, buildPythonPackage
-, pytest }:
-
-buildPythonPackage rec {
-  pname = "pytest-ordering";
-  version = "unstable-2019-06-19";
-
-  # Pypi lacks tests/
-  # Resolves PytestUnknownMarkWarning from pytest
-  src = fetchFromGitHub {
-    owner = "ftobia";
-    repo = pname;
-    rev = "492697ee26633cc31d329c1ceaa468375ee8ee9c";
-    sha256 = "1xim0kj5g37p1skgvp8gdylpx949krmx60w3pw6j1m1h7sakmddn";
-  };
-
-  nativeCheckInputs = [
-    pytest
-  ];
-
-  checkPhase = ''
-    pytest tests
-  '';
-
-  meta = with lib; {
-    homepage = "https://github.com/ftobia/pytest-ordering";
-    description = "Pytest plugin to run your tests in a specific order";
-    license = licenses.mit;
-    broken = true;  # See https://github.com/NixOS/nixpkgs/pull/122264
-    maintainers = with maintainers; [ eadwu ];
-  };
-}

pkgs/development/python-modules/pytest-sanic/default.nix

···
-{ lib
-, aiohttp
-, async_generator
-, buildPythonPackage
-, fetchFromGitHub
-, httpx
-, pytest
-, pytestCheckHook
-, sanic
-, websockets
-}:
-
-buildPythonPackage rec {
-  pname = "pytest-sanic";
-  version = "1.9.1";
-
-  src = fetchFromGitHub {
-    owner = "yunstanford";
-    repo = pname;
-    rev = "v${version}";
-    hash = "sha256-82Xq/jyxTXyZVHqn7G+S9K++InDdORCO9oFqgaIgY7s=";
-  };
-
-  buildInputs = [
-    pytest
-  ];
-
-  propagatedBuildInputs = [
-    aiohttp
-    async_generator
-    httpx
-    pytest
-    websockets
-  ];
-
-  nativeCheckInputs = [
-    sanic
-    pytestCheckHook
-  ];
-
-  pythonImportsCheck = [
-    "pytest_sanic"
-  ];
-
-  meta = with lib; {
-    description = "A pytest plugin for Sanic";
-    homepage = "https://github.com/yunstanford/pytest-sanic/";
-    license = licenses.asl20;
-    maintainers = with maintainers; [ costrouc ];
-    broken = true; # 2021-11-04
-  };
-}

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

···
+{ lib
+, buildPythonPackage
+, fetchPypi
+, beautifulsoup4
+, requests
+, unittestCheckHook
+}:
+
+buildPythonPackage rec {
+  pname = "wikipedia";
+  version = "1.4.0";
+  format = "setuptools";
+
+  src = fetchPypi {
+    inherit pname version;
+    hash = "sha256-2w+tGCn91EGxhSMG6YVjmCBNwHhtKZbdLgyLuOJhM7I=";
+  };
+
+  propagatedBuildInputs = [
+    beautifulsoup4
+    requests
+  ];
+
+  nativeCheckInputs = [
+    unittestCheckHook
+  ];
+
+  unittestFlagsArray = [
+    "tests/ '*test.py'"
+  ];
+
+  meta = with lib; {
+    description = "A Pythonic wrapper for the Wikipedia API";
+    homepage = "https://github.com/goldsmith/Wikipedia";
+    changelog = "https://github.com/goldsmith/Wikipedia/blob/master/CHANGELOG.md";
+    license = licenses.mit;
+    maintainers = with maintainers; [ natsukium ];
+  };
+}

pkgs/development/tools/bearer/default.nix

···
 
 buildGoModule rec {
   pname = "bearer";
-  version = "1.11.0";
+  version = "1.14.0";
 
   src = fetchFromGitHub {
     owner = "bearer";
     repo = "bearer";
     rev = "refs/tags/v${version}";
-    hash = "sha256-JbxITOF+6LxITA1Ujy9ZbCO9vSym/qfbEascKDvogJk=";
+    hash = "sha256-7h+7lP4K4Dbf5V2HDrb2lJKWqINtOpqybBAyae0S6EE=";
   };
 
-  vendorHash = "sha256-MKfD6RBMaCxB09SX0FlH+mJnzXyw2KkkOnVvBTMdb/w=";
+  vendorHash = "sha256-D8LdufbOx3ogLbeSwBTsDnQ4NpZF+Ro2QiUg4hPGGYI=";
 
   subPackages = [
     "cmd/bearer"

pkgs/development/tools/oh-my-posh/default.nix

···
 
 buildGoModule rec {
   pname = "oh-my-posh";
-  version = "17.4.0";
+  version = "17.5.2";
 
   src = fetchFromGitHub {
     owner = "jandedobbeleer";
     repo = pname;
     rev = "refs/tags/v${version}";
-    hash = "sha256-dcQj9VPHPMg6Ht6EBz4nCv76xcQ7xqxvDH/KfFPQsqU=";
+    hash = "sha256-WNB4NzOvabShVHivDs027y6QmU71GMrYJehCB9jPlA8=";
   };
 
-  vendorHash = "sha256-tEOEFCKR4qqqnyfpAEMw5WQdOok4SFZAqsMc1+H5CCU=";
+  vendorHash = "sha256-fHwaCcN47+LkJYqRFSQgVddVuR1QfdFuSNDYFh1edM4=";
 
   sourceRoot = "source/src";
 

pkgs/development/tools/parsing/tree-sitter/default.nix

···
         { tree-sitter-typescript = grammars'.tree-sitter-typescript // { location = "typescript"; }; } //
         { tree-sitter-tsx = grammars'.tree-sitter-typescript // { location = "tsx"; }; } //
         { tree-sitter-markdown = grammars'.tree-sitter-markdown // { location = "tree-sitter-markdown"; }; } //
-        { tree-sitter-markdown-inline = grammars'.tree-sitter-markdown // { language = "markdown_inline"; location = "tree-sitter-markdown-inline"; }; };
+        { tree-sitter-markdown-inline = grammars'.tree-sitter-markdown // { language = "markdown_inline"; location = "tree-sitter-markdown-inline"; }; } //
+        { tree-sitter-wing = grammars'.tree-sitter-wing // { location = "libs/tree-sitter-wing"; generate = true; }; };
     in
     lib.mapAttrs build (grammars);
 

pkgs/development/tools/parsing/tree-sitter/grammars/default.nix

···
   tree-sitter-verilog = lib.importJSON ./tree-sitter-verilog.json;
   tree-sitter-vim = lib.importJSON ./tree-sitter-vim.json;
   tree-sitter-vue = lib.importJSON ./tree-sitter-vue.json;
+  tree-sitter-wing = lib.importJSON ./tree-sitter-wing.json;
   tree-sitter-yaml = lib.importJSON ./tree-sitter-yaml.json;
   tree-sitter-yang = lib.importJSON ./tree-sitter-yang.json;
   tree-sitter-zig = lib.importJSON ./tree-sitter-zig.json;

pkgs/development/tools/parsing/tree-sitter/grammars/tree-sitter-wing.json

···
+{
+  "url": "https://github.com/winglang/wing",
+  "rev": "e578973d6f60091ba3458095edceb37bae2d04e2",
+  "date": "2023-06-27T12:28:26+00:00",
+  "path": "/nix/store/ppjabjz0dgmsr3k0wm07z7391vz7m120-wing",
+  "sha256": "0089rxdzxi43qal2310dpyzw1a3zl08qbm5b8md8cgwmvycija9a",
+  "fetchLFS": false,
+  "fetchSubmodules": false,
+  "deepClone": false,
+  "leaveDotGit": false
+}

pkgs/development/tools/parsing/tree-sitter/update.nix

···
       orga = "eonpatapon";
       repo = "tree-sitter-cue";
     };
+    "tree-sitter-wing" = {
+      orga = "winglang";
+      repo = "wing";
+    };
   };
 
   allGrammars =

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

···
 
 rustPlatform.buildRustPackage rec {
   pname = "cargo-binstall";
-  version = "0.23.1";
+  version = "1.0.0";
 
   src = fetchFromGitHub {
     owner = "cargo-bins";
     repo = "cargo-binstall";
     rev = "v${version}";
-    hash = "sha256-Dpo/J6FTW95rODWeIqD+8YnN4dt5yhLPxoezA1CTM4A=";
+    hash = "sha256-43AXxTuHwaNLDTDmLps/HbRvQFWyUgLQhTrxHtQCk3k=";
   };
 
-  cargoHash = "sha256-Nc/kdrLsAooM41pwlkZ3zWsLvFlnxHG/2ZQhPsEyPkI=";
+  cargoHash = "sha256-F26wjIsBjQ+z+sHGzE7PdYOZi7XwStlOXfbK/lpepDY=";
 
   nativeBuildInputs = [
     pkg-config
···
   buildNoDefaultFeatures = true;
   buildFeatures = [
     "fancy-no-backtrace"
+    "git"
     "pkg-config"
     "rustls"
     "trust-dns"
···
     "--skip=gh_api_client::test::test_gh_api_client_cargo_binstall_no_such_release"
     "--skip=gh_api_client::test::test_gh_api_client_cargo_binstall_v0_20_1"
   ];
-
-  # remove cargo config so it can find the linker on aarch64-unknown-linux-gnu
-  postPatch = ''
-    rm .cargo/config
-  '';
 
   meta = with lib; {
     description = "A tool for installing rust binaries as an alternative to building from source";

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

···
 
 rustPlatform.buildRustPackage rec {
   pname = "cargo-vet";
-  version = "0.7.0";
+  version = "0.8.0";
 
   src = fetchFromGitHub {
     owner = "mozilla";
     repo = pname;
     rev = version;
-    sha256 = "sha256-URTWfV/weXWvgaZv7RWKqr7w3dnad2Pr5wNv0rcm2eg=";
+    sha256 = "sha256-VnOqQ1dKgNZSHTzJrD7stoCzNGrSkYxcLDJAsrJUsEQ=";
   };
 
-  cargoSha256 = "sha256-cnxVcq5v6MXH7hrdT4kE+8DxJY5z2fGCF3G6GGJx8pw=";
+  cargoSha256 = "sha256-M8sZzgSEMIB6pPVaE+tC18MCbwYaYpHOnhrEvm9JTso=";
 
   buildInputs = lib.optional stdenv.isDarwin Security;
 

pkgs/development/tools/sq/default.nix

···
 
 buildGoModule rec {
   pname = "sq";
-  version = "0.38.0";
+  version = "0.39.1";
 
   src = fetchFromGitHub {
     owner = "neilotoole";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-h8rCHtBTckLjRxi79N26pYiCJSI/UKUbwUTsQXD7Sco=";
+    sha256 = "sha256-Icx7IhMRbud2gCyMvjuYM9CipzAH39X+bC4AEwVheVQ=";
   };
 
-  vendorHash = "sha256-VcqCscheXYgWT88ZExJWdwRMT5Ir0C49S5+Hp557jiw=";
+  vendorHash = "sha256-xaUjkUWmYfvYGgWgKiMhgi50ws0VhNNqzBwQ2WzDkas=";
 
   proxyVendor = true;
 

pkgs/development/tools/xcodes/default.nix

···
 
 stdenv.mkDerivation (finalAttrs: {
   pname = "xcodes";
-  version = "1.3.0";
+  version = "1.4.1";
 
   src = fetchurl {
     url = "https://github.com/XcodesOrg/xcodes/releases/download/${finalAttrs.version}/xcodes.zip";
-    hash = "sha256:0cqb0gfb80xrnm4fipr46kbzqz2kicc13afhdxkbifzm4k83any5";
+    hash = "sha256-PtXF2eqNfEX29EtXlcjdxrUs7BPn/YurUuFFeLpXwrk=";
   };
 
   nativeBuildInputs = [ unzip ];
···
   dontFixup = true;
 
   meta = with lib; {
+    changelog = "https://github.com/XcodesOrg/xcodes/releases/tag/${finalAttrs.version}";
     description = "Command-line tool to install and switch between multiple versions of Xcode";
     homepage = "https://github.com/XcodesOrg/xcodes";
     license = licenses.mit;

pkgs/games/rare/default.nix

···
 
 buildPythonApplication rec {
   pname = "rare";
-  version = "1.9.4";
+  version = "1.10.3";
 
   src = fetchFromGitHub {
     owner = "Dummerle";
     repo = "Rare";
     rev = "refs/tags/${version}";
-    sha256 = "sha256-+STwVsDdvjP7HaqmaQVug+6h0n0rw/j4LGQQSNdLVQQ=";
+    hash = "sha256-7KER9gCpqjEKikQTVHsvwX6efCb9L0ut6OBjjLBW2tI=";
   };
 
   nativeBuildInputs = [
···
   ];
 
   patches = [
-    ./fix-instance.patch
     # Not able to run pythonRelaxDepsHook because of https://github.com/NixOS/nixpkgs/issues/198342
     ./legendary-gl-version.patch
   ];

pkgs/games/rare/fix-instance.patch

···
-diff --git a/rare/utils/misc.py b/rare/utils/misc.py
-index 4492074..5352dac 100644
---- a/rare/utils/misc.py
-+++ b/rare/utils/misc.py
-@@ -190,6 +190,7 @@ def get_rare_executable() -> List[str]:
-         executable = [sys.executable]
- 
-     executable[0] = os.path.abspath(executable[0])
-+    executable.pop(0)
-     return executable

pkgs/games/rare/legendary-gl-version.patch

···
  
  requirements = [
      "requests<3.0",
--    "legendary-gl==0.20.31",
-+    "legendary-gl~=0.20.31",
+-    "legendary-gl==0.20.32",
++    "legendary-gl~=0.20.32",
      "setuptools",
      "wheel",
      "PyQt5",

pkgs/misc/lssecret/default.nix

···
+{ lib
+, stdenv
+, fetchFromGitLab
+, pkg-config
+, libsecret
+}:
+
+stdenv.mkDerivation rec {
+  name = "lssecret";
+  version = "unstable-2022-12-02";
+
+  src = fetchFromGitLab {
+    owner = "GrantMoyer";
+    repo = name;
+    rev = "20fd771a";
+    hash = "sha256-yU70WZj4EC/sFJxyq2SQ0YQ6RCQHYiW/aQiYWo7+ujk=";
+  };
+
+  nativeBuildInputs = [ pkg-config ];
+  buildInputs = [ libsecret ];
+
+  makeFlags = ["DESTDIR=$(out)"];
+
+  meta = {
+    description = "A tool to list passwords and other secrets stored using the org.freedesktop.secrets dbus api";
+    homepage = "https://gitlab.com/GrantMoyer/lssecret";
+    license = lib.licenses.unlicense;
+    maintainers = with lib.maintainers; [ genericnerdyusername ];
+    platforms = lib.platforms.unix;
+  };
+}

pkgs/tools/games/trigger-control/default.nix

···
     homepage = "https://github.com/Etaash-mathamsetty/trigger-control";
     license = licenses.mit;
     maintainers = with maintainers; [ azuwis ];
+    platforms = platforms.all;
   };
 }

pkgs/tools/misc/hashpump/default.nix

···
+{ stdenv, fetchFromGitHub, openssl, lib }:
+
+stdenv.mkDerivation (finalAttrs: {
+  pname = "hashpump";
+  version = "1.2.0";
+
+  src = fetchFromGitHub {
+    owner = "bwall";
+    repo = "HashPump";
+    rev = "v${finalAttrs.version}";
+    hash = "sha256-xL/1os17agwFtdq0snS3ZJzwJhk22ujxfWLH65IMMEM=";
+  };
+
+  makeFlags = [ "INSTALLLOCATION=${placeholder "out"}/bin/" ];
+
+  buildInputs = [ openssl ];
+
+  doCheck = true;
+  checkPhase = ''
+    runHook preCheck
+    ./hashpump --test
+    runHook postCheck
+  '';
+
+  preInstall = ''
+    mkdir -p $out/bin
+  '';
+
+  meta = {
+    description = "A tool to exploit the hash length extension attack in various hashing algorithms";
+    homepage = "https://github.com/bwall/HashPump";
+    license = lib.licenses.mit;
+    maintainers = with lib.maintainers; [ t4ccer ];
+    platforms = lib.platforms.linux;
+  };
+})

pkgs/tools/misc/shopware-cli/default.nix

···
 
 buildGoModule rec {
   pname = "shopware-cli";
-  version = "0.2.0";
+  version = "0.2.1";
   src = fetchFromGitHub {
     repo = "shopware-cli";
     owner = "FriendsOfShopware";
     rev = version;
-    hash = "sha256-IWp4cgZd6td2hOMd2r4v3MI5kY1PqLhLGAIJ3VLvgEA=";
+    hash = "sha256-3upZmqsKCg98j/HTwFp0L7MMspCw7Dj6dRoyEPW287k=";
   };
 
   nativeBuildInputs = [ installShellFiles makeWrapper ];
 
-  vendorHash = "sha256-JTjz39zw5Il37V6V7mOQuCYiPJnnizBhkBHBAg2DvSU=";
+  vendorHash = "sha256-KEWACwZka4WMQS4/O6WkIdeeUnxtcpEwQmMlNBLUjbI=";
 
   postInstall = ''
     export HOME="$(mktemp -d)"

pkgs/tools/networking/ooniprobe-cli/default.nix

···
 
 buildGoModule rec {
   pname = "ooniprobe-cli";
-  version = "3.17.5";
+  version = "3.18.0";
 
   src = fetchFromGitHub {
     owner = "ooni";
     repo = "probe-cli";
     rev = "v${version}";
-    hash = "sha256-pzNcyioicAOCAWaEo30T/Dr74sJ1kXvJN0pnuA2JJ7k=";
+    hash = "sha256-3KnPqUB9vNxIWF28BGZqqg1IwglHOP2qAZfDMaNcN7s=";
   };
 
-  vendorHash = "sha256-e8FI678zr6EWKd+rOvPOyq20PJyaXszzcooDFuGWfOU=";
+  vendorHash = "sha256-iMEmTip9c7ySFUxcKr8ZUuREw7FfBvsIhECvmagvVL0=";
 
   subPackages = [ "cmd/ooniprobe" ];
+
+  ldflags = [ "-s" "-w" ];
 
   meta = with lib; {
     changelog = "https://github.com/ooni/probe-cli/releases/tag/${src.rev}";

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

···
+{ lib
+, fetchurl
+, pkgs
+, stdenv
+}:
+
+stdenv.mkDerivation rec {
+  pname = "fortran-fpm";
+
+  version = "0.9.0";
+
+  src = fetchurl {
+    url = "https://github.com/fortran-lang/fpm/releases/download/v${version}/fpm-${version}.F90";
+    sha256 = "sha256-VWs4g7odtv1iyZunFD8el+u0CXKcQgnwOqPG/JcMzj8=";
+  };
+
+  dontUnpack = true;
+
+  nativeBuildInputs = with pkgs; [ gfortran ];
+
+  buildPath = "build/bootstrap";
+
+  buildPhase = ''
+    runHook preBuild
+
+    mkdir -p ${buildPath}
+    gfortran -J ${buildPath} -o ${buildPath}/${pname} $src
+
+    runHook postBuild
+  '';
+
+  installPhase = ''
+    runHook preInstall
+
+    mkdir -p $out/bin
+    cp ${buildPath}/${pname} $out/bin
+
+    runHook postInstall
+  '';
+
+  meta = with lib; {
+    description = "Fortran Package Manager (fpm)";
+    homepage = "https://fpm.fortran-lang.org";
+    maintainers = [ maintainers.proofconstruction ];
+    license = licenses.mit;
+    platforms = platforms.all;
+  };
+}

pkgs/tools/security/gotrue/supabase.nix

···
 
 buildGoModule rec {
   pname = "gotrue";
-  version = "2.74.2";
+  version = "2.76.0";
 
   src = fetchFromGitHub {
     owner = "supabase";
     repo = pname;
     rev = "v${version}";
-    hash = "sha256-cTRCwWbGqiN6qy2Nh9Hs6Ex928z1r1ud5dGNJLZDLAA=";
+    hash = "sha256-2hhO/8PvrRoz2RoctoJdCMWn+DdBEni+AyoxkXLbgp0=";
   };
 
   vendorHash = "sha256-uLcea5tLe61oAyw09PpIfgf1xbClgqZYlk6553Vsvso=";

pkgs/tools/security/rnp/default.nix

···
 , json_c
 , pkg-config
 , python3
+, sexp
 , zlib
 }:
 
-stdenv.mkDerivation rec {
+stdenv.mkDerivation (finalAttrs: {
   pname = "rnp";
-  version = "0.16.3";
+  version = "0.17.0";
 
   src = fetchFromGitHub {
     owner = "rnpgp";
     repo = "rnp";
-    rev = "v${version}";
-    sha256 = "sha256-kM3gBc5rbLJU7UXvWz4a9c+Ahi/d0z8R9S5t0B9Fts0=";
+    rev = "v${finalAttrs.version}";
+    hash = "sha256-4fB7Sl9+ATrJTRnhbNG5BoW3XLxR7IP167RK96+gxj0=";
   };
 
-  buildInputs = [ zlib bzip2 json_c botan2 ];
+  buildInputs = [ zlib bzip2 json_c botan2 sexp ];
+
+  patches = [ ./unbundle-sexp.patch ];
 
   cmakeFlags = [
     "-DCMAKE_INSTALL_PREFIX=${placeholder "out"}"
···
   outputs = [ "out" "lib" "dev" ];
 
   preConfigure = ''
-    echo "v${version}" > version.txt
+    echo "v${finalAttrs.version}" > version.txt
   '';
 
   meta = with lib; {
···
     platforms = platforms.all;
     maintainers = with maintainers; [ ribose-jeffreylau ];
   };
-}
+})

pkgs/tools/security/rnp/unbundle-sexp.patch

···
+diff --git i/CMakeLists.txt w/CMakeLists.txt
+index bb6d40cb..30171e7c 100644
+--- i/CMakeLists.txt
++++ w/CMakeLists.txt
+@@ -176,11 +176,6 @@ if (ENABLE_FUZZERS)
+ endif()
+ add_subdirectory(src/common)
+
+-set(WITH_SEXP_CLI OFF)
+-set(WITH_SEXP_TESTS OFF)
+-set(CMAKE_INSTALL_DEFAULT_COMPONENT_NAME development)
+-add_subdirectory(src/libsexp EXCLUDE_FROM_ALL)
+-
+ add_subdirectory(src/lib)
+ add_subdirectory(src/rnp)
+ add_subdirectory(src/rnpkeys)
+diff --git i/src/lib/CMakeLists.txt w/src/lib/CMakeLists.txt
+index 086ac57d..b219ef06 100755
+--- i/src/lib/CMakeLists.txt
++++ w/src/lib/CMakeLists.txt
+@@ -433,7 +433,7 @@ install(TARGETS librnp
+       COMPONENT development
+   )
+
+-  install(TARGETS librnp-static sexp
++  install(TARGETS librnp-static
+     EXPORT rnp-targets
+     ARCHIVE
+       DESTINATION  "${CMAKE_INSTALL_LIBDIR}"
+@@ -441,7 +441,7 @@ install(TARGETS librnp
+   )
+ else(BUILD_SHARED_LIBS)
+ # static libraries only
+-install(TARGETS librnp sexp
++install(TARGETS librnp
+     EXPORT rnp-targets
+     ARCHIVE
+       DESTINATION  "${CMAKE_INSTALL_LIBDIR}"

pkgs/tools/text/asciigraph/default.nix

···
 
 buildGoModule rec {
   pname = "asciigraph";
-  version = "0.5.5";
+  version = "0.5.6";
 
   src = fetchFromGitHub {
     owner = "guptarohit";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-7sobelRCDY8mC5FYyGZmNsvUsEMxRulqPnUucNRN5J8=";
+    sha256 = "sha256-ZmH0+UXPUyO90ZI6YsKiTd6Nf8dgZAgm7Qx8PVUkHAU=";
   };
 
-  vendorSha256 = null;
+  vendorHash = null;
 
   ldflags = [ "-s" "-w" ];
 

pkgs/tools/virtualization/cloud-init/default.nix

···
 
 python3.pkgs.buildPythonApplication rec {
   pname = "cloud-init";
-  version = "23.2";
+  version = "23.2.1";
   namePrefix = "";
 
   src = fetchFromGitHub {
     owner = "canonical";
     repo = "cloud-init";
     rev = "refs/tags/${version}";
-    hash = "sha256-/bhezXS5GunlgID7e/QaTC4UsQ2hDvS5HnG8Wphk64k=";
+    hash = "sha256-2e05ExF6JOeFR0BUd/iCIYV0XoKTgoI7xz20GQ/bmO4=";
   };
 
   patches = [
···
   meta = with lib; {
     homepage = "https://github.com/canonical/cloud-init";
     description = "Provides configuration and customization of cloud instance";
+    changelog = "https://github.com/canonical/cloud-init/raw/${version}/ChangeLog";
     license = with licenses; [ asl20 gpl3Plus ];
     maintainers = with maintainers; [ illustris jfroche ];
     platforms = platforms.all;

pkgs/top-level/all-packages.nix

···
     inherit (darwin.apple_sdk.frameworks) Security;
   };
 
+  git-graph = callPackage ../applications/version-management/git-graph { };
+
   git-hound = callPackage ../applications/version-management/git-hound { };
 
   git-hub = callPackage ../applications/version-management/git-hub { };
···
 
   long-shebang = callPackage ../misc/long-shebang { };
 
+  lssecret = callPackage ../misc/lssecret {};
+
   lowdown = callPackage ../tools/typesetting/lowdown { };
 
   numatop = callPackage ../os-specific/linux/numatop { };
···
 
   forktty = callPackage ../os-specific/linux/forktty { };
 
+  fortran-fpm = callPackage ../tools/package-management/fortran-fpm { };
+
   fortune = callPackage ../tools/misc/fortune { };
 
   fox = callPackage ../development/libraries/fox {
···
 
   onlykey = callPackage ../tools/security/onlykey { node_webkit = nwjs; };
 
-  ooniprobe-cli = callPackage ../tools/networking/ooniprobe-cli {
-    buildGoModule = buildGo119Module; # go 1.20 build failure
-  };
+  ooniprobe-cli = callPackage ../tools/networking/ooniprobe-cli { };
 
   openapi-generator-cli = callPackage ../tools/networking/openapi-generator-cli { jre = pkgs.jre_headless; };
   openapi-generator-cli-unstable = callPackage ../tools/networking/openapi-generator-cli/unstable.nix { jre = pkgs.jre_headless; };
···
 
   profile-sync-daemon = callPackage ../tools/misc/profile-sync-daemon { };
 
+  projectable = callPackage ../applications/file-managers/projectable { };
+
   projectlibre = callPackage ../applications/misc/projectlibre {
     jre = jre8;
     jdk = jdk8;
···
 
   cheesecutter = callPackage ../applications/audio/cheesecutter { };
 
+  cutecapture = callPackage ../applications/video/cutecapture { };
+
   milkytracker = callPackage ../applications/audio/milkytracker { };
 
   ptcollab = libsForQt5.callPackage ../applications/audio/ptcollab { };
···
 
   gummy = callPackage ../tools/misc/gummy { };
 
+  hashpump = callPackage ../tools/misc/hashpump { };
+
   hck = callPackage ../tools/text/hck { };
 
   helm = callPackage ../applications/audio/helm { };
···
 
   alejandra = callPackage ../tools/nix/alejandra { };
 
-  nixfmt = haskell.lib.compose.justStaticExecutables haskellPackages.nixfmt;
+  nixfmt = haskellPackages.nixfmt.bin;
 
   nixpkgs-fmt = callPackage ../tools/nix/nixpkgs-fmt { };
 
···
   reindeer = callPackage ../development/tools/reindeer { };
 
   charasay = callPackage ../tools/misc/charasay { };
+
+  waylyrics = callPackage ../applications/audio/waylyrics { };
 }

pkgs/top-level/haskell-packages.nix

···
     "ghc945"
     "ghc94"
     "ghc96"
-    "ghc961"
     "ghc962"
     "ghcHEAD"
   ];
···
     "ghc944"
     "ghc945"
     "ghc96"
-    "ghc961"
     "ghc962"
     "ghcHEAD"
   ];
···
       llvmPackages = pkgs.llvmPackages_12;
     };
     ghc94 = ghc945;
-    ghc961 = callPackage ../development/compilers/ghc/9.6.1.nix {
-      bootPkgs =
-        # For GHC 9.2 no armv7l bindists are available.
-        if stdenv.hostPlatform.isAarch32 then
-          packages.ghc924
-        else if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then
-          packages.ghc924
-        else if stdenv.isAarch64 then
-          packages.ghc924BinaryMinimal
-        else
-          packages.ghc924Binary;
-      inherit (buildPackages.python3Packages) sphinx;
-      # Need to use apple's patched xattr until
-      # https://github.com/xattr/xattr/issues/44 and
-      # https://github.com/xattr/xattr/issues/55 are solved.
-      inherit (buildPackages.darwin) xattr autoSignDarwinBinariesHook;
-      # Support range >= 10 && < 15
-      buildTargetLlvmPackages = pkgsBuildTarget.llvmPackages_14;
-      llvmPackages = pkgs.llvmPackages_14;
-    };
     ghc962 = callPackage ../development/compilers/ghc/9.6.2.nix {
       bootPkgs =
         # For GHC 9.2 no armv7l bindists are available.
···
       compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-9.4.x.nix { };
     };
     ghc94 = ghc945;
-    ghc961 = callPackage ../development/haskell-modules {
-      buildHaskellPackages = bh.packages.ghc961;
-      ghc = bh.compiler.ghc961;
-      compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-9.6.x.nix { };
-    };
     ghc962 = callPackage ../development/haskell-modules {
       buildHaskellPackages = bh.packages.ghc962;
       ghc = bh.compiler.ghc962;

pkgs/top-level/python-aliases.nix

···
   pyblake2 = throw "pyblake2 is deprecated in favor of hashlib"; # added 2023-04-23
   pyblock = throw "pyblock has been removed, since it is abandoned and broken"; # added 2023-06-20
   pydrive = throw "pydrive is broken and deprecated and has been replaced with pydrive2."; # added 2022-06-01
+  pygbm = throw "pygbm has been removed, since it is abandoned and broken"; # added 2023-06-20
   PyGithub = pygithub; # added 2023-02-19
   pyGtkGlade = throw "Glade support for pygtk has been removed"; # added 2022-01-15
   pycallgraph = throw "pycallgraph has been removed, it was using setuptools 2to3 translation feature, which has been removed in setuptools 58"; # added 2022-01-18
···
   PyStemmer = pystemmer; # added 2023-02-19
   pytest_6 = pytest; # added 2022-02-10
   pytestcov = pytest-cov; # added 2021-01-04
+  pytest-ordering = throw "pytest-ordering has been removed, since it is no longer maintained and broken"; # added 2023-06-22
   pytest-pep8 = pytestpep8; # added 2021-01-04
   pytest-pep257 = throw "pytest-pep257 was removed, as the pep257 package was migrated into pycodestyle"; # added 2022-04-12
   pytest-pythonpath = throw "pytest-pythonpath is obsolete as of pytest 7.0.0 and has been removed"; # added 2022-03-09
+  pytest-sanic = throw "pytest-sanic has been removed because it is unmaintained and broken"; # added 2023-06-22
   pytestpep8 = throw "pytestpep8 was removed because it is abandoned and no longer compatible with pytest v6.0"; # added 2020-12-10
   pytestquickcheck = pytest-quickcheck; # added 2021-07-20
   pytestrunner = pytest-runner; # added 2021-01-04

pkgs/top-level/python-packages.nix

···
 
   binwalk-full = self.binwalk.override { visualizationSupport = true; };
 
+  biopandas = callPackage ../development/python-modules/biopandas { };
+
   biopython = callPackage ../development/python-modules/biopython { };
 
   biplist = callPackage ../development/python-modules/biplist { };
···
   cjkwrap = callPackage ../development/python-modules/cjkwrap { };
 
   ckcc-protocol = callPackage ../development/python-modules/ckcc-protocol { };
+
+  clarifai = callPackage ../development/python-modules/clarifai { };
+
+  clarifai-grpc = callPackage ../development/python-modules/clarifai-grpc { };
 
   claripy = callPackage ../development/python-modules/claripy { };
 
···
 
   marshmallow-sqlalchemy = callPackage ../development/python-modules/marshmallow-sqlalchemy { };
 
+  mashumaro = callPackage ../development/python-modules/mashumaro { };
+
   mask-rcnn = callPackage ../development/python-modules/mask-rcnn { };
 
   masky = callPackage ../development/python-modules/masky { };
···
   mmh3 = callPackage ../development/python-modules/mmh3 { };
 
   mmpython = callPackage ../development/python-modules/mmpython { };
+
+  mmtf-python = callPackage ../development/python-modules/mmtf-python { };
 
   mnemonic = callPackage ../development/python-modules/mnemonic { };
 
···
 
   pygatt = callPackage ../development/python-modules/pygatt { };
 
-  pygbm = callPackage ../development/python-modules/pygbm { };
-
   pygccxml = callPackage ../development/python-modules/pygccxml { };
 
   pygdbmi = callPackage ../development/python-modules/pygdbmi { };
···
 
   pytest-order = callPackage ../development/python-modules/pytest-order { };
 
-  pytest-ordering = callPackage ../development/python-modules/pytest-ordering { };
-
   pytest-param-files = callPackage ../development/python-modules/pytest-param-files { };
 
   pytest-playwright = callPackage ../development/python-modules/pytest-playwright {};
···
   pytest-resource-path = callPackage ../development/python-modules/pytest-resource-path { };
 
   pytest-runner = callPackage ../development/python-modules/pytest-runner { };
-
-  pytest-sanic = callPackage ../development/python-modules/pytest-sanic {
-    sanic = self.sanic.override { doCheck = false; };
-  };
 
   pytest-server-fixtures = callPackage ../development/python-modules/pytest-server-fixtures { };
 
···
   wiffi = callPackage ../development/python-modules/wiffi { };
 
   wifi = callPackage ../development/python-modules/wifi { };
+
+  wikipedia = callPackage ../development/python-modules/wikipedia { };
 
   willow = callPackage ../development/python-modules/willow { };
 

pkgs/top-level/release-haskell.nix

···
     ghc927
     ghc928
     ghc945
-    ghc961
     ghc962
   ];
 
···
       Cabal_3_10_1_0 = released;
       Cabal-syntax_3_10_1_0 = released;
       cabal2nix = lib.subtractLists [
-        compilerNames.ghc961
         compilerNames.ghc962
       ] released;
       cabal2nix-unstable = lib.subtractLists [
-        compilerNames.ghc961
         compilerNames.ghc962
       ] released;
       funcmp = lib.subtractLists [
-        compilerNames.ghc961
         compilerNames.ghc962
       ] released;
       haskell-language-server = lib.subtractLists [
···
         compilerNames.ghc884
       ] released;
       hoogle = lib.subtractLists [
-        compilerNames.ghc961
         compilerNames.ghc962
       ] released;
       hlint = lib.subtractLists [
-        compilerNames.ghc961
         compilerNames.ghc962
       ] released;
       hpack = lib.subtractLists [
-        compilerNames.ghc961
         compilerNames.ghc962
       ] released;
       hsdns = released;
       jailbreak-cabal = released;
       language-nix = lib.subtractLists [
-        compilerNames.ghc961
         compilerNames.ghc962
       ] released;
       nix-paths = released;