haskellPackages: stackage LTS 23.24 -> LTS 23.27 (#424162)

doc/languages-frameworks/agda.section.md

···
 
 ## Writing Agda packages {#writing-agda-packages}
 
-To write a nix derivation for an Agda library, first check that the library has a `*.agda-lib` file.
+To write a nix derivation for an Agda library, first check that the library has a (single) `*.agda-lib` file.
 
 A derivation can then be written using `agdaPackages.mkDerivation`. This has similar arguments to `stdenv.mkDerivation` with the following additions:
 
-* `everythingFile` can be used to specify the location of the `Everything.agda` file, defaulting to `./Everything.agda`. If this file does not exist then either it should be patched in or the `buildPhase` should be overridden (see below).
 * `libraryName` should be the name that appears in the `*.agda-lib` file, defaulting to `pname`.
 * `libraryFile` should be the file name of the `*.agda-lib` file, defaulting to `${libraryName}.agda-lib`.
 
···
 
 ### Building Agda packages {#building-agda-packages}
 
-The default build phase for `agdaPackages.mkDerivation` runs `agda` on the `Everything.agda` file.
+The default build phase for `agdaPackages.mkDerivation` runs `agda --build-library`.
 If something else is needed to build the package (e.g. `make`) then the `buildPhase` should be overridden.
-Additionally, a `preBuild` or `configurePhase` can be used if there are steps that need to be done prior to checking the `Everything.agda` file.
+Additionally, a `preBuild` or `configurePhase` can be used if there are steps that need to be done prior to checking the library.
 `agda` and the Agda libraries contained in `buildInputs` are made available during the build phase.
 
 ### Installing Agda packages {#installing-agda-packages}
···
 
 ### Adding Agda packages to Nixpkgs {#adding-agda-packages-to-nixpkgs}
 
-To add an Agda package to `nixpkgs`, the derivation should be written to `pkgs/development/libraries/agda/${library-name}/` and an entry should be added to `pkgs/top-level/agda-packages.nix`. Here it is called in a scope with access to all other Agda libraries, so the top line of the `default.nix` can look like:
+To add an Agda package to `nixpkgs`, the derivation should be written to `pkgs/development/libraries/agda/${library-name}/default.nix` and an entry should be added to `pkgs/top-level/agda-packages.nix`. Here it is called in a scope with access to all other Agda libraries, so the derivation could look like:
 
 ```nix
 {
···
   standard-library,
   fetchFromGitHub,
 }:
-{ }
-```
 
-Note that the derivation function is called with `mkDerivation` set to `agdaPackages.mkDerivation`, therefore you
-could use a similar set as in your `default.nix` from [Writing Agda Packages](#writing-agda-packages) with
-`agdaPackages.mkDerivation` replaced with `mkDerivation`.
-
-Here is an example skeleton derivation for iowa-stdlib:
-
-```nix
 mkDerivation {
-  version = "1.5.0";
-  pname = "iowa-stdlib";
-
+  pname = "my-library";
+  version = "1.0";
   src = <...>;
-
-  libraryFile = "";
-  libraryName = "IAL-1.3";
-
-  buildPhase = ''
-    runHook preBuild
-
-    patchShebangs find-deps.sh
-    make
-
-    runHook postBuild
-  '';
+  buildInputs = [ standard-library ];
+  meta = <...>;
 }
 ```
 
-This library has a file called `.agda-lib`, and so we give an empty string to `libraryFile` as nothing precedes `.agda-lib` in the filename. This file contains `name: IAL-1.3`, and so we let `libraryName =  "IAL-1.3"`. This library does not use an `Everything.agda` file and instead has a Makefile, so there is no need to set `everythingFile` and we set a custom `buildPhase`.
+You can look at other files under `pkgs/development/libraries/agda/` for more inspiration.
+
+Note that the derivation function is called with `mkDerivation` set to `agdaPackages.mkDerivation`, therefore you
+could use a similar set as in your `default.nix` from [Writing Agda Packages](#writing-agda-packages) with
+`agdaPackages.mkDerivation` replaced with `mkDerivation`.
 
 When writing an Agda package it is essential to make sure that no `.agda-lib` file gets added to the store as a single file (for example by using `writeText`). This causes Agda to think that the nix store is a Agda library and it will attempt to write to it whenever it typechecks something. See [https://github.com/agda/agda/issues/4613](https://github.com/agda/agda/issues/4613).
 
···
 you can test whether it builds correctly by writing in a comment:
 
 ```
-@ofborg build agdaPackages.iowa-stdlib
+@ofborg build agdaPackages.my-library
 ```
 
 ### Maintaining Agda packages {#agda-maintaining-packages}

maintainers/scripts/haskell/merge-and-open-pr.sh

···
 gh pr merge --repo NixOS/nixpkgs --merge "$curr_haskell_updates_pr_num"
 
 # Update stackage, Hackage hashes, and regenerate Haskell package set
-echo "Updating Stackage..."
-./maintainers/scripts/haskell/update-stackage.sh --do-commit
-echo "Updating Hackage hashes..."
-./maintainers/scripts/haskell/update-hackage.sh --do-commit
-echo "Regenerating Hackage packages..."
-# Using fast here because after the hackage-update eval errors will likely break the transitive dependencies check.
-./maintainers/scripts/haskell/regenerate-hackage-packages.sh --fast --do-commit
+./maintainers/scripts/haskell/update-package-set.sh
 
 # Push these new commits to the haskell-updates branch
 echo "Pushing commits just created to the remote $push_remote/haskell-updates branch..."

maintainers/scripts/haskell/regenerate-hackage-packages.sh

···
 if [[ "$DO_COMMIT" -eq 1 ]]; then
 git add pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml
 git add pkgs/development/haskell-modules/hackage-packages.nix
-git commit -F - << EOF
+git commit --edit -F - << EOF
 haskellPackages: regenerate package set based on current config
 
-This commit has been generated by maintainers/scripts/haskell/regenerate-hackage-packages.sh
+(generated by maintainers/scripts/haskell/regenerate-hackage-packages.sh)
 EOF
 fi
 

maintainers/scripts/haskell/update-hackage.sh

···
 #! /usr/bin/env nix-shell
 #! nix-shell -i bash -p curl jq git gnused -I nixpkgs=.
-
-# See regenerate-hackage-packages.sh for details on the purpose of this script.
+#
+# SYNOPSIS
+#
+#   Update Hackage index and hashes data exposed via pkgs.all-cabal-hashes.
+#
+# DESCRIPTION
+#
+#   Find latest revision of the commercialhaskell/all-cabal-hashes repository's
+#   hackage branch and update pkgs/data/misc/hackage/pin.json accordingly.
+#
+#   This data is used by hackage2nix to generate hackage-packages.nix. Since
+#   hackage2nix uses the latest version of a package unless an explicit
+#   constraint is configured, running this script indirectly updates packages
+#   (when hackage2nix is executed afterwards).
+#
+#   Prints a version difference to stdout if the pin has been updated, nothing
+#   otherwise.
+#
+# EXIT STATUS
+#
+#   Always exit with zero (even if nothing changed) unless there was an error.
 
 set -euo pipefail
 
+if [[ "${1:-}" == "--do-commit" ]]; then
+  echo "$0: --do-commit is no longer supported. Use update-package-set.sh instead."
+  exit 100
+fi
+
 pin_file=pkgs/data/misc/hackage/pin.json
 current_commit="$(jq -r .commit $pin_file)"
 old_date="$(jq -r .msg $pin_file | sed 's/Update from Hackage at //')"
···
 new_date="$(echo "$commit_msg" | sed 's/Update from Hackage at //')"
 
 if [ "$current_commit" != "$head_commit" ]; then
+   echo "Updating all-cabal-hashes from $old_date to $new_date" >&2
    url="https://github.com/commercialhaskell/all-cabal-hashes/archive/$head_commit.tar.gz"
    hash="$(nix-prefetch-url "$url")"
    jq -n \
···
      --arg commit_msg "$commit_msg" \
      '{commit: $commit, url: $url, sha256: $hash, msg: $commit_msg}' \
      > $pin_file
+else
+   echo "No new all-cabal-hashes version" >&2
+   exit 0
 fi
 
-if [[ "${1:-}" == "--do-commit" ]]; then
-git add pkgs/data/misc/hackage/pin.json
-git commit -F - << EOF
-all-cabal-hashes: $old_date -> $new_date
-
-This commit has been generated by maintainers/scripts/haskell/update-hackage.sh
-EOF
-fi
+echo "$old_date -> $new_date"

maintainers/scripts/haskell/update-package-set.sh

···
+#! /usr/bin/env nix-shell
+#! nix-shell -i bash
+#! nix-shell -p git -I nixpkgs=.
+set -euo pipefail
+
+filesToStage=(
+  'pkgs/data/misc/hackage/pin.json'
+  'pkgs/development/haskell-modules/configuration-hackage2nix/stackage.yaml'
+  'pkgs/development/haskell-modules/hackage-packages.nix'
+)
+
+if ! git diff --quiet --cached; then
+  echo "Please commit staged changes before running $0" >&2
+  exit 100
+fi
+
+if ! git diff --quiet -- "${filesToStage[@]}"; then
+  echo -n "Please commit your changes to the following files before running $0: " >&2
+  echo    "${filesToStage[@]}" >&2
+  exit 100
+fi
+
+stackage_diff="$(./maintainers/scripts/haskell/update-stackage.sh)"
+hackage_diff="$(./maintainers/scripts/haskell/update-hackage.sh)"
+readonly stackage_diff hackage_diff
+
+# Prefer Stackage version diff in the commit header, fall back to Hackage
+if [[ -n "$stackage_diff" ]]; then
+  commit_message="haskellPackages: stackage $stackage_diff"
+  if [[ -n "$hackage_diff" ]]; then
+    commit_message="$commit_message
+
+all-cabal-hashes: $hackage_diff"
+  fi
+elif [[ -n "$hackage_diff" ]]; then
+  commit_message="haskellPackages: hackage $hackage_diff
+
+all-cabal-hashes: $hackage_diff"
+else
+  echo "Neither Hackage nor Stackage changed. Nothing to do." >&2
+  exit 0
+fi
+
+commit_message="$commit_message
+
+(generated by maintainers/scripts/haskell/update-package-set.sh)"
+
+# Using fast here because after the hackage-update eval errors will likely break the transitive dependencies check.
+./maintainers/scripts/haskell/regenerate-hackage-packages.sh --fast
+
+# A --do-commit flag probably doesn't make much sense
+git add -- "${filesToStage[@]}"
+git commit -m "$commit_message"

maintainers/scripts/haskell/update-stackage.sh

···
 #! /usr/bin/env nix-shell
 #! nix-shell -i bash -p curl jq git gnused gnugrep -I nixpkgs=.
 # shellcheck shell=bash
+#
+# SYNOPSIS
+#
+#   Update version constraints in hackage2nix config file from Stackage.
+#
+# DESCRIPTION
+#
+#   Fetches the latest snapshot of the configured Stackage solver which is
+#   configured via the SOLVER (either LTS or Nightly) and VERSION variables in
+#   the script.
+#
+#   VERSION is only applicable if SOLVER is LTS. SOLVER=LTS and VERSION=22
+#   will cause update-stackage.sh to fetch the latest LTS-22.XX version.
+#   If empty, the latest version of the solver is used.
+#
+#   If the configuration file has been updated, update-stackage.sh prints a
+#   version difference to stdout, e.g. 23.11 -> 23.13. Otherwise, stdout remains
+#   empty.
+#
+# EXIT STATUS
+#
+#   Always exit with zero (even if nothing changed) unless there was an error.
 
 set -eu -o pipefail
+
+if [[ "${1:-}" == "--do-commit" ]]; then
+  echo "$0: --do-commit is no longer supported. Use update-package-set.sh instead."
+  exit 100
+fi
 
 # Stackage solver to use, LTS or Nightly
 # (should be capitalized like the display name)
···
 version="$SOLVER $(sed -rn "s/^--.*http:..(www.)?stackage.org.snapshot.$(toLower "$SOLVER")-//p" "$tmpfile")"
 
 if [[ "$old_version" == "$version" ]]; then
-   echo "No new stackage version"
+   echo "No new stackage version" >&2
    exit 0 # Nothing to do
 fi
 
-echo "Updating Stackage from $old_version to $version."
+echo "Updating Stackage from $old_version to $version." >&2
 
 # Create a simple yaml version of the file.
 sed -r \
···
 # ShellCheck: latest version of command-line dev tool.
 # Agda: The Agda community is fast-moving; we strive to always include the newest versions of Agda and the Agda packages in nixpkgs.
 
-if [[ "${1:-}" == "--do-commit" ]]; then
-git add $stackage_config
-git commit -F - << EOF
-haskellPackages: stackage $old_version -> $version
-
-This commit has been generated by maintainers/scripts/haskell/update-stackage.sh
-EOF
-fi
+echo "$old_version -> $version"

pkgs/build-support/agda/default.nix

···
       pname,
       meta,
       buildInputs ? [ ],
-      everythingFile ? "./Everything.agda",
-      includePaths ? [ ],
       libraryName ? pname,
       libraryFile ? "${libraryName}.agda-lib",
       buildPhase ? null,
···
       ...
     }:
     let
-      agdaWithArgs = withPackages (filter (p: p ? isAgdaDerivation) buildInputs);
-      includePathArgs = concatMapStrings (path: "-i" + path + " ") (
-        includePaths ++ [ (dirOf everythingFile) ]
-      );
+      agdaWithPkgs = withPackages (filter (p: p ? isAgdaDerivation) buildInputs);
     in
     {
       inherit libraryName libraryFile;
 
       isAgdaDerivation = true;
 
-      buildInputs = buildInputs ++ [ agdaWithArgs ];
+      buildInputs = buildInputs ++ [ agdaWithPkgs ];
 
       buildPhase =
         if buildPhase != null then
···
         else
           ''
             runHook preBuild
-            agda ${includePathArgs} ${everythingFile}
-            rm ${everythingFile} ${lib.interfaceFile Agda.version everythingFile}
+            agda --build-library
             runHook postBuild
           '';
 

pkgs/build-support/agda/lib.nix

···
     * The resulting path may not be normalized.
     *
     * Examples:
-    * interfaceFile pkgs.agda.version "./Everything.agda" == "_build/2.6.4.3/agda/./Everything.agdai"
-    * interfaceFile pkgs.agda.version "src/Everything.lagda.tex" == "_build/2.6.4.3/agda/src/Everything.agdai"
+    * interfaceFile pkgs.agda.version "./Foo.agda" == "_build/AGDA_VERSION/agda/./Foo.agdai"
+    * interfaceFile pkgs.agda.version "src/Foo.lagda.tex" == "_build/AGDA_VERSION/agda/src/Foo.agdai"
   */
   interfaceFile =
     agdaVersion: agdaFile:

pkgs/data/misc/hackage/pin.json

···
 {
-  "commit": "0b40331fe9f6ba2ce9cf1b8afe0a04aa79d36878",
-  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/0b40331fe9f6ba2ce9cf1b8afe0a04aa79d36878.tar.gz",
-  "sha256": "03mjsvybfh8bq5v475pqqs5bs9xdb0pm2qrw9w892q0q0ir5b6na",
-  "msg": "Update from Hackage at 2025-06-01T18:10:16Z"
+  "commit": "e184dedb360769d6e8e041e711559185f39ab55c",
+  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/e184dedb360769d6e8e041e711559185f39ab55c.tar.gz",
+  "sha256": "16qlwrw96lf52yvmmhfl948wpimbnqm9z87j27agcdmigf5icg1s",
+  "msg": "Update from Hackage at 2025-07-07T21:33:55Z"
 }

pkgs/development/compilers/ghc/8.10.7.nix

···
       || (stdenv.hostPlatform != stdenv.targetPlatform)
     ),
 
+  # Enable NUMA support in RTS
+  enableNuma ? lib.meta.availableOn stdenv.targetPlatform numactl,
+  numactl,
+
   # What flavour to build. An empty string indicates no
   # specific flavour and falls back to ghc default values.
   ghcFlavour ? lib.optionalString (stdenv.targetPlatform != stdenv.hostPlatform) (
···
       basePackageSet = if hostPlatform != targetPlatform then targetPackages else pkgsHostTarget;
     in
     {
-      inherit (basePackageSet) gmp ncurses;
+      inherit (basePackageSet) gmp ncurses numactl;
       # dynamic inherits are not possible in Nix
       libffi = basePackageSet.${libffi_name};
     };
···
         sha256 = "1rmv3132xhxbka97v0rx7r6larx5f5nnvs4mgm9q3rmgpjyd1vf9";
         includes = [ "libraries/ghci/ghci.cabal.in" ];
       })
+
+      # Correctly record libnuma's library and include directories in the
+      # package db. This fixes linking whenever stdenv and propagation won't
+      # quite pass the correct -L flags to the linker, e.g. when using GHC
+      # outside of stdenv/nixpkgs or build->build compilation in pkgsStatic.
+      ./ghc-8.10-9.2-rts-package-db-libnuma-dirs.patch
     ]
     ++ lib.optionals stdenv.hostPlatform.isDarwin [
       # Make Block.h compile with c++ compilers. Remove with the next release
···
     ++ lib.optionals (disableLargeAddressSpace) [
       "--disable-large-address-space"
     ]
+    ++ lib.optionals enableNuma [
+      "--enable-numa"
+      "--with-libnuma-includes=${lib.getDev targetLibs.numactl}/include"
+      "--with-libnuma-libraries=${lib.getLib targetLibs.numactl}/lib"
+    ]
     ++ lib.optionals enableUnregisterised [
       "--enable-unregisterised"
     ];
···
 
     buildInputs = [ bash ] ++ (libDeps hostPlatform);
 
-    depsTargetTarget = map lib.getDev (libDeps targetPlatform);
-    depsTargetTargetPropagated = map (lib.getOutput "out") (libDeps targetPlatform);
+    # stage1 GHC doesn't need to link against libnuma, so it's target specific
+    depsTargetTarget = map lib.getDev (
+      libDeps targetPlatform ++ lib.optionals enableNuma [ targetLibs.numactl ]
+    );
+    depsTargetTargetPropagated = map (lib.getOutput "out") (
+      libDeps targetPlatform ++ lib.optionals enableNuma [ targetLibs.numactl ]
+    );
 
     # required, because otherwise all symbols from HSffi.o are stripped, and
     # that in turn causes GHCi to abort

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

···
     && !stdenv.hostPlatform.isStatic,
   elfutils,
 
+  # Enable NUMA support in RTS
+  enableNuma ? lib.meta.availableOn stdenv.targetPlatform numactl,
+  numactl,
+
   # What flavour to build. Flavour string may contain a flavour and flavour
   # transformers as accepted by hadrian.
   ghcFlavour ?
···
         # While split sections are now enabled by default in ghc 8.8 for windows,
         # they seem to lead to `too many sections` errors when building base for
         # profiling.
-        ++ lib.optionals (!stdenv.targetPlatform.isWindows) [ "split_sections" ];
+        ++ (if stdenv.targetPlatform.isWindows then [ "no_split_sections" ] else [ "split_sections" ]);
     in
     baseFlavour + lib.concatMapStrings (t: "+${t}") transformers,
 
···
             ./Cabal-3.12-paths-fix-cycle-aarch64-darwin.patch
         )
       ]
+      ++ lib.optionals stdenv.targetPlatform.isWindows [
+        # https://gitlab.haskell.org/ghc/ghc/-/merge_requests/13919
+        (fetchpatch {
+          name = "include-modern-utimbuf.patch";
+          url = "https://gitlab.haskell.org/ghc/ghc/-/commit/7e75928ed0f1c4654de6ddd13d0b00bf4b5c6411.patch";
+          hash = "sha256-sb+AHdkGkCu8MW0xoQIpD5kEc0zYX8udAMDoC+TWc0Q=";
+        })
+      ]
       # Prevents passing --hyperlinked-source to haddock. Note that this can
       # be configured via a user defined flavour now. Unfortunately, it is
       # impossible to import an existing flavour in UserSettings, so patching
···
           url = "https://gitlab.haskell.org/ghc/ghc/-/commit/39bb6e583d64738db51441a556d499aa93a4fc4a.patch";
           sha256 = "0w5fx413z924bi2irsy1l4xapxxhrq158b5gn6jzrbsmhvmpirs0";
         })
+      ]
+
+      # Missing ELF symbols
+      ++ lib.optionals stdenv.targetPlatform.isAndroid [
+        ./ghc-define-undefined-elf-st-visibility.patch
       ];
 
     stdenv = stdenvNoCC;
···
 assert stdenv.buildPlatform == stdenv.hostPlatform || stdenv.hostPlatform == stdenv.targetPlatform;
 
 # It is currently impossible to cross-compile GHC with Hadrian.
-assert stdenv.buildPlatform == stdenv.hostPlatform;
+assert lib.assertMsg (stdenv.buildPlatform == stdenv.hostPlatform)
+  "GHC >= 9.6 can't be cross-compiled. If you meant to build a GHC cross-compiler, use `buildPackages`.";
 
 let
   inherit (stdenv) buildPlatform hostPlatform targetPlatform;
···
           ld = cc.bintools;
           "ld.gold" = cc.bintools;
 
+          windres = cc.bintools;
+
           otool = cc.bintools.bintools;
 
           # GHC needs install_name_tool on all darwin platforms. The same one can
···
       gmp
       libffi
       ncurses
+      numactl
       ;
   };
 
···
       "--with-libdw-includes=${lib.getDev targetLibs.elfutils}/include"
       "--with-libdw-libraries=${lib.getLib targetLibs.elfutils}/lib"
     ]
+    ++ lib.optionals enableNuma [
+      "--enable-numa"
+      "--with-libnuma-includes=${lib.getDev targetLibs.numactl}/include"
+      "--with-libnuma-libraries=${lib.getLib targetLibs.numactl}/lib"
+    ]
     ++ lib.optionals targetPlatform.isDarwin [
       # Darwin uses llvm-ar. GHC will try to use `-L` with `ar` when it is `llvm-ar`
       # but it doesn’t currently work because Cabal never uses `-L` on Darwin. See:
···
 
     buildInputs = [ bash ] ++ (libDeps hostPlatform);
 
-    depsTargetTarget = map lib.getDev (libDeps targetPlatform);
-    depsTargetTargetPropagated = map (lib.getOutput "out") (libDeps targetPlatform);
+    # stage0:ghc (i.e. stage1) doesn't need to link against libnuma, so it's target specific
+    depsTargetTarget = map lib.getDev (
+      libDeps targetPlatform ++ lib.optionals enableNuma [ targetLibs.numactl ]
+    );
+    depsTargetTargetPropagated = map (lib.getOutput "out") (
+      libDeps targetPlatform ++ lib.optionals enableNuma [ targetLibs.numactl ]
+    );
 
     hadrianFlags = [
       "--flavour=${ghcFlavour}"
···
           else
             "${llvmPackages.clang}/bin/${llvmPackages.clang.targetPrefix}clang"
         }"
+    ''
+    + lib.optionalString stdenv.targetPlatform.isWindows ''
+      ghc-settings-edit "$settingsFile" \
+      "windres command" "${toolPath "windres" installCC}"
     ''
     + ''
 

pkgs/development/compilers/ghc/common-make-native-bignum.nix

···
       || (stdenv.hostPlatform != stdenv.targetPlatform)
     ),
 
+  # Enable NUMA support in RTS
+  enableNuma ? lib.meta.availableOn stdenv.targetPlatform numactl,
+  numactl,
+
   # What flavour to build. An empty string indicates no
   # specific flavour and falls back to ghc default values.
   ghcFlavour ? lib.optionalString (stdenv.targetPlatform != stdenv.hostPlatform) (
···
       gmp
       libffi
       ncurses
+      numactl
       ;
   };
 
···
         stripLen = 1;
         extraPrefix = "libraries/unix/";
       })
-    ]
-    ++ lib.optionals (lib.versionOlder version "9.4") [
-      # fix hyperlinked haddock sources: https://github.com/haskell/haddock/pull/1482
-      (fetchpatch {
-        url = "https://patch-diff.githubusercontent.com/raw/haskell/haddock/pull/1482.patch";
-        sha256 = "sha256-8w8QUCsODaTvknCDGgTfFNZa8ZmvIKaKS+2ZJZ9foYk=";
-        extraPrefix = "utils/haddock/";
-        stripLen = 1;
-      })
-    ]
 
-    ++ lib.optionals (lib.versionOlder version "9.4.6") [
-      # Fix docs build with sphinx >= 6.0
-      # https://gitlab.haskell.org/ghc/ghc/-/issues/22766
-      (fetchpatch {
-        name = "ghc-docs-sphinx-6.0.patch";
-        url = "https://gitlab.haskell.org/ghc/ghc/-/commit/10e94a556b4f90769b7fd718b9790d58ae566600.patch";
-        sha256 = "0kmhfamr16w8gch0lgln2912r8aryjky1hfcda3jkcwa5cdzgjdv";
-      })
-    ]
-
-    ++ [
       # Fix docs build with Sphinx >= 7 https://gitlab.haskell.org/ghc/ghc/-/issues/24129
       ./docs-sphinx-7.patch
-    ]
 
-    ++ lib.optionals (lib.versionOlder version "9.2.2") [
-      # Add flag that fixes C++ exception handling; opt-in. Merged in 9.4 and 9.2.2.
-      # https://gitlab.haskell.org/ghc/ghc/-/merge_requests/7423
-      (fetchpatch {
-        name = "ghc-9.0.2-fcompact-unwind.patch";
-        # Note that the test suite is not packaged.
-        url = "https://gitlab.haskell.org/ghc/ghc/-/commit/c6132c782d974a7701e7f6447bdcd2bf6db4299a.patch?merge_request_iid=7423";
-        sha256 = "sha256-b4feGZIaKDj/UKjWTNY6/jH4s2iate0wAgMxG3rAbZI=";
-      })
-    ]
-
-    ++ lib.optionals (lib.versionAtLeast version "9.2") [
-      # Don't generate code that doesn't compile when --enable-relocatable is passed to Setup.hs
-      # Can be removed if the Cabal library included with ghc backports the linked fix
-      (fetchpatch {
-        url = "https://github.com/haskell/cabal/commit/6c796218c92f93c95e94d5ec2d077f6956f68e98.patch";
-        stripLen = 1;
-        extraPrefix = "libraries/Cabal/";
-        sha256 = "sha256-yRQ6YmMiwBwiYseC5BsrEtDgFbWvst+maGgDtdD0vAY=";
-      })
-    ]
-
-    ++ lib.optionals (version == "9.4.6") [
-      # Work around a type not being defined when including Rts.h in bytestring's cbits
-      # due to missing feature macros. See https://gitlab.haskell.org/ghc/ghc/-/issues/23810.
-      ./9.4.6-bytestring-posix-source.patch
-    ]
-
-    ++ lib.optionals (stdenv.targetPlatform.isDarwin && stdenv.targetPlatform.isAarch64) [
-      # Prevent the paths module from emitting symbols that we don't use
-      # when building with separate outputs.
-      #
-      # These cause problems as they're not eliminated by GHC's dead code
-      # elimination on aarch64-darwin. (see
-      # https://github.com/NixOS/nixpkgs/issues/140774 for details).
+      # Correctly record libnuma's library and include directories in the
+      # package db. This fixes linking whenever stdenv and propagation won't
+      # quite pass the correct -L flags to the linker, e.g. when using GHC
+      # outside of stdenv/nixpkgs or build->build compilation in pkgsStatic.
       (
-        if lib.versionAtLeast version "9.2" then
-          ./Cabal-at-least-3.6-paths-fix-cycle-aarch64-darwin.patch
+        if lib.versionAtLeast version "9.4" then
+          ./ghc-9.4-rts-package-db-libnuma-dirs.patch
         else
-          ./Cabal-3.2-3.4-paths-fix-cycle-aarch64-darwin.patch
+          ./ghc-8.10-9.2-rts-package-db-libnuma-dirs.patch
       )
-    ]
-
-    # Fixes stack overrun in rts which crashes an process whenever
-    # freeHaskellFunPtr is called with nixpkgs' hardening flags.
-    # https://gitlab.haskell.org/ghc/ghc/-/issues/25485
-    # https://gitlab.haskell.org/ghc/ghc/-/merge_requests/13599
-    # TODO: patch doesn't apply for < 9.4, but may still be necessary?
-    ++ lib.optionals (lib.versionAtLeast version "9.4") [
-      (fetchpatch {
-        name = "ghc-rts-adjustor-fix-i386-stack-overrun.patch";
-        url = "https://gitlab.haskell.org/ghc/ghc/-/commit/39bb6e583d64738db51441a556d499aa93a4fc4a.patch";
-        sha256 = "0w5fx413z924bi2irsy1l4xapxxhrq158b5gn6jzrbsmhvmpirs0";
-      })
     ]
 
     # Before GHC 9.6, GHC, when used to compile C sources (i.e. to drive the CC), would first
···
         [
           # TODO(@sternenseemann): backport changes to GHC < 9.4 if possible
         ]
-    );
+    )
+
+    ++ lib.optionals (lib.versionAtLeast version "9.2") [
+      # Don't generate code that doesn't compile when --enable-relocatable is passed to Setup.hs
+      # Can be removed if the Cabal library included with ghc backports the linked fix
+      (fetchpatch {
+        url = "https://github.com/haskell/cabal/commit/6c796218c92f93c95e94d5ec2d077f6956f68e98.patch";
+        stripLen = 1;
+        extraPrefix = "libraries/Cabal/";
+        sha256 = "sha256-yRQ6YmMiwBwiYseC5BsrEtDgFbWvst+maGgDtdD0vAY=";
+      })
+    ]
+
+    ++ lib.optionals (lib.versionOlder version "9.2.2") [
+      # Add flag that fixes C++ exception handling; opt-in. Merged in 9.4 and 9.2.2.
+      # https://gitlab.haskell.org/ghc/ghc/-/merge_requests/7423
+      (fetchpatch {
+        name = "ghc-9.0.2-fcompact-unwind.patch";
+        # Note that the test suite is not packaged.
+        url = "https://gitlab.haskell.org/ghc/ghc/-/commit/c6132c782d974a7701e7f6447bdcd2bf6db4299a.patch?merge_request_iid=7423";
+        sha256 = "sha256-b4feGZIaKDj/UKjWTNY6/jH4s2iate0wAgMxG3rAbZI=";
+      })
+    ]
+
+    # fix hyperlinked haddock sources: https://github.com/haskell/haddock/pull/1482
+    ++ lib.optionals (lib.versionOlder version "9.4") [
+      (fetchpatch {
+        url = "https://patch-diff.githubusercontent.com/raw/haskell/haddock/pull/1482.patch";
+        sha256 = "sha256-8w8QUCsODaTvknCDGgTfFNZa8ZmvIKaKS+2ZJZ9foYk=";
+        extraPrefix = "utils/haddock/";
+        stripLen = 1;
+      })
+    ]
+
+    # Fixes stack overrun in rts which crashes an process whenever
+    # freeHaskellFunPtr is called with nixpkgs' hardening flags.
+    # https://gitlab.haskell.org/ghc/ghc/-/issues/25485
+    # https://gitlab.haskell.org/ghc/ghc/-/merge_requests/13599
+    # TODO: patch doesn't apply for < 9.4, but may still be necessary?
+    ++ lib.optionals (lib.versionAtLeast version "9.4") [
+      (fetchpatch {
+        name = "ghc-rts-adjustor-fix-i386-stack-overrun.patch";
+        url = "https://gitlab.haskell.org/ghc/ghc/-/commit/39bb6e583d64738db51441a556d499aa93a4fc4a.patch";
+        sha256 = "0w5fx413z924bi2irsy1l4xapxxhrq158b5gn6jzrbsmhvmpirs0";
+      })
+    ]
+
+    ++ lib.optionals (lib.versionOlder version "9.4.6") [
+      # Fix docs build with sphinx >= 6.0
+      # https://gitlab.haskell.org/ghc/ghc/-/issues/22766
+      (fetchpatch {
+        name = "ghc-docs-sphinx-6.0.patch";
+        url = "https://gitlab.haskell.org/ghc/ghc/-/commit/10e94a556b4f90769b7fd718b9790d58ae566600.patch";
+        sha256 = "0kmhfamr16w8gch0lgln2912r8aryjky1hfcda3jkcwa5cdzgjdv";
+      })
+    ]
+
+    ++ lib.optionals (version == "9.4.6") [
+      # Work around a type not being defined when including Rts.h in bytestring's cbits
+      # due to missing feature macros. See https://gitlab.haskell.org/ghc/ghc/-/issues/23810.
+      ./9.4.6-bytestring-posix-source.patch
+    ]
+
+    ++ lib.optionals (stdenv.targetPlatform.isDarwin && stdenv.targetPlatform.isAarch64) [
+      # Prevent the paths module from emitting symbols that we don't use
+      # when building with separate outputs.
+      #
+      # These cause problems as they're not eliminated by GHC's dead code
+      # elimination on aarch64-darwin. (see
+      # https://github.com/NixOS/nixpkgs/issues/140774 for details).
+      (
+        if lib.versionAtLeast version "9.2" then
+          ./Cabal-at-least-3.6-paths-fix-cycle-aarch64-darwin.patch
+        else
+          ./Cabal-3.2-3.4-paths-fix-cycle-aarch64-darwin.patch
+      )
+    ];
 
     postPatch = "patchShebangs .";
 
···
     ++ lib.optionals (disableLargeAddressSpace) [
       "--disable-large-address-space"
     ]
+    ++ lib.optionals enableNuma [
+      "--enable-numa"
+      "--with-libnuma-includes=${lib.getDev targetLibs.numactl}/include"
+      "--with-libnuma-libraries=${lib.getLib targetLibs.numactl}/lib"
+    ]
     ++ lib.optionals enableUnregisterised [
       "--enable-unregisterised"
     ];
···
 
     buildInputs = [ bash ] ++ (libDeps hostPlatform);
 
-    depsTargetTarget = map lib.getDev (libDeps targetPlatform);
-    depsTargetTargetPropagated = map (lib.getOutput "out") (libDeps targetPlatform);
+    # stage1 GHC doesn't need to link against libnuma, so it's target specific
+    depsTargetTarget = map lib.getDev (
+      libDeps targetPlatform ++ lib.optionals enableNuma [ targetLibs.numactl ]
+    );
+    depsTargetTargetPropagated = map (lib.getOutput "out") (
+      libDeps targetPlatform ++ lib.optionals enableNuma [ targetLibs.numactl ]
+    );
 
     # required, because otherwise all symbols from HSffi.o are stripped, and
     # that in turn causes GHCi to abort

pkgs/development/compilers/ghc/ghc-8.10-9.2-rts-package-db-libnuma-dirs.patch

···
+From 3d17e6fa39fb18d4300fbf2a0c4b9ddb4adf746b Mon Sep 17 00:00:00 2001
+From: sterni <[e-mail]>
+Date: Thu, 17 Jul 2025 21:21:29 +0200
+Subject: [PATCH] rts: record libnuma include and lib dirs in package conf
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+The --with-libnuma-libraries and --with-libnuma-includes flags were
+originally introduced for hadrian in def486c90ef6f37d81d0d9c6df7544
+and curiously never supported by the make build system — even though
+the addition was made in the 9.0 series and even backported to the
+8.10 series.
+
+While the make build system knows when to link against libnuma, it won't
+enforce its specific directories by adding them to rts.conf in the
+package db. This commit implements this retroactively for the make build
+system, modeled after how make does the same sort of thing for Libdw.
+The Libdw logic also affects the bindist configure file in
+distrib/configure.ac which isn't replicate since we don't need it.
+---
+ mk/config.mk.in     | 4 ++++
+ rts/ghc.mk          | 8 ++++++++
+ rts/package.conf.in | 5 +++--
+ rts/rts.cabal.in    | 1 +
+ 4 files changed, 16 insertions(+), 2 deletions(-)
+
+diff --git a/mk/config.mk.in b/mk/config.mk.in
+index 35f6e2d087..d2b1329eb5 100644
+--- a/mk/config.mk.in
++++ b/mk/config.mk.in
+@@ -333,6 +333,10 @@ LibdwIncludeDir=@LibdwIncludeDir@
+ #     rts/Libdw.c:set_initial_registers()
+ GhcRtsWithLibdw=$(strip $(if $(filter $(TargetArch_CPP),i386 x86_64 s390x),@UseLibdw@,NO))
+ 
++UseLibNuma=@UseLibNuma@
++LibNumaLibDir=@LibNumaLibDir@
++LibNumaIncludeDir=@LibNumaIncludeDir@
++
+ ################################################################################
+ #
+ #		Paths (see paths.mk)
+diff --git a/rts/ghc.mk b/rts/ghc.mk
+index 9c535def5a..7782c4b768 100644
+--- a/rts/ghc.mk
++++ b/rts/ghc.mk
+@@ -576,6 +576,14 @@ rts_PACKAGE_CPP_OPTS += -DLIBDW_INCLUDE_DIR=
+ rts_PACKAGE_CPP_OPTS += -DLIBDW_LIB_DIR=
+ endif
+ 
++ifeq "$(UseLibNuma)" "YES"
++rts_PACKAGE_CPP_OPTS += -DLIBNUMA_INCLUDE_DIR=$(LibNumaIncludeDir)
++rts_PACKAGE_CPP_OPTS += -DLIBNUMA_LIB_DIR=$(LibNumaLibDir)
++else
++rts_PACKAGE_CPP_OPTS += -DLIBNUMA_INCLUDE_DIR=
++rts_PACKAGE_CPP_OPTS += -DLIBNUMA_LIB_DIR=
++endif
++
+ # -----------------------------------------------------------------------------
+ # dependencies
+ 
+diff --git a/rts/package.conf.in b/rts/package.conf.in
+index 9bdbf3659a..46f728b09a 100644
+--- a/rts/package.conf.in
++++ b/rts/package.conf.in
+@@ -18,9 +18,9 @@ hidden-modules:
+ import-dirs:
+ 
+ #if defined(INSTALLING)
+-library-dirs:           LIB_DIR"/rts" FFI_LIB_DIR LIBDW_LIB_DIR
++library-dirs:           LIB_DIR"/rts" FFI_LIB_DIR LIBDW_LIB_DIR LIBNUMA_LIB_DIR
+ #else /* !INSTALLING */
+-library-dirs:           TOP"/rts/dist/build" FFI_LIB_DIR LIBDW_LIB_DIR
++library-dirs:           TOP"/rts/dist/build" FFI_LIB_DIR LIBDW_LIB_DIR LIBNUMA_LIB_DIR
+ #endif
+ 
+ hs-libraries:   "HSrts" FFI_LIB
+@@ -76,6 +76,7 @@ include-dirs:           TOP"/rts/dist/build"
+                         FFI_INCLUDE_DIR
+                         LIBDW_INCLUDE_DIR
+                         TOP"/includes/dist-install/build"
++                        LIBNUMA_INCLUDE_DIR
+ #endif
+ 
+ includes:               Stg.h
+diff --git a/rts/rts.cabal.in b/rts/rts.cabal.in
+index 0a06414d95..f71fb079ec 100644
+--- a/rts/rts.cabal.in
++++ b/rts/rts.cabal.in
+@@ -150,6 +150,7 @@ library
+     include-dirs: build ../includes includes
+                   includes/dist-derivedconstants/header @FFIIncludeDir@
+                   @LibdwIncludeDir@
++                  @LibNumaIncludeDir@
+     includes: Stg.h
+     install-includes: Cmm.h HsFFI.h MachDeps.h Rts.h RtsAPI.h Stg.h
+                       ghcautoconf.h ghcconfig.h ghcplatform.h ghcversion.h
+-- 
+2.50.0
+

pkgs/development/compilers/ghc/ghc-9.4-rts-package-db-libnuma-dirs.patch

···
+From a0b547f41939304adfc0c430314c342dd69306ae Mon Sep 17 00:00:00 2001
+From: sterni <[e-mail]>
+Date: Thu, 17 Jul 2025 21:21:29 +0200
+Subject: [PATCH] rts: record libnuma include and lib dirs in package conf
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+The --with-libnuma-libraries and --with-libnuma-includes flags were
+originally introduced for hadrian in def486c90ef6f37d81d0d9c6df7544
+and curiously never supported by the make build system — even though
+the addition was made in the 9.0 series and even backported to the
+8.10 series.
+
+While the make build system knows when to link against libnuma, it won't
+enforce its specific directories by adding them to rts.conf in the
+package db. This commit implements this retroactively for the make build
+system, modeled after how make does the same sort of thing for Libdw.
+The Libdw logic also affects the bindist configure file in
+distrib/configure.ac which isn't replicate since we don't need it.
+---
+ mk/config.mk.in     | 4 ++++
+ rts/ghc.mk          | 8 ++++++++
+ rts/package.conf.in | 5 +++--
+ rts/rts.cabal.in    | 1 +
+ 4 files changed, 16 insertions(+), 2 deletions(-)
+
+diff --git a/mk/config.mk.in b/mk/config.mk.in
+index 2ff2bea9b6..d95f927dbd 100644
+--- a/mk/config.mk.in
++++ b/mk/config.mk.in
+@@ -324,6 +324,10 @@ LibdwIncludeDir=@LibdwIncludeDir@
+ #     rts/Libdw.c:set_initial_registers()
+ GhcRtsWithLibdw=$(strip $(if $(filter $(TargetArch_CPP),i386 x86_64 s390x),@UseLibdw@,NO))
+ 
++UseLibNuma=@UseLibNuma@
++LibNumaLibDir=@LibNumaLibDir@
++LibNumaIncludeDir=@LibNumaIncludeDir@
++
+ ################################################################################
+ #
+ #		Paths (see paths.mk)
+diff --git a/rts/ghc.mk b/rts/ghc.mk
+index 36a82f9f2c..854bb8e013 100644
+--- a/rts/ghc.mk
++++ b/rts/ghc.mk
+@@ -573,6 +573,14 @@ rts_PACKAGE_CPP_OPTS += -DLIBDW_INCLUDE_DIR=
+ rts_PACKAGE_CPP_OPTS += -DLIBDW_LIB_DIR=
+ endif
+ 
++ifeq "$(UseLibNuma)" "YES"
++rts_PACKAGE_CPP_OPTS += -DLIBNUMA_INCLUDE_DIR=$(LibNumaIncludeDir)
++rts_PACKAGE_CPP_OPTS += -DLIBNUMA_LIB_DIR=$(LibNumaLibDir)
++else
++rts_PACKAGE_CPP_OPTS += -DLIBNUMA_INCLUDE_DIR=
++rts_PACKAGE_CPP_OPTS += -DLIBNUMA_LIB_DIR=
++endif
++
+ # -----------------------------------------------------------------------------
+ # dependencies
+ 
+diff --git a/rts/package.conf.in b/rts/package.conf.in
+index cb5a436f5c..9e5ae48adb 100644
+--- a/rts/package.conf.in
++++ b/rts/package.conf.in
+@@ -18,9 +18,9 @@ hidden-modules:
+ import-dirs:
+ 
+ #if defined(INSTALLING)
+-library-dirs:           LIB_DIR FFI_LIB_DIR LIBDW_LIB_DIR
++library-dirs:           LIB_DIR FFI_LIB_DIR LIBDW_LIB_DIR LIBNUMA_LIB_DIR
+ #else /* !INSTALLING */
+-library-dirs:           TOP"/rts/dist-install/build" FFI_LIB_DIR LIBDW_LIB_DIR
++library-dirs:           TOP"/rts/dist-install/build" FFI_LIB_DIR LIBDW_LIB_DIR LIBNUMA_LIB_DIR
+ #endif
+ 
+ hs-libraries:   "HSrts" FFI_LIB
+@@ -74,6 +74,7 @@ include-dirs:           TOP"/rts/include"
+                         TOP"/rts/dist-install/build/include"
+                         FFI_INCLUDE_DIR
+                         LIBDW_INCLUDE_DIR
++                        LIBNUMA_INCLUDE_DIR
+ #endif
+ 
+ includes:               Rts.h
+diff --git a/rts/rts.cabal.in b/rts/rts.cabal.in
+index a8882268ac..debf2ba0a0 100644
+--- a/rts/rts.cabal.in
++++ b/rts/rts.cabal.in
+@@ -154,6 +154,7 @@ library
+     include-dirs: include
+                   @FFIIncludeDir@
+                   @LibdwIncludeDir@
++                  @LibNumaIncludeDir@
+     includes: Rts.h
+     install-includes: Cmm.h HsFFI.h MachDeps.h Rts.h RtsAPI.h Stg.h
+                       ghcautoconf.h ghcconfig.h ghcplatform.h ghcversion.h
+-- 
+2.50.0
+

pkgs/development/compilers/ghc/ghc-define-undefined-elf-st-visibility.patch

···
+diff --git a/rts/linker/ElfTypes.h b/rts/linker/ElfTypes.h
+index f5e2f819d9..7f75087738 100644
+--- a/rts/linker/ElfTypes.h
++++ b/rts/linker/ElfTypes.h
+@@ -33,6 +33,9 @@
+ #define Elf_Sym     Elf64_Sym
+ #define Elf_Rel     Elf64_Rel
+ #define Elf_Rela    Elf64_Rela
++#if !defined(ELF64_ST_VISIBILITY)
++#define ELF64_ST_VISIBILITY(o) ((o)&0x3)
++#endif
+ #if !defined(ELF_ST_VISIBILITY)
+ #define ELF_ST_VISIBILITY ELF64_ST_VISIBILITY
+ #endif
+@@ -60,6 +63,9 @@
+ #define Elf_Sym     Elf32_Sym
+ #define Elf_Rel     Elf32_Rel
+ #define Elf_Rela    Elf32_Rela
++#if !defined(ELF32_ST_VISIBILITY)
++#define ELF32_ST_VISIBILITY(o) ((o)&0x3)
++#endif
+ #if !defined(ELF_ST_VISIBILITY)
+ #define ELF_ST_VISIBILITY ELF32_ST_VISIBILITY
+ #endif /* ELF_ST_VISIBILITY */

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

···
         cabalInstallOverlay = cself: csuper: {
           Cabal = cself.Cabal_3_14_2_0;
           Cabal-syntax = cself.Cabal-syntax_3_14_2_0;
+
+          # Only needed for cabal2nix, hpack < 0.37 forbids Cabal >= 3.14
+          hpack = cself.hpack_0_38_1;
         };
       in
       {
···
           # May as well…
           (self.generateOptparseApplicativeCompletions [ "guardian" ])
         ];
+
+        cabal2nix-unstable = super.cabal2nix-unstable.overrideScope cabalInstallOverlay;
       }
     )
     cabal-install
     cabal-install-solver
     guardian
+    cabal2nix-unstable
     ;
 
   # Expected test output for these accidentally checks the absolute location of the source directory
···
     sha256 = "10zkvclyir3zf21v41zdsvg68vrkq89n64kv9k54742am2i4aygf";
   }) super.weeder;
 
-  # Version 2.1.1 is deprecated, but part of Stackage LTS at the moment.
-  # https://github.com/commercialhaskell/stackage/issues/7500
-  # https://github.com/yesodweb/shakespeare/issues/280
-  shakespeare = doDistribute self.shakespeare_2_1_0_1;
+  # Test suite doesn't find necessary test files when compiling
+  # https://github.com/yesodweb/shakespeare/issues/294
+  shakespeare = dontCheck super.shakespeare;
 
   # Work around -Werror failures until a more permanent solution is released
   # https://github.com/haskell-cryptography/HsOpenSSL/issues/88
···
           name = "git-annex-${super.git-annex.version}-src";
           url = "git://git-annex.branchable.com/";
           rev = "refs/tags/" + super.git-annex.version;
-          sha256 = "0d968aciaxmblahk79x2m708rvbg19flj5naxzg0zdp9j2jwlcqf";
+          sha256 = "sha256-whpBFmOHBTm1clXoAwInsQw7mnxrQOyaUj7byogku5c=";
           # delete android and Android directories which cause issues on
           # darwin (case insensitive directory). Since we don't need them
           # during the build process, we can delete it to prevent a hash
···
           # TODO(@sternenseemann): submit upstreamable patch resolving this
           # (this should be possible by also taking PREFIX into account).
           ./patches/git-annex-no-usr-prefix.patch
-
-          # Pick fix for git 2.50 related test suite failures from 10.20250630
-          # https://git-annex.branchable.com/bugs/test_suite_fail_with_git_2.50/
-          (pkgs.fetchpatch {
-            name = "git-annex-workaround-for-git-2.50.patch";
-            url = "https://git.joeyh.name/index.cgi/git-annex.git/patch/?id=fb155b1e3e59cc1f9cf8a4fe7d47cba49d1c81af";
-            sha256 = "sha256-w6eXW0JqshXTd0/tNPZ0fOW2SVmA90G5eFhsd9y05BI=";
-            excludes = [
-              "doc/**"
-              "CHANGELOG"
-            ];
-          })
         ];
 
         postPatch = ''
···
   VulkanMemoryAllocator = addExtraLibrary pkgs.vulkan-headers super.VulkanMemoryAllocator;
   vulkan-utils = addExtraLibrary pkgs.vulkan-headers super.vulkan-utils;
 
-  # Support for vulkan-headers 1.4.313.0
-  # https://github.com/YoshikuniJujo/gpu-vulkan-middle/issues/10
-  gpu-vulkan-middle = overrideCabal (drv: {
-    version =
-      let
-        fixed = "0.1.0.76";
-      in
-      lib.warnIf (lib.versionAtLeast drv.version fixed)
-        "haskellPackages.gpu-vulkan-middle: default version ${drv.version} >= ${fixed}, consider dropping override"
-        fixed;
-    sha256 = "sha256-VQAVo/84qPBFkQSmY3pT4WXOK9zrFMpK7WN9/UdED6E=";
-    revision = null;
-    editedCabalFile = null;
-  }) super.gpu-vulkan-middle;
-
   # Generate cli completions for dhall.
   dhall = self.generateOptparseApplicativeCompletions [ "dhall" ] super.dhall;
   # 2025-01-27: allow aeson >= 2.2, 9.8 versions of text and bytestring
···
   # https://github.com/haskell-servant/servant-ekg/issues/15
   servant-ekg = doJailbreak super.servant-ekg;
 
-  # Fixes bug in an Ord instance that was causing the test suite to fail
-  # https://github.com/fpringle/servant-routes/issues/33
-  servant-routes = appendPatches [
-    (pkgs.fetchpatch {
-      name = "servant-routes-fix-ord.patch";
-      url = "https://github.com/fpringle/servant-routes/commit/d1ef071f11c6a0810637beb8ea0b08f8e524b48a.patch";
-      sha256 = "1c2xpi7sz0621fj9r1010587d1l39j6mm8l4vqmz9pldccmcb0f2";
-    })
-  ] super.servant-routes;
-
-  # Fix test suite with text >= 2.1.2
-  servant-client =
-    appendPatches
-      [
-        (pkgs.fetchpatch {
-          name = "servant-client-text-2.1.2.patch";
-          url = "https://github.com/haskell-servant/servant/commit/9cda0cfb356a01ad402ee949e0b0d5c0494eace2.patch";
-          sha256 = "19vpn7h108wra9b84r642zxg0mii66rq4vjbqhi7ackkdb0mx9yn";
-          relative = "servant-client";
-          # patch to servant-client.cabal doesn't apply on 0.20.2
-          includes = [ "README.md" ];
-        })
-      ]
-      (
-        overrideCabal (drv: {
-          postPatch = super.postPatch or "" + ''
-            # Restore the symlink (to the file we patch) which becomes a regular file
-            # in the hackage tarball
-            ln -sf README.md README.lhs
-          '';
-        }) super.servant-client
-      );
-
   # it wants to build a statically linked binary by default
   hledger-flow = overrideCabal (drv: {
     postPatch = (drv.postPatch or "") + ''
···
       })
       # https://github.com/NixOS/nixpkgs/issues/198495
       (dontCheckIf (pkgs.postgresqlTestHook.meta.broken) super.persistent-postgresql);
-
-  # Downgrade persistent-test to a version that's compatible with
-  # persistent < 2.16 (which Stackage prescribed).  Unfortunately, the
-  # bad version of persistent-test slipped into Stackage LTS because
-  # PVP allows it and LTS doesn't continuously run test suites (contrary
-  # to nightly).
-  # See also https://github.com/yesodweb/persistent/pull/1584#issuecomment-2939756529
-  #          https://github.com/commercialhaskell/stackage/issues/7768
-  persistent-test_2_13_1_4 = dontDistribute super.persistent-test;
-  persistent-test = doDistribute self.persistent-test_2_13_1_3;
 
   # Needs matching lsp-types
   # Allow lens >= 5.3
···
   # https://github.com/obsidiansystems/database-id/issues/1
   database-id-class = doJailbreak super.database-id-class;
 
-  cabal2nix-unstable = overrideCabal {
-    passthru = {
-      updateScript = ../../../maintainers/scripts/haskell/update-cabal2nix-unstable.sh;
-
-      # This is used by regenerate-hackage-packages.nix to supply the configuration
-      # values we can easily generate automatically without checking them in.
-      compilerConfig =
-        pkgs.runCommand "hackage2nix-${self.ghc.haskellCompilerName}-config.yaml"
-          {
-            nativeBuildInputs = [
-              self.ghc
-            ];
-          }
-          ''
-            cat > "$out" << EOF
-            # generated by haskellPackages.cabal2nix-unstable.compilerConfig
-            compiler: ${self.ghc.haskellCompilerName}
-
-            core-packages:
-            EOF
-
-            ghc-pkg list \
-              | tail -n '+2' \
-              | sed -e 's/[()]//g' -e 's/\s\+/  - /' \
-              >> "$out"
-          '';
-    };
-  } super.cabal2nix-unstable;
-
   # Too strict version bounds on base
   # https://github.com/gibiansky/IHaskell/issues/1217
   ihaskell-display = doJailbreak super.ihaskell-display;
···
     self: super: {
       # stack needs to be built with the same hpack version that the upstream releases use.
       # https://github.com/NixOS/nixpkgs/issues/223390
-      hpack = self.hpack_0_38_0;
+      hpack = self.hpack_0_38_1;
     }
   );
 
···
   # https://github.com/snoyberg/http-client/pull/563
   http-client-tls = doJailbreak super.http-client-tls;
 
+  # agda2hs 1.3 is not compatible with Agda 2.8.0
+  agda2hs = lib.pipe super.agda2hs [
+    (warnAfterVersion "1.3")
+    (overrideSrc {
+      version = "1.3-unstable-2025-07-25";
+      src = pkgs.fetchFromGitHub {
+        owner = "agda";
+        repo = "agda2hs";
+        rev = "01cc0532b522f64223782617cbde1a6f21b8880e";
+        hash = "sha256-SXhnkZa8OmgpYRTb2IVTfebtX+GG5mkVcqKchl2Noic=";
+      };
+    })
+  ];
+
   bsb-http-chunked = lib.pipe super.bsb-http-chunked [
     (warnAfterVersion "0.0.0.4")
     # Last released in 2018
···
         src = amazonkaSrc + "/${dir}";
       })
         drv;
-    isAmazonkaService =
-      name: lib.hasPrefix "amazonka-" name && name != "amazonka-test" && name != "amazonka-s3-streaming";
-    amazonkaServices = lib.filter isAmazonkaService (lib.attrNames super);
+    # To get the list of amazonka services run:
+    # > nix eval --impure --expr 'builtins.attrNames (import ./. {}).haskellPackages' --json | jq '.[]' | grep '^"amazonka'
+    # NB: we exclude amazonka-test and amazonka-s3-streaming
+    amazonkaServices = [
+      "amazonka"
+      "amazonka-accessanalyzer"
+      "amazonka-account"
+      "amazonka-alexa-business"
+      "amazonka-amp"
+      "amazonka-amplify"
+      "amazonka-amplifybackend"
+      "amazonka-amplifyuibuilder"
+      "amazonka-apigateway"
+      "amazonka-apigatewaymanagementapi"
+      "amazonka-apigatewayv2"
+      "amazonka-appconfig"
+      "amazonka-appconfigdata"
+      "amazonka-appflow"
+      "amazonka-appintegrations"
+      "amazonka-application-autoscaling"
+      "amazonka-application-insights"
+      "amazonka-applicationcostprofiler"
+      "amazonka-appmesh"
+      "amazonka-apprunner"
+      "amazonka-appstream"
+      "amazonka-appsync"
+      "amazonka-arc-zonal-shift"
+      "amazonka-athena"
+      "amazonka-auditmanager"
+      "amazonka-autoscaling"
+      "amazonka-autoscaling-plans"
+      "amazonka-backup"
+      "amazonka-backup-gateway"
+      "amazonka-backupstorage"
+      "amazonka-batch"
+      "amazonka-billingconductor"
+      "amazonka-braket"
+      "amazonka-budgets"
+      "amazonka-certificatemanager"
+      "amazonka-certificatemanager-pca"
+      "amazonka-chime"
+      "amazonka-chime-sdk-identity"
+      "amazonka-chime-sdk-media-pipelines"
+      "amazonka-chime-sdk-meetings"
+      "amazonka-chime-sdk-messaging"
+      "amazonka-chime-sdk-voice"
+      "amazonka-cloud9"
+      "amazonka-cloudcontrol"
+      "amazonka-clouddirectory"
+      "amazonka-cloudformation"
+      "amazonka-cloudfront"
+      "amazonka-cloudhsm"
+      "amazonka-cloudhsmv2"
+      "amazonka-cloudsearch"
+      "amazonka-cloudsearch-domains"
+      "amazonka-cloudtrail"
+      "amazonka-cloudwatch"
+      "amazonka-cloudwatch-events"
+      "amazonka-cloudwatch-logs"
+      "amazonka-codeartifact"
+      "amazonka-codebuild"
+      "amazonka-codecommit"
+      "amazonka-codedeploy"
+      "amazonka-codeguru-reviewer"
+      "amazonka-codeguruprofiler"
+      "amazonka-codepipeline"
+      "amazonka-codestar"
+      "amazonka-codestar-connections"
+      "amazonka-codestar-notifications"
+      "amazonka-cognito-identity"
+      "amazonka-cognito-idp"
+      "amazonka-cognito-sync"
+      "amazonka-comprehend"
+      "amazonka-comprehendmedical"
+      "amazonka-compute-optimizer"
+      "amazonka-config"
+      "amazonka-connect"
+      "amazonka-connect-contact-lens"
+      "amazonka-connectcampaigns"
+      "amazonka-connectcases"
+      "amazonka-connectparticipant"
+      "amazonka-contrib-rds-utils"
+      "amazonka-controltower"
+      "amazonka-core"
+      "amazonka-cost-explorer"
+      "amazonka-cur"
+      "amazonka-customer-profiles"
+      "amazonka-databrew"
+      "amazonka-dataexchange"
+      "amazonka-datapipeline"
+      "amazonka-datasync"
+      "amazonka-detective"
+      "amazonka-devicefarm"
+      "amazonka-devops-guru"
+      "amazonka-directconnect"
+      "amazonka-discovery"
+      "amazonka-dlm"
+      "amazonka-dms"
+      "amazonka-docdb"
+      "amazonka-docdb-elastic"
+      "amazonka-drs"
+      "amazonka-ds"
+      "amazonka-dynamodb"
+      "amazonka-dynamodb-dax"
+      "amazonka-dynamodb-streams"
+      "amazonka-ebs"
+      "amazonka-ec2"
+      "amazonka-ec2-instance-connect"
+      "amazonka-ecr"
+      "amazonka-ecr-public"
+      "amazonka-ecs"
+      "amazonka-efs"
+      "amazonka-eks"
+      "amazonka-elastic-inference"
+      "amazonka-elasticache"
+      "amazonka-elasticbeanstalk"
+      "amazonka-elasticsearch"
+      "amazonka-elastictranscoder"
+      "amazonka-elb"
+      "amazonka-elbv2"
+      "amazonka-emr"
+      "amazonka-emr-containers"
+      "amazonka-emr-serverless"
+      "amazonka-evidently"
+      "amazonka-finspace"
+      "amazonka-finspace-data"
+      "amazonka-fis"
+      "amazonka-fms"
+      "amazonka-forecast"
+      "amazonka-forecastquery"
+      "amazonka-frauddetector"
+      "amazonka-fsx"
+      "amazonka-gamelift"
+      "amazonka-gamesparks"
+      "amazonka-glacier"
+      "amazonka-globalaccelerator"
+      "amazonka-glue"
+      "amazonka-grafana"
+      "amazonka-greengrass"
+      "amazonka-greengrassv2"
+      "amazonka-groundstation"
+      "amazonka-guardduty"
+      "amazonka-health"
+      "amazonka-healthlake"
+      "amazonka-honeycode"
+      "amazonka-iam"
+      "amazonka-iam-policy"
+      "amazonka-identitystore"
+      "amazonka-imagebuilder"
+      "amazonka-importexport"
+      "amazonka-inspector"
+      "amazonka-inspector2"
+      "amazonka-iot"
+      "amazonka-iot-analytics"
+      "amazonka-iot-dataplane"
+      "amazonka-iot-jobs-dataplane"
+      "amazonka-iot-roborunner"
+      "amazonka-iot1click-devices"
+      "amazonka-iot1click-projects"
+      "amazonka-iotdeviceadvisor"
+      "amazonka-iotevents"
+      "amazonka-iotevents-data"
+      "amazonka-iotfleethub"
+      "amazonka-iotfleetwise"
+      "amazonka-iotsecuretunneling"
+      "amazonka-iotsitewise"
+      "amazonka-iotthingsgraph"
+      "amazonka-iottwinmaker"
+      "amazonka-iotwireless"
+      "amazonka-ivs"
+      "amazonka-ivschat"
+      "amazonka-kafka"
+      "amazonka-kafkaconnect"
+      "amazonka-kendra"
+      "amazonka-keyspaces"
+      "amazonka-kinesis"
+      "amazonka-kinesis-analytics"
+      "amazonka-kinesis-firehose"
+      "amazonka-kinesis-video"
+      "amazonka-kinesis-video-archived-media"
+      "amazonka-kinesis-video-media"
+      "amazonka-kinesis-video-signaling"
+      "amazonka-kinesis-video-webrtc-storage"
+      "amazonka-kinesisanalyticsv2"
+      "amazonka-kms"
+      "amazonka-lakeformation"
+      "amazonka-lambda"
+      "amazonka-lex-models"
+      "amazonka-lex-runtime"
+      "amazonka-lexv2-models"
+      "amazonka-license-manager"
+      "amazonka-license-manager-linux-subscriptions"
+      "amazonka-license-manager-user-subscriptions"
+      "amazonka-lightsail"
+      "amazonka-location"
+      "amazonka-lookoutequipment"
+      "amazonka-lookoutmetrics"
+      "amazonka-lookoutvision"
+      "amazonka-m2"
+      "amazonka-macie"
+      "amazonka-maciev2"
+      "amazonka-managedblockchain"
+      "amazonka-marketplace-analytics"
+      "amazonka-marketplace-catalog"
+      "amazonka-marketplace-entitlement"
+      "amazonka-marketplace-metering"
+      "amazonka-mechanicalturk"
+      "amazonka-mediaconnect"
+      "amazonka-mediaconvert"
+      "amazonka-medialive"
+      "amazonka-mediapackage"
+      "amazonka-mediapackage-vod"
+      "amazonka-mediastore"
+      "amazonka-mediastore-dataplane"
+      "amazonka-mediatailor"
+      "amazonka-memorydb"
+      "amazonka-mgn"
+      "amazonka-migration-hub-refactor-spaces"
+      "amazonka-migrationhub"
+      "amazonka-migrationhub-config"
+      "amazonka-migrationhuborchestrator"
+      "amazonka-migrationhubstrategy"
+      "amazonka-ml"
+      "amazonka-mobile"
+      "amazonka-mq"
+      "amazonka-mtl"
+      "amazonka-mwaa"
+      "amazonka-neptune"
+      "amazonka-network-firewall"
+      "amazonka-networkmanager"
+      "amazonka-nimble"
+      "amazonka-oam"
+      "amazonka-omics"
+      "amazonka-opensearch"
+      "amazonka-opensearchserverless"
+      "amazonka-opsworks"
+      "amazonka-opsworks-cm"
+      "amazonka-organizations"
+      "amazonka-outposts"
+      "amazonka-panorama"
+      "amazonka-personalize"
+      "amazonka-personalize-events"
+      "amazonka-personalize-runtime"
+      "amazonka-pi"
+      "amazonka-pinpoint"
+      "amazonka-pinpoint-email"
+      "amazonka-pinpoint-sms-voice"
+      "amazonka-pinpoint-sms-voice-v2"
+      "amazonka-pipes"
+      "amazonka-polly"
+      "amazonka-pricing"
+      "amazonka-privatenetworks"
+      "amazonka-proton"
+      "amazonka-qldb"
+      "amazonka-qldb-session"
+      "amazonka-quicksight"
+      "amazonka-ram"
+      "amazonka-rbin"
+      "amazonka-rds"
+      "amazonka-rds-data"
+      "amazonka-redshift"
+      "amazonka-redshift-data"
+      "amazonka-redshift-serverless"
+      "amazonka-rekognition"
+      "amazonka-resiliencehub"
+      "amazonka-resource-explorer-v2"
+      "amazonka-resourcegroups"
+      "amazonka-resourcegroupstagging"
+      "amazonka-robomaker"
+      "amazonka-rolesanywhere"
+      "amazonka-route53"
+      "amazonka-route53-autonaming"
+      "amazonka-route53-domains"
+      "amazonka-route53-recovery-cluster"
+      "amazonka-route53-recovery-control-config"
+      "amazonka-route53-recovery-readiness"
+      "amazonka-route53resolver"
+      "amazonka-rum"
+      "amazonka-s3"
+      "amazonka-s3-encryption"
+      #"amazonka-s3-streaming"
+      "amazonka-s3outposts"
+      "amazonka-sagemaker"
+      "amazonka-sagemaker-a2i-runtime"
+      "amazonka-sagemaker-edge"
+      "amazonka-sagemaker-featurestore-runtime"
+      "amazonka-sagemaker-geospatial"
+      "amazonka-sagemaker-metrics"
+      "amazonka-sagemaker-runtime"
+      "amazonka-savingsplans"
+      "amazonka-scheduler"
+      "amazonka-schemas"
+      "amazonka-sdb"
+      "amazonka-secretsmanager"
+      "amazonka-securityhub"
+      "amazonka-securitylake"
+      "amazonka-serverlessrepo"
+      "amazonka-service-quotas"
+      "amazonka-servicecatalog"
+      "amazonka-servicecatalog-appregistry"
+      "amazonka-ses"
+      "amazonka-sesv2"
+      "amazonka-shield"
+      "amazonka-signer"
+      "amazonka-simspaceweaver"
+      "amazonka-sms"
+      "amazonka-sms-voice"
+      "amazonka-snow-device-management"
+      "amazonka-snowball"
+      "amazonka-sns"
+      "amazonka-sqs"
+      "amazonka-ssm"
+      "amazonka-ssm-contacts"
+      "amazonka-ssm-incidents"
+      "amazonka-ssm-sap"
+      "amazonka-sso"
+      "amazonka-sso-admin"
+      "amazonka-sso-oidc"
+      "amazonka-stepfunctions"
+      "amazonka-storagegateway"
+      "amazonka-sts"
+      "amazonka-support"
+      "amazonka-support-app"
+      "amazonka-swf"
+      "amazonka-synthetics"
+      #"amazonka-test"
+      "amazonka-textract"
+      "amazonka-timestream-query"
+      "amazonka-timestream-write"
+      "amazonka-transcribe"
+      "amazonka-transfer"
+      "amazonka-translate"
+      "amazonka-voice-id"
+      "amazonka-waf"
+      "amazonka-waf-regional"
+      "amazonka-wafv2"
+      "amazonka-wellarchitected"
+      "amazonka-wisdom"
+      "amazonka-workdocs"
+      "amazonka-worklink"
+      "amazonka-workmail"
+      "amazonka-workmailmessageflow"
+      "amazonka-workspaces"
+      "amazonka-workspaces-web"
+      "amazonka-xray"
+    ];
     amazonkaServiceOverrides = (
       lib.genAttrs amazonkaServices (
         name:

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

···
       libraryHaskellDepends = drv.libraryHaskellDepends ++ [ self.file-embed ];
     }) (disableCabalFlag "fixity-th" super.fourmolu);
 
-    # https://github.com/NixOS/nixpkgs/issues/149692
-    Agda = disableCabalFlag "optimise-heavily" super.Agda;
+    Agda = lib.pipe super.Agda [
+      # https://github.com/NixOS/nixpkgs/issues/149692
+      (disableCabalFlag "optimise-heavily")
+      # https://github.com/agda/agda/issues/8016
+      (appendConfigureFlag "--ghc-option=-Wwarn=deprecations")
+    ];
 
     # https://github.com/NixOS/nixpkgs/issues/198495
     eventsourcing-postgresql = dontCheck super.eventsourcing-postgresql;

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

···
 
   hlint = self.hlint_3_4_1;
 
+  # test suite depends on vcr since hpack >= 0.38.1 which requires GHC2021
+  hpack_0_38_1 = dontCheck super.hpack_0_38_1;
+
   mime-string = disableOptimization super.mime-string;
 
   # weeder 2.3.* no longer supports GHC 8.10

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

···
       "haskell-language-server has dropped support for ghc 9.0 in version 2.4.0.0, please use a newer ghc version or an older nixpkgs version"
       (markBroken super.haskell-language-server);
 
+  # test suite depends on vcr since hpack >= 0.38.1 which requires GHC2021
+  hpack_0_38_1 = dontCheck super.hpack_0_38_1;
+
   # Needs to use ghc-lib due to incompatible GHC
   ghc-tags = doDistribute self.ghc-tags_1_5;
 

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

···
   tagged = doDistribute self.tagged_0_8_9;
   time-compat = doDistribute self.time-compat_1_9_8;
   extensions = doDistribute self.extensions_0_1_0_3;
-  doctest = doDistribute self.doctest_0_24_0;
+  doctest = doDistribute self.doctest_0_24_2; # see :/doctest_0_24_2 =/ below
   ghc-syntax-highlighter = doDistribute self.ghc-syntax-highlighter_0_0_13_0;
   ghc-lib = doDistribute self.ghc-lib_9_12_2_20250421;
   ghc-exactprint = doDistribute self.ghc-exactprint_1_12_0_0;
···
 
   relude = dontCheck super.relude;
 
-  doctest_0_24_0 = overrideCabal (drv: {
+  doctest_0_24_2 = overrideCabal (drv: {
     testFlags = drv.testFlags or [ ] ++ [
       # These tests require cabal-install (would cause infinite recursion)
       "--skip=/Cabal.Options"
       "--skip=/Cabal.Paths/paths"
       "--skip=/Cabal.ReplOptions" # >= 0.23
     ];
-  }) super.doctest_0_24_0;
+  }) super.doctest_0_24_2;
 
   # https://gitlab.haskell.org/ghc/ghc/-/issues/25930
   generic-lens = dontCheck super.generic-lens;
···
   };
 
   # Allow Cabal 3.14
-  hpack = doDistribute self.hpack_0_38_0;
+  hpack = doDistribute self.hpack_0_38_1;
 }

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

···
   - AC-BuildPlatform # failure in job https://hydra.nixos.org/build/233219130 at 2023-09-02
   - AC-EasyRaster-GTK # failure in job https://hydra.nixos.org/build/233226232 at 2023-09-02
   - AC-HalfInteger # failure in job https://hydra.nixos.org/build/233239266 at 2023-09-02
+  - ac-library-hs # failure in job https://hydra.nixos.org/build/302800699 at 2025-07-27
   - ac-machine # failure in job https://hydra.nixos.org/build/233253535 at 2023-09-02
   - AC-MiniTest # failure in job https://hydra.nixos.org/build/233216015 at 2023-09-02
   - AC-Terminal # failure in job https://hydra.nixos.org/build/233192747 at 2023-09-02
···
   - ascii-string # failure in job https://hydra.nixos.org/build/233249978 at 2023-09-02
   - ascii-vector-avc # failure in job https://hydra.nixos.org/build/233208533 at 2023-09-02
   - ascii85-conduit # failure in job https://hydra.nixos.org/build/233235427 at 2023-09-02
+  - ascii85x # failure in job https://hydra.nixos.org/build/302801241 at 2025-07-27
   - asciidiagram # failure in job https://hydra.nixos.org/build/233259020 at 2023-09-02
   - asif # failure in job https://hydra.nixos.org/build/233251551 at 2023-09-02
   - asil # failure in job https://hydra.nixos.org/build/233204081 at 2023-09-02
···
   - auto # failure in job https://hydra.nixos.org/build/233211088 at 2023-09-02
   - auto-split # failure in job https://hydra.nixos.org/build/295091795 at 2025-04-22
   - autoapply # failure in job https://hydra.nixos.org/build/295091805 at 2025-04-22
+  - autodocodec-exact # failure in job https://hydra.nixos.org/build/302801281 at 2025-07-27
   - autom # failure in job https://hydra.nixos.org/build/234461198 at 2023-09-13
   - automata # failure in job https://hydra.nixos.org/build/295091890 at 2025-04-22
   - autonix-deps # failure in job https://hydra.nixos.org/build/233258269 at 2023-09-02
···
   - avwx # failure in job https://hydra.nixos.org/build/233258167 at 2023-09-02
   - awesome-prelude # failure in job https://hydra.nixos.org/build/233232761 at 2023-09-02
   - awesomium-raw # failure in job https://hydra.nixos.org/build/233241036 at 2023-09-02
+  - aws-academy-grade-exporter # failure in job https://hydra.nixos.org/build/302801316 at 2025-07-27
   - aws-cloudfront-signed-cookies # failure in job https://hydra.nixos.org/build/252736035 at 2024-03-16
   - aws-cloudfront-signer # failure in job https://hydra.nixos.org/build/233194723 at 2023-09-02
   - aws-easy # failure building library in job https://hydra.nixos.org/build/237244335 at 2023-10-21
···
   - base32-lens # failure in job https://hydra.nixos.org/build/233226670 at 2023-09-02
   - base58address # failure in job https://hydra.nixos.org/build/233221633 at 2023-09-02
   - base62 # failure in job https://hydra.nixos.org/build/233250040 at 2023-09-02
-  - base64-bytes # failure in job https://hydra.nixos.org/build/295091866 at 2025-04-22
   - base64-conduit # failure in job https://hydra.nixos.org/build/233197196 at 2023-09-02
   - base64-lens # failure in job https://hydra.nixos.org/build/233252600 at 2023-09-02
   - based # failure in job https://hydra.nixos.org/build/233211900 at 2023-09-02
···
   - bliplib # failure in job https://hydra.nixos.org/build/233195751 at 2023-09-02
   - blockchain # failure in job https://hydra.nixos.org/build/233245492 at 2023-09-02
   - blockhash # failure in job https://hydra.nixos.org/build/233227049 at 2023-09-02
+  - blockio-uring # failure in job https://hydra.nixos.org/build/302801498, https://github.com/well-typed/blockio-uring/issues/44 at 2025-07-27
+  - blockio-uring # https://github.com/well-typed/blockio-uring/issues/44, added 2025-07-27
   - Blogdown # failure in job https://hydra.nixos.org/build/233239841 at 2023-09-02
   - BlogLiterately # failure in job https://hydra.nixos.org/build/233202164 at 2023-09-02
   - bloodhound-amazonka-auth # failure building library in job https://hydra.nixos.org/build/237245625 at 2023-10-21
···
   - Cassava # failure in job https://hydra.nixos.org/build/233245677 at 2023-09-02
   - cassava-conduit # failure in job https://hydra.nixos.org/build/233220495 at 2023-09-02
   - cassava-records # failure in job https://hydra.nixos.org/build/233259049 at 2023-09-02
-  - cassette # failure in job https://hydra.nixos.org/build/233201251 at 2023-09-02
   - castle # failure in job https://hydra.nixos.org/build/233204027 at 2023-09-02
   - catamorphism # failure in job https://hydra.nixos.org/build/233208488 at 2023-09-02
   - Catana # failure in job https://hydra.nixos.org/build/233196550 at 2023-09-02
···
   - category-printf # failure in job https://hydra.nixos.org/build/233216355 at 2023-09-02
   - category-traced # failure in job https://hydra.nixos.org/build/233193963 at 2023-09-02
   - catnplus # failure in job https://hydra.nixos.org/build/233241280 at 2023-09-02
+  - cauldron # failure in job https://hydra.nixos.org/build/302801682 at 2025-07-27
   - cautious-file # failure in job https://hydra.nixos.org/build/233218702 at 2023-09-02
   - cautious-gen # failure in job https://hydra.nixos.org/build/233258367 at 2023-09-02
   - cayene-lpp # failure in job https://hydra.nixos.org/build/233228959 at 2023-09-02
···
   - cmph # failure in job https://hydra.nixos.org/build/233225766 at 2023-09-02
   - CMQ # failure in job https://hydra.nixos.org/build/233233168 at 2023-09-02
   - cmt # failure in job https://hydra.nixos.org/build/233233474 at 2023-09-02
-  - co-log-concurrent # failure in job https://hydra.nixos.org/build/295092333 at 2025-04-22
-  - co-log-json # failure in job https://hydra.nixos.org/build/295092337 at 2025-04-22
   - co-log-polysemy-formatting # failure building executable 'example' in job https://hydra.nixos.org/build/237249360 at 2023-10-21
   - co-log-sys # failure in job https://hydra.nixos.org/build/233206587 at 2023-09-02
   - cobot-tools # failure in job https://hydra.nixos.org/build/233259173 at 2023-09-02
···
   - contra-tracers # failure in job https://hydra.nixos.org/build/233197959 at 2023-09-02
   - contracheck-applicative # failure in job https://hydra.nixos.org/build/233255104 at 2023-09-02
   - Contract # failure in job https://hydra.nixos.org/build/233242103 at 2023-09-02
-  - control-block # failure in job https://hydra.nixos.org/build/295092490 at 2025-04-22
   - control-dsl # failure in job https://hydra.nixos.org/build/233249037 at 2023-09-02
   - control-iso # failure in job https://hydra.nixos.org/build/233229763 at 2023-09-02
   - control-monad-failure # failure in job https://hydra.nixos.org/build/233240265 at 2023-09-02
···
   - contstuff-monads-tf # failure in job https://hydra.nixos.org/build/233224064 at 2023-09-02
   - contstuff-transformers # failure in job https://hydra.nixos.org/build/233244153 at 2023-09-02
   - conversion-bytestring # failure in job https://hydra.nixos.org/build/295092506 at 2025-04-22
+  - convex-schema-parser # failure in job https://hydra.nixos.org/build/302801971 at 2025-07-27
   - cookie-tray # failure in job https://hydra.nixos.org/build/295092527 at 2025-04-22
   - cooklang-hs # failure in job https://hydra.nixos.org/build/295092511 at 2025-04-22
   - copilot-bluespec # failure in job https://hydra.nixos.org/build/253685418 at 2024-03-31
···
   - cuckoo # failure in job https://hydra.nixos.org/build/233210915 at 2023-09-02
   - cuckoo-filter # failure in job https://hydra.nixos.org/build/233226484 at 2023-09-02
   - cudd # failure in job https://hydra.nixos.org/build/252716117 at 2024-03-16
+  - cuddle # failure in job https://hydra.nixos.org/build/302802065 at 2025-07-27
   - curl-aeson # failure in job https://hydra.nixos.org/build/233210106 at 2023-09-02
   - curl-runnings # failure in job https://hydra.nixos.org/build/233258680 at 2023-09-02
   - currency-convert # failure in job https://hydra.nixos.org/build/233224509 at 2023-09-02
···
   - dia-base # failure in job https://hydra.nixos.org/build/233230896 at 2023-09-02
   - diagnose # failure in job https://hydra.nixos.org/build/233231767 at 2023-09-02
   - diagrams-boolean # failure in job https://hydra.nixos.org/build/233202036 at 2023-09-02
-  - diagrams-gtk # failure in job https://hydra.nixos.org/build/295092833 at 2025-04-22
   - diagrams-haddock # failure in job https://hydra.nixos.org/build/295092844 at 2025-04-22
-  - diagrams-pandoc # failure in job https://hydra.nixos.org/build/295092840 at 2025-04-22
   - diagrams-pdf # failure in job https://hydra.nixos.org/build/233197864 at 2023-09-02
   - diagrams-qrcode # failure in job https://hydra.nixos.org/build/233229542 at 2023-09-02
   - diagrams-rubiks-cube # failure in job https://hydra.nixos.org/build/233213426 at 2023-09-02
···
   - direm # failure in job https://hydra.nixos.org/build/233211496 at 2023-09-02
   - dirstream # failure in job https://hydra.nixos.org/build/273442606 at 2024-10-01
   - disco # failure in job https://hydra.nixos.org/build/233212298 at 2023-09-02
-  - discord-haskell # failure in job https://hydra.nixos.org/build/295092870 at 2025-04-22
   - discord-register # failure in job https://hydra.nixos.org/build/295092898 at 2025-04-22
   - discord-types # failure in job https://hydra.nixos.org/build/233251778 at 2023-09-02
   - discordian-calendar # failure in job https://hydra.nixos.org/build/233218124 at 2023-09-02
···
   - DOH # failure in job https://hydra.nixos.org/build/233231913 at 2023-09-02
   - doi # failure in job https://hydra.nixos.org/build/295092999 at 2025-04-22
   - dom-events # failure in job https://hydra.nixos.org/build/233231199 at 2023-09-02
-  - dom-parser # failure in job https://hydra.nixos.org/build/233235797 at 2023-09-02
   - dom-selector # failure in job https://hydra.nixos.org/build/233212663 at 2023-09-02
   - domaindriven-core # failure in job https://hydra.nixos.org/build/233234739 at 2023-09-02
   - dominion # failure in job https://hydra.nixos.org/build/252714022 at 2024-03-16
···
   - dormouse-uri # failure in job https://hydra.nixos.org/build/233191706 at 2023-09-02
   - dot-linker # failure in job https://hydra.nixos.org/build/233237512 at 2023-09-02
   - dotfs # failure in job https://hydra.nixos.org/build/233200762 at 2023-09-02
-  - double-x-encoding # failure in job https://hydra.nixos.org/build/253694746 at 2024-03-31
   - doublezip # failure in job https://hydra.nixos.org/build/233219270 at 2023-09-02
   - doublify-toolkit # failure in job https://hydra.nixos.org/build/233223302 at 2023-09-02
   - dovin # failure in job https://hydra.nixos.org/build/252714139 at 2024-03-16
···
   - dualizer # failure in job https://hydra.nixos.org/build/233237592 at 2023-09-02
   - duckling # failure in job https://hydra.nixos.org/build/233247880 at 2023-09-02
   - duet # failure in job https://hydra.nixos.org/build/233219004 at 2023-09-02
-  - dumb-cas # failure in job https://hydra.nixos.org/build/252730634 at 2024-03-16
   - dump-core # failure in job https://hydra.nixos.org/build/233244428 at 2023-09-02
   - dunai-core # failure in job https://hydra.nixos.org/build/233255804 at 2023-09-02
   - Dung # failure in job https://hydra.nixos.org/build/233206343 at 2023-09-02
···
   - editline # failure in job https://hydra.nixos.org/build/233259515 at 2023-09-02
   - edits # failure in job https://hydra.nixos.org/build/295093075 at 2025-04-22
   - effect-handlers # failure in job https://hydra.nixos.org/build/233234988 at 2023-09-02
-  - effect-stack # failure in job https://hydra.nixos.org/build/233212358 at 2023-09-02
   - effectful-st # failure in job https://hydra.nixos.org/build/233248591 at 2023-09-02
   - effectful-zoo # failure in job https://hydra.nixos.org/build/283208805 at 2024-12-31
   - effective-aspects # failure in job https://hydra.nixos.org/build/233223120 at 2023-09-02
···
   - exinst-hashable # failure in job https://hydra.nixos.org/build/233210438 at 2023-09-02
   - exists # failure in job https://hydra.nixos.org/build/233243541 at 2023-09-02
   - exitcode # failure in job https://hydra.nixos.org/build/233238454 at 2023-09-02
+  - exotic-list-monads # failure in job https://hydra.nixos.org/build/302802593 at 2025-07-27
   - exp-cache # failure in job https://hydra.nixos.org/build/233220561 at 2023-09-02
   - exp-extended # failure in job https://hydra.nixos.org/build/233236139 at 2023-09-02
   - experimenter # failure in job https://hydra.nixos.org/build/252726011 at 2024-03-16
···
   - frown # failure in job https://hydra.nixos.org/build/233208462 at 2023-09-02
   - frp-arduino # failure in job https://hydra.nixos.org/build/233192216 at 2023-09-02
   - frpnow # failure in job https://hydra.nixos.org/build/233236056 at 2023-09-02
-  - fs-api # failure in job https://hydra.nixos.org/build/299137683 at 2025-06-23
   - fs-events # failure in job https://hydra.nixos.org/build/233218231 at 2023-09-02
   - fsh-csv # failure in job https://hydra.nixos.org/build/233220196 at 2023-09-02
   - FSM # failure in job https://hydra.nixos.org/build/233247343 at 2023-09-02
···
   - funcons-tools # failure in job https://hydra.nixos.org/build/295122838 at 2025-04-22
   - function-instances-algebra # failure in job https://hydra.nixos.org/build/233202209 at 2023-09-02
   - functional-arrow # failure in job https://hydra.nixos.org/build/295093396 at 2025-04-22
-  - functor-combinators # failure in job https://hydra.nixos.org/build/252714438 at 2024-03-16
   - functor-friends # failure in job https://hydra.nixos.org/build/233208108 at 2023-09-02
   - functor-infix # failure in job https://hydra.nixos.org/build/233228794 at 2023-09-02
   - functor-utils # failure in job https://hydra.nixos.org/build/233213259 at 2023-09-02
···
   - fwgl # failure in job https://hydra.nixos.org/build/233246210 at 2023-09-02
   - fwgl-javascript # broken by fwgl, manually entered here, because it does not appear in transitive-broken.yaml at 2024-07-09
   - fx # failure in job https://hydra.nixos.org/build/295093438 at 2025-04-22
-  - fxpak # failure in job https://hydra.nixos.org/build/265955610 at 2024-07-14
   - g-npm # failure in job https://hydra.nixos.org/build/233215965 at 2023-09-02
   - g4ip # failure in job https://hydra.nixos.org/build/233248315 at 2023-09-02
   - gambler # failure in job https://hydra.nixos.org/build/252732701 at 2024-03-16
···
   - GeneralTicTacToe # failure in job https://hydra.nixos.org/build/233207939 at 2023-09-02
   - generator # failure in job https://hydra.nixos.org/build/233213384 at 2023-09-02
   - generators # failure in job https://hydra.nixos.org/build/233246459 at 2023-09-02
-  - generic-aeson # failure in job https://hydra.nixos.org/build/233198064 at 2023-09-02
   - generic-binary # failure in job https://hydra.nixos.org/build/233214473 at 2023-09-02
   - generic-church # failure in job https://hydra.nixos.org/build/233213419 at 2023-09-02
   - generic-enum # failure in job https://hydra.nixos.org/build/233220316 at 2023-09-02
···
   - gentlemark # failure in job https://hydra.nixos.org/build/233202158 at 2023-09-02
   - genvalidity-appendful # failure in job https://hydra.nixos.org/build/295093519 at 2025-04-22
   - genvalidity-mergeful # failure in job https://hydra.nixos.org/build/295093508 at 2025-04-22
-  - genvalidity-network-uri # failure in job https://hydra.nixos.org/build/299137822 at 2025-06-23
   - geo-resolver # failure in job https://hydra.nixos.org/build/233206563 at 2023-09-02
   - geo-uk # failure in job https://hydra.nixos.org/build/233221284 at 2023-09-02
   - geocode-google # failure in job https://hydra.nixos.org/build/233191594 at 2023-09-02
···
   - gi-gio-hs-list-model # failure in job https://hydra.nixos.org/build/233241640 at 2023-09-02
   - gi-gstapp # failure in job https://hydra.nixos.org/build/253686159 at 2024-03-31
   - gi-gsttag # failure in job https://hydra.nixos.org/build/233197576 at 2023-09-02
+  - gi-gtk4-layer-shell # failure in job https://hydra.nixos.org/build/302803068 at 2025-07-27
   - gi-gtksheet # failure in job https://hydra.nixos.org/build/233211386 at 2023-09-02
   - gi-ibus # failure in job https://hydra.nixos.org/build/233220272 at 2023-09-02
   - gi-keybinder # failure in job https://hydra.nixos.org/build/265273447 at 2024-07-14
···
   - giak # failure in job https://hydra.nixos.org/build/233242229 at 2023-09-02
   - gibberish # failure in job https://hydra.nixos.org/build/255688714 at 2024-04-16
   - Gifcurry # failure in job https://hydra.nixos.org/build/233200204 at 2023-09-02
+  - ginger2 # failure in job https://hydra.nixos.org/build/302803092 at 2025-07-27
   - gingersnap # failure in job https://hydra.nixos.org/build/233227186 at 2023-09-02
   - ginsu # failure in job https://hydra.nixos.org/build/233223259 at 2023-09-02
   - gipeda # failure in job https://hydra.nixos.org/build/233228149 at 2023-09-02
···
   - haskelldb-wx # failure in job https://hydra.nixos.org/build/233197525 at 2023-09-02
   - HaskellForMaths # failure in job https://hydra.nixos.org/build/233237608 at 2023-09-02
   - HaskellLM # failure in job https://hydra.nixos.org/build/233237641 at 2023-09-02
-  - HaskellNet # failure in job https://hydra.nixos.org/build/295091001 at 2025-04-22
   - HaskellNN # failure in job https://hydra.nixos.org/build/233209323 at 2023-09-02
   - Haskelloids # failure in job https://hydra.nixos.org/build/233204861 at 2023-09-02
   - haskellscrabble # failure in job https://hydra.nixos.org/build/233251248 at 2023-09-02
···
   - haskoin # failure in job https://hydra.nixos.org/build/233201668 at 2023-09-02
   - haskoin-store # failure in job https://hydra.nixos.org/build/299138382 at 2025-06-23
   - haskoin-util # failure in job https://hydra.nixos.org/build/233222171 at 2023-09-02
-  - haskoin-wallet # failure in job https://hydra.nixos.org/build/233206922 at 2023-09-02
   - haskore-realtime # failure in job https://hydra.nixos.org/build/301391170 at 2025-07-01
   - haskore-vintage # failure in job https://hydra.nixos.org/build/233230742 at 2023-09-02
   - HaskRel # failure in job https://hydra.nixos.org/build/295090970 at 2025-04-22
···
   - hbeat # failure in job https://hydra.nixos.org/build/233228628 at 2023-09-02
   - hblas # failure in job https://hydra.nixos.org/build/233232561 at 2023-09-02
   - hblock # failure in job https://hydra.nixos.org/build/233205351 at 2023-09-02
+  - hblosc # failure in job https://hydra.nixos.org/build/302803521 at 2025-07-27
   - hburg # failure in job https://hydra.nixos.org/build/233247429 at 2023-09-02
   - hcad # failure in job https://hydra.nixos.org/build/233219976 at 2023-09-02
   - HCard # failure in job https://hydra.nixos.org/build/233231922 at 2023-09-02
···
   - heckle # failure in job https://hydra.nixos.org/build/233228954 at 2023-09-02
   - heddit # failure in job https://hydra.nixos.org/build/233229058 at 2023-09-02
   - hedgehog-checkers # failure in job https://hydra.nixos.org/build/233229405 at 2023-09-02
+  - hedgehog-extras # failure in job https://hydra.nixos.org/build/302803553, https://github.com/input-output-hk/hedgehog-extras/issues/93 at 2025-07-27
   - hedgehog-gen # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/237243271 at 2023-10-21
   - hedgehog-generic # failure in job https://hydra.nixos.org/build/233204695 at 2023-09-02
   - hedgehog-golden # failure in job https://hydra.nixos.org/build/233219619 at 2023-09-02
···
   - hs-scrape # failure in job https://hydra.nixos.org/build/233244221 at 2023-09-02
   - hs-server-starter # failure in job https://hydra.nixos.org/build/295094379 at 2025-04-22
   - hs-snowtify # failure in job https://hydra.nixos.org/build/233200511 at 2023-09-02
-  - hs-speedscope # failure in job https://hydra.nixos.org/build/295094385 at 2025-04-22
   - hs-tags # failure in job https://hydra.nixos.org/build/233258358 at 2023-09-02
   - hs-tango # failure in job https://hydra.nixos.org/build/276377558 at 2024-11-06
   - hs-term-emulator # failure in job https://hydra.nixos.org/build/233252262 at 2023-09-02
···
   - IDynamic # failure in job https://hydra.nixos.org/build/233196222 at 2023-09-02
   - ieee-utils # failure in job https://hydra.nixos.org/build/233224430 at 2023-09-02
   - iexcloud # failure in job https://hydra.nixos.org/build/233224874 at 2023-09-02
+  - if-instance # failure in job https://hydra.nixos.org/build/302803982 at 2025-07-27
   - ifcxt # failure in job https://hydra.nixos.org/build/233196911 at 2023-09-02
   - IFS # failure in job https://hydra.nixos.org/build/233246865 at 2023-09-02
   - ig # failure in job https://hydra.nixos.org/build/233203872 at 2023-09-02
···
   - interspersed # failure in job https://hydra.nixos.org/build/252722645 at 2024-03-16
   - interval # failure in job https://hydra.nixos.org/build/233239434 at 2023-09-02
   - interval-algebra # failure in job https://hydra.nixos.org/build/233208487 at 2023-09-02
-  - interval-patterns # failure in job https://hydra.nixos.org/build/239259401 at 2023-11-10
   - interval-tree-clock # failure in job https://hydra.nixos.org/build/233234316 at 2023-09-02
   - IntFormats # failure in job https://hydra.nixos.org/build/233195190 at 2023-09-02
   - intricacy # failure in job https://hydra.nixos.org/build/252711846 at 2024-03-16
···
   - isdicom # failure in job https://hydra.nixos.org/build/233214249 at 2023-09-02
   - IsNull # failure in job https://hydra.nixos.org/build/233233011 at 2023-09-02
   - iso-deriving # failure in job https://hydra.nixos.org/build/252738238 at 2024-03-16
-  - iso8601-duration # failure in job https://hydra.nixos.org/build/233190968 at 2023-09-02
   - isobmff # failure in job https://hydra.nixos.org/build/233237273 at 2023-09-02
   - isotope # failure in job https://hydra.nixos.org/build/233204650 at 2023-09-02
   - it-has # failure in job https://hydra.nixos.org/build/233212395 at 2023-09-02
···
   - json-qq # failure in job https://hydra.nixos.org/build/233196259 at 2023-09-02
   - json-rpc-generic # failure in job https://hydra.nixos.org/build/233201371 at 2023-09-02
   - json-rpc-server # failure in job https://hydra.nixos.org/build/233201284 at 2023-09-02
+  - json-schema # failure in job https://hydra.nixos.org/build/303231342 at 2025-07-27
   - json-syntax # failure in job https://hydra.nixos.org/build/233250639 at 2023-09-02
   - json-to-haskell # failure in job https://hydra.nixos.org/build/252711573 at 2024-03-16
   - json-to-type # failure in job https://hydra.nixos.org/build/275143966 at 2024-10-21
···
   - llvm-base # failure in job https://hydra.nixos.org/build/233244366 at 2023-09-02
   - llvm-codegen # failure in job https://hydra.nixos.org/build/295095119 at 2025-04-22
   - llvm-extension # failure in job https://hydra.nixos.org/build/266355631 at 2024-07-14
+  - llvm-extra # failure in job https://hydra.nixos.org/build/303481607 at 2025-07-27
   - llvm-general-pure # failure in job https://hydra.nixos.org/build/233246430 at 2023-09-02
   - llvm-hs # failure in job https://hydra.nixos.org/build/233205149 at 2023-09-02
   - llvm-hs-pure # failure in job https://hydra.nixos.org/build/252721738 at 2024-03-16
···
   - mcm # failure in job https://hydra.nixos.org/build/233229087 at 2023-09-02
   - mcmaster-gloss-examples # failure in job https://hydra.nixos.org/build/234457610 at 2023-09-13
   - mcmc-synthesis # failure in job https://hydra.nixos.org/build/233208414 at 2023-09-02
+  - mcp # failure in job https://hydra.nixos.org/build/302804588 at 2025-07-27
+  - mcp-server # failure in job https://hydra.nixos.org/build/302804602 at 2025-07-27
   - mcpi # failure in job https://hydra.nixos.org/build/233231465 at 2023-09-02
   - mdapi # failure in job https://hydra.nixos.org/build/233257724 at 2023-09-02
   - mdcat # failure in job https://hydra.nixos.org/build/233249429 at 2023-09-02
···
   - monoid-absorbing # failure in job https://hydra.nixos.org/build/233236465 at 2023-09-02
   - monoid-owns # failure in job https://hydra.nixos.org/build/233259043 at 2023-09-02
   - monoidmap # failure in job https://hydra.nixos.org/build/295095498 at 2025-04-22
-  - monoidmap-internal # failure in job https://hydra.nixos.org/build/295095513 at 2025-04-22
   - monoidplus # failure in job https://hydra.nixos.org/build/233226759 at 2023-09-02
   - monoids # failure in job https://hydra.nixos.org/build/233231684 at 2023-09-02
   - monopati # failure in job https://hydra.nixos.org/build/233234119 at 2023-09-02
···
   - movie-monad # failure in job https://hydra.nixos.org/build/233215402 at 2023-09-02
   - mpppc # failure in job https://hydra.nixos.org/build/233223008 at 2023-09-02
   - mpris # failure in job https://hydra.nixos.org/build/233259241 at 2023-09-02
+  - mptcp-pm # failure in job https://hydra.nixos.org/build/303231350 at 2025-07-27
   - mpvguihs # failure in job https://hydra.nixos.org/build/233196650 at 2023-09-02
   - mqtt # failure in job https://hydra.nixos.org/build/233202067 at 2023-09-02
   - mqtt-hs # failure in job https://hydra.nixos.org/build/233239399 at 2023-09-02
···
   - ms-auth # failure in job https://hydra.nixos.org/build/233193383 at 2023-09-02
   - ms-azure-api # failure in job https://hydra.nixos.org/build/233202229 at 2023-09-02
   - ms-graph-api # failure in job https://hydra.nixos.org/build/233219042 at 2023-09-02
-  - msgpack # failure in job https://hydra.nixos.org/build/233258131 at 2023-09-02
+  - msgpack-aeson # failure in job https://hydra.nixos.org/build/303231349 at 2025-07-27
+  - msgpack-rpc # failure in job https://hydra.nixos.org/build/303231348 at 2025-07-27
   - msgpack-types # failure in job https://hydra.nixos.org/build/233235351 at 2023-09-02
   - msh # failure in job https://hydra.nixos.org/build/233196466 at 2023-09-02
   - MTGBuilder # failure in job https://hydra.nixos.org/build/233227528 at 2023-09-02
···
   - ohhecs # failure in job https://hydra.nixos.org/build/267987310 at 2024-07-31
   - ohloh-hs # failure in job https://hydra.nixos.org/build/233228177 at 2023-09-02
   - oi # failure in job https://hydra.nixos.org/build/233190838 at 2023-09-02
-  - oidc-client # failure in job https://hydra.nixos.org/build/295095776 at 2025-04-22
   - okapi # failure in job https://hydra.nixos.org/build/233193822 at 2023-09-02
   - old-version # failure in job https://hydra.nixos.org/build/233198538 at 2023-09-02
   - ollama-haskell # failure in job https://hydra.nixos.org/build/276371507 at 2024-11-06
···
   - openssh-protocol # failure in job https://hydra.nixos.org/build/233196013 at 2023-09-02
   - opentelemetry-extra # failure in job https://hydra.nixos.org/build/233194254 at 2023-09-02
   - opentelemetry-http-client # failure in job https://hydra.nixos.org/build/233221983 at 2023-09-02
-  - opentelemetry-plugin # failure in job https://hydra.nixos.org/build/295095836 at 2025-04-22
   - opentheory-char # failure in job https://hydra.nixos.org/build/233222347 at 2023-09-02
   - opentype # failure in job https://hydra.nixos.org/build/233213443 at 2023-09-02
   - OpenVGRaw # failure in job https://hydra.nixos.org/build/233254457 at 2023-09-02
···
   - overloaded-records # failure in job https://hydra.nixos.org/build/233235922 at 2023-09-02
   - overture # failure in job https://hydra.nixos.org/build/233245959 at 2023-09-02
   - owoify-hs # failure in job https://hydra.nixos.org/build/233213422 at 2023-09-02
+  - ox-arrays # failure in job https://hydra.nixos.org/build/302805170 at 2025-07-27
   - pa-field-parser # failure in job https://hydra.nixos.org/build/295095885 at 2025-04-22
   - pack # failure in job https://hydra.nixos.org/build/233243562 at 2023-09-02
   - package-description-remote # failure in job https://hydra.nixos.org/build/233221358 at 2023-09-02
   - package-vt # failure in job https://hydra.nixos.org/build/233225831 at 2023-09-02
   - packdeps # failure in job https://hydra.nixos.org/build/233216607 at 2023-09-02
   - packed # failure in job https://hydra.nixos.org/build/233231889 at 2023-09-02
+  - packed-data # failure in job https://hydra.nixos.org/build/302805203 at 2025-07-27
   - packed-dawg # failure in job https://hydra.nixos.org/build/233207332 at 2023-09-02
   - packed-multikey-map # failure in job https://hydra.nixos.org/build/233234157 at 2023-09-02
   - packedstring # failure in job https://hydra.nixos.org/build/233240511 at 2023-09-02
···
   - plural # failure in job https://hydra.nixos.org/build/233198934 at 2023-09-02
   - ply-loader # failure in job https://hydra.nixos.org/build/252720663 at 2024-03-16
   - plzwrk # failure in job https://hydra.nixos.org/build/233219630 at 2023-09-02
+  - pms-domain-model # failure in job https://hydra.nixos.org/build/302805399 at 2025-07-27
   - pngload-fixed # failure in job https://hydra.nixos.org/build/233233956 at 2023-09-02
   - pocket # failure in job https://hydra.nixos.org/build/233244120 at 2023-09-02
   - podenv # failure in job https://hydra.nixos.org/build/233210257 at 2023-09-02
···
   - pontarius-xpmn # failure in job https://hydra.nixos.org/build/233217546 at 2023-09-02
   - pool # failure in job https://hydra.nixos.org/build/233205364 at 2023-09-02
   - pool-conduit # failure in job https://hydra.nixos.org/build/233246643 at 2023-09-02
-  - poolboy # failure in job https://hydra.nixos.org/build/233195085 at 2023-09-02
   - pop3-client # failure in job https://hydra.nixos.org/build/233251475 at 2023-09-02
   - popkey # failure in job https://hydra.nixos.org/build/233203892 at 2023-09-02
   - poppler # failure in job https://hydra.nixos.org/build/233196044 at 2023-09-02
···
   - quickbooks # failure in job https://hydra.nixos.org/build/233227666 at 2023-09-02
   - quickcheck-arbitrary-template # failure in job https://hydra.nixos.org/build/233223045 at 2023-09-02
   - quickcheck-combinators # failure in job https://hydra.nixos.org/build/233209131 at 2023-09-02
-  - quickcheck-lockstep # failure in job https://hydra.nixos.org/build/295096463 at 2025-04-22
   - quickcheck-property-comb # failure in job https://hydra.nixos.org/build/233204877 at 2023-09-02
   - quickcheck-property-monad # failure in job https://hydra.nixos.org/build/233228775 at 2023-09-02
   - quickcheck-rematch # failure in job https://hydra.nixos.org/build/233205449 at 2023-09-02
···
   - regexqq # failure in job https://hydra.nixos.org/build/233233149 at 2023-09-02
   - regions # failure in job https://hydra.nixos.org/build/233196483 at 2023-09-02
   - register-machine-typelevel # failure in job https://hydra.nixos.org/build/233217514 at 2023-09-02
+  - registry-messagepack # failure in job https://hydra.nixos.org/build/303231364 at 2025-07-27
   - registry-options # failure in job https://hydra.nixos.org/build/295096594 at 2025-04-22
   - regress # failure in job https://hydra.nixos.org/build/233208901 at 2023-09-02
   - regular # failure in job https://hydra.nixos.org/build/233232656 at 2023-09-02
···
   - servant-avro # failure in job https://hydra.nixos.org/build/233225632 at 2023-09-02
   - servant-benchmark # failure in job https://hydra.nixos.org/build/233203748 at 2023-09-02
   - servant-cassava # failure in job https://hydra.nixos.org/build/252730906 at 2024-03-16
-  - servant-cli # failure in job https://hydra.nixos.org/build/233259212 at 2023-09-02
   - servant-client-js # failure in job https://hydra.nixos.org/build/233194725 at 2023-09-02
   - servant-combinators # failure in job https://hydra.nixos.org/build/233249924 at 2023-09-02
   - servant-db # failure in job https://hydra.nixos.org/build/233234946 at 2023-09-02
···
   - servant-docs-simple # failure in job https://hydra.nixos.org/build/233237374 at 2023-09-02
   - servant-ekg # failure in job https://hydra.nixos.org/build/295096851 at 2025-04-22
   - servant-errors # failure in job https://hydra.nixos.org/build/233239712 at 2023-09-02
+  - servant-event-stream # failure in job https://hydra.nixos.org/build/302806100 at 2025-07-27
   - servant-gdp # failure in job https://hydra.nixos.org/build/233191664 at 2023-09-02
   - servant-generate # failure in job https://hydra.nixos.org/build/233199452 at 2023-09-02
   - servant-generic # failure in job https://hydra.nixos.org/build/233211338 at 2023-09-02
···
   - servant-to-elm # failure in job https://hydra.nixos.org/build/253681347 at 2024-03-31
   - servant-tracing # failure in job https://hydra.nixos.org/build/233229308 at 2023-09-02
   - servant-typed-error # failure in job https://hydra.nixos.org/build/252727241 at 2024-03-16
-  - servant-typescript # failure in job https://hydra.nixos.org/build/253932573 at 2024-03-31
   - servant-util # failure in job https://hydra.nixos.org/build/252729690 at 2024-03-16
   - servant-wasm # failure in job https://hydra.nixos.org/build/233191644 at 2023-09-02
   - servant-xml-conduit # failure in job https://hydra.nixos.org/build/243828707 at 2024-01-01
···
   - skemmtun # failure in job https://hydra.nixos.org/build/233223893 at 2023-09-02
   - sketch-frp-copilot # copilot >=4.3 && <4.4,
   - skew-list # failure in job https://hydra.nixos.org/build/295097034 at 2025-04-22
+  - skews # time out in job https://hydra.nixos.org/build/302806286 at 2025-07-27
   - skopedate # failure in job https://hydra.nixos.org/build/233220634 at 2023-09-02
   - skulk # failure in job https://hydra.nixos.org/build/233258672 at 2023-09-02
   - skylighting-extensions # failure in job https://hydra.nixos.org/build/233221387 at 2023-09-02
···
   - socketed # failure in job https://hydra.nixos.org/build/233210087 at 2023-09-02
   - socketio # failure in job https://hydra.nixos.org/build/233214659 at 2023-09-02
   - sockets # failure in job https://hydra.nixos.org/build/295097095 at 2025-04-22
+  - socks5 # failure in job https://hydra.nixos.org/build/302806344 at 2025-07-27
   - sodium # failure in job https://hydra.nixos.org/build/233213989 at 2023-09-02
   - soegtk # failure in job https://hydra.nixos.org/build/233198991 at 2023-09-02
   - softfloat-hs # failure in job https://hydra.nixos.org/build/233205242 at 2023-09-02
···
   - sonic-visualiser # failure in job https://hydra.nixos.org/build/233257956 at 2023-09-02
   - Sonnex # failure in job https://hydra.nixos.org/build/233229367 at 2023-09-02
   - SoOSiM # failure in job https://hydra.nixos.org/build/233224114 at 2023-09-02
+  - sop-satisfier # failure in job https://hydra.nixos.org/build/302806351 at 2025-07-27
   - sorted # failure in job https://hydra.nixos.org/build/233222633 at 2023-09-02
   - sorting # failure in job https://hydra.nixos.org/build/233214204 at 2023-09-02
   - sorty # failure in job https://hydra.nixos.org/build/233211118 at 2023-09-02
···
   - system-test # failure in job https://hydra.nixos.org/build/233240318 at 2023-09-02
   - systemd-ntfy # failure in job https://hydra.nixos.org/build/236686880 at 2023-10-04
   - systemd-socket-activation # failure in job https://hydra.nixos.org/build/295097415 at 2025-04-22
-  - systranything # failure in job https://hydra.nixos.org/build/295097462 at 2025-04-22
   - t-regex # failure in job https://hydra.nixos.org/build/233254486 at 2023-09-02
   - t3-server # failure in job https://hydra.nixos.org/build/233220511 at 2023-09-02
   - table # failure in job https://hydra.nixos.org/build/233223186 at 2023-09-02
···
   - tasty-grading-system # failure in job https://hydra.nixos.org/build/236673021 at 2023-10-04
   - tasty-hedgehog-coverage # failure in job https://hydra.nixos.org/build/233231332 at 2023-09-02
   - tasty-mgolden # failure in job https://hydra.nixos.org/build/233248196 at 2023-09-02
+  - tasty-papi # failure in job https://hydra.nixos.org/build/302806735, https://github.com/Shimuuar/tasty-papi/issues/4#issuecomment-3123432375 at 2025-07-27
   - tasty-process # failure in job https://hydra.nixos.org/build/253680638 at 2024-03-31
   - tasty-stats # failure in job https://hydra.nixos.org/build/233228752 at 2023-09-02
   - tasty-test-reporter # failure in job https://hydra.nixos.org/build/233208181 at 2023-09-02
···
   - tiger # failure in job https://hydra.nixos.org/build/233249333 at 2023-09-02
   - TigerHash # failure in job https://hydra.nixos.org/build/233208162 at 2023-09-02
   - tightrope # failure in job https://hydra.nixos.org/build/233215237 at 2023-09-02
-  - tiktoken # failure in job https://hydra.nixos.org/build/273448419 at 2024-10-01
   - tikzsd # failure in job https://hydra.nixos.org/build/233224431 at 2023-09-02
   - time-extras # failure in job https://hydra.nixos.org/build/233204030 at 2023-09-02
   - time-parsers # failure in job https://hydra.nixos.org/build/295097665 at 2025-04-22
···
   - turing-music # failure in job https://hydra.nixos.org/build/233203435 at 2023-09-02
   - turtle-options # failure in job https://hydra.nixos.org/build/233255831 at 2023-09-02
   - tweak # failure in job https://hydra.nixos.org/build/233211020 at 2023-09-02
+  - twee # failure in job https://hydra.nixos.org/build/302807024 at 2025-07-27
   - twentefp-websockets # failure in job https://hydra.nixos.org/build/233207022 at 2023-09-02
   - twhs # failure in job https://hydra.nixos.org/build/233201182 at 2023-09-02
   - twilio # failure in job https://hydra.nixos.org/build/233199959 at 2023-09-02
···
   - typed-wire # failure in job https://hydra.nixos.org/build/233237626 at 2023-09-02
   - typedquery # failure in job https://hydra.nixos.org/build/233215307 at 2023-09-02
   - typehash # failure in job https://hydra.nixos.org/build/233207184 at 2023-09-02
+  - typelet # failure in job https://hydra.nixos.org/build/302807072 at 2025-07-27
   - typelevel-rewrite-rules # failure in job https://hydra.nixos.org/build/233243365 at 2023-09-02
   - typelevel-tensor # failure in job https://hydra.nixos.org/build/233190827 at 2023-09-02
   - typeparams # failure in job https://hydra.nixos.org/build/233192078 at 2023-09-02
···
   - X11-xfixes # failure in job https://hydra.nixos.org/build/233256494 at 2023-09-02
   - x86-64bit # failure in job https://hydra.nixos.org/build/252737465 at 2024-03-16
   - xcffib # failure in job https://hydra.nixos.org/build/295098351 at 2025-04-22
+  - xcframework # failure in job https://hydra.nixos.org/build/302807506 at 2025-07-27
   - xchat-plugin # failure in job https://hydra.nixos.org/build/233238679 at 2023-09-02
   - xcp # failure in job https://hydra.nixos.org/build/233208926 at 2023-09-02
   - Xec # failure in job https://hydra.nixos.org/build/233191564 at 2023-09-02
···
   - xml-extractors # failure in job https://hydra.nixos.org/build/252718569 at 2024-03-16
   - xml-html-conduit-lens # failure in job https://hydra.nixos.org/build/233238471 at 2023-09-02
   - xml-indexed-cursor # failure in job https://hydra.nixos.org/build/295098303 at 2025-04-22
-  - xml-lens # failure in job https://hydra.nixos.org/build/295098347 at 2025-04-22
+  - xml-isogen # failure in job https://hydra.nixos.org/build/303231372 at 2025-07-27
   - xml-parsec # failure in job https://hydra.nixos.org/build/233208461 at 2023-09-02
   - xml-parser # failure in job https://hydra.nixos.org/build/252721082 at 2024-03-16
   - xml-prettify # failure in job https://hydra.nixos.org/build/233225974 at 2023-09-02
···
   - xmonad-vanessa # failure in job https://hydra.nixos.org/build/233214303 at 2023-09-02
   - xmonad-wallpaper # failure in job https://hydra.nixos.org/build/233217165 at 2023-09-02
   - xmonad-windownames # failure in job https://hydra.nixos.org/build/233258043 at 2023-09-02
+  - xnobar # failure in job https://hydra.nixos.org/build/302807518 at 2025-07-27
   - xorshift-plus # failure in job https://hydra.nixos.org/build/233255176 at 2023-09-02
   - Xorshift128Plus # failure in job https://hydra.nixos.org/build/233225679 at 2023-09-02
   - xsact # failure in job https://hydra.nixos.org/build/233221821 at 2023-09-02

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

···
   - extensions < 0.1.0.2 # Incompatible with Cabal < 3.12, the newest extensions version is only needed on ghc 9.10
   # 2021-11-09: ghc-bignum is bundled starting with 9.0.1; only 1.0 builds with GHCs prior to 9.2.1
   - ghc-bignum == 1.0
+  # 2025-07-26: HLS doesn't support hiedb >= 0.7 yet
+  - hiedb < 0.7
   # 2024-08-17: Stackage doesn't contain hnix-store-core >= 0.8 yet, so we need to restrict hnix-store-remote
   - hnix-store-remote < 0.7
   # 2025-01-17: need to match stackage version of hosc
···
   - hlint == 3.4.1                      # 2022-09-21: preserve for ghc 8.10
   - hlint == 3.6.*                      # 2025-04-14: needed for hls with ghc-lib-parser 9.6
   - hnix-store-core < 0.7               # 2023-12-11: required by hnix-store-remote 0.6
-  - hpack == 0.38.0                     # 2025-04-23: preserve for stack == 3.5.1
   - hspec < 2.8                         # 2022-04-07: Needed for tasty-hspec 1.1.6
   - hspec-core < 2.8                    # 2022-04-07: Needed for tasty-hspec 1.1.6
   - hspec-discover < 2.8                # 2022-04-07: Needed for tasty-hspec 1.1.6
···
   - ormolu == 0.5.2.0                   # 2023-08-08: preserve for ghc 9.0
   - ormolu == 0.7.2.0                   # 2023-11-13: for ghc-lib-parser 9.6 compat
   - ormolu == 0.7.7.0                   # 2025-01-27: for ghc 9.10 compat
-  - persistent-test < 2.13.1.4          # 2025-06-04: incompatible with persistent < 2.16, see conf*-common.nix
   - postgresql-binary < 0.14            # 2025-01-19: Needed for building postgrest
   - primitive-unlifted == 0.1.3.1       # 2024-03-16: preserve for ghc 9.2
   - retrie < 1.2.0.0                    # 2022-12-30: preserve for ghc < 9.2

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

···
-# Stackage LTS 23.24
+# Stackage LTS 23.27
 # This file is auto-generated by
 # maintainers/scripts/haskell/update-stackage.sh
 default-package-overrides:
···
   - attoparsec-binary ==0.2
   - attoparsec-data ==1.0.5.4
   - attoparsec-expr ==0.1.1.2
-  - attoparsec-framer ==0.1.0.9
+  - attoparsec-framer ==0.1.0.10
   - attoparsec-iso8601 ==1.1.1.0
   - attoparsec-path ==0.0.0.1
   - attoparsec-time ==1.0.3.1
···
   - aws-xray-client ==0.1.0.2
   - aws-xray-client-persistent ==0.1.0.5
   - aws-xray-client-wai ==0.1.0.2
-  - backprop ==0.2.6.5
+  - backprop ==0.2.7.2
   - backtracking ==0.1.0
   - bank-holiday-germany ==1.3.1.0
   - bank-holidays-england ==0.2.0.11
···
   - bcp47 ==0.2.0.6
   - bcp47-orphans ==0.1.0.6
   - bcrypt ==0.0.11
-  - beam-core ==0.10.3.1
+  - beam-core ==0.10.4.0
   - beam-migrate ==0.5.3.1
   - beam-postgres ==0.5.4.2
   - beam-sqlite ==0.5.4.0
-  - bech32 ==1.1.8
-  - bech32-th ==1.1.8
+  - bech32 ==1.1.9
+  - bech32-th ==1.1.9
   - bench-show ==0.3.2
   - benchpress ==0.2.2.25
   - bencode ==0.6.1.1
···
   - bson-lens ==0.1.1
   - btrfs ==0.2.1.0
   - buffer-pipe ==0.0
-  - bugsnag ==1.1.0.1
+  - bugsnag ==1.1.0.2
   - bugsnag-hs ==0.2.0.12
-  - bugsnag-wai ==1.0.0.1
+  - bugsnag-wai ==1.0.1.1
   - bugsnag-yesod ==1.0.1.0
   - bugzilla-redhat ==1.0.1.1
-  - burrito ==2.0.1.13
+  - burrito ==2.0.1.14
   - bv ==0.5
   - bv-little ==1.3.2
   - bv-sized ==1.0.6
···
   - byteorder ==1.0.4
   - bytes ==0.17.4
   - byteset ==0.1.1.2
-  - byteslice ==0.2.14.0
+  - byteslice ==0.2.15.0
   - bytesmith ==0.3.11.1
   - bytestring-builder ==0.10.8.2.0
   - bytestring-conversion ==0.3.2
···
   - cabal-add ==0.1
   - cabal-appimage ==0.4.1.0
   - cabal-clean ==0.2.20230609
-  - cabal-debian ==5.2.5
+  - cabal-debian ==5.2.6
   - cabal-doctest ==1.0.11
   - cabal-file ==0.1.1
   - cabal-fix ==0.1.0.0
   - cabal-flatpak ==0.1.2
   - cabal-gild ==1.5.0.3
   - cabal-install-parsers ==0.6.1.1
-  - cabal-plan ==0.7.5.0
+  - cabal-plan ==0.7.6.0
   - cabal-rpm ==2.2.1
   - cabal-sort ==0.1.2.1
   - cabal2spec ==2.7.1
···
   - cased ==0.1.0.0
   - cases ==0.1.4.4
   - casing ==0.1.4.1
-  - cassava ==0.5.3.2
+  - cassava ==0.5.4.0
   - cassava-conduit ==0.6.6
   - cassava-megaparsec ==2.1.1
   - cast ==0.1.0.2
···
   - Chart-cairo ==1.9.4.1
   - Chart-diagrams ==1.9.5.1
   - chart-svg ==0.7.0.0
-  - ChasingBottoms ==1.3.1.15
+  - ChasingBottoms ==1.3.1.16
   - check-email ==1.0.2
   - checkers ==0.6.0
   - checksum ==0.0.0.1
···
   - commutative-semigroups ==0.2.0.2
   - comonad ==5.0.9
   - compact ==0.2.0.0
-  - compactmap ==0.1.4.5
+  - compactmap ==0.1.4.6
   - companion ==0.1.0
   - compdata ==0.13.1
   - compensated ==0.8.3
···
   - conduit-algorithms ==0.0.14.0
   - conduit-combinators ==1.3.0
   - conduit-concurrent-map ==0.1.4
-  - conduit-extra ==1.3.7
+  - conduit-extra ==1.3.8
   - conduit-parse ==0.2.1.1
   - conduit-zstd ==0.0.2.0
   - conferer ==1.1.0.0
···
   - doctest ==0.22.6
   - doctest-discover ==0.2.0.0
   - doctest-driver-gen ==0.3.0.8
-  - doctest-exitcode-stdio ==0.0
+  - doctest-exitcode-stdio ==0.0.0.1
   - doctest-extract ==0.1.2
   - doctest-lib ==0.1.1.1
   - doctest-parallel ==0.3.1.1
···
   - effectful-plugin ==1.1.0.4
   - effectful-th ==1.0.0.3
   - egison-pattern-src ==0.2.1.2
-  - either ==5.0.2
+  - either ==5.0.3
   - either-unwrap ==1.1
   - ekg ==0.4.1.2
-  - ekg-core ==0.1.1.8
+  - ekg-core ==0.1.2.0
   - ekg-json ==0.1.1.1
   - ekg-statsd ==0.2.6.2
   - elerea ==2.9.0
···
   - explainable-predicates ==0.1.2.4
   - explicit-exception ==0.2
   - express ==1.0.18
-  - extended-reals ==0.2.6.0
+  - extended-reals ==0.2.7.0
   - extensible ==0.9.2
   - extensible-effects ==5.0.0.1
   - extensible-exceptions ==0.1.1.4
···
   - falsify ==0.2.0
   - fast-builder ==0.1.5.0
   - fast-digits ==0.3.2.0
-  - fast-logger ==3.2.5
+  - fast-logger ==3.2.6
   - fast-math ==1.0.2
   - fast-myers-diff ==0.0.1
   - fcf-family ==0.2.0.2
···
   - feature-flags ==0.1.0.1
   - fedora-krb ==0.1.0
   - fedora-releases ==0.2.1
-  - fedora-repoquery ==0.7.2
+  - fedora-repoquery ==0.7.3
   - feed ==1.3.2.1
   - FenwickTree ==0.1.2.1
   - fft ==0.1.8.7
···
   - focus ==1.0.3.2
   - focuslist ==0.1.1.0
   - fold-debounce ==0.2.0.16
-  - foldable1-classes-compat ==0.1.1
+  - foldable1-classes-compat ==0.1.2
   - foldl ==1.4.18
   - folds ==0.7.8
   - FontyFruity ==0.5.3.5
···
   - format-numbers ==0.1.0.1
   - formatn ==0.3.1.0
   - formatting ==7.2.0
-  - fortran-src ==0.16.5
+  - fortran-src ==0.16.7
   - foundation ==0.0.30
   - fourmolu ==0.15.0.0
   - Frames ==0.7.4.2
···
   - funcmp ==1.9
   - function-builder ==0.3.0.1
   - functor-classes-compat ==2.0.0.2
-  - functor-combinators ==0.4.1.3
+  - functor-combinators ==0.4.1.4
   - functor-products ==0.1.2.2
   - fused-effects ==1.1.2.5
   - fusion-plugin ==0.2.7
···
   - gi-gdkx11 ==3.0.17
   - gi-gdkx113 ==3.0.17
   - gi-gdkx114 ==4.0.9
-  - gi-gio ==2.0.37
+  - gi-gio ==2.0.38
   - gi-glib ==2.0.30
   - gi-gmodule ==2.0.6
   - gi-gobject ==2.0.31
···
   - gpolyline ==0.1.0.1
   - graph-core ==0.3.0.0
   - graphite ==0.10.0.1
-  - graphql ==1.5.0.0
+  - graphql ==1.5.0.1
   - graphql-client ==1.2.4
   - graphql-spice ==1.0.6.0
   - graphs ==0.7.3
-  - graphula ==2.1.0.1
+  - graphula ==2.1.2.0
   - graphviz ==2999.20.2.1
   - gravatar ==0.8.1
   - greskell ==2.0.3.3
-  - greskell-core ==1.0.0.4
+  - greskell-core ==1.0.0.6
   - greskell-websocket ==1.0.0.4
   - gridtables ==0.1.0.0
   - grisette ==0.9.0.0
···
   - gtk2hs-buildtools ==0.13.12.0
   - gtk3 ==0.15.10
   - guarded-allocation ==0.0.1
-  - hackage-cli ==0.1.0.2
-  - hackage-security ==0.6.3.0
+  - hackage-cli ==0.1.0.3
+  - hackage-security ==0.6.3.1
   - hackage-security-HTTP ==0.1.1.2
   - haddock-library ==1.11.0
   - haha ==0.3.1.1
   - hakyll ==4.16.6.0
   - hakyll-convert ==0.3.0.5
   - hal ==1.1
-  - half ==0.3.2
+  - half ==0.3.3
   - hall-symbols ==0.1.0.6
   - hamlet ==1.2.0
   - hamtsolo ==1.0.4
···
   - hashids ==1.1.1.0
   - hashmap ==1.3.3
   - hashtables ==1.3.1
-  - haskell-gi ==0.26.15
-  - haskell-gi-base ==0.26.8
+  - haskell-gi ==0.26.16
+  - haskell-gi-base ==0.26.9
   - haskell-gi-overloading ==1.0
   - haskell-lexer ==1.1.2
   - haskell-src ==1.0.4.1
···
   - HMock ==0.5.1.2
   - hmpfr ==0.4.5
   - hnix-store-core ==0.8.0.0
+  - hoare ==0.1.1.0
   - hoauth2 ==2.14.0
   - hoogle ==5.0.18.4
   - hopenssl ==2.2.5
···
   - hslua-core ==2.3.2
   - hslua-list ==1.1.4
   - hslua-marshalling ==2.3.1
-  - hslua-module-doclayout ==1.2.0
+  - hslua-module-doclayout ==1.2.0.1
   - hslua-module-path ==1.1.1
   - hslua-module-system ==1.1.3
   - hslua-module-text ==1.1.1
   - hslua-module-version ==1.1.1
-  - hslua-module-zip ==1.1.3
+  - hslua-module-zip ==1.1.4
   - hslua-objectorientation ==2.3.1
   - hslua-packaging ==2.3.1
   - hslua-repl ==0.1.2
···
   - http-semantics ==0.3.0
   - http-streams ==0.8.9.9
   - http-types ==0.12.4
-  - http2 ==5.3.9
+  - http2 ==5.3.10
   - httpd-shed ==0.4.1.2
   - human-readable-duration ==0.2.1.4
   - HUnit ==1.6.2.0
···
   - io-streams ==1.5.2.2
   - io-streams-haproxy ==1.0.1.0
   - ip ==1.7.8
-  - ip6addr ==2.0.0
+  - ip6addr ==2.0.0.1
   - iproute ==1.7.15
   - IPv6Addr ==2.0.6.1
   - IPv6DB ==0.3.3.4
···
   - JuicyPixels-scale-dct ==0.1.2
   - junit-xml ==0.1.0.4
   - justified-containers ==0.3.0.0
-  - kan-extensions ==5.2.6
+  - kan-extensions ==5.2.7
   - kansas-comet ==0.4.3
   - katip ==0.8.8.2
   - katip-logstash ==0.1.0.2
···
   - leapseconds-announced ==2017.1.0.1
   - learn-physics ==0.6.7
   - leb128-cereal ==1.2
-  - lens ==5.3.4
+  - lens ==5.3.5
   - lens-action ==0.2.6
   - lens-aeson ==1.2.3
   - lens-csv ==0.1.1.0
   - lens-family ==2.1.3
   - lens-family-core ==2.1.3
-  - lens-family-th ==0.5.3.1
+  - lens-family-th ==0.5.3.2
   - lens-misc ==0.0.2.0
   - lens-properties ==4.11.1
   - lens-regex ==0.1.3
···
   - lift-type ==0.1.2.0
   - lifted-async ==0.10.2.7
   - lifted-base ==0.2.3.12
-  - linear ==1.23.1
+  - linear ==1.23.2
   - linear-base ==0.4.0
   - linear-circuit ==0.1.0.4
   - linear-generics ==0.2.3
···
   - locators ==0.3.0.5
   - loch-th ==0.2.2
   - lockfree-queue ==0.2.4
-  - log-base ==0.12.0.1
+  - log-base ==0.12.1.0
   - log-domain ==0.13.2
   - logfloat ==0.14.0
   - logger-thread ==0.1.0.2
···
   - markov-chain ==0.0.3.4
   - markov-chain-usage-model ==0.0.0
   - markup-parse ==0.1.1.1
-  - massiv ==1.0.4.1
+  - massiv ==1.0.5.0
   - massiv-io ==1.0.0.1
   - massiv-serialise ==1.0.0.2
   - massiv-test ==1.1.0.1
···
   - mmark ==0.0.8.0
   - mmark-cli ==0.0.5.2
   - mmark-ext ==0.2.1.5
-  - mmorph ==1.2.0
+  - mmorph ==1.2.1
   - mnist-idx ==0.1.3.2
   - mnist-idx-conduit ==0.4.0.0
   - mockcat ==0.5.2.0
···
   - nanospec ==0.2.2
   - nanovg ==0.8.1.0
   - nats ==1.1.2
-  - natural-arithmetic ==0.2.2.0
+  - natural-arithmetic ==0.2.3.0
   - natural-induction ==0.2.0.0
   - natural-sort ==0.1.2
   - natural-transformation ==0.4.1
···
   - pandoc ==3.6
   - pandoc-cli ==3.6
   - pandoc-lua-engine ==0.4.1.1
-  - pandoc-lua-marshal ==0.3.0
+  - pandoc-lua-marshal ==0.3.1
   - pandoc-plot ==1.9.1
   - pandoc-server ==0.1.0.11
   - pandoc-throw ==0.1.0.0
···
   - pathtype ==0.8.1.3
   - pathwalk ==0.3.1.2
   - patience ==0.3
-  - patrol ==1.0.0.11
+  - patrol ==1.0.1.0
   - pava ==0.1.1.4
   - pcg-random ==0.1.4.0
   - pcre-heavy ==1.0.0.4
···
   - persistable-types-HDBC-pg ==0.0.3.5
   - persistent ==2.14.6.3
   - persistent-discover ==0.1.0.7
-  - persistent-documentation ==0.1.0.5
+  - persistent-documentation ==0.1.0.6
   - persistent-lens ==1.0.0
   - persistent-mongoDB ==2.13.1.0
   - persistent-mtl ==0.5.1
···
   - persistent-redis ==2.13.0.2
   - persistent-sqlite ==2.13.3.0
   - persistent-template ==2.12.0.0
-  - persistent-test ==2.13.1.4
+  - persistent-test ==2.13.1.3
   - persistent-typed-db ==0.1.0.7
   - pfile ==0.1.0.1
   - pg-harness-client ==0.6.0
···
   - process-extras ==0.7.4
   - product-isomorphic ==0.0.3.4
   - product-profunctors ==0.11.1.1
-  - profunctors ==5.6.2
+  - profunctors ==5.6.3
   - project-template ==0.2.1.0
   - projectroot ==0.2.0.1
   - prometheus ==2.3.0
···
   - quickcheck-assertions ==0.3.0
   - quickcheck-classes ==0.6.5.0
   - quickcheck-classes-base ==0.6.2.0
-  - quickcheck-groups ==0.0.1.4
+  - quickcheck-groups ==0.0.1.5
   - quickcheck-higherorder ==0.1.0.1
-  - quickcheck-instances ==0.3.32
+  - quickcheck-instances ==0.3.33
   - quickcheck-io ==0.2.0
-  - quickcheck-monoid-subclasses ==0.3.0.5
-  - quickcheck-quid ==0.0.1.7
+  - quickcheck-monoid-subclasses ==0.3.0.6
+  - quickcheck-quid ==0.0.1.8
   - quickcheck-simple ==0.1.1.1
   - quickcheck-state-machine ==0.10.1
   - quickcheck-text ==0.1.2.1
···
   - rhine-gloss ==1.5
   - rhine-terminal ==1.5
   - riak-protobuf ==0.25.0.0
-  - richenv ==0.1.0.2
+  - richenv ==0.1.0.3
   - rio ==0.1.22.0
   - rio-orphans ==0.1.2.0
   - rio-prettyprint ==0.1.8.0
   - rng-utils ==0.3.1
-  - roc-id ==0.2.0.4
+  - roc-id ==0.2.0.5
   - rocksdb-haskell ==1.0.1
   - rocksdb-haskell-jprupp ==2.1.7
   - rocksdb-query ==0.4.3
···
   - sampling ==0.3.5
   - samsort ==0.1.0.0
   - sandi ==0.5
-  - sandwich ==0.3.0.3
-  - sandwich-contexts ==0.3.0.2
+  - sandwich ==0.3.0.4
+  - sandwich-contexts ==0.3.0.3
   - sandwich-hedgehog ==0.1.3.1
   - sandwich-quickcheck ==0.1.0.7
   - sandwich-slack ==0.1.2.0
-  - sandwich-webdriver ==0.3.0.0
+  - sandwich-webdriver ==0.3.0.1
   - saturn ==1.0.0.8
   - say ==0.1.0.1
   - sayable ==1.2.5.0
···
   - scientist ==0.0.0.0
   - scotty ==0.22
   - scrypt ==0.5.0
-  - search-algorithms ==0.3.3
+  - search-algorithms ==0.3.4
   - secp256k1-haskell ==1.4.6
   - securemem ==0.1.10
   - select-rpms ==0.2.0
···
   - sequence-formats ==1.10.0.0
   - sequenceTools ==1.5.3.1
   - serialise ==0.2.6.1
-  - servant ==0.20.2
+  - servant ==0.20.3.0
   - servant-auth ==0.4.2.0
   - servant-auth-client ==0.4.2.0
   - servant-auth-docs ==0.2.11.0
-  - servant-auth-server ==0.4.9.0
+  - servant-auth-server ==0.4.9.1
   - servant-auth-swagger ==0.2.11.0
   - servant-blaze ==0.9.1
   - servant-checked-exceptions ==2.2.0.1
   - servant-checked-exceptions-core ==2.2.0.1
   - servant-cli ==0.1.1.0
-  - servant-client ==0.20.2
-  - servant-client-core ==0.20.2
+  - servant-client ==0.20.3.0
+  - servant-client-core ==0.20.3.0
   - servant-conduit ==0.16.1
   - servant-docs ==0.13.1
   - servant-elm ==0.7.3
···
   - servant-quickcheck ==0.1.1.0
   - servant-rate-limit ==0.2.0.0
   - servant-rawm ==1.0.0.0
-  - servant-server ==0.20.2
+  - servant-server ==0.20.3.0
   - servant-static-th ==1.0.0.1
   - servant-swagger ==1.2.1
   - servant-swagger-ui ==0.3.5.5.0.1
···
   - SHA ==1.6.4.4
   - shake ==0.19.8
   - shake-plus ==0.3.4.0
-  - shakespeare ==2.1.1
+  - shakespeare ==2.1.4
   - shakespeare-text ==1.1.0
   - shared-memory ==0.2.0.1
   - shell-conduit ==5.0.0
···
   - soxlib ==0.0.3.2
   - special-values ==0.1.0.0
   - speculate ==0.4.20
-  - specup ==0.2.0.5
+  - specup ==0.2.0.6
   - speedy-slice ==0.3.2
   - sphinx ==0.6.1
   - Spintax ==0.3.7.0
   - splice ==0.6.1.1
   - split ==0.2.5
   - split-record ==0.1.1.4
-  - splitmix ==0.1.1
+  - splitmix ==0.1.3.1
   - splitmix-distributions ==1.0.0
   - Spock-api ==0.14.0.0
   - spoon ==0.3.1
···
   - tagchup ==0.4.1.2
   - tagged ==0.8.8
   - tagged-binary ==0.2.0.1
-  - tagged-identity ==0.1.4
+  - tagged-identity ==0.1.5
   - tagged-transformer ==0.8.3
   - tagsoup ==0.14.8
   - tagstream-conduit ==0.5.6
···
   - tasty-bench-fit ==0.1.1
   - tasty-checklist ==1.0.6.0
   - tasty-dejafu ==2.1.0.2
-  - tasty-discover ==5.0.1
+  - tasty-discover ==5.0.2
   - tasty-expected-failure ==0.12.3
   - tasty-fail-fast ==0.0.3
   - tasty-focus ==1.0.1
···
   - tasty-inspection-testing ==0.2.1
   - tasty-kat ==0.0.3
   - tasty-leancheck ==0.0.2
-  - tasty-lua ==1.1.1
+  - tasty-lua ==1.1.1.1
   - tasty-papi ==0.1.2.0
   - tasty-program ==1.1.0
   - tasty-quickcheck ==0.11
···
   - text-regex-replace ==0.1.1.5
   - text-rope ==0.2
   - text-short ==0.1.6
-  - text-show ==3.11.1
+  - text-show ==3.11.2
   - text-show-instances ==3.9.10
   - text-zipper ==0.13
   - textlocal ==0.1.0.5
···
   - toml-reader ==0.2.2.0
   - toml-reader-parse ==0.1.1.1
   - tomland ==1.3.3.3
-  - tools-yj ==0.1.0.27
+  - tools-yj ==0.1.0.45
   - tophat ==1.0.8.0
   - topograph ==1.0.1
   - torrent ==10000.1.3
···
   - universum ==1.8.2.2
   - unix-bytestring ==0.4.0.3
   - unix-compat ==0.7.4
-  - unix-time ==0.4.16
+  - unix-time ==0.4.17
   - unjson ==0.15.4
   - unlifted ==0.2.3.0
   - unliftio ==0.2.25.1
···
   - vector-builder ==0.3.8.6
   - vector-bytes-instances ==0.1.1
   - vector-extras ==0.2.8.2
-  - vector-hashtables ==0.1.2.0
-  - vector-instances ==3.4.2
+  - vector-hashtables ==0.1.2.1
+  - vector-instances ==3.4.3
   - vector-mmap ==0.0.3
   - vector-rotcev ==0.1.0.2
   - vector-sized ==1.6.1
   - vector-space ==0.16
-  - vector-split ==1.0.0.3
+  - vector-split ==1.0.0.4
   - vector-stream ==0.1.0.1
   - vector-th-unbox ==0.2.2
   - verset ==0.0.1.11
···
   - vty ==6.2
   - vty-crossplatform ==0.4.0.0
   - vty-unix ==0.2.0.0
-  - vty-windows ==0.2.0.3
+  - vty-windows ==0.2.0.4
   - wai ==3.2.4
   - wai-app-static ==3.1.9
   - wai-cli ==0.2.3
···
   - wai-transformers ==0.1.0
   - wai-websockets ==3.0.1.2
   - wakame ==0.1.0.0
-  - warp ==3.4.7
+  - warp ==3.4.8
   - warp-tls ==3.4.9
   - wave ==0.2.1
   - wcwidth ==0.0.2
···
   - welford-online-mean-variance ==0.2.0.0
   - what4 ==1.6.3
   - wherefrom-compat ==0.1.1.1
-  - wide-word ==0.1.7.0
-  - wild-bind ==0.1.2.11
+  - wide-word ==0.1.7.1
+  - wild-bind ==0.1.2.12
   - wild-bind-x11 ==0.2.0.17
   - Win32-notify ==0.3.0.3
   - windns ==0.1.0.1

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

···
  - dhall-secret
  - dia-functions
  - diagrams-html5
- - diagrams-reflex
  - diagrams-wx
  - dialog
  - diff
···
  - frpnow-gtk
  - frpnow-gtk3
  - frpnow-vty
- - fs-sim
  - ftdi
  - ftp-client-conduit
  - FTPLine
···
  - gridland
  - grisette
  - grisette-monad-coroutine
- - grisette_0_12_0_0
+ - grisette_0_13_0_0
  - gross
  - groundhog-converters
  - groundhog-inspector
···
  - haskelldb-hsql-postgresql
  - haskelldb-hsql-sqlite3
  - haskelldb-th
- - HaskellNet-SSL
  - haskelm
  - haskey
  - haskey-mtl
···
  - HPong
  - hpqtypes-effectful
  - hpqtypes-extras
- - hpqtypes-extras_1_17_0_1
+ - hpqtypes-extras_1_18_0_0
  - hprotoc
  - hprotoc-fork
  - hps
···
  - json-pointer-hasql
  - json-query
  - json-rpc-client
- - json-schema
  - json-state
  - json-togo
  - json2-hdbc
···
  - kit
  - kmeans-par
  - kmeans-vector
+ - knead
  - knit-haskell
  - koji-install
  - koji-tool
+ - koji-tool_1_3
  - korfu
  - ks-test
- - kubernetes-api-client
  - kubernetes-client
  - kure-your-boilerplate
  - kurita
···
  - legion-discovery
  - legion-discovery-client
  - legion-extra
- - leksah
  - leksah-server
  - lens-utils
  - lenz
···
  - liquidhaskell-cabal-demo
  - list-t-attoparsec
  - list-t-html-parser
- - list1
  - listenbrainz-client
  - ListT
  - liszt
···
  - llvm-base-types
  - llvm-base-util
  - llvm-data-interop
+ - llvm-dsl
  - llvm-general
  - llvm-general-quote
  - llvm-hs-pretty
···
  - magic-wormhole
  - mahoro
  - maid
- - mail-pool
  - MailchimpSimple
  - mailgun
  - majordomo
···
  - mpretty
  - mprover
  - mps
- - mptcp-pm
  - mptcpanalyzer
- - msgpack-aeson
  - msgpack-arbitrary
  - msgpack-binary
  - msgpack-idl
  - msgpack-persist
- - msgpack-rpc
  - msgpack-rpc-conduit
  - msgpack-testsuite
  - msi-kb-backlit
···
  - partage
  - partial-semigroup-test
  - passman-cli
+ - patch-image
  - pathfindingcore
  - patterns
  - paypal-rest-client
···
  - Plot-ho-matic
  - PlslTools
  - plugins-auto
+ - pms-application-service
+ - pms-domain-service
+ - pms-infra-cmdrun
+ - pms-infra-procspawn
+ - pms-infra-socket
+ - pms-infra-watch
+ - pms-infrastructure
+ - pms-ui-notification
+ - pms-ui-request
+ - pms-ui-response
  - png-file
  - pngload
  - pointless-lenses
···
  - polysemy-hasql
  - polysemy-hasql-test
  - polysemy-kvstore-jsonfile
- - polysemy-log-co
  - polysemy-methodology
  - polysemy-methodology-co-log
  - polysemy-methodology-composite
···
  - psql
  - ptera
  - ptera-th
+ - pty-mcp-server
  - publicsuffixlist
  - puffytools
  - Pugs
···
  - rbr
  - rc
  - rdioh
+ - rds-data-polysemy
  - react-flux-servant
  - reactive
  - reactive-banana-sdl
···
  - refh
  - reflex-animation
  - reflex-backend-wai
- - reflex-dom-colonnade
  - reflex-ghci
  - reflex-gloss-scene
  - reflex-libtelnet
  - reflex-localize
- - reflex-localize-dom
  - reflex-monad-auth
  - reflex-process
  - reform-blaze
···
  - regions-monadsfd
  - regions-monadstf
  - regions-mtl
- - registry-messagepack
  - regular-extras
  - regular-web
  - regular-xmlpickler
···
  - spelling-suggest
  - sphero
  - spice
- - spike
  - SpinCounter
  - splines
  - sprinkles
···
  - trasa-client
  - trasa-extra
  - trasa-form
- - trasa-reflex
  - trasa-server
  - trasa-th
  - traversal-template
···
  - xml-catalog
  - xml-enumerator
  - xml-enumerator-combinators
- - xml-isogen
  - xml-monad
  - xml-pipe
  - xml-push

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

···
   # can't use pkg-config (LLVM has no official .pc files), we need to pass the
   # `dev` and `lib` output in, or Cabal will have trouble finding the library.
   # Since it looks a bit neater having it in a list, we circumvent the singular
-  # LLVM input here.
-  llvm-ffi = addBuildDepends [
-    pkgs.llvmPackages_16.llvm.lib
-    pkgs.llvmPackages_16.llvm.dev
-  ] (super.llvm-ffi.override { LLVM = null; });
+  # LLVM input that llvm-ffi declares.
+  llvm-ffi =
+    let
+      chosenLlvmVersion = 20;
+      nextLlvmAttr = "llvmPackages_${toString (chosenLlvmVersion + 1)}";
+      shouldUpgrade =
+        pkgs ? ${nextLlvmAttr} && (lib.strings.match ".+rc.+" pkgs.${nextLlvmAttr}.llvm.version) == null;
+    in
+    lib.warnIf shouldUpgrade
+      "haskellPackages.llvm-ffi: ${nextLlvmAttr} is available in Nixpkgs, consider updating."
+      lib.pipe
+      super.llvm-ffi
+      [
+        # ATTN: There is no matching flag for the latest supported LLVM version,
+        # so you may need to remove this when updating chosenLlvmVersion
+        (enableCabalFlag "LLVM${toString chosenLlvmVersion}00")
+        (addBuildDepends [
+          pkgs."llvmPackages_${toString chosenLlvmVersion}".llvm.lib
+          pkgs."llvmPackages_${toString chosenLlvmVersion}".llvm.dev
+        ])
+      ];
 
   # Needs help finding LLVM.
   spaceprobe = addBuildTool self.buildHaskellPackages.llvmPackages.llvm super.spaceprobe;
···
     pkgs.z3
   ] super.crucible-llvm;
 
+  # yaml doesn't build its executables (json2yaml, yaml2json) by default:
+  # https://github.com/snoyberg/yaml/issues/194
+  yaml = lib.pipe super.yaml [
+    (disableCabalFlag "no-exe")
+    enableSeparateBinOutput
+    (addBuildDepend self.optparse-applicative)
+  ];
+
   # Compile manpages (which are in RST and are compiled with Sphinx).
   futhark =
     overrideCabal
···
     ];
   }) super.relocant;
 
+  # https://gitlab.iscpif.fr/gargantext/haskell-pgmq/blob/9a869df2842eccc86a0f31a69fb8dc5e5ca218a8/README.md#running-test-cases
+  haskell-pgmq = overrideCabal (drv: {
+    env = drv.env or { } // {
+      postgresqlEnableTCP = toString true;
+    };
+    testToolDepends = drv.testToolDepends or [ ] ++ [
+      # otherwise .dev gets selected?!
+      (lib.getBin (pkgs.postgresql.withPackages (ps: [ ps.pgmq ])))
+      pkgs.postgresqlTestHook
+    ];
+  }) super.haskell-pgmq;
+
+  # https://gitlab.iscpif.fr/gargantext/haskell-bee/blob/19c8775f0d960c669235bf91131053cb6f69a1c1/README.md#redis
+  haskell-bee-redis = overrideCabal (drv: {
+    testToolDepends = drv.testToolDepends or [ ] ++ [
+      pkgs.redisTestHook
+    ];
+  }) super.haskell-bee-redis;
+
   retrie = addTestToolDepends [ pkgs.git pkgs.mercurial ] super.retrie;
   retrie_1_2_0_0 = addTestToolDepends [ pkgs.git pkgs.mercurial ] super.retrie_1_2_0_0;
   retrie_1_2_1_1 = addTestToolDepends [ pkgs.git pkgs.mercurial ] super.retrie_1_2_1_1;
···
           ]
         }"
     '';
+
+    passthru = {
+      updateScript = ../../../maintainers/scripts/haskell/update-cabal2nix-unstable.sh;
+
+      # This is used by regenerate-hackage-packages.nix to supply the configuration
+      # values we can easily generate automatically without checking them in.
+      compilerConfig =
+        pkgs.runCommand "hackage2nix-${self.ghc.haskellCompilerName}-config.yaml"
+          {
+            nativeBuildInputs = [
+              self.ghc
+            ];
+          }
+          ''
+            cat > "$out" << EOF
+            # generated by haskellPackages.cabal2nix-unstable.compilerConfig
+            compiler: ${self.ghc.haskellCompilerName}
+
+            core-packages:
+            EOF
+
+            ghc-pkg list \
+              | tail -n '+2' \
+              | sed -e 's/[()]//g' -e 's/\s\+/  - /' \
+              >> "$out"
+          '';
+    };
   }) (justStaticExecutables super.cabal2nix-unstable);
 
   # test suite needs local redis daemon
···
     }))
     (self.generateOptparseApplicativeCompletions [ "cloudy" ])
   ];
+
+  # We don't have multiple GHC versions to test against in PATH
+  ghc-hie = overrideCabal (drv: {
+    testFlags = drv.testFlags or [ ] ++ [
+      "--skip=/GHC.Iface.Ext.Binary/readHieFile"
+    ];
+  }) super.ghc-hie;
 
   # Wants running postgresql database accessible over ip, so postgresqlTestHook
   # won't work (or would need to patch test suite).
···
     (overrideCabal { mainProgram = "agda"; })
     # Split outputs to reduce closure size
     enableSeparateBinOutput
+    # Build the primitive library to generate its interface files.
+    # These are needed in order to use Agda in Nix builds.
+    (overrideCabal (drv: {
+      postInstall = drv.postInstall or "" + ''
+        agdaExe=''${bin:-$out}/bin/agda
+
+        echo "Generating Agda core library interface files..."
+        (cd "$("$agdaExe" --print-agda-data-dir)/lib/prim" && "$agdaExe" --build-library)
+      '';
+    }))
   ];
 
   # ats-format uses cli-setup in Setup.hs which is quite happy to write
···
   ];
 
   xmobar = enableSeparateBinOutput super.xmobar;
+
+  # These test cases access the network
+  hpack_0_38_1 = doDistribute (
+    overrideCabal (drv: {
+      testFlags = drv.testFlags or [ ] ++ [
+        "--skip"
+        "/Hpack.Defaults/ensureFile/with 404/does not create any files/"
+        "--skip"
+        "/Hpack.Defaults/ensureFile/downloads file if missing/"
+        "--skip"
+        "/EndToEnd/hpack/defaults/fails if defaults don't exist/"
+      ];
+    }) super.hpack_0_38_1
+  );
 
   # 2024-08-09: Disable some cabal-doctest tests pending further investigation.
   inherit

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

···
   enableSharedLibraries ?
     !stdenv.hostPlatform.isStatic
     && (ghc.enableShared or false)
-    && !stdenv.hostPlatform.useAndroidPrebuilt,
+    && !stdenv.hostPlatform.useAndroidPrebuilt, # TODO: figure out why /build leaks into RPATH
   enableDeadCodeElimination ? (!stdenv.hostPlatform.isDarwin), # TODO: use -dead_strip for darwin
   # Disabling this for ghcjs prevents this crash: https://gitlab.haskell.org/ghc/ghc/-/issues/23235
   enableStaticLibraries ?

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

···
       blaze-html,
       boxes,
       bytestring,
-      Cabal,
       case-insensitive,
       containers,
       data-hash,
···
       dlist,
       edit-distance,
       emacs,
+      enummapset,
       equivalence,
       exceptions,
+      filelock,
+      filemanip,
       filepath,
+      generic-data,
       ghc-compact,
       gitrev,
       happy,
···
       monad-control,
       mtl,
       murmur-hash,
+      nonempty-containers,
       parallel,
       peano,
       pqueue,
       pretty,
       process,
+      process-extras,
       regex-tdfa,
       split,
       stm,
       STMonadTrans,
       strict,
+      template-haskell,
       text,
       time,
       transformers,
···
     }:
     mkDerivation {
       pname = "Agda";
-      version = "2.7.0.1";
-      sha256 = "13pn0mbxyfy04fcdl68l2m36b40hwk8iwpkqdfad3xsf9l5ddxil";
-      revision = "3";
-      editedCabalFile = "0vmsy5hjivysiqkzk65ca1y8ivbzly5z55zi12bgsmj7jqrd8vrf";
+      version = "2.8.0";
+      sha256 = "184vjq260zf5w9c8nz11nbhpsvq3a1yxp7mhaz7synlaww3ik146";
       isLibrary = true;
       isExecutable = true;
       enableSeparateDataOutput = true;
-      setupHaskellDepends = [
-        base
-        Cabal
-        directory
-        filepath
-        process
-      ];
       libraryHaskellDepends = [
         aeson
         ansi-terminal
···
         directory
         dlist
         edit-distance
+        enummapset
         equivalence
         exceptions
+        filelock
+        filemanip
         filepath
+        generic-data
         ghc-compact
         gitrev
         hashable
···
         monad-control
         mtl
         murmur-hash
+        nonempty-containers
         parallel
         peano
         pqueue
         pretty
         process
+        process-extras
         regex-tdfa
         split
         stm
         STMonadTrans
         strict
+        template-haskell
         text
         time
         transformers
···
       ];
       executableHaskellDepends = [
         base
+        bytestring
         directory
+        filelock
         filepath
+        gitrev
         process
+        template-haskell
       ];
       executableToolDepends = [ emacs ];
       description = "A dependently typed functional programming language and proof assistant";
···
     }:
     mkDerivation {
       pname = "ChasingBottoms";
-      version = "1.3.1.15";
-      sha256 = "0if8h6xq10y1xa90cwmx2jkxjn9628rzs8y6fsjmpjdcvcyr5wnj";
-      revision = "2";
-      editedCabalFile = "11h7gfnlxfrfpvax74lbdwaz8jazy833q6mzrgs9p8cyj6q69ibn";
+      version = "1.3.1.16";
+      sha256 = "08zg018arf4qvp970dcnf0nyaqp7wkp5ba2dhck3v4l49k5cax9m";
       libraryHaskellDepends = [
         base
         containers
···
     }
   ) { };
 
+  "ConsoleAsk" = callPackage (
+    {
+      mkDerivation,
+      base,
+      lens,
+      parsec,
+      regex-tdfa,
+      text,
+    }:
+    mkDerivation {
+      pname = "ConsoleAsk";
+      version = "0.1.0.1";
+      sha256 = "0mbrvaqdxfx7vfcqy6rbva0ml6a7a2yklgzh3vx008yaavzw4hy6";
+      libraryHaskellDepends = [
+        base
+        lens
+        parsec
+        regex-tdfa
+        text
+      ];
+      description = "Simple CLI user input library";
+      license = lib.licenses.mit;
+    }
+  ) { };
+
   "ConstraintKinds" = callPackage (
     {
       mkDerivation,
···
     }:
     mkDerivation {
       pname = "HaskellNet";
-      version = "0.6.1.2";
-      sha256 = "0yd0n6c9favb6kv37flz2cn9wz5kapx3iqljq2h7l6qvx6kd92v5";
-      revision = "1";
-      editedCabalFile = "1j5g09v40rvsk4crfjabs0mma5nlwsbzbny25803bc6805jh9058";
+      version = "0.6.2";
+      sha256 = "134gmv5b4f02f24m86ql256dssdvkgqjp2cw36p6958ydbdsx6s4";
       libraryHaskellDepends = [
         array
         base
···
       ];
       description = "Client support for POP3, SMTP, and IMAP";
       license = lib.licenses.bsd3;
-      hydraPlatforms = lib.platforms.none;
-      broken = true;
     }
   ) { };
 
···
       ];
       description = "Helpers to connect to SSL/TLS mail servers with HaskellNet";
       license = lib.licenses.bsd3;
-      hydraPlatforms = lib.platforms.none;
       mainProgram = "HaskellNet-SSL-example";
     }
   ) { };
···
     }:
     mkDerivation {
       pname = "HsSyck";
-      version = "0.53";
-      sha256 = "17r4jwnkjinmzpw9m2crjwccdyv9wmpljnv1ldgljkr9p9mb5ywf";
+      version = "0.55";
+      sha256 = "1ccm9r40898kfgkrnwz0ybcdps83li9wk565fm37gdpsvmi19faf";
       enableSeparateDataOutput = true;
       libraryHaskellDepends = [
         base
···
       pname = "HsYAML";
       version = "0.2.1.5";
       sha256 = "13av46629msknp1spmcczgd2hpsyj0ca590vpiy7df8l6cfwjyk5";
+      revision = "1";
+      editedCabalFile = "1l5ig8a1c13rwcx530li93p0kkxcsjpjyr303v19z6n8zmdvnz6a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
       pname = "IPv6DB";
       version = "0.3.3.4";
       sha256 = "1mkf2fqlg2n9q3l3p8rxdcmb7k281lz37x6hiry1wvxbn92d4pja";
+      revision = "1";
+      editedCabalFile = "18wx26x4nyyywbl7inwna68kmxs8sbyckmrhdz4png9gn7ix4sr0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
       pname = "LPFP";
       version = "1.1.5";
       sha256 = "11mlcd1pq2vb0kwjm2z6304qslvmdcfdbly37yr27zhn860zfzz2";
+      revision = "2";
+      editedCabalFile = "1530y0rmj3gwhk0ghpaf0977wz0n2pq86dfcb401y0ala7f4z167";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
     }:
     mkDerivation {
       pname = "MicroHs";
-      version = "0.12.6.1";
-      sha256 = "145fk10clh4mmfd58212kr1b56fr4j19vrlrq6d4jdv4zrvk5iwl";
+      version = "0.13.0.0";
+      sha256 = "02wl86ql8xcp9w7vlhvh0m95am6ssmw8fzkbs597qlhpwp91ax3w";
       isLibrary = false;
       isExecutable = true;
       enableSeparateDataOutput = true;
···
     }
   ) { };
 
-  "NanoID_3_4_1" = callPackage (
+  "NanoID_3_4_1_1" = callPackage (
     {
       mkDerivation,
       aeson,
···
     }:
     mkDerivation {
       pname = "NanoID";
-      version = "3.4.1";
-      sha256 = "1rrz4wmhba372fg9w8rg6fgynwqmy5dhyz5i74xab5mbjgv169rs";
+      version = "3.4.1.1";
+      sha256 = "1dfl5vj6fwxwrhgx11vzxij2p19q3kqri130fxgw2l6ajlckyh8x";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
     }:
     mkDerivation {
       pname = "PenroseKiteDart";
-      version = "1.3";
-      sha256 = "0yjfc7zahrf4h02xhlbhzh0r8nzns5v1a2rp2sg3gi073v59gpps";
+      version = "1.4.3";
+      sha256 = "1nrp9cr7jxjvplkfgp4lxh3rvzf1pms8bm7kwhc4w4fzmpy3p3p1";
       libraryHaskellDepends = [
         base
         containers
···
     }
   ) { };
 
-  "QuickCheck_2_15_0_1" = callPackage (
+  "QuickCheck_2_16_0_0" = callPackage (
     {
       mkDerivation,
       base,
···
     }:
     mkDerivation {
       pname = "QuickCheck";
-      version = "2.15.0.1";
-      sha256 = "0zvfydg44ibs1br522rzvdlxj9mpz0h62js1hay1sj5gvdnj3cm3";
-      revision = "1";
-      editedCabalFile = "0cgfp4s51cjphsn9cls6rndisvqmi94vn95xan9g1yz6p5xk7z8c";
+      version = "2.16.0.0";
+      sha256 = "1h02m26hvhfcs82rrfmfznwh4vj799gn55kysmv3sr8ixak3ymhb";
       libraryHaskellDepends = [
         base
         containers
···
     { mkDerivation }:
     mkDerivation {
       pname = "Win32";
-      version = "2.14.2.0";
-      sha256 = "0qmm44py2r1z5mj12vr33s01kci5hmh479pr6v8ljqgm2imlfr4j";
+      version = "2.14.2.1";
+      sha256 = "0583vy22b89z4zdgg52ayga46mw8qmj0lw7qm99q6wggnjgmmlb9";
       description = "A binding to Windows Win32 API";
       license = lib.licenses.bsd3;
       platforms = lib.platforms.windows;
···
     }:
     mkDerivation {
       pname = "ac-library-hs";
-      version = "1.5.0.0";
-      sha256 = "15jvxwsx50qcv58wx4a2m4f1h5ic476cnb78n757shyfm0asn9ag";
+      version = "1.5.2.0";
+      sha256 = "028781j64wv42j9i2gmgccmlakyjchpxqk13rk5n59xavlyv7yw9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
         bytestring
         primitive
         random
+        transformers
         vector
         vector-algorithms
         wide-word
···
         bytestring
         primitive
         random
+        transformers
         vector
         vector-algorithms
         wide-word
···
       ];
       description = "Data structures and algorithms";
       license = lib.licenses.cc0;
+      hydraPlatforms = lib.platforms.none;
       mainProgram = "example-lazy-segtree";
+      broken = true;
     }
   ) { };
 
···
       pname = "active";
       version = "0.2.1";
       sha256 = "150kwir36aj9q219qi80mlqd0vxm4941dh6x4xp58rbd5a3mhmv1";
-      revision = "4";
-      editedCabalFile = "0s5aiyskly1j4wd4hs2c52bdawx9340pgdx0378xvivixd48cd8x";
+      revision = "5";
+      editedCabalFile = "0wxl3pfdz4krx7lg1rckvmjkm2hj5vlwx3kyzzfrpsfhc9zq7f1g";
       libraryHaskellDepends = [
         base
         lens
···
       pname = "aeson";
       version = "2.2.3.0";
       sha256 = "1akbrh8iz47f0ai30yabg1n4vcf1fx0a9gzj45fx0si553s5r8ns";
-      revision = "3";
-      editedCabalFile = "16sajjm1fqrjjgdy651ff7hyj89di7ys9wk4qnm9h6nnpbr5krb1";
+      revision = "4";
+      editedCabalFile = "0yw5kahz82kls4svn0qssckvx143k73h5nqg0z1d4s7ibqww4j3x";
       libraryHaskellDepends = [
         base
         bytestring
···
       pname = "align-audio";
       version = "0.0.0.1";
       sha256 = "1r1660igj6bmzhccw30vj0wsz7jjkd5k0vbr4nrcbpcwkxllshnb";
-      revision = "2";
-      editedCabalFile = "15hqn6q6991qp60pvykw3ryrcyqz94vhwcj1y28sxdpn5ga8mrl9";
+      revision = "3";
+      editedCabalFile = "1j50cp7i77dplkd3g7nnyn9xgcr8r8d4lh6nh9xcnjfkn8p6g539";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
···
     }:
     mkDerivation {
       pname = "amazonka-mtl";
-      version = "0.1.1.1";
-      sha256 = "19rcmfq5ly92jm96w5770286kihd5gsdc45rmpbkhm71xl2aa0pq";
+      version = "0.1.1.3";
+      sha256 = "06ng492c6r0zwyjyr0h6b665sp6v17i245svdsag3ha8ni303hka";
       libraryHaskellDepends = [
         amazonka
         amazonka-core
···
     }:
     mkDerivation {
       pname = "android-activity";
-      version = "0.2.0.1";
-      sha256 = "1pb250zsmh9z7h8wcqnqhbvhhdwwhmrwj8qr1w8053pxylsr5npn";
+      version = "0.2.0.2";
+      sha256 = "1l82k9if392682wr31b6g74wv25qwl5cgxwcmhnrp4lm8w0n428d";
       libraryHaskellDepends = [
         base
         data-default
···
       pname = "ansi-terminal-game";
       version = "1.9.3.0";
       sha256 = "1yy7hzdcawdmwl8wqzabbamzjdg260xbwryj0hdjn7b0n6qlqymk";
-      revision = "2";
-      editedCabalFile = "1gjaa3kj05v5zyjn27y17w05nx018bx28znj7r0al0c6267n0la8";
+      revision = "3";
+      editedCabalFile = "0m4df8a2p18j29zsgffnyf69hjkyam3rg3xc4zvmxafidj877ykk";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
     }:
     mkDerivation {
       pname = "aoc";
-      version = "0.1.0.2";
-      sha256 = "0x5lpirk74zf4283gpvmw71dv8mgil80l1awv42f8sfxg5nx805g";
+      version = "0.2.0.0";
+      sha256 = "0hamr2sqw00njwg4sdir81fmsgc29ic21m0rzqnrfmd5jgdmg27h";
       libraryHaskellDepends = [
         base
         containers
···
       pname = "arithmoi";
       version = "0.13.1.0";
       sha256 = "0ka0sqkrkqrln6ci8fxzls9r5bhwii48xc39bbapdqbn4sc2c5bf";
-      revision = "1";
-      editedCabalFile = "1q36pbxsz3vcig7gjr0m38bn5d34az2cjkhcag4n2ra86zdqrnvv";
+      revision = "2";
+      editedCabalFile = "1q81krc6qgg495qqlnh7kbzg2fk57amgiqa5xmxwhxrhlffjsk3d";
       configureFlags = [ "-f-llvm" ];
       libraryHaskellDepends = [
         array
···
     }
   ) { };
 
+  "ascii85x" = callPackage (
+    {
+      mkDerivation,
+      array,
+      attoparsec,
+      base,
+      bytestring,
+      hedgehog,
+      JuicyPixels,
+      optparse-applicative,
+      text,
+      vector,
+    }:
+    mkDerivation {
+      pname = "ascii85x";
+      version = "0.2.4.1";
+      sha256 = "1jr0qqcyx173gy5izz99z5s3v9a78ks48g7am4lfab7py3k0xri3";
+      isLibrary = true;
+      isExecutable = true;
+      libraryHaskellDepends = [
+        array
+        attoparsec
+        base
+        bytestring
+        JuicyPixels
+        text
+        vector
+      ];
+      executableHaskellDepends = [
+        array
+        attoparsec
+        base
+        bytestring
+        JuicyPixels
+        optparse-applicative
+        text
+        vector
+      ];
+      testHaskellDepends = [
+        array
+        attoparsec
+        base
+        bytestring
+        hedgehog
+        JuicyPixels
+        text
+        vector
+      ];
+      description = "Displays TI-85 variable files as text";
+      license = lib.licenses.bsd3;
+      hydraPlatforms = lib.platforms.none;
+      mainProgram = "ascii85x";
+      broken = true;
+    }
+  ) { };
+
   "asciichart" = callPackage (
     {
       mkDerivation,
···
     }:
     mkDerivation {
       pname = "attoparsec-framer";
-      version = "0.1.0.9";
-      sha256 = "0kh54qdzjqa7lxd8s679b3my5nsy55rwqwd84nblmfczi73bjc0p";
+      version = "0.1.0.10";
+      sha256 = "1ziskifj6mly9ywsag8395ladwscrwzjpn628nbmn29x28zq0n61";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
       containers,
       deepseq,
       directory,
+      fail,
       filepath,
       ghc-prim,
       haddock-use-refs,
···
       QuickCheck,
       quickcheck-unicode,
       scientific,
+      semigroups,
       tagged,
       tasty,
       tasty-bench,
···
     }:
     mkDerivation {
       pname = "attoparsec-isotropic";
-      version = "0.14.4";
-      sha256 = "17rgqqkshn7pdyk54ac4vc3xs4p2kqh3mbd0ppsy7shyry7c1ahs";
+      version = "0.14.5";
+      sha256 = "1bvxy2gydz3kv0fbhp77bwk75l73kz7qc4aa7wlldga90f8y3vhj";
       libraryHaskellDepends = [
         array
         base
         bytestring
         containers
         deepseq
+        fail
         ghc-prim
         haddock-use-refs
         scientific
+        semigroups
         tagged
         text
         trace-embrace
···
         array
         base
         bytestring
+        containers
         deepseq
+        fail
+        haddock-use-refs
         http-types
         QuickCheck
         quickcheck-unicode
         scientific
+        semigroups
+        tagged
         tasty
         tasty-bench
         tasty-quickcheck
···
         containers
         deepseq
         directory
+        fail
         filepath
         ghc-prim
+        haddock-use-refs
         http-types
         parsec
         scientific
+        semigroups
+        tagged
         tasty-bench
         text
+        trace-embrace
         transformers
         unordered-containers
         vector
···
       pname = "audacity";
       version = "0.0.2.2";
       sha256 = "1glvk4mkq8j48s0xm86xb1l3xrb6m3cijcckdm48zq3pz7yg3hd8";
+      revision = "1";
+      editedCabalFile = "1zijgx43yd713czj9r5b2yv26dii4d4i6ar9n0l1c9zqaqv7vh6p";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
     }
   ) { };
 
+  "autodocodec_0_5_0_0" = callPackage (
+    {
+      mkDerivation,
+      aeson,
+      base,
+      bytestring,
+      containers,
+      dlist,
+      doctest,
+      hashable,
+      mtl,
+      scientific,
+      text,
+      time,
+      unordered-containers,
+      validity,
+      validity-scientific,
+      vector,
+    }:
+    mkDerivation {
+      pname = "autodocodec";
+      version = "0.5.0.0";
+      sha256 = "172z14rfrl7jn0cwsbspyzb884szrmvq1rixd2b8ymc8d278l049";
+      libraryHaskellDepends = [
+        aeson
+        base
+        bytestring
+        containers
+        dlist
+        hashable
+        mtl
+        scientific
+        text
+        time
+        unordered-containers
+        validity
+        validity-scientific
+        vector
+      ];
+      testHaskellDepends = [
+        base
+        doctest
+      ];
+      description = "Self-documenting encoder and decoder";
+      license = lib.licenses.mit;
+      hydraPlatforms = lib.platforms.none;
+    }
+  ) { };
+
+  "autodocodec-exact" = callPackage (
+    {
+      mkDerivation,
+      aeson,
+      aeson-pretty,
+      autodocodec,
+      base,
+      bytestring,
+      containers,
+      mtl,
+      pretty-show,
+      scientific,
+      text,
+      unordered-containers,
+      vector,
+    }:
+    mkDerivation {
+      pname = "autodocodec-exact";
+      version = "0.0.0.1";
+      sha256 = "07ljrfxhkrl7k33nhg51m30334yvjp7jrix6hlwzgfqgr4nsbdas";
+      libraryHaskellDepends = [
+        aeson
+        aeson-pretty
+        autodocodec
+        base
+        bytestring
+        containers
+        mtl
+        pretty-show
+        scientific
+        text
+        unordered-containers
+        vector
+      ];
+      description = "Exact decoder for autodocodec";
+      license = lib.licenses.mit;
+      hydraPlatforms = lib.platforms.none;
+      broken = true;
+    }
+  ) { };
+
   "autodocodec-nix" = callPackage (
     {
       mkDerivation,
···
     }
   ) { };
 
+  "autodocodec-servant-multipart_0_0_0_2" = callPackage (
+    {
+      mkDerivation,
+      aeson,
+      autodocodec,
+      base,
+      bytestring,
+      servant-multipart,
+      servant-multipart-api,
+      text,
+      unordered-containers,
+      vector,
+    }:
+    mkDerivation {
+      pname = "autodocodec-servant-multipart";
+      version = "0.0.0.2";
+      sha256 = "0zdghkqmrr2d4lj71c3qh62bqvc5frhid8s8zkh3hwkkla7a1ld4";
+      libraryHaskellDepends = [
+        aeson
+        autodocodec
+        base
+        bytestring
+        servant-multipart
+        servant-multipart-api
+        text
+        unordered-containers
+        vector
+      ];
+      description = "Autodocodec interpreters for Servant Multipart";
+      license = lib.licenses.mit;
+      hydraPlatforms = lib.platforms.none;
+    }
+  ) { };
+
   "autodocodec-swagger2" = callPackage (
     {
       mkDerivation,
···
       ];
       description = "Autodocodec interpreters for yaml";
       license = lib.licenses.mit;
+    }
+  ) { };
+
+  "autodocodec-yaml_0_4_0_2" = callPackage (
+    {
+      mkDerivation,
+      autodocodec,
+      autodocodec-schema,
+      base,
+      bytestring,
+      containers,
+      path,
+      path-io,
+      safe-coloured-text,
+      scientific,
+      text,
+      vector,
+      yaml,
+    }:
+    mkDerivation {
+      pname = "autodocodec-yaml";
+      version = "0.4.0.2";
+      sha256 = "17ll6bb0qs7nm9s2kf1b2zn67kjv5lwcrs2igllk5vlsajk4difl";
+      libraryHaskellDepends = [
+        autodocodec
+        autodocodec-schema
+        base
+        bytestring
+        containers
+        path
+        path-io
+        safe-coloured-text
+        scientific
+        text
+        vector
+        yaml
+      ];
+      description = "Autodocodec interpreters for yaml";
+      license = lib.licenses.mit;
+      hydraPlatforms = lib.platforms.none;
     }
   ) { };
 
···
     }
   ) { };
 
+  "aws-academy-grade-exporter" = callPackage (
+    {
+      mkDerivation,
+      aeson,
+      base,
+      bytestring,
+      cassava,
+      optparse-applicative,
+      postgresql-simple,
+      req,
+      text,
+      vector,
+    }:
+    mkDerivation {
+      pname = "aws-academy-grade-exporter";
+      version = "0.1.0.0";
+      sha256 = "1wh0sz2x4kfh97yi3811r3vg2qf6i6zp2hyifzz1jy1nra93b6av";
+      isLibrary = false;
+      isExecutable = true;
+      executableHaskellDepends = [
+        aeson
+        base
+        bytestring
+        cassava
+        optparse-applicative
+        postgresql-simple
+        req
+        text
+        vector
+      ];
+      description = "Export grades from AWS Academy to different formats";
+      license = lib.licenses.mit;
+      hydraPlatforms = lib.platforms.none;
+      mainProgram = "aws-academy-grade-exporter";
+      broken = true;
+    }
+  ) { };
+
   "aws-arn" = callPackage (
     {
       mkDerivation,
···
     }:
     mkDerivation {
       pname = "aws-spend-summary";
-      version = "0.2.0.2";
-      sha256 = "0zp9bdrhxl4z8fyjqcilndpj6qw5scs1byh1fzj8v9r4zzg59zsg";
+      version = "0.3.0.0";
+      sha256 = "0lnwlvjqjs4hxqfblrhgqjq6309c466hlnamryprgd3l8nhnpak3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
       microlens,
       microlens-th,
       mwc-random,
-      primitive,
       reflection,
       time,
       transformers,
···
     }:
     mkDerivation {
       pname = "backprop";
-      version = "0.2.6.5";
-      sha256 = "0rc6dsf0zasl9vah8kv61qk2z7s644lzsrmkd7fwxwj1480kb482";
+      pname = "nat";
+      sha256 = "1v7r2gr18kcrcf12dmjpg2cqg1lanpqfpjwbqqnm1sbibvf467w7";
       libraryHaskellDepends = [
         base
         containers
         deepseq
         microlens
-        primitive
         reflection
         transformers
         vector
···
       pname = "ban-instance";
       version = "0.1.0.1";
       sha256 = "0504qsjbqbrdf9avfrhs290baszc9dickx7wknbyxwrzpzzbpggk";
-      revision = "4";
-      editedCabalFile = "1ip2abbxnj2cwc3b0l88s0014zakx4g84ifnnaqq8rg6mcn5ppik";
+      revision = "5";
+      editedCabalFile = "1a0xh0kfdpqgppaisb0hlm4k40gssbxh5jjz2j2l8xn2bnmv95cb";
       libraryHaskellDepends = [
         base
         template-haskell
···
       pname = "base64-bytes";
       version = "0.1.1.1";
       sha256 = "0gvh2yg7mqwrswcq5p0h35bifsvm18cdvsjzazz37yrwan0i31vs";
+      revision = "1";
+      editedCabalFile = "17kl1813wdqbh6hjrm7npm2w65d0ir4bpbklggr4bxzxabwbsg2c";
       libraryHaskellDepends = [
         base
         byte-order
···
       ];
       description = "Base64 encoding of byte sequences";
       license = lib.licenses.bsd3;
-      hydraPlatforms = lib.platforms.none;
-      broken = true;
     }
   ) { };
 
···
       pname = "base64-bytestring-type";
       version = "1.0.1";
       sha256 = "03kq4rjj6by02rf3hg815jfdqpdk0xygm5f46r2pn8mb99yd01zn";
-      revision = "21";
-      editedCabalFile = "1y3j1lkqlqw8l4p0g8s3iac0gd84nz3pqccrzfj7n23fp19zr1q3";
+      revision = "22";
+      editedCabalFile = "0a5640qjbd3f96v9sf6r1laqpqk83xh073qlq75174kcg5zi4rxa";
       libraryHaskellDepends = [
         aeson
         base
···
     }:
     mkDerivation {
       pname = "beam-automigrate";
-      version = "0.1.6.0";
-      sha256 = "09pq0i3zb68ad20qznvf4kqf3y3zz0pjfi84g87rxay6y4sj6vi1";
+      version = "0.1.7.0";
+      sha256 = "019b0kykdjqmf2xcj11pi2s67ssy2al882nsj5aq2h1mq6c7bx63";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
     }:
     mkDerivation {
       pname = "beam-core";
-      version = "0.10.3.1";
-      sha256 = "0n3fyjhcljd44ri7z3kb1sd3izv047v82m9n7597r7sbipv8cysc";
+      version = "0.10.4.0";
+      sha256 = "1zxqyxxyid186s86lfw0sq030jckh83j3rwj6ibx4wg3flslk515";
       libraryHaskellDepends = [
         aeson
         base
···
     }
   ) { };
 
+  "beam-sqlite_0_5_4_1" = callPackage (
+    {
+      mkDerivation,
+      aeson,
+      attoparsec,
+      base,
+      beam-core,
+      beam-migrate,
+      bytestring,
+      direct-sqlite,
+      dlist,
+      free,
+      hashable,
+      monad-control,
+      mtl,
+      network-uri,
+      scientific,
+      sqlite-simple,
+      tasty,
+      tasty-expected-failure,
+      tasty-hunit,
+      text,
+      time,
+      transformers-base,
+    }:
+    mkDerivation {
+      pname = "beam-sqlite";
+      version = "0.5.4.1";
+      sha256 = "1f5yjsx7zfbfbxs3xd64rwn2m3vjffrbdn5xadhm1axhghi6srki";
+      libraryHaskellDepends = [
+        aeson
+        attoparsec
+        base
+        beam-core
+        beam-migrate
+        bytestring
+        direct-sqlite
+        dlist
+        free
+        hashable
+        monad-control
+        mtl
+        network-uri
+        scientific
+        sqlite-simple
+        text
+        time
+        transformers-base
+      ];
+      testHaskellDepends = [
+        base
+        beam-core
+        beam-migrate
+        sqlite-simple
+        tasty
+        tasty-expected-failure
+        tasty-hunit
+        text
+        time
+      ];
+      description = "Beam driver for SQLite";
+      license = lib.licenses.mit;
+      hydraPlatforms = lib.platforms.none;
+    }
+  ) { };
+
   "beam-th" = callPackage (
     {
       mkDerivation,
···
     }:
     mkDerivation {
       pname = "bech32";
-      version = "1.1.8";
-      sha256 = "0y9k93c5rxh0wjdyz4f1qpp6kljdbsrmy5appp4aqvwq2nqz9aas";
+      version = "1.1.9";
+      sha256 = "0l3h4c1aqjqrlxdc4gq409dwly61i7k2d7g3gz0gya9nf39xc3f4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
     }:
     mkDerivation {
       pname = "bech32-th";
-      version = "1.1.8";
-      sha256 = "0dg79llv3rrakhskzpbs1qdwjn8i1whn1fn3xqkd9scmwh26a2n2";
+      version = "1.1.9";
+      sha256 = "0bc3wx5np17lb1y4s843f8m65687ainiv8biqfhfg7i2gfsc60cs";
       libraryHaskellDepends = [
         base
         bech32
···
       pname = "bhoogle";
       version = "0.1.4.4";
       sha256 = "1z19h0jgnipj16rqbrflcjnqaslafq9bvwkyg8q0il76q7s4wyxa";
-      revision = "1";
-      editedCabalFile = "182j2bc4cqddzv5vd2fkkyx2qs9ya7vg9r234xr5gyp35waln1i9";
+      revision = "2";
+      editedCabalFile = "1kpzvlzydrfqjhmpjirb51xhnwircdcnmhbn82nvnvm5s4h0pajd";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
···
     }:
     mkDerivation {
       pname = "blockfrost-api";
-      version = "0.12.2.0";
-      sha256 = "04w745ws2nf90yix2idd6shahqfi7mwx83j4divjrkfb57pd8v6p";
+      version = "0.13.0.0";
+      sha256 = "0nghxnx9kjwk2frzsy0zrskvn3yffy7xp2fa70hl25bsc4sa2zar";
       libraryHaskellDepends = [
         aeson
         base
···
     }:
     mkDerivation {
       pname = "blockfrost-client";
-      version = "0.9.2.0";
-      sha256 = "04q48afris70y4j4ya52kvj9n1iy8jqn6ygydp11idr15fpjj4qh";
+      version = "0.10.0.0";
+      sha256 = "0jyg2mc8jmwpsix46nh8r6bc2p1j5rdrjsrcdyyvqz5a2ri6hac7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
     }
   ) { };
 
+  "blockio-uring" = callPackage (
+    {
+      mkDerivation,
+      async,
+      base,
+      containers,
+      liburing,
+      primitive,
+      quickcheck-classes,
+      random,
+      tasty,
+      tasty-hunit,
+      tasty-quickcheck,
+      time,
+      unix,
+      vector,
+    }:
+    mkDerivation {
+      pname = "blockio-uring";
+      version = "0.1.0.0";
+      sha256 = "1g4sd7wqxf86i1c5iqiar6mpdszk99v7p71jcrx3dm8pap69r1x7";
+      libraryHaskellDepends = [
+        base
+        primitive
+        vector
+      ];
+      libraryPkgconfigDepends = [ liburing ];
+      testHaskellDepends = [
+        base
+        primitive
+        quickcheck-classes
+        tasty
+        tasty-hunit
+        tasty-quickcheck
+        vector
+      ];
+      testPkgconfigDepends = [ liburing ];
+      benchmarkHaskellDepends = [
+        async
+        base
+        containers
+        primitive
+        random
+        time
+        unix
+        vector
+      ];
+      benchmarkPkgconfigDepends = [ liburing ];
+      description = "Perform batches of asynchronous disk IO operations";
+      license = lib.licenses.bsd3;
+      hydraPlatforms = lib.platforms.none;
+      broken = true;
+    }
+  ) { inherit (pkgs) liburing; };
+
   "blogination" = callPackage (
     {
       mkDerivation,
···
       pname = "boomwhacker";
       version = "0.0.2";
       sha256 = "0q5cq5j7dy1qm5jqpcl1imwiqqm0h21yvqwnvabsjnfrvfvryqg2";
-      revision = "1";
-      editedCabalFile = "0hwqdahpbinw9m7h05q0fhakj4w8mlvqz0ah6609x6wgb0dggmyb";
+      revision = "2";
+      editedCabalFile = "0jqys322j818dc24fyb37a59qs66m3b46j05y4vswipakwm1kgmk";
       isLibrary = false;
       isExecutable = true;
       enableSeparateDataOutput = true;
···
       pname = "brotli";
       version = "0.0.0.2";
       sha256 = "09y460adrq6cp9d8qlf8522yb0qc1vgjxv4d56kq2rdf9khqic6z";
+      revision = "1";
+      editedCabalFile = "1a0lbghilwpa6hb5msivb7hjqnnxi2bxlfgiawv0mjpc7gidhbz7";
       libraryHaskellDepends = [
         base
         bytestring
···
       pname = "brotli-streams";
       version = "0.0.0.0";
       sha256 = "14jc1nhm50razsl99d95amdf4njf75dnzx8vqkihgrgp7qisyz3z";
-      revision = "9";
-      editedCabalFile = "1rhy0d1jy3v9r1skg3bdlnjj5avxy968ih1cyg9x9yb7rbyf3za5";
+      revision = "10";
+      editedCabalFile = "0v0zg5q9ahf8kvfm9zwlj4ws1yd3bvdxyxkak3xk7nca49vb8mcm";
       libraryHaskellDepends = [
         base
         brotli
···
     }:
     mkDerivation {
       pname = "bugsnag";
-      version = "1.1.0.1";
-      sha256 = "1n2lq9iyz5m0s1mx22cwaci18f9i37g6xgdq3nbbyysmylrw09w2";
+      version = "1.1.0.2";
+      sha256 = "1f0jsad9z9zsj8sbirq6h1x0s7245rxv5gpciz4p8wv9ryi8d3m3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
     }
   ) { };
 
+  "bugsnag_1_2_0_0" = callPackage (
+    {
+      mkDerivation,
+      aeson,
+      annotated-exception,
+      base,
+      bugsnag-hs,
+      bytestring,
+      containers,
+      Glob,
+      hspec,
+      http-client,
+      http-client-tls,
+      parsec,
+      template-haskell,
+      text,
+      th-lift-instances,
+      ua-parser,
+      unliftio,
+      unordered-containers,
+    }:
+    mkDerivation {
+      pname = "bugsnag";
+      version = "1.2.0.0";
+      sha256 = "0hhr4z1jdsbg8jx2416dgpad0lirzdjiv79s4ykhfimn2pqk9liq";
+      isLibrary = true;
+      isExecutable = true;
+      libraryHaskellDepends = [
+        aeson
+        annotated-exception
+        base
+        bugsnag-hs
+        bytestring
+        containers
+        Glob
+        http-client
+        http-client-tls
+        parsec
+        template-haskell
+        text
+        th-lift-instances
+        ua-parser
+        unliftio
+        unordered-containers
+      ];
+      testHaskellDepends = [
+        annotated-exception
+        base
+        hspec
+        unliftio
+      ];
+      description = "Bugsnag error reporter for Haskell";
+      license = lib.licenses.mit;
+      hydraPlatforms = lib.platforms.none;
+    }
+  ) { };
+
   "bugsnag-haskell" = callPackage (
     {
       mkDerivation,
···
     }:
     mkDerivation {
       pname = "bugsnag-wai";
-      version = "1.0.0.1";
-      sha256 = "0f3x4m9nl277rhg2pwrja9xh6fffrwl2dm1cf3jiyngkrbrfck0w";
+      version = "1.0.1.1";
+      sha256 = "0wi0ip7fjzk3hvw2i19wjj08pn0bvmnx9j68lh4hgc8a0bdr69bg";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
     }:
     mkDerivation {
       pname = "burrito";
-      version = "2.0.1.13";
-      sha256 = "1bg3nd994xrwpirqn2hsbk831fralal946sac3ljslxjlvxar8v6";
+      version = "2.0.1.14";
+      sha256 = "1mywmf72rsj5p6mrg3454wsihlh1b26x4acb2gp0awx4bg96j09i";
       libraryHaskellDepends = [
         base
         bytestring
···
     }:
     mkDerivation {
       pname = "byteslice";
-      version = "0.2.14.0";
-      sha256 = "0s9cnb7p1wr5vh3j95a952222xf2xzli451las5il3n04n4rxq1n";
+      version = "0.2.15.0";
+      sha256 = "10fcb7g9m4rkd6mza2km64agsgkwrbl7crv5hdcd5yljq6gyx2fm";
       libraryHaskellDepends = [
         base
         bytestring
···
       pname = "cabal-add";
       version = "0.1";
       sha256 = "1szbi0z8yf98641rwnj856gcfsvvflxwrfxraxy6rl60m7i0mab1";
-      revision = "2";
-      editedCabalFile = "1qb5xq7r68psc2dpp8wdfcfd1w4nls7xfla1fkc9vppd8zxmi87m";
+      revision = "3";
+      editedCabalFile = "0siv5ajqxcbs9c0ky94p5qk51w6cgf1zyc3rckxvlc25f4kygw4v";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
     }
   ) { };
 
+  "cabal-add_0_2" = callPackage (
+    {
+      mkDerivation,
+      base,
+      bytestring,
+      Cabal,
+      cabal-install-parsers,
+      Cabal-syntax,
+      containers,
+      Diff,
+      directory,
+      filepath,
+      mtl,
+      optparse-applicative,
+      process,
+      string-qq,
+      tasty,
+      temporary,
+    }:
+    mkDerivation {
+      pname = "cabal-add";
+      version = "0.2";
+      sha256 = "0fd098gkfmxrhq0k4j1ll5g4xwwzgmhdx0mj9hnp5xanj7z1laxg";
+      isLibrary = true;
+      isExecutable = true;
+      libraryHaskellDepends = [
+        base
+        bytestring
+        Cabal
+        Cabal-syntax
+        containers
+        mtl
+      ];
+      executableHaskellDepends = [
+        base
+        bytestring
+        cabal-install-parsers
+        Cabal-syntax
+        directory
+        filepath
+        optparse-applicative
+        process
+      ];
+      testHaskellDepends = [
+        base
+        bytestring
+        Cabal
+        Diff
+        directory
+        process
+        string-qq
+        tasty
+        temporary
+      ];
+      description = "Extend Cabal build-depends from the command line";
+      license = lib.licenses.bsd3;
+      hydraPlatforms = lib.platforms.none;
+      mainProgram = "cabal-add";
+    }
+  ) { };
+
   "cabal-appimage" = callPackage (
     {
       mkDerivation,
···
     }:
     mkDerivation {
       pname = "cabal-cargs";
-      version = "1.6.0";
-      sha256 = "1kn21l5w838db558nijblar6i3z5jkh12d6l1yccxmd70lrb39vv";
+      version = "1.7.0";
+      sha256 = "17q51lg7vhdzvy9s8f3zplxa4mij2bjclzxry5f9d2pgiq4290p9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
     }:
     mkDerivation {
       pname = "cabal-debian";
-      version = "5.2.5";
-      sha256 = "0nkrvs1a9kj2nqz9pklxzni5wbirwgqim9haqn8lglqliycrdzbx";
+      pname = "nat";
+      sha256 = "081h14nw6spfpr6l0cd9knc2jw8g3zhlwyhq7zrxvfrlqwwwm14w";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
       pname = "cabal-flatpak";
       version = "0.1.2";
       sha256 = "05ig175b2glxppn5wr05pnncqkp8yhhy1m7ymmc1jk5pmiy3zvzi";
-      revision = "1";
-      editedCabalFile = "0fhwfjrq20zqh64cb0iv2civljacllgy3zqsyjlydmphs95v5hhv";
+      revision = "2";
+      editedCabalFile = "01iqpfj5nvl19580ckl4b0aljl86svplxzpkavp5r0jbwaqi0ll3";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
···
     }
   ) { };
 
-  "cabal-install-parsers_0_6_2" = callPackage (
+  "cabal-install-parsers_0_6_3" = callPackage (
     {
       mkDerivation,
       aeson,
···
     }:
     mkDerivation {
       pname = "cabal-install-parsers";
-      version = "0.6.2";
-      sha256 = "1362p021irm0kaz7n8gdjy1ppjk914zza114cmpm87ris0i1a9jn";
+      version = "0.6.3";
+      sha256 = "1vcy6y1p750g4v9zqmsakrcvw78p43n2b745fl02xq7xyr5lpfij";
       libraryHaskellDepends = [
         aeson
         base
···
     }:
     mkDerivation {
       pname = "cabal-plan";
-      version = "0.7.5.0";
-      sha256 = "0svvsh3ir9z1pdjbbhi8fkcqv66812hixnv18vifhcw0v8w94ymi";
+      version = "0.7.6.0";
+      sha256 = "0n6q56gyyiflagka0bhmp077py71xdc9j921yyl7818q6b6ha3hs";
       configureFlags = [ "-fexe" ];
       isLibrary = true;
       isExecutable = true;
···
       pname = "cabal-sort";
       version = "0.1.2.2";
       sha256 = "1gyx5d485mzya147d7gwh0i9bkvdqxixrb80bfv5sn710p07bfdz";
+      revision = "1";
+      editedCabalFile = "0hlz8y734rgcqjlncv0bwi05m30iviz6bi9bsafvsv1w25lxlpc4";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
···
     }:
     mkDerivation {
       pname = "cachix";
-      version = "1.7.8";
-      sha256 = "18vp2r0q6ibk5snsys7qh65vmshp4344z29pqdp8qfwzk5yqc3hc";
+      version = "1.7.9";
+      sha256 = "02q0z2f668y826f9rspwwn1kw3ma1igwsh2fp291g4sz8x6z66fv";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
     }:
     mkDerivation {
       pname = "cachix-api";
-      version = "1.7.8";
-      sha256 = "0rvmfwmgyn6jpivq45f5v5sg0s007ansjmizflxgiqn4sfqbkndr";
+      version = "1.7.9";
+      sha256 = "1jp55yvih27xkpky4i6pl37ajwyql84cniz2nhgwdb67qac5nmgi";
       libraryHaskellDepends = [
         aeson
         async
···
     }:
     mkDerivation {
       pname = "cassava";
-      version = "0.5.3.2";
-      sha256 = "1jd9s10z2y3hizrpy3iaw2vvqmk342zxhwkky57ba39cbli5vlis";
+      version = "0.5.4.0";
+      sha256 = "0vdbmvb36sg08glig1dqc8kb1s07l5fcn2n0c58iglkv5djsbpnr";
       revision = "1";
-      editedCabalFile = "0xkqzvj5xd6d37gpf2rm9cp2p2lhkc3jgd0gvlmv99vcmy125rdj";
+      editedCabalFile = "1w7mih2wpbgv0bn2cg2ip0ffsn2y7aywqixi1lig30yarsyc873x";
       configureFlags = [ "-f-bytestring--lt-0_10_4" ];
       libraryHaskellDepends = [
         array
···
   ) { };
 
   "cassette" = callPackage (
-    { mkDerivation, base }:
+    {
+      mkDerivation,
+      base,
+      profunctors,
+    }:
     mkDerivation {
       pname = "cassette";
-      version = "0.1.0";
-      sha256 = "04qnk1s4bdj3wbbxdwzzvpnhkcgma8c4qfkg454ybg7f8kyv6h7x";
-      libraryHaskellDepends = [ base ];
-      description = "A combinator library for simultaneously defining parsers and pretty printers";
-      license = lib.licenses.bsd3;
-      hydraPlatforms = lib.platforms.none;
-      broken = true;
+      version = "0.2.0.1";
+      sha256 = "1rl5bb7bhprvnqcr55psbgws96xvjfci5nimhly3avs7pvkwxbhj";
+      libraryHaskellDepends = [
+        base
+        profunctors
+      ];
+      description = "Combinators to simultaneously define parsers and pretty printers";
+      license = lib.licenses.asl20;
     }
   ) { };
 
···
   "cauldron" = callPackage (
     {
       mkDerivation,
-      algebraic-graphs,
       base,
-      bytestring,
       containers,
       tasty,
       tasty-hunit,
-      text,
       transformers,
     }:
     mkDerivation {
       pname = "cauldron";
-      version = "0.6.1.0";
-      sha256 = "04anjjpjvj51x27mq9n2sc88v6398bz5ljzq049d879avl0i08sj";
+      version = "0.8.0.0";
+      sha256 = "1vkvxkr3lr99xvd4vqga18idcpw3p1mv8hr94qagvfqdxrd68wcl";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
-        algebraic-graphs
         base
-        bytestring
         containers
-        text
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [
-        algebraic-graphs
         base
         containers
         tasty
         tasty-hunit
-        text
         transformers
       ];
+      doHaddock = false;
       description = "Dependency injection library";
       license = lib.licenses.bsd3;
+      hydraPlatforms = lib.platforms.none;
       mainProgram = "cauldron-example-wiring";
+      broken = true;
     }
   ) { };
 
···
       pname = "cborg";
       version = "0.2.10.0";
       sha256 = "15y7p5rsv76fpklh4rgrxlxxaivpbchxdfdw96mqqjgw7060gzhp";
-      revision = "2";
-      editedCabalFile = "0m1ndq1a4yya5p7093lw3ynpcw2q74s73im0bhm9jp6a19cj88m5";
+      revision = "3";
+      editedCabalFile = "1ahqlq51kjc8cf5sybbmrh4rf6vsbkcd67rhxhrr9rc5w6nl9h27";
       libraryHaskellDepends = [
         array
         base
···
       pname = "cborg-json";
       version = "0.2.6.0";
       sha256 = "1p6xdimwypmlsc0zdyw1vyyapnhwn2g8b9n0a83ca6h4r90722yv";
-      revision = "3";
-      editedCabalFile = "1dlmm5jyl8a8rxpkvr2dk5dlsvxrap3x4pbwnx4mg3q7sz25rs8r";
+      revision = "4";
+      editedCabalFile = "06pjqx8v7j8f6rvkf84vahva8y02lykaymnjdrjqrc5rgy01c6m0";
       libraryHaskellDepends = [
         aeson
         aeson-pretty
···
     }
   ) { };
 
-  "chart-svg_0_8_0_3" = callPackage (
+  "chart-svg_0_8_1_0" = callPackage (
     {
       mkDerivation,
       base,
···
     }:
     mkDerivation {
       pname = "chart-svg";
-      version = "0.8.0.3";
-      sha256 = "0qvnxm90vka02pplz9fxncsplnsbxkh9xcp81wik0g795g7xkpsp";
+      version = "0.8.1.0";
+      sha256 = "1rsix6qdxhsgjg4zp7rh5di6y5mjxjv0mzv9g82ryl3vlcryyaj4";
       libraryHaskellDepends = [
         base
         bytestring
···
     }:
     mkDerivation {
       pname = "co-log-concurrent";
-      version = "0.5.1.0";
-      sha256 = "07qmx9z03vmgq2cgz4352fsav7r1nx8n7svmrhg2lkdiyp0j7a59";
-      revision = "3";
-      editedCabalFile = "17pmkgly1882hbwa6b2qb0y1wh4x4nawhw1vl8fsy252caxkck0s";
+      version = "0.5.1.1";
+      sha256 = "1yw5ljanhc176k4xj1pfqkhq6c63hv5an7pm06vjiakmk6j4rqlg";
+      revision = "1";
+      editedCabalFile = "071xrzj7bjnb32f5dlsqa726cmw9s9q22bv7ch4gj2r83crng68g";
       libraryHaskellDepends = [
         base
         co-log-core
···
       ];
       description = "Asynchronous backend for co-log library";
       license = lib.licenses.mpl20;
-      hydraPlatforms = lib.platforms.none;
-      broken = true;
     }
   ) { };
 
···
     }:
     mkDerivation {
       pname = "co-log-json";
-      version = "0.1.0.0";
-      sha256 = "0212dcaw4anjn569a8gpv30k09b9lk99r70bbsh7kb8hb268rk83";
+      version = "0.1.0.2";
+      sha256 = "0lr8599hqiyg70qw5pmdbrpm1lyps819h7anxxi4ip2r1im2p3xd";
       libraryHaskellDepends = [
         aeson
         base
···
       ];
       description = "Structured messages support in co-log ecosystem";
       license = lib.licenses.mpl20;
-      hydraPlatforms = lib.platforms.none;
-      broken = true;
     }
   ) { };
 
···
     }:
     mkDerivation {
       pname = "compactmap";
-      version = "0.1.4.5";
-      sha256 = "1xa4wa4qjd7yjghkaakpgrz9kw4iyy0zlc9cpajyysaxdq4k7czf";
+      version = "0.1.4.6";
+      sha256 = "1lkvhmdz77m6jm43946q2g6ijl7w6kqs9n68g1gzfxw6akmpy39y";
       libraryHaskellDepends = [
         base
         vector
···
     }:
     mkDerivation {
       pname = "conduit-extra";
-      version = "1.3.7";
-      sha256 = "0mrbaf4lrnczgn1kxjwpmzxk226wprw10y9xg621g74h4s36zgdj";
+      version = "1.3.8";
+      sha256 = "08l2728vyr3dppnj4z3yagi2265ixp8g8ayhz07x3x88jj73w7s9";
+      revision = "1";
+      editedCabalFile = "1fq0cs2fcn2kd1mvp9ygsp7rm5qridwp1wwnr60jmpahvihb4cp9";
       libraryHaskellDepends = [
         async
         attoparsec
···
       conduit,
       conduit-combinators,
       conduit-extra,
-      directory,
-      doctest,
       either,
       exceptions,
       filepath,
···
       monad-control,
       mtl,
       regex-posix,
+      resourcet,
       semigroups,
       streaming-commons,
       text,
       time,
       transformers,
       transformers-base,
+      transformers-either,
       unix,
       unix-compat,
+      unliftio-core,
     }:
     mkDerivation {
       pname = "conduit-find";
-      version = "0.1.0.3";
-      sha256 = "13gbpvqxs3k2vlsbdn0vr90z4y8kaz7hlw9bywyqd8jna3ff13a9";
+      version = "0.1.0.4";
+      sha256 = "03mrfqmxryrv21adk6ijf3isfffjhf91qkjqqrlfkm3fxhz2xp4m";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
         monad-control
         mtl
         regex-posix
+        resourcet
         semigroups
         streaming-commons
         text
         time
         transformers
         transformers-base
+        transformers-either
         unix-compat
+        unliftio-core
       ];
       executableHaskellDepends = [
         attoparsec
···
         monad-control
         mtl
         regex-posix
+        resourcet
         semigroups
         streaming-commons
         text
···
         transformers
         transformers-base
         unix
+        unliftio-core
       ];
       testHaskellDepends = [
         attoparsec
         base
         conduit
         conduit-combinators
-        directory
-        doctest
         either
         exceptions
         filepath
···
         monad-control
         mtl
         regex-posix
+        resourcet
         semigroups
         streaming-commons
         text
···
         transformers
         transformers-base
         unix-compat
+        unliftio-core
       ];
       description = "A file-finding conduit that allows user control over traversals";
       license = lib.licenses.mit;
···
     }:
     mkDerivation {
       pname = "control-block";
-      version = "0.0.1";
-      sha256 = "06l9s8inrdqp9z4zsd178rk3211zmhx4acwxq1py801lpb7vgn8v";
+      version = "0.0.2";
+      sha256 = "0p79ic8yq9jw86jiyxs6k6z740w25ckkdn0lp3rj8rxya2h7viaw";
       libraryHaskellDepends = [
         base
         indexed-traversable
···
       ];
       description = "Higher-order functions with their function arguments at the end, for channeling the full power of BlockArguments and LambdaCase";
       license = lib.licenses.bsd2;
-      hydraPlatforms = lib.platforms.none;
-      broken = true;
     }
   ) { };
 
···
     }
   ) { };
 
+  "convex-schema-parser" = callPackage (
+    {
+      mkDerivation,
+      aeson,
+      base,
+      containers,
+      deepseq,
+      directory,
+      filepath,
+      fsnotify,
+      HUnit,
+      mtl,
+      optparse-applicative,
+      parsec,
+      process,
+      split,
+      stm,
+      yaml,
+    }:
+    mkDerivation {
+      pname = "convex-schema-parser";
+      version = "0.1.3.0";
+      sha256 = "01z32fdxzwqbn8i7izh4amqa3jv4zfkxjn2zcy3fmyc7js72az68";
+      isLibrary = false;
+      isExecutable = true;
+      libraryHaskellDepends = [
+        base
+        containers
+        directory
+        filepath
+        mtl
+        parsec
+        process
+        split
+      ];
+      executableHaskellDepends = [
+        aeson
+        base
+        deepseq
+        directory
+        filepath
+        fsnotify
+        optparse-applicative
+        parsec
+        process
+        stm
+        yaml
+      ];
+      testHaskellDepends = [
+        base
+        containers
+        HUnit
+        mtl
+        parsec
+      ];
+      doHaddock = false;
+      description = "A type-safe client generator for Convex for both Rust and Python";
+      license = lib.licenses.mit;
+      hydraPlatforms = lib.platforms.none;
+      mainProgram = "convex-schema-parser";
+      broken = true;
+    }
+  ) { };
+
   "convexHullNd" = callPackage (
     {
       mkDerivation,
···
       pname = "countdown-numbers-game";
       version = "0.0.0.1";
       sha256 = "1warpkqimxjvqrm1jq4nbj3g3bz009alklqs46dh23p3lrgcif61";
+      revision = "1";
+      editedCabalFile = "05106icwf7kvnwj5109yim2xyx8q5lxvccbn2dqb0q571h5v1a5q";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
···
       pname = "criterion";
       version = "1.6.4.0";
       sha256 = "0l9gxar759nskhm7gskr3j08bw8515amw6rr4n3zx3978dxg8aq6";
+      revision = "1";
+      editedCabalFile = "0wwzijzvqrv7swpalr24i3j4pjcjm266ybhhah853d783zz37vzz";
       isLibrary = true;
       isExecutable = true;
       enableSeparateDataOutput = true;
···
     }
   ) { inherit (pkgs) cudd; };
 
+  "cuddle" = callPackage (
+    {
+      mkDerivation,
+      base,
+      base16-bytestring,
+      boxes,
+      bytestring,
+      capability,
+      cborg,
+      containers,
+      data-default-class,
+      foldable1-classes-compat,
+      generic-optics,
+      hashable,
+      hspec,
+      hspec-megaparsec,
+      HUnit,
+      megaparsec,
+      mtl,
+      mutable-containers,
+      optics-core,
+      optparse-applicative,
+      ordered-containers,
+      parser-combinators,
+      prettyprinter,
+      QuickCheck,
+      random,
+      regex-tdfa,
+      scientific,
+      string-qq,
+      text,
+      tree-diff,
+    }:
+    mkDerivation {
+      pname = "cuddle";
+      version = "0.5.0.0";
+      sha256 = "1vjm6v5wf1hbj7ikwmfxf4ah62g4j33nhqqc1xjb9dll5jlvadyn";
+      isLibrary = true;
+      isExecutable = true;
+      libraryHaskellDepends = [
+        base
+        base16-bytestring
+        boxes
+        bytestring
+        capability
+        cborg
+        containers
+        data-default-class
+        foldable1-classes-compat
+        generic-optics
+        hashable
+        megaparsec
+        mtl
+        mutable-containers
+        optics-core
+        ordered-containers
+        parser-combinators
+        prettyprinter
+        random
+        regex-tdfa
+        scientific
+        text
+        tree-diff
+      ];
+      executableHaskellDepends = [
+        base
+        base16-bytestring
+        bytestring
+        cborg
+        megaparsec
+        mtl
+        optparse-applicative
+        prettyprinter
+        random
+        text
+      ];
+      testHaskellDepends = [
+        base
+        bytestring
+        data-default-class
+        hspec
+        hspec-megaparsec
+        HUnit
+        megaparsec
+        prettyprinter
+        QuickCheck
+        string-qq
+        text
+        tree-diff
+      ];
+      description = "CDDL Generator and test utilities";
+      license = lib.licenses.asl20;
+      hydraPlatforms = lib.platforms.none;
+      mainProgram = "cuddle";
+      broken = true;
+    }
+  ) { };
+
   "cue-sheet" = callPackage (
     {
       mkDerivation,
···
     }
   ) { };
 
+  "data-debruijn" = callPackage (
+    {
+      mkDerivation,
+      base,
+      containers,
+      deepseq,
+      ghc-bignum,
+      ghc-prim,
+      QuickCheck,
+    }:
+    mkDerivation {
+      pname = "data-debruijn";
+      version = "0.1.0.0";
+      sha256 = "1zwi7wsznmhph5nljhxzk1rbz5a8qz79j8djdkqc169z5f7fkssv";
+      revision = "1";
+      editedCabalFile = "1njc7m4g0nwj9ww2gk2z83xbll8pcchmmix109fwgwgz9jv26ckr";
+      libraryHaskellDepends = [
+        base
+        containers
+        deepseq
+        ghc-bignum
+        ghc-prim
+        QuickCheck
+      ];
+      doHaddock = false;
+      description = "Fast and safe implementation of common compiler machinery";
+      license = lib.licenses.agpl3Only;
+    }
+  ) { };
+
   "data-default" = callPackage (
     {
       mkDerivation,
···
     }:
     mkDerivation {
       pname = "dataframe";
-      version = "0.1.0.3";
-      sha256 = "0p4syk43nz1b9x9fzm3hgrdgksjs3siqgczaf2bqmgrra61fw8nh";
+      version = "0.2.0.1";
+      sha256 = "1qgdlmyz4mlvqb1qicspv7yiddyla8kxczx7018myryws9861f52";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
     }
   ) { };
 
-  "dbus_1_4_0" = callPackage (
+  "dbus_1_4_1" = callPackage (
     {
       mkDerivation,
       base,
···
     }:
     mkDerivation {
       pname = "dbus";
-      version = "1.4.0";
-      sha256 = "1rb5q8g0n3fj9b57wlds7ldji029fqym4dvpvq10hmn7qw313dz6";
+      version = "1.4.1";
+      sha256 = "016xrx8gnvldpwgalpsxzvkwagavpzw9m7j65w5msskaxk474ln7";
       libraryHaskellDepends = [
         base
         bytestring
···
       containers,
       hspec,
       markdown-unlit,
+      scientific,
       text,
       vector,
     }:
     mkDerivation {
       pname = "debug-print";
-      version = "0.2.0.1";
-      sha256 = "1bcdmnkxcyicw4f57vlx64iyfj3lwz1157s89k4gdyk3ilc2x8g4";
+      version = "0.2.1.0";
+      sha256 = "1mgl8sc69fbpcx3hrb8b1dcsgs2zzflms5ryf3zbs8j91yvpx02s";
       libraryHaskellDepends = [
         aeson
         base
         containers
+        scientific
         text
         vector
       ];
···
       pname = "decimal-literals";
       version = "0.1.0.1";
       sha256 = "0lbpnc4c266fbqjzzrnig648zzsqfaphlxqwyly9xd15qggzasb0";
-      revision = "3";
-      editedCabalFile = "1650vnqwjsqg2mghsvghiyzg5qqbz36vibkq8614adhyjpcd3w07";
+      revision = "4";
+      editedCabalFile = "1jiayinmqx35lm7n5dwgfqfq8pafdz7q1ysv8lqqjaiylrlm092r";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [
         base
···
     }
   ) { };
 
-  "deepseq_1_5_1_0" = callPackage (
+  "deepseq_1_5_2_0" = callPackage (
     {
       mkDerivation,
       base,
···
     }:
     mkDerivation {
       pname = "deepseq";
-      version = "1.5.1.0";
-      sha256 = "0yz1b3c4fpa1pknwd64fba37wbr7mxzawd0han2ifq70mgiqfkiz";
+      version = "1.5.2.0";
+      sha256 = "1rgv1kn3igdip34bpn24syirmsjllipd98l301y5n225gw6q1mq9";
       libraryHaskellDepends = [
         base
         ghc-prim
···
       pname = "deltaq";
       version = "1.0.0.0";
       sha256 = "00zpvwxar13rq84li7j21ycapdnyx128cs2yqvn6hwnrr8w25w9d";
+      revision = "1";
+      editedCabalFile = "1i4lkq6w34ik7csx6wpwy4by2vbdijilpynwjf9kr7dfn5ac2gz1";
       libraryHaskellDepends = [
         base
         Chart
···
       pname = "diagrams-builder";
       version = "0.8.0.6";
       sha256 = "17yi5dmcxx4sgk3wha386zbv9h69pwq72j8i21vmfh35brxhs9f4";
-      revision = "2";
-      editedCabalFile = "1mkxn0r6wmxyvdhwly1a6j0z4j234mfv7aimirwl7jmcv55lwbs4";
+      revision = "3";
+      editedCabalFile = "0pi4509j5i8jgxn0a9z39ac1sr8n2n97v8pfyla9s30sc63ybjag";
       configureFlags = [
         "-fcairo"
         "-fps"
···
     }
   ) { };
 
-  "diagrams-cairo_1_4_3" = callPackage (
+  "diagrams-cairo_1_5" = callPackage (
     {
       mkDerivation,
       array,
···
     }:
     mkDerivation {
       pname = "diagrams-cairo";
-      version = "1.4.3";
-      sha256 = "0irj7jigi9dfprjilndyx0kwg7vjpbhrsxhlsqc8n1sy1b4s2aha";
+      version = "1.5";
+      sha256 = "1s0cq1sv158b7pszhipc4f5555zfqz1xxa7hdd13afx7jnh68z3i";
+      revision = "1";
+      editedCabalFile = "19daz3jx4kc4pqr0ffq4wrpfwk95xz3fnhlacba9q96aw3c1vcnd";
       libraryHaskellDepends = [
         array
         base
···
       pname = "diagrams-canvas";
       version = "1.4.2";
       sha256 = "0ns1xmgcjqig7qld7r77rbcrk779cmzj7xfqj6a7sbdci3in2dgm";
-      revision = "1";
-      editedCabalFile = "08pm7i10k7a046jjrdbzhmlrv05wp171mblgs8y18m6vc8hw87v6";
+      revision = "2";
+      editedCabalFile = "0if7b5dzgrdqz491ma31kizasiyaa3pc0m570r4ccr4m2gs7jz2m";
       libraryHaskellDepends = [
         base
         blank-canvas
···
       pname = "diagrams-contrib";
       version = "1.4.6";
       sha256 = "1x5z361xmqfa503brmf0zwyq3lldm9kgixx90v14s4dsz52my46k";
-      revision = "1";
-      editedCabalFile = "00zgzy7b3vkjd0f22hbp2lknwl1x5nd6d1ng30wq4qlncwdxqkpz";
+      revision = "3";
+      editedCabalFile = "07yslc0ds8sj412xgy13dxa7g2a8psgx06nds99yd55bfppias32";
       libraryHaskellDepends = [
         base
         circle-packing
···
     }:
     mkDerivation {
       pname = "diagrams-gi-cairo";
-      version = "1.4.2";
-      sha256 = "0k6fw1vvqa4pra4czd90n7i7h1vf6hn08a4jip1xbqkf57d89bn6";
-      revision = "1";
-      editedCabalFile = "1r1ph8nc7xgh3by63dsamkvhi6bvw1bgvhnc8f664iiziaj9p08a";
+      version = "1.5";
+      sha256 = "1wkr52maf7320k75si6lbwds39i0zw0mhd8b4y5h262ifqfkyi1s";
       libraryHaskellDepends = [
         array
         base
···
       pname = "diagrams-gtk";
       version = "1.4";
       sha256 = "1sga2wwkircjgryd4pn9i0wvvcnh3qnhpxas32crpdq939idwsxn";
-      revision = "6";
-      editedCabalFile = "0fiv5w3pk8rbj6d28qyay13h25px7fs1flzqdriz1n74f6prnj98";
+      revision = "7";
+      editedCabalFile = "065hmxb3hhaa7g1xbay0wa29zcyivxrp289l9wrak7pg610ri3j3";
       libraryHaskellDepends = [
         base
         cairo
···
       ];
       description = "Backend for rendering diagrams directly to GTK windows";
       license = lib.licenses.bsd3;
-      hydraPlatforms = lib.platforms.none;
-      broken = true;
     }
   ) { };
 
···
       pname = "diagrams-lib";
       version = "1.5";
       sha256 = "0gp9k6cfc62j6rlfiziig6j5shf05d0vbcvss40rzjk8qi012i11";
-      revision = "1";
-      editedCabalFile = "092pidlcpqxrjqjmpwgiznqkjzz1qwbkxb8526k2gi7n1zy2bw3v";
+      revision = "2";
+      editedCabalFile = "0499yz41prmsixfq2h9virqr9fkn9akllxxf0yc2kqkv7ran2ij9";
       libraryHaskellDepends = [
         active
         adjunctions
···
     }:
     mkDerivation {
       pname = "diagrams-pandoc";
-      version = "0.4";
-      sha256 = "164f0k1jk8p604h31wypy2z2jy5x0gfbkbmmrd64c9jp7j71iyc4";
+      version = "0.4.1";
+      sha256 = "1gil467zp3n6wymiw4d492izf1hhac01j4nafmahjh4ybvi840xr";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
       ];
       description = "A Pandoc filter to express diagrams inline using the Haskell EDSL _Diagrams_";
       license = lib.licenses.bsd3;
-      hydraPlatforms = lib.platforms.none;
       mainProgram = "diagrams-pandoc";
-      broken = true;
     }
   ) { };
 
···
       pname = "diagrams-pgf";
       version = "1.5";
       sha256 = "13zm00ayyk6gvlh4l2wdmrdqic386v69i3krylgvrajhdsd050al";
+      revision = "1";
+      editedCabalFile = "0vzi1dim76arwjrh9yqb9l2004ffsir8rws4vx26is5wzxsqf8y1";
       libraryHaskellDepends = [
         base
         bytestring
···
       pname = "diagrams-postscript";
       version = "1.5.2";
       sha256 = "08kqhnd5r60kisjraypwjfcri1v4f32rf14js413871pgic4rhy5";
-      revision = "1";
-      editedCabalFile = "0ndvf9nhvgwvwnc0k9in3n83l3jif1nzsyyrmpk5plif590hj1zp";
+      revision = "2";
+      editedCabalFile = "060zkv836i1df97nqkna8fnqkyxv4wgmk7yn74whyf1fii4rf86g";
       libraryHaskellDepends = [
         base
         bytestring
···
       pname = "diagrams-rasterific";
       version = "1.5";
       sha256 = "02bq6819a8xxa20kggmg9j5wa72zh4gbcvbpv1b1pzbg57bp2s8k";
+      revision = "1";
+      editedCabalFile = "1f5l5w28kbnajc0kd304fs2h9svc2inb90qbjmqyii30bf0b2n15";
       libraryHaskellDepends = [
         base
         bytestring
···
       ];
       description = "reflex backend for diagrams drawing EDSL";
       license = lib.licenses.bsd3;
-      hydraPlatforms = lib.platforms.none;
     }
   ) { };
 
···
       pname = "diagrams-svg";
       version = "1.5";
       sha256 = "1g11fvcgx99xg71c9sd6m7pfclnzcfx72alcx3avlb4qzz56wn52";
+      revision = "2";
+      editedCabalFile = "1d7n707vmcbk1l1fi956hagyyzzn3hd11wxyabm1mirv8qxrha0s";
       libraryHaskellDepends = [
         base
         base64-bytestring
···
     }:
     mkDerivation {
       pname = "discord-haskell";
-      version = "1.17.1";
-      sha256 = "1lw1n8m297ad0rcbn48ysg85l35sg5bh3gwbnm2698cd051b4yad";
+      version = "1.18.0";
+      sha256 = "0g3xlhjfqslv6565fgzq0m0qdsf50kv9m5shb71yr4hwvar4w7qc";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
       ];
       description = "Write bots for Discord in Haskell";
       license = lib.licenses.mit;
-      hydraPlatforms = lib.platforms.none;
-      broken = true;
     }
   ) { };
 
···
     }
   ) { };
 
-  "doctest_0_24_0" = callPackage (
+  "doctest_0_24_2" = callPackage (
     {
       mkDerivation,
       base,
···
     }:
     mkDerivation {
       pname = "doctest";
-      version = "0.24.0";
-      sha256 = "1cylb84kmlw7a38xnfyx0sxcpgahmfm7bsbv0vf2x3slsgz597kx";
+      version = "0.24.2";
+      sha256 = "1dpffnr24zaricmkwc13npap569crwwfha1w9vz3fhywmh0dnfjk";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
     }:
     mkDerivation {
       pname = "doctest-exitcode-stdio";
-      version = "0.0";
-      sha256 = "1g3c7yrqq2mwqbmvs8vkx1a3cf0p0x74b7fnn344dsk7bsfpgv0x";
-      revision = "2";
-      editedCabalFile = "0gfnxkbm126m0d4pnqgl5ca6ab8x5p1vpbxjxgz1sxczablsmk5b";
+      version = "0.0.0.1";
+      sha256 = "0kg5xiw4giyvqpcj6cxqqnysvixhxlwm0pbg3qks8dzwb5w79dvk";
       libraryHaskellDepends = [
         base
         doctest-lib
···
       pname = "doctest-extract";
       version = "0.1.2";
       sha256 = "1dizs0r9pdankbv5ijfgqva5ha8p5xxl7x8y1sjql6h7ch8pz0p6";
+      revision = "1";
+      editedCabalFile = "1m71h2iwizh9rms2dq29wwzbsfz8qzqw7q8vldpmk7nm1572rhss";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
···
     }
   ) { };
 
+  "doctest-parallel_0_4" = callPackage (
+    {
+      mkDerivation,
+      base,
+      base-compat,
+      Cabal,
+      code-page,
+      containers,
+      deepseq,
+      directory,
+      exceptions,
+      filepath,
+      ghc,
+      ghc-exactprint,
+      ghc-paths,
+      Glob,
+      hspec,
+      hspec-core,
+      HUnit,
+      mockery,
+      process,
+      QuickCheck,
+      random,
+      setenv,
+      silently,
+      stringbuilder,
+      syb,
+      template-haskell,
+      transformers,
+      unordered-containers,
+    }:
+    mkDerivation {
+      pname = "doctest-parallel";
+      version = "0.4";
+      sha256 = "1y907fg2y7ayddwv38rjv6nyc18w682dxwkq3msqnlkddglqlxfx";
+      libraryHaskellDepends = [
+        base
+        base-compat
+        Cabal
+        code-page
+        containers
+        deepseq
+        directory
+        exceptions
+        filepath
+        ghc
+        ghc-exactprint
+        ghc-paths
+        Glob
+        process
+        random
+        syb
+        template-haskell
+        transformers
+        unordered-containers
+      ];
+      testHaskellDepends = [
+        base
+        base-compat
+        code-page
+        containers
+        deepseq
+        directory
+        exceptions
+        filepath
+        ghc
+        ghc-paths
+        hspec
+        hspec-core
+        HUnit
+        mockery
+        process
+        QuickCheck
+        setenv
+        silently
+        stringbuilder
+        syb
+        transformers
+      ];
+      doHaddock = false;
+      description = "Test interactive Haskell examples";
+      license = lib.licenses.mit;
+      hydraPlatforms = lib.platforms.none;
+    }
+  ) { };
+
   "doctest-prop" = callPackage (
     {
       mkDerivation,
···
     }:
     mkDerivation {
       pname = "dollaridoos";
-      version = "0.1.0.0";
-      sha256 = "1pipbyfpny8mq540rpfkgkwbc3mc13yf6xm1h9vxm0fnaa8kcbw9";
+      version = "0.2.0.0";
+      sha256 = "09hbm1dkgg8qb4y22hbqwmy858nbaxjn9vizv7z58gd2756gia7s";
       libraryHaskellDepends = [
         base
         profunctors
···
       ];
       description = "Simple monadic DOM parser";
       license = lib.licenses.mit;
-      hydraPlatforms = lib.platforms.none;
-      broken = true;
     }
   ) { };
 
···
     }:
     mkDerivation {
       pname = "double-x-encoding";
-      version = "1.2.1";
-      sha256 = "0sg8sh9a1krzfhdwxcd3ja56kzr6hif11s4iqicrdqz3qgi905ia";
+      version = "1.2.2";
+      sha256 = "0wzawzwsw2dkmw5yvnva8la6v2iwr5ni353imi0qmsgssvg0va6s";
       libraryHaskellDepends = [
         base
         Cabal-syntax
···
       ];
       description = "Encoding scheme to encode any Unicode string with only [0-9a-zA-Z_]";
       license = lib.licenses.isc;
-      hydraPlatforms = lib.platforms.none;
-      broken = true;
     }
   ) { };
 
···
       pname = "dumb-cas";
       version = "0.2.1.1";
       sha256 = "0rqh1sy500gbgqr69z220yb8g7gp117z0iw1kly9zxqhrzn3sv9f";
-      revision = "1";
-      editedCabalFile = "031hcc34r20gpvsicllwcvvzirx2bm5nsdabp75a0m05rj3wzmvv";
+      revision = "2";
+      editedCabalFile = "0gg7yxb8r8f53pw6j33ifm9l5a934q7x261kbydj1kf8zbq0pwfd";
       libraryHaskellDepends = [
         base
         containers
···
       ];
       description = "A computer “algebra” system that knows nothing about algebra, at the core";
       license = lib.licenses.gpl3Only;
-      hydraPlatforms = lib.platforms.none;
-      broken = true;
     }
   ) { };
 
···
     }:
     mkDerivation {
       pname = "dwergaz";
-      version = "0.3.0.2";
-      sha256 = "0849adznjgfg4z1llq5kfwi3ypjj9bj1jw7anax6g86izzvs75jj";
+      version = "0.3.1.0";
+      sha256 = "1c40js81v95hl90zv7nbsmdn8z05s8f2arjhzvsbimckvjrg03x9";
       libraryHaskellDepends = [
         base
         pretty
···
     }:
     mkDerivation {
       pname = "effect-stack";
-      version = "0.3";
-      sha256 = "08zalj8svp78ykqbf5nhd6khgygz8dplcvjd19w3hvgm08y4kxqi";
+      version = "0.3.0.1";
+      sha256 = "04y5rqvjzz5fsvlkwqwjlwngz3j3p83anzh77d7fbmkii8fb9g87";
       libraryHaskellDepends = [
         base
         constraints
···
       ];
       description = "Reducing the pain of transformer stacks with duplicated effects";
       license = lib.licenses.bsd3;
-      hydraPlatforms = lib.platforms.none;
-      broken = true;
     }
   ) { };
 
···
     }
   ) { };
 
+  "effectful_2_6_0_0" = callPackage (
+    {
+      mkDerivation,
+      async,
+      base,
+      bytestring,
+      containers,
+      directory,
+      effectful-core,
+      exceptions,
+      lifted-base,
+      primitive,
+      process,
+      safe-exceptions,
+      stm,
+      strict-mutable-base,
+      tasty,
+      tasty-bench,
+      tasty-hunit,
+      text,
+      time,
+      unix,
+      unliftio,
+    }:
+    mkDerivation {
+      pname = "effectful";
+      version = "2.6.0.0";
+      sha256 = "1k850pgslnfdhfwqcwr4hv2ymab4cszklrh4rxmwhwixrbb7m3l8";
+      libraryHaskellDepends = [
+        async
+        base
+        bytestring
+        directory
+        effectful-core
+        process
+        stm
+        strict-mutable-base
+        time
+        unliftio
+      ];
+      testHaskellDepends = [
+        base
+        containers
+        effectful-core
+        exceptions
+        lifted-base
+        primitive
+        safe-exceptions
+        strict-mutable-base
+        tasty
+        tasty-hunit
+        unliftio
+      ];
+      benchmarkHaskellDepends = [
+        async
+        base
+        tasty-bench
+        text
+        unix
+        unliftio
+      ];
+      description = "An easy to use, performant extensible effects library";
+      license = lib.licenses.bsd3;
+      hydraPlatforms = lib.platforms.none;
+    }
+  ) { };
+
   "effectful-core" = callPackage (
     {
       mkDerivation,
···
     }
   ) { };
 
+  "effectful-core_2_6_0_0" = callPackage (
+    {
+      mkDerivation,
+      base,
+      containers,
+      deepseq,
+      exceptions,
+      monad-control,
+      primitive,
+      strict-mutable-base,
+      transformers-base,
+      unliftio-core,
+    }:
+    mkDerivation {
+      pname = "effectful-core";
+      version = "2.6.0.0";
+      sha256 = "1zi1cgnyfzz5csml8saf9zxixrc7q074ywgh0cjd5k2v3zj79rw1";
+      libraryHaskellDepends = [
+        base
+        containers
+        deepseq
+        exceptions
+        monad-control
+        primitive
+        strict-mutable-base
+        transformers-base
+        unliftio-core
+      ];
+      description = "An easy to use, performant extensible effects library";
+      license = lib.licenses.bsd3;
+      hydraPlatforms = lib.platforms.none;
+    }
+  ) { };
+
   "effectful-plugin" = callPackage (
     {
       mkDerivation,
···
       ];
       description = "A GHC plugin for improving disambiguation of effects";
       license = lib.licenses.bsd3;
+    }
+  ) { };
+
+  "effectful-plugin_2_0_0_0" = callPackage (
+    {
+      mkDerivation,
+      base,
+      containers,
+      effectful-core,
+      ghc,
+    }:
+    mkDerivation {
+      pname = "effectful-plugin";
+      version = "2.0.0.0";
+      sha256 = "11xy98k20r9bw2436digcn3mjdk5qlf12i0h7d0xizsqsdazyvy6";
+      libraryHaskellDepends = [
+        base
+        containers
+        effectful-core
+        ghc
+      ];
+      testHaskellDepends = [
+        base
+        effectful-core
+      ];
+      description = "A GHC plugin for improving disambiguation of effects";
+      license = lib.licenses.bsd3;
+      hydraPlatforms = lib.platforms.none;
     }
   ) { };
 
···
       profunctors,
       QuickCheck,
       semigroupoids,
-      test-framework,
-      test-framework-quickcheck2,
+      tasty,
+      tasty-quickcheck,
     }:
     mkDerivation {
       pname = "either";
-      version = "5.0.2";
-      sha256 = "1gl748ia68bldbqb2fl7vjv44g0y8ivn659fjmy1qyypgyb5p95z";
-      revision = "2";
-      editedCabalFile = "1lx6ls938vssg75ib2fr1ww4nsig2rkhjc6x57yfinx1yb9r62vz";
+      version = "5.0.3";
+      sha256 = "00a8h2jgrpqdlsi8vjrm2qa6rmw33ksirxv9s6i90nlmhhg6jrkd";
       libraryHaskellDepends = [
         base
         bifunctors
···
       testHaskellDepends = [
         base
         QuickCheck
-        test-framework
-        test-framework-quickcheck2
+        tasty
+        tasty-quickcheck
       ];
       description = "Combinators for working with sums";
       license = lib.licenses.bsd3;
···
       mkDerivation,
       base,
       containers,
+      ghc-prim,
       text,
       unordered-containers,
     }:
     mkDerivation {
       pname = "ekg-core";
-      version = "0.1.1.8";
-      sha256 = "028c3g1fz0rfxpfn98wxxmklnxx3szwvjxl9n9ls2w011vqslvia";
-      revision = "1";
-      editedCabalFile = "1lwss6aha8bjmjb3xji58jznca7k7nss76qva5pihgb20j7xs7vi";
+      version = "0.1.2.0";
+      sha256 = "12d4xzkdczbrmhhpgymf9brjn0kpq5645dq57xw05sylalfyslzz";
       libraryHaskellDepends = [
         base
         containers
+        ghc-prim
         text
         unordered-containers
       ];
···
     }:
     mkDerivation {
       pname = "erebos-tester";
-      version = "0.3.2";
-      sha256 = "0m3fi03q0l55r6amxcq0l01sqcg8m6hqbx1zhdaq75s3yyx4wb71";
+      version = "0.3.3";
+      sha256 = "0xcwijr034dw5s4f6jyb727449wayyd31lv8afmfr49i0jmwhgay";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
···
     }
   ) { };
 
+  "ersatz_0_6" = callPackage (
+    {
+      mkDerivation,
+      array,
+      attoparsec,
+      base,
+      bytestring,
+      containers,
+      data-default,
+      fail,
+      lens,
+      mtl,
+      optparse-applicative,
+      parsec,
+      process,
+      semigroups,
+      streams,
+      tasty,
+      tasty-hunit,
+      temporary,
+      transformers,
+      unordered-containers,
+    }:
+    mkDerivation {
+      pname = "ersatz";
+      version = "0.6";
+      sha256 = "05wg6hvrxijdw6pnzpzdcf85ybjdhax731f70gxl1hvwfllrp43j";
+      isLibrary = true;
+      isExecutable = true;
+      enableSeparateDataOutput = true;
+      libraryHaskellDepends = [
+        array
+        attoparsec
+        base
+        bytestring
+        containers
+        data-default
+        lens
+        mtl
+        process
+        semigroups
+        streams
+        temporary
+        transformers
+        unordered-containers
+      ];
+      executableHaskellDepends = [
+        array
+        base
+        bytestring
+        containers
+        fail
+        lens
+        mtl
+        optparse-applicative
+        parsec
+        semigroups
+      ];
+      testHaskellDepends = [
+        array
+        base
+        containers
+        data-default
+        tasty
+        tasty-hunit
+      ];
+      description = "A monad for expressing SAT or QSAT problems using observable sharing";
+      license = lib.licenses.bsd3;
+      hydraPlatforms = lib.platforms.none;
+      broken = true;
+    }
+  ) { };
+
   "ersatz-toysat" = callPackage (
     {
       mkDerivation,
···
     }:
     mkDerivation {
       pname = "eventlog2html";
-      version = "0.11.1";
-      sha256 = "1rfyw285g48c7dck8kjykx9n4brw7ngm275n64g1wwwkm4ybn43n";
-      revision = "1";
-      editedCabalFile = "0kxb0990f8x394j2l7y5y2xz43lqdlm4bc6gihfqnkc6w5qsqhji";
+      version = "0.12.0";
+      sha256 = "1jbp46hcx4kcnkln9vd8b36fjwhxlmlcv08narr6w5bfxz1dpzy6";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
     }
   ) { };
 
-  "exceptions_0_10_9" = callPackage (
+  "exceptions_0_10_10" = callPackage (
     {
       mkDerivation,
       base,
       mtl,
       QuickCheck,
       stm,
+      tasty,
+      tasty-hunit,
+      tasty-quickcheck,
       template-haskell,
-      test-framework,
-      test-framework-hunit,
-      test-framework-quickcheck2,
       transformers,
     }:
     mkDerivation {
       pname = "exceptions";
-      version = "0.10.9";
-      sha256 = "0h5y2rqg7kz4ic59n5i7619766mzfpqcdill3l712nihs3q2nk4v";
-      revision = "1";
-      editedCabalFile = "11p0d1gd3ybgbyplhr18wy2k7cy3hf6ab288ymy3ddayc4a927k6";
+      version = "0.10.10";
+      sha256 = "1cddmj2y5h2hqjgmk14c698g8hhq0x2rycdl5vgz8vvzzsg83zq8";
       libraryHaskellDepends = [
         base
         mtl
···
         mtl
         QuickCheck
         stm
+        tasty
+        tasty-hunit
+        tasty-quickcheck
         template-haskell
-        test-framework
-        test-framework-hunit
-        test-framework-quickcheck2
         transformers
       ];
       description = "Extensible optionally-pure exceptions";
···
     }:
     mkDerivation {
       pname = "exotic-list-monads";
-      version = "1.1.1";
-      sha256 = "063nmcqp9swzmhbdbdvl63kll1mqw3gywwrzx64s5hdk893rzkrf";
+      version = "1.2.0";
+      sha256 = "1wxdhh869v69schj88xz9anzmj4qly3wrh8jmkwga6h5krhvqkgh";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [
         base
···
       testToolDepends = [ hspec-discover ];
       description = "Non-standard monads on lists and non-empty lists";
       license = lib.licenses.mit;
+      hydraPlatforms = lib.platforms.none;
+      broken = true;
     }
   ) { };
 
···
     }:
     mkDerivation {
       pname = "extended-reals";
-      version = "0.2.6.0";
-      sha256 = "0cy5fb6b9kidxqadpymy0pqvswlsqxwxqqhfx9di1l66ynks2b6z";
+      version = "0.2.7.0";
+      sha256 = "0q9k3fl8n30mlsv1c459470bjd4bqyg0vqycjc76qkzxwljl6pwk";
+      revision = "1";
+      editedCabalFile = "1w69ym1cpsdxh7344j6j0kabrdazfx7n9yzqgxcjplsd92gwr97k";
       libraryHaskellDepends = [
         base
         deepseq
···
     }:
     mkDerivation {
       pname = "fast-logger";
-      version = "3.2.5";
-      sha256 = "0cddv18k0n1hdbjf0szqq7pl5r0h4srzxy8pmr66a4pc1w410lii";
+      version = "3.2.6";
+      sha256 = "1hy5cczg64q6cafahfcfjsij48w80zskgjnn3ks0w5w4vqiccrmx";
       libraryHaskellDepends = [
         array
         auto-update
···
     }:
     mkDerivation {
       pname = "fbrnch";
-      version = "1.6.2";
-      sha256 = "0yqpxma3qgdkacbabaffz0498phl79yvn2pbhn10gb6f18lzxcsf";
+      version = "1.7.1";
+      sha256 = "1xsq70xpd0qgz0krlmm31b821ir94sc8qa0qpshjlcfja882p11l";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
···
     }
   ) { };
 
+  "fedora-releases_0_3_0" = callPackage (
+    {
+      mkDerivation,
+      aeson,
+      base,
+      bodhi,
+      cached-json-file,
+      extra,
+      safe,
+    }:
+    mkDerivation {
+      pname = "fedora-releases";
+      version = "0.3.0";
+      sha256 = "1lipp022kxj72i9d25f8if4dppa706zvb1a62lx3gw1xw1p55j8b";
+      libraryHaskellDepends = [
+        aeson
+        base
+        bodhi
+        cached-json-file
+        extra
+        safe
+      ];
+      description = "Library for Fedora release versions";
+      license = lib.licenses.gpl3Only;
+      hydraPlatforms = lib.platforms.none;
+    }
+  ) { };
+
   "fedora-repoquery" = callPackage (
     {
       mkDerivation,
···
     }:
     mkDerivation {
       pname = "fedora-repoquery";
-      version = "0.7.2";
-      sha256 = "0glmc6fqcw7r400nczlnalbdp98ddvvywrxng9jz5y7bindy1vh7";
+      version = "0.7.3";
+      sha256 = "1sdyvbvrh1z32y8hsbfwzyrffl57niri0rgpp580syh11l621sj1";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
···
       pname = "filepath";
       version = "1.5.4.0";
       sha256 = "1bswvf1hrsslb8xlwvsccz12h5habrdpqq4zgcyjg4zm6b28dajl";
+      revision = "1";
+      editedCabalFile = "0b7hmqygr29ppazwbmrrl60bshpqg7zhvzq5g4wl3pgj19iw55ql";
       libraryHaskellDepends = [
         base
         bytestring
···
       pname = "filestore";
       version = "0.6.5";
       sha256 = "0z29273vdqjsrj4vby0gp7d12wg9nkzq9zgqg18db0p5948jw1dh";
-      revision = "2";
-      editedCabalFile = "1m6qi647v475gcim8nfb6cgahhc99rszc8k1z2mpzm797qxg9xbs";
+      revision = "3";
+      editedCabalFile = "003vfb6j47vihjba1py9ls9l269gkg89rf732gb5lwdximxg7wf0";
       libraryHaskellDepends = [
         base
         bytestring
···
     }:
     mkDerivation {
       pname = "finite";
-      version = "1.4.1.2";
-      sha256 = "10hnqz4klgrpfbvla07h8yghpv22bsyijf0cibfzwl9j779vb4nc";
+      version = "1.5.0.0";
+      sha256 = "02fw2m1qn4rpz25jnd9vb16417srpzwz0lhzin04dwc6gjq74i8g";
       libraryHaskellDepends = [
         array
         base
···
       QuickCheck,
       quickcheck-instances,
       tagged,
+      tasty,
       tasty-bench,
-      test-framework,
-      test-framework-quickcheck2,
+      tasty-quickcheck,
       transformers,
     }:
     mkDerivation {
       pname = "foldable1-classes-compat";
-      version = "0.1.1";
-      sha256 = "17xmc3525crnd86rrl2c50rfnhibwh5xbqrnmvzvyns4d3l4vvdg";
-      revision = "2";
-      editedCabalFile = "0m1cd2g2f2983nb9h4d3amq058k2yri6hbh5v026y5lxhg9fq0i8";
+      version = "0.1.2";
+      sha256 = "1n6a8ga07gdwnhy485qzy23algcmnzppfcxfy8c6qipamn4hw5p3";
       libraryHaskellDepends = [
         base
         ghc-prim
···
         containers
         QuickCheck
         quickcheck-instances
-        test-framework
-        test-framework-quickcheck2
+        tasty
+        tasty-quickcheck
         transformers
       ];
       benchmarkHaskellDepends = [
···
     }:
     mkDerivation {
       pname = "fortran-src";
-      version = "0.16.5";
-      sha256 = "1adqczpb1d2zclgvg03z3izcmmncgxj7bff9zz5p8zc77v8865m4";
+      version = "0.16.7";
+      sha256 = "12d46b232aks34nvb3jc66dhz0nxq3z8ngbs6rfn71paj2mfj5cv";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
     }:
     mkDerivation {
       pname = "freckle-app";
-      version = "1.23.1.0";
-      sha256 = "0ik1ay4vm0qw5jg1zvbdfl1p0gxawlrah9lphg9y2cqq48yj4zql";
+      version = "1.23.3.0";
+      sha256 = "0405dj2isvhgib85km2fppq32aan5sghsny2ilwv39pr2g6kkwkm";
       libraryHaskellDepends = [
         aeson
         annotated-exception
···
     }:
     mkDerivation {
       pname = "freckle-http";
-      version = "0.1.0.0";
-      sha256 = "1a8isx1z9injzmbcfj19i4m8cccbl754chx8ayxww76ahd1s6v81";
+      version = "0.2.0.0";
+      sha256 = "0an1bqpsslr8zlpmvvp5hjw5fwpwqjr6w0m4ib7sa1d0218xzdnz";
       libraryHaskellDepends = [
         aeson
         annotated-exception
···
       pname = "free-vector-spaces";
       version = "0.1.5.2";
       sha256 = "0p0flpai3n9ism9dd3kyf1fa8s8rpb4cc00m3bplb9s8zb6aghpb";
-      revision = "2";
-      editedCabalFile = "1jlaljmfhsb4yb8iqmw1zaa3kkiayg6li6bk04a3camh2jc8k22m";
+      revision = "3";
+      editedCabalFile = "1nhbj4ch0fayqbd90qzwhlda929rny81422grdqifghqrr1lq4lv";
       libraryHaskellDepends = [
         base
         lens
···
     }:
     mkDerivation {
       pname = "fs-api";
-      version = "0.3.0.1";
-      sha256 = "0yjfldwmxqg4fgcymyb9bb9axwsfsnldnxxfmk54spkmiab8kr49";
-      revision = "1";
-      editedCabalFile = "17z9clqfs0hm8jl2hdgk0jqvjdxm8i4lk0av489nhsj2qp6ikvmy";
+      version = "0.4.0.0";
+      sha256 = "1aw9x4cgflm2fy5ps3cgpwfzgfp7r7r9fps2vkzbqz03gjpql0dm";
       libraryHaskellDepends = [
         base
         bytestring
···
       ];
       description = "Abstract interface for the file system";
       license = lib.licenses.asl20;
-      hydraPlatforms = lib.platforms.none;
-      broken = true;
     }
   ) { };
 
···
       bifunctors,
       bytestring,
       containers,
+      deepseq,
       fs-api,
       generics-sop,
       io-classes,
···
     }:
     mkDerivation {
       pname = "fs-sim";
-      version = "0.3.1.0";
-      sha256 = "0qq7fc9b37haz2dcywyxhkszy58i3fr7z8nyrrp16x46v5cs6jwq";
-      revision = "1";
-      editedCabalFile = "1pbpi5hngw723z2nr9zwp9rzfxh1p1q8jk8ln01brm7xf3kkq2pb";
+      version = "0.4.0.0";
+      sha256 = "0wirx3mk2dmjw13adbf4d9qpgx7b9kk0y5my7s3yx1lsm2z9m4pw";
       libraryHaskellDepends = [
         base
         base16-bytestring
···
         bifunctors
         bytestring
         containers
+        deepseq
         fs-api
         generics-sop
         io-classes
···
       ];
       description = "Simulated file systems";
       license = lib.licenses.asl20;
-      hydraPlatforms = lib.platforms.none;
     }
   ) { };
 
···
     }:
     mkDerivation {
       pname = "functor-combinators";
-      version = "0.4.1.3";
-      sha256 = "0123y4n01rga8kb86w74hzjwvz8jfr15c1abkrrngacp60bd25rl";
+      version = "0.4.1.4";
+      sha256 = "1yqfbnwv649viy1qpzvk8f9xip0id1k7q6m0j2ssiapfpig43xys";
       libraryHaskellDepends = [
         assoc
         base
···
       ];
       description = "Tools for functor combinator-based program design";
       license = lib.licenses.bsd3;
-      hydraPlatforms = lib.platforms.none;
-      broken = true;
     }
   ) { };
 
···
     }:
     mkDerivation {
       pname = "fxpak";
-      version = "0.1.2";
-      sha256 = "1mrpbz32aczrh5aw550p1vzvj8zqhcnmj574sc012r3z1c0g1cin";
+      version = "0.1.3";
+      sha256 = "1fn88wzhazx9jwddjxq4l4q1xr9g9yl5dsbc9slizb8mnkrkacd9";
       libraryHaskellDepends = [
         base
         bytestring
···
       ];
       description = "Interface to the FXPak/FXPak Pro USB interface";
       license = lib.licenses.bsd3;
-      hydraPlatforms = lib.platforms.none;
-      broken = true;
     }
   ) { };
 
···
       pname = "generic-aeson";
       version = "0.2.0.14";
       sha256 = "0ssras2db9fqgyfhhw2pk827xf4dd4g9s9vwj8g85vaqxyvzyd8x";
+      revision = "1";
+      editedCabalFile = "047mgqq08f1zmnw9400b246bjgpg1r5barz53kbqhfqiaq7ybz85";
       libraryHaskellDepends = [
         aeson
         attoparsec
···
       ];
       description = "Derivation of Aeson instances using GHC generics";
       license = lib.licenses.bsd3;
-      hydraPlatforms = lib.platforms.none;
-      broken = true;
     }
   ) { };
 
···
     { mkDerivation, base }:
     mkDerivation {
       pname = "generic-enumeration";
-      version = "0.1.0.3";
-      sha256 = "02ywn0byg4g42hl28mqc07jifj48jxzmnjm4plfdz4pnxs40kwzg";
+      version = "0.1.0.4";
+      sha256 = "0f83fnvmmi4yvdn9i2r1vkpk6cy4lqpxgjv26f380akyf30av90p";
       libraryHaskellDepends = [ base ];
       description = "Generically derived enumerations";
       license = lib.licenses.mit;
···
       pname = "generic-lens-lite";
       version = "0.1.1";
       sha256 = "1ldc13g7l5jjgca80c2hymkbgq9pf8b5j4x3dr83kz6wq2p76q12";
+      revision = "1";
+      editedCabalFile = "1wg3qxik9mgd49jkrgzargpncj6d1pg1zy13xg9yck5w4i10rixw";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base ];
       description = "Monomorphic field lens like with generic-lens";
···
     { mkDerivation, base }:
     mkDerivation {
       pname = "generic-lexicographic-order";
-      version = "0.1.0.0";
-      sha256 = "096c1fan7isxynyk968llm3p204kgcmh8xp4krnmspz0xvcn7sh0";
+      version = "0.1.0.1";
+      sha256 = "01vylkficx9ylri9200pvqgqc89lm9x4iy3s4bfal96pv8q59knx";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base ];
       description = "Derive Bounded and Enum for sum types and Enum for product types";
···
       pname = "generic-optics-lite";
       version = "0.1.1";
       sha256 = "1dd2dw72fyyimnyq8bw57k7lbh0lnjipvk08dyj87h357ykjv3ql";
+      revision = "1";
+      editedCabalFile = "1z3bf20fj03bfp4zigdxzw4v30hmxgwkdzdmgbn4hibpcz2j24p0";
       libraryHaskellDepends = [
         base
         generic-lens-lite
···
       ];
       description = "GenValidity support for URI";
       license = lib.licenses.mit;
-      hydraPlatforms = lib.platforms.none;
-      broken = true;
     }
   ) { };
 
···
     }
   ) { };
 
-  "ghc_9_12_1" =
+  "ghc_9_12_2" =
     callPackage
       (
         {
···
         }:
         mkDerivation {
           pname = "ghc";
-          version = "9.12.1";
-          sha256 = "179gp0lqrxhvzc0pyxwmkvxpilm6c201s1pjws3dl8qqyddliiqs";
+          version = "9.12.2";
+          sha256 = "0l5rrnfv933m37dziqaf5iv4nqirig1mfaj037by94s486ggx5f7";
           setupHaskellDepends = [
             base
             Cabal
···
     }:
     mkDerivation {
       pname = "ghc-debugger";
-      version = "0.2.0.0";
-      sha256 = "0k02y36kz9412i0fk9vvdidcyc5qh0cq47jbgk78i8c7276dm4j3";
+      version = "0.4.0.0";
+      sha256 = "0nzmlnhv5liwkibva0djvc06c0d2wwpqa9x4lvpb2snkid0yliyl";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
         binary
         bytestring
         containers
+        directory
         exceptions
         filepath
         ghc
         ghci
+        hie-bios
         mtl
         process
         unix
···
     }
   ) { };
 
+  "ghc-hie" = callPackage (
+    {
+      mkDerivation,
+      array,
+      base,
+      bytestring,
+      containers,
+      deepseq,
+      directory,
+      filepath,
+      ghc,
+      ghc-boot,
+      hspec,
+      hspec-discover,
+      process,
+      QuickCheck,
+      temporary,
+      transformers,
+    }:
+    mkDerivation {
+      pname = "ghc-hie";
+      version = "0.0.2";
+      sha256 = "1z51fbm0n9knqrp01gqd7xx0pkfwyr9kgaginvqmdw45gi8rqhm7";
+      libraryHaskellDepends = [
+        array
+        base
+        bytestring
+        containers
+        deepseq
+        directory
+        filepath
+        ghc
+        ghc-boot
+        transformers
+      ];
+      testHaskellDepends = [
+        array
+        base
+        bytestring
+        containers
+        deepseq
+        directory
+        filepath
+        ghc
+        ghc-boot
+        hspec
+        process
+        QuickCheck
+        temporary
+        transformers
+      ];
+      testToolDepends = [ hspec-discover ];
+      description = "HIE-file parsing machinery that supports multiple versions of GHC";
+      license = lib.licenses.mit;
+    }
+  ) { };
+
   "ghc-hotswap" = callPackage (
     {
       mkDerivation,
···
     }:
     mkDerivation {
       pname = "ghc-prof";
-      version = "1.4.1.13";
-      sha256 = "0g85216s10pm515wi0dl95znq3vdac3zvagizg8vy82zfmsgxwcp";
+      version = "1.4.1.14";
+      sha256 = "16zl8x8abkh2fbyzsd6k48vm2na0bbm0cv2b9sfi3jac7mi3v3kq";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
       base,
       containers,
       ghc,
+      template-haskell,
       transformers,
     }:
     mkDerivation {
       pname = "ghc-tcplugin-api";
-      version = "0.14.0.0";
-      sha256 = "089lw1gjxrk54s1agl5gxkwg49368z6i6m260snz05nfia4m7fak";
+      version = "0.15.0.0";
+      sha256 = "024gwhs575rirrizlriigxvz0b9az2c63vbbdfm3dd4qa5ln3jmq";
       libraryHaskellDepends = [
         base
         containers
         ghc
+        template-haskell
         transformers
       ];
       description = "An API for type-checker plugins";
···
     }
   ) { };
 
+  "ghci4luatex" = callPackage (
+    {
+      mkDerivation,
+      aeson,
+      base,
+      bytestring,
+      cmdargs,
+      containers,
+      hspec,
+      network-simple,
+      process,
+      QuickCheck,
+      stm,
+      text,
+    }:
+    mkDerivation {
+      pname = "ghci4luatex";
+      version = "0.1";
+      sha256 = "1x3kdwxcallnyvssbxaj4scf6rc0f5yx3js1bzzwmi9p3imxj4x8";
+      isLibrary = true;
+      isExecutable = true;
+      libraryHaskellDepends = [
+        aeson
+        base
+        bytestring
+        cmdargs
+        containers
+        network-simple
+        process
+        stm
+        text
+      ];
+      executableHaskellDepends = [
+        aeson
+        base
+        bytestring
+        cmdargs
+        containers
+        network-simple
+        process
+        stm
+        text
+      ];
+      testHaskellDepends = [
+        aeson
+        base
+        bytestring
+        cmdargs
+        containers
+        hspec
+        network-simple
+        process
+        QuickCheck
+        stm
+        text
+      ];
+      description = "A GHCi session in LaTeX";
+      license = lib.licenses.bsd3;
+      mainProgram = "ghci4luatex";
+    }
+  ) { };
+
   "ghcid" = callPackage (
     {
       mkDerivation,
···
     }:
     mkDerivation {
       pname = "ghcitui";
-      version = "0.4.1.0";
-      sha256 = "05c9s43qhzxc280xycicwrm95kl1jpz14pzlcnv0a29i8589gpdz";
+      version = "0.4.1.1";
+      sha256 = "1s7imyvv7pg3yyrajgl5fqv1q35188ianm8y689mzb5ikbwr5wq4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
     { mkDerivation }:
     mkDerivation {
       pname = "ghcjs-base";
-      version = "0.8.0.3";
-      sha256 = "1cff0sgcwdas30dgxg9mdab5rk0s1v2qkkb9cr47dl3d5wmc4add";
+      version = "0.8.0.4";
+      sha256 = "081w3234jramsmafnl86v37lwbckr2vc93gr9pdwc31yzni9kbml";
       description = "base library for GHCJS";
       license = lib.licenses.mit;
       platforms = [ "javascript-ghcjs" ];
···
       pname = "ghostscript-parallel";
       version = "0.0.1";
       sha256 = "1sja6nhp8p9h2z0yr5qwxd8d59zzpb11ybmsbargza6ddaplpxny";
+      revision = "1";
+      editedCabalFile = "1sd1rh0fm29c3h4vm42fv6vbqplcm32ilqzimdp7vxfp3mhbblpr";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
···
     }:
     mkDerivation {
       pname = "gi-gio";
-      version = "2.0.37";
-      sha256 = "0a3z1aj1fqnpwxcf27anjcp2wpg3mbn86xybk150260bb00jzxpb";
-      setupHaskellDepends = [
-        base
-        Cabal
-        gi-glib
-        gi-gobject
-        haskell-gi
-      ];
-      libraryHaskellDepends = [
-        base
-        bytestring
-        containers
-        gi-glib
-        gi-gobject
-        haskell-gi
-        haskell-gi-base
-        haskell-gi-overloading
-        text
-        transformers
-      ];
-      libraryPkgconfigDepends = [ glib ];
-      description = "Gio bindings";
-      license = lib.licenses.lgpl21Only;
-    }
-  ) { inherit (pkgs) glib; };
-
-  "gi-gio_2_0_38" = callPackage (
-    {
-      mkDerivation,
-      base,
-      bytestring,
-      Cabal,
-      containers,
-      gi-glib,
-      gi-gobject,
-      glib,
-      haskell-gi,
-      haskell-gi-base,
-      haskell-gi-overloading,
-      text,
-      transformers,
-    }:
-    mkDerivation {
-      pname = "gi-gio";
       version = "2.0.38";
       sha256 = "12bmpafy5w85y7mzww0l5ilimbdmaabpxz7ry9sacg37kjm3kidf";
       setupHaskellDepends = [
···
       libraryPkgconfigDepends = [ glib ];
       description = "Gio bindings";
       license = lib.licenses.lgpl21Only;
-      hydraPlatforms = lib.platforms.none;
     }
   ) { inherit (pkgs) glib; };
 
···
     }
   ) { inherit (pkgs) gtk4; };
 
+  "gi-gtk4-layer-shell" = callPackage (
+    {
+      mkDerivation,
+      base,
+      bytestring,
+      Cabal,
+      containers,
+      gi-gdk4,
+      gi-gtk4,
+      gtk4-layer-shell,
+      haskell-gi,
+      haskell-gi-base,
+      haskell-gi-overloading,
+      text,
+      transformers,
+    }:
+    mkDerivation {
+      pname = "gi-gtk4-layer-shell";
+      version = "0.1.0";
+      sha256 = "0x1bafara3nq2f76lmmzvkm51i16za0fymh0zpvqx4mvac8lhpzz";
+      setupHaskellDepends = [
+        base
+        Cabal
+        gi-gdk4
+        gi-gtk4
+        haskell-gi
+      ];
+      libraryHaskellDepends = [
+        base
+        bytestring
+        containers
+        gi-gdk4
+        gi-gtk4
+        haskell-gi
+        haskell-gi-base
+        haskell-gi-overloading
+        text
+        transformers
+      ];
+      libraryPkgconfigDepends = [ gtk4-layer-shell ];
+      description = "gtk4-layer-shell bindings";
+      license = lib.licenses.lgpl21Only;
+      hydraPlatforms = lib.platforms.none;
+      broken = true;
+    }
+  ) { inherit (pkgs) gtk4-layer-shell; };
+
   "gi-gtkosxapplication" = callPackage (
     {
       mkDerivation,
···
     }:
     mkDerivation {
       pname = "gi-webkit";
-      version = "6.0.4";
-      sha256 = "0cabpym4p654psrck548wpkdf43wbm8zn0r2lrqiijx72f6xwij5";
+      version = "6.0.5";
+      sha256 = "1a7nmzry1h24i35imhp2d9x32bn32fwswpvrp72lk8yyb12v7i5g";
       setupHaskellDepends = [
         base
         Cabal
···
       pname = "ginger";
       version = "0.10.6.0";
       sha256 = "0j5arz8x2ksbcwy5iq8p7pzy71rl0nhadlv2d6933ibdgvzbsb7j";
+      revision = "1";
+      editedCabalFile = "1226x5dlcpaczy3kx5h27fmq4g03h4aa1nc1aw9r7x18h8rjay04";
       isLibrary = true;
       isExecutable = true;
       enableSeparateDataOutput = true;
···
     }
   ) { };
 
+  "ginger2" = callPackage (
+    {
+      mkDerivation,
+      aeson,
+      array,
+      base,
+      base64-bytestring,
+      bytestring,
+      cmark,
+      containers,
+      directory,
+      filepath,
+      megaparsec,
+      mtl,
+      optparse-applicative,
+      quickcheck-instances,
+      random,
+      regex-tdfa,
+      scientific,
+      SHA,
+      tasty,
+      tasty-hunit,
+      tasty-quickcheck,
+      template-haskell,
+      text,
+      time,
+      vector,
+      yaml,
+    }:
+    mkDerivation {
+      pname = "ginger2";
+      version = "2.2.0.0";
+      sha256 = "0a8aa944v7b8qlwqykkrvm334ic8c8lfb8zwls7wx1cyh68kif66";
+      isLibrary = true;
+      isExecutable = true;
+      libraryHaskellDepends = [
+        aeson
+        array
+        base
+        base64-bytestring
+        bytestring
+        containers
+        filepath
+        megaparsec
+        mtl
+        random
+        regex-tdfa
+        scientific
+        SHA
+        tasty
+        tasty-quickcheck
+        template-haskell
+        text
+        time
+        vector
+      ];
+      executableHaskellDepends = [
+        aeson
+        base
+        cmark
+        containers
+        directory
+        filepath
+        optparse-applicative
+        random
+        text
+        vector
+        yaml
+      ];
+      testHaskellDepends = [
+        base
+        base64-bytestring
+        bytestring
+        containers
+        megaparsec
+        mtl
+        quickcheck-instances
+        random
+        tasty
+        tasty-hunit
+        tasty-quickcheck
+        text
+        vector
+      ];
+      description = "Jinja templates for Haskell";
+      license = lib.licenses.mit;
+      hydraPlatforms = lib.platforms.none;
+      mainProgram = "ginger2";
+      broken = true;
+    }
+  ) { };
+
   "gingersnap" = callPackage (
     {
       mkDerivation,
···
     }:
     mkDerivation {
       pname = "git-annex";
-      version = "10.20250520";
-      sha256 = "15qb4pm3chhb5x0halx5qd4s1rcbci1q22sskm0mw4xjn2yfhc99";
+      version = "10.20250630";
+      sha256 = "1varfir2vmnr29kfsjpqc5vd6msansch6xiag1d0s4bj5wpn1pq3";
       configureFlags = [
         "-fassistant"
         "-f-benchmark"
···
     }
   ) { };
 
+  "github-actions" = callPackage (
+    {
+      mkDerivation,
+      aeson,
+      base,
+      bytestring,
+      containers,
+      filepath,
+      hedgehog,
+      hoist-error,
+      pretty-show,
+      string-interpolate,
+      tasty,
+      tasty-discover,
+      tasty-golden,
+      tasty-golden-extra,
+      tasty-hedgehog,
+      tasty-hunit,
+      text,
+      vector,
+      yaml,
+    }:
+    mkDerivation {
+      pname = "github-actions";
+      version = "0.1.0.0";
+      sha256 = "0aa4j8cbij6ags49pmdlfjgwfhj4w1960cjijfhncjm1dr5gij1z";
+      revision = "1";
+      editedCabalFile = "13n5nxpqgak96fqyywp1kx0yvzp7m2r19fn84z0khb5bq5nglv01";
+      libraryHaskellDepends = [
+        aeson
+        base
+        containers
+        hedgehog
+        hoist-error
+        string-interpolate
+        text
+        vector
+      ];
+      testHaskellDepends = [
+        aeson
+        base
+        bytestring
+        containers
+        filepath
+        hedgehog
+        hoist-error
+        pretty-show
+        string-interpolate
+        tasty
+        tasty-discover
+        tasty-golden
+        tasty-golden-extra
+        tasty-hedgehog
+        tasty-hunit
+        text
+        vector
+        yaml
+      ];
+      testToolDepends = [ tasty-discover ];
+      description = "Github Actions";
+      license = lib.licenses.bsd3;
+    }
+  ) { };
+
   "github-app-token" = callPackage (
     {
       mkDerivation,
···
     }:
     mkDerivation {
       pname = "gothic";
-      version = "0.1.8.2";
-      sha256 = "1mqkkla4ipibp7y7aiy466qrqcapra4n2xx8an07c1inwkpsxzw1";
+      version = "0.1.8.3";
+      sha256 = "0lf0yhq4q2vcw9b69l7ixdscmz5drxiag9l31iz1ypb8cyjspi1q";
       libraryHaskellDepends = [
         aeson
         base
···
     }:
     mkDerivation {
       pname = "gpu-vulkan-middle";
-      version = "0.1.0.75";
-      sha256 = "1m22f7p78pwpipkvlsg95izivhz4z2cxiww4l4qy329s1cyyy0w6";
+      version = "0.1.0.76";
+      sha256 = "188g8i3zszb3xm5cl57bvhmwwrg1adx679h4j52z1a1qzyiia02m";
       enableSeparateDataOutput = true;
       libraryHaskellDepends = [
         base
···
     }:
     mkDerivation {
       pname = "graphql";
-      version = "1.5.0.0";
-      sha256 = "1vgvrk225fgn94cmdk5yy6a6d8p10igwx1fbvll94x4izkq57h9y";
+      version = "1.5.0.1";
+      sha256 = "0kx0pnf16zwdjxc1ig46mbv7px7r7v6xn6kmlypl0d73ik8jfzrq";
       libraryHaskellDepends = [
         base
         conduit
···
       pname = "graphql-client";
       version = "1.2.4";
       sha256 = "0rm7x5hrjz7fqfixpaab2c8fmwpn6m3p14zr0wq2bll8qf0hj15c";
+      revision = "1";
+      editedCabalFile = "0fi7q2zxfm85pdpn9b4jzh49rnakm5dvcmjkr0g39738zprgwaph";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
     }:
     mkDerivation {
       pname = "graphula";
-      version = "2.1.0.1";
-      sha256 = "1bc8nr6m9lahbfg5h1i9y25kv5ikr7dcqs4ga4hzii07zvq6ks84";
+      version = "2.1.2.0";
+      sha256 = "11w4sp6jpygpqd0xjnhwdrj5gizz4nrn01md2hc98fxm19a0la03";
       libraryHaskellDepends = [
         base
         containers
···
     }:
     mkDerivation {
       pname = "greskell-core";
-      version = "1.0.0.4";
-      sha256 = "0cvqrbpfa0flsvjvmdg6pf1m0dd1gxgk22n8wqbnvwak8c528hff";
+      version = "1.0.0.6";
+      sha256 = "14xsjs4xf3db8ppz4xypshzvyvxsn7s7syr8vqkrbll8vz9laab8";
       libraryHaskellDepends = [
         aeson
         base
···
     }
   ) { };
 
-  "grisette_0_12_0_0" = callPackage (
+  "grisette_0_13_0_0" = callPackage (
     {
       mkDerivation,
       array,
···
     }:
     mkDerivation {
       pname = "grisette";
-      version = "0.12.0.0";
-      sha256 = "0dcwbc53321jg6jfmsr72kmsx8w7c6x9aq4yllwfvbzh092ljlib";
+      version = "0.13.0.0";
+      sha256 = "0115al5kw0vfsp11cndra6qrjiakm2w0gpi8ai4g47fysn8xbx6p";
       libraryHaskellDepends = [
         array
         async
···
     }:
     mkDerivation {
       pname = "hackage-cli";
-      version = "0.1.0.2";
-      sha256 = "1q7k8fy6mqb7h4q4bm8qp0ma2nhspszkwy8d606hb66sdiw7k73k";
+      version = "0.1.0.3";
+      sha256 = "19mnvvhhcagq1l3qc37qxxv7pwzfw6p15194f21z7harj5y1ly5c";
       isLibrary = false;
       isExecutable = true;
       libraryHaskellDepends = [
···
       pname = "hackage-repo-tool";
       version = "0.1.1.4";
       sha256 = "1nqm6rri8rkhrqvppyzy04s3875c4wjcay8gny4ygbr65c6iw81v";
-      revision = "1";
-      editedCabalFile = "09fx1z32m36riv3hmjrv36knlmmrrjq2hbl30i2qfk7pfcbcjlgw";
+      revision = "2";
+      editedCabalFile = "0ghjpd02ccv6xdp0n6mxylq09ff5w7yzvpw3v3w4i62l43fi9j7q";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
···
       pname = "hackage-revdeps";
       version = "0.1.1";
       sha256 = "0ckkcp2ndzv219hpl42vfzw0hvb5vblsx2bvdsa98wikkxnmn47j";
+      revision = "1";
+      editedCabalFile = "078lhc7lzs24qqizplyf4ipggxkqqsfmgq6vnrgbyhxiia2smc4b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
     }:
     mkDerivation {
       pname = "hackage-security";
-      version = "0.6.3.0";
-      sha256 = "0w0d94gbqpi8b3ddkb32px8xj0qxaaxwdbl8x45y55331b23a7a0";
+      version = "0.6.3.1";
+      sha256 = "05sckvvwj10krkhp1457mgp1hgq45p7r2sp850g3b5689i91mvqx";
+      revision = "1";
+      editedCabalFile = "1si6mkc8gimkpqkdl2wyzxp14v7yphp40hxvp77im7bhr8brsa77";
       libraryHaskellDepends = [
         base
         base16-bytestring
···
       aeson,
       attoparsec,
       base,
+      bytestring,
       data-default,
       doctest,
       filepath,
···
     }:
     mkDerivation {
       pname = "haiji";
-      version = "0.3.4.0";
-      sha256 = "1m97lnd993xpxcbm3n2qgqzqjb5j3jvkzkdcb1h9qjd3lr88j1cf";
+      version = "0.4.0.0";
+      sha256 = "1r6bzh95a4qg0waday49qqrm1kmss667hksp0wcl749w5g32jnaq";
       libraryHaskellDepends = [
         aeson
         attoparsec
···
       testHaskellDepends = [
         aeson
         base
+        bytestring
         data-default
         doctest
         filepath
···
       pname = "hakyll";
       version = "4.16.6.0";
       sha256 = "1933k6aiawa0kdws7ajm9picjchnfrkkd0qd8xb9l2yv1fvcywg2";
-      revision = "1";
-      editedCabalFile = "0w6z4dq378aai39n9samlfahqr5s1p0fz1xl6kgfp9z8bvq9daa7";
+      revision = "3";
+      editedCabalFile = "0q2yl6vqf6qqc7azqwsls7b2pm3y42shhdcpyszrpi16zgx9y137";
       isLibrary = true;
       isExecutable = true;
       enableSeparateDataOutput = true;
···
       bytestring,
       deepseq,
       QuickCheck,
+      tasty,
+      tasty-quickcheck,
       template-haskell,
-      test-framework,
-      test-framework-quickcheck2,
     }:
     mkDerivation {
       pname = "half";
-      version = "0.3.2";
-      sha256 = "0f7hgnfy8qpjsjv78gk01di3riwfbrb961msn19qmsplnsgjx68r";
+      version = "0.3.3";
+      sha256 = "00mb2xfz0q8sq8zxqpw3ycp1p8gjhlgc0wxh5xr7kzyn52b08xpl";
       libraryHaskellDepends = [
         base
         binary
···
         binary
         bytestring
         QuickCheck
-        test-framework
-        test-framework-quickcheck2
+        tasty
+        tasty-quickcheck
       ];
       description = "Half-precision floating-point";
       license = lib.licenses.bsd3;
···
     }
   ) { };
 
+  "harpie_0_1_3_0" = callPackage (
+    {
+      mkDerivation,
+      adjunctions,
+      base,
+      distributive,
+      doctest-parallel,
+      first-class-families,
+      prettyprinter,
+      QuickCheck,
+      quickcheck-instances,
+      random,
+      vector,
+      vector-algorithms,
+    }:
+    mkDerivation {
+      pname = "harpie";
+      version = "0.1.3.0";
+      sha256 = "1agkp62rcgk705hp8hlppfiidv5vsz0ps6pq3pvlnn1g73vv5ivr";
+      isLibrary = true;
+      isExecutable = true;
+      libraryHaskellDepends = [
+        adjunctions
+        base
+        distributive
+        first-class-families
+        prettyprinter
+        QuickCheck
+        quickcheck-instances
+        random
+        vector
+        vector-algorithms
+      ];
+      executableHaskellDepends = [
+        adjunctions
+        base
+        first-class-families
+      ];
+      testHaskellDepends = [
+        base
+        doctest-parallel
+      ];
+      description = "Haskell array programming";
+      license = lib.licenses.bsd3;
+      hydraPlatforms = lib.platforms.none;
+      mainProgram = "harpie-bug-issue1";
+    }
+  ) { };
+
   "harpie-numhask" = callPackage (
     {
       mkDerivation,
···
     }:
     mkDerivation {
       pname = "hash-string";
-      version = "0.1.0.1";
-      sha256 = "136a5pkygam99fx52r1dhrxydkzk1v83n0ip5iaczdx99cwki0gb";
+      version = "0.1.0.2";
+      sha256 = "0ri03id2jwpsn77mnnvvicx6niy5q5q7mr38r6y64am4j6yfh2q3";
       libraryHaskellDepends = [
         base
         bytestring
···
     }
   ) { };
 
+  "haskell-bee" = callPackage (
+    {
+      mkDerivation,
+      aeson,
+      base,
+      safe-exceptions,
+      stm,
+      tasty,
+      tasty-quickcheck,
+      text,
+      unbounded-delays,
+    }:
+    mkDerivation {
+      pname = "haskell-bee";
+      version = "0.1.0.0";
+      sha256 = "1wsdwfqswvq9vbsk8vpdx58bqrznqix2p8d527fwvksvg9rpq5r0";
+      libraryHaskellDepends = [
+        aeson
+        base
+        safe-exceptions
+        stm
+        text
+        unbounded-delays
+      ];
+      testHaskellDepends = [
+        aeson
+        base
+        tasty
+        tasty-quickcheck
+      ];
+      description = "A lightweight library for asynchronous job workers with multiple broker backends";
+      license = lib.licenses.agpl3Plus;
+    }
+  ) { };
+
+  "haskell-bee-pgmq" = callPackage (
+    {
+      mkDerivation,
+      aeson,
+      base,
+      bytestring,
+      containers,
+      deepseq,
+      haskell-bee,
+      haskell-bee-tests,
+      haskell-pgmq,
+      hspec,
+      mtl,
+      postgresql-libpq,
+      postgresql-simple,
+      random-strings,
+      safe,
+      safe-exceptions,
+      scientific,
+      tasty,
+      tasty-hspec,
+      text,
+      time,
+      units,
+      unix-time,
+    }:
+    mkDerivation {
+      pname = "haskell-bee-pgmq";
+      version = "0.1.0.0";
+      sha256 = "1cf8mc1ddl1vhh7nyjsla5ccymy3963sz2j9l337pvpm492lxf0a";
+      isLibrary = true;
+      isExecutable = true;
+      libraryHaskellDepends = [
+        aeson
+        base
+        bytestring
+        containers
+        deepseq
+        haskell-bee
+        haskell-pgmq
+        postgresql-libpq
+        postgresql-simple
+        safe
+        safe-exceptions
+        scientific
+        text
+        time
+        units
+        unix-time
+      ];
+      executableHaskellDepends = [
+        aeson
+        base
+        haskell-bee
+        haskell-pgmq
+        mtl
+        postgresql-simple
+        text
+      ];
+      testHaskellDepends = [
+        aeson
+        base
+        containers
+        haskell-bee
+        haskell-bee-tests
+        hspec
+        postgresql-simple
+        random-strings
+        tasty
+        tasty-hspec
+        text
+      ];
+      description = "PostgreSQL/PGMQ broker implementation for haskell-bee";
+      license = lib.licenses.agpl3Plus;
+      mainProgram = "simple-worker";
+    }
+  ) { };
+
+  "haskell-bee-redis" = callPackage (
+    {
+      mkDerivation,
+      aeson,
+      base,
+      bytestring,
+      containers,
+      deepseq,
+      haskell-bee,
+      haskell-bee-tests,
+      hedis,
+      hspec,
+      random-strings,
+      safe,
+      safe-exceptions,
+      scientific,
+      stm,
+      tasty,
+      tasty-hspec,
+      tasty-hunit,
+      tasty-quickcheck,
+      text,
+      time,
+      units,
+      unix-time,
+    }:
+    mkDerivation {
+      pname = "haskell-bee-redis";
+      version = "0.1.0.0";
+      sha256 = "19qq0gkpqb0ywchsz0z2q5qpvj3f260k1175zkjc49mzwl6q26x4";
+      libraryHaskellDepends = [
+        aeson
+        base
+        bytestring
+        containers
+        deepseq
+        haskell-bee
+        hedis
+        safe
+        safe-exceptions
+        scientific
+        stm
+        text
+        time
+        units
+        unix-time
+      ];
+      testHaskellDepends = [
+        aeson
+        base
+        containers
+        haskell-bee
+        haskell-bee-tests
+        hedis
+        hspec
+        random-strings
+        stm
+        tasty
+        tasty-hspec
+        tasty-hunit
+        tasty-quickcheck
+        text
+        unix-time
+      ];
+      description = "Redis broker implementation for haskell-bee";
+      license = lib.licenses.agpl3Plus;
+    }
+  ) { };
+
+  "haskell-bee-stm" = callPackage (
+    {
+      mkDerivation,
+      aeson,
+      base,
+      bytestring,
+      containers,
+      deepseq,
+      haskell-bee,
+      haskell-bee-tests,
+      hspec,
+      random-strings,
+      safe,
+      safe-exceptions,
+      scientific,
+      stm,
+      tasty,
+      tasty-hspec,
+      tasty-hunit,
+      tasty-quickcheck,
+      text,
+      time,
+      units,
+      unix-time,
+    }:
+    mkDerivation {
+      pname = "haskell-bee-stm";
+      version = "0.1.0.0";
+      sha256 = "1m34642h4nkl03yrvpgrhnprkj09xylg5rfg169gadwk8jm6w0bw";
+      libraryHaskellDepends = [
+        aeson
+        base
+        bytestring
+        containers
+        deepseq
+        haskell-bee
+        safe
+        safe-exceptions
+        scientific
+        stm
+        text
+        time
+        units
+        unix-time
+      ];
+      testHaskellDepends = [
+        aeson
+        base
+        containers
+        haskell-bee
+        haskell-bee-tests
+        hspec
+        random-strings
+        stm
+        tasty
+        tasty-hspec
+        tasty-hunit
+        tasty-quickcheck
+        text
+        unix-time
+      ];
+      description = "STM broker implementation for haskell-bee";
+      license = lib.licenses.agpl3Plus;
+    }
+  ) { };
+
+  "haskell-bee-tests" = callPackage (
+    {
+      mkDerivation,
+      aeson,
+      base,
+      containers,
+      haskell-bee,
+      hedis,
+      hspec,
+      postgresql-simple,
+      random-strings,
+      stm,
+      tasty,
+      tasty-hspec,
+      text,
+    }:
+    mkDerivation {
+      pname = "haskell-bee-tests";
+      version = "0.1.0.0";
+      sha256 = "1bcg8c8fm9yaq4k3v8m79qq6miqjgbmc3xbdnr4mn5z8ayi1s2cr";
+      libraryHaskellDepends = [
+        aeson
+        base
+        containers
+        haskell-bee
+        hedis
+        hspec
+        postgresql-simple
+        random-strings
+        stm
+        tasty
+        tasty-hspec
+        text
+      ];
+      description = "Reusable test suite for any haskell-bee Broker implementation";
+      license = lib.licenses.agpl3Plus;
+    }
+  ) { };
+
   "haskell-bitmex-client" = callPackage (
     {
       mkDerivation,
···
         }:
         mkDerivation {
           pname = "haskell-gi";
-          version = "0.26.15";
-          sha256 = "07lpd31j582czgvrivyh0fp3bbjmhvqicgy47pv2j69x450q2wsa";
+          version = "0.26.16";
+          sha256 = "0v5pjysap2v5a9njc1z9c6by2sv18p9kkqcpzpxwqjs9hh4mxq5q";
           setupHaskellDepends = [
             base
             Cabal
···
         inherit (pkgs) gobject-introspection;
       };
 
+  "haskell-gi_0_26_17" =
+    callPackage
+      (
+        {
+          mkDerivation,
+          ansi-terminal,
+          attoparsec,
+          base,
+          bytestring,
+          Cabal,
+          cabal-doctest,
+          containers,
+          directory,
+          doctest,
+          filepath,
+          glib,
+          gobject-introspection,
+          haskell-gi-base,
+          mtl,
+          pretty-show,
+          process,
+          regex-tdfa,
+          safe,
+          text,
+          transformers,
+          xdg-basedir,
+          xml-conduit,
+        }:
+        mkDerivation {
+          pname = "haskell-gi";
+          version = "0.26.17";
+          sha256 = "0vg75z5qgf0km59gv6dvpzckyxdli3i5d8lk8xck55smaf9h6f6i";
+          setupHaskellDepends = [
+            base
+            Cabal
+            cabal-doctest
+          ];
+          libraryHaskellDepends = [
+            ansi-terminal
+            attoparsec
+            base
+            bytestring
+            Cabal
+            containers
+            directory
+            filepath
+            haskell-gi-base
+            mtl
+            pretty-show
+            process
+            regex-tdfa
+            safe
+            text
+            transformers
+            xdg-basedir
+            xml-conduit
+          ];
+          libraryPkgconfigDepends = [
+            glib
+            gobject-introspection
+          ];
+          testHaskellDepends = [
+            base
+            doctest
+            process
+          ];
+          description = "Generate Haskell bindings for GObject Introspection capable libraries";
+          license = lib.licenses.lgpl21Only;
+          hydraPlatforms = lib.platforms.none;
+        }
+      )
+      {
+        inherit (pkgs) glib;
+        inherit (pkgs) gobject-introspection;
+      };
+
   "haskell-gi-base" = callPackage (
     {
       mkDerivation,
···
       bytestring,
       containers,
       glib,
+      optics-core,
       text,
     }:
     mkDerivation {
       pname = "haskell-gi-base";
-      version = "0.26.8";
-      sha256 = "19sp8yi9inxq7vqw6zpf2rlk56algxajkf8gyl0iqbx95kb4x1bb";
+      version = "0.26.9";
+      sha256 = "1li1q8k5zn7yxqn3rdh5sjkq4lsr9gsbhkvxh6wzca39n37vnnf3";
       libraryHaskellDepends = [
         base
         bytestring
         containers
+        optics-core
         text
       ];
       libraryPkgconfigDepends = [ glib ];
···
       hydraPlatforms = lib.platforms.none;
       mainProgram = "haskell-go-checkers";
       broken = true;
+    }
+  ) { };
+
+  "haskell-google-genai-client" = 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,
+      microlens,
+      monad-logger,
+      mtl,
+      network,
+      QuickCheck,
+      random,
+      safe-exceptions,
+      semigroups,
+      text,
+      time,
+      transformers,
+      unordered-containers,
+      vector,
+    }:
+    mkDerivation {
+      pname = "haskell-google-genai-client";
+      version = "0.1.0";
+      sha256 = "020qnab47jn1ixmwds8w4nbyzd2j1kpg7ykd71lfc71vnr4mh93h";
+      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
+        microlens
+        monad-logger
+        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
+      ];
+      description = "Auto-generated Gemini API Client for Haskell";
+      license = lib.licenses.mit;
     }
   ) { };
 
···
       pname = "haskell-language-server";
       version = "2.11.0.0";
       sha256 = "1acd42sqa76nkrwkb6jcrimbf8va6ikkynv9ssbbamyy4vmx1aa4";
+      revision = "1";
+      editedCabalFile = "06ah5cdcg52azd0jx7n4n7xwrhphjc2k4k8gqda44m1kiv5z2v18";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
     }
   ) { };
 
+  "haskell-pgmq" = callPackage (
+    {
+      mkDerivation,
+      aeson,
+      base,
+      bytestring,
+      containers,
+      hspec,
+      postgresql-simple,
+      random-strings,
+      safe,
+      stm,
+      tasty,
+      tasty-hspec,
+      text,
+      time,
+      units,
+    }:
+    mkDerivation {
+      pname = "haskell-pgmq";
+      version = "0.1.0.0";
+      sha256 = "1kslpx1zah97k9z2k967rwkjm01p9c0vz0if4hhpa52rprcadm7k";
+      isLibrary = true;
+      isExecutable = true;
+      enableSeparateDataOutput = true;
+      libraryHaskellDepends = [
+        aeson
+        base
+        bytestring
+        postgresql-simple
+        safe
+        text
+        time
+        units
+      ];
+      executableHaskellDepends = [
+        base
+        postgresql-simple
+      ];
+      testHaskellDepends = [
+        aeson
+        base
+        containers
+        hspec
+        postgresql-simple
+        random-strings
+        stm
+        tasty
+        tasty-hspec
+        text
+      ];
+      description = "Haskell interface for Tembo's PGMQ PostgreSQL extension";
+      license = lib.licenses.agpl3Plus;
+    }
+  ) { };
+
   "haskell-platform-test" = callPackage (
     {
       mkDerivation,
···
       testToolDepends = [ hspec-discover ];
       description = "Lightweight CLI wallet for Bitcoin and Bitcoin Cash";
       license = lib.licenses.publicDomain;
-      hydraPlatforms = lib.platforms.none;
       mainProgram = "hw";
-      broken = true;
     }
   ) { };
 
···
     }:
     mkDerivation {
       pname = "hasktorch";
-      version = "0.2.1.3";
-      sha256 = "18j3mvbag1anmkc5s8486i1a6am3iljm48aixxf5fi1bg2mkq46k";
+      version = "0.2.1.4";
+      sha256 = "0g5k796s66mz53cabfd0gl099rrjk1pfxc55qfg2j97mn69hgb1q";
       setupHaskellDepends = [
         base
         Cabal
···
     }:
     mkDerivation {
       pname = "hasql-resource-pool";
-      version = "1.9.1.2";
-      sha256 = "1cg1wgrb7xbnqqqzy31y5lskcb66vmsr6ifmv0xi1qy0kb0c2y7i";
+      version = "1.9.1.3";
+      sha256 = "10hgwdpnd82yhsjflbskngwkjmkpp49qrvxspgka24ngp8q08zyz";
       libraryHaskellDepends = [
         base-prelude
         clock
···
       pname = "haxr";
       version = "3000.11.5.1";
       sha256 = "1r5ipm1qzlkxk1xc9hv86kli5aa4nw7i9a6n42ixkcspwb8fjhzd";
+      revision = "1";
+      editedCabalFile = "0m9x1cs789qs7k3zc197zri1nbh6g1y05xraq5a1k10s0xs5sjdy";
       libraryHaskellDepends = [
         array
         base
···
     }
   ) { };
 
+  "hblosc" = callPackage (
+    {
+      mkDerivation,
+      base,
+      bytestring,
+      hspec,
+    }:
+    mkDerivation {
+      pname = "hblosc";
+      version = "0.1.0.2";
+      sha256 = "0xsp5cwj8mqss6rwbm5ndjkzl2yhw7x135s9gvhwm6xj36pz0gnb";
+      libraryHaskellDepends = [
+        base
+        bytestring
+      ];
+      testHaskellDepends = [
+        base
+        bytestring
+        hspec
+      ];
+      description = "Blosc (numerical compression library) bindings for Haskell";
+      license = lib.licenses.mit;
+      hydraPlatforms = lib.platforms.none;
+      broken = true;
+    }
+  ) { };
+
   "hbro" = callPackage (
     {
       mkDerivation,
···
       pname = "hedgehog-classes";
       version = "0.2.5.4";
       sha256 = "0z9ik5asddc2pnz430jsi1pyahkh6jy36ng0vwm7ywcq7cvhcvlz";
-      revision = "5";
-      editedCabalFile = "19jxkb9dszkvch4cd30n4nsp36p86xdbgqbliqv836m2qwayjmyp";
+      revision = "6";
+      editedCabalFile = "1gj6lrvy11bxnv26ayg1b98dv44ahwqngi8d5rxw1h1m13a7yzkk";
       libraryHaskellDepends = [
         aeson
         base
···
       async,
       base,
       bytestring,
+      containers,
       deepseq,
       Diff,
       directory,
       exceptions,
       filepath,
+      generic-lens,
       hedgehog,
       http-conduit,
+      hw-prelude,
       lifted-async,
       lifted-base,
+      microlens,
       mmorph,
       monad-control,
       mtl,
       network,
       process,
       resourcet,
-      retry,
       stm,
       tar,
       tasty,
···
     }:
     mkDerivation {
       pname = "hedgehog-extras";
-      version = "0.7.0.0";
-      sha256 = "0dhkhai2q831fb8z9cyv065gdf0468x0sbns1np74v8qnzwbhgav";
-      revision = "1";
-      editedCabalFile = "1f8xc2dr158c3nppj4rny611vfli74fpggnx1s75ln846xq2yzkj";
+      version = "0.9.0.0";
+      sha256 = "0l067gvm7vvhr5jrcys9676kfhdvaivbwiqh85n0zlcnkf3mjff0";
       libraryHaskellDepends = [
         aeson
         aeson-pretty
         async
         base
         bytestring
+        containers
         deepseq
         Diff
         directory
         exceptions
         filepath
+        generic-lens
         hedgehog
         http-conduit
+        hw-prelude
         lifted-async
         lifted-base
+        microlens
         mmorph
         monad-control
         mtl
         network
         process
         resourcet
-        retry
         stm
         tar
+        tasty
+        tasty-discover
+        tasty-hedgehog
         temporary
         text
         time
···
       testHaskellDepends = [
         base
         hedgehog
+        lifted-base
         network
         process
         resourcet
         tasty
+        tasty-discover
         tasty-hedgehog
         time
         transformers
···
       testToolDepends = [ tasty-discover ];
       description = "Supplemental library for hedgehog";
       license = lib.licenses.asl20;
+      hydraPlatforms = lib.platforms.none;
+      broken = true;
     }
   ) { };
 
···
       pname = "hedgehog-fakedata";
       version = "0.0.1.5";
       sha256 = "00k26d83v0646klrg0k3cf94r4fnnx3ykxv7i8shjjgbkbzlzz78";
-      revision = "2";
-      editedCabalFile = "1b8v4j8zkvdfx786nfxxdkxj57b2qh4p9h16wiy0kc3l1dsj6llm";
+      revision = "3";
+      editedCabalFile = "1gfknhs1lslw7s00ciqn14r9b1lpph0827hhbb6bg9r52lylv9g3";
       libraryHaskellDepends = [
         base
         fakedata
···
       pname = "heist";
       version = "1.1.1.2";
       sha256 = "1377740si611j0szp64axy0xj1fi2a6w8i9s3xij89h34m7rb3rz";
-      revision = "4";
-      editedCabalFile = "112bhvishyhknb7gzii56sqaz5gxzb1png2k73rsnfmranvzl3ka";
+      revision = "5";
+      editedCabalFile = "0rx4cx09zlg9kdl2sn5fn2ka7a7c26xrvbhkp60pzdnj1hdnsbqi";
       libraryHaskellDepends = [
         aeson
         attoparsec
···
     }
   ) { };
 
+  "heph-sparse-set" = callPackage (
+    {
+      mkDerivation,
+      base,
+      containers,
+      criterion,
+      deepseq,
+      hedgehog,
+      mtl,
+      nothunks,
+      primitive,
+      random,
+      tasty,
+      tasty-discover,
+      tasty-hedgehog,
+      tasty-hunit,
+      vector,
+    }:
+    mkDerivation {
+      pname = "heph-sparse-set";
+      version = "0.1.0.0";
+      sha256 = "0w1h6xa62xp1bwpz4czdr6vzml311zq76i1swq6iqpw2wch0dbvn";
+      libraryHaskellDepends = [
+        base
+        deepseq
+        primitive
+        vector
+      ];
+      testHaskellDepends = [
+        base
+        containers
+        deepseq
+        hedgehog
+        nothunks
+        primitive
+        tasty
+        tasty-discover
+        tasty-hedgehog
+        tasty-hunit
+        vector
+      ];
+      testToolDepends = [ tasty-discover ];
+      benchmarkHaskellDepends = [
+        base
+        containers
+        criterion
+        deepseq
+        mtl
+        primitive
+        random
+        vector
+      ];
+      description = "Really fast mutable sparse sets";
+      license = lib.licenses.bsd3;
+    }
+  ) { };
+
   "heptapod" = callPackage (
     {
       mkDerivation,
···
       license = lib.licenses.bsd3;
       hydraPlatforms = lib.platforms.none;
       broken = true;
+    }
+  ) { };
+
+  "heredocs-r2" = callPackage (
+    {
+      mkDerivation,
+      base,
+      bytestring,
+      hspec,
+      parsec,
+      template-haskell,
+      text,
+    }:
+    mkDerivation {
+      pname = "heredocs-r2";
+      version = "0.1.0.2";
+      sha256 = "1dzsgblbn4hijd6hgrwc951h1v6fjbg7gjbl8l3ihy79jm75ifbx";
+      libraryHaskellDepends = [
+        base
+        parsec
+        template-haskell
+      ];
+      testHaskellDepends = [
+        base
+        bytestring
+        hspec
+        text
+      ];
+      description = "Heredocument on Haskell";
+      license = lib.licenses.bsd3;
     }
   ) { };
 
···
     }
   ) { };
 
+  "hiedb_0_7_0_0" = callPackage (
+    {
+      mkDerivation,
+      algebraic-graphs,
+      ansi-terminal,
+      array,
+      base,
+      bytestring,
+      containers,
+      directory,
+      extra,
+      filepath,
+      ghc,
+      ghc-paths,
+      hie-compat,
+      hspec,
+      lucid,
+      mtl,
+      optparse-applicative,
+      process,
+      sqlite-simple,
+      temporary,
+      terminal-size,
+      text,
+    }:
+    mkDerivation {
+      pname = "hiedb";
+      version = "0.7.0.0";
+      sha256 = "0mhajz4wlgdzg079r9dcrhkl6dx5fdwq2x1c892frq0gqd18k5ln";
+      isLibrary = true;
+      isExecutable = true;
+      libraryHaskellDepends = [
+        algebraic-graphs
+        ansi-terminal
+        array
+        base
+        bytestring
+        containers
+        directory
+        extra
+        filepath
+        ghc
+        hie-compat
+        lucid
+        mtl
+        optparse-applicative
+        sqlite-simple
+        terminal-size
+        text
+      ];
+      executableHaskellDepends = [
+        base
+        ghc-paths
+      ];
+      testHaskellDepends = [
+        algebraic-graphs
+        base
+        directory
+        filepath
+        ghc-paths
+        hspec
+        process
+        temporary
+      ];
+      description = "Generates a references DB from .hie files";
+      license = lib.licenses.bsd3;
+      hydraPlatforms = lib.platforms.none;
+      mainProgram = "hiedb";
+    }
+  ) { };
+
   "hiedb-plugin" = callPackage (
     {
       mkDerivation,
···
     }
   ) { };
 
-  "hledger_1_42_2" = callPackage (
+  "hledger_1_43_2" = callPackage (
     {
       mkDerivation,
       aeson,
···
       hashable,
       haskeline,
       hledger-lib,
+      http-client,
+      http-types,
       lucid,
       math-functions,
       megaparsec,
···
       mtl,
       process,
       regex-tdfa,
+      req,
       safe,
       shakespeare,
       split,
···
     }:
     mkDerivation {
       pname = "hledger";
-      version = "1.42.2";
-      sha256 = "0c6g90xdwavp23azv4b1k9sn309j96150adc5ihm4lhijvldphcr";
+      version = "1.43.2";
+      sha256 = "043gw3amc29fbjxlzyc4m97bw5i5462352lmk61adlxcd12l47i1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
         hashable
         haskeline
         hledger-lib
+        http-client
+        http-types
         lucid
         math-functions
         megaparsec
···
         mtl
         process
         regex-tdfa
+        req
         safe
         shakespeare
         split
···
         githash
         haskeline
         hledger-lib
+        http-client
+        http-types
         math-functions
         megaparsec
         microlens
         mtl
         process
         regex-tdfa
+        req
         safe
         shakespeare
         split
···
         githash
         haskeline
         hledger-lib
+        http-client
+        http-types
         math-functions
         megaparsec
         microlens
         mtl
         process
         regex-tdfa
+        req
         safe
         shakespeare
         split
···
         wizards
       ];
       description = "Command-line interface for the hledger accounting system";
-      license = lib.licenses.gpl3Only;
+      license = lib.licenses.gpl3Plus;
       hydraPlatforms = lib.platforms.none;
       mainProgram = "hledger";
       maintainers = [
···
       pname = "hledger-iadd";
       version = "1.3.21";
       sha256 = "00x0vbfp08kqs1nbknndk9h56hcidf6xnrk0ldz45dvjrmgcv3w2";
-      revision = "8";
-      editedCabalFile = "166vkhghms83x0c03m6kg6v5fx3x8wyr445zjy6vxfsbni6ks4h7";
+      revision = "9";
+      editedCabalFile = "0fhkk8gsqiv7mxjk8jlz43i2h0cqampr8w5f1lxcnfz9g4k0bv5l";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
       pname = "hledger-interest";
       version = "1.6.7";
       sha256 = "1jirygghw82zi8z160j45qzfcj1l89vckqr7hrv78h3f3pim6np4";
-      revision = "1";
-      editedCabalFile = "1hl3vgwhlk15xrhafmp5y017cm4y7zkn2n8l9frsc0xz67h9571z";
+      revision = "2";
+      editedCabalFile = "1inrlrz2rgk99sspm33r7rnfiycx8pllsh95ais9x05fp88cxhcf";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
···
     }
   ) { };
 
-  "hledger-lib_1_42_2" = callPackage (
+  "hledger-lib_1_43_2" = callPackage (
     {
       mkDerivation,
       aeson,
···
       ansi-terminal,
       array,
       base,
-      base-compat,
       blaze-html,
       blaze-markup,
       bytestring,
···
     }:
     mkDerivation {
       pname = "hledger-lib";
-      version = "1.42.2";
-      sha256 = "0m0z70m4bm7bhrhjczdhwgz8afvjc1lrxwdr8kzgg0yyq2xrmxxx";
+      version = "1.43.2";
+      sha256 = "18037qwz7d0h4i86ac0w3hkrvx22vdxf04fjbg0qjlizgb3dlazf";
       libraryHaskellDepends = [
         aeson
         aeson-pretty
         ansi-terminal
         array
         base
-        base-compat
         blaze-html
         blaze-markup
         bytestring
···
         ansi-terminal
         array
         base
-        base-compat
         blaze-html
         blaze-markup
         bytestring
···
         utf8-string
       ];
       description = "A library providing the core functionality of hledger";
-      license = lib.licenses.gpl3Only;
+      license = lib.licenses.gpl3Plus;
       hydraPlatforms = lib.platforms.none;
     }
   ) { };
···
     }
   ) { };
 
-  "hledger-ui_1_42_2" = callPackage (
+  "hledger-ui_1_43_2" = callPackage (
     {
       mkDerivation,
       ansi-terminal,
···
     }:
     mkDerivation {
       pname = "hledger-ui";
-      version = "1.42.2";
-      sha256 = "17jmjphvrxcmg69b3p82sapf8x14w5xw10crbpcs6ws0wmlmmq71";
-      revision = "1";
-      editedCabalFile = "0lh28f9pxx6zxn91wna6ywj50igraqb6dyg797qqm2q3zz0kapif";
+      version = "1.43.2";
+      sha256 = "1xz5ndkg5mci689n82dnmwhhr8a08qw12czsf4b82ha7zlmbkmnv";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
       ];
       executableHaskellDepends = [ base ];
       description = "Terminal interface for the hledger accounting system";
-      license = lib.licenses.gpl3Only;
+      license = lib.licenses.gpl3Plus;
       hydraPlatforms = lib.platforms.none;
       mainProgram = "hledger-ui";
       maintainers = [ lib.maintainers.maralorn ];
···
     }
   ) { };
 
-  "hledger-web_1_42_2" = callPackage (
+  "hledger-web_1_43_2" = callPackage (
     {
       mkDerivation,
       aeson,
       base,
-      base-compat,
       base64,
       blaze-html,
       blaze-markup,
···
       Decimal,
       directory,
       extra,
+      file-embed,
       filepath,
       githash,
       hjsmin,
···
     }:
     mkDerivation {
       pname = "hledger-web";
-      version = "1.42.2";
-      sha256 = "0ciz1y97aw7493avj8i9hnzjinc1fwj20wns036qa6yxglsj0qkm";
+      version = "1.43.2";
+      sha256 = "0d4sv9k3m7s0764lbq2l8w9p2p47cby177l0avl5w3fa9y8d0gyd";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson
         base
-        base-compat
         base64
         blaze-html
         blaze-markup
···
         Decimal
         directory
         extra
+        file-embed
         filepath
         githash
         hjsmin
···
         yesod-static
         yesod-test
       ];
-      executableHaskellDepends = [
-        base
-        base-compat
-      ];
-      testHaskellDepends = [
-        base
-        base-compat
-      ];
+      executableHaskellDepends = [ base ];
+      testHaskellDepends = [ base ];
       description = "Web user interface for the hledger accounting system";
-      license = lib.licenses.gpl3Only;
+      license = lib.licenses.gpl3Plus;
       hydraPlatforms = lib.platforms.none;
       mainProgram = "hledger-web";
       maintainers = [ lib.maintainers.maralorn ];
···
     }:
     mkDerivation {
       pname = "hoist-error";
-      version = "0.3.0.0";
-      sha256 = "160967zsp8rzsvs12crsxh3854lnhxiidv8adixb4nf9hxvdnka6";
+      version = "0.3.1.0";
+      sha256 = "12hq6xz6jrsjd6nc03iv033abx73m1b2baszlk6b7k6r850fw4q5";
       libraryHaskellDepends = [
         base
         mtl
···
       pname = "horizontal-rule";
       version = "0.7.0.0";
       sha256 = "0s4hf7frj1gc41v83qk8fgdfn49msmvhcfw6vjklx6w7b6pkfx9x";
-      revision = "1";
-      editedCabalFile = "1jb71y6mxkrcnps1jdh6rkkrznhzcsyl8c7s565xjalabql56nkq";
+      revision = "2";
+      editedCabalFile = "02cql9yvsvbi6xf7kplidmxay7n70lxb1z2499vngn7197b6d5kh";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
     }
   ) { };
 
-  "hpack_0_38_0" = callPackage (
-    {
-      mkDerivation,
-      aeson,
-      base,
-      bifunctors,
-      bytestring,
-      Cabal,
-      containers,
-      crypton,
-      deepseq,
-      directory,
-      filepath,
-      Glob,
-      hspec,
-      hspec-discover,
-      http-client,
-      http-client-tls,
-      http-types,
-      HUnit,
-      infer-license,
-      interpolate,
-      mockery,
-      mtl,
-      pretty,
-      QuickCheck,
-      scientific,
-      template-haskell,
-      temporary,
-      text,
-      transformers,
-      unordered-containers,
-      vector,
-      yaml,
-    }:
-    mkDerivation {
-      pname = "hpack";
-      version = "0.38.0";
-      sha256 = "0iysz3xnxhjj49hjz9gv56awaldamrbidkiw0xd873g5yfyhyljp";
-      revision = "1";
-      editedCabalFile = "02pqfqqijvr2z3ki2rnb9nlavhzm59qbbvhq89bfdvhcicfgmmf4";
-      isLibrary = true;
-      isExecutable = true;
-      libraryHaskellDepends = [
-        aeson
-        base
-        bifunctors
-        bytestring
-        Cabal
-        containers
-        crypton
-        deepseq
-        directory
-        filepath
-        Glob
-        http-client
-        http-client-tls
-        http-types
-        infer-license
-        mtl
-        pretty
-        scientific
-        text
-        transformers
-        unordered-containers
-        vector
-        yaml
-      ];
-      executableHaskellDepends = [
-        aeson
-        base
-        bifunctors
-        bytestring
-        Cabal
-        containers
-        crypton
-        deepseq
-        directory
-        filepath
-        Glob
-        http-client
-        http-client-tls
-        http-types
-        infer-license
-        mtl
-        pretty
-        scientific
-        text
-        transformers
-        unordered-containers
-        vector
-        yaml
-      ];
-      testHaskellDepends = [
-        aeson
-        base
-        bifunctors
-        bytestring
-        Cabal
-        containers
-        crypton
-        deepseq
-        directory
-        filepath
-        Glob
-        hspec
-        http-client
-        http-client-tls
-        http-types
-        HUnit
-        infer-license
-        interpolate
-        mockery
-        mtl
-        pretty
-        QuickCheck
-        scientific
-        template-haskell
-        temporary
-        text
-        transformers
-        unordered-containers
-        vector
-        yaml
-      ];
-      testToolDepends = [ hspec-discover ];
-      description = "A modern format for Haskell packages";
-      license = lib.licenses.mit;
-      hydraPlatforms = lib.platforms.none;
-      mainProgram = "hpack";
-    }
-  ) { };
-
   "hpack_0_38_1" = callPackage (
     {
       mkDerivation,
···
     }
   ) { };
 
-  "hpqtypes-extras_1_17_0_1" = callPackage (
+  "hpqtypes-extras_1_18_0_0" = callPackage (
     {
       mkDerivation,
       base,
···
     }:
     mkDerivation {
       pname = "hpqtypes-extras";
-      version = "1.17.0.1";
-      sha256 = "1f2ipf4hwp3iqfb79bbx8h97l1cy8vyc1w5h0q1fvg2yvxl52szp";
+      version = "1.18.0.0";
+      sha256 = "1vqyb1izw6ascmkkqkm33iahydrabpb7rq2r3qkhxkjbhrgfk5j5";
       libraryHaskellDepends = [
         base
         base16-bytestring
···
       ];
       description = "HQuantLib Time is a business calendar functions extracted from HQuantLib";
       license = "LGPL";
+    }
+  ) { };
+
+  "hquantlib-time_0_1_2" = callPackage (
+    {
+      mkDerivation,
+      base,
+      time,
+    }:
+    mkDerivation {
+      pname = "hquantlib-time";
+      version = "0.1.2";
+      sha256 = "0i0klg4l4vipw8802ghb2ddd1fpn7wrg027pqfh1yf6x1m1r2k8z";
+      libraryHaskellDepends = [
+        base
+        time
+      ];
+      description = "HQuantLib Time is a business calendar functions extracted from HQuantLib";
+      license = lib.licenses.lgpl3Plus;
+      hydraPlatforms = lib.platforms.none;
     }
   ) { };
 
···
       base,
       extra,
       ghc-events,
+      machines,
       optparse-applicative,
       text,
       vector,
     }:
     mkDerivation {
       pname = "hs-speedscope";
-      version = "0.2.1";
-      sha256 = "1qzmcn718mbg5pckvbcw2n36srmbixkyp45hrkdcdnqcsvf5agln";
+      version = "0.3.0";
+      sha256 = "089mg3q9f6pkvkx4zxgnv69hyzs06cr4ljkaij5kzgq35i12l4x3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
         base
         extra
         ghc-events
+        machines
         optparse-applicative
         text
         vector
···
       executableHaskellDepends = [ base ];
       description = "Convert an eventlog into the speedscope json format";
       license = lib.licenses.bsd3;
-      hydraPlatforms = lib.platforms.none;
       mainProgram = "hs-speedscope";
-      broken = true;
     }
   ) { };
 
···
       cmdargs,
       directory,
       filepath,
-      filepath-bytestring,
       libssh2,
       mtl,
       tasty,
···
     }:
     mkDerivation {
       pname = "hsftp";
-      version = "1.3.1";
-      sha256 = "0027bmn11fl3lbyd4aw77w5b4xdf53izpxnnpp1qnwpxd8j92w82";
+      version = "1.4.0";
+      sha256 = "01fzgrk9w6xy7wxkpg2znw5g2wkqrcz6vj1f0pdffvg0bslfn4g0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
         cmdargs
         directory
         filepath
-        filepath-bytestring
         libssh2
         mtl
         time
···
         cmdargs
         directory
         filepath
-        filepath-bytestring
         libssh2
         mtl
         time
···
         cmdargs
         directory
         filepath
-        filepath-bytestring
         libssh2
         mtl
         tasty
···
     }
   ) { };
 
+  "hslua_2_4_0" = callPackage (
+    {
+      mkDerivation,
+      base,
+      bytestring,
+      exceptions,
+      hslua-aeson,
+      hslua-classes,
+      hslua-core,
+      hslua-marshalling,
+      hslua-objectorientation,
+      hslua-packaging,
+      hslua-typing,
+      tasty,
+      tasty-hslua,
+      tasty-hunit,
+      text,
+    }:
+    mkDerivation {
+      pname = "hslua";
+      version = "2.4.0";
+      sha256 = "093cjgrzxyvd7kg7ap5bszbfpgzcggwsnypm2q2ij6hyqz8x8gqk";
+      isLibrary = true;
+      isExecutable = true;
+      libraryHaskellDepends = [
+        base
+        hslua-aeson
+        hslua-classes
+        hslua-core
+        hslua-marshalling
+        hslua-objectorientation
+        hslua-packaging
+        hslua-typing
+      ];
+      testHaskellDepends = [
+        base
+        bytestring
+        exceptions
+        hslua-core
+        tasty
+        tasty-hslua
+        tasty-hunit
+        text
+      ];
+      description = "Bindings to Lua, an embeddable scripting language";
+      license = lib.licenses.mit;
+      hydraPlatforms = lib.platforms.none;
+    }
+  ) { };
+
   "hslua-aeson" = callPackage (
     {
       mkDerivation,
···
     }:
     mkDerivation {
       pname = "hslua-module-doclayout";
-      version = "1.2.0";
-      sha256 = "1x3znkdz1l8p8gsvazz85936p107xscsaah1ac3padyiswhair1j";
+      version = "1.2.0.1";
+      sha256 = "139l4sh9pllm0zjgv3w7scbpd0cgn23r95fdlchavsdfwkpvcx17";
       libraryHaskellDepends = [
         base
         doclayout
···
     }
   ) { };
 
+  "hslua-module-system_1_2_0" = callPackage (
+    {
+      mkDerivation,
+      base,
+      bytestring,
+      directory,
+      exceptions,
+      hslua-core,
+      hslua-marshalling,
+      hslua-packaging,
+      process,
+      tasty,
+      tasty-hunit,
+      tasty-lua,
+      temporary,
+      text,
+      time,
+    }:
+    mkDerivation {
+      pname = "hslua-module-system";
+      version = "1.2.0";
+      sha256 = "0wbbz0h33wrhdpxz40gqgijkra19jg0zyy4snmj75qxcq2cc9dw2";
+      libraryHaskellDepends = [
+        base
+        bytestring
+        directory
+        exceptions
+        hslua-core
+        hslua-marshalling
+        hslua-packaging
+        process
+        temporary
+        text
+        time
+      ];
+      testHaskellDepends = [
+        base
+        hslua-core
+        hslua-packaging
+        tasty
+        tasty-hunit
+        tasty-lua
+      ];
+      description = "Lua module wrapper around Haskell's System module";
+      license = lib.licenses.mit;
+      hydraPlatforms = lib.platforms.none;
+    }
+  ) { };
+
   "hslua-module-text" = callPackage (
     {
       mkDerivation,
···
     {
       mkDerivation,
       base,
-      bytestring,
-      filepath,
       hslua-core,
       hslua-list,
       hslua-marshalling,
···
     }:
     mkDerivation {
       pname = "hslua-module-zip";
-      version = "1.1.3";
-      sha256 = "1fws5jwf1zwqilgm05y28ywgxavygnjpdlj43nhfg8cmng1p0kyq";
-      revision = "1";
-      editedCabalFile = "1ml14hycwh4wg8351b8dq94qyppkzhw8jk0b0dgahqvy7p5w86y3";
+      version = "1.1.4";
+      sha256 = "1ij2rmy8m4pw7k7w5vvb3g934kms60vhzhhp8kryknbi6bsg8lsy";
       libraryHaskellDepends = [
         base
-        bytestring
-        filepath
         hslua-core
         hslua-list
         hslua-marshalling
···
       ];
       testHaskellDepends = [
         base
-        bytestring
-        filepath
         hslua-core
-        hslua-list
-        hslua-marshalling
         hslua-module-system
         hslua-packaging
-        hslua-typing
         tasty
         tasty-hunit
         tasty-lua
-        text
-        time
-        zip-archive
       ];
       description = "Lua module to work with file zips";
       license = lib.licenses.mit;
···
     }
   ) { };
 
+  "hslua-objectorientation_2_4_0" = callPackage (
+    {
+      mkDerivation,
+      base,
+      bytestring,
+      containers,
+      hslua-core,
+      hslua-marshalling,
+      hslua-typing,
+      tasty,
+      tasty-hslua,
+      text,
+    }:
+    mkDerivation {
+      pname = "hslua-objectorientation";
+      version = "2.4.0";
+      sha256 = "0gm7l5gqbxrvniivz82wl9rmwgmrg2swji3q0wk43s2xxhajbihs";
+      libraryHaskellDepends = [
+        base
+        containers
+        hslua-core
+        hslua-marshalling
+        hslua-typing
+        text
+      ];
+      testHaskellDepends = [
+        base
+        bytestring
+        hslua-core
+        hslua-marshalling
+        hslua-typing
+        tasty
+        tasty-hslua
+      ];
+      description = "Object orientation tools for HsLua";
+      license = lib.licenses.mit;
+      hydraPlatforms = lib.platforms.none;
+    }
+  ) { };
+
   "hslua-packaging" = callPackage (
     {
       mkDerivation,
···
       ];
       description = "Utilities to build Lua modules";
       license = lib.licenses.mit;
+    }
+  ) { };
+
+  "hslua-packaging_2_3_2" = callPackage (
+    {
+      mkDerivation,
+      base,
+      bytestring,
+      containers,
+      hslua-core,
+      hslua-marshalling,
+      hslua-objectorientation,
+      hslua-typing,
+      tasty,
+      tasty-hslua,
+      tasty-hunit,
+      text,
+    }:
+    mkDerivation {
+      pname = "hslua-packaging";
+      version = "2.3.2";
+      sha256 = "1w7929fr6pkwm9x25ags1nk5xrfq9kn3g113wi5c02a8m8zqwh8s";
+      libraryHaskellDepends = [
+        base
+        containers
+        hslua-core
+        hslua-marshalling
+        hslua-objectorientation
+        hslua-typing
+        text
+      ];
+      testHaskellDepends = [
+        base
+        bytestring
+        hslua-core
+        hslua-marshalling
+        tasty
+        tasty-hslua
+        tasty-hunit
+        text
+      ];
+      description = "Utilities to build Lua modules";
+      license = lib.licenses.mit;
+      hydraPlatforms = lib.platforms.none;
     }
   ) { };
 
···
     }
   ) { };
 
+  "hspec-annotated-exception" = callPackage (
+    {
+      mkDerivation,
+      annotated-exception,
+      base,
+      hspec,
+      HUnit,
+      lens,
+      text,
+    }:
+    mkDerivation {
+      pname = "hspec-annotated-exception";
+      version = "0.0.0.0";
+      sha256 = "0cmhplcqqbn9ggv5fwdij3kmj52jvkm8j4z3gbrgyd66y1i9wmhb";
+      libraryHaskellDepends = [
+        annotated-exception
+        base
+        hspec
+        HUnit
+        lens
+        text
+      ];
+      description = "Hspec hook that unwraps test failures from AnnotatedException";
+      license = lib.licenses.mit;
+    }
+  ) { };
+
   "hspec-api" = callPackage (
     {
       mkDerivation,
···
       pname = "hspec-core";
       version = "2.11.12";
       sha256 = "030400w95775jrivbi7n1nnx6j5z717rqd3986ggklb8h9hjalfc";
+      revision = "1";
+      editedCabalFile = "0yq9nnawcgbgxiz4ymfa8k66jrvgrhmv8j7g880x8k6q8q4ncqlq";
       libraryHaskellDepends = [
         ansi-terminal
         array
···
       pname = "hspec-meta";
       version = "2.11.12";
       sha256 = "1612pg5gihqjxrzqqvbbgckaqiwq3rmz3rg07lrjhzklg975nj69";
+      revision = "2";
+      editedCabalFile = "1jrk14s51psb0zjici56220iyb98i3q06sd3rsyx594s3cddgn5d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
     }
   ) { inherit (pkgs) sqlite; };
 
-  "hsqml" = callPackage (
-    {
-      mkDerivation,
-      base,
-      c2hs,
-      Cabal,
-      containers,
-      directory,
-      filepath,
-      qt5,
-      QuickCheck,
-      tagged,
-      template-haskell,
-      text,
-      transformers,
-    }:
-    mkDerivation {
-      pname = "hsqml";
-      version = "0.3.5.1";
-      sha256 = "046inz0pa5s052w653pk2km9finj44c6y2yx7iqihn4h4vnqbim0";
-      setupHaskellDepends = [
-        base
-        Cabal
-        filepath
-        template-haskell
-      ];
-      libraryHaskellDepends = [
-        base
-        containers
-        filepath
-        tagged
-        text
-        transformers
-      ];
-      libraryPkgconfigDepends = [ qt5 ];
-      libraryToolDepends = [ c2hs ];
-      testHaskellDepends = [
-        base
-        containers
-        directory
-        QuickCheck
-        tagged
-        text
-      ];
-      description = "Haskell binding for Qt Quick";
-      license = lib.licenses.bsd3;
-      hydraPlatforms = lib.platforms.none;
-    }
-  ) { qt5 = null; };
+  "hsqml" =
+    callPackage
+      (
+        {
+          mkDerivation,
+          base,
+          bytestring,
+          c2hs,
+          Cabal,
+          containers,
+          directory,
+          filepath,
+          qt5,
+          Qt5Network,
+          QuickCheck,
+          tagged,
+          template-haskell,
+          text,
+          transformers,
+        }:
+        mkDerivation {
+          pname = "hsqml";
+          version = "0.3.6.1";
+          sha256 = "0wvnxc3kad9ja4s16n9nj6nqknckal93ifbprq6nwd0x5i6zvknm";
+          setupHaskellDepends = [
+            base
+            Cabal
+            filepath
+            template-haskell
+          ];
+          libraryHaskellDepends = [
+            base
+            bytestring
+            containers
+            directory
+            filepath
+            QuickCheck
+            tagged
+            text
+            transformers
+          ];
+          libraryPkgconfigDepends = [
+            qt5
+            Qt5Network
+          ];
+          libraryToolDepends = [ c2hs ];
+          testHaskellDepends = [
+            base
+            containers
+            directory
+            QuickCheck
+            tagged
+            text
+          ];
+          description = "Haskell binding for Qt Quick";
+          license = lib.licenses.bsd3;
+          hydraPlatforms = lib.platforms.none;
+        }
+      )
+      {
+        Qt5Network = null;
+        qt5 = null;
+      };
 
   "hsqml-datamodel" = callPackage (
     {
···
     }:
     mkDerivation {
       pname = "hsqml-demo-manic";
-      version = "0.3.4.0";
-      sha256 = "09lnd6am51z98j4kwwidj4jw0bcrx8904r526w50y38afngysqx6";
+      version = "0.3.5.0";
+      sha256 = "1y5wfqdilmgkshvd5zz0ajpjx41rn68n6gp43nx1qamz036plklv";
       isLibrary = false;
       isExecutable = true;
       enableSeparateDataOutput = true;
···
     }:
     mkDerivation {
       pname = "hsqml-demo-morris";
-      version = "0.3.1.1";
-      sha256 = "166r06yhnmg063d48dh7973wg85nfmvp1c5gmy79ilycc8xgvmhm";
+      version = "0.3.2.0";
+      sha256 = "0bc0ll794bmz0m12y2s6pcwxlm16ppcldhr0gbs4xfwcb2mylrd2";
       isLibrary = false;
       isExecutable = true;
       enableSeparateDataOutput = true;
···
     }:
     mkDerivation {
       pname = "hsqml-demo-notes";
-      version = "0.3.3.0";
-      sha256 = "0gjlsqlspchav6lvc4ld15192x70j8cyzw903dgla7g9sj8fg813";
+      version = "0.3.4.0";
+      sha256 = "1k15v0wyv59dkd7wgzpkv8qy8g0i3sw5dpsjf003cy59rl8g8y3q";
       isLibrary = false;
       isExecutable = true;
       enableSeparateDataOutput = true;
···
     }:
     mkDerivation {
       pname = "hsqml-demo-samples";
-      version = "0.3.4.0";
-      sha256 = "0y82caz4fb4cz4qfmdg7h5zr959yw2q162zz980jz179188a8pr2";
+      version = "0.3.5.0";
+      sha256 = "0xihibxfy86ml20hhzr66mzygk0lhwhwjpz09ig47fvdlhs0239d";
       isLibrary = false;
       isExecutable = true;
       enableSeparateDataOutput = true;
···
     }:
     mkDerivation {
       pname = "http2";
-      version = "5.3.9";
-      sha256 = "0wcv9ziz0865j66avlax7f4i9l5k7ydcn96bacy78snmvcciblqf";
+      version = "5.3.10";
+      sha256 = "0rs21pgnmd0qcg1j360pm8r9c4hm18bcivhnq3krqjl32zb1frpl";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
       base,
       bytestring,
       crypton-x509-store,
+      crypton-x509-system,
       crypton-x509-validation,
       http2,
       network,
···
     }:
     mkDerivation {
       pname = "http2-tls";
-      version = "0.4.6";
-      sha256 = "1fi7mk5lkpgr194da9wcwwn7hwdj5cw9kzdiqr3w8dwixnddqrl9";
+      version = "0.4.8";
+      sha256 = "1sy2q6zyc68fjk03fc9pnd6sshjwr6djbyw45gningpfcrw41qv6";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base
         bytestring
         crypton-x509-store
+        crypton-x509-system
         crypton-x509-validation
         http2
         network
···
       iproute,
       network,
       network-byte-order,
+      network-control,
+      psqueues,
       quic,
       QuickCheck,
       sockaddr,
···
     }:
     mkDerivation {
       pname = "http3";
-      version = "0.0.24";
-      sha256 = "1i7dzw9ib9h0i2zjnwsqxbs188p71ly1ad1vdnjnbhyr4gq6aw77";
+      version = "0.1.0";
+      sha256 = "1ygm1a6ph24a84vsdqb7l2bn1ylzd3dl0bc6blvpqq6yhhm34cpa";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
         iproute
         network
         network-byte-order
+        network-control
+        psqueues
         quic
         sockaddr
         stm
···
         base
         base16-bytestring
         bytestring
+        case-insensitive
         conduit
         conduit-extra
+        containers
         crypton
         hspec
         http-semantics
···
       doHaddock = false;
       description = "Branch on whether a constraint is satisfied";
       license = lib.licenses.bsd3;
+      hydraPlatforms = lib.platforms.none;
+      broken = true;
     }
   ) { };
 
···
     }
   ) { };
 
-  "inspection-testing_0_6" = callPackage (
+  "inspection-testing_0_6_2" = callPackage (
     {
       mkDerivation,
       base,
···
     }:
     mkDerivation {
       pname = "inspection-testing";
-      version = "0.6";
-      sha256 = "13j6bqybkqd1nrhx648j0nmsjgyqnmbgssm5pxynmkqw62yylbry";
+      version = "0.6.2";
+      sha256 = "0zi1q86sd9jy5dpqfs2j71acdl7kvik0ps78xirpdhyldhwwyqws";
       libraryHaskellDepends = [
         base
         containers
···
       pname = "int-cast";
       version = "0.2.0.0";
       sha256 = "0s8rqm5d9f4y2sskajsw8ff7q8xp52vwqa18m6bajldp11m9a1p0";
-      revision = "7";
-      editedCabalFile = "0z1bffrx787f2697a6gfkmbxkj3ymgs88kid9ckcla08n11zw2ql";
+      revision = "8";
+      editedCabalFile = "10a33fvsy4qkckw6ciqiigy4r5f1pflw16l284scsdas56lk1pqq";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [
         base
···
     }:
     mkDerivation {
       pname = "int-like";
-      version = "0.3.0";
-      sha256 = "0nyxhq5715cb5dpvs6ap6zkm08xai1ivhpvj6jsj3kiy0fxyscmw";
+      version = "0.3.1";
+      sha256 = "093kq89lj49wmr878i3nx4yw7x0csh7wmnbil4w7whcy7zfmfabx";
       libraryHaskellDepends = [
         algebraic-graphs
         base
···
       hashable,
       heaps,
       hspec,
+      indexed-traversable,
       lattices,
       parsec,
       QuickCheck,
···
     }:
     mkDerivation {
       pname = "interval-patterns";
-      version = "0.8.0";
-      sha256 = "1paciwq4wzl0kqkl5zzj486dsq5pg6275nj15gicv1czj7m9ncg9";
+      version = "0.8.1";
+      sha256 = "1wq080qvc1xbw6kd86ffl7017prz27g5658yyyvmjrshv5krxrhx";
       libraryHaskellDepends = [
         base
         containers
···
         groups
         hashable
         heaps
+        indexed-traversable
         lattices
         semirings
         time
···
         hashable
         heaps
         hspec
+        indexed-traversable
         lattices
         parsec
         QuickCheck
···
       ];
       description = "Intervals, and monoids thereof";
       license = lib.licenses.bsd3;
-      hydraPlatforms = lib.platforms.none;
-      broken = true;
     }
   ) { };
 
···
     }:
     mkDerivation {
       pname = "io-classes";
-      version = "1.8.0.0";
-      sha256 = "154bpq8w65xyy4slbd12d0r02gv5bz0q09rlpxyjwx63kpzy5xw1";
+      version = "1.8.0.1";
+      sha256 = "0ivhs0wpl2i8fw5g2ch3ck5adzwsp1dlfl1j3vy872i3cfygcbdi";
       libraryHaskellDepends = [
         array
         async
···
     }:
     mkDerivation {
       pname = "io-sim";
-      version = "1.8.0.0";
-      sha256 = "00dmqfbq9j906f5ga1vqqmrvzdmwxwrw6gcigmdspwnpaq73yydr";
+      version = "1.8.0.1";
+      sha256 = "1xv0j1l46n0wv76sll796avrvl3aaxnf0dsqjkp66fw0yprdbh5n";
       libraryHaskellDepends = [
         base
         containers
···
     }:
     mkDerivation {
       pname = "ip6addr";
-      version = "2.0.0";
-      sha256 = "1drhjv6xmwfnx2yvxxs03ds415gxdgylzkmb5wy9g7b12q91kxf5";
+      version = "2.0.0.1";
+      sha256 = "18g1y923ll8sh1flg9ddf5nyi7ndngf99p3d39q6icimffnyqkfh";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
···
       bytestring-lexing,
       hspec,
       hspec-core,
+      hspec-discover,
       QuickCheck,
       quickcheck-instances,
       time,
     }:
     mkDerivation {
       pname = "iso8601-duration";
-      version = "0.1.2.0";
-      sha256 = "1hzzcgc1k3dn4l5yxzqq9d62n2hfkrcg0ag14dly7ak3gx9l8l3n";
+      version = "0.1.2.1";
+      sha256 = "0swdzv13y0ww4vlddcfwlwdcp0n5v824dcn5hfa5lxlp06xvy86h";
       libraryHaskellDepends = [
         attoparsec
         base
···
         quickcheck-instances
         time
       ];
+      testToolDepends = [ hspec-discover ];
       description = "Types and parser for ISO8601 durations";
       license = lib.licenses.bsd3;
-      hydraPlatforms = lib.platforms.none;
-      broken = true;
     }
   ) { };
 
···
       base,
       bytestring,
       jsaddle,
+      template-haskell,
     }:
     mkDerivation {
       pname = "nat";
-      version = "0.1.1.0";
-      pname = "nat";
+      version = "0.1.2.0";
+      sha256 = "1anr6gg5900mcywwkx8s5j4wpq7hs0zgxc8b2mxf9nlagjjparfz";
       libraryHaskellDepends = [
         base
         bytestring
         jsaddle
+        template-haskell
       ];
       doHaddock = false;
       pname = "nat";
···
       pname = "nat";
       license = lib.licenses.bsd3;
       hydraPlatforms = lib.platforms.none;
+      broken = true;
     }
   ) { };
 
···
     }:
     mkDerivation {
       pname = "nat";
-      version = "0.5.5";
-      pname = "nat";
+      version = "0.5.8";
+      sha256 = "1pb7z95cmqaxbmba2grrbf8dm56821y40v12l4402milnahzl3k9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
     }:
     mkDerivation {
       pname = "nat";
-      pname = "nat";
-      pname = "nat";
-      revision = "1";
-      pname = "nat";
+      version = "5.2.7";
+      sha256 = "0n716zyihbnq3s1zhqbh3fm0qzhgy2hk79ziy8b6bvydjpzsq8y3";
       libraryHaskellDepends = [
         adjunctions
         array
···
       ];
       pname = "nat";
       license = lib.licenses.bsd3;
+      hydraPlatforms = lib.platforms.none;
     }
   ) { };
 
···
     }
   ) { };
 
+  "koji-tool_1_3" = callPackage (
+    {
+      mkDerivation,
+      base,
+      directory,
+      extra,
+      filepath,
+      formatting,
+      http-conduit,
+      http-directory,
+      koji,
+      pretty-simple,
+      rpm-nvr,
+      safe,
+      select-rpms,
+      simple-cmd,
+      simple-cmd-args,
+      text,
+      time,
+      utf8-string,
+      xdg-userdirs,
+    }:
+    mkDerivation {
+      pname = "nat";
+      version = "1.3";
+      sha256 = "0ibbkl0lvgfwh16hihgqbc9gsgxdlz2w1ra7kfjs9cmx5l8w1gpg";
+      isLibrary = false;
+      isExecutable = true;
+      executableHaskellDepends = [
+        base
+        directory
+        extra
+        filepath
+        formatting
+        http-conduit
+        http-directory
+        koji
+        pretty-simple
+        rpm-nvr
+        safe
+        select-rpms
+        simple-cmd
+        simple-cmd-args
+        text
+        time
+        utf8-string
+        xdg-userdirs
+      ];
+      testHaskellDepends = [
+        base
+        simple-cmd
+      ];
+      pname = "nat";
+      license = lib.licenses.bsd3;
+      hydraPlatforms = lib.platforms.none;
+      pname = "nat";
+    }
+  ) { };
+
       pname = "nat";
     {
       mkDerivation,
···
     }:
     mkDerivation {
       pname = "nat";
-      version = "0.6.0.1";
-      pname = "nat";
+      version = "0.6.1.1";
+      sha256 = "0f3sfs6z9xwf7811s7mbh03a4jsyfcvjx1lvycs7gv1ak1jhm27z";
       libraryHaskellDepends = [
         aeson
         attoparsec
···
       testToolDepends = [ hspec-discover ];
       pname = "nat";
       license = lib.licenses.asl20;
-      hydraPlatforms = lib.platforms.none;
     }
   ) { };
 
···
       pname = "langchain-hs";
       version = "0.0.2.0";
       sha256 = "0gh3gmmppfms1jg5zaxksalh90675r4pl6lmz63szkpwl9rmc9kz";
+      revision = "2";
+      editedCabalFile = "0qk56yswclxrf903c34ifadd8ja2l3zxfc0b2vzlgf1x7zf4cikl";
       libraryHaskellDepends = [
         aeson
         async
···
       pname = "lapack-ffi-tools";
       version = "0.1.3.2";
       sha256 = "0y30qwxzbggn3aqr437j3bi1yfa1fpdq96xq7vxbi1fnll8a9432";
-      revision = "1";
-      editedCabalFile = "0z8ahg1bxcphdyhjaxwmfhdhwwg1d2mhx3dvl6af3c9sql9r5xjw";
+      revision = "2";
+      editedCabalFile = "0k96wssmadcjrhdzcd6q3n7qx9kpb2wb3i9c61xygwx6x9q13wm3";
       isLibrary = false;
       isExecutable = true;
       enableSeparateDataOutput = true;
···
       pname = "lattices";
       version = "2.2.1";
       sha256 = "0rknzbzwcbg87hjiz4jwqb81w14pywkipxjrrlrp0m5i8ciky1i7";
-      revision = "2";
-      editedCabalFile = "1y01fx2d3ad601zg13n52k8d4lcx1s3b6hhbwmyblhdj7x9xyl2i";
+      revision = "3";
+      editedCabalFile = "0ry6d23sy0pqgzn2cfbr0yrsxcf1mix2irhv1x9bzv99cz2az3qm";
       libraryHaskellDepends = [
         base
         containers
···
       ];
       description = "Haskell IDE written in Haskell";
       license = "GPL";
-      hydraPlatforms = lib.platforms.none;
       mainProgram = "leksah";
     }
   ) { inherit (pkgs) gtk3; };
···
       generic-deriving,
       ghc-prim,
       hashable,
-      HUnit,
       indexed-traversable,
       indexed-traversable-instances,
       kan-extensions,
···
       simple-reflect,
       strict,
       tagged,
+      tasty,
+      tasty-hunit,
+      tasty-quickcheck,
       template-haskell,
-      test-framework,
-      test-framework-hunit,
-      test-framework-quickcheck2,
       text,
       th-abstraction,
       these,
···
     }:
     mkDerivation {
       pname = "lens";
-      version = "5.3.4";
-      sha256 = "12n8jdwlpa5lcp2yi26a4fwncn1v1lyznaa9fasszk6qp0afvdpi";
+      version = "5.3.5";
+      sha256 = "1s0ziznj60l9z3z5dacq58kaq8cdfxcz0r75f5hwj25ivzrsrszg";
       libraryHaskellDepends = [
         array
         assoc
···
         bytestring
         containers
         deepseq
-        HUnit
         mtl
         QuickCheck
         simple-reflect
-        test-framework
-        test-framework-hunit
-        test-framework-quickcheck2
+        tasty
+        tasty-hunit
+        tasty-quickcheck
         text
         transformers
       ];
···
     }:
     mkDerivation {
       pname = "lens-family-th";
-      version = "0.5.3.1";
-      sha256 = "0fhv44qb3gdwiay3imhwhqhdpiczncjz2w6jiiqk11qn4a63rv7l";
+      version = "0.5.3.2";
+      sha256 = "1lkzrnajlgnxd5wmxaa8z4j3kxry5iwarc15n9jkxygb0b20x3rh";
       libraryHaskellDepends = [
         base
         template-haskell
···
       pname = "lens-properties";
       version = "4.11.1";
       sha256 = "1caciyn75na3f25q9qxjl7ibjam22xlhl5k2pqfiak10lxsmnz2g";
-      revision = "7";
-      editedCabalFile = "14n9yzar4zfqigyayxhi11a0g954nb4jcz0fahgpxyl2vbg7h1ch";
+      revision = "8";
+      editedCabalFile = "0lp0nkbm38v2i361w79dmqq20v3gn95bh1xixbs20549k73cxxj3";
       libraryHaskellDepends = [
         base
         lens
···
       pname = "lentil";
       version = "1.5.8.0";
       sha256 = "08g15kzynync0kl9f247sifzqpkjyvigc5r31w2n3vivi3pdcafn";
-      revision = "1";
-      editedCabalFile = "0n991bjlcjchmjlgfxg709sp6vsi6c5igzs7904i6hfabq3z47q5";
+      revision = "2";
+      editedCabalFile = "0qcibmqkw96658fx3dcfy90k8w4a7xdvllb8h0hk14v0lwvi4cmm";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
···
         }:
         mkDerivation {
           pname = "libtorch-ffi";
-          version = "2.0.1.3";
-          sha256 = "0hamxxlf69r3m826a3x59k11cmlv4m2340mr3xmcbyqga2zs04a6";
+          version = "2.0.1.5";
+          sha256 = "0qk8wdfp2c3xwn8ydszxn5zpifcgbp5ns75rinyyqybz0rls1xk8";
           libraryHaskellDepends = [
             async
             base
···
       distributive,
       ghc-prim,
       hashable,
-      HUnit,
       indexed-traversable,
       lens,
       QuickCheck,
···
       semigroupoids,
       simple-reflect,
       tagged,
+      tasty,
+      tasty-hunit,
+      tasty-quickcheck,
       template-haskell,
-      test-framework,
-      test-framework-hunit,
-      test-framework-quickcheck2,
       transformers,
       transformers-compat,
       unordered-containers,
···
     }:
     mkDerivation {
       pname = "linear";
-      version = "1.23.1";
-      sha256 = "0ybch2f4yc7mhxryr5f29i7j8ryq1i1n69fgldskxjrj825qkb3x";
+      version = "1.23.2";
+      sha256 = "05v91is8rwm34a86gra2q03d5f1klj4nmlxx8r3cx0gbkdhrvmmv";
       libraryHaskellDepends = [
         adjunctions
         base
···
         binary
         bytestring
         deepseq
-        HUnit
         QuickCheck
         reflection
         simple-reflect
-        test-framework
-        test-framework-hunit
-        test-framework-quickcheck2
+        tasty
+        tasty-hunit
+        tasty-quickcheck
         vector
       ];
       description = "Linear Algebra";
···
   ) { };
 
   "list1" = callPackage (
-    {
-      mkDerivation,
-      base,
-      smash,
-    }:
+    { mkDerivation, base }:
     mkDerivation {
       pname = "list1";
-      version = "0.0.2";
-      sha256 = "0lxx1m2vrf14fb8r4qzfp6y8iqxai3cdpg2dzh9az383qxhy0zmh";
-      libraryHaskellDepends = [
-        base
-        smash
-      ];
+      version = "0.1.0";
+      sha256 = "1kyl7gg0prq7cyr0radwqcwdmqj3d0w2rjs1406nkryjfibsxgkh";
+      libraryHaskellDepends = [ base ];
       description = "Helpers for working with NonEmpty lists";
       license = lib.licenses.bsd3;
-      hydraPlatforms = lib.platforms.none;
     }
   ) { };
 
···
       pname = "literatex";
       version = "0.4.0.0";
       sha256 = "06whn0rx1gy2pzl4678z087pfragy2sjaw34ljx6sfvxg0wn03bx";
+      revision = "1";
+      editedCabalFile = "1kqa99vrq35hk0n58cj5sgp6s87jgwhafz78jzrwi67v94w3hi01";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
       ];
       description = "Support for writing an EDSL with LLVM-JIT as target";
       license = lib.licenses.bsd3;
+      hydraPlatforms = lib.platforms.none;
     }
   ) { };
 
···
       doHaddock = false;
       description = "Utility functions for the llvm interface";
       license = lib.licenses.bsd3;
+      hydraPlatforms = lib.platforms.none;
+      broken = true;
     }
   ) { };
 
···
       mkDerivation,
       base,
       enumset,
-      LLVM,
+      LLVM-21git,
     }:
     mkDerivation {
       pname = "llvm-ffi";
-      version = "16.0";
-      sha256 = "14cf6qhdq69ggx41259ih55g6z1vn0694wrh3s8m6f7adq990ra9";
+      version = "21.0";
+      sha256 = "1dfl6zxcghhyyp49lgkknlq8nkvii7aag7y8b38ny93cpcczgx0g";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base
         enumset
       ];
-      librarySystemDepends = [ LLVM ];
+      librarySystemDepends = [ LLVM-21git ];
       description = "FFI bindings to the LLVM compiler toolkit";
       license = lib.licenses.bsd3;
       maintainers = [ lib.maintainers.thielema ];
     }
-  ) { LLVM = null; };
+  ) { LLVM-21git = null; };
 
   "llvm-ffi-tools" = callPackage (
     {
···
     }:
     mkDerivation {
       pname = "llvm-tf";
-      version = "16.0";
-      sha256 = "1nscccmk0nf52p9r0af354p4n4vr1fbaym4x164wwwid7xc1x65g";
+      version = "21.0";
+      sha256 = "108a6kw5xfbxq4y613702r79bix6djyn3szi188d38vmwzs4a8qx";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
     }:
     mkDerivation {
       pname = "log-base";
-      version = "0.12.0.1";
-      sha256 = "021chwkggy7q5c3hysfg3aj6pv60wla1cv8iyppibx70ilqpzqs4";
+      version = "0.12.1.0";
+      sha256 = "1c4dimdgzbia8h201prbl1w8g4qixn9fr100d7aawr256xhi7jci";
       libraryHaskellDepends = [
         aeson
         aeson-pretty
···
       bytestring,
       deepseq,
       http-client,
-      http-client-openssl,
+      http-client-tls,
       http-types,
       log-base,
       network-uri,
···
     }:
     mkDerivation {
       pname = "log-elasticsearch";
-      version = "0.13.0.1";
-      sha256 = "1l9p4zpf18rkwkv485swrlwyx2l3iqd332273mkz64ybjqllsdkx";
+      version = "0.13.0.2";
+      sha256 = "1hnd866bcp5fqnxlh3z39d2kn9mza9vp554sm34cmaclmkzfp0cw";
       libraryHaskellDepends = [
         aeson
         aeson-pretty
···
         bytestring
         deepseq
         http-client
-        http-client-openssl
+        http-client-tls
         http-types
         log-base
         network-uri
···
     }:
     mkDerivation {
       pname = "lz4-bytes";
-      version = "0.1.2.0";
-      sha256 = "1jgsz96n7n7g4403w0h3zjvlhdh11vy4s7wqka0ppsikjjl7f1ni";
+      version = "0.2.0.0";
+      sha256 = "10g253lwwmiz7ci70lyxfjln8mczj5r3m2nmcgidh4r9h31x30yv";
       libraryHaskellDepends = [
         base
         byte-order
···
       ];
       description = "Preconfigured email connection pool on top of smtp";
       license = lib.licenses.mit;
-      hydraPlatforms = lib.platforms.none;
       mainProgram = "exe";
     }
   ) { };
···
     }
   ) { };
 
+  "markup-parse_0_2_0_0" = callPackage (
+    {
+      mkDerivation,
+      base,
+      bytestring,
+      containers,
+      deepseq,
+      Diff,
+      doctest-parallel,
+      flatparse,
+      string-interpolate,
+      tasty,
+      tasty-golden,
+      these,
+    }:
+    mkDerivation {
+      pname = "markup-parse";
+      version = "0.2.0.0";
+      sha256 = "1z08d3chvgl9zk9y2crfjih0crh5dv7pih6x0n7af38l6lhsgkhz";
+      libraryHaskellDepends = [
+        base
+        bytestring
+        containers
+        deepseq
+        flatparse
+        string-interpolate
+        these
+      ];
+      testHaskellDepends = [
+        base
+        bytestring
+        Diff
+        doctest-parallel
+        tasty
+        tasty-golden
+      ];
+      description = "A markup parser";
+      license = lib.licenses.bsd3;
+      hydraPlatforms = lib.platforms.none;
+    }
+  ) { };
+
   "markup-preview" = callPackage (
     {
       mkDerivation,
···
     }:
     mkDerivation {
       pname = "massiv";
-      version = "1.0.4.1";
-      sha256 = "11gvl0z49aariw3vy8g46di1x5xibf6l7zf6b3l701hvg0hffyn7";
-      libraryHaskellDepends = [
-        base
-        bytestring
-        deepseq
-        exceptions
-        primitive
-        random
-        scheduler
-        unliftio-core
-        vector
-        vector-stream
-      ];
-      testHaskellDepends = [
-        base
-        doctest
-      ];
-      description = "Massiv (Массив) is an Array Library";
-      license = lib.licenses.bsd3;
-      maintainers = [ lib.maintainers.sheepforce ];
-    }
-  ) { };
-
-  "massiv_1_0_5_0" = callPackage (
-    {
-      mkDerivation,
-      base,
-      bytestring,
-      deepseq,
-      doctest,
-      exceptions,
-      primitive,
-      random,
-      scheduler,
-      unliftio-core,
-      vector,
-      vector-stream,
-    }:
-    mkDerivation {
-      pname = "massiv";
       version = "1.0.5.0";
       sha256 = "138y8kk2qxprlwd8isb6h7wigiymmin1sip255060ql5gzjaawcw";
       libraryHaskellDepends = [
···
       ];
       description = "Massiv (Массив) is an Array Library";
       license = lib.licenses.bsd3;
-      hydraPlatforms = lib.platforms.none;
       maintainers = [ lib.maintainers.sheepforce ];
     }
   ) { };
···
     }:
     mkDerivation {
       pname = "mattermost-api";
-      version = "90000.0.0";
-      sha256 = "1ka3r4bnfwlbjnkws8vkg8i9gj8wzsyss137p7hxrx4sr75s6iyv";
+      version = "90000.1.0";
+      sha256 = "0mp2qch4amgiixmx7zv158fb3ld1dpfad17sb43gxwadrj9afxdh";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
     }:
     mkDerivation {
       pname = "mattermost-api-qc";
-      version = "90000.0.0";
-      sha256 = "0lrb8l8nbrdp4y2ala8hchr8ikv5hqw710ffiiw1sz6z2dqiqbxm";
+      version = "90000.1.0";
+      sha256 = "08ifm97c80a8vp9cqlwk7jb7105y2q6w77zvy2p42vk1l1p6yq4m";
       libraryHaskellDepends = [
         base
         containers
···
     }
   ) { };
 
+  "mcp" = callPackage (
+    {
+      mkDerivation,
+      aeson,
+      async,
+      base,
+      base64-bytestring,
+      bytestring,
+      containers,
+      cryptonite,
+      http-conduit,
+      http-types,
+      jose,
+      memory,
+      mtl,
+      optparse-applicative,
+      random,
+      scientific,
+      servant,
+      servant-auth,
+      servant-auth-server,
+      servant-server,
+      stm,
+      text,
+      time,
+      transformers,
+      unordered-containers,
+      uuid,
+      wai,
+      wai-extra,
+      warp,
+    }:
+    mkDerivation {
+      pname = "mcp";
+      version = "0.2.0.1";
+      sha256 = "0mmm890m86dv16hw7mjbznswhw1jrm7kbn45qqhfp661k3kwlw1j";
+      isLibrary = true;
+      isExecutable = true;
+      libraryHaskellDepends = [
+        aeson
+        async
+        base
+        base64-bytestring
+        bytestring
+        containers
+        cryptonite
+        http-conduit
+        http-types
+        jose
+        memory
+        mtl
+        random
+        servant
+        servant-auth
+        servant-auth-server
+        servant-server
+        stm
+        text
+        time
+        transformers
+        unordered-containers
+        uuid
+        wai
+        wai-extra
+        warp
+      ];
+      executableHaskellDepends = [
+        aeson
+        base
+        containers
+        optparse-applicative
+        scientific
+        text
+        time
+      ];
+      testHaskellDepends = [ base ];
+      description = "A Haskell implementation of the Model Context Protocol (MCP)";
+      license = lib.licenses.mit;
+      hydraPlatforms = lib.platforms.none;
+      broken = true;
+    }
+  ) { };
+
+  "mcp-server" = callPackage (
+    {
+      mkDerivation,
+      aeson,
+      base,
+      bytestring,
+      containers,
+      hspec,
+      http-types,
+      network-uri,
+      QuickCheck,
+      template-haskell,
+      text,
+      vector,
+      wai,
+      warp,
+    }:
+    mkDerivation {
+      pname = "mcp-server";
+      version = "0.1.0.14";
+      sha256 = "0lyr19sg5cjsgiq16v0cfkf1rkwgvyacz4siflf4wapllrkr82fz";
+      isLibrary = true;
+      isExecutable = true;
+      libraryHaskellDepends = [
+        aeson
+        base
+        bytestring
+        containers
+        http-types
+        network-uri
+        template-haskell
+        text
+        vector
+        wai
+        warp
+      ];
+      executableHaskellDepends = [
+        base
+        containers
+        network-uri
+        text
+      ];
+      testHaskellDepends = [
+        aeson
+        base
+        bytestring
+        containers
+        hspec
+        network-uri
+        QuickCheck
+        template-haskell
+        text
+      ];
+      description = "Library for building Model Context Protocol (MCP) servers";
+      license = lib.licenses.bsd3;
+      hydraPlatforms = lib.platforms.none;
+      broken = true;
+    }
+  ) { };
+
   "mcpi" = callPackage (
     {
       mkDerivation,
···
       pname = "med-module";
       version = "0.1.3";
       sha256 = "04p1aj85hsr3wpnnfg4nxbqsgq41ga63mrg2w39d8ls8ljvajvna";
-      revision = "1";
-      editedCabalFile = "0m69cvm2nzx2g0y8jfkymap529fm0k65wg82dycj0dc60p9fj66r";
+      revision = "2";
+      editedCabalFile = "0b557rrqki2rjb922s1yqkd7gbm9cjhzg52f0h5mp19v53nds3vz";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
       pname = "megaparsec-tests";
       version = "9.7.0";
       sha256 = "17jwz62f8lnrfmmfrsv1jcvn9wmpk4jlhmxjwk5qqx2iyijnrpb1";
+      revision = "1";
+      editedCabalFile = "108nv4c045xg3ks0v7c0figqrl7v90l87cahhmn5mc24vdpxhkrj";
       libraryHaskellDepends = [
         base
         bytestring
···
     }
   ) { };
 
-  "mem-info_0_4_1_0" = callPackage (
+  "mem-info_0_4_1_1" = callPackage (
     {
       mkDerivation,
       base,
···
     }:
     mkDerivation {
       pname = "mem-info";
-      version = "0.4.1.0";
-      sha256 = "0613k5qil4j1cfh335gyjf708md9cicbhm5xji7v8fzfmzsqxx1c";
+      version = "0.4.1.1";
+      sha256 = "10b3lmqh4nbyfpglgjb04xx0wd65vxfyc53m3l89linhvij61kmc";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
       pname = "microaeson";
       version = "0.1.0.2";
       sha256 = "025vnzs4j2nmkin5x8h5hbrj25spamqppg68wfqlnbrr1519lxfz";
-      revision = "1";
-      editedCabalFile = "1faq5mjz8jy739lbaizy1v5wrvkxsjzp6lhjmb06a3yv71h6m594";
+      revision = "2";
+      editedCabalFile = "04kq6sh1fl0xgkai0d055s7hkwf21vlksgqizh4xfvsb2xbakgiz";
       libraryHaskellDepends = [
         array
         base
···
       pname = "midi-music-box";
       version = "0.0.1.2";
       sha256 = "0rnjwis6y0lnyfjxnxqk3zsh78ylccq5v21avb97vybmj0pld1l9";
-      revision = "6";
-      editedCabalFile = "0b8039mw0wacjxxwx1ws2wczwdgxm4iiymdkykk7lp5ii75vvfww";
+      revision = "7";
+      editedCabalFile = "02xnldnw5ci6chpbj18mz82m8pp582zpy9z3bdy5yi7q7k415h0p";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
···
       pname = "midimory";
       version = "0.0.2.3";
       sha256 = "1k9pm0ai9i66c7l4px84cf5db3nsq5ab9ndplcyfh05snbdy70vz";
+      revision = "1";
+      editedCabalFile = "1sq7xipm92nfcbf6cad1yclzl36gghqlnnvs1r0579njjcchbgl5";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
···
       directory,
       filepath,
       hspec,
+      hspec-discover,
       http-client,
       http-date,
       http-types,
+      http2,
       network,
       old-locale,
       parsec,
···
     }:
     mkDerivation {
       pname = "mighttpd2";
-      version = "4.0.8";
-      sha256 = "0yqj3m7y493bzjmx1ycyid4s40h11l46w8lv1783drlw7wpakmya";
+      version = "4.0.9";
+      sha256 = "1qd43hlyvhnslxrvy4h0rj5qs6nbxnz8d23myqjspa9jl8rzb1bg";
       isLibrary = true;
       isExecutable = true;
       enableSeparateDataOutput = true;
···
         filepath
         http-date
         http-types
+        http2
         network
         parsec
         resourcet
···
         hspec
         http-client
       ];
+      testToolDepends = [ hspec-discover ];
       description = "High performance web server on WAI/warp";
       license = lib.licenses.bsd3;
       hydraPlatforms = lib.platforms.none;
···
     }:
     mkDerivation {
       pname = "minici";
-      version = "0.1.7";
-      sha256 = "0kwlgsjn7ikddk59bksb4abb0dc262a61mh4694p8s7x3psjris1";
+      version = "0.1.8";
+      sha256 = "0fady7w644gcrjd9yy7ngbi1dj2rp87lnzmxjr307w8kdb2aqdcj";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
···
       bytestring,
       concurrent-output,
       containers,
+      data-default,
       directory,
+      extra,
       filepath,
       filepattern,
-      ghc-prim,
       hspec,
       HsYAML,
+      MissingH,
       monad-parallel,
       process,
       SafeSemaphore,
       text,
+      text-builder-linear,
+      text-display,
       time,
       unix-compat,
-      unordered-containers,
       xdg-basedir,
     }:
     mkDerivation {
       pname = "miv";
-      version = "0.4.8";
-      sha256 = "1b3lplsnjf992rvidj48swccl8f8aqdik1sf481g7vwv2mz7d7m6";
+      version = "0.4.9";
+      sha256 = "1z3hwvg3jb82hf6hrlzl9vv1fqy1llgfj2rps27fbccz50i6v6ps";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
···
         bytestring
         concurrent-output
         containers
+        data-default
         directory
+        extra
         filepath
         filepattern
-        ghc-prim
         HsYAML
+        MissingH
         monad-parallel
         process
         SafeSemaphore
         text
+        text-builder-linear
+        text-display
         time
         unix-compat
-        unordered-containers
         xdg-basedir
       ];
       testHaskellDepends = [
         base
-        bytestring
-        containers
-        directory
-        ghc-prim
         hspec
-        HsYAML
-        monad-parallel
-        process
-        text
-        time
-        unordered-containers
       ];
       description = "Vim plugin manager written in Haskell";
       license = lib.licenses.mit;
···
       pname = "mmark-cli";
       version = "0.0.5.2";
       sha256 = "05i8wy3zls6fp1qmdz4ayydhgvq6jnhh2rj4r3frvp8nl70kkv26";
+      revision = "1";
+      editedCabalFile = "1p1ia1vxaa8qpbc4hclmavjnk8xj1b6qqzprq3gysy5l38s340aj";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
···
     }:
     mkDerivation {
       pname = "mmorph";
-      version = "1.2.0";
-      sha256 = "1022d8mm523dihkf85mqsqxpm9rnyicmv91c8rm4csv7xdc80cv1";
-      revision = "3";
-      editedCabalFile = "1582vcpjiyimb1vwnhgq8gp805iziwa8sivv2frir0cgq4z236yz";
+      version = "1.2.1";
+      sha256 = "1rjclyxyr5ajnpmkrlwap77h5fmdwys8bpwfj0n87v33hh1dcn8f";
       libraryHaskellDepends = [
         base
         mtl
···
     }:
     mkDerivation {
       pname = "monoidmap-aeson";
-      version = "0.0.0.5";
-      sha256 = "1m5pw94lrybjvf6hnfzl0v974fg2i53r5s8aw4qv9cbxizhh68ag";
+      version = "0.0.0.6";
+      sha256 = "0fd2cd4a8ncb3hibfknq0sf7j8nmmisr4bwc42yp6l0ddfsdbbd6";
       libraryHaskellDepends = [
         aeson
         base
···
     }:
     mkDerivation {
       pname = "monoidmap-examples";
-      version = "0.0.0.0";
-      sha256 = "1pqswi2r41r7hrrzwg4ygj67jsgmmsyyqyn7n47lnf4q331l1hv6";
+      version = "0.0.0.1";
+      sha256 = "1q7vssgknncjq1f187zvg6630r6kk12mdmq1985skm98ynl1n8wx";
       libraryHaskellDepends = [
         base
         containers
···
     }:
     mkDerivation {
       pname = "monoidmap-internal";
-      version = "0.0.0.0";
-      sha256 = "0di3b4x4f5mkmi71rpfa0zv5048z4hkzzdy1zw1qla46sn1646jg";
+      version = "0.0.0.1";
+      sha256 = "1khqa1pnxfngbay9gzjvls7hy7pddr8pd32c0z1na9mj8q8hz63c";
       libraryHaskellDepends = [
         base
         containers
···
       ];
       description = "Internal support for monoidmap";
       license = lib.licenses.asl20;
-      hydraPlatforms = lib.platforms.none;
-      broken = true;
     }
   ) { };
 
···
     }:
     mkDerivation {
       pname = "monoidmap-quickcheck";
-      version = "0.0.0.2";
-      sha256 = "0sqgd61a6abwr7rdiqm25cs2kl496v8ji0rax9dw0sdc3zh6m4j2";
+      version = "0.0.0.3";
+      sha256 = "065b7rk64yg89ll546n338jny9d3y0pmp2alwf5z7z5n25nf40cq";
       libraryHaskellDepends = [
         base
         containers
···
       badPlatforms = lib.platforms.darwin;
       hydraPlatforms = lib.platforms.none;
       mainProgram = "mptcp-pm";
+      broken = true;
     }
   ) { };
 
···
       pname = "msgpack";
       version = "1.0.1.0";
       sha256 = "1ljb9rdhdbxqs32brrwd42c8v3z7yrl6pr4mzmid1rfqdipard77";
-      revision = "2";
-      editedCabalFile = "07m8xrwfxp0p6dgg7bz1vwsypcwi9ix84bxva462261ncyaayd9p";
+      revision = "3";
+      editedCabalFile = "10qhv3v617zq8r3b08mqb3h1h6vzmvyq2rps6kdvs8gvqb5mkiss";
       libraryHaskellDepends = [
         base
         binary
···
       ];
       description = "A Haskell implementation of MessagePack";
       license = lib.licenses.bsd3;
-      hydraPlatforms = lib.platforms.none;
-      broken = true;
     }
   ) { };
 
···
       description = "Aeson adapter for MessagePack";
       license = lib.licenses.bsd3;
       hydraPlatforms = lib.platforms.none;
+      broken = true;
     }
   ) { };
 
···
       description = "A MessagePack-RPC Implementation";
       license = lib.licenses.bsd3;
       hydraPlatforms = lib.platforms.none;
+      broken = true;
     }
   ) { };
 
···
       pname = "multistate";
       version = "0.8.0.4";
       sha256 = "0y42c21ha0chqhrn40a4bikdbirsw7aqg4i866frpagz1ivr915q";
-      revision = "1";
-      editedCabalFile = "0m1wv2yv1isw1qkzfa2fgjx0md7irp9djcgy16739wvl8hnj1ciq";
+      revision = "2";
+      editedCabalFile = "1gdxarys4x4bws8d8smw219z7zrjbyl8k7d2fqv1ray1x52zxr3n";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
     }:
     mkDerivation {
       pname = "natural-arithmetic";
-      version = "0.2.2.0";
-      sha256 = "1ps6lcp0s3izphp3hx73p2v91cs1r2iz4rh1hwrmxd9pfar815ya";
+      version = "0.2.3.0";
+      sha256 = "1lf7v804lnvb63mw232qkyqrhdrbk37s6icx4wysiw8z90v6c10j";
       libraryHaskellDepends = [
         base
         unlifted
···
     }:
     mkDerivation {
       pname = "network-protocol-xmpp";
-      version = "0.5.1";
-      sha256 = "1fd8rq235lbpkdlashsqk01ymxbbh6q1hng706h5lw0v49wpvd7i";
+      version = "0.5.2";
+      sha256 = "0jm46pkhys8a2rvyss8dv1b61im56il0kkwswg521xv6mfqk1csm";
       libraryHaskellDepends = [
         base
         bytestring
···
         }:
         mkDerivation {
           pname = "notmuch";
-          version = "0.3.1.1";
-          sha256 = "18z8pbqagdyd5rqv42i6060vv40gv84dx3sf52vvrayga19k1ydw";
+          version = "0.3.2";
+          sha256 = "0yx7lkncs7xn3w3sdplwj7ghsblm9q4w97af9vw9rszhpd50b1cd";
           isLibrary = true;
           isExecutable = true;
           libraryHaskellDepends = [
···
           ];
           libraryToolDepends = [ c2hs ];
           description = "Haskell binding to Notmuch, the mail indexer";
-          license = lib.licenses.gpl3Only;
+          license = lib.licenses.gpl3Plus;
         }
       )
       {
···
     }
   ) { };
 
+  "numhask_0_13_0_0" = callPackage (
+    {
+      mkDerivation,
+      base,
+      doctest-parallel,
+      QuickCheck,
+    }:
+    mkDerivation {
+      pname = "numhask";
+      version = "0.13.0.0";
+      sha256 = "13174w30c9pmmfjc5gn9yfzvlyr6ljm0diyh0q0gysiq0wspx2ni";
+      libraryHaskellDepends = [ base ];
+      testHaskellDepends = [
+        base
+        doctest-parallel
+        QuickCheck
+      ];
+      description = "A numeric class hierarchy";
+      license = lib.licenses.bsd3;
+      hydraPlatforms = lib.platforms.none;
+    }
+  ) { };
+
   "numhask-array" = callPackage (
     {
       mkDerivation,
···
       pname = "ods2csv";
       version = "0.1.0.1";
       sha256 = "1a1qrknqh24hgv5v46vnxnaqcnx3n92rcwgh3b6h6k27kassx4xa";
+      revision = "1";
+      editedCabalFile = "0sb7k4sw64ld5jdsx1g522q911d4z9c92mh0vfjb0p7h4r1h71hm";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
···
       pname = "oidc-client";
       version = "0.8.0.0";
       sha256 = "0fmffnf6gg99d15nn84ih36lr7qasa1zfkb62sgb0icik8dwv83m";
+      revision = "1";
+      editedCabalFile = "1zaaldni8i7kdxpmbpd2nlva0ygycn9955yh9qvcm08cd2wvq15d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
       ];
       description = "OpenID Connect 1.0 library for RP";
       license = lib.licenses.mit;
-      hydraPlatforms = lib.platforms.none;
-      broken = true;
     }
   ) { };
 
···
     }
   ) { };
 
+  "ollama-haskell_0_2_0_0" = callPackage (
+    {
+      mkDerivation,
+      aeson,
+      base,
+      base64-bytestring,
+      bytestring,
+      containers,
+      directory,
+      filepath,
+      http-client,
+      http-client-tls,
+      http-types,
+      mtl,
+      scientific,
+      silently,
+      stm,
+      tasty,
+      tasty-hunit,
+      text,
+      time,
+    }:
+    mkDerivation {
+      pname = "ollama-haskell";
+      version = "0.2.0.0";
+      sha256 = "00vgffjzhyc060x59gxrqazzclkm3bspmvzva5kc2c2319l93wy8";
+      libraryHaskellDepends = [
+        aeson
+        base
+        base64-bytestring
+        bytestring
+        containers
+        directory
+        filepath
+        http-client
+        http-client-tls
+        http-types
+        mtl
+        stm
+        text
+        time
+      ];
+      testHaskellDepends = [
+        aeson
+        base
+        base64-bytestring
+        bytestring
+        containers
+        directory
+        filepath
+        http-client
+        http-client-tls
+        http-types
+        mtl
+        scientific
+        silently
+        stm
+        tasty
+        tasty-hunit
+        text
+        time
+      ];
+      description = "Haskell client for ollama";
+      license = lib.licenses.mit;
+      hydraPlatforms = lib.platforms.none;
+      broken = true;
+    }
+  ) { };
+
   "ollama-holes-plugin" = callPackage (
     {
       mkDerivation,
···
     }:
     mkDerivation {
       pname = "opencascade-hs";
-      version = "0.5.0.1";
-      sha256 = "1a397mxry4k5hq6gwnjn1lc3q8fz5pg7ff6imr1fwyf9b6rhls9j";
+      version = "0.5.1.0";
+      sha256 = "12c77xnh0h0h2sw23q5v891iddnmsq5j1853b90wypm6p18kpnsw";
       libraryHaskellDepends = [
         base
         resourcet
···
     }:
     mkDerivation {
       pname = "opencc";
-      version = "0.1.1.0";
-      sha256 = "06jz04352bgqnfvzds75n65x352x07ffj8aan01q6m2mjs3xidfa";
+      version = "0.1.2.0";
+      sha256 = "0vl57aglagq0zpxld3hhp4sda783m5sncdxwyxyjypl433yjyzgq";
       libraryHaskellDepends = [
         base
         bytestring
···
     }:
     mkDerivation {
       pname = "opentelemetry-plugin";
-      version = "1.1.1";
-      sha256 = "1sp6bzy0is704x18522b2kmbbsw3nbfz9x69rvidmpz0x52cpwbg";
+      version = "1.1.2";
+      sha256 = "12lm7b4kjqlvc3j2i4q7xqavr0d98wazfaqyvph20afvfq90zwf8";
       libraryHaskellDepends = [
         base
         bytestring
···
       ];
       description = "GHC plugin for open telemetry";
       license = lib.licenses.bsd3;
-      hydraPlatforms = lib.platforms.none;
-      broken = true;
     }
   ) { };
 
···
     }
   ) { };
 
-  "optima_0_4_0_6" = callPackage (
+  "optima_0_4_0_7" = callPackage (
     {
       mkDerivation,
       attoparsec,
···
     }:
     mkDerivation {
       pname = "optima";
-      version = "0.4.0.6";
-      sha256 = "06wy9d3zidly70d3n9bbxfl9yx2hx03xw8k9p8vhjb0xj526vpgk";
+      version = "0.4.0.7";
+      sha256 = "0cqy4ifddmyjmp8hj5ksi7f1b2bvxlwljm6q2cjxfpp3ig6alzr6";
       libraryHaskellDepends = [
         attoparsec
         attoparsec-data
···
     }
   ) { };
 
+  "optparse-applicative_0_19_0_0" = callPackage (
+    {
+      mkDerivation,
+      base,
+      prettyprinter,
+      prettyprinter-ansi-terminal,
+      process,
+      QuickCheck,
+      text,
+      transformers,
+    }:
+    mkDerivation {
+      pname = "optparse-applicative";
+      version = "0.19.0.0";
+      sha256 = "0waq6i6jk0zj9vb00m62khfcm9xdnz3afzs471vhqwr1v3psw5ng";
+      libraryHaskellDepends = [
+        base
+        prettyprinter
+        prettyprinter-ansi-terminal
+        process
+        text
+        transformers
+      ];
+      testHaskellDepends = [
+        base
+        QuickCheck
+      ];
+      description = "Utilities and combinators for parsing command line options";
+      license = lib.licenses.bsd3;
+      hydraPlatforms = lib.platforms.none;
+    }
+  ) { };
+
   "optparse-applicative-cmdline-util" = callPackage (
     {
       mkDerivation,
···
       pname = "os-string";
       version = "2.0.7";
       sha256 = "186b4swiga0nk05np512iw50pz9w88l3bqz47pr241997bykb71k";
+      revision = "1";
+      editedCabalFile = "0504jf7wa84z3a8gd60cx7df6232xq31wqc532jcxrxh3hl0hm6b";
       libraryHaskellDepends = [
         base
         bytestring
···
     }:
     mkDerivation {
       pname = "oughta";
-      version = "0.2.0.0";
-      sha256 = "1ls97l94jpv5mlmiqccm4z8p80vnk8z0mv2937zcl1c7bx67ra3j";
+      version = "0.3.0.0";
+      sha256 = "1153jnvscsc3i8zz0sih7vy42vlsgynw0hvjvh0zxxqcyx4cc27i";
       libraryHaskellDepends = [
         base
         bytestring
···
     }
   ) { };
 
+  "ox-arrays" = callPackage (
+    {
+      mkDerivation,
+      base,
+      bytestring,
+      deepseq,
+      ghc-typelits-knownnat,
+      ghc-typelits-natnormalise,
+      hedgehog,
+      hmatrix,
+      orthotope,
+      random,
+      tasty,
+      tasty-bench,
+      tasty-hedgehog,
+      template-haskell,
+      vector,
+    }:
+    mkDerivation {
+      pname = "ox-arrays";
+      version = "0.1.0.0";
+      sha256 = "0kix255p5n1dg9y3s00il3x4s1r4d3fn1v6ljm6zgy8j40lg1nzh";
+      libraryHaskellDepends = [
+        base
+        deepseq
+        ghc-typelits-knownnat
+        ghc-typelits-natnormalise
+        orthotope
+        template-haskell
+        vector
+      ];
+      testHaskellDepends = [
+        base
+        bytestring
+        ghc-typelits-knownnat
+        ghc-typelits-natnormalise
+        hedgehog
+        orthotope
+        random
+        tasty
+        tasty-hedgehog
+        vector
+      ];
+      benchmarkHaskellDepends = [
+        base
+        hmatrix
+        orthotope
+        tasty-bench
+        vector
+      ];
+      doHaddock = false;
+      description = "An efficient CPU-based multidimensional array (tensor) library";
+      license = lib.licenses.bsd3;
+      hydraPlatforms = lib.platforms.none;
+      broken = true;
+    }
+  ) { };
+
   "pa-error-tree" = callPackage (
     {
       mkDerivation,
···
       extra,
       filepath,
       hspec,
+      linear-base,
       listsafe,
       mtl,
       optparse-applicative,
···
     }:
     mkDerivation {
       pname = "packed-data";
-      version = "0.1.0.3";
-      sha256 = "1h0aqcpfygj29mij5ln7zaypf4a6v37ycnlhh5shb7pvh0nfajn3";
+      version = "0.2.0.0";
+      sha256 = "07hkm3a98aadihm3zvvq299xmswf8xzdyzx06qcs7nbdqwkqx2zk";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base
         bytestring
-        bytestring-strict-builder
         deepseq
         extra
+        linear-base
         mtl
         template-haskell
       ];
···
         vector
       ];
       license = lib.licenses.bsd3;
+      hydraPlatforms = lib.platforms.none;
       mainProgram = "examples";
+      broken = true;
     }
   ) { };
 
···
   "palindromes" = callPackage (
     {
       mkDerivation,
-      array,
       base,
-      bytestring,
-      containers,
+      conduit,
+      criterion,
+      deepseq,
+      directory,
+      filepath,
+      HUnit,
+      levenshtein,
+      QuickCheck,
+      strict,
+      vector,
     }:
     mkDerivation {
       pname = "palindromes";
-      version = "0.4";
-      sha256 = "1k0kvd8p1ivwmpmf8khwmb4vyk8z0di74xn5840zy9jhf1cwx4kn";
+      version = "1.1.0.0";
+      sha256 = "1dfq0b2f11xwbdn9hyrrr4ywzz415nb32n4yfjrqf35myaqdbfcz";
       isLibrary = true;
       isExecutable = true;
+      libraryHaskellDepends = [
+        base
+        conduit
+        vector
+      ];
       executableHaskellDepends = [
-        array
         base
-        bytestring
-        containers
+        directory
+      ];
+      testHaskellDepends = [
+        base
+        HUnit
+        levenshtein
+        QuickCheck
+        vector
+      ];
+      benchmarkHaskellDepends = [
+        base
+        criterion
+        deepseq
+        directory
+        filepath
+        strict
       ];
       description = "Finding palindromes in strings";
       license = lib.licenses.bsd3;
···
     }:
     mkDerivation {
       pname = "pandoc-lua-marshal";
-      version = "0.3.0";
-      sha256 = "0d8vfbmgd107b9lq9dq0b39v3dhznqh11j0ci0i8hsb7g3dkks5g";
+      version = "0.3.1";
+      sha256 = "0869amr9w5s90dha694vy6rwfni7p1wp9dyjyyk2jvh8h22gcpr0";
       libraryHaskellDepends = [
         aeson
         base
···
       pname = "pandoc-plot";
       version = "1.9.1";
       sha256 = "0d6lknjnlzg4a7sx311kpdi94yq7fp19lhvwbsf7rvc3ykx0hjm3";
+      revision = "1";
+      editedCabalFile = "0ykgv0cxiwvcx0pkkmx841cdwv2sas033mq928mg6dlcbvw32nx1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
       pname = "pandoc-types";
       version = "1.23.1";
       sha256 = "1hd18l1c5yh7x24gsligkbraadq12hn7mim16xyjnicdsa1s03xd";
-      revision = "2";
-      editedCabalFile = "1whymq4w5z08l5ng829kn8aslczda6svi6c6q72cnv200mlq7d1c";
+      revision = "3";
+      editedCabalFile = "0w2n4vzxs3jasrivaq49clxdlccnfv2gh4mkp8s7krxa1arambrz";
       libraryHaskellDepends = [
         aeson
         base
···
       pname = "parser-combinators-tests";
       version = "1.3.0";
       sha256 = "0sw6ws7za93y3lbmxp6jp1k17zi3wdg7698ab133kcw82f6mzba2";
-      revision = "1";
-      editedCabalFile = "0h6lwj0mdlirlwcadjvyblvgqg6yksw2bnp77qkjxm2kk3rw56hn";
+      revision = "2";
+      editedCabalFile = "1b038wk6b1kria8627qb0nfrz4v67j2yq5rx01m3vigfxf6h4422";
       isLibrary = false;
       isExecutable = false;
       testHaskellDepends = [
···
       exceptions,
       hspec,
       http-client,
+      http-client-tls,
       http-types,
       network-uri,
       text,
···
     }:
     mkDerivation {
       pname = "patrol";
-      version = "1.0.0.11";
-      sha256 = "0adci15r7mm0ddbg4zb10kngyl0c7ipaws7drd7idmzrb0gb82kd";
+      version = "1.0.1.0";
+      sha256 = "1yk90shi4idxdzf82mvxpsbgslx3psrwpxgwhnqpcl0kj4sdblf1";
+      libraryHaskellDepends = [
+        aeson
+        base
+        bytestring
+        case-insensitive
+        containers
+        exceptions
+        http-client
+        http-client-tls
+        http-types
+        network-uri
+        text
+        time
+        uuid
+      ];
+      testHaskellDepends = [
+        aeson
+        base
+        bytestring
+        case-insensitive
+        containers
+        hspec
+        http-client
+        http-types
+        network-uri
+        text
+        time
+        uuid
+      ];
+      description = "Sentry SDK";
+      license = lib.licenses.mit;
+    }
+  ) { };
+
+  "patrol_1_1_0_0" = callPackage (
+    {
+      mkDerivation,
+      aeson,
+      base,
+      bytestring,
+      case-insensitive,
+      containers,
+      exceptions,
+      hspec,
+      http-client,
+      http-client-tls,
+      http-types,
+      network-uri,
+      text,
+      time,
+      uuid,
+    }:
+    mkDerivation {
+      pname = "patrol";
+      version = "1.1.0.0";
+      sha256 = "0ijfflc9gv3ks5y3irng0mpsbcfwx41v59xgm8840310sz6kj4p1";
       libraryHaskellDepends = [
         aeson
         base
···
         containers
         exceptions
         http-client
+        http-client-tls
         http-types
         network-uri
         text
···
       ];
       description = "Sentry SDK";
       license = lib.licenses.mit;
+      hydraPlatforms = lib.platforms.none;
     }
   ) { };
 
···
       ];
       description = "Lazy Peano numbers including observable infinity value";
       license = lib.licenses.bsd3;
+    }
+  ) { };
+
+  "pear" = callPackage (
+    {
+      mkDerivation,
+      base,
+      doctest,
+      markdown-unlit,
+    }:
+    mkDerivation {
+      pname = "pear";
+      version = "1.0.0.1";
+      sha256 = "1svbmj1v7y3hq9f43x4szvs6h83zz085y1h5lncci4i4yx7qfrhj";
+      libraryHaskellDepends = [ base ];
+      testHaskellDepends = [
+        base
+        doctest
+      ];
+      testToolDepends = [ markdown-unlit ];
+      description = "Pear Trees: An indexed type using type-level binary numbers";
+      license = lib.licenses.mit;
     }
   ) { };
 
···
     }:
     mkDerivation {
       pname = "persistent-documentation";
-      version = "0.1.0.5";
-      sha256 = "032mfnsz5kpy1022gc2w9y0g4fjhqwq07zb2r8arjdhzzhbirwk2";
-      libraryHaskellDepends = [
-        base
-        containers
-        mtl
-        persistent
-        template-haskell
-        text
-      ];
-      testHaskellDepends = [
-        base
-        containers
-        hspec
-        hspec-discover
-        persistent
-        persistent-template
-        text
-      ];
-      testToolDepends = [ hspec-discover ];
-      description = "Documentation DSL for persistent entities";
-      license = lib.licenses.asl20;
-    }
-  ) { };
-
-  "persistent-documentation_0_1_0_6" = callPackage (
-    {
-      mkDerivation,
-      base,
-      containers,
-      hspec,
-      hspec-discover,
-      mtl,
-      persistent,
-      persistent-template,
-      template-haskell,
-      text,
-    }:
-    mkDerivation {
-      pname = "persistent-documentation";
       version = "0.1.0.6";
       sha256 = "1v07vhjmim4bycl7ygg2my3qwqqz36ajm8x8gwqh0g0i83sjh5ks";
       libraryHaskellDepends = [
···
       testToolDepends = [ hspec-discover ];
       description = "Documentation DSL for persistent entities";
       license = lib.licenses.asl20;
-      hydraPlatforms = lib.platforms.none;
     }
   ) { };
 
···
     }
   ) { };
 
+  "persistent-postgresql_2_13_7_0" = callPackage (
+    {
+      mkDerivation,
+      aeson,
+      attoparsec,
+      base,
+      blaze-builder,
+      bytestring,
+      conduit,
+      containers,
+      fast-logger,
+      hspec,
+      hspec-expectations,
+      hspec-expectations-lifted,
+      http-api-data,
+      HUnit,
+      monad-logger,
+      mtl,
+      path-pieces,
+      persistent,
+      persistent-qq,
+      persistent-test,
+      postgresql-libpq,
+      postgresql-simple,
+      QuickCheck,
+      quickcheck-instances,
+      resource-pool,
+      resourcet,
+      string-conversions,
+      text,
+      time,
+      transformers,
+      unliftio,
+      unliftio-core,
+      unordered-containers,
+      vault,
+      vector,
+    }:
+    mkDerivation {
+      pname = "persistent-postgresql";
+      version = "2.13.7.0";
+      sha256 = "1774fh28jls2r692164ln66ipa6gl3sqj8pb04nf3sl1m498qjd7";
+      isLibrary = true;
+      isExecutable = true;
+      libraryHaskellDepends = [
+        aeson
+        attoparsec
+        base
+        blaze-builder
+        bytestring
+        conduit
+        containers
+        monad-logger
+        mtl
+        persistent
+        postgresql-libpq
+        postgresql-simple
+        resource-pool
+        resourcet
+        string-conversions
+        text
+        time
+        transformers
+        unliftio-core
+        vault
+      ];
+      testHaskellDepends = [
+        aeson
+        base
+        bytestring
+        containers
+        fast-logger
+        hspec
+        hspec-expectations
+        hspec-expectations-lifted
+        http-api-data
+        HUnit
+        monad-logger
+        path-pieces
+        persistent
+        persistent-qq
+        persistent-test
+        QuickCheck
+        quickcheck-instances
+        resourcet
+        text
+        time
+        transformers
+        unliftio
+        unliftio-core
+        unordered-containers
+        vector
+      ];
+      description = "Backend for the persistent library using postgresql";
+      license = lib.licenses.mit;
+      hydraPlatforms = lib.platforms.none;
+    }
+  ) { };
+
   "persistent-postgresql-streaming" = callPackage (
     {
       mkDerivation,
···
     }
   ) { };
 
-  "persistent-test_2_13_1_3" = callPackage (
+  "persistent-test" = callPackage (
     {
       mkDerivation,
       aeson,
···
       ];
       description = "Tests for Persistent";
       license = lib.licenses.mit;
-      hydraPlatforms = lib.platforms.none;
     }
   ) { };
 
-  "persistent-test" = callPackage (
+  "persistent-test_2_13_1_4" = callPackage (
     {
       mkDerivation,
       aeson,
···
       pname = "persistent-test";
       version = "2.13.1.4";
       sha256 = "1k2wq6ag4jvqr1krdjfx84mmx0mg09hy38w569zxwdrd03ffcjpy";
+      revision = "1";
+      editedCabalFile = "1kzqhvs4h8xpx2x153gh64rc006mvjxv6fzsyxvnfknmqcx8xn19";
       libraryHaskellDepends = [
         aeson
         base
···
       ];
       description = "Tests for Persistent";
       license = lib.licenses.mit;
+      hydraPlatforms = lib.platforms.none;
     }
   ) { };
 
···
       pname = "persistent-typed-db";
       version = "0.1.0.7";
       sha256 = "0fkshbf35mnlx4aqkij0lzzmpfxw34zkwgq8s2lm3rrrqw7gw59l";
-      revision = "1";
-      editedCabalFile = "19l1nfd82l8lsjsi00virsapwlnany5cdwgzw9hmm9bkwxfsk9v8";
+      revision = "2";
+      editedCabalFile = "0m5ajvfcj10k1mnlwdyd1n9s3py70g4sinzh0gkvch9q1bl6qiwz";
       libraryHaskellDepends = [
         aeson
         base
···
       bytestring,
       containers,
       directory,
+      file-embed,
       filepath,
       hspec,
       hspec-core,
···
       megaparsec,
       optparse-applicative,
       prettyprinter,
+      process,
+      random,
       scientific,
       silently,
       text,
+      time,
       utf8-string,
+      vector,
+      xml-conduit,
       yaml,
     }:
     mkDerivation {
       pname = "phino";
-      version = "0.0.0.1";
-      sha256 = "1sl4iqrcmmjn2gc294rz4yfj5k0hd7ngl9ax57k22h2qac90rrkc";
+      version = "0.0.0.14";
+      sha256 = "1nl2n0y636bdppxc29p4zyxlyra2zjiy3a1s6xw2yin64q3gqrim";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
         bytestring
         containers
         directory
+        file-embed
         filepath
         megaparsec
         optparse-applicative
         prettyprinter
+        random
         scientific
         text
+        time
         utf8-string
+        vector
+        xml-conduit
         yaml
       ];
       executableHaskellDepends = [ base ];
···
         megaparsec
         optparse-applicative
         prettyprinter
+        process
         silently
         text
+        xml-conduit
         yaml
       ];
       testToolDepends = [ hspec-discover ];
···
       pname = "pipes-safe";
       version = "2.3.5";
       sha256 = "13npagy597g6zfr2f3vj4a98h2ssg2ps7lmdzrgdsvm8m28x3cph";
-      revision = "3";
-      editedCabalFile = "1wic8km3c17g2xrmxd4qj5qmppb76k7srxrgj8jg1vs6g2l7v6cs";
+      revision = "4";
+      editedCabalFile = "1x0p9fiilz21ck5n52lg2p17qi7n0mkk566qzzwd4jnvhbcsb8jf";
       libraryHaskellDepends = [
         base
         containers
···
     }
   ) { };
 
+  "pms-application-service" = callPackage (
+    {
+      mkDerivation,
+      aeson,
+      async,
+      async-pool,
+      base,
+      data-default,
+      fast-logger,
+      hspec,
+      hspec-discover,
+      lens,
+      monad-logger,
+      mtl,
+      pms-domain-model,
+      safe-exceptions,
+      stm,
+      text,
+      unix,
+      yaml,
+    }:
+    mkDerivation {
+      pname = "pms-application-service";
+      version = "0.0.4.0";
+      sha256 = "0a91pa5rs2vplixky8bap4gl8i8mm3j7454w7s4pihyf4h7wfhpl";
+      libraryHaskellDepends = [
+        aeson
+        async
+        async-pool
+        base
+        data-default
+        fast-logger
+        lens
+        monad-logger
+        mtl
+        pms-domain-model
+        safe-exceptions
+        text
+        yaml
+      ];
+      testHaskellDepends = [
+        async
+        base
+        data-default
+        hspec
+        hspec-discover
+        lens
+        monad-logger
+        pms-domain-model
+        stm
+        unix
+      ];
+      testToolDepends = [ hspec-discover ];
+      description = "pms-application-service";
+      license = lib.licenses.asl20;
+      hydraPlatforms = lib.platforms.none;
+    }
+  ) { };
+
+  "pms-domain-model" = callPackage (
+    {
+      mkDerivation,
+      aeson,
+      async,
+      base,
+      bytestring,
+      data-default,
+      fast-logger,
+      filepath,
+      hspec,
+      hspec-discover,
+      lens,
+      monad-logger,
+      mtl,
+      safe-exceptions,
+      stm,
+      strip-ansi-escape,
+      text,
+      transformers,
+      unix,
+    }:
+    mkDerivation {
+      pname = "pms-domain-model";
+      version = "0.0.5.0";
+      sha256 = "0z0a04j6x4jrq6xpfdd6jnbq7q7p71y51gar6i6g0apfliiydq9w";
+      libraryHaskellDepends = [
+        aeson
+        base
+        bytestring
+        data-default
+        fast-logger
+        filepath
+        lens
+        monad-logger
+        mtl
+        safe-exceptions
+        stm
+        strip-ansi-escape
+        text
+        transformers
+      ];
+      testHaskellDepends = [
+        aeson
+        async
+        base
+        data-default
+        hspec
+        hspec-discover
+        lens
+        monad-logger
+        stm
+        unix
+      ];
+      testToolDepends = [ hspec-discover ];
+      description = "pms-domain-model";
+      license = lib.licenses.asl20;
+      hydraPlatforms = lib.platforms.none;
+      broken = true;
+    }
+  ) { };
+
+  "pms-domain-service" = callPackage (
+    {
+      mkDerivation,
+      aeson,
+      async,
+      base,
+      bytestring,
+      conduit,
+      data-default,
+      directory,
+      fast-logger,
+      filepath,
+      hspec,
+      hspec-discover,
+      lens,
+      monad-logger,
+      mtl,
+      mustache,
+      network-uri,
+      pms-domain-model,
+      safe-exceptions,
+      stm,
+      template-haskell,
+      text,
+      transformers,
+      unix,
+      unordered-containers,
+    }:
+    mkDerivation {
+      pname = "pms-domain-service";
+      version = "0.0.4.0";
+      sha256 = "1akacdrh2ngyvik46sjhag8kp9hyyr7rv9grswx7i3ngy6pk64yn";
+      libraryHaskellDepends = [
+        aeson
+        base
+        bytestring
+        conduit
+        data-default
+        directory
+        fast-logger
+        filepath
+        lens
+        monad-logger
+        mtl
+        mustache
+        network-uri
+        pms-domain-model
+        safe-exceptions
+        stm
+        template-haskell
+        text
+        transformers
+        unordered-containers
+      ];
+      testHaskellDepends = [
+        async
+        base
+        data-default
+        hspec
+        hspec-discover
+        lens
+        monad-logger
+        pms-domain-model
+        stm
+        unix
+      ];
+      testToolDepends = [ hspec-discover ];
+      description = "pms-domain-service";
+      license = lib.licenses.asl20;
+      hydraPlatforms = lib.platforms.none;
+    }
+  ) { };
+
+  "pms-infra-cmdrun" = callPackage (
+    {
+      mkDerivation,
+      aeson,
+      async,
+      base,
+      bytestring,
+      conduit,
+      data-default,
+      directory,
+      fast-logger,
+      filepath,
+      hspec,
+      hspec-discover,
+      lens,
+      monad-logger,
+      mtl,
+      pms-domain-model,
+      process,
+      safe-exceptions,
+      stm,
+      text,
+      transformers,
+      unix,
+    }:
+    mkDerivation {
+      pname = "pms-infra-cmdrun";
+      version = "0.0.2.0";
+      sha256 = "0c4jhci5im04ks49if7ncbqipbln2ixw2f262qw64ir5a5hdygzy";
+      libraryHaskellDepends = [
+        aeson
+        async
+        base
+        bytestring
+        conduit
+        data-default
+        directory
+        fast-logger
+        filepath
+        lens
+        monad-logger
+        mtl
+        pms-domain-model
+        process
+        safe-exceptions
+        stm
+        text
+        transformers
+      ];
+      testHaskellDepends = [
+        async
+        base
+        data-default
+        hspec
+        hspec-discover
+        lens
+        monad-logger
+        pms-domain-model
+        stm
+        unix
+      ];
+      testToolDepends = [ hspec-discover ];
+      description = "pms-infra-cmdrun";
+      license = lib.licenses.asl20;
+      hydraPlatforms = lib.platforms.none;
+    }
+  ) { };
+
+  "pms-infra-procspawn" = callPackage (
+    {
+      mkDerivation,
+      aeson,
+      async,
+      base,
+      bytestring,
+      conduit,
+      data-default,
+      directory,
+      fast-logger,
+      filepath,
+      hspec,
+      hspec-discover,
+      lens,
+      monad-logger,
+      mtl,
+      pms-domain-model,
+      process,
+      safe-exceptions,
+      stm,
+      text,
+      transformers,
+      unix,
+    }:
+    mkDerivation {
+      pname = "pms-infra-procspawn";
+      version = "0.0.1.0";
+      sha256 = "1wg0508h2svl0pk9yrwrnmssrqnm2vnlws9w9nm5ydqlqibdr282";
+      libraryHaskellDepends = [
+        aeson
+        async
+        base
+        bytestring
+        conduit
+        data-default
+        directory
+        fast-logger
+        filepath
+        lens
+        monad-logger
+        mtl
+        pms-domain-model
+        process
+        safe-exceptions
+        stm
+        text
+        transformers
+      ];
+      testHaskellDepends = [
+        async
+        base
+        data-default
+        hspec
+        hspec-discover
+        lens
+        monad-logger
+        pms-domain-model
+        stm
+        unix
+      ];
+      testToolDepends = [ hspec-discover ];
+      description = "pms-infra-procspawn";
+      license = lib.licenses.asl20;
+      hydraPlatforms = lib.platforms.none;
+    }
+  ) { };
+
+  "pms-infra-socket" = callPackage (
+    {
+      mkDerivation,
+      aeson,
+      async,
+      base,
+      base16-bytestring,
+      bytestring,
+      conduit,
+      data-default,
+      directory,
+      fast-logger,
+      filepath,
+      hspec,
+      hspec-discover,
+      lens,
+      monad-logger,
+      mtl,
+      network,
+      pms-domain-model,
+      process,
+      safe-exceptions,
+      stm,
+      text,
+      transformers,
+      unix,
+    }:
+    mkDerivation {
+      pname = "pms-infra-socket";
+      version = "0.0.1.0";
+      sha256 = "01iz8ws1wc04k52djy37wrlyrr8g33n7zvd03md06wjycahhrri5";
+      libraryHaskellDepends = [
+        aeson
+        async
+        base
+        base16-bytestring
+        bytestring
+        conduit
+        data-default
+        directory
+        fast-logger
+        filepath
+        lens
+        monad-logger
+        mtl
+        network
+        pms-domain-model
+        process
+        safe-exceptions
+        stm
+        text
+        transformers
+      ];
+      testHaskellDepends = [
+        async
+        base
+        data-default
+        hspec
+        hspec-discover
+        lens
+        monad-logger
+        pms-domain-model
+        stm
+        unix
+      ];
+      testToolDepends = [ hspec-discover ];
+      description = "pms-infra-socket";
+      license = lib.licenses.asl20;
+      hydraPlatforms = lib.platforms.none;
+    }
+  ) { };
+
+  "pms-infra-watch" = callPackage (
+    {
+      mkDerivation,
+      aeson,
+      async,
+      base,
+      bytestring,
+      conduit,
+      data-default,
+      directory,
+      fast-logger,
+      filepath,
+      fsnotify,
+      hspec,
+      hspec-discover,
+      lens,
+      monad-logger,
+      mtl,
+      pms-domain-model,
+      process,
+      safe-exceptions,
+      stm,
+      text,
+      transformers,
+      unix,
+    }:
+    mkDerivation {
+      pname = "pms-infra-watch";
+      version = "0.0.3.0";
+      sha256 = "0lwiydxf9p7pvri6s3p0wg0lya9imp6rpggb2mrpb49nqknnpxpx";
+      libraryHaskellDepends = [
+        aeson
+        async
+        base
+        bytestring
+        conduit
+        data-default
+        directory
+        fast-logger
+        filepath
+        fsnotify
+        lens
+        monad-logger
+        mtl
+        pms-domain-model
+        process
+        safe-exceptions
+        stm
+        text
+        transformers
+      ];
+      testHaskellDepends = [
+        async
+        base
+        data-default
+        hspec
+        hspec-discover
+        lens
+        monad-logger
+        pms-domain-model
+        stm
+        unix
+      ];
+      testToolDepends = [ hspec-discover ];
+      description = "pms-infra-watch";
+      license = lib.licenses.asl20;
+      hydraPlatforms = lib.platforms.none;
+    }
+  ) { };
+
+  "pms-infrastructure" = callPackage (
+    {
+      mkDerivation,
+      aeson,
+      async,
+      base,
+      bytestring,
+      conduit,
+      data-default,
+      directory,
+      fast-logger,
+      filepath,
+      hie-bios,
+      hspec,
+      hspec-discover,
+      lens,
+      monad-logger,
+      mtl,
+      pms-domain-model,
+      posix-pty,
+      process,
+      safe-exceptions,
+      stm,
+      strip-ansi-escape,
+      text,
+      transformers,
+      unix,
+    }:
+    mkDerivation {
+      pname = "pms-infrastructure";
+      version = "0.0.4.0";
+      sha256 = "1vawlgs6i1rpw2266zbzxwykjsf5p61w88vi2lyj69dgl3dd0kiz";
+      libraryHaskellDepends = [
+        aeson
+        async
+        base
+        bytestring
+        conduit
+        data-default
+        directory
+        fast-logger
+        filepath
+        hie-bios
+        lens
+        monad-logger
+        mtl
+        pms-domain-model
+        posix-pty
+        process
+        safe-exceptions
+        stm
+        strip-ansi-escape
+        text
+        transformers
+      ];
+      testHaskellDepends = [
+        async
+        base
+        data-default
+        hspec
+        hspec-discover
+        lens
+        monad-logger
+        pms-domain-model
+        stm
+        unix
+      ];
+      testToolDepends = [ hspec-discover ];
+      description = "pms-infrastructure";
+      license = lib.licenses.asl20;
+      hydraPlatforms = lib.platforms.none;
+    }
+  ) { };
+
+  "pms-ui-notification" = callPackage (
+    {
+      mkDerivation,
+      aeson,
+      async,
+      base,
+      bytestring,
+      conduit,
+      data-default,
+      fast-logger,
+      hspec,
+      hspec-discover,
+      lens,
+      monad-logger,
+      mtl,
+      pms-domain-model,
+      safe-exceptions,
+      stm,
+      text,
+      transformers,
+      unix,
+    }:
+    mkDerivation {
+      pname = "pms-ui-notification";
+      version = "0.0.3.0";
+      sha256 = "1fq1kasqmghbic59v815032spcl9wahm9wqjyjmg93di92xz8mm3";
+      libraryHaskellDepends = [
+        aeson
+        base
+        bytestring
+        conduit
+        data-default
+        fast-logger
+        lens
+        monad-logger
+        mtl
+        pms-domain-model
+        safe-exceptions
+        stm
+        text
+        transformers
+      ];
+      testHaskellDepends = [
+        async
+        base
+        data-default
+        hspec
+        hspec-discover
+        lens
+        monad-logger
+        pms-domain-model
+        stm
+        unix
+      ];
+      testToolDepends = [ hspec-discover ];
+      description = "pms-ui-notification";
+      license = lib.licenses.asl20;
+      hydraPlatforms = lib.platforms.none;
+    }
+  ) { };
+
+  "pms-ui-request" = callPackage (
+    {
+      mkDerivation,
+      aeson,
+      async,
+      base,
+      bytestring,
+      conduit,
+      data-default,
+      fast-logger,
+      hspec,
+      hspec-discover,
+      lens,
+      monad-logger,
+      mtl,
+      pms-domain-model,
+      safe-exceptions,
+      stm,
+      text,
+      transformers,
+      unix,
+    }:
+    mkDerivation {
+      pname = "pms-ui-request";
+      version = "0.0.4.0";
+      sha256 = "1yg42dy0jrv0xhz657kys41i0prr2xn417ji2p6wahgnlfkiy6am";
+      libraryHaskellDepends = [
+        aeson
+        base
+        bytestring
+        conduit
+        data-default
+        fast-logger
+        lens
+        monad-logger
+        mtl
+        pms-domain-model
+        safe-exceptions
+        stm
+        text
+        transformers
+      ];
+      testHaskellDepends = [
+        async
+        base
+        data-default
+        hspec
+        hspec-discover
+        lens
+        monad-logger
+        pms-domain-model
+        stm
+        unix
+      ];
+      testToolDepends = [ hspec-discover ];
+      description = "pms-ui-request";
+      license = lib.licenses.asl20;
+      hydraPlatforms = lib.platforms.none;
+    }
+  ) { };
+
+  "pms-ui-response" = callPackage (
+    {
+      mkDerivation,
+      aeson,
+      async,
+      base,
+      bytestring,
+      conduit,
+      data-default,
+      fast-logger,
+      hspec,
+      hspec-discover,
+      lens,
+      monad-logger,
+      mtl,
+      pms-domain-model,
+      safe-exceptions,
+      stm,
+      text,
+      transformers,
+      unix,
+    }:
+    mkDerivation {
+      pname = "pms-ui-response";
+      version = "0.0.4.0";
+      sha256 = "0045ddj3v34aycvnh72fvy9159iv4vad1jghd1ndslhphav1d91b";
+      libraryHaskellDepends = [
+        aeson
+        base
+        bytestring
+        conduit
+        data-default
+        fast-logger
+        lens
+        monad-logger
+        mtl
+        pms-domain-model
+        safe-exceptions
+        stm
+        text
+        transformers
+      ];
+      testHaskellDepends = [
+        async
+        base
+        data-default
+        hspec
+        hspec-discover
+        lens
+        monad-logger
+        pms-domain-model
+        stm
+        unix
+      ];
+      testToolDepends = [ hspec-discover ];
+      description = "pms-ui-response";
+      license = lib.licenses.asl20;
+      hydraPlatforms = lib.platforms.none;
+    }
+  ) { };
+
   "png-file" = callPackage (
     {
       mkDerivation,
···
       ];
       description = "Colog adapters for polysemy-log";
       license = "BSD-2-Clause-Patent";
-      hydraPlatforms = lib.platforms.none;
     }
   ) { };
 
···
   "poolboy" = callPackage (
     {
       mkDerivation,
-      async,
       base,
       hspec,
       hspec-core,
-      stm,
+      timeit,
       unliftio,
+      unordered-containers,
     }:
     mkDerivation {
       pname = "poolboy";
-      version = "0.2.2.0";
-      sha256 = "0d0lxqyf73w7nvgydbgv692zzc0zg2hk8sdd3lb6xyzdqkkd0vf3";
+      version = "0.4.0.1";
+      sha256 = "0ifdp2p2c257k52c9prm072c1gmfx55a40gaanba083viq6cxzal";
       libraryHaskellDepends = [
-        async
         base
-        stm
         unliftio
+        unordered-containers
       ];
       testHaskellDepends = [
         base
         hspec
         hspec-core
+        timeit
       ];
       description = "Simple work queue for bounded concurrency";
       license = lib.licenses.isc;
-      hydraPlatforms = lib.platforms.none;
-      broken = true;
     }
   ) { };
 
···
     { mkDerivation, base }:
     mkDerivation {
       pname = "positive-integer";
-      version = "0.1.0.0";
-      sha256 = "17vqxdmqbsp6366dipq5xdfb3aq5mrshlvkw8zv30byl7p6iaz51";
-      revision = "1";
-      editedCabalFile = "101bbp5zv7w5ldr7j2nxpmm21mpnpzz4knrcv5inqfs0k69w1z7c";
+      version = "0.1.2.0";
+      sha256 = "0m0l02v3ybsilkcvyc82ma57bbha4rhncsf5574b0m3zmxq17kaq";
       libraryHaskellDepends = [ base ];
       description = "Type of positive integers";
       license = lib.licenses.mit;
···
       base,
       bytestring,
       criterion,
+      deepseq,
       ppad-base16,
       ppad-chacha,
       ppad-poly1305,
···
     }:
     mkDerivation {
       pname = "ppad-aead";
-      version = "0.1.0";
-      sha256 = "1vvz39m852yp3j0mdm1mx3i5rgl78z0limlgm70al34gv1gxv3mh";
+      version = "0.2.0";
+      sha256 = "1s14bplwjfavg50xfyy65r2f8lg4man31jc83m3l32k6h4jvg983";
       libraryHaskellDepends = [
         base
         bytestring
···
         base
         bytestring
         criterion
+        deepseq
         ppad-base16
       ];
       description = "A pure AEAD-ChaCha20-Poly1305 construction";
···
     }:
     mkDerivation {
       pname = "ppad-base58";
-      version = "0.2.0";
-      sha256 = "1bn0fv1vmsc698lpl8x1brgi00bl9rcnh7r8v81rcxnjqf9xfdcb";
+      version = "0.2.1";
+      sha256 = "0s94985p1d1zh0ip404pgi12bj97naydr525i45aac64w8iis03y";
       libraryHaskellDepends = [
         base
         bytestring
···
     }:
     mkDerivation {
       pname = "ppad-bech32";
-      version = "0.2.2";
-      sha256 = "1bp4p6adfi7awy3k2fbi3akjqr5gyiijilgxg5r0hzpnzmzpxvzr";
+      version = "0.2.3";
+      sha256 = "0g8fk0bwx88zr4k4mijd8zn5jhi6gcsn6hvdp8jxb3r4a97a4yyv";
       libraryHaskellDepends = [
         base
         bytestring
···
     }:
     mkDerivation {
       pname = "ppad-bip32";
-      version = "0.1.1";
-      sha256 = "0q76ffxzrbr0fiv18ghgfjrv0y61nvsb6971pl49377c2835qa1l";
+      version = "0.2.0";
+      sha256 = "1h7i6km0ai3wvyrhfhl31gpaq21vcggrgk0gvr0cjhkmmscd3d5w";
       libraryHaskellDepends = [
         base
         bytestring
···
     }:
     mkDerivation {
       pname = "ppad-bip39";
-      version = "0.2.1";
-      sha256 = "1aqcjq1xika89qhxf54z25shg4kz8pmr6k70k48w7lyk85h3l97b";
+      version = "0.3.0";
+      sha256 = "18bshwr4hpnxk2v73kqxcsjbjffpss41whmd3scm20wq3al2xvva";
       libraryHaskellDepends = [
         base
         bytestring
···
       base,
       bytestring,
       criterion,
+      deepseq,
       ppad-base16,
       primitive,
       tasty,
···
     }:
     mkDerivation {
       pname = "ppad-chacha";
-      version = "0.1.0";
-      sha256 = "15idv1nrl2rl5rmx42dw1zwpdr7wvrr08j0k4vwy0s12cc40aka6";
+      version = "0.2.0";
+      sha256 = "1zqrg1af6rlflq74lamxd9f0p8sfhvmhjv3ii89mkckhizr8fqrc";
       libraryHaskellDepends = [
         base
         bytestring
···
         base
         bytestring
         criterion
+        deepseq
         ppad-base16
       ];
       description = "A pure ChaCha20 stream cipher";
···
     }:
     mkDerivation {
       pname = "ppad-hkdf";
-      version = "0.2.1";
-      sha256 = "1y5rmkaq8wgibsx6bvppbaqp13fb9al5yn4ni9x2ll685545m398";
+      version = "0.3.0";
+      sha256 = "194nwcjpdals55wf5khvl393d0q4fzdmx9424s9j2n0z70ry29pw";
       libraryHaskellDepends = [
         base
         bytestring
···
     }:
     mkDerivation {
       pname = "ppad-pbkdf";
-      version = "0.1.1";
-      sha256 = "05g3k4gyjkpn9k5fhz37lq10qgzlwayf4xiy5m4kjijv7l1wcxqp";
+      version = "0.2.0";
+      sha256 = "1zir2zm4bgimrgiv94dzqvn794dhwywl63b4im9sg9c61gh91r9m";
       libraryHaskellDepends = [
         base
         bytestring
···
     }:
     mkDerivation {
       pname = "ppad-poly1305";
-      version = "0.2.0";
-      sha256 = "1vv3ln9lzszx3h0dji4fqznh86qh40sl34msljddgyj3h709lzk6";
+      version = "0.3.0";
+      sha256 = "06db9qvi688nyhw8fqk8vqxhl6sddfkrg5ap15xd2lf75rl1v7kw";
       libraryHaskellDepends = [
         base
         bytestring
···
     }:
     mkDerivation {
       pname = "ppad-secp256k1";
-      version = "0.3.0";
-      sha256 = "1k2glxrrpgdngzy0j5mgbkh9a0a5b0cp5c1lmvaiwipik50n9rb3";
+      version = "0.4.0";
+      sha256 = "0wrmbz0s19g7b6qardn7isgmkrl5svw5nf360ksvhwagicv51g7l";
       libraryHaskellDepends = [
         base
         bytestring
···
       pname = "probability-polynomial";
       version = "1.0.0.1";
       sha256 = "1f06x4d2cbd9j7rxgwdpxn8ff8w32xag96qk86mwggnzlw091gib";
-      revision = "1";
-      editedCabalFile = "10avhbz8k3yg1hzjp5qbkhv3mmmhrvii5mpjcxqcw9pq635x0kc8";
+      revision = "2";
+      editedCabalFile = "039np4z6lzz81n90k1sqbr7n8bxfmh8v4xvbppzzpgk6kp5fxpfm";
       libraryHaskellDepends = [
         base
         containers
···
     }:
     mkDerivation {
       pname = "profunctors";
-      version = "5.6.2";
-      sha256 = "0an9v003ivxmjid0s51qznbjhd5fsa1dkcfsrhxllnjja1xmv5b5";
-      revision = "3";
-      editedCabalFile = "0y2g5dhmvkbd8zsckpgxd1g4hr3g56g0iqi6crjjc8wqd12bly71";
+      version = "5.6.3";
+      sha256 = "1wqf3isrrgmqxz5h42phsa7lawl6442r1da89hg82bld6qkz9imr";
       libraryHaskellDepends = [
         base
         base-orphans
···
     }
   ) { };
 
+  "prometheus-wai" = callPackage (
+    {
+      mkDerivation,
+      autoexporter,
+      base,
+      bytestring,
+      containers,
+      http-types,
+      prometheus,
+      text,
+      wai,
+    }:
+    mkDerivation {
+      pname = "prometheus-wai";
+      version = "0.0.0.0";
+      sha256 = "027i17zyxk3wgzw7161h57rnmgb5iqqnlnlcg129q28dw005wg9h";
+      libraryHaskellDepends = [
+        base
+        bytestring
+        containers
+        http-types
+        prometheus
+        text
+        wai
+      ];
+      libraryToolDepends = [ autoexporter ];
+      license = lib.licenses.mit;
+    }
+  ) { };
+
   "prometheus-wai-middleware" = callPackage (
     {
       mkDerivation,
···
     }
   ) { };
 
+  "pty-mcp-server" = callPackage (
+    {
+      mkDerivation,
+      base,
+      optparse-applicative,
+      pms-application-service,
+      pms-domain-model,
+      pms-domain-service,
+      pms-infra-cmdrun,
+      pms-infra-procspawn,
+      pms-infra-socket,
+      pms-infra-watch,
+      pms-infrastructure,
+      pms-ui-notification,
+      pms-ui-request,
+      pms-ui-response,
+      safe-exceptions,
+    }:
+    mkDerivation {
+      pname = "pty-mcp-server";
+      version = "0.0.5.0";
+      sha256 = "0vra3p8cfzijkz3m5aw3m97vf3awqfc5ga72ks7hmk4fbf7hiwkq";
+      isLibrary = false;
+      isExecutable = true;
+      executableHaskellDepends = [
+        base
+        optparse-applicative
+        pms-application-service
+        pms-domain-model
+        pms-domain-service
+        pms-infra-cmdrun
+        pms-infra-procspawn
+        pms-infra-socket
+        pms-infra-watch
+        pms-infrastructure
+        pms-ui-notification
+        pms-ui-request
+        pms-ui-response
+        safe-exceptions
+      ];
+      description = "pty-mcp-server";
+      license = lib.licenses.asl20;
+      hydraPlatforms = lib.platforms.none;
+      mainProgram = "pty-mcp-server";
+    }
+  ) { };
+
   "pub" = callPackage (
     {
       mkDerivation,
···
     }:
     mkDerivation {
       pname = "push-notify-apn";
-      version = "0.4.0.3";
-      sha256 = "024xanv7wcpmbd2mv4v8gw281gsnx5z15a39zh0v07bgiq7q04wb";
+      version = "0.5.0.0";
+      sha256 = "128k7awxxs07lymqln224lnxvcqwcc263jzpsbsadzp6zpwpg641";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
       bytestring,
       containers,
       cryptonite,
+      extra,
       hspec,
       optparse-applicative,
       process,
       simple-sql-parser,
-      split,
       sqlite-simple,
       syb,
       text,
···
     }:
     mkDerivation {
       pname = "qhs";
-      version = "0.3.3";
-      sha256 = "1wm11y9gnfrjrq5i5nl74vkg242mr08223kw6cracnmr4n6xqm0q";
+      version = "0.4.0";
+      sha256 = "10b996ymvsmcmjyiaw567idr52mc017cgppma9va8yw94xqgdx7s";
       isLibrary = false;
       isExecutable = true;
-      executableHaskellDepends = [
+      libraryHaskellDepends = [
         base
         bytestring
         containers
         cryptonite
+        extra
         optparse-applicative
         simple-sql-parser
-        split
         sqlite-simple
         syb
         text
         zlib
       ];
+      executableHaskellDepends = [ base ];
       testHaskellDepends = [
         base
-        bytestring
         containers
-        cryptonite
+        extra
         hspec
-        optparse-applicative
         process
-        simple-sql-parser
-        split
-        sqlite-simple
-        syb
-        text
-        zlib
       ];
+      doHaddock = false;
       description = "Command line tool qhs, SQL queries on CSV and TSV files";
       license = lib.licenses.mit;
       hydraPlatforms = lib.platforms.none;
···
       pname = "quantification";
       version = "0.8";
       sha256 = "1dw47hy0pvar4mkdp6xjz8ywpic2zs3q0xah9zlbnfpibhjjc1a9";
+      revision = "1";
+      editedCabalFile = "1abpn4sz7g9ih4c3iclpqnwng15dwa7553pxyvwvgy19x6sfgck2";
       libraryHaskellDepends = [
         base
         binary
···
       crypton,
       crypton-x509,
       crypton-x509-system,
+      crypton-x509-validation,
       fast-logger,
       filepath,
       hspec,
···
     }:
     mkDerivation {
       pname = "quic";
-      version = "0.2.14";
-      sha256 = "1f486d4mqc18pfx5krwxv9mh1zkmyjbjddkx4yixjf2yfhq6a855";
+      version = "0.2.17";
+      sha256 = "15fk5786rkryjixqiqk9y7zh5wazwakp6gkk5jr4ryckjdgjyyjj";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
         crypton
         crypton-x509
         crypton-x509-system
+        crypton-x509-validation
         fast-logger
         filepath
         iproute
···
   "quick-process" = callPackage (
     {
       mkDerivation,
+      array,
       attoparsec,
       base,
+      base-orphans,
       bytestring,
       casing,
       conduit,
···
       either,
       exceptions,
       filepath,
+      generic-data,
+      generic-deriving,
       generic-lens,
       generic-random,
+      ghc-prim,
       hashable,
-      HList,
       lens,
       mmorph,
       monad-control,
+      monad-time,
       mtl,
-      pretty,
+      pretty-simple,
       process,
+      profunctors,
       QuickCheck,
       quickcheck-instances,
       regex-compat,
···
       sbv,
       semigroups,
       streaming-commons,
+      tagged,
       tasty,
       tasty-discover,
       tasty-hunit,
···
       unix-compat,
       unliftio,
       unliftio-core,
+      wl-pprint-text,
     }:
     mkDerivation {
       pname = "quick-process";
-      version = "0.0.1";
-      sha256 = "1dgv63w8qlb35xjsyn0716xsmb9jimdwly0c7704pmlfnw5sp38s";
+      version = "0.0.3";
+      sha256 = "180zxzsg2xh24nw7gdzmk134hx7vl61hfc3dsvrdr0rwkp1xmngi";
       libraryHaskellDepends = [
+        array
         attoparsec
         base
+        base-orphans
         bytestring
         casing
         conduit
···
         either
         exceptions
         filepath
+        generic-data
+        generic-deriving
         generic-lens
         generic-random
+        ghc-prim
         hashable
-        HList
         lens
         mmorph
         monad-control
+        monad-time
         mtl
-        pretty
+        pretty-simple
         process
+        profunctors
         QuickCheck
         regex-compat
         regex-posix
···
         sbv
         semigroups
         streaming-commons
+        tagged
         template-haskell
         temporary
         text
···
         unix
         unix-compat
         unliftio-core
+        wl-pprint-text
       ];
       testHaskellDepends = [
         base
         bytestring
         directory
         generic-lens
-        HList
         lens
         QuickCheck
         quickcheck-instances
···
     }:
     mkDerivation {
       pname = "quickcheck-groups";
-      version = "0.0.1.4";
-      sha256 = "1k1pbxcp8ppzyym2wavvpn6p5d74cddh1ldlg1kv55ypfszzzf21";
+      version = "0.0.1.5";
+      sha256 = "1ibchcgj1bqfsc6dx3n4bii6dhylxjn8zl9vhhvk48zsk99q4jaz";
       libraryHaskellDepends = [
         base
         groups
···
     }:
     mkDerivation {
       pname = "quickcheck-instances";
-      version = "0.3.32";
-      sha256 = "10zz62j1jplk392c90hkg9mfk8piyp5ify94jp3rld722phg5xa8";
+      version = "0.3.33";
+      sha256 = "0rl8y3rb4fm4nqz122bp5f2aya4f8bc9m9i9n2vwlyq2gdacs0v8";
       revision = "1";
-      editedCabalFile = "0d7vgsvvkipa1d1gh7z7ha12fv49frcv81dz09qy0m6kvn5lawl7";
+      editedCabalFile = "1xkc7rsfgya4rwiizh0yfincws3knpdnh08m280v1dgik4kv37vh";
       libraryHaskellDepends = [
         array
         base
···
     }:
     mkDerivation {
       pname = "quickcheck-lockstep";
-      version = "0.7.0";
-      sha256 = "0dcy47ab2813saml3jdiar9xlx8ml8c55awcg92i6amazhgwpyw2";
+      version = "0.8.0";
+      sha256 = "1y3icjvd9qbv38q1cxkn48d6fp4b7c0j0j0l3mwkfi8ph8qjg2y6";
       libraryHaskellDepends = [
         base
         constraints
···
       ];
       description = "Library for lockstep-style testing with 'quickcheck-dynamic'";
       license = lib.licenses.bsd3;
-      hydraPlatforms = lib.platforms.none;
-      broken = true;
     }
   ) { };
 
···
       pretty-show,
       QuickCheck,
       quickcheck-classes,
-      quickcheck-instances,
       semigroupoids,
       text,
       vector,
     }:
     mkDerivation {
       pname = "quickcheck-monoid-subclasses";
-      version = "0.3.0.5";
-      sha256 = "0hnrm69vavc2b1h4cishdvn7j0x8l8mk8fggbai3kn77w6cnf3il";
+      version = "0.3.0.6";
+      sha256 = "03gngckzwhln7c86dixg8szrnqwgdl9svy6hfnzgyjpn4qfqwcmv";
       libraryHaskellDepends = [
         base
         containers
···
         pretty-show
         QuickCheck
         quickcheck-classes
-        quickcheck-instances
         semigroupoids
       ];
       testHaskellDepends = [
···
         monoid-subclasses
         QuickCheck
         quickcheck-classes
-        quickcheck-instances
         text
         vector
       ];
···
     }:
     mkDerivation {
       pname = "quickcheck-quid";
-      version = "0.0.1.7";
-      sha256 = "1r0ip3a281dgvy6bplhr76wg5n0l4qz0k6i6r3fzh4848r6z9say";
+      version = "0.0.1.8";
+      sha256 = "0qx08f6z1y21qn63z5hkhlvj1rgn921ads03lrppmggg9kvrk5x0";
       libraryHaskellDepends = [
         base
         containers
···
     }:
     mkDerivation {
       pname = "rdf4h";
-      version = "5.2.0";
-      sha256 = "03f1dcw4zii4yvq7azhcgpkf59wibjdlvkifb88jp8maiaadzr75";
+      version = "5.2.1";
+      sha256 = "1jah12gcmc85qpbhw6igi28rvmww38fqmj1waqw7c16y0lxnkvxb";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
     }:
     mkDerivation {
       pname = "rds-data";
-      version = "0.2.0.0";
-      sha256 = "08lk0m1vgvbsmbvf5gv9nlab161a05w6n964w90g7wf1rqmj54d7";
-      isLibrary = false;
-      isExecutable = false;
+      version = "0.2.0.1";
+      sha256 = "1kfi9qmq07v9bvs7a08221r4c7r4hl74f1iavnk6d5gaqms38sfz";
       libraryHaskellDepends = [
         aeson
         amazonka-core
···
     }
   ) { };
 
+  "rds-data-polysemy" = callPackage (
+    {
+      mkDerivation,
+      aeson,
+      aeson-pretty,
+      amazonka,
+      amazonka-core,
+      amazonka-rds,
+      amazonka-rds-data,
+      amazonka-secretsmanager,
+      base,
+      base64-bytestring,
+      bytestring,
+      contravariant,
+      generic-lens,
+      hedgehog,
+      hedgehog-extras,
+      http-client,
+      hw-polysemy,
+      hw-prelude,
+      microlens,
+      mtl,
+      optparse-applicative,
+      polysemy-log,
+      polysemy-plugin,
+      polysemy-time,
+      rds-data,
+      resourcet,
+      stm,
+      tasty,
+      tasty-discover,
+      tasty-hedgehog,
+      testcontainers,
+      text,
+      time,
+      transformers,
+      ulid,
+      uuid,
+    }:
+    mkDerivation {
+      pname = "rds-data-polysemy";
+      version = "0.1.0.0";
+      sha256 = "13anncaj8yw3y4csg7kbda6wrb9s8g5spd9k5h1ygrwy1az697sr";
+      isLibrary = false;
+      isExecutable = true;
+      libraryHaskellDepends = [
+        aeson
+        amazonka
+        amazonka-core
+        amazonka-rds
+        amazonka-rds-data
+        amazonka-secretsmanager
+        base
+        base64-bytestring
+        bytestring
+        contravariant
+        generic-lens
+        hw-polysemy
+        hw-prelude
+        microlens
+        mtl
+        polysemy-log
+        polysemy-plugin
+        rds-data
+        text
+        time
+        transformers
+        ulid
+        uuid
+      ];
+      executableHaskellDepends = [
+        aeson
+        amazonka
+        amazonka-rds-data
+        base
+        bytestring
+        generic-lens
+        hedgehog
+        http-client
+        hw-polysemy
+        hw-prelude
+        microlens
+        optparse-applicative
+        polysemy-log
+        polysemy-plugin
+        polysemy-time
+        rds-data
+        resourcet
+        stm
+        testcontainers
+        text
+        time
+        ulid
+        uuid
+      ];
+      testHaskellDepends = [
+        aeson
+        aeson-pretty
+        amazonka
+        amazonka-core
+        amazonka-rds
+        amazonka-rds-data
+        amazonka-secretsmanager
+        base
+        base64-bytestring
+        bytestring
+        generic-lens
+        hedgehog
+        hedgehog-extras
+        hw-polysemy
+        microlens
+        polysemy-log
+        polysemy-plugin
+        rds-data
+        tasty
+        tasty-discover
+        tasty-hedgehog
+        testcontainers
+        text
+        time
+        ulid
+        uuid
+      ];
+      testToolDepends = [ tasty-discover ];
+      doHaddock = false;
+      description = "Codecs for use with AWS rds-data";
+      license = lib.licenses.bsd3;
+      hydraPlatforms = lib.platforms.none;
+      mainProgram = "rds-data";
+    }
+  ) { };
+
   "rdtsc" = callPackage (
     { mkDerivation, base }:
     mkDerivation {
···
     }:
     mkDerivation {
       pname = "reflex";
-      version = "0.9.3.3";
-      sha256 = "0iklqcszxmj3dian0mjpz75483084ar8i328ydcx68xk9l9rlqbf";
+      version = "0.9.3.4";
+      sha256 = "1qh2xbg4q2gif25hinz72j8ka2w976lccklknwgijxaayh92if4a";
       libraryHaskellDepends = [
         base
         bifunctors
···
       ];
       description = "Use colonnade with reflex-dom";
       license = lib.licenses.bsd3;
-      hydraPlatforms = lib.platforms.none;
     }
   ) { };
 
···
       description = "Helper widgets for reflex-localize";
       license = lib.licenses.mit;
       badPlatforms = [ "aarch64-linux" ] ++ lib.platforms.darwin;
-      hydraPlatforms = lib.platforms.none;
     }
   ) { };
 
···
       description = "MessagePack encoders / decoders";
       license = lib.licenses.mit;
       hydraPlatforms = lib.platforms.none;
+      broken = true;
     }
   ) { };
 
···
     }
   ) { };
 
+  "resource-pool_0_5_0_0" = callPackage (
+    {
+      mkDerivation,
+      base,
+      hashable,
+      primitive,
+      stm,
+      text,
+      time,
+    }:
+    mkDerivation {
+      pname = "resource-pool";
+      version = "0.5.0.0";
+      sha256 = "1l0l26fgwjilqh55z7vylw9i735hich8amwgl1a63dgcwyvhlxgs";
+      libraryHaskellDepends = [
+        base
+        hashable
+        primitive
+        stm
+        text
+        time
+      ];
+      description = "A high-performance striped resource pooling implementation";
+      license = lib.licenses.bsd3;
+      hydraPlatforms = lib.platforms.none;
+    }
+  ) { };
+
   "resource-pool-catchio" = callPackage (
     {
       mkDerivation,
···
     }:
     mkDerivation {
       pname = "richenv";
-      version = "0.1.0.2";
-      sha256 = "0yxl6cnhg7n29f93mj4a5wkp1v1i2y38824n2bg8b64ik1hlg876";
+      version = "0.1.0.3";
+      sha256 = "0v6ymwypp6023srv9axh0rc98bsvkhk29nwhap9rb33x8ibb8vr9";
       libraryHaskellDepends = [
         aeson
         base
···
     }:
     mkDerivation {
       pname = "roc-id";
-      version = "0.2.0.4";
-      sha256 = "126ijgk7wi06694xcqvjz9amg61pzi2hnx7gq631zwxa6d98czzk";
+      version = "0.2.0.5";
+      sha256 = "1a70y8l45lyglq6rrxrp20jfpwg87gkga4wdxdf15nzh0p1a417f";
       libraryHaskellDepends = [
         base
         MonadRandom
···
       exceptions,
       filepath,
       free,
-      haskell-src-exts,
       microlens,
       microlens-th,
       monad-control,
···
     }:
     mkDerivation {
       pname = "sandwich";
-      version = "0.3.0.3";
-      sha256 = "0j53b68vgidwahmbbhcrshh9043k1g230lypyfavcwbpcgrzxkpb";
+      version = "0.3.0.4";
+      sha256 = "1j6xlnhb58kg776jl1bp82lfi95a9xy27haqanbx67mw7n471gc6";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
         exceptions
         filepath
         free
-        haskell-src-exts
         microlens
         microlens-th
         monad-control
···
         exceptions
         filepath
         free
-        haskell-src-exts
         microlens
         microlens-th
         monad-control
···
         exceptions
         filepath
         free
-        haskell-src-exts
         microlens
         microlens-th
         monad-control
···
       string-interpolate,
       temporary,
       text,
-      time,
       transformers,
       unix-compat,
       unliftio,
···
     }:
     mkDerivation {
       pname = "sandwich-contexts";
-      version = "0.3.0.2";
-      sha256 = "01klfrf9n1z6h1iqgb3ccch1dxihp28lh60d44xj3xmfz2q4y5iq";
+      version = "0.3.0.3";
+      sha256 = "0bd0a3akg7rbpp94cwyrpjjw104468y7caxnvl6iwl3fnc6gvy7c";
       libraryHaskellDepends = [
         aeson
         base
···
         string-interpolate
         temporary
         text
-        time
         transformers
         unix-compat
         unliftio
···
       exceptions,
       filepath,
       http-client,
-      kubernetes-client,
-      pname = "nat";
+      pname = "nat";
+      kubernetes-api-client,
       lens,
       lens-aeson,
       minio-hs,
···
     }:
     mkDerivation {
       pname = "sandwich-contexts-kubernetes";
-      version = "0.1.0.0";
-      sha256 = "04p2g6jjra3bh4a4zb00lidckm91ba3cvwvrvjh28i3flh15b6wr";
+      version = "0.1.1.0";
+      sha256 = "00g2fq9xnk8icrvfjmqkhl3g7pz7159kqajx10vgy4xgdxp25zfz";
       libraryHaskellDepends = [
         aeson
         base
···
         exceptions
         filepath
         http-client
-        kubernetes-client
-      pname = "nat";
+      pname = "nat";
+        kubernetes-api-client
         lens
         lens-aeson
         minio-hs
···
     }:
     mkDerivation {
       pname = "sandwich-webdriver";
-      version = "0.3.0.0";
-      sha256 = "1s4j2i91csn1wplw1vnz7s8kin5v580a7m98yfas8p7nlm9bihp4";
+      version = "0.3.0.1";
+      sha256 = "18vb8vdcpdy6zkqynhqwzy2217lbz0jrdhd2c21wr6ly4rfmf0jr";
       libraryHaskellDepends = [
         aeson
         base
···
         sandwich
         sandwich-contexts
         string-interpolate
+        temporary
         text
         time
         transformers
···
     }
   ) { inherit (pkgs) z3; };
 
-  "sbv_11_7" = callPackage (
+  "sbv_12_0" = callPackage (
     {
       mkDerivation,
       array,
···
       deepseq,
       directory,
       filepath,
+      haskell-src-exts,
+      haskell-src-meta,
       libBF,
       mtl,
       pretty,
···
     }:
     mkDerivation {
       pname = "sbv";
-      version = "11.7";
-      sha256 = "1nq1yjc4wfjmqhp0y61aqmva99vxnpj2mpksyai63ijmx9zq8yzs";
+      version = "12.0";
+      sha256 = "14c9i9aa6rbm6kfxjcdbcy7vajh3v6bhsginhn1v6hg8430f93rp";
       enableSeparateDataOutput = true;
       libraryHaskellDepends = [
         array
···
         deepseq
         directory
         filepath
+        haskell-src-exts
+        haskell-src-meta
         libBF
         mtl
         pretty
···
     }:
     mkDerivation {
       pname = "search-algorithms";
-      version = "0.3.3";
-      sha256 = "00b1fxgjg57m6qm8017yvqbs6qvblw4iazir005flzjm6jls12kz";
+      version = "0.3.4";
+      sha256 = "1r6nnwb0ry95xqg8psdwgfx6h264kd437a3mr5z7gv7vdarb3r2h";
       libraryHaskellDepends = [
         base
         containers
···
     }
   ) { };
 
+  "select-rpms_0_3_0" = callPackage (
+    {
+      mkDerivation,
+      base,
+      directory,
+      extra,
+      filepath,
+      Glob,
+      rpm-nvr,
+      safe,
+      simple-cmd,
+      simple-cmd-args,
+      simple-prompt,
+    }:
+    mkDerivation {
+      pname = "select-rpms";
+      version = "0.3.0";
+      sha256 = "0xzhhic205nvh8n2mdb85675x8kdvlgjy0d4xxyw1nq8p078cn51";
+      libraryHaskellDepends = [
+        base
+        directory
+        extra
+        filepath
+        Glob
+        rpm-nvr
+        safe
+        simple-cmd
+        simple-cmd-args
+        simple-prompt
+      ];
+      description = "Select a subset of RPM packages";
+      license = lib.licenses.mit;
+      hydraPlatforms = lib.platforms.none;
+    }
+  ) { };
+
   "selections" = callPackage (
     { mkDerivation, base }:
     mkDerivation {
···
     }
   ) { };
 
-  "sequence-formats_1_11_0_1" = callPackage (
+  "sequence-formats_1_11_0_2" = callPackage (
     {
       mkDerivation,
       attoparsec,
···
     }:
     mkDerivation {
       pname = "sequence-formats";
-      version = "1.11.0.1";
-      sha256 = "1qzawb3qnn76j7dvb0q8jbblbayggr5hja0x723y09nv1y9lg6g5";
+      version = "1.11.0.2";
+      sha256 = "1y6sv7xlzbkvlrihmkclv1hp5g3nsrnz37xika3jzksqv4grv412";
       libraryHaskellDepends = [
         attoparsec
         base
···
       pname = "serialise";
       version = "0.2.6.1";
       sha256 = "1x3p9vi6daf50xgv5xxjnclqcq9ynqg1qw7af3ppa1nizycrg533";
-      revision = "4";
-      editedCabalFile = "1ipcrg5g450a3aq15l5rhngpfck8krz7c7bvhhrd8fv3q645yjbh";
+      revision = "5";
+      editedCabalFile = "0kfai48gza3zzi3s3ll1gng2wbpdmr5z5isx8snlh49vafsqjzx6";
       libraryHaskellDepends = [
         array
         base
···
       constraints,
       containers,
       deepseq,
+      generics-sop,
       hspec,
       hspec-discover,
       http-api-data,
···
     }:
     mkDerivation {
       pname = "servant";
-      version = "0.20.2";
-      sha256 = "0rakyjrmn05sb2gxk4bkxlb23zfwm1pjkdg9mh7b4hjgsdwy4fba";
-      revision = "1";
-      editedCabalFile = "17n769vwyyc5hshm71r33ksvn26qcz19017wl9p8xj4igav790pa";
+      version = "0.20.3.0";
+      sha256 = "00k6pwqxpyjp5qm5pjl8qb75iqmpql5iv3ac43xdvikcixffcwzj";
       libraryHaskellDepends = [
         aeson
         attoparsec
···
         constraints
         containers
         deepseq
+        generics-sop
         http-api-data
         http-media
         http-types
···
         hspec
         http-media
         mtl
+        network-uri
         QuickCheck
         quickcheck-instances
         text
···
       containers,
       servant,
       servant-server,
-      template-haskell,
       text,
     }:
     mkDerivation {
       pname = "servant-activeresource";
-      version = "0.1.0.0";
-      sha256 = "0dcip0vbry344pv8za5ldxr9g71vyb63ks3jdpjc7z4vixp5rbsp";
-      revision = "1";
-      editedCabalFile = "006mbw5mvj5kzz8bigws55xallwrsvdsi5b5y9wc4d7l8a63z0gd";
+      version = "0.2.0.0";
+      sha256 = "0gxw9yxsr4ri2lwr4y0qhf0cgqknrdjgpqn87wy1n4pas2k6sc15";
       libraryHaskellDepends = [
         aeson
         base
···
         containers
         servant
         servant-server
-        template-haskell
         text
       ];
       testHaskellDepends = [
···
         containers
         servant
         servant-server
-        template-haskell
         text
       ];
-      description = "Servant endpoints compatible with Rails's ActiveResources";
+      description = "Servant endpoints compatible with Rails's ActiveResource";
       license = lib.licenses.bsd3;
     }
   ) { };
···
       bytestring,
       case-insensitive,
       cookie,
-      data-default-class,
+      data-default,
       entropy,
       hspec,
       hspec-discover,
···
     }:
     mkDerivation {
       pname = "servant-auth-server";
-      version = "0.4.9.0";
-      sha256 = "0fhk2z9n9ax4g7iisdgcd87wgj9wvazhl86kjh364gsj1g8a5y99";
-      revision = "1";
-      editedCabalFile = "0skvvqkyqzgjdg5b2l9fd1ri144s649g5yddpclwciraimip7gw1";
+      version = "0.4.9.1";
+      sha256 = "04sy2g81pp0pr31xi6h1hqm199z6r4xv3fy2x307dlydxmdm8qb3";
       libraryHaskellDepends = [
         aeson
         base
···
         bytestring
         case-insensitive
         cookie
-        data-default-class
+        data-default
         entropy
         http-types
         jose
···
       ];
       description = "Command line interface for Servant API clients";
       license = lib.licenses.bsd3;
-      hydraPlatforms = lib.platforms.none;
       mainProgram = "greet-cli";
-      broken = true;
     }
   ) { };
 
···
       deepseq,
       entropy,
       exceptions,
+      generics-sop,
       hspec,
       hspec-discover,
       http-api-data,
···
     }:
     mkDerivation {
       pname = "servant-client";
-      version = "0.20.2";
-      sha256 = "026bp0qk2bx672834yjxmqrfacyzzdssm89bd0niz1xzxzmw5r7g";
-      revision = "2";
-      editedCabalFile = "1sm0xspcsxn6n70nirpglcmx07sn6vmag8kvvw9i2dr2hcfkgk55";
+      version = "0.20.3.0";
+      sha256 = "0kxmixgv5nmir2bk3zfrhaal4969rf414wi2ccnngjm3395bqrwn";
+      revision = "1";
+      editedCabalFile = "0644af144zy4axv8hhqhv8mj7amnqd09fbz5rglr6l60d27hpqx1";
       libraryHaskellDepends = [
         base
         base-compat
···
         base-compat
         bytestring
         entropy
+        generics-sop
         hspec
         http-api-data
         http-client
···
     {
       mkDerivation,
       aeson,
+      attoparsec,
       base,
       base-compat,
       base64-bytestring,
···
       sop-core,
       template-haskell,
       text,
+      transformers,
     }:
     mkDerivation {
       pname = "servant-client-core";
-      version = "0.20.2";
-      sha256 = "10nv810ns8v1d9a2fkg9bgi7h9gm4yap1y6mg2r15d569i27rrvc";
+      version = "0.20.3.0";
+      sha256 = "1vv6xf340hyk60vv6jb1zxfpsb7x2ykacb84yrn3h1w4k075hlyn";
       revision = "1";
-      editedCabalFile = "13200adlbl8mydi35x1r8w4q9ra8y079figgjxl5jsrhvps54608";
+      editedCabalFile = "1g8arzgcqc9qp1fimrs8iwqvzgsp6br76kkh72hsz0nsg6gmlvc1";
       libraryHaskellDepends = [
         aeson
+        attoparsec
         base
         base-compat
         base64-bytestring
···
       testHaskellDepends = [
         base
         base-compat
+        bytestring
         deepseq
         hspec
         QuickCheck
+        servant
+        transformers
       ];
       testToolDepends = [ hspec-discover ];
       description = "Core functionality and class for client function generation for servant APIs";
···
       testHaskellDepends = [ base ];
       description = "Servant support for Server-Sent events";
       license = lib.licenses.bsd3;
+      hydraPlatforms = lib.platforms.none;
+      broken = true;
     }
   ) { };
 
···
     }:
     mkDerivation {
       pname = "servant-routes";
-      version = "0.1.0.0";
-      sha256 = "1m17cpbmyi8y2h27p9y28193b2d46qmr8bhswvjn89nd5z42d6x2";
+      version = "0.1.1.0";
+      sha256 = "0r9db46gbi9rcsrdvqndfa9433szbp5a0c1ad3z3qchpf3i2dxfm";
       libraryHaskellDepends = [
         aeson
         aeson-pretty
···
     }
   ) { };
 
+  "servant-routes-golden" = callPackage (
+    {
+      mkDerivation,
+      aeson,
+      aeson-pretty,
+      base,
+      hspec,
+      hspec-core,
+      hspec-discover,
+      hspec-golden,
+      QuickCheck,
+      servant,
+      servant-routes,
+      text,
+    }:
+    mkDerivation {
+      pname = "servant-routes-golden";
+      version = "0.1.0.0";
+      sha256 = "16kc5q0vc7hjy7dfd3smnlcs6308sligzgr3hcnx1mqxnfmv0svp";
+      libraryHaskellDepends = [
+        aeson
+        aeson-pretty
+        base
+        hspec-core
+        hspec-golden
+        servant-routes
+        text
+      ];
+      testHaskellDepends = [
+        aeson
+        aeson-pretty
+        base
+        hspec
+        hspec-core
+        hspec-golden
+        QuickCheck
+        servant
+        servant-routes
+        text
+      ];
+      testToolDepends = [ hspec-discover ];
+      description = "Golden test your Servant APIs using `servant-routes`";
+      license = lib.licenses.bsd3;
+    }
+  ) { };
+
   "servant-ruby" = callPackage (
     {
       mkDerivation,
···
     }:
     mkDerivation {
       pname = "servant-server";
-      version = "0.20.2";
-      sha256 = "0fqgnzzgbj4w441h3v841lav7gxazakz04s354r24pq4rh6m1kqy";
+      version = "0.20.3.0";
+      sha256 = "05crwklbncd393zq00gi04zgnfyy2wk31s0xf5hy6yjrsbshlmih";
       revision = "1";
-      editedCabalFile = "0qjl1yrr0l7kynrndv8qmpzl0jz9nzb7c4v9r7kxq05nnb7xpqbz";
+      editedCabalFile = "1z2h1gmxphwd76chyah405ww4ciyxq7rvggghr6lh0z1m3p2k90h";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
       servant,
       pname = "nat";
       string-interpolate,
+      temporary,
       text,
     }:
     mkDerivation {
       pname = "servant-typescript";
-      version = "0.1.0.2";
-      sha256 = "03nf4gqiy7jpdaxmddv859im0czpjrdss72cgjhkd96vqf4g4kam";
+      version = "0.1.0.3";
+      sha256 = "0x10dsd16bjqkk7s8kb1yfhrvkzqw5v0smxm8vf3bm8q10anf2dp";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
         servant
       pname = "nat";
         string-interpolate
+        temporary
         text
       ];
       testHaskellDepends = [
···
       ];
       description = "TypeScript client generation for Servant";
       license = lib.licenses.bsd3;
-      hydraPlatforms = lib.platforms.none;
       mainProgram = "servant-typescript-exe";
-      broken = true;
     }
   ) { };
 
···
     }
   ) { };
 
-  "shakespeare_2_1_0_1" = callPackage (
-    {
-      mkDerivation,
-      aeson,
-      base,
-      blaze-html,
-      blaze-markup,
-      bytestring,
-      containers,
-      directory,
-      exceptions,
-      file-embed,
-      ghc-prim,
-      hspec,
-      HUnit,
-      parsec,
-      process,
-      scientific,
-      template-haskell,
-      text,
-      th-lift,
-      time,
-      transformers,
-      unordered-containers,
-      vector,
-    }:
-    mkDerivation {
-      pname = "shakespeare";
-      version = "2.1.0.1";
-      sha256 = "0byj0zhxi1pr8l5f18phzkwcf7z38lyk2zznz8hbkqadfgrmbdkc";
-      libraryHaskellDepends = [
-        aeson
-        base
-        blaze-html
-        blaze-markup
-        bytestring
-        containers
-        directory
-        exceptions
-        file-embed
-        ghc-prim
-        parsec
-        process
-        scientific
-        template-haskell
-        text
-        th-lift
-        time
-        transformers
-        unordered-containers
-        vector
-      ];
-      testHaskellDepends = [
-        aeson
-        base
-        blaze-html
-        blaze-markup
-        bytestring
-        containers
-        directory
-        exceptions
-        ghc-prim
-        hspec
-        HUnit
-        parsec
-        process
-        template-haskell
-        text
-        time
-        transformers
-      ];
-      description = "A toolkit for making compile-time interpolated templates";
-      license = lib.licenses.mit;
-      hydraPlatforms = lib.platforms.none;
-      maintainers = [ lib.maintainers.psibi ];
-    }
-  ) { };
-
   "shakespeare" = callPackage (
     {
       mkDerivation,
···
     }:
     mkDerivation {
       pname = "shakespeare";
-      version = "2.1.1";
-      sha256 = "1j6jniy8d8dgc61h4n2kw668y8f30cqnsfwmgad1s4fqj1bplh0r";
+      version = "2.1.4";
+      sha256 = "1c9lvb0aw00r0wibm061c614phlwsrf888amjn9nc168ix0cxv6x";
       libraryHaskellDepends = [
         aeson
         base
···
     }
   ) { };
 
-  "shellify_0_14_0_0" = callPackage (
+  "shellify_0_14_0_1" = callPackage (
     {
       mkDerivation,
       base,
···
     }:
     mkDerivation {
       pname = "shellify";
-      version = "0.14.0.0";
-      sha256 = "09i55y57innmjbgb0x1bvrbpk0c5py0bb004wxnqpw4b8swxc60r";
+      version = "0.14.0.1";
+      sha256 = "1gnr4ii3wn7i0b8facg5a9d3b83lwm7nyk56576ll3nyywqh577i";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
       ];
       description = "A very quick-and-dirty WebSocket server";
       license = lib.licenses.bsd3;
+      hydraPlatforms = lib.platforms.none;
+      broken = true;
     }
   ) { };
 
···
       pname = "snap";
       version = "1.1.3.3";
       sha256 = "1mqckzm9gasa04ls691zgw4c6m53mgcj86yd2p5qvy07mpn9rdvx";
-      revision = "3";
-      editedCabalFile = "1nzkb0jq359lpwz4a1ldx1fh8xs735wfwf2z6qq0z7y0c4zxb9da";
+      revision = "4";
+      editedCabalFile = "1zqvs7kx3jy8vmgwqc344cyv6f3zpx0vg9w5nb9lf5h23bl85k0i";
       libraryHaskellDepends = [
         aeson
         attoparsec
···
     }:
     mkDerivation {
       pname = "snappy";
-      version = "0.2.0.3";
-      sha256 = "0jy747dg58smzzr1mzrm751bkwvnaaghn65ppfkqbpqz6jw45qq2";
+      version = "0.2.0.4";
+      sha256 = "1marmb148hq6fnwmb5q1kqmzjsxpnqcgszmm4jdapiijlmms1b76";
       libraryHaskellDepends = [
         base
         bytestring
···
     }
   ) { };
 
+  "socks5" = callPackage (
+    {
+      mkDerivation,
+      async,
+      base,
+      binary,
+      bytestring,
+      data-default,
+      hspec,
+      iproute,
+      mtl,
+      network,
+      network-run,
+      optparse-applicative,
+      text,
+      tls,
+    }:
+    mkDerivation {
+      pname = "socks5";
+      version = "0.6.0.1";
+      sha256 = "1q4084wvfhyni3dw0xa5a08k3lkylr6g5bzv6d463iqwn5skjwsq";
+      isLibrary = true;
+      isExecutable = true;
+      libraryHaskellDepends = [
+        async
+        base
+        binary
+        bytestring
+        iproute
+        mtl
+        network
+        network-run
+        text
+        tls
+      ];
+      executableHaskellDepends = [
+        base
+        bytestring
+        data-default
+        network
+        optparse-applicative
+        text
+        tls
+      ];
+      testHaskellDepends = [
+        async
+        base
+        bytestring
+        data-default
+        hspec
+        network
+        network-run
+        tls
+      ];
+      description = "A SOCKS5 (RFC 1928) implementation";
+      license = lib.licenses.bsd3;
+      hydraPlatforms = lib.platforms.none;
+      broken = true;
+    }
+  ) { };
+
   "sodium" = callPackage (
     {
       mkDerivation,
···
     }
   ) { };
 
+  "sop-satisfier" = callPackage (
+    {
+      mkDerivation,
+      base,
+      containers,
+      tasty,
+      tasty-hunit,
+      transformers,
+    }:
+    mkDerivation {
+      pname = "sop-satisfier";
+      version = "0.3.4.5";
+      sha256 = "1q0w5syb0x04k6iy4rhssw7wnj1vy562lhw9lmvygi37wir6vjj1";
+      libraryHaskellDepends = [
+        base
+        containers
+        transformers
+      ];
+      testHaskellDepends = [
+        base
+        tasty
+        tasty-hunit
+      ];
+      description = "Check satisfiability of expressions on natural numbers";
+      license = lib.licenses.bsd2;
+      hydraPlatforms = lib.platforms.none;
+      broken = true;
+    }
+  ) { };
+
   "sophia" = callPackage (
     {
       mkDerivation,
···
     }:
     mkDerivation {
       pname = "specup";
-      version = "0.2.0.5";
-      sha256 = "1b84drxgqaij48rwwannnkms1mzd5mw4i4r442am6wz4y7v45309";
+      version = "0.2.0.6";
+      sha256 = "1b7bvrb2ad1p78g82q7a3pzi4pgq2qrsas8vl9nglljyn2l259va";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
       math-functions,
       process,
       random,
+      template-haskell,
       test-framework,
       test-framework-hunit,
       testu01,
···
     }:
     mkDerivation {
       pname = "splitmix";
-      version = "0.1.1";
-      sha256 = "1iqjxg3jdjmpj6rchnab1scr6b12p1mk7y75ywn06qisc0dc8y6n";
+      version = "0.1.3.1";
+      sha256 = "0w32z3rhsnijb9s5k6h60rhbzgzkw8xq1glfbjbl1znlkgbx1g5n";
       libraryHaskellDepends = [
         base
         deepseq
···
         math-functions
         process
         random
+        template-haskell
         test-framework
         test-framework-hunit
         tf-random
···
       pname = "spreadsheet";
       version = "0.1.3.10";
       sha256 = "022q6an3jl0s8bnwgma8v03b6m4zq3q0drl6nsrcs0nav8n1z5r0";
-      revision = "1";
-      editedCabalFile = "1dd37qgmy7nzxkbarflh5fm33gy7yqy91pa4pa3x4yggp9v52f61";
+      revision = "2";
+      editedCabalFile = "1zw9lf90r43vnmybbzmgahw4w423zfjhz4b0nmssnvdbk2lj5yps";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
       pname = "sqlite";
       version = "0.5.5";
       sha256 = "1i2bkfyswmannwb1fx6y8ma3pzgx28nl05a35gz1gar28rsx7gyk";
+      revision = "1";
+      editedCabalFile = "0pp4b2z41n9rpln4zrc6d9100v8g60m3ggjrjbq5fk0xjan4gp7k";
       libraryHaskellDepends = [
         base
         bytestring
···
     }
   ) { inherit (pkgs) nlopt; };
 
-  "srtree_2_0_1_4" = callPackage (
+  "srtree_2_0_1_5" = callPackage (
     {
       mkDerivation,
       ad,
···
     }:
     mkDerivation {
       pname = "srtree";
-      version = "2.0.1.4";
-      sha256 = "04r9lxf3nffpmmv978h8mfzr0shcbcrwarxs8s2mgpdvdx5qm1sa";
+      version = "2.0.1.5";
+      sha256 = "0h856i6gsh01rpp08lkvdrigylhbf1h016xwkccmmyd20iz3023l";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
       pname = "stache";
       version = "2.3.4";
       sha256 = "0kgiyxws2kir8q8zrqkzmk103y7hl6nksxl70f6fy8m9fqkjga51";
-      revision = "4";
-      editedCabalFile = "03bgp2b2kpijnvdsvcr4adas7iyz3v12cp6j044b248cw6hklayd";
+      revision = "5";
+      editedCabalFile = "1kvqv42w223r53mjkj2am6j65qly8bvahr5fxvlbnx88bairp0zm";
       isLibrary = true;
       isExecutable = true;
       enableSeparateDataOutput = true;
···
     }:
     mkDerivation {
       pname = "stack";
-      version = "3.5.1";
-      sha256 = "12423vw5k576c1yy0mg40cjia8j6b9jsf8p2489ixlvm192fza7f";
+      pname = "nat";
+      sha256 = "03n8191slbq9zs9h437qda1w24nnf73p7x48x8lqp8sbcn6plaj1";
       configureFlags = [
         "-fdisable-git-info"
         "-fhide-dependency-versions"
···
     }:
     mkDerivation {
       pname = "stackctl";
-      version = "1.7.3.4";
-      sha256 = "0y0prp85gf5yns5lb9285g2xqfy8w5ck2ajkpiljnmff2zqnlyzb";
+      version = "1.7.3.5";
+      sha256 = "1naf2n41d0vhhnkkc4bnkapzqdmap6kp8xh27dqjcg7kmv3hllhi";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
       pname = "stan";
       version = "0.2.1.0";
       sha256 = "1mf01bpy291131jfl4fcslv0jfn8i8jqwr29v1v48j6c6q49rias";
+      revision = "1";
+      editedCabalFile = "0b7lf7g8kg7xxxl3zgfxk86bs0pl9i9xm1cvn1n2bpmfvymm19qa";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
     }
   ) { };
 
+  "stats-monad" = callPackage (
+    { mkDerivation, base }:
+    mkDerivation {
+      pname = "stats-monad";
+      version = "0.1.0.1";
+      sha256 = "1cg0db7malqm75rlxxcmp2w00pvlf1kki4fz5p7lc86qy7241vzb";
+      libraryHaskellDepends = [ base ];
+      description = "A discrete probability monad with statistics";
+      license = lib.licenses.bsd3;
+    }
+  ) { };
+
   "statsd" = callPackage (
     {
       mkDerivation,
···
       pname = "stm";
       version = "2.5.3.1";
       sha256 = "1rrh4s07vav9mlhpqsq9r6r0gh3f4k8g1gjlx63ngkpdj59ldc7b";
+      revision = "1";
+      editedCabalFile = "1pfrf0r1f3hl9x3nxv5nja6hrflm72z3cls4x5vljnzmrp4mf6s2";
       libraryHaskellDepends = [
         array
         base
···
       pname = "string-interpolate";
       version = "0.3.4.0";
       sha256 = "13hb3spabggr6gsn9xhwpwldjvpl2l7z4lgssis82c40n108b0w8";
-      revision = "2";
-      editedCabalFile = "0mw6ws7ixdcfhn7pkgci8v1pk26wnid123pi5f1y88hnmnrzs13k";
+      revision = "3";
+      editedCabalFile = "0grq9v023186gfq3a2as9974qlwcjx3dhxqczpq22bq2wfpw24x7";
       libraryHaskellDepends = [
         base
         bytestring
···
       pname = "sum-pyramid";
       version = "0.0.1";
       sha256 = "1zh7g16d345g8wffgj7wswfryrxxf7ik02fwrncqyc9yxmc7hm6y";
+      revision = "1";
+      editedCabalFile = "0pq6b89ygb0c2sd7b73zic7f8g589jz08ff0a1fpwr4xj5mawkmd";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
···
     }:
     mkDerivation {
       pname = "sv2v";
-      version = "0.0.13";
-      sha256 = "0gg8972im84gp60qavpmsdxcmjwzsbbg3va2f0fdxz5yqyc96cdn";
+      version = "0.0.13.1";
+      sha256 = "1idv0mm1n02k9qzqqshylp310bcjlg5m3dh7l6dvz575553r4d1l";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
···
       boolexpr,
       brick,
       brick-list-skip,
+      brick-tabular-list,
       bytestring,
       clock,
       colour,
···
       fused-effects,
       fused-effects-lens,
       fuzzy,
+      generic-data,
       githash,
       hashable,
       hsnoise,
···
       megaparsec,
       minimorph,
       MissingH,
+      monad-logger,
+      monoidmap,
+      monoidmap-aeson,
       mtl,
       murmur3,
       natural-sort,
       nonempty-containers,
       optparse-applicative,
+      ordered-containers,
       palette,
       pandoc,
       pandoc-types,
       parser-combinators,
       prettyprinter,
       QuickCheck,
+      quickcheck-instances,
       random,
       scientific,
+      servant,
       servant-docs,
+      servant-JuicyPixels,
       servant-multipart,
       servant-server,
       SHA,
-      simple-enumeration,
       split,
       sqlite-simple,
       syb,
···
     }:
     mkDerivation {
       pname = "swarm";
-      version = "0.6.0.0";
-      sha256 = "0y2ijxfn8yns6fk87mj7nzlnq5k62mhc5xp8nhzzs5yf2v4p72j6";
+      version = "0.7.0.0";
+      sha256 = "0i0n5vrsz7d8x45lbjzmk1jln368bcz6cy3hn3yaafvhyacqii82";
       isLibrary = false;
       isExecutable = true;
       enableSeparateDataOutput = true;
···
         boolexpr
         brick
         brick-list-skip
+        brick-tabular-list
         bytestring
         clock
         colour
···
         fused-effects
         fused-effects-lens
         fuzzy
+        generic-data
         githash
         hashable
         hsnoise
···
         lsp
         megaparsec
         minimorph
+        monad-logger
+        monoidmap
+        monoidmap-aeson
         mtl
         murmur3
         natural-sort
         nonempty-containers
+        ordered-containers
         palette
         pandoc
         pandoc-types
···
         prettyprinter
         random
         scientific
+        servant
         servant-docs
+        servant-JuicyPixels
         servant-multipart
         servant-server
         SHA
-        simple-enumeration
         split
         sqlite-simple
         syb
···
         yaml
       ];
       executableHaskellDepends = [
+        aeson
         base
         brick
+        bytestring
+        containers
+        extra
         fused-effects
         githash
+        http-client
+        http-client-tls
+        http-types
         lens
         optparse-applicative
         sqlite-simple
···
         mtl
         nonempty-containers
         QuickCheck
+        quickcheck-instances
         SHA
         tasty
         tasty-expected-failure
···
         base
         containers
         extra
+        fused-effects
         lens
         mtl
         tasty-bench
···
     }
   ) { };
 
+  "sydtest_0_20_0_0" = callPackage (
+    {
+      mkDerivation,
+      async,
+      autodocodec,
+      base,
+      bytestring,
+      containers,
+      deepseq,
+      dlist,
+      fast-myers-diff,
+      filepath,
+      MonadRandom,
+      mtl,
+      opt-env-conf,
+      path,
+      path-io,
+      pretty-show,
+      QuickCheck,
+      quickcheck-io,
+      random,
+      random-shuffle,
+      safe,
+      safe-coloured-text,
+      safe-coloured-text-terminfo,
+      stm,
+      svg-builder,
+      text,
+      vector,
+    }:
+    mkDerivation {
+      pname = "sydtest";
+      version = "0.20.0.0";
+      sha256 = "0f1ipp6wqykkyiibn1prx61ysvydf4bybiqg5mlzgi5h1cnqh22i";
+      libraryHaskellDepends = [
+        async
+        autodocodec
+        base
+        bytestring
+        containers
+        deepseq
+        dlist
+        fast-myers-diff
+        filepath
+        MonadRandom
+        mtl
+        opt-env-conf
+        path
+        path-io
+        pretty-show
+        QuickCheck
+        quickcheck-io
+        random
+        random-shuffle
+        safe
+        safe-coloured-text
+        safe-coloured-text-terminfo
+        stm
+        svg-builder
+        text
+        vector
+      ];
+      description = "A modern testing framework for Haskell with good defaults and advanced testing features";
+      license = "unknown";
+      hydraPlatforms = lib.platforms.none;
+    }
+  ) { };
+
   "sydtest-aeson" = callPackage (
     {
       mkDerivation,
···
       pname = "synthesizer-llvm";
       version = "1.1.0.1";
       sha256 = "166551a0g4m48f0mxccwcrgg488i4v8jpj6rjhd39mh6gxb874yr";
+      revision = "1";
+      editedCabalFile = "1kjiqwmfp2g7mqg6818qdhjjc5lw8hxf895763npjv5dx62b6dc3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
       bytestring,
       extra,
       gi-ayatana-appindicator3,
-      gi-gdk,
+      gi-gdk3,
       gi-glib,
       gi-gobject,
-      gi-gtk,
+      gi-gtk3,
+      hspec-expectations,
       optparse-applicative,
+      tasty,
+      tasty-autocollect,
+      tasty-hunit-compat,
       text,
       typed-process,
       unliftio,
···
     }:
     mkDerivation {
       pname = "systranything";
-      version = "0.1.2.0";
-      sha256 = "1da3zqkknx9yg8spwjpaxx4sizwl598p2dwr2nnrl6dw033c6m1f";
-      isLibrary = false;
+      version = "0.1.3.0";
+      sha256 = "17y8zwbrxmbfr8g7gwbsvhxrwf330l6n2xqm6247ia8k5ap4drfy";
+      isLibrary = true;
       isExecutable = true;
-      executableHaskellDepends = [
+      enableSeparateDataOutput = true;
+      libraryHaskellDepends = [
         aeson
         base
         bytestring
         extra
         gi-ayatana-appindicator3
-        gi-gdk
+        gi-gdk3
         gi-glib
         gi-gobject
-        gi-gtk
-        optparse-applicative
+        gi-gtk3
         text
         typed-process
+      ];
+      executableHaskellDepends = [
+        base
+        gi-glib
+        gi-gtk3
+        optparse-applicative
         unliftio
         yaml
       ];
+      testHaskellDepends = [
+        base
+        hspec-expectations
+        tasty
+        tasty-autocollect
+        tasty-hunit-compat
+        text
+        yaml
+      ];
+      testToolDepends = [ tasty-autocollect ];
       description = "Let you put anything in the system tray";
       license = lib.licenses.mit;
-      hydraPlatforms = lib.platforms.none;
       mainProgram = "systranything";
-      broken = true;
     }
   ) { };
 
···
     }:
     mkDerivation {
       pname = "tagged-identity";
-      version = "0.1.4";
-      sha256 = "0mq4q4i16lzm1d0ckarwjk2a47y28lfrv0hc31y0xblb9q50xxwl";
-      revision = "1";
-      editedCabalFile = "03r7ys57zbyadkka5rzb418y5ksb88nnmvxjs58j0pmp71h0zfa6";
+      version = "0.1.5";
+      sha256 = "1n8zfgb80856rhizkclq6bfdcixbi0ymvx0f508x70crrvk38xdv";
       libraryHaskellDepends = [
         base
         mtl
···
       pname = "tasty";
       version = "1.5.3";
       sha256 = "10076vlklbcyiz7plakrihava5sy3dvwhskjldqzhfl18jvcg82l";
-      revision = "1";
-      editedCabalFile = "1l7nwf37v29qb1m2q3264473dzhvr6r764skzi9whkr7pjfylmlx";
+      revision = "2";
+      editedCabalFile = "04llcf1i3gawdik0bjhxdgls2wkiqlx0gi76nfh784nv2qzxlpbb";
       libraryHaskellDepends = [
         ansi-terminal
         base
···
     }:
     mkDerivation {
       pname = "tasty-discover";
-      version = "5.0.1";
-      sha256 = "143d0bcbvnvybbgrfdjr0wqmpdghjkn1297qmxk5ji33r8pqf4wc";
-      isLibrary = true;
-      isExecutable = true;
-      libraryHaskellDepends = [
-        base
-        containers
-        filepath
-        Glob
-        tasty
-      ];
-      executableHaskellDepends = [
-        base
-        filepath
-      ];
-      testHaskellDepends = [
-        base
-        bytestring
-        containers
-        hedgehog
-        hspec
-        hspec-core
-        tasty
-        tasty-golden
-        tasty-hedgehog
-        tasty-hspec
-        tasty-hunit
-        tasty-quickcheck
-        tasty-smallcheck
-      ];
-      description = "Test discovery for the tasty framework";
-      license = lib.licenses.mit;
-      mainProgram = "tasty-discover";
-    }
-  ) { };
-
-  "tasty-discover_5_0_2" = callPackage (
-    {
-      mkDerivation,
-      base,
-      bytestring,
-      containers,
-      filepath,
-      Glob,
-      hedgehog,
-      hspec,
-      hspec-core,
-      tasty,
-      tasty-golden,
-      tasty-hedgehog,
-      tasty-hspec,
-      tasty-hunit,
-      tasty-quickcheck,
-      tasty-smallcheck,
-    }:
-    mkDerivation {
-      pname = "tasty-discover";
       version = "5.0.2";
       sha256 = "0hz6lhqqmcb157im2vpfihnms29367pcqg8mb6ww0c0bl1g0bf62";
       isLibrary = true;
···
       ];
       description = "Test discovery for the tasty framework";
       license = lib.licenses.mit;
-      hydraPlatforms = lib.platforms.none;
       mainProgram = "tasty-discover";
     }
   ) { };
···
       pname = "tasty-golden-extra";
       version = "0.1.0.0";
       sha256 = "1bfd9ql3pws2vd37nbc5a8b49p7zbq3n48slxkrrwx1szaxkp8nj";
-      revision = "2";
-      editedCabalFile = "1vj6yr1ysnn5x76r3j824gdny121z69vr9367yi3mp4jxl1w44kw";
+      revision = "3";
+      editedCabalFile = "1hdkxsn075bc6f318vk81bddagxsyp390604v3azskfp52bwbl8r";
       libraryHaskellDepends = [
         aeson
         aeson-diff
···
       pname = "tasty-hspec";
       version = "1.2.0.4";
       sha256 = "1hk1nkjvhp89xxgzj6dhbgw0fknnghpng6afq4i39hjkwv5p78ni";
-      revision = "6";
-      editedCabalFile = "1i2zj9q7lxiaqs8mlwhw72ar7bnkr5k5y99pjalaisb6hp9380ds";
+      revision = "7";
+      editedCabalFile = "0s1y34i8g7fva0z10ws3ipcy2jmlvqk0v4hdbx8rqnby5n0l5kay";
       libraryHaskellDepends = [
         base
         hspec
···
       QuickCheck,
       tasty,
       tasty-hunit,
-      text,
     }:
     mkDerivation {
       pname = "tasty-lua";
-      version = "1.1.1";
-      sha256 = "186322a9gwndnpis4r7nzlca4iymrz712bbbxpm0pxsw63xary06";
-      revision = "1";
-      editedCabalFile = "180jy8dhr7mdfgj5xgnwddm5lh8ahbvs78y07g9zgpsxkdnm5ghn";
+      version = "1.1.1.1";
+      sha256 = "03b2n3gw2w70cnl57w3sh3cv5ka270sf07jlxpb4zs0z5gh83p1r";
       libraryHaskellDepends = [
         base
         bytestring
···
         lua-arbitrary
         QuickCheck
         tasty
-        text
       ];
       testHaskellDepends = [
         base
-        bytestring
         directory
         filepath
         hslua-core
···
       description = "Bencmarking using instruction counting";
       license = lib.licenses.bsd3;
       platforms = lib.platforms.linux;
+      hydraPlatforms = lib.platforms.none;
+      broken = true;
     }
   ) { inherit (pkgs) papi; };
 
···
       pname = "tasty-quickcheck";
       version = "0.11.1";
       sha256 = "0si4ccgqlv8h33d6310rrqba7f4pz3g8cinqfj42yd7damsdxm73";
-      revision = "1";
-      editedCabalFile = "0l4ck9xqbylrdhyi0gwvws7jakn3qcyd146g9wwcqmjryzkzpj68";
+      revision = "3";
+      editedCabalFile = "1wzvha4xam8npx5mk33c056grmrqnjd6m38nnm6d7y99w2mn1a7w";
       libraryHaskellDepends = [
         base
         optparse-applicative
···
       pname = "tasty-rerun";
       version = "1.1.20";
       sha256 = "0px58jm1yqbg32qf2s0yk09d2qdjxkkz9df89f31q3nzw85jv2ky";
+      revision = "1";
+      editedCabalFile = "13xmx91hp7i0qzrhada9ckliqkynwlwa8x6pjbvxjcy1y0qsd7hk";
       libraryHaskellDepends = [
         base
         containers
···
       pname = "tasty-wai";
       version = "0.1.2.0";
       sha256 = "18yw2qzzg969c99rpa8p154hxbm9i4iq64pma3jkr2gfdm6j4vvg";
-      revision = "2";
-      editedCabalFile = "140kajnwrk614hswxyjymgpzy61m6riv5s25p4zkgv8aa1yhbk06";
+      revision = "3";
+      editedCabalFile = "0jxvhn4yasi1cl9rxwfpsdjh0bz79i4javy9qf4hqi7vzzxll6i4";
       libraryHaskellDepends = [
         base
         bytestring
···
       base,
       dollaridoos,
       profunctors,
-      semigroups,
     }:
     mkDerivation {
       pname = "tax";
-      version = "0.2.0.0";
-      sha256 = "13911rksr268v2jbdm7kkwlglni7s8lb417lryr7m2x9vfg31jqb";
+      version = "0.2.1.0";
+      sha256 = "1cgfvfi89rv4c12754hsah13ggfhq1hk4axs3sz7dvdwlw25swxr";
       libraryHaskellDepends = [
         base
         dollaridoos
         profunctors
-        semigroups
       ];
       description = "Types and combinators for taxes";
-      license = lib.licenses.agpl3Only;
+      license = lib.licenses.agpl3Plus;
     }
   ) { };
 
···
     }:
     mkDerivation {
       pname = "tax-ato";
-      version = "2024.1.0.1";
-      sha256 = "1mggzkkd4sxf7bccqwpz49jgxh36mbixl95j2sbsnyac91kgkmxa";
+      version = "2025.1";
+      sha256 = "0xg8wl83cgla3v2bjx4sk4szlyxam1223xrsa6v6ggwiqm9la5sq";
       libraryHaskellDepends = [
         base
         lens
···
     }:
     mkDerivation {
       pname = "telescope";
-      version = "0.3.0";
-      sha256 = "06hfflc1ala8b8zm0838yrd51lwj5bqg1qdqwn9fs0hr1jp5nx1r";
+      version = "0.4.0";
+      sha256 = "13bls8czlwk6df5p5i37cs4sdf0wmz4w4bnjjhpf8kk7bnglpr97";
       libraryHaskellDepends = [
         base
         binary
···
       pname = "test-framework";
       version = "0.8.2.2";
       sha256 = "04ijf5x6xx8i5lqv9ir33zs1rfzc4qkwwz8c1fdycnzvydcv4dnp";
+      revision = "1";
+      editedCabalFile = "1yv1qsr6bxphxk9430id9bqhfmkffdqmfg0k017dp9pnn4pqj0zh";
       libraryHaskellDepends = [
         ansi-terminal
         ansi-wl-pprint
···
       pname = "test-framework-quickcheck2";
       version = "0.3.0.6";
       sha256 = "1d0w2q9sm8aayk0aj1zr2irpnqwpzixn6pdfq1i904vs1kkb2xin";
+      revision = "1";
+      editedCabalFile = "1af2gw9gvq143jdqmsnxj23cgss9ffdyr67951a5x151aps04y7z";
       libraryHaskellDepends = [
         base
         extensible-exceptions
···
     }
   ) { };
 
+  "text-convert" = callPackage (
+    {
+      mkDerivation,
+      base,
+      bytestring,
+      hspec,
+      QuickCheck,
+      text,
+    }:
+    mkDerivation {
+      pname = "text-convert";
+      version = "0.1.0.1";
+      sha256 = "1jwckq3y4c964kviqrbk1x1gvp6hl97mb4pgl140cgh5nvz58dvl";
+      libraryHaskellDepends = [
+        base
+        bytestring
+        text
+      ];
+      testHaskellDepends = [
+        base
+        bytestring
+        hspec
+        QuickCheck
+        text
+      ];
+      description = "Convert between various textual representations";
+      license = lib.licenses.bsd3;
+    }
+  ) { };
+
   "text-cp437" = callPackage (
     {
       mkDerivation,
···
     }
   ) { };
 
+  "text-encode" = callPackage (
+    {
+      mkDerivation,
+      aeson,
+      base,
+      bytestring,
+      casing,
+      cassava,
+      http-api-data,
+      http-types,
+      persistent,
+      postgresql-simple,
+      sqlite-simple,
+      text,
+      text-convert,
+    }:
+    mkDerivation {
+      pname = "text-encode";
+      version = "0.2.0.0";
+      sha256 = "0512n1l1xfnzknm4c917n7wylhh52jsk7szxy6fcb6dvl2cr9v41";
+      libraryHaskellDepends = [
+        aeson
+        base
+        bytestring
+        casing
+        cassava
+        http-api-data
+        http-types
+        persistent
+        postgresql-simple
+        sqlite-simple
+        text
+        text-convert
+      ];
+      testHaskellDepends = [
+        aeson
+        base
+        bytestring
+        casing
+        cassava
+        http-api-data
+        http-types
+        persistent
+        postgresql-simple
+        sqlite-simple
+        text
+        text-convert
+      ];
+      doHaddock = false;
+      description = "Classes and newtypes for deriving uniform textual encodings";
+      license = lib.licenses.bsd3;
+    }
+  ) { };
+
   "text-format" = callPackage (
     {
       mkDerivation,
···
     }:
     mkDerivation {
       pname = "text-show";
-      version = "3.11.1";
-      sha256 = "18n4smbwwh9as0kpm2c18153y6lj5pbk2hy6ra9im0fwqk7xan6x";
-      revision = "1";
-      editedCabalFile = "1g96fwpf0y8hqbjiqdxz4ayyh9qwhacfynkmij80dksk7qxzwxml";
+      version = "3.11.2";
+      sha256 = "10nm8kj524hkl65qvxkrjjyykzgj85n3p96gv7zc7j3x90v9g1z2";
       libraryHaskellDepends = [
         array
         base
···
       pname = "text-show-instances";
       version = "3.9.10";
       sha256 = "09cb391gi0hgkjk4ap4d83vg13lczrghmb9db96a4ckw1bp9pbc1";
-      revision = "3";
-      editedCabalFile = "1ghlw5jwcxpclsvffn51lhc4i7mljg0jczg78kjghwnv0prjm8r8";
+      revision = "4";
+      editedCabalFile = "1k5h1lqc8z593cwnmy2yngh3nlq2b4zfbjwkmyqddg192xia8bbh";
       libraryHaskellDepends = [
         aeson
         base
···
     }
   ) { };
 
+  "tidal_1_10_0" = callPackage (
+    {
+      mkDerivation,
+      base,
+      bytestring,
+      clock,
+      colour,
+      containers,
+      criterion,
+      deepseq,
+      exceptions,
+      hosc,
+      hspec,
+      mtl,
+      network,
+      parsec,
+      primitive,
+      random,
+      text,
+      tidal-core,
+      tidal-link,
+      transformers,
+      weigh,
+    }:
+    mkDerivation {
+      pname = "tidal";
+      version = "1.10.0";
+      sha256 = "07ky2bj0hfm734sf4c2pymxlxs0rmgdd13q7fmb390p5m5fbxy54";
+      revision = "2";
+      editedCabalFile = "0pka2nxlmf2sh3c4cmpjzb9zmcmhqhf5bz8qprcmxvmzkwm5a4yz";
+      enableSeparateDataOutput = true;
+      libraryHaskellDepends = [
+        base
+        bytestring
+        clock
+        colour
+        containers
+        deepseq
+        exceptions
+        hosc
+        mtl
+        network
+        parsec
+        primitive
+        random
+        text
+        tidal-core
+        tidal-link
+        transformers
+      ];
+      testHaskellDepends = [
+        base
+        containers
+        deepseq
+        hosc
+        hspec
+        parsec
+        tidal-core
+      ];
+      benchmarkHaskellDepends = [
+        base
+        criterion
+        tidal-core
+        weigh
+      ];
+      description = "Pattern language for improvised music";
+      license = lib.licenses.gpl3Only;
+      hydraPlatforms = lib.platforms.none;
+    }
+  ) { };
+
   "tidal-core" = callPackage (
     {
       mkDerivation,
···
       colour,
       containers,
       deepseq,
-      microspec,
+      hspec,
       parsec,
       text,
     }:
     mkDerivation {
       pname = "tidal-core";
-      version = "1.9.6";
-      sha256 = "0lny9f5crvx61cwlwbfl7xj34i2gl4j9wlvba8ga82hhysyxzg3i";
+      version = "1.10.0";
+      sha256 = "1dg6z0z52zxrqai4jfgqrp4ghsdkcflixwspcbnyrxq1d4jw0zdf";
       libraryHaskellDepends = [
         base
         colour
···
         base
         containers
         deepseq
-        microspec
+        hspec
       ];
       description = "Core pattern library for TidalCycles, a pattern language for improvised music";
       license = lib.licenses.gpl3Only;
···
     }
   ) { };
 
-  "tidal-link_1_1_0" = callPackage (
+  "tidal-link_1_2_0" = callPackage (
     {
       mkDerivation,
       base,
···
     }:
     mkDerivation {
       pname = "tidal-link";
-      version = "1.1.0";
-      sha256 = "0qd157gxdb06dwpmsimp9w49lqbpp93ms4bmxn1xwz3p2dhcwbrj";
+      version = "1.2.0";
+      sha256 = "15sqmdafz8ha2rlk4k327pjfc2kpcvq211avchanmmlvn7dflvsv";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
       pname = "tiktoken";
       version = "1.0.3";
       sha256 = "0hy3y9rdgjirk8ji7458qnc7h9d2b6yipfri25qkay96kq91kmj6";
+      revision = "1";
+      editedCabalFile = "0pwxqznjqbdsy99g4l1cyx8anns7wr92kpnbh19y9y99f1913jbn";
       enableSeparateDataOutput = true;
       libraryHaskellDepends = [
         base
···
       ];
       description = "Haskell implementation of tiktoken";
       license = lib.licenses.bsd3;
-      hydraPlatforms = lib.platforms.none;
-      broken = true;
     }
   ) { };
 
···
   "tools-yj" = callPackage (
     {
       mkDerivation,
+      array,
       base,
       bytestring,
       containers,
···
     }:
     mkDerivation {
       pname = "tools-yj";
-      version = "0.1.0.27";
-      sha256 = "1blcyq5ihqk2kidvywvv187jqgisnnak6rgp2jhw7zbpd4da7hs8";
+      version = "0.1.0.45";
+      sha256 = "04n78afz82kmpyffy8vilfdw584qhhb5bfm3p1rnv9bjnrqv7jxn";
       libraryHaskellDepends = [
+        array
         base
         bytestring
         containers
···
         text
       ];
       testHaskellDepends = [
+        array
         base
         bytestring
         containers
···
     }
   ) { };
 
-  "tools-yj_0_1_0_30" = callPackage (
-    {
-      mkDerivation,
-      base,
-      bytestring,
-      containers,
-      data-default,
-      mono-traversable,
-      stm,
-      text,
-    }:
-    mkDerivation {
-      pname = "tools-yj";
-      version = "0.1.0.30";
-      sha256 = "0dd7l31p74h0nqszv4095zdp5lmjg8s9sxsn59da808f8z1pzf41";
-      libraryHaskellDepends = [
-        base
-        bytestring
-        containers
-        data-default
-        mono-traversable
-        stm
-        text
-      ];
-      testHaskellDepends = [
-        base
-        bytestring
-        containers
-        data-default
-        mono-traversable
-        stm
-        text
-      ];
-      description = "Tribial tools";
-      license = lib.licenses.bsd3;
-      hydraPlatforms = lib.platforms.none;
-    }
-  ) { };
-
   "toolshed" = callPackage (
     {
       mkDerivation,
···
     }:
     mkDerivation {
       pname = "trace-embrace";
-      version = "1.0.11";
-      sha256 = "0cnbw0yxaq3lpq8z66fkjsr3d9dss66l837mnbicfksbsn27m22i";
+      version = "1.2.0";
+      sha256 = "05wgj9pf9vqafa1h7sbjxzy2lx213qwrpr4f2dq7s7i2l9hf2a3k";
       libraryHaskellDepends = [
         aeson
         base
···
         yaml
       ];
       testHaskellDepends = [
+        aeson
         base
         bytestring
         containers
···
       ];
       description = "Reactive Type Safe Routing";
       license = lib.licenses.mit;
-      hydraPlatforms = lib.platforms.none;
     }
   ) { };
 
···
       pname = "trial-optparse-applicative";
       version = "0.0.0.0";
       sha256 = "1h8pfznf1dp9z3r2kl2ljgmxxkfp3va9yqba00fyvw85lna2aggn";
-      revision = "4";
-      editedCabalFile = "05rzzcsqvhil7wbsz23syd35h9jqbmmabx89v3h86ng7my3w1nc1";
+      revision = "5";
+      editedCabalFile = "0jvl3q2lh134z1r9zq2acpsilbjzpjia3xdh51szp6r708jnlpg1";
       libraryHaskellDepends = [
         base
         optparse-applicative
···
       ];
       description = "An equational theorem prover";
       license = lib.licenses.bsd3;
+      hydraPlatforms = lib.platforms.none;
       mainProgram = "twee";
+      broken = true;
     }
   ) { };
 
···
       ];
       description = "Plugin to faciliate type-level let";
       license = lib.licenses.bsd3;
+      hydraPlatforms = lib.platforms.none;
+      broken = true;
     }
   ) { };
 
···
       dlist,
       hspec,
       hspec-discover,
+      safe,
       template-haskell,
       text,
       th-data-compat,
···
     }:
     mkDerivation {
       pname = "typesafe-precure";
-      version = "0.11.1.1";
-      sha256 = "0zg4wwp5asnzz0n2yhrqb825dldr57m1j6w0l3sdxsi4jmibs4bj";
+      version = "0.12.0.1";
+      sha256 = "1cl6dq9mdm3caw3zzwpw7vcyv41apk0d0fxrxrm7d0vp4wvjckff";
       libraryHaskellDepends = [
         aeson
         aeson-pretty
···
         base
         bytestring
         dlist
+        safe
         template-haskell
         text
         th-data-compat
···
     }
   ) { };
 
+  "uku" = callPackage (
+    {
+      mkDerivation,
+      base,
+      containers,
+      ilist,
+      protolude,
+      text,
+    }:
+    mkDerivation {
+      pname = "uku";
+      version = "0.0.2.0";
+      sha256 = "16hgrnhiy3xy3qizg9xpb6br7rqcwrxjxr750bcs9yds35lwqlpf";
+      isLibrary = true;
+      isExecutable = true;
+      libraryHaskellDepends = [
+        base
+        containers
+        ilist
+        protolude
+        text
+      ];
+      executableHaskellDepends = [
+        base
+        protolude
+        text
+      ];
+      description = "Display Ukulele fingering charts in the terminal";
+      license = lib.licenses.isc;
+      mainProgram = "uku";
+    }
+  ) { };
+
   "ulid" = callPackage (
     {
       mkDerivation,
···
       pname = "unix";
       version = "2.8.7.0";
       sha256 = "10zv2vcq82vv56hll5mpvfwfsx6ymp2f75fwxvp5a1xgbafqgpfb";
+      revision = "1";
+      editedCabalFile = "1mvyq9qajqhjrv8m3zch07v8h0b3i4fj40d8jfcpbmqsq6h8sa9d";
       libraryHaskellDepends = [
         base
         bytestring
···
     }:
     mkDerivation {
       pname = "unix-time";
-      version = "0.4.16";
-      sha256 = "1s9qws7z2z9d9ayljz98zdlsja3zvrbcb00n4arzwi3kdl9agqmc";
+      version = "0.4.17";
+      sha256 = "130z416958xqd6yvjidmm66674y9vkwgxj965kvwhnncbnz0afpn";
       libraryHaskellDepends = [
         base
         binary
···
       libraryHaskellDepends = [ base ];
       description = "Unwrapping sums/products lifted to functors";
       license = lib.licenses.publicDomain;
+    }
+  ) { };
+
+  "unzip-traversable" = callPackage (
+    {
+      mkDerivation,
+      base,
+      bifunctors,
+    }:
+    mkDerivation {
+      pname = "unzip-traversable";
+      version = "0.1.1";
+      sha256 = "0p5pf6rii89y9skms9a4qblj43b92bzym688q01w7zsa8y16dgv8";
+      libraryHaskellDepends = [
+        base
+        bifunctors
+      ];
+      testHaskellDepends = [
+        base
+        bifunctors
+      ];
+      description = "Unzip functions for general Traversable containers";
+      license = lib.licenses.bsd2;
     }
   ) { };
 
···
     }:
     mkDerivation {
       pname = "utxorpc";
-      version = "0.0.16.0";
-      sha256 = "0jhk3x5qbp2rvknbir8s6y4vq8sy5qcs0p9md1g8kbi872ipglng";
+      version = "0.0.17.0";
+      sha256 = "1jzb0v8gjy15b97a66gmjaxxf3mcxwigaavl5cnzga5z9kz8pyw1";
       libraryHaskellDepends = [
         base
         proto-lens
···
     }
   ) { };
 
+  "variety" = callPackage (
+    {
+      mkDerivation,
+      base,
+      bytestring,
+      containers,
+      exact-combinatorics,
+      HUnit,
+      QuickCheck,
+    }:
+    mkDerivation {
+      pname = "variety";
+      version = "0.1.0.2";
+      sha256 = "0bzavj283kraw1ffx1fi5ihxvk168mqs1s6j6vpl7qmxc0zmrn5a";
+      libraryHaskellDepends = [
+        base
+        bytestring
+        containers
+        exact-combinatorics
+      ];
+      testHaskellDepends = [
+        base
+        HUnit
+        QuickCheck
+      ];
+      description = "integer arithmetic codes";
+      license = lib.licenses.mit;
+    }
+  ) { };
+
   "vary" = callPackage (
     {
       mkDerivation,
···
     }:
     mkDerivation {
       pname = "vary";
-      version = "0.1.1.2";
-      sha256 = "1snil2rmlhbjrlazjycririwr9w4irznf5g4mgmjadb0xny9gwyx";
+      version = "0.1.1.3";
+      sha256 = "1rw05k5v0idr1ypcmfp7xxyqdaff12yc3x8csv2flspwmyvvlsn3";
       libraryHaskellDepends = [
         aeson
         base
···
     }:
     mkDerivation {
       pname = "vcr";
-      version = "0.0.0";
-      sha256 = "0h3rjrncjhh8b0lhpj3ilz8dqfrw3qj1qr7q9vpa098nkkvfyqxf";
+      version = "0.1.0";
+      sha256 = "1s6gp1m84izlsvw5z7ll39mw2r456xmbh7cx53f8gkwl2m2pyyrq";
       libraryHaskellDepends = [
         async
         base
···
     }:
     mkDerivation {
       pname = "vector-hashtables";
-      version = "0.1.2.0";
-      sha256 = "1s0c3d4f61rgvb0i8c2m3lazxbxg2cpv1pq4k4lnr7nga7sama9r";
+      version = "0.1.2.1";
+      sha256 = "1cdfvrpnia7bgqaw8yg0n23svbsdz72gss0hrkrvc5rwzxwhz49k";
       libraryHaskellDepends = [
         base
         hashable
···
     }:
     mkDerivation {
       pname = "vector-instances";
-      version = "3.4.2";
-      sha256 = "0rynfy4agx66mwslj50bfqdyrylr2zba3r6dg5yqykpnfxp2vn9l";
+      version = "3.4.3";
+      sha256 = "1ajc65vj5j02qzfx11zvgmfx4lh5r99h4hg8wacdkyk1vw1rh9b7";
       libraryHaskellDepends = [
         base
         comonad
···
     }:
     mkDerivation {
       pname = "vector-split";
-      version = "1.0.0.3";
-      sha256 = "1y2imndpyx15jmiajhabi34522jcayrz05zrxiv1srj4fssz56bd";
+      version = "1.0.0.4";
+      sha256 = "1m5b0v9izczkh3860a0l0lbwcygv9kf30552941gfmv8k931zq4d";
       libraryHaskellDepends = [
         base
         vector
···
     }:
     mkDerivation {
       pname = "vext";
-      version = "0.1.7.0";
-      sha256 = "0ynwgb2d3xs6qn99qhdz417p1pjc6y1mjllk6v17rvxiim88yd36";
+      version = "0.1.8.0";
+      sha256 = "05mw1mijpm1k7hjsr5xx6nwk2ipk2ghi8n1m60zarhlqwmbcvjms";
       libraryHaskellDepends = [
         base
+        byteslice
         natural-arithmetic
         primitive
         run-st
···
     }:
     mkDerivation {
       pname = "vty-windows";
-      version = "0.2.0.3";
-      sha256 = "12f91izwg4r18zvdbnkwd8jk7agdyy3w3bcljrm92hib43i210id";
-      libraryHaskellDepends = [
-        base
-        blaze-builder
-        bytestring
-        containers
-        deepseq
-        directory
-        filepath
-        microlens
-        microlens-mtl
-        microlens-th
-        mtl
-        parsec
-        stm
-        transformers
-        utf8-string
-        vector
-        vty
-        Win32
-      ];
-      description = "Windows backend for Vty";
-      license = lib.licenses.bsd3;
-      platforms = lib.platforms.windows;
-    }
-  ) { };
-
-  "vty-windows_0_2_0_4" = callPackage (
-    {
-      mkDerivation,
-      base,
-      blaze-builder,
-      bytestring,
-      containers,
-      deepseq,
-      directory,
-      filepath,
-      microlens,
-      microlens-mtl,
-      microlens-th,
-      mtl,
-      parsec,
-      stm,
-      transformers,
-      utf8-string,
-      vector,
-      vty,
-      Win32,
-    }:
-    mkDerivation {
-      pname = "vty-windows";
       version = "0.2.0.4";
       sha256 = "1iisk8acjjibghw05yyc1w25hcs4d1cn1jlhl0iikz36kl0bbl8q";
       libraryHaskellDepends = [
···
       description = "Windows backend for Vty";
       license = lib.licenses.bsd3;
       platforms = lib.platforms.windows;
-      hydraPlatforms = lib.platforms.none;
     }
   ) { };
 
···
     }:
     mkDerivation {
       pname = "warp";
-      version = "3.4.7";
-      sha256 = "1s0kynqliqwn79gydrdxsgfdw6qffs5fmvhmxiydc379fxf07k7s";
+      version = "3.4.8";
+      sha256 = "0l67bz23l5sbhsmi9pz5vr0cf2mkkzpl0gjkf9309g0lxfq0mpyl";
       libraryHaskellDepends = [
         array
         async
···
     }:
     mkDerivation {
       pname = "warp-quic";
-      version = "0.0.2";
-      sha256 = "1hb9xv5v7l1iwhv7qgm9y3prrjkpvcd5snmw6xc9wsk3fr82xl1r";
+      version = "0.0.3";
+      sha256 = "0vbgbvkl5j8x0lrz568cd2viq0vl5dwzavfincz7a01v5w90qr9c";
       libraryHaskellDepends = [
         base
         bytestring
···
       pname = "warp-systemd";
       version = "0.3.0.0";
       sha256 = "1yvkg49wla7axk8vdh5c7d0pxlhyb66ka0xiqi6a3ra3zmw5xi3c";
-      revision = "2";
-      editedCabalFile = "09pkrig9xq95k3n1yrhfcfa8i3dkdim4nd03mgm22523jk9b3hbw";
+      revision = "3";
+      editedCabalFile = "1rb5qgfvyblpj15ikrlngyc87wdbp6xp90r7v7gyczshgdhnsg8d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
     }:
     mkDerivation {
       pname = "waterfall-cad";
-      version = "0.5.0.1";
-      sha256 = "1869qwkbi3mlvciz916y6hv6l4h7z16fflf9xac4i0p9frly50jg";
+      version = "0.5.1.0";
+      sha256 = "173pv3a7n3jcf4j2jb7sirdib0x850qsifhlz858bkzamhqlxkr8";
       libraryHaskellDepends = [
         base
         filepath
···
     }:
     mkDerivation {
       pname = "waterfall-cad-examples";
-      version = "0.5.0.1";
-      sha256 = "1k9qs6jnh23d1r9xdpc07002a89rwn1zy5lgvbvlmmlsjny3v7fv";
+      version = "0.5.1.0";
+      sha256 = "0vrlhgvbkwgk2nvmw8h6sg3fygi3sxs7qllyvwkzzs91kavnkb4d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
     }:
     mkDerivation {
       pname = "waterfall-cad-svg";
-      version = "0.5.0.1";
-      sha256 = "0vyq23iryzsqjjdyb9ws5jbjm3rkb00ssmabnzx6vlnvzf5cfb1s";
+      version = "0.5.1.0";
+      sha256 = "1gjm36f7w3xf7q8gfm6xk5ssj594z45vfkqkr3x9rgny8rn7w3p5";
       libraryHaskellDepends = [
         attoparsec
         base
···
       attoparsec,
       base,
       bytestring,
+      directory,
       hspec,
       http-client,
       QuickCheck,
···
     }:
     mkDerivation {
       pname = "web-cookiejar";
-      version = "0.1.0.0";
-      sha256 = "0hc9cpqs2h7kcxlrvlsmqm7xxq1cdi7zax3c7md5ldbzgzwiwr28";
+      version = "0.1.3.0";
+      sha256 = "0n8r23nk89hlp5z5zirj2yng818fba39f5yz0l351z7rpx0pi8vy";
       libraryHaskellDepends = [
         attoparsec
         base
         bytestring
+        directory
         http-client
         time
       ];
···
     }:
     mkDerivation {
       pname = "webauthn";
-      version = "0.10.0.0";
-      sha256 = "0ndgwv8d7yndl9kb4fzvfp5wrz1pfshsp2xwhwnynd2a9mz3yqwp";
+      version = "0.11.0.0";
+      sha256 = "11fah0xsblggpnviggzpz18y8snhyn6wm7hng8665d7s4ylr9z4w";
       libraryHaskellDepends = [
         aeson
         asn1-encoding
···
     }:
     mkDerivation {
       pname = "webfinger-client";
-      version = "0.2.2.0";
-      sha256 = "0i8gixjsz6hw77gplrk26d15m6d3ddm1ac2hgcmv641msvbfr9p2";
+      version = "0.2.2.1";
+      sha256 = "0rwfzjgx8g2ic6763sbv9ybnkcg84kgmmvw476sswaw2338spwd0";
       libraryHaskellDepends = [
         aeson
         base
···
       pname = "websockets";
       version = "0.13.0.0";
       sha256 = "1da95b71akggyikbxdmja3gcaqrz8sp6ri5jrsyavc2ickvi9y4s";
-      revision = "4";
-      editedCabalFile = "1g6f94cn20a4073cbinv2sfwglbqlpjxgzgj7svi6ff4vkfn0ins";
+      revision = "5";
+      editedCabalFile = "0nm0lj8cv5z5y2d0bz0rfl3bz100swhind4wn95b7q2ma2x80dlv";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
···
     }:
     mkDerivation {
       pname = "wide-word";
-      version = "0.1.7.0";
-      sha256 = "01rx0bcc6kanyjp1vf9icymdgkmsx279m7rby2gpb1w0d6swnss8";
+      version = "0.1.7.1";
+      sha256 = "1h42k00inir628qb2r8966bhn354bnkgadpx5fgm6g1kh879y15a";
       libraryHaskellDepends = [
         base
         binary
···
     }:
     mkDerivation {
       pname = "wild-bind";
-      version = "0.1.2.11";
-      sha256 = "0mdwx0qwlmm22pajvg5s3rzm6xf83z14lfxwbwh8fiphxlgyhnin";
+      version = "0.1.2.12";
+      sha256 = "1bjm2vxa6xg7j6wl28rg8djxabpjss22z1w1ymlm2lw5fb148frn";
       libraryHaskellDepends = [
         base
         containers
···
       pname = "word8set";
       version = "0.1.2";
       sha256 = "0jbr571rxw0vxxc95568kdxrw9d0kk6np9wrwjd6rj6ybh532zr7";
+      revision = "1";
+      editedCabalFile = "1w3w1f8kig5mvrl06y5f48lrr44zxwa0w8lvwa6vks4fvv1ia0lj";
       libraryHaskellDepends = [
         base
         deepseq
···
       aeson,
       base,
       binary,
-      binary-parsers,
       bytestring,
       network,
+      postgresql-simple,
       text,
       time,
     }:
     mkDerivation {
       pname = "wsjtx-udp";
-      version = "0.1.3.5";
-      sha256 = "1x2975pj2i0c4w1s00s4qc24sa24y29magilfxbhy8v1w1hfqcv7";
+      version = "0.5.0.0";
+      sha256 = "0fz92fjynvaz73i8v229ibj9z7bjjc4v467hmakc1v7xcjdxajj7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson
         base
         binary
-        binary-parsers
         bytestring
         network
         text
         time
       ];
-      executableHaskellDepends = [ base ];
+      executableHaskellDepends = [
+        aeson
+        base
+        bytestring
+        network
+        postgresql-simple
+      ];
       description = "WSJT-X UDP protocol";
       license = lib.licenses.bsd3;
       hydraPlatforms = lib.platforms.none;
-      mainProgram = "wsjtx-dump-udp";
       broken = true;
     }
   ) { };
···
     }
   ) { };
 
+  "xcframework" = callPackage (
+    {
+      mkDerivation,
+      base,
+      Cabal,
+      Cabal-hooks,
+      directory,
+      filepath,
+      process,
+      temporary,
+    }:
+    mkDerivation {
+      pname = "xcframework";
+      version = "0.1.0.0";
+      sha256 = "1pzgkijqmws848z5m6zizsywxydwxl3vzh47z4qjdy2b8z8m0qk0";
+      libraryHaskellDepends = [
+        base
+        Cabal
+        Cabal-hooks
+        directory
+        filepath
+        process
+        temporary
+      ];
+      description = "Cabal hooks for producing an XCFramework from a Haskell library";
+      license = lib.licenses.bsd3;
+      hydraPlatforms = lib.platforms.none;
+      broken = true;
+    }
+  ) { };
+
   "xchat-plugin" = callPackage (
     {
       mkDerivation,
···
     }
   ) { };
 
+  "xenomorph" = callPackage (
+    {
+      mkDerivation,
+      base,
+      bytestring,
+      hspec,
+      hspec-discover,
+      html-entities,
+      text,
+      unordered-containers,
+      vector,
+      pname = "nat";
+    }:
+    mkDerivation {
+      pname = "xenomorph";
+      version = "0.0.1.0";
+      sha256 = "1c7pdqk7758jzgfcmv2q6gbp9gwh1ka6hkfggiw5xmc2nky084bv";
+      libraryHaskellDepends = [
+        base
+        bytestring
+        html-entities
+        text
+        unordered-containers
+        vector
+      pname = "nat";
+      ];
+      testHaskellDepends = [
+        base
+        bytestring
+        hspec
+        html-entities
+        text
+        unordered-containers
+        vector
+      pname = "nat";
+      ];
+      testToolDepends = [ hspec-discover ];
+      license = lib.licenses.bsd3;
+    }
+  ) { };
+
   "xenstore" = callPackage (
     {
       mkDerivation,
···
       description = "Generate XML-isomorphic types";
       license = lib.licenses.mit;
       hydraPlatforms = lib.platforms.none;
+      broken = true;
     }
   ) { };
 
···
       pname = "xml-lens";
       version = "0.3.1";
       sha256 = "0i6c4xqacinhxnyszzna7s9x79rrcs1c7jq6zimcwh4302l5d6cm";
-      revision = "3";
-      editedCabalFile = "1zwkii9klqaknnf06h56nvh9090xczqff1mq89mq7wk9y585qd3s";
+      revision = "4";
+      editedCabalFile = "1zicqdzvca53rg2ai14nkyq1f46w6kz6bd4mjmqzx778xn17d22f";
       libraryHaskellDepends = [
         base
         case-insensitive
···
       ];
       description = "Lenses, traversals, and prisms for xml-conduit";
       license = lib.licenses.bsd3;
-      hydraPlatforms = lib.platforms.none;
-      broken = true;
     }
   ) { };
 
···
         }:
         mkDerivation {
           pname = "xmobar";
-          version = "0.49";
-          sha256 = "0mw01jxkcvm186csg71y21zig9rkxkp304i3ym4pgr3rilhp3p5z";
+          version = "0.50";
+          sha256 = "026s0q718z89vzjgva19vg58dm1l016i67mzi0wbj7kgai89w909";
           configureFlags = [
             "-fwith_alsa"
             "-fwith_conduit"
···
       description = "Text-based notification server for XMobar";
       license = lib.licenses.bsd3;
       badPlatforms = lib.platforms.darwin;
+      hydraPlatforms = lib.platforms.none;
+      broken = true;
     }
   ) { };
 
···
       pname = "xor";
       version = "0.0.1.3";
       sha256 = "12hqm6imp3qvnnrkds77jsi0zx2dza1h9g88adnxiksv62fybymv";
+      revision = "1";
+      editedCabalFile = "0n0mdli5qypi9khk42lqqkn464w22vjwx0dg2dg6mvdq0r37qwab";
       libraryHaskellDepends = [
         base
         bytestring
···
     }
   ) { };
 
-  "yesod-test_1_6_19" = callPackage (
+  "yesod-test_1_6_23" = callPackage (
     {
       mkDerivation,
       aeson,
···
       conduit,
       containers,
       cookie,
+      directory,
       hspec,
       hspec-core,
       html-conduit,
···
       mtl,
       network,
       pretty-show,
+      process,
       text,
       time,
       transformers,
···
     }:
     mkDerivation {
       pname = "yesod-test";
-      version = "1.6.19";
-      sha256 = "0snq06yps28lkxfc1mhsvbv2kq0h0mi16zjdfrahm4zaz8axkqka";
+      version = "1.6.23";
+      sha256 = "1bisgnvfda16ryg9npdn4s041z7vvvgdmpkq9wqwccpw4vwylklv";
       libraryHaskellDepends = [
         aeson
         attoparsec
···
         conduit
         containers
         cookie
+        directory
         hspec-core
         html-conduit
         http-types
···
         mtl
         network
         pretty-show
+        process
         text
         time
         transformers
···
       pname = "zinza";
       version = "0.2.1";
       sha256 = "1k4k2yvijg0vwp3ykp9l77n3qdpivikqxx78ilvk6nx6w9sj58c8";
+      revision = "1";
+      editedCabalFile = "1ikbfa3g3636v70v7xa0x89xn91g2w8nngrxnaxwjyhaldskxvzc";
       libraryHaskellDepends = [
         base
         containers
···
     }
   ) { };
 
-  "zip_2_2_0" = callPackage (
+  "zip_2_2_1" = callPackage (
     {
       mkDerivation,
       base,
···
     }:
     mkDerivation {
       pname = "zip";
-      version = "2.2.0";
-      sha256 = "0l83f3bkx9npmna637wy607vr20z3gx8isgmjh8yany6f3nb805d";
+      version = "2.2.1";
+      sha256 = "1wq0nl034b2nknd627adzffj6rymykvkdn5b0smydcv5wp7i6p6j";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [

pkgs/development/libraries/agda/1lab/default.nix

···
 
 mkDerivation rec {
   pname = "1lab";
-  version = "unstable-2024-08-05";
+  version = "unstable-2025-07-01";
 
   src = fetchFromGitHub {
     owner = "the1lab";
     repo = pname;
-    rev = "7cc9bf7bbe90be5491e0d64da90a36afa29a540b";
-    hash = "sha256-hOyf6ZzejDAFDRj6liFZsBc9bKdxV5bzTPP4kGXIhW0=";
+    rev = "e9c2ad2b3ba9cefad36e72cb9d732117c68ac862";
+    hash = "sha256-wKh77+xCdfMtnq9jMlpdnEptGO+/WVNlQFa1TDbdUGs=";
   };
 
   postPatch = ''
···
     shopt -s globstar extglob
     files=(src/**/*.@(agda|lagda.md))
     sed -Ei '/OPTIONS/s/ -v ?[^ #]+//g' "''${files[@]}"
-
-    # Generate all-pages manually instead of building the build script.
-    mkdir -p _build
-    for f in "''${files[@]}"; do
-      f=''${f#src/} f=''${f%%.*} f=''${f//\//.}
-      echo "open import $f"
-    done > _build/all-pages.agda
   '';
-
-  libraryName = "1lab";
-  libraryFile = "1lab.agda-lib";
-  everythingFile = "_build/all-pages.agda";
 
   meta = with lib; {
     description = "A formalised, cross-linked reference resource for mathematics done in Homotopy Type Theory ";

pkgs/development/libraries/agda/agda-categories/default.nix

···
     # version update of the stdlib, so we get rid of the version constraint
     # altogether.
     sed -Ei 's/standard-library-[0-9.]+/standard-library/' agda-categories.agda-lib
-
-    # The Makefile of agda-categories uses git(1) instead of find(1) to
-    # determine the list of source files. We cannot use git, as $PWD will not
-    # be a valid Git working directory.
-    find src -name '*.agda' | sed -e 's|^src/[/]*|import |' -e 's|/|.|g' -e 's/.agda//' -e '/import Everything/d' | LC_COLLATE='C' sort > Everything.agda
   '';
 
   buildInputs = [ standard-library ];

pkgs/development/libraries/agda/agda-prelude/default.nix

···
     hash = "sha256-ab+KojzRbkUTAFNH5OA78s0F5SUuXTbliai6badveg4=";
   };
 
-  preConfigure = ''
-    cd test
-    make everything
-    mv Everything.agda ..
-    cd ..
-  '';
-
   meta = with lib; {
     homepage = "https://github.com/UlfNorell/agda-prelude";
     description = "Programming library for Agda";

pkgs/development/libraries/agda/agdarsec/default.nix

···
     sha256 = "02fqkycvicw6m2xsz8p01aq8n3gj2d2gyx8sgj15l46f8434fy0x";
   };
 
-  everythingFile = "./index.agda";
-
-  includePaths = [
-    "src"
-    "examples"
-  ];
-
   buildInputs = [ standard-library ];
 
   meta = with lib; {

pkgs/development/libraries/agda/cubical-mini/default.nix

···
 
 mkDerivation rec {
   pname = "cubical-mini";
-  version = "nightly-20241214";
+  version = "0.5-unstable-2025-06-13";
 
   src = fetchFromGitHub {
     repo = pname;
     owner = "cmcmA20";
-    rev = "ab18320018ddc0055db60d4bb5560d31909c5b78";
-    hash = "sha256-32qXY9KbProdPwqHxSkwO74Oqx65rTzoXtH2SpRB3OM=";
+    rev = "1776874d13d0b811e6eeb70d0e5a52b4d2a978d2";
+    hash = "sha256-UxWOS+uzP9aAaMdSueA2CAuzWkImGAoKxroarcgpk+w=";
   };
 
   nativeBuildInputs = [

pkgs/development/libraries/agda/cubical/default.nix

···
   lib,
   mkDerivation,
   fetchFromGitHub,
-  ghc,
 }:
 
 mkDerivation rec {
···
     hash = "sha256-KwwN2g2naEo4/rKTz2L/0Guh5LxymEYP53XQzJ6eMjM=";
   };
 
-  # The cubical library has several `Everything.agda` files, which are
-  # compiled through the make file they provide.
-  nativeBuildInputs = [ ghc ];
-  buildPhase = ''
-    runHook preBuild
-    make
-    runHook postBuild
+  postPatch = ''
+    # This imports the Everything files, which we don't generate.
+    # TODO: remove for the next release
+    rm -rf Cubical/README.agda Cubical/Talks/EPA2020.agda
   '';
 
   meta = with lib; {

pkgs/development/libraries/agda/functional-linear-algebra/default.nix

···
     sha256 = "sha256-3nme/eH4pY6bD0DkhL4Dj/Vp/WnZqkQtZTNk+n1oAyY=";
   };
 
-  preConfigure = ''
-    sh generate-everything.sh
-  '';
-
   meta = with lib; {
     homepage = "https://github.com/ryanorendorff/functional-linear-algebra";
     description = ''

pkgs/development/libraries/agda/generics/default.nix

···
     standard-library
   ];
 
-  # everythingFile = "./README.agda";
+  # Agda expects a single .agda-lib file.
+  preBuild = ''
+    rm tests.agda-lib
+  '';
 
   meta = with lib; {
     description = "Library for datatype-generic programming in Agda";

pkgs/development/libraries/agda/standard-library/default.nix

···
   lib,
   mkDerivation,
   fetchFromGitHub,
-  ghcWithPackages,
   nixosTests,
 }:
 
 mkDerivation rec {
   pname = "standard-library";
-  version = "2.2";
+  version = "2.2-unstable-2025-07-03";
 
   src = fetchFromGitHub {
     repo = "agda-stdlib";
     owner = "agda";
-    rev = "v${version}";
-    hash = "sha256-/Fy5EOSbVNXt6Jq0yKSnlNPW4SYfn+eCTAYFnMZrbR0=";
+    rev = "6f8af9452e7fac27bc3b3ad068793b538f07668e";
+    hash = "sha256-LD6KasmQ9ZHRNQJ0N4wjyc6JiSkZpmyqQq9B0Wta1n0=";
   };
-
-  nativeBuildInputs = [ (ghcWithPackages (self: [ self.filemanip ])) ];
-  preConfigure = ''
-    runhaskell GenerateEverything.hs --include-deprecated
-    # We will only build/consider Everything.agda, in particular we don't want Everything*.agda
-    # do be copied to the store.
-    rm EverythingSafe.agda
-  '';
 
   passthru.tests = { inherit (nixosTests) agda; };
   meta = with lib; {

pkgs/top-level/agda-packages.nix

···
 
       agda = withPackages [ ];
 
-      standard-library = callPackage ../development/libraries/agda/standard-library {
-        inherit (pkgs.haskellPackages) ghcWithPackages;
-      };
+      standard-library = callPackage ../development/libraries/agda/standard-library { };
 
       iowa-stdlib = callPackage ../development/libraries/agda/iowa-stdlib { };
 

pkgs/top-level/release-haskell.nix

···
           };
 
       pkgsCross = {
+        aarch64-android-prebuilt.pkgsStatic =
+          removePlatforms
+            [
+              # Android NDK package doesn't support building on
+              "aarch64-darwin"
+              "aarch64-linux"
+
+              "x86_64-darwin"
+            ]
+            {
+              haskell.packages.ghc912 = {
+                inherit
+                  (packagePlatforms pkgs.pkgsCross.aarch64-android-prebuilt.pkgsStatic.haskell.packages.ghc912)
+                  ghc
+                  hello
+                  microlens
+                  ;
+              };
+            };
+
         ghcjs =
           removePlatforms
             [
···
                   ;
               };
 
-              haskell.packages.ghc910 = {
-                inherit (packagePlatforms pkgs.pkgsCross.aarch64-android-prebuilt.haskell.packages.ghc910)
-                  ghc
-                  hello
-                  microlens
-                  ;
-              };
-
               haskell.packages.ghcHEAD = {
                 inherit (packagePlatforms pkgs.pkgsCross.ghcjs.haskell.packages.ghcHEAD)
                   ghc
···
                   ;
               };
             };
+
+        ucrt64.haskell.packages.ghc912 = {
+          inherit (packagePlatforms pkgs.pkgsCross.ucrt64.haskell.packages.ghc912)
+            ghc
+            # hello # executables don't build yet
+            microlens
+            ;
+        };
 
         riscv64 = {
           # Cross compilation of GHC