Merge PR #369373 (haskell-updates) into staging

doc/languages-frameworks/haskell.section.md

···
 
 ```nix
 haskellPackages.haskell-ci.overrideScope (self: super: {
-  Cabal = self.Cabal_3_14_0_0;
+  Cabal = self.Cabal_3_14_1_0;
 })
 ```
 

maintainers/scripts/haskell/update-stackage.sh

···
 # (should be capitalized like the display name)
 SOLVER=LTS
 # Stackage solver verson, if any. Use latest if empty
-VERSION=
+VERSION=22
 TMP_TEMPLATE=update-stackage.XXXXXXX
 readonly SOLVER
 readonly VERSION

pkgs/data/misc/hackage/pin.json

···
 {
-  "commit": "11b47ef0c5fa2ddecc20a556776ede00e9569867",
-  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/11b47ef0c5fa2ddecc20a556776ede00e9569867.tar.gz",
-  "sha256": "17k59rkyrz1ax8gx8jps295371p25ksscli9jbp3h4ivfmls5fyd",
-  "msg": "Update from Hackage at 2024-11-07T13:09:31Z"
+  "commit": "c9ce1cc4a029220ec3582fbcf69e082d245d78b6",
+  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/c9ce1cc4a029220ec3582fbcf69e082d245d78b6.tar.gz",
+  "sha256": "02x3z4rg4dwarzb6p88z7sff40bkbq41gxnczvzph8s3s8jq9iw1",
+  "msg": "Update from Hackage at 2024-12-23T18:27:47Z"
 }

pkgs/development/haskell-modules/cabal2nix-unstable.nix

···
 }:
 mkDerivation {
   pname = "cabal2nix";
-  version = "unstable-2024-12-22";
+  version = "unstable-2024-12-31";
   src = fetchzip {
-    url = "https://github.com/NixOS/cabal2nix/archive/cc5c0285bac65da2be0afd123f1cee94104c25fd.tar.gz";
-    sha256 = "1jrjgjjg1nkdc4fhk9m8hp5j5zq9bs0lvvk4v3kx6xmvjx93hk8h";
+    url = "https://github.com/NixOS/cabal2nix/archive/e290b906f056dd1414ede71b4bb6375be2d0aa5d.tar.gz";
+    sha256 = "0x94w4dfjfxp3f5h7w5738znkyb8barzjki0xsf94asiffiqsgxn";
   };
   postUnpack = "sourceRoot+=/cabal2nix; echo source root reset to $sourceRoot";
   isLibrary = true;

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

···
   Cabal_3_12_1_0 = doDistribute (super.Cabal_3_12_1_0.override {
     Cabal-syntax = self.Cabal-syntax_3_12_1_0;
   });
-  Cabal_3_14_0_0 = doDistribute (super.Cabal_3_14_0_0.override {
-    Cabal-syntax = self.Cabal-syntax_3_14_0_0;
+  Cabal_3_14_1_0 = doDistribute (super.Cabal_3_14_1_0.override {
+    Cabal-syntax = self.Cabal-syntax_3_14_1_0;
   });
 
   # hackage-security == 0.6.2.6 has a wider support range in theory, but it only
-  # makes sense to use the non Stackage version if we want to use Cabal* >= 3.12
+  # makes sense to use the non Stackage version if we want to use Cabal* >= 3.14
   hackage-security_0_6_2_6 = super.hackage-security_0_6_2_6.override {
-    Cabal = self.Cabal_3_12_1_0;
-    Cabal-syntax = self.Cabal-syntax_3_12_1_0;
+    Cabal = self.Cabal_3_14_1_0;
+    Cabal-syntax = self.Cabal-syntax_3_14_1_0;
   };
 
   # cabal-install needs most recent versions of Cabal and Cabal-syntax,
···
       cabalInstallOverlay = cself: csuper:
         {
           hackage-security = self.hackage-security_0_6_2_6;
-        } // lib.optionalAttrs (lib.versionOlder self.ghc.version "9.10.2") {
-          Cabal = cself.Cabal_3_12_1_0;
-          Cabal-syntax = cself.Cabal-syntax_3_12_1_0;
+        } // lib.optionalAttrs (lib.versionOlder self.ghc.version "9.12") {
+          Cabal = cself.Cabal_3_14_1_0;
+          Cabal-syntax = cself.Cabal-syntax_3_14_1_0;
         };
     in
     {
···
   # jacinda needs latest version of alex and happy
   jacinda = super.jacinda.override {
     alex = self.alex_3_5_1_0;
-    happy = self.happy_2_1_2;
+    happy = self.happy_2_1_3;
   };
 
   # 2024-07-09: rhine 1.4.* needs newer monad-schedule than stackage (and is only consumer)
···
   http-api-data = doJailbreak super.http-api-data;
   tasty-discover = doJailbreak super.tasty-discover;
 
+  # Too strict lower bound on lens, drop with LTS 23
+  provide = doJailbreak super.provide;
+  # Too strict bounds on quickcheck-instances/tasty-qickcheck, drop with LTS 23
+  lawful-conversions = doJailbreak super.lawful-conversions;
+
   # Out of date test data: https://github.com/ocharles/weeder/issues/176
   weeder = appendPatch (pkgs.fetchpatch {
     name = "weeder-2.9.0-test-fix-expected.patch";
···
   termbox-bindings-c = appendConfigureFlags [
     "--ghc-option=-optc=-Wno-error=implicit-function-declaration"
   ] super.termbox-bindings-c;
-  libxml-sax = appendConfigureFlags [
-    "--ghc-option=-optc=-Wno-error=implicit-function-declaration"
-  ] super.libxml-sax;
 
   # There are numerical tests on random data, that may fail occasionally
   lapack = dontCheck super.lapack;
···
   # As well as deepseq < 1.5 (so it forbids GHC 9.8)
   hw-fingertree = doJailbreak super.hw-fingertree;
 
+  # Test suite is slow and sometimes comes up with counter examples.
+  # Upstream is aware (https://github.com/isovector/nspace/issues/1),
+  # if it's a bug, at least doesn't seem to be nixpkgs-specific.
+  nspace = dontCheck super.nspace;
+
   # 2024-03-10: Maintainance stalled, fixes unmerged: https://github.com/haskell/ThreadScope/pull/130
   threadscope = overrideCabal (drv: {
     prePatch = drv.prePatch or "" + ''
···
       name = "git-annex-${super.git-annex.version}-src";
       url = "git://git-annex.branchable.com/";
       rev = "refs/tags/" + super.git-annex.version;
-      sha256 = "0lhy8yhlnjw8n9ymn1r6n7z9vgil188asj10s2q5mjb706ip8wmj";
+      sha256 = "0jr4crq52qvnn85qxw077bdpzrgvamm7fmrqn6ygrhlyk1lb9n9x";
       # 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
···
   # Too strict upper bound on algebraic-graphs
   # https://github.com/awakesecurity/nix-graph/issues/5
   nix-graph = doJailbreak super.nix-graph;
+
+  # Too strict bounds on hspec
+  # https://github.com/illia-shkroba/pfile/issues/2
+  pfile = doJailbreak super.pfile;
 
   # Manually maintained
   cachix-api = overrideCabal (drv: {
···
 
   # Pandoc 3.5 improves the quality of PDF rendering in Quarto >=1.6.30.
   # https://github.com/NixOS/nixpkgs/pull/349683
-  pandoc-cli_3_5 = super.pandoc-cli_3_5.overrideScope (
+  pandoc-cli_3_6 = super.pandoc-cli_3_6.overrideScope (
     self: super: {
       doclayout = self.doclayout_0_5;
       hslua-module-doclayout = self.hslua-module-doclayout_1_2_0;
       lpeg = self.lpeg_1_1_0;
-      pandoc = self.pandoc_3_5;
-      pandoc-lua-engine = self.pandoc-lua-engine_0_3_3;
-      pandoc-server = self.pandoc-server_0_1_0_9;
-      texmath = self.texmath_0_12_8_11;
+      pandoc = self.pandoc_3_6;
+      pandoc-lua-engine = self.pandoc-lua-engine_0_4;
+      pandoc-server = self.pandoc-server_0_1_0_10;
+      texmath = self.texmath_0_12_8_12;
       tls = self.tls_2_0_6;
       toml-parser = self.toml-parser_2_0_1_0;
-      typst = self.typst_0_6;
+      typst = self.typst_0_6_1;
       typst-symbols = self.typst-symbols_0_1_6;
     }
   );
···
   # 2021-04-16: too strict bounds on QuickCheck and tasty
   # https://github.com/hasufell/lzma-static/issues/1
   lzma-static = doJailbreak super.lzma-static;
+  xz = doJailbreak super.xz;
 
   # Too strict version bounds on base:
   # https://github.com/obsidiansystems/database-id/issues/1
···
   }) super.gi-gtk-declarative;
   gi-gtk-declarative-app-simple = doJailbreak super.gi-gtk-declarative-app-simple;
 
-  gi-gtk_4 = self.gi-gtk_4_0_9;
-  gi-gtk_4_0_9 = doDistribute (super.gi-gtk_4_0_9.override {
+  gi-gtk_4 = self.gi-gtk_4_0_11;
+  gi-gtk_4_0_11 = doDistribute (super.gi-gtk_4_0_11.override {
     gi-gdk = self.gi-gdk_4;
   });
   gi-gdk_4 = self.gi-gdk_4_0_9;
···
   # base <4.14
   decimal-literals = doJailbreak super.decimal-literals;
 
-  # 2024-06-22: hevm ghc96 fixes
-  hevm = lib.pipe super.hevm [
-    (appendPatch (fetchpatch {
-      url = "https://github.com/ethereum/hevm/compare/02c072f...hellwolf:hevm:c29d3a7.patch";
-      hash = "sha256-cL26HD77vXsiKqo5G6PXgK0q19MUGMwaNium5x93CBI=";
-    }))
-    (overrideCabal (old: {
-      postPatch = old.postPatch or "" + ''
-        sed -i 's/^ *brick .*,/brick,/' hevm.cabal
-        sed -i 's/^ *vty .*,/vty,/' hevm.cabal
-      '';
-    }))
-    doJailbreak
-  ];
-
   # multiple bounds too strict
   snaplet-sqlite-simple = doJailbreak super.snaplet-sqlite-simple;
 
···
     })
     super.linux-namespaces;
 
-  inherit
-    (let
-      unbreakRepa = packageName: drv: lib.pipe drv [
-        # 2023-12-23: Apply build fixes for ghc >=9.4
-        (appendPatches (lib.optionals (lib.versionAtLeast self.ghc.version "9.4") (repaPatches.${packageName} or [])))
-        # 2023-12-23: jailbreak for base <4.17, vector <0.13
-        doJailbreak
-      ];
-      # https://github.com/haskell-repa/repa/pull/27
-      repaPatches = lib.mapAttrs (relative: hash: lib.singleton (pkgs.fetchpatch {
-        name = "repa-pr-27.patch";
-        url = "https://github.com/haskell-repa/repa/pull/27/commits/40cb2866bb4da51a8cac5e3792984744a64b016e.patch";
-        inherit relative hash;
-     })) {
-        repa = "sha256-bcSnzvCJmmSBts9UQHA2dYL0Q+wXN9Fbz5LfkrmhCo8=";
-        repa-io = "sha256-KsIN7NPWCyTpVzhR+xaBKGl8vC6rYH94llvlTawSxFk=";
-        repa-examples = "sha256-//2JG1CW1h2sKS2BSJadVAujSE3v1TfS0F8zgcNkPI8=";
-        repa-algorithms = "sha256-z/a7DpT3xJrIsif4cbciYcTSjapAtCoNNVX7PrZtc4I=";
-      };
-    in
-      lib.mapAttrs unbreakRepa super)
-    repa
-    repa-io
-    repa-examples
-    repa-algorithms
-    # The following packages aren't fixed yet, sorry:
-    #   repa-array, repa-convert, repa-eval, repa-flow,
-    #   repa-query, repa-scalar, repa-store, repa-stream
-  ;
-
   # Use recent git version as the hackage version is outdated and not building on recent GHC versions
   haskell-to-elm = overrideSrc {
     version = "unstable-2023-12-02";
···
       sha256 = "sha256-MnOc51tTNg8+HDu1VS2Ct7Mtu0vuuRd3DjzOAOF+t7Q=";
     })
   ] super.hailgun;
+
+  # opencascade-hs requires the include path configuring relative to the
+  # opencascade subdirectory in include.
+  opencascade-hs = appendConfigureFlags [
+    "--extra-include-dirs=${lib.getDev pkgs.opencascade-occt}/include/opencascade"
+  ] super.opencascade-hs;
 
 } // import ./configuration-tensorflow.nix {inherit pkgs haskellLib;} self super

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

···
   unix = null;
   # GHC only bundles the xhtml library if haddock is enabled, check if this is
   # still the case when updating: https://gitlab.haskell.org/ghc/ghc/-/blob/0198841877f6f04269d6050892b98b5c3807ce4c/ghc.mk#L463
-  xhtml = if self.ghc.hasHaddock or true then null else doDistribute self.xhtml_3000_3_0_0;
+  xhtml = if self.ghc.hasHaddock or true then null else doDistribute self.xhtml_3000_4_0_0;
 
   # Need the Cabal-syntax-3.6.0.0 fake package for Cabal < 3.8 to allow callPackage and the constraint solver to work
   Cabal-syntax = self.Cabal-syntax_3_6_0_0;
···
   # Needs OneTuple for ghc < 9.2
   binary-orphans = addBuildDepends [ self.OneTuple ] super.binary-orphans;
 
-  # Requires GHC < 9.4
-  ghc-source-gen = doDistribute (unmarkBroken super.ghc-source-gen);
+  # 0.4.6.0 only supports >= 9.0
+  ghc-source-gen = doDistribute self.ghc-source-gen_0_4_5_0;
 
   # No instance for (Show B.Builder) arising from a use of ‘print’
   http-types = dontCheck super.http-types;

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

···
   unix = null;
   # GHC only bundles the xhtml library if haddock is enabled, check if this is
   # still the case when updating: https://gitlab.haskell.org/ghc/ghc/-/blob/0198841877f6f04269d6050892b98b5c3807ce4c/ghc.mk#L463
-  xhtml = if self.ghc.hasHaddock or true then null else doDistribute self.xhtml_3000_3_0_0;
+  xhtml = if self.ghc.hasHaddock or true then null else doDistribute self.xhtml_3000_4_0_0;
 
   # Need the Cabal-syntax-3.6.0.0 fake package for Cabal < 3.8 to allow callPackage and the constraint solver to work
   Cabal-syntax = self.Cabal-syntax_3_6_0_0;
···
   ghc-lib-parser-ex = addBuildDepend self.ghc-lib-parser super.ghc-lib-parser-ex;
 
   # This became a core library in ghc 8.10., so we don’t have an "exception" attribute anymore.
-  exceptions = self.exceptions_0_10_8;
+  exceptions = self.exceptions_0_10_9;
 
   # vector 0.12.2 indroduced doctest checks that don’t work on older compilers
   vector = dontCheck super.vector;

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

···
   unix = null;
   # GHC only bundles the xhtml library if haddock is enabled, check if this is
   # still the case when updating: https://gitlab.haskell.org/ghc/ghc/-/blob/0198841877f6f04269d6050892b98b5c3807ce4c/ghc.mk#L463
-  xhtml = if self.ghc.hasHaddock or true then null else doDistribute self.xhtml_3000_3_0_0;
+  xhtml = if self.ghc.hasHaddock or true then null else doDistribute self.xhtml_3000_4_0_0;
 
   # Need the Cabal-syntax-3.6.0.0 fake package for Cabal < 3.8 to allow callPackage and the constraint solver to work
   Cabal-syntax = self.Cabal-syntax_3_6_0_0;
···
 
   # Needs OneTuple for ghc < 9.2
   binary-orphans = addBuildDepends [ self.OneTuple ] super.binary-orphans;
-
-  # Requires GHC < 9.4
-  ghc-source-gen = doDistribute (unmarkBroken super.ghc-source-gen);
 
   hspec-megaparsec = super.hspec-megaparsec_2_2_0;
 

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

···
   # already made the relevant changes.
   aeson = doDistribute self.aeson_2_2_3_0;
   attoparsec-aeson = doDistribute self.attoparsec-aeson_2_2_2_0;
-  auto-update = super.auto-update_0_2_2;
+  auto-update = doDistribute self.auto-update_0_2_6;
   dependent-sum-template = doJailbreak self.dependent-sum-template_0_2_0_1; # template-haskell < 2.22
   extensions = doDistribute self.extensions_0_1_0_2;
   fourmolu = doDistribute self.fourmolu_0_16_2_0;
   hashable = doDistribute self.hashable_1_4_7_0;
   integer-conversion = doDistribute self.integer-conversion_0_1_1;
+  ghc-lib = doDistribute self.ghc-lib_9_10_1_20241103;
   ghc-lib-parser = doDistribute self.ghc-lib-parser_9_10_1_20241103;
   ghc-lib-parser-ex = doDistribute self.ghc-lib-parser-ex_9_10_0_0;
-  http2 = doDistribute self.http2_5_3_5;
+  http2 = doDistribute self.http2_5_3_9;
   http-semantics = doDistribute self.http-semantics_0_3_0;
+  htree = doDistribute self.htree_0_2_0_0;
   lens = doDistribute self.lens_5_3_2;
   lukko = doDistribute self.lukko_0_1_2;
   network-control = super.network-control_0_1_3;
   network-run = super.network-run_0_4_0;
   ormolu = doDistribute self.ormolu_0_7_7_0;
-  primitive = doDistribute (dontCheck self.primitive_0_9_0_0); # tests introduce a recursive dependency via hspec
+  primitive = doDistribute self.primitive_0_9_0_0;
   quickcheck-instances = doDistribute self.quickcheck-instances_0_3_32;
   rebase = doDistribute self.rebase_1_21_1;
   rerebase = doDistribute self.rerebase_1_21_1;
   scientific = doDistribute self.scientific_0_3_8_0;
   semirings = doDistribute self.semirings_0_7;
-  time-manager = super.time-manager_0_1_1;
-  th-abstraction = doDistribute self.th-abstraction_0_7_0_0;
+  time-manager = doDistribute self.time-manager_0_2_2;
+  th-abstraction = doDistribute self.th-abstraction_0_7_1_0;
   uuid-types = doDistribute self.uuid-types_1_0_6;
-  warp = pkgs.haskell.lib.dontCheck super.warp_3_4_4; # test suite assumes it can freely call curl
+  warp = pkgs.haskell.lib.dontCheck super.warp_3_4_7; # test suite assumes it can freely call curl
 
   # A given major version of ghc-exactprint only supports one version of GHC.
   ghc-exactprint = doDistribute self.ghc-exactprint_1_9_0_0;
···
   #
   # Test suite issues
   #
-  call-stack = dontCheck super.call-stack; # expects the package to be named "main", but we generate a name
+  call-stack = dontCheck super.call-stack; # https://github.com/sol/call-stack/issues/19
   lifted-base = dontCheck super.lifted-base; # doesn't compile with transformers ==0.6.*
   lukko_0_1_2 = dontCheck super.lukko_0_1_2; # doesn't compile with tasty ==1.4.*
   resolv = dontCheck super.resolv; # doesn't compile with filepath ==1.5.*

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

···
 
 let
   inherit (pkgs) lib;
+in
 
-in
+with haskellLib;
 
 self: super: {
   llvmPackages = lib.dontRecurseIntoAttrs self.ghc.llvmPackages;
···
   unix = null;
   xhtml = null;
 
+  # Version upgrades
+  htree = doDistribute self.htree_0_2_0_0;
+  primitive = doDistribute self.primitive_0_9_0_0;
+  splitmix = doDistribute self.splitmix_0_1_1;
+  tagged = doDistribute self.tagged_0_8_9;
+  tar = doDistribute self.tar_0_6_3_0;
+
+  # Test suite issues
+  call-stack = dontCheck super.call-stack; # https://github.com/sol/call-stack/issues/19
 }

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

···
   unix = null;
   # GHC only bundles the xhtml library if haddock is enabled, check if this is
   # still the case when updating: https://gitlab.haskell.org/ghc/ghc/-/blob/0198841877f6f04269d6050892b98b5c3807ce4c/ghc.mk#L463
-  xhtml = if self.ghc.hasHaddock or true then null else doDistribute self.xhtml_3000_3_0_0;
+  xhtml = if self.ghc.hasHaddock or true then null else doDistribute self.xhtml_3000_4_0_0;
 
   # Need the Cabal-syntax-3.6.0.0 fake package for Cabal < 3.8 to allow callPackage and the constraint solver to work
   Cabal-syntax = self.Cabal-syntax_3_6_0_0;
···
 
   # A given major version of ghc-exactprint only supports one version of GHC.
   ghc-exactprint = super.ghc-exactprint_1_5_0;
-
-  # Requires GHC < 9.4
-  ghc-source-gen = doDistribute (unmarkBroken super.ghc-source-gen);
 
   # Packages which need compat library for GHC < 9.6
   inherit (lib.mapAttrs (_: addBuildDepends [ self.foldable1-classes-compat ]) super)

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

···
   unix = null;
   # GHC only bundles the xhtml library if haddock is enabled, check if this is
   # still the case when updating: https://gitlab.haskell.org/ghc/ghc/-/blob/0198841877f6f04269d6050892b98b5c3807ce4c/ghc.mk#L463
-  xhtml = if self.ghc.hasHaddock or true then null else doDistribute self.xhtml_3000_3_0_0;
+  xhtml = if self.ghc.hasHaddock or true then null else doDistribute self.xhtml_3000_4_0_0;
 
   # Jailbreaks & Version Updates
 

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

···
   #
   # Version upgrades
   #
-  th-abstraction = doDistribute self.th-abstraction_0_7_0_0;
-  ghc-lib-parser = doDistribute self.ghc-lib-parser_9_8_3_20241103;
+  th-abstraction = doDistribute self.th-abstraction_0_7_1_0;
+  ghc-lib-parser = doDistribute self.ghc-lib-parser_9_8_4_20241130;
   ghc-lib-parser-ex = doDistribute self.ghc-lib-parser-ex_9_8_0_2;
-  ghc-lib = doDistribute self.ghc-lib_9_8_3_20241103;
-  megaparsec = doDistribute self.megaparsec_9_6_1;
+  ghc-lib = doDistribute self.ghc-lib_9_8_4_20241130;
+  megaparsec = doDistribute self.megaparsec_9_7_0;
   # aeson 2.2.3.0 seemingly unnecessesarily bumped the lower bound on hashable
   # https://github.com/haskell/aeson/commit/1a666febd0775d8e88d315ece1b97cd20602fb5f
   aeson = doJailbreak (doDistribute self.aeson_2_2_3_0);

pkgs/development/haskell-modules/configuration-ghcjs-8.x.nix

···
   # GHCJS does not ship with the same core packages as GHC.
   # https://github.com/ghcjs/ghcjs/issues/676
   stm = doJailbreak self.stm_2_5_3_1;
-  exceptions = dontCheck self.exceptions_0_10_8;
+  exceptions = dontCheck self.exceptions_0_10_9;
 
   ## OTHER PACKAGES
 

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

···
   - alex-prelude # failure in job https://hydra.nixos.org/build/233238387 at 2023-09-02
   - al # failure in job https://hydra.nixos.org/build/252733710 at 2024-03-16
   - alfred # failure in job https://hydra.nixos.org/build/233227316 at 2023-09-02
-  - alfred-margaret # failure in job https://hydra.nixos.org/build/233223038 at 2023-09-02
   - alga # failure in job https://hydra.nixos.org/build/233252723 at 2023-09-02
   - algebra-dag # failure in job https://hydra.nixos.org/build/233191945 at 2023-09-02
   - algebraic-classes # failure in job https://hydra.nixos.org/build/233246872 at 2023-09-02
···
   - bdelta # failure in job https://hydra.nixos.org/build/233214765 at 2023-09-02
   - bdo # failure in job https://hydra.nixos.org/build/233216486 at 2023-09-02
   - beamable # failure in job https://hydra.nixos.org/build/233211619 at 2023-09-02
-  - beam # failure in job https://hydra.nixos.org/build/233213313 at 2023-09-02
   - beam-automigrate # failure in job https://hydra.nixos.org/build/282936134 at 2024-12-24
+  - beam # failure in job https://hydra.nixos.org/build/233213313 at 2023-09-02
   - beam-mysql # failure in job https://hydra.nixos.org/build/233253237 at 2023-09-02
   - beam-newtype-field # failure in job https://hydra.nixos.org/build/233206317 at 2023-09-02
   - bearriver # failure in job https://hydra.nixos.org/build/269669840 at 2024-08-19
···
   - cg # failure in job https://hydra.nixos.org/build/233212272 at 2023-09-02
   - cgi-utils # failure in job https://hydra.nixos.org/build/233251773 at 2023-09-02
   - cgroup-rts-threads # failure in job https://hydra.nixos.org/build/233207888 at 2023-09-02
+  - chakra # failure in job https://hydra.nixos.org/build/282936173 at 2024-12-24
   - chalkboard # failure in job https://hydra.nixos.org/build/234453414 at 2023-09-13
-  - chakra # failure in job https://hydra.nixos.org/build/282936173 at 2024-12-24
   - chalmers-lava2000 # failure in job https://hydra.nixos.org/build/233239592 at 2023-09-02
   - changelog-d # failure in job https://hydra.nixos.org/build/252716175 at 2024-03-16
   - changelog-d # failure in job https://hydra.nixos.org/build/253689337 at 2024-03-31
···
   - dead-code-detection # failure in job https://hydra.nixos.org/build/233205957 at 2023-09-02
   - Deadpan-DDP # failure in job https://hydra.nixos.org/build/233221990 at 2023-09-02
   - dead-simple-json # failure in job https://hydra.nixos.org/build/233204301 at 2023-09-02
+  - debruijn # failure in job https://hydra.nixos.org/build/283207128 at 2024-12-31
+  - debruijn-safe # failure in job https://hydra.nixos.org/build/283210219 at 2024-12-31
   - debugger-hs # failure in job https://hydra.nixos.org/build/233206302 at 2023-09-02
   - debug-me # failure in job https://hydra.nixos.org/build/233213991 at 2023-09-02
   - debug-trace-file # failure in job https://hydra.nixos.org/build/233231840 at 2023-09-02
···
   - deepcontrol # failure in job https://hydra.nixos.org/build/233238035 at 2023-09-02
   - DeepDarkFantasy # failure in job https://hydra.nixos.org/build/233242150 at 2023-09-02
   - deepl # failure in job https://hydra.nixos.org/build/233232956 at 2023-09-02
+  - deep-map # failure in job https://hydra.nixos.org/build/283207785 at 2024-12-31
   - deepseq-bounded # failure in job https://hydra.nixos.org/build/233211193 at 2023-09-02
   - deepseq-instances # failure in job https://hydra.nixos.org/build/233236748 at 2023-09-02
   - deepseq-magic # failure in job https://hydra.nixos.org/build/233228993 at 2023-09-02
···
   - edit-lenses # failure in job https://hydra.nixos.org/build/233195827 at 2023-09-02
   - editline # failure in job https://hydra.nixos.org/build/233259515 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
   - effect-handlers # failure in job https://hydra.nixos.org/build/233234988 at 2023-09-02
   - effective-aspects # failure in job https://hydra.nixos.org/build/233223120 at 2023-09-02
   - effect-stack # failure in job https://hydra.nixos.org/build/233212358 at 2023-09-02
···
   - elm-websocket # failure in job https://hydra.nixos.org/build/233192201 at 2023-09-02
   - elocrypt # failure in job https://hydra.nixos.org/build/233229627 at 2023-09-02
   - ema-generics # failure in job https://hydra.nixos.org/build/233200038 at 2023-09-02
-  - email # deprecated, depends on outdated dependencies
   - emailaddress # failure in job https://hydra.nixos.org/build/233202700 at 2023-09-02
+  - email # deprecated, depends on outdated dependencies
   - email-header # failure in job https://hydra.nixos.org/build/233243713 at 2023-09-02
   - email-postmark # failure in job https://hydra.nixos.org/build/233245426 at 2023-09-02
   - embed-config # failure in job https://hydra.nixos.org/build/233237733 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
   - gingersnap # failure in job https://hydra.nixos.org/build/233227186 at 2023-09-02
+  - gi-nm # failure in job https://hydra.nixos.org/build/283561133 at 2024-12-31
   - 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
   - giphy-api # failure in job https://hydra.nixos.org/build/233203687 at 2023-09-02
···
   - hsc3-cairo # failure in job https://hydra.nixos.org/build/233215926 at 2023-09-02
   - hsc3-db # failure in job https://hydra.nixos.org/build/233191679 at 2023-09-02
   - hsc3-dot # failure in job https://hydra.nixos.org/build/233219452 at 2023-09-02
+  - hsc3 # failure in job https://hydra.nixos.org/build/283199022 at 2024-12-31
   - hsc3-lang # failure in job https://hydra.nixos.org/build/233198291 at 2023-09-02
   - hsc3-process # failure in job https://hydra.nixos.org/build/233196358 at 2023-09-02
   - hsc3-rec # failure in job https://hydra.nixos.org/build/233206364 at 2023-09-02
···
   - hsfilt # failure in job https://hydra.nixos.org/build/233242295 at 2023-09-02
   - hs-fltk # failure in job https://hydra.nixos.org/build/233225244 at 2023-09-02
   - hsforce # failure in job https://hydra.nixos.org/build/233242016 at 2023-09-02
+  - hsftp # failure in job https://hydra.nixos.org/build/283199528 at 2024-12-31
   - hs-gizapp # failure in job https://hydra.nixos.org/build/233248733 at 2023-09-02
   - hsgnutls # failure in job https://hydra.nixos.org/build/233199419 at 2023-09-02
   - hsgnutls-yj # failure in job https://hydra.nixos.org/build/233220680 at 2023-09-02
···
   - libphonenumber # failure in job https://hydra.nixos.org/build/233251839 at 2023-09-02
   - libpq # failure in job https://hydra.nixos.org/build/233192542 at 2023-09-02
   - librandomorg # failure in job https://hydra.nixos.org/build/233232749 at 2023-09-02
+  - libremidi # failure in job https://hydra.nixos.org/build/283561085 at 2024-12-31
   - libsecp256k1 # failure in job https://hydra.nixos.org/build/234441559 at 2023-09-13
   - libsodium # failure in job https://hydra.nixos.org/build/243816565 at 2024-01-01
   - libsystemd-daemon # failure in job https://hydra.nixos.org/build/233207090 at 2023-09-02
   - libtagc # failure in job https://hydra.nixos.org/build/233223631 at 2023-09-02
   - libtelnet # failure in job https://hydra.nixos.org/build/233209594 at 2023-09-02
+  - libtorch-ffi # failure in job https://hydra.nixos.org/build/283204506 at 2024-12-31
   - libvirt-hs # failure in job https://hydra.nixos.org/build/253697570 at 2024-03-31
   - libxls # failure in job https://hydra.nixos.org/build/233257847 at 2023-09-02
   - libxlsxwriter-hs # failure in job https://hydra.nixos.org/build/233244798 at 2023-09-02
+  - libxml-sax # failure in job https://hydra.nixos.org/build/283561084 at 2024-12-31
   - libxslt # failure in job https://hydra.nixos.org/build/233248464 at 2023-09-02
   - libyaml-streamly # failure in job https://hydra.nixos.org/build/233203611 at 2023-09-02
   - libzfs # failure in job https://hydra.nixos.org/build/233662945 at 2023-09-02
···
   - openapi3-code-generator # failure in job https://hydra.nixos.org/build/233255628 at 2023-09-02
   - openapi-petstore # failure in job https://hydra.nixos.org/build/233221722 at 2023-09-02
   - openapi-typed # failure in job https://hydra.nixos.org/build/233226830 at 2023-09-02
-  - opencascade-hs # failure in job https://hydra.nixos.org/build/243821447 at 2024-01-01
   - opencc # failure in job https://hydra.nixos.org/build/233211902 at 2023-09-02
   - opench-meteo # failure in job https://hydra.nixos.org/build/233212476 at 2023-09-02
   - OpenCL # failure in job https://hydra.nixos.org/build/233216571 at 2023-09-02
···
   - pg-harness # failure in job https://hydra.nixos.org/build/233219805 at 2023-09-02
   - pg-harness-server # failure in job https://hydra.nixos.org/build/233236493 at 2023-09-02
   - pgp-wordlist # failure in job https://hydra.nixos.org/build/252723543 at 2024-03-16
+  - pg-query # failure in job https://hydra.nixos.org/build/283202281 at 2024-12-31
   - pg-recorder # failure in job https://hydra.nixos.org/build/233241248 at 2023-09-02
   - pgsql-simple # failure in job https://hydra.nixos.org/build/233228421 at 2023-09-02
   - pg-store # failure in job https://hydra.nixos.org/build/233208603 at 2023-09-02
···
   - reorderable # failure in job https://hydra.nixos.org/build/233256477 at 2023-09-02
   - reorder-expression # failure in job https://hydra.nixos.org/build/233215573 at 2023-09-02
   - repa-bytestring # failure in job https://hydra.nixos.org/build/252723812 at 2024-03-16
+  - repa-convert # failure in job https://hydra.nixos.org/build/283561102 at 2024-12-31
   - repa-devil # failure in job https://hydra.nixos.org/build/252724171 at 2024-03-16
-  - repa-eval # failure in job https://hydra.nixos.org/build/233259486 at 2023-09-02
   - repa-examples # failure in job https://hydra.nixos.org/build/252712195 at 2024-03-16
   - repa-linear-algebra # failure in job https://hydra.nixos.org/build/252713634 at 2024-03-16
-  - repa-scalar # failure in job https://hydra.nixos.org/build/233213694 at 2023-09-02
   - repa-series # failure in job https://hydra.nixos.org/build/233200085 at 2023-09-02
+  - repa-stream # failure in job https://hydra.nixos.org/build/283561119 at 2024-12-31
   - ReplaceUmlaut # failure in job https://hydra.nixos.org/build/233228662 at 2023-09-02
   - repl # failure in job https://hydra.nixos.org/build/233233135 at 2023-09-02
   - RepLib # failure in job https://hydra.nixos.org/build/233210112 at 2023-09-02
···
   - tak # failure in job https://hydra.nixos.org/build/233191188 at 2023-09-02
   - Takusen # failure in job https://hydra.nixos.org/build/233230088 at 2023-09-02
   - takusen-oracle # failure in job https://hydra.nixos.org/build/233197944 at 2023-09-02
+  - talash # failure in job https://hydra.nixos.org/build/283561113 at 2024-12-31
   - tamarin-prover-utils # failure in job https://hydra.nixos.org/build/233235417 at 2023-09-02
   - Tape # failure in job https://hydra.nixos.org/build/233191662 at 2023-09-02
   - tapioca # failure in job https://hydra.nixos.org/build/233207781 at 2023-09-02
···
   - tasty-checklist # failure in job https://hydra.nixos.org/build/252710481 at 2024-03-16
   - tasty-fail-fast # failure in job https://hydra.nixos.org/build/233200040 at 2023-09-02
   - tasty-flaky # failure in job https://hydra.nixos.org/build/275140265 at 2024-10-21
+  - tasty-golden-extra # failure in job https://hydra.nixos.org/build/283204600 at 2024-12-31
   - 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
···
   - time-w3c # failure in job https://hydra.nixos.org/build/233225902 at 2023-09-02
   - timezone-detect # failure in job https://hydra.nixos.org/build/233205213 at 2023-09-02
   - tini # failure in job https://hydra.nixos.org/build/252732072 at 2024-03-16
+  - tinyapp # failure in job https://hydra.nixos.org/build/283207451 at 2024-12-31
   - tinyid # failure in job https://hydra.nixos.org/build/233249999 at 2023-09-02
   - TinyLaunchbury # failure in job https://hydra.nixos.org/build/233233671 at 2023-09-02
   - tinylog # failure in job https://hydra.nixos.org/build/233198434 at 2023-09-02
···
   - unamb-custom # failure in job https://hydra.nixos.org/build/233197458 at 2023-09-02
   - unbeliever # failure in job https://hydra.nixos.org/build/233221256 at 2023-09-02
   - unbounded-delays-units # failure in job https://hydra.nixos.org/build/233200989 at 2023-09-02
+  - unbound-generics-unify # failure in job https://hydra.nixos.org/build/283205015 at 2024-12-31
   - unboxed-containers # failure in job https://hydra.nixos.org/build/233200384 at 2023-09-02
   - unboxed # failure in job https://hydra.nixos.org/build/233219555 at 2023-09-02
   - unboxed-references # failure in job https://hydra.nixos.org/build/233192713 at 2023-09-02
···
   - wkt-geom # failure in job https://hydra.nixos.org/build/233199774 at 2023-09-02
   - wkt-types # failure in job https://hydra.nixos.org/build/269668682 at 2024-08-19
   - WL500gPLib # failure in job https://hydra.nixos.org/build/233203811 at 2023-09-02
+  - wled-json # failure in job https://hydra.nixos.org/build/283201821 at 2024-12-31
   - wl-pprint-console # failure in job https://hydra.nixos.org/build/233204682 at 2023-09-02
   - wl-pprint-extras # failure in job https://hydra.nixos.org/build/233233369 at 2023-09-02
   - WMSigner # failure in job https://hydra.nixos.org/build/233199780 at 2023-09-02

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

···
   - http-semantics < 0.3.0
   # 2024-12-23: last version to be compatible with Stackage LTS 22/23 (due to data-default)
   - diagrams-input < 0.1.4
+  # 2024-12-31: last version that's compatible with GHC < 9.9
+  - htree < 0.2.0.0
 
 extra-packages:
   - Cabal == 3.2.*                      # Used for packages needing newer Cabal on ghc 8.6 and 8.8
···
   - ghc-lib == 9.8.*                    # 2024-05-19: preserve for GHC 9.8
   - ghc-lib-parser == 9.2.*             # 2022-02-17: preserve for GHC 8.10, 9.0
   - ghc-lib-parser == 9.8.*             # 2024-05-19: preserve for GHC 9.8
+  - ghc-lib == 9.10.*                   # 2024-12-30: preserve for GHC 9.10/ghc-tags 1.9
+  - ghc-lib-parser == 9.10.*            # 2024-12-26: preserve for ghc-syntax-highlighter == 0.0.12.0
+  - ghc-lib-parser-ex == 9.10.*         # 2024-12-26: preserve for 9.10 HLS
   - ghc-lib-parser-ex == 9.2.*          # 2022-07-13: preserve for GHC 8.10, 9.0
   - ghc-lib-parser-ex == 9.8.*          # 2024-05-19: preserve for GHC 9.8
   - happy == 1.19.12                    # for ghcjs
···
   - extensions == 0.1.0.2               # 2024-10-20: for GHC 9.10/Cabal 3.12
   - network-run == 0.4.0                # 2024-10-20: for GHC 9.10/network == 3.1.*
   - typst-symbols >=0.1.6 && <0.1.7     # 2024-11-20: for pandoc 3.5 and quarto
+  - ghc-source-gen < 0.4.6.0            # 2024-12-31: support GHC < 9.0
 
 package-maintainers:
   abbradar:

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

···
-# Stackage LTS 22.40
+# Stackage LTS 22.43
 # This file is auto-generated by
 # maintainers/scripts/haskell/update-stackage.sh
 default-package-overrides:
···
   - blaze-textual ==0.2.3.1
   - bloodhound ==0.21.0.0
   - bloomfilter ==2.0.1.2
-  - bluefin ==0.0.10.0
-  - bluefin-internal ==0.0.10.0
+  - bluefin ==0.0.12.1
+  - bluefin-internal ==0.0.13.0
   - bm ==0.2.0.0
   - bmp ==1.2.6.4
   - bnb-staking-csvs ==0.2.2.0
···
   - cabal2spec ==2.7.1
   - cabal-appimage ==0.4.0.5
   - cabal-clean ==0.2.20230609
-  - cabal-debian ==5.2.4
-  - cabal-doctest ==1.0.10
+  - cabal-debian ==5.2.5
+  - cabal-doctest ==1.0.11
   - cabal-file ==0.1.1
   - cabal-plan ==0.7.3.0
   - cabal-rpm ==2.1.5
···
   - crypton-x509 ==1.7.7
   - crypton-x509-store ==1.6.9
   - crypton-x509-system ==1.6.7
-  - crypton-x509-validation ==1.6.12
+  - crypton-x509-validation ==1.6.13
   - crypto-pubkey-types ==0.4.3
   - crypto-random-api ==0.2.0
   - cryptostore ==0.3.1.0
···
   - deriveJsonNoPrefix ==0.1.0.1
   - derive-storable ==0.3.1.0
   - derive-topdown ==0.0.3.0
-  - deriving-aeson ==0.2.9
+  - deriving-aeson ==0.2.10
   - deriving-compat ==0.6.6
   - deriving-trans ==0.9.1.0
   - detour-via-sci ==1.0.0
···
   - fixed ==0.3
   - fixed-length ==0.2.3.1
   - fixed-vector ==1.2.3.0
-  - fixed-vector-hetero ==0.6.1.1
+  - fixed-vector-hetero ==0.6.2.0
   - fix-whitespace ==0.1
   - flac ==0.2.1
   - flac-picture ==0.1.3
   - flags-applicative ==0.1.0.3
   - flat ==0.6
-  - flatparse ==0.5.1.0
+  - flatparse ==0.5.1.1
   - flay ==0.4
   - flexible-defaults ==0.0.3
   - FloatingHex ==0.5
···
   - ghc-lib ==9.6.6.20240701
   - ghc-lib-parser ==9.6.6.20240701
   - ghc-lib-parser-ex ==9.6.0.2
-  - ghc-parser ==0.2.6.0
+  - ghc-parser ==0.2.7.0
   - ghc-paths ==0.1.0.12
   - ghc-syntax-highlighter ==0.0.10.0
   - ghc-tcplugins-extra ==0.4.6
···
   - hsndfile-vector ==0.5.2
   - HsOpenSSL ==0.11.7.8
   - HsOpenSSL-x509-system ==0.1.0.4
-  - hspec ==2.11.9
-  - hspec-api ==2.11.9
+  - hspec ==2.11.10
+  - hspec-api ==2.11.10
   - hspec-attoparsec ==0.1.0.2
   - hspec-checkers ==0.1.0.2
   - hspec-contrib ==0.5.2
-  - hspec-core ==2.11.9
-  - hspec-discover ==2.11.9
+  - hspec-core ==2.11.10
+  - hspec-discover ==2.11.10
   - hspec-expectations ==0.8.4
   - hspec-expectations-json ==1.0.2.1
   - hspec-expectations-lifted ==0.10.0
···
   - hspec-junit-formatter ==1.1.2.1
   - hspec-leancheck ==0.0.6
   - hspec-megaparsec ==2.2.1
-  - hspec-meta ==2.11.9
+  - hspec-meta ==2.11.10
   - hspec-parsec ==0
   - hspec-smallcheck ==0.5.3
   - hspec-tmp-proc ==0.5.2.0
···
   - integer-conversion ==0.1.0.1
   - integer-logarithms ==1.0.3.1
   - integer-roots ==1.0.2.0
-  - integer-types ==0.1.4.0
+  - integer-types ==0.1.4.1
   - integration ==0.2.1
   - intern ==0.9.5
   - interpolate ==0.2.1
···
   - liboath-hs ==0.0.1.2
   - libyaml ==0.1.4
   - libyaml-clib ==0.2.5
-  - lifted-async ==0.10.2.6
+  - lifted-async ==0.10.2.7
   - lifted-base ==0.2.3.12
   - lift-generics ==0.2.1
   - lift-type ==0.1.2.0
···
   - logging-effect ==1.4.0
   - logging-facade ==0.3.1
   - logging-facade-syslog ==1
-  - logict ==0.8.1.0
+  - logict ==0.8.2.0
   - logstash ==0.1.0.4
   - loop ==0.3.0
   - lpeg ==1.0.4
···
   - multiset ==0.3.4.3
   - multistate ==0.8.0.4
   - murmur3 ==1.0.5
-  - murmur-hash ==0.1.0.10
+  - murmur-hash ==0.1.0.11
   - MusicBrainz ==0.4.1
   - mustache ==2.4.2
   - mutable-containers ==0.3.4.1
···
   - Only ==0.1
   - oo-prototypes ==0.1.0.0
   - oops ==0.2.0.1
-  - opaleye ==0.10.3.1
+  - opaleye ==0.10.4.0
   - OpenAL ==1.7.0.5
   - openapi3 ==3.2.4
   - open-browser ==0.2.1.0
···
   - OrderedBits ==0.0.2.0
   - ordered-containers ==0.2.4
   - ormolu ==0.7.2.0
-  - os-string ==2.0.6
+  - os-string ==2.0.7
   - overhang ==1.0.0
   - packcheck ==0.6.0
   - pager ==0.1.1.0
···
   - pureMD5 ==2.1.4
   - purescript-bridge ==0.15.0.0
   - purview ==0.2.0.2
-  - pusher-http-haskell ==2.1.0.18
+  - pusher-http-haskell ==2.1.0.19
   - pvar ==1.0.0.0
   - pwstore-fast ==2.4.4
   - PyF ==0.11.3.0
···
   - safe-foldable ==0.1.0.0
   - safe-gen ==1.0.1
   - safeio ==0.0.6.0
-  - safe-json ==1.2.0.1
+  - safe-json ==1.2.0.2
   - safe-money ==0.9.1
   - SafeSemaphore ==0.10.1
   - saltine ==0.2.1.0
···
   - sdl2-image ==2.1.0.0
   - sdl2-mixer ==1.2.0.0
   - sdl2-ttf ==2.1.3
-  - search-algorithms ==0.3.2
+  - search-algorithms ==0.3.3
   - secp256k1-haskell ==1.1.0
   - securemem ==0.1.10
   - selections ==0.3.0.0
···
   - shellmet ==0.0.5.0
   - shelltestrunner ==1.10
   - shell-utility ==0.1
-  - shellwords ==0.1.3.1
+  - shellwords ==0.1.3.2
   - shelly ==1.12.1
   - should-not-typecheck ==2.1.0
   - show-combinators ==0.2.0.0
   - siggy-chardust ==1.0.0
   - signal ==0.1.0.4
-  - silently ==1.2.5.3
+  - silently ==1.2.5.4
   - simple ==2.0.0
   - simple-affine-space ==0.2.1
   - simple-cabal ==0.1.3.1
···
   - system-argv0 ==0.1.1
   - systemd ==2.3.0
   - systemd-socket-activation ==1.1.0.1
-  - system-fileio ==0.3.16.4
-  - system-filepath ==0.4.14
+  - system-fileio ==0.3.16.5
+  - system-filepath ==0.4.14.1
   - system-info ==0.5.2
   - system-linux-proc ==0.1.1.1
   - tabular ==0.2.2.8
···
   - text-ansi ==0.3.0.1
   - text-binary ==0.2.1.1
   - text-builder ==0.6.7.2
-  - text-builder-dev ==0.3.5
+  - text-builder-dev ==0.3.6
   - text-builder-linear ==0.1.3
   - text-conversions ==0.3.1.1
   - text-format ==0.3.2.1
···
   - text-rope ==0.2
   - text-short ==0.1.6
   - text-show ==3.10.5
-  - text-show-instances ==3.9.9
+  - text-show-instances ==3.9.10
   - text-zipper ==0.13
   - tfp ==1.0.2
   - tf-random ==0.5
···
   - wai-websockets ==3.0.1.2
   - wakame ==0.1.0.0
   - warp ==3.3.31
-  - warp-tls ==3.4.7
+  - warp-tls ==3.4.9
   - wave ==0.2.1
   - wcwidth ==0.0.2
-  - webdriver ==0.12.0.0
+  - webdriver ==0.12.0.1
   - webex-teams-api ==0.2.0.1
   - webex-teams-conduit ==0.2.0.1
   - webpage ==0.0.5.1
···
   - wide-word ==0.1.6.0
   - Win32-notify ==0.3.0.3
   - windns ==0.1.0.1
-  - witch ==1.2.2.0
+  - witch ==1.2.3.1
   - withdependencies ==0.3.1
   - witherable ==0.4.2
   - within ==0.2.0.1
···
   - xmlbf ==0.7
   - xmlbf-xeno ==0.2.2
   - xmlbf-xmlhtml ==0.2.2
-  - xml-conduit ==1.9.1.3
+  - xml-conduit ==1.9.1.4
   - xmlgen ==0.6.2.2
   - xml-hamlet ==0.5.0.2
   - xml-helpers ==1.0.0

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

···
  - bamstats
  - barley
  - base32-bytestring
- - base_4_20_0_1
+ - base_4_21_0_0
  - baserock-schema
  - basic
  - batchd
···
  - chart-cli
  - chart-svg
  - chart-svg-various
- - chart-svg_0_7_0_0
+ - chart-svg_0_8_0_0
  - chart-unit
  - chassis
  - chatty
···
  - copilot-cbmc
  - copilot-frp-sketch
  - copilot-language
- - copilot-language_4_0
+ - copilot-language_4_1
  - copilot-libraries
- - copilot-libraries_4_0
+ - copilot-libraries_4_1
  - copilot-sbv
  - copilot-theorem
- - copilot-theorem_4_0
+ - copilot-theorem_4_1
  - copilot-verifier
- - copilot_4_0
+ - copilot_4_1
  - corenlp-parser
  - coroutine-enumerator
  - coroutine-iteratee
···
  - cqrs-test
  - cqrs-testkit
  - crackNum
- - crackNum_3_14
+ - crackNum_3_15
  - craft
  - craftwerk-cairo
  - craftwerk-gtk
···
  - gore-and-ash-sync
  - gps
  - gps2htmlReport
- - gpu-vulkan
- - gpu-vulkan-middle
  - grab-form
  - graflog
  - grammar-combinators
···
  - hoppy-docs
  - hoppy-runtime
  - hoppy-std
+ - hotel-california
  - hotswap
  - hp2any-graph
  - hp2any-manager
···
  - hs-functors
  - hs-gen-iface
  - hs-ix
+ - hs-opentelemetry-awsxray
+ - hs-opentelemetry-instrumentation-tasty
+ - hs-opentelemetry-sdk
+ - hs-opentelemetry-utils-exceptions
  - hs-pkpass
  - hs-profunctors
  - hs-sdl-term-emulator
···
  - mediabus-fdk-aac
  - mediabus-rtp
  - mediawiki2latex
+ - mello
  - mellon-gpio
  - mellon-web
  - memcache-conduit
···
  - openpgp-crypto-api
  - openssh-github-keys
  - opentelemetry-lightstep
+ - opentelemetry-plugin
  - opentok
  - opentracing-http-client
  - opentracing-jaeger
···
  - perdure
  - perf
  - perf-analysis
- - perf_0_13_0_0
+ - perf_0_14_0_1
  - perfecthash
  - periodic-client
  - periodic-client-exe
···
  - potoki-hasql
  - potoki-zlib
  - powerqueue-sqs
+ - ppad-base58
  - ppad-hmac-drbg
  - ppad-secp256k1
  - pqueue-mtl
···
  - random-extras
  - random-hypergeometric
  - range-space
+ - ranged-list_0_1_2_3
  - rasa
  - rasa-example-config
  - rasa-ext-bufs
···
  - remote-json-server
  - remotion
  - repa-array
- - repa-convert
  - repa-flow
  - repa-plugin
- - repa-stream
  - repa-v4l2
  - replicant
  - repo-based-blog
···
  - sr-extra
  - srt-dhall
  - srt-formatting
+ - srtree_2_0_0_2
  - sscgi
  - sshd-lint
  - sssp
···
  - sydtest-webdriver-screenshot_0_1_0_0
  - sydtest-webdriver-yesod
  - sydtest-yesod
- - sydtest_0_18_0_1
+ - sydtest_0_19_0_0
  - sylvia
  - symantic-atom
  - symantic-http-demo
···
  - tak-ai
  - takahashi
  - tal
- - talash
  - tamarin-prover
  - tamarin-prover-term
  - tamarin-prover-theory
···
  - type-sets
  - type-structure
  - type-sub-th
+ - typecheck-plugin-nat-simple_0_1_0_11
  - typed-admin
  - typed-encoding-encoding
  - typed-gui
···
  - unicoder
  - uniform-io
  - uniform-watch
+ - unimap
  - uniqueness-periods
  - uniqueness-periods-vector-examples
  - uniqueness-periods-vector-filters
···
  - warp-grpc
  - warp-quic
  - warped
- - waterfall-cad
- - waterfall-cad-examples
  - wavesurfer
  - wavy
  - weatherhs

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

···
 
   # Break infinite recursion cycle between QuickCheck and splitmix.
   splitmix = dontCheck super.splitmix;
+  splitmix_0_1_1 = dontCheck super.splitmix_0_1_1;
 
   # Break infinite recursion cycle with OneTuple and quickcheck-instances.
   foldable1-classes-compat = dontCheck super.foldable1-classes-compat;
···
       # Setup PATH for the actual tests
       ln -sf dist/build/git-annex/git-annex git-annex
       ln -sf git-annex git-annex-shell
+      ln -sf git-annex git-remote-annex
+      ln -sf git-annex git-remote-tor-annex
       PATH+=":$PWD"
 
       echo checkFlags: $checkFlags ''${checkFlagsArray:+"''${checkFlagsArray[@]}"}
···
   # break infinite recursion with base-orphans
   primitive = dontCheck super.primitive;
   primitive_0_7_1_0 = dontCheck super.primitive_0_7_1_0;
+  primitive_0_9_0_0 = dontCheck super.primitive_0_9_0_0;
 
   cut-the-crap =
     let path = pkgs.lib.makeBinPath [ pkgs.ffmpeg pkgs.youtube-dl ];
···
 
   # Test have become more fussy in >= 2.0. We need to have which available for
   # tests to succeed and the makefile no longer finds happy by itself.
-  happy_2_1_2 = overrideCabal (drv: {
+  happy_2_1_3 = overrideCabal (drv: {
     buildTools = drv.buildTools or [ ] ++ [ pkgs.buildPackages.which ];
     preCheck = drv.preCheck or "" + ''
       export PATH="$PWD/dist/build/happy:$PATH"
     '';
-  }) super.happy_2_1_2;
+  }) super.happy_2_1_3;
   # Additionally install documentation
   jacinda = overrideCabal (drv: {
     enableSeparateDocOutput = true;
···
   # Disable checks to break dependency loop with SCalendar
   scalendar = dontCheck super.scalendar;
 
+  # Make sure we build xz against nixpkgs' xz package instead of
+  # Hackage repackaging of the upstream sources.
+  xz = enableCabalFlag "system-xz" super.xz;
+  xz-clib = dontDistribute super.xz-clib;
+  lzma-static = dontDistribute super.lzma-static; # deprecated
+
   halide-haskell = super.halide-haskell.override { Halide = pkgs.halide; };
 
   feedback = self.generateOptparseApplicativeCompletions [ "feedback" ]
···
     }) super)
       gi-javascriptcore
       gi-webkit2webextension
-      gi-gtk_4_0_9
+      gi-gtk_4_0_11
       gi-gdk_4_0_9
       gi-gsk
       gi-adwaita

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

···
      }) {};
 
   "AspectAG" = callPackage
-    ({ mkDerivation, base, containers, ghc-prim, loch-th, mtl, poly-rec
-     , requirements, template-haskell
-     }:
+    ({ mkDerivation, base, mtl, poly-rec, requirements }:
      mkDerivation {
        pname = "AspectAG";
-       version = "0.7.0.1";
-       sha256 = "00cprqks3lany16zbmm250p1qms4hampwck44m688z2xk388gakn";
-       revision = "2";
-       editedCabalFile = "0hlgkm8ph28x1dkjprjjajdwk8y7ghsb9i6vr5jbr046vzrziblp";
-       libraryHaskellDepends = [
-         base containers ghc-prim loch-th mtl poly-rec requirements
-         template-haskell
-       ];
-       description = "Strongly typed Attribute Grammars implemented using type-level programming";
-       license = lib.licenses.gpl3Only;
+       version = "0.8.0.0";
+       sha256 = "00aqqsdwy94kzbrfjvwqk7h7b39fnkzr5fvkbrda70jhgp2vnpnh";
+       libraryHaskellDepends = [ base mtl poly-rec requirements ];
+       testHaskellDepends = [ base poly-rec requirements ];
+       description = "First-class Attribute Grammars implemented using type-level programming";
+       license = lib.licenses.gpl2Plus;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "Cabal_3_14_0_0" = callPackage
+  "Cabal_3_14_1_0" = callPackage
     ({ mkDerivation, array, base, bytestring, Cabal-syntax, containers
      , deepseq, directory, filepath, mtl, parsec, pretty, process, time
      , transformers, unix
      }:
      mkDerivation {
        pname = "Cabal";
-       version = "3.14.0.0";
-       sha256 = "0pfvw4r4xdnis34k4pz987283g2r5gv3akxnfp7s3jgxffd7nm94";
+       version = "3.14.1.0";
+       sha256 = "1858158n9dbh5hcpcv2ikl3q01kmlap6n5fsp76mzihir5903ii3";
        setupHaskellDepends = [ mtl parsec ];
        libraryHaskellDepends = [
          array base bytestring Cabal-syntax containers deepseq directory
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "Cabal-syntax_3_14_0_0" = callPackage
+  "Cabal-syntax_3_14_1_0" = callPackage
     ({ mkDerivation, alex, array, base, binary, bytestring, containers
      , deepseq, directory, filepath, mtl, parsec, pretty, text, time
      , transformers
      }:
      mkDerivation {
        pname = "Cabal-syntax";
-       version = "3.14.0.0";
-       sha256 = "0c9gwm9za13zvrwbq2lgzfcw6r42r2pwc424qk3vjnv4kazrni5x";
+       version = "3.14.1.0";
+       sha256 = "13d4sfqlbx2m8f075jnqq965sj0ayn1vk2fd2m8rdp9fsqy8hxm0";
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq directory filepath
          mtl parsec pretty text time transformers
···
        pname = "Chart";
        version = "1.9.5";
        sha256 = "0nyzdag9p56vknrphdnqjsf19fmw9abs81avdm2vjgh9cnw2y7hc";
-       revision = "1";
-       editedCabalFile = "0gi758fccq3674sxzs5qcdlyjivh78lzin5k4cb15d3gscjakkhk";
+       revision = "2";
+       editedCabalFile = "1a9z8an5yhsqbawzahmg77g9l6jvavhxbk2v48k4j8fyr7sy544q";
        libraryHaskellDepends = [
          array base colour data-default-class lens mtl old-locale
          operational time vector
···
        pname = "Chart-cairo";
        version = "1.9.4.1";
        sha256 = "0x10l9y38bscx88n849k9ybn7axp4j9hlivc1jv9wwvv4gqw5jr7";
-       revision = "1";
-       editedCabalFile = "193liy309yb9dnlfzfrc2kis0g8mj6ni1pqfr4kpn860r1m5gr5b";
+       revision = "2";
+       editedCabalFile = "0gyhv409q1a9rxw0j51rngws2bzy7xnjsbs4lj2wysjxp8c7xs74";
        libraryHaskellDepends = [
          array base cairo Chart colour data-default-class lens mtl
          old-locale operational time
···
        pname = "Chart-diagrams";
        version = "1.9.5.1";
        sha256 = "1pk2fsmjl2dsabzpdwk3190nw0nwy581c4qsl93npx764qcxkp7q";
-       revision = "1";
-       editedCabalFile = "0s2c4qrmy21y7cmsq24g67fw1q5vsspda8bz2ybp6117crnzw817";
+       revision = "2";
+       editedCabalFile = "14z8s46qxcn33mzy66zhlg0pmwk1xks8c3mmrrbj4bp30wldgihz";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base blaze-markup bytestring Chart colour containers
···
        pname = "Chart-gtk";
        version = "1.9.3";
        sha256 = "0wdv193wsadzrkpxl6lzw2r11bvr4fnfhmzqcmpqns3psqpgk43f";
+       revision = "1";
+       editedCabalFile = "1a9gqgbhgr3qqmp953idl8p14apnxmr2m7znf4pfvbms6gih5fbb";
        libraryHaskellDepends = [
          array base cairo Chart Chart-cairo colour data-default-class gtk
          mtl old-locale time
···
        pname = "Chart-gtk3";
        version = "1.9.3";
        sha256 = "0lldchq419fivczas2sbbz45b1xlf2chd7a2af66mbigdbld3xka";
+       revision = "1";
+       editedCabalFile = "0l6yp4k3nnppnd6ryhykfm30hlk3j2raswrc3lc996mpkbb1rja0";
        libraryHaskellDepends = [
          array base cairo Chart Chart-cairo colour data-default-class gtk3
          mtl old-locale time
···
        pname = "Chart-tests";
        version = "1.9.4";
        sha256 = "1sy31dl4mwm25ajpgr0pgkr85py5raf7h76bnz06ybygjbnmc4fp";
+       revision = "1";
+       editedCabalFile = "0dpq35wrswxinzscapwn399xfpf6ndb0xxb5aj56snzv5b8kd90m";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        broken = true;
      }) {};
 
+  "ChibiHash" = callPackage
+    ({ mkDerivation, base, bytestring, hspec }:
+     mkDerivation {
+       pname = "ChibiHash";
+       version = "0.2.0.0";
+       sha256 = "023ddj6sywlnjrr17g5kgzjwgr5fp9rs613slc7rxx5rjsaddjwz";
+       revision = "1";
+       editedCabalFile = "0pvfjhqv3x2x9nc2hh9byp91rla8rskjhvms794sd6sfgx64a0jn";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base bytestring ];
+       executableHaskellDepends = [ base bytestring ];
+       testHaskellDepends = [ base bytestring hspec ];
+       description = "a simple and fast 64-bit hash function";
+       license = lib.licenses.mit;
+       mainProgram = "ChibiHash-example";
+     }) {};
+
   "Chitra" = callPackage
     ({ mkDerivation, base, binary, bytestring, mtl, network }:
      mkDerivation {
···
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        broken = true;
+     }) {};
+
+  "ClickHaskell" = callPackage
+    ({ mkDerivation, base, binary, bytestring, deepseq, network, text
+     , time, vector, wide-word
+     }:
+     mkDerivation {
+       pname = "ClickHaskell";
+       version = "0.1.0";
+       sha256 = "1yb3g1rh587clzhlav00c0m7v3fy4i09jf55i2mlwcv3w2xk1hd7";
+       revision = "1";
+       editedCabalFile = "1d8msl3vlazp7xsbd5glxjc1qppfi8q7x6ncqdd6mmi88q8rfgrz";
+       libraryHaskellDepends = [
+         base binary bytestring deepseq network text time vector wide-word
+       ];
+       description = "ClickHouse driver";
+       license = lib.licenses.bsd3;
      }) {};
 
   "Clipboard" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "Diff_1_0_1_1" = callPackage
+  "Diff_1_0_2" = callPackage
     ({ mkDerivation, array, base, directory, pretty, process
      , QuickCheck, test-framework, test-framework-quickcheck2
      }:
      mkDerivation {
        pname = "Diff";
-       version = "1.0.1.1";
-       sha256 = "060ksa6ql4v6gjdjhrd4q1kr9qs7hz48pacan8gq6baa7xvc5m6v";
+       version = "1.0.2";
+       sha256 = "11ad6ng3pqjb9dixnqk35bpgzjzva7ifnnjjlz0z5xzbsp9jcznd";
        libraryHaskellDepends = [ array base pretty ];
        testHaskellDepends = [
          array base directory pretty process QuickCheck test-framework
···
      }) {};
 
   "HCL" = callPackage
-    ({ mkDerivation, base, containers, HUnit, mtl, QuickCheck, random
+    ({ mkDerivation, base, containers, exceptions, HUnit, mtl
+     , QuickCheck, random
      }:
      mkDerivation {
        pname = "HCL";
-       version = "1.8";
-       sha256 = "1h5mrrpr6kma8k0mqzzjcyg3nd94f7lv6a2k5pfxcqs01qy3khgk";
+       version = "1.9";
+       sha256 = "0rl4i1p7k6ibjsqmzbdv44k9r01n6p4r8y47zjrv7pl1nm2f2csh";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
-       libraryHaskellDepends = [ base containers mtl QuickCheck random ];
+       libraryHaskellDepends = [
+         base containers exceptions mtl QuickCheck random
+       ];
        executableHaskellDepends = [
          base containers mtl QuickCheck random
        ];
        testHaskellDepends = [
-         base containers HUnit mtl QuickCheck random
+         base containers exceptions HUnit mtl QuickCheck random
        ];
        description = "High-level library for building command line interfaces";
        license = lib.licenses.bsd3;
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "HSvm_1_0_3_32" = callPackage
+  "HSvm_1_0_3_35" = callPackage
     ({ mkDerivation, base, containers }:
      mkDerivation {
        pname = "HSvm";
-       version = "1.0.3.32";
-       sha256 = "1azbvnq13js2k3mvkmhdp9pjibkshyjigsc9krl9v26gkicmz47y";
+       version = "1.0.3.35";
+       sha256 = "0zs1l9022hc7j7mh5q2xa09ax33cx1llhgwfsf0s85494v732v0v";
        libraryHaskellDepends = [ base containers ];
        description = "Haskell Bindings for libsvm";
-       license = lib.licenses.bsd2;
+       license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
      }) {};
 
···
        pname = "HaXml";
        version = "1.25.13";
        sha256 = "0wxkp9bnbnjrjrzsmpm6nknzn0ijiiajd5kms81kgyfypm4m91ax";
-       revision = "2";
-       editedCabalFile = "1y1qf3224gls6f27pp8w9cpyisdr24pan8ccfh1zffy9m2bk80lj";
+       revision = "3";
+       editedCabalFile = "069v5wapa004h37l16lfv81a7f1877apv8gvklax31z5b5i72hcx";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.lgpl21Only;
      }) {};
 
+  "HaXml_1_25_14" = callPackage
+    ({ mkDerivation, base, bytestring, containers, directory, filepath
+     , polyparse, pretty, random
+     }:
+     mkDerivation {
+       pname = "HaXml";
+       version = "1.25.14";
+       sha256 = "1zvrpa88pydak4yx984zk7j5z84hqfyv682j6chk8j4kva6xhxza";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring containers filepath polyparse pretty random
+       ];
+       executableHaskellDepends = [ base directory polyparse pretty ];
+       description = "Utilities for manipulating XML documents";
+       license = lib.licenses.lgpl21Only;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "Hach" = callPackage
     ({ mkDerivation, base, containers, network, old-locale, text, time
      , vty, vty-ui
···
        license = lib.licenses.bsd3;
      }) {inherit (pkgs) imlib2;};
 
+  "ImpSpec" = callPackage
+    ({ mkDerivation, base, bytestring, deepseq, hspec, hspec-core
+     , hspec-expectations-lifted, HUnit, mtl, prettyprinter
+     , prettyprinter-ansi-terminal, QuickCheck, quickcheck-transformer
+     , random, text, unliftio
+     }:
+     mkDerivation {
+       pname = "ImpSpec";
+       version = "0.1.0.0";
+       sha256 = "1f0l8hlkf1d37m2xy8fsvizs7c9vr8y0kcqlwp0741fhwdnqzciq";
+       libraryHaskellDepends = [
+         base bytestring deepseq hspec hspec-core hspec-expectations-lifted
+         HUnit mtl prettyprinter prettyprinter-ansi-terminal QuickCheck
+         quickcheck-transformer random text unliftio
+       ];
+       testHaskellDepends = [ base ];
+       description = "Imperative approach to testing stateful applications. ImpSpec is build on top of HSpec and QuickCheck";
+       license = lib.licenses.asl20;
+     }) {};
+
   "ImperativeHaskell" = callPackage
     ({ mkDerivation, base, mtl, template-haskell }:
      mkDerivation {
···
        pname = "LC3";
        version = "0.1.0.2";
        sha256 = "029l4rgdzas0w9c4dpgfxhgbl1ngkvsfd3yf6mx8vwriwgmqbs05";
+       revision = "1";
+       editedCabalFile = "0zb59py1ysw9kwa6n07n7c9fvpbk2xjvaq3h06dzjs7wxs8yj0p4";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
     ({ mkDerivation, base, directory, process }:
      mkDerivation {
        pname = "MicroCabal";
-       version = "0.2.1.1";
-       sha256 = "0yln9inja3m624qqpslws8jxk4x27v0yy7pc7p7915c15lxnpy68";
+       version = "0.3.1.2";
+       sha256 = "175f6s0b6h3vdi57jdwwx6mbi8azm3j5cnbqi1il3356hhfq0786";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base directory process ];
···
      }) {};
 
   "MicroHs" = callPackage
-    ({ mkDerivation, base, deepseq, directory, ghc-prim, haskeline
-     , process, text, time
+    ({ mkDerivation, base, deepseq, directory, filepath, ghc-prim
+     , haskeline, process, text, time
      }:
      mkDerivation {
        pname = "MicroHs";
-       version = "0.10.4.0";
-       sha256 = "15c4kwkbnz894zvcvdj035k6lcjj8rh9rjm6l7cwirqk2q5nk6pm";
+       version = "0.10.7.0";
+       sha256 = "0s1px67b1ssw1scdh6ffx46iivsk628k9s3rrv70fbgpms31mjvf";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
        executableHaskellDepends = [
-         base deepseq directory ghc-prim haskeline process text time
+         base deepseq directory filepath ghc-prim haskeline process text
+         time
        ];
        description = "A small compiler for Haskell";
        license = lib.licenses.asl20;
···
        mainProgram = "mucheck-smallcheck";
      }) {};
 
+  "MultiChor" = callPackage
+    ({ mkDerivation, base, bytestring, http-client, mtl, servant
+     , servant-client, servant-server, template-haskell
+     , unordered-containers, warp
+     }:
+     mkDerivation {
+       pname = "MultiChor";
+       version = "1.0.1.1";
+       sha256 = "1rdwjr6j398m91f7a6mjhpp9zjzs2iclq22q221pcxx5x1y08hq1";
+       libraryHaskellDepends = [
+         base bytestring http-client mtl servant servant-client
+         servant-server template-haskell unordered-containers warp
+       ];
+       description = "Type-safe and efficient choreographies with location-set polymorphism";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "MultipletCombiner" = callPackage
     ({ mkDerivation, base, HUnit }:
      mkDerivation {
···
        pname = "OneTuple";
        version = "0.4.2";
        sha256 = "0mdbga3a5pjzszlq9bny3zgfbz25w2q2bjw2h6q1fk80yjhahk8p";
+       revision = "1";
+       editedCabalFile = "1m54gsnc1bqy30vv3fab7axxmfns23cass11cvjp0afshgwncwnx";
        libraryHaskellDepends = [ base ghc-prim template-haskell ];
        testHaskellDepends = [ base hashable template-haskell ];
        description = "Singleton Tuple";
···
        pname = "PSQueue";
        version = "1.2.0";
        sha256 = "1rkvaz6gjh6cg9an67nly82v5wvpjrrh7qdlb5q2lc3zpr3kh01r";
-       revision = "2";
-       editedCabalFile = "1cxv515z5ni102jwgadzsnaphimldrjz1klg33dbha87yblj2pgv";
+       revision = "3";
+       editedCabalFile = "0nfb930h870l21611zq894lbr2rzwzkc49b9kjgsvr7j0ag4nmxr";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base QuickCheck ];
        description = "Priority Search Queue";
···
     ({ mkDerivation, base, containers, diagrams-lib, hspec }:
      mkDerivation {
        pname = "PenroseKiteDart";
-       version = "1.1.0";
-       sha256 = "0m1wigw2n2cp1cgbj615xrzqq81yaaprdrfnpd7qilnzijrp0biq";
+       version = "1.2";
+       sha256 = "09z9kyyqmmbhw89inikh8hr2v8ninkwn4wkb7mjnfja92d4nfj3a";
        libraryHaskellDepends = [ base containers diagrams-lib ];
        testHaskellDepends = [ base containers diagrams-lib hspec ];
        benchmarkHaskellDepends = [ base containers diagrams-lib ];
···
     ({ mkDerivation, base, mmorph, QuickCheck, random, transformers }:
      mkDerivation {
        pname = "QuickCheck-GenT";
-       version = "0.2.2.1";
-       sha256 = "16kn7l98h7px3644gjc24a8pgisy1gr3w5k4gzw71dp6msqcbnqh";
+       version = "0.2.2.2";
+       sha256 = "1sss452xjxhllvsaxm2ln932xcdnj4z1095yapv9yap4cbcjwaqf";
        libraryHaskellDepends = [
          base mmorph QuickCheck random transformers
        ];
···
      }) {};
 
   "Raincat" = callPackage
-    ({ mkDerivation, base, containers, extensible-exceptions, GLUT, mtl
-     , OpenGL, random, sdl2, sdl2-image, sdl2-mixer, time
+    ({ mkDerivation, base, containers, GLUT, mtl, OpenGL, random, sdl2
+     , sdl2-image, sdl2-mixer, time
      }:
      mkDerivation {
        pname = "Raincat";
-       version = "1.2.1";
-       sha256 = "10y9zi22m6hf13c9h8zd9vg7mljpwbw0r3djb6r80bna701fdf6c";
+       version = "1.2.3";
+       sha256 = "1w20342faksdvqh2zw7kp1317vmy3khzxzjnzxcl4gknf2j9fls7";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
        executableHaskellDepends = [
-         base containers extensible-exceptions GLUT mtl OpenGL random sdl2
-         sdl2-image sdl2-mixer time
+         base containers GLUT mtl OpenGL random sdl2 sdl2-image sdl2-mixer
+         time
        ];
        description = "A puzzle game written in Haskell with a cat in lead role";
        license = lib.licenses.bsd3;
···
        pname = "ShellCheck";
        version = "0.10.0";
        sha256 = "08bdjcdl457xz2vh8y2w29bcwh1k7sfzyvszln3498vm5m1xn22d";
+       revision = "1";
+       editedCabalFile = "1935jrzy1r3g9cc74b330fmxnz2i1j8hsdk9jnl557qgk6xjqzs7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "Spintax" = callPackage
-    ({ mkDerivation, attoparsec, base, extra, mtl, mwc-random, text }:
+    ({ mkDerivation, attoparsec, base, either, extra, mtl, mwc-random
+     , text
+     }:
      mkDerivation {
        pname = "Spintax";
-       version = "0.3.6.1";
-       sha256 = "066pks24c4501i86hgll3bygqkgyag7n2src19k0x9gc05p130wr";
-       revision = "1";
-       editedCabalFile = "1946q9361nzsp4aa6jxv36g96nhgb7isv3wpcrnvvk4r2w0jvlmp";
+       version = "0.3.7.0";
+       sha256 = "1w2rfq9ayylifqgj5a0d9ivf9jvk43k4y23djpmwi02qlb96qr75";
        libraryHaskellDepends = [
-         attoparsec base extra mtl mwc-random text
+         attoparsec base either extra mtl mwc-random text
        ];
        description = "Random text generation based on spintax";
        license = lib.licenses.bsd3;
···
     ({ mkDerivation }:
      mkDerivation {
        pname = "Win32";
-       version = "2.14.0.0";
-       sha256 = "1rb65bhma4dhs6gprr3k195fysx56k89s3v5cdhj2wghb3dwv7ag";
+       version = "2.14.1.0";
+       sha256 = "00sqx9vpkp56nblks3fq7v4bn6lig3cp4w504wjfz03dgwhh7xwy";
        description = "A binding to Windows Win32 API";
        license = lib.licenses.bsd3;
        platforms = lib.platforms.windows;
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "Yampa_0_14_12" = callPackage
+    ({ mkDerivation, base, criterion, deepseq, filepath, random
+     , simple-affine-space, time
+     }:
+     mkDerivation {
+       pname = "Yampa";
+       version = "0.14.12";
+       sha256 = "032kzcrxpsdb53xg7qrjl1h8vfd8alfknd8s03zsn8gg85grdnl3";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base deepseq random simple-affine-space
+       ];
+       benchmarkHaskellDepends = [ base criterion filepath time ];
+       description = "Elegant Functional Reactive Programming Language for Hybrid Systems";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "Yampa-core" = callPackage
     ({ mkDerivation, base, deepseq, random, vector-space }:
      mkDerivation {
···
        broken = true;
      }) {};
 
+  "aeson-jsonpath" = callPackage
+    ({ mkDerivation, aeson, base, hspec, parsec, protolude, vector }:
+     mkDerivation {
+       pname = "aeson-jsonpath";
+       version = "0.1.0.0";
+       sha256 = "0s7i5zsjzvsq1xj2xaf208fmhp34lzxavz5y38sygwj910wn6pl8";
+       libraryHaskellDepends = [ aeson base parsec protolude vector ];
+       testHaskellDepends = [ aeson hspec parsec protolude ];
+       description = "Parse and run JSONPath queries on Aeson documents";
+       license = lib.licenses.mit;
+     }) {};
+
   "aeson-lens" = callPackage
     ({ mkDerivation, aeson, base, bytestring, doctest, lens, text
      , unordered-containers, vector
···
      }:
      mkDerivation {
        pname = "aftovolio";
-       version = "0.4.0.0";
-       sha256 = "0gf86va0x7ni169w4swcr1m5qf115i925pckbw342m7md3k8a6rv";
+       version = "0.6.2.0";
+       sha256 = "0ijyhd38g7dfd64dksc5v834qd1k2wmz2r37fsz612xdgkldfqcc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "aip-version";
-       version = "0.0.0.2";
-       sha256 = "0gcdbvcikiqg86nvcf6b8b897fq9mciilc9p0sfnfphabqlb1q55";
+       version = "0.0.0.3";
+       sha256 = "0vdzyi4ns4z84s0i6j2psw9r9x6kvhgnv13pql3xcdxzdmjsl20c";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        benchmarkHaskellDepends = [ base criterion deepseq text vector ];
        description = "Fast Aho-Corasick string searching";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
        mainProgram = "dump-automaton";
-       broken = true;
      }) {};
 
   "alg" = callPackage
···
        license = lib.licenses.gpl3Only;
      }) {};
 
+  "amqp-utils_0_6_6_0" = callPackage
+    ({ mkDerivation, amqp, base, bytestring, containers
+     , crypton-connection, crypton-x509-system, data-default-class
+     , directory, filepath, filepath-bytestring, hinotify, magic
+     , network, process, rawfilepath, text, time, tls, unix, utf8-string
+     }:
+     mkDerivation {
+       pname = "amqp-utils";
+       version = "0.6.6.0";
+       sha256 = "08s3djzf4jpz765myxa2jl4sng61892xalczsgka2rnpgvxgcap0";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         amqp base bytestring containers crypton-connection
+         crypton-x509-system data-default-class directory filepath
+         filepath-bytestring hinotify magic network process rawfilepath text
+         time tls unix utf8-string
+       ];
+       description = "AMQP toolset for the command line";
+       license = lib.licenses.gpl3Only;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "amqp-worker" = callPackage
     ({ mkDerivation, aeson, amqp, base, bytestring, exceptions
      , monad-loops, mtl, resource-pool, text
···
        pname = "android-activity";
        version = "0.1";
        sha256 = "07mgmpcwj7xi3ibmlcz45l645s5cbfnkr1brlhrzbnbyx72x7dr6";
+       revision = "1";
+       editedCabalFile = "0ix06grk7kbr0pxa9i8f1amma7vmyrkwz3r5xi8b82j7p0b30mac";
        libraryHaskellDepends = [ base data-default ];
        description = "Turn regular Haskell programs into Android Activities";
        license = lib.licenses.bsd3;
···
     ({ mkDerivation, base, hspec, hspec-discover, QuickCheck, vector }:
      mkDerivation {
        pname = "anitomata";
-       version = "0.1.0.2";
-       sha256 = "01c1cjczb2mvgl93iqf3zg9sm9rz307bi8f96nk113r036db6nh9";
+       version = "0.1.0.3";
+       sha256 = "04v0iwvs1q1c2bnflw8jqvnz9myhjh7sygkcx98dvjjiv9zxfhbh";
        libraryHaskellDepends = [ base vector ];
        testHaskellDepends = [ base hspec QuickCheck vector ];
        testToolDepends = [ hspec-discover ];
···
      }:
      mkDerivation {
        pname = "anitomata-aseprite";
-       version = "0.1.1.2";
-       sha256 = "177gqb3p64h8ymw5i20fd0xba1hqcw4j4prqnp6hs1h6wgrcmppq";
+       version = "0.1.1.3";
+       sha256 = "0zbqvhj3rlzma19mw6mwdwwqknribm7srn390zvzf5gfzcp5gi70";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "ansi-terminal_1_1_1" = callPackage
+  "ansi-terminal_1_1_2" = callPackage
     ({ mkDerivation, ansi-terminal-types, base, colour }:
      mkDerivation {
        pname = "ansi-terminal";
-       version = "1.1.1";
-       sha256 = "0k5wl5b9bzvkgplg4rgsz92rkps18s1qy5p560ypzad5z36qyi3y";
+       version = "1.1.2";
+       sha256 = "1c2n051943gkwc87vpw7nrjxr5hivzq128x9k5j2mqji0hz4ml58";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ ansi-terminal-types base colour ];
···
     ({ mkDerivation, base, ghc-prim, integer-gmp }:
      mkDerivation {
        pname = "aop-prelude";
-       version = "0.4.1.2";
-       sha256 = "0fjq8aifwcs9vm8l1vz5i7vfq3ca1g8w1ffp0f6w7cgdq0i9c16y";
+       version = "0.5.0.0";
+       sha256 = "121z6ikqcpyfb3caja40vdcc6g903akxbg7ybs1si95g8yqi5h0i";
        libraryHaskellDepends = [ base ghc-prim integer-gmp ];
        testHaskellDepends = [ base ghc-prim ];
        description = "prelude for Algebra of Programming";
···
        pname = "apply-merge";
        version = "0.1.1.0";
        sha256 = "1snm9m35r3px9vgn64ygcqq37ay6jvwc5jsi3s62rxrh8biy8ir8";
-       revision = "2";
-       editedCabalFile = "1k5iajw80v2i40zmks4h8f9pfy8nq5zx55dwxgvn5z1k44wxa5z6";
+       revision = "3";
+       editedCabalFile = "1mcjvd77l4iz1yq02j4kqaicrimayb3ldxas8f96b7sisr1zyl14";
        libraryHaskellDepends = [ base containers pqueue reflection ];
        testHaskellDepends = [
          base containers data-ordlist pqueue reflection tasty
···
      }:
      mkDerivation {
        pname = "arion-compose";
-       version = "0.2.1.0";
-       sha256 = "188nbv404zly4p0klj2aad8lkfzgma473gzj4f7sxynkl11dp8f1";
+       version = "0.2.2.0";
+       sha256 = "0rrxsyb7s9smx3k6hjj5cjysjdzcgpvfypys5d8gwy5jj15liism";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        pname = "array";
        version = "0.5.8.0";
        sha256 = "0sz6cm7p8n7kh8xyn0lpl7g6g744r57v9c2d827ng3b0mkb2s0is";
-       revision = "1";
-       editedCabalFile = "0j8lbxf3wliz3cal5zp9bh0ifisn0kncadg98fnlav5ls8rmby8n";
+       revision = "2";
+       editedCabalFile = "16y3q0gdd8qdj59vn1srnsqwqmfdk6nwnjs0z352iq8xh14zpg6c";
        libraryHaskellDepends = [ base ];
        description = "Mutable and immutable arrays";
        license = lib.licenses.bsd3;
···
        pname = "arrayfire";
        version = "0.7.0.0";
        sha256 = "0id1safpvd6lmjddgnkw94i6c586ba71yid4xfjq06wjx52l33rk";
+       revision = "1";
+       editedCabalFile = "0p5kzc32y18lwpnab7dg7bzppklw27mqzs21am4rr9dn5ghdwfdx";
        isLibrary = true;
        isExecutable = true;
        setupHaskellDepends = [ base Cabal cabal-doctest ];
···
      }:
      mkDerivation {
        pname = "arrow-utils";
-       version = "0.1.1";
-       sha256 = "112g74g844lnqfphkxqmp8ysnvi11iii9gcn70ml1ag6m5bdr7lc";
+       version = "0.1.2";
+       sha256 = "138bzcir259k1kql4h9shh5snfh7x7j3j7cwnbj9c70jywdnm1xd";
        libraryHaskellDepends = [ base vector-sized ];
        testHaskellDepends = [
          base QuickCheck test-framework test-framework-quickcheck2
···
        pname = "assoc";
        version = "1.1.1";
        sha256 = "1xhg7fqs8i067q2wmpma1yynsa9vbrhjh4pmbbcmv7zhzsvlj493";
+       revision = "1";
+       editedCabalFile = "0pqq27nzpsabvklgbldqls37mcl2hzs19qy6balsqk7b3x6rpcqa";
        libraryHaskellDepends = [ base ];
        description = "swap and assoc: Symmetric and Semigroupy Bifunctors";
        license = lib.licenses.bsd3;
···
        license = lib.licenses.asl20;
      }) {};
 
+  "atomic-counter_0_1_2_3" = callPackage
+    ({ mkDerivation, async, base, primitive, QuickCheck, stm, tasty
+     , tasty-bench, tasty-quickcheck
+     }:
+     mkDerivation {
+       pname = "atomic-counter";
+       version = "0.1.2.3";
+       sha256 = "016gyi2nzgr0lyd3g99snjjh49i2hgs8kbrjprn4439w3cwn6jyf";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [
+         async base QuickCheck tasty tasty-quickcheck
+       ];
+       benchmarkHaskellDepends = [
+         async base primitive QuickCheck stm tasty tasty-bench
+         tasty-quickcheck
+       ];
+       description = "Mutable counters that can be modified with atomic operatinos";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "atomic-file-ops" = callPackage
     ({ mkDerivation, base, directory, filelock, filepath
      , io-string-like
···
        pname = "attoparsec";
        version = "0.14.4";
        sha256 = "0v4yjz4qi8bwhbyavqxlhsfb1iv07v10gxi64khmsmi4hvjpycrz";
-       revision = "5";
-       editedCabalFile = "1bmih9b4b3vdad8mpwy6k15ay2k8zbxl0z5x40b47ml1p0wraw7c";
+       revision = "6";
+       editedCabalFile = "1wrm23wl373219znwbcgpdpyw6a9ahwwhbvx387h07vln459s4im";
        libraryHaskellDepends = [
          array base bytestring containers deepseq ghc-prim scientific text
          transformers
···
        license = lib.licenses.mit;
      }) {};
 
-  "auto-update_0_2_2" = callPackage
+  "auto-update_0_2_6" = callPackage
     ({ mkDerivation, base, exceptions, hspec, hspec-discover, HUnit
-     , retry
+     , retry, stm
      }:
      mkDerivation {
        pname = "auto-update";
-       version = "0.2.2";
-       sha256 = "1x93p1qylbll32sxwwmad5nb8q5p0z0zma9ymrxpz17zy80rqq59";
-       libraryHaskellDepends = [ base ];
+       version = "0.2.6";
+       sha256 = "0m0f9v3cbacgs1fmbh82r2bqbs7ya76zz0g9zy0hk8p2kmfcq9cs";
+       libraryHaskellDepends = [ base stm ];
        testHaskellDepends = [ base exceptions hspec HUnit retry ];
        testToolDepends = [ hspec-discover ];
        description = "Efficiently run periodic, on-demand actions";
···
      }:
      mkDerivation {
        pname = "automaton";
-       version = "1.4";
-       sha256 = "0g04as057ya3r698q8kwc73lzj2pzqwns7pd6dy84qs7rsxyj1fj";
+       version = "1.5";
+       sha256 = "0zm67nrk15yzw4r8p8ak2birly425xg0vfbzbdjznhpz0zsl09qz";
+       isLibrary = true;
+       isExecutable = true;
        libraryHaskellDepends = [
+         base mmorph MonadRandom mtl profunctors selective semialign
+         simple-affine-space these transformers
+       ];
+       executableHaskellDepends = [
          base mmorph MonadRandom mtl profunctors selective semialign
          simple-affine-space these transformers
        ];
···
          semialign simple-affine-space tasty tasty-hunit tasty-quickcheck
          these transformers
        ];
-       description = "Effectful streams and automata in initial encoding";
+       description = "Effectful streams and automata in coalgebraic encoding";
        license = lib.licenses.mit;
      }) {};
 
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "aws_0_24_2" = callPackage
+  "aws_0_24_3" = callPackage
     ({ mkDerivation, aeson, attoparsec, attoparsec-aeson, base
      , base16-bytestring, base64-bytestring, blaze-builder, byteable
      , bytestring, case-insensitive, cereal, conduit, conduit-extra
···
      }:
      mkDerivation {
        pname = "aws";
-       version = "0.24.2";
-       sha256 = "0bk8pc6zs514dg7bm97y6969rzndf3mvbdrdgbv2vwn70k1n1r66";
+       version = "0.24.3";
+       sha256 = "1vmgzpkkkmhsczxdnqiyq0havgf7269dk0xjc10gfw6f9dfxzqjz";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "aws-spend-summary";
-       version = "0.1.0.0";
-       sha256 = "0maspcjm53ncd2004h2xp6yr6c6gz9qv15wkx0c49r4wl6iaaqm1";
+       version = "0.2.0.0";
+       sha256 = "0hsyk496wn96qwsf9p8ari45gdg31p2aazql15kjjgzjlnb83yl0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "bank-holiday-germany";
        version = "1.3.0.0";
        sha256 = "1agf4flql5xkj2rpdbdxpmvajhigcwzbxsmrh76bckmcj2b38k9f";
-       revision = "3";
-       editedCabalFile = "1v89p0d8q41ivmjciw0aw5w79y1kbyn23ma0s8673liwqxlzldig";
+       revision = "4";
+       editedCabalFile = "057nvj7bd6hm4xjylr75gq3sg74iz8h4xkyzxmxj54x76nplgq9i";
        libraryHaskellDepends = [ base time ];
        testHaskellDepends = [
          base doctest hedgehog hspec hspec-hedgehog time
···
        broken = true;
      }) {};
 
-  "base_4_20_0_1" = callPackage
+  "base_4_21_0_0" = callPackage
     ({ mkDerivation, ghc-internal, ghc-prim }:
      mkDerivation {
        pname = "base";
-       version = "4.20.0.1";
-       sha256 = "0pg93zvlvx56ffz8b2gf920an4jzqyd1305h59c7slx51ibf2aww";
+       version = "4.21.0.0";
+       sha256 = "18jlid0yzsgxlg7mhdpfsr5jc8lvqrnvwkx1vmd8vl947nwzd9sj";
        libraryHaskellDepends = [ ghc-internal ghc-prim ];
        description = "Core data structures and operations";
        license = lib.licenses.bsd3;
···
        license = lib.licenses.mit;
      }) {};
 
-  "base-compat_0_14_0" = callPackage
+  "base-compat_0_14_1" = callPackage
     ({ mkDerivation, base, ghc-prim, unix }:
      mkDerivation {
        pname = "base-compat";
-       version = "0.14.0";
-       sha256 = "0l4wg4xna7dnphlzslbxvi4h2rm35pw0sdn9ivhynf6899kdwipi";
+       version = "0.14.1";
+       sha256 = "1s9mk80lb8rscb0rndm9pkh1nmkkd4dnl7nymb3qypk43ra5brkl";
        libraryHaskellDepends = [ base ghc-prim unix ];
        description = "A compatibility layer for base";
        license = lib.licenses.mit;
···
        license = lib.licenses.mit;
      }) {};
 
-  "base-compat-batteries_0_14_0" = callPackage
+  "base-compat-batteries_0_14_1" = callPackage
     ({ mkDerivation, base, base-compat, ghc-prim, hspec, hspec-discover
      , QuickCheck
      }:
      mkDerivation {
        pname = "base-compat-batteries";
-       version = "0.14.0";
-       sha256 = "1qxbv7ywdr79bbi7py97k2ph1x6i9flw7kk6hmqrk00nzpqsbs1s";
+       version = "0.14.1";
+       sha256 = "1q9873jrfld2gqkw8xfhcmw1r3hqkvi58r1lxpvwh0nd0hpz8arx";
        libraryHaskellDepends = [ base base-compat ghc-prim ];
        testHaskellDepends = [ base hspec QuickCheck ];
        testToolDepends = [ hspec-discover ];
···
        license = lib.licenses.mit;
      }) {};
 
+  "base-orphans_0_9_3" = callPackage
+    ({ mkDerivation, base, ghc-prim, hspec, hspec-discover, QuickCheck
+     }:
+     mkDerivation {
+       pname = "base-orphans";
+       version = "0.9.3";
+       sha256 = "1n5bpwzgw8xg00p23prajw0bj08kxh2ri3821ib1943ir1wm18qp";
+       libraryHaskellDepends = [ base ghc-prim ];
+       testHaskellDepends = [ base hspec QuickCheck ];
+       testToolDepends = [ hspec-discover ];
+       description = "Backwards-compatible orphan instances for base";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "base-prelude" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
        pname = "base62";
        version = "0.1.1.2";
        sha256 = "0kwz0asfc6lg96g14d58a64rvp2194z67y53nbb6y10hrbwq1j7j";
+       revision = "1";
+       editedCabalFile = "0lxkyd5a1diy2v3f910rw27wibziyy559275p4ra7kby9zky1m11";
        libraryHaskellDepends = [
          base bytebuild byteslice bytestring natural-arithmetic primitive
          text text-short wide-word
···
        pname = "base64-bytestring-type";
        version = "1.0.1";
        sha256 = "03kq4rjj6by02rf3hg815jfdqpdk0xygm5f46r2pn8mb99yd01zn";
-       revision = "20";
-       editedCabalFile = "0zp0c7n6gnxg37azc63xxrqchdzk2srf0zykccvndr3xlw1v83kc";
+       revision = "21";
+       editedCabalFile = "1y3j1lkqlqw8l4p0g8s3iac0gd84nz3pqccrzfj7n23fp19zr1q3";
        libraryHaskellDepends = [
          aeson base base-compat base64-bytestring binary bytestring cereal
          deepseq hashable http-api-data QuickCheck serialise text
···
        pname = "beam-core";
        version = "0.10.3.0";
        sha256 = "1q3f95xjyinr6g9yxq1w32agp9n6q152b6mfpmabpv0l74c9mmhm";
+       revision = "1";
+       editedCabalFile = "1spy3lxqbsmykmkqgzj79hhz455q9ilwpbwxyxlwxiklk0izvfg7";
        libraryHaskellDepends = [
          aeson base bytestring containers dlist free ghc-prim hashable
          microlens mtl network-uri scientific tagged text time vector
···
        license = lib.licenses.mit;
      }) {};
 
+  "beam-core_0_10_3_1" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, dlist, free
+     , ghc-prim, hashable, microlens, mtl, network-uri, scientific
+     , tagged, tasty, tasty-hunit, text, time, vector, vector-sized
+     }:
+     mkDerivation {
+       pname = "beam-core";
+       version = "0.10.3.1";
+       sha256 = "0n3fyjhcljd44ri7z3kb1sd3izv047v82m9n7597r7sbipv8cysc";
+       libraryHaskellDepends = [
+         aeson base bytestring containers dlist free ghc-prim hashable
+         microlens mtl network-uri scientific tagged text time vector
+         vector-sized
+       ];
+       testHaskellDepends = [
+         base bytestring microlens tasty tasty-hunit text time
+       ];
+       description = "Type-safe, feature-complete SQL query and manipulation interface for Haskell";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "beam-migrate" = callPackage
     ({ mkDerivation, aeson, base, beam-core, bytestring, containers
      , deepseq, dependent-map, dependent-sum, free, ghc-prim, hashable
···
        pname = "beam-migrate";
        version = "0.5.3.1";
        sha256 = "0qx1nh5vvncgr4ixnraaahwp879v8wgn2lhixgzndk6zrs3y4a21";
+       revision = "1";
+       editedCabalFile = "0sm683b4k7km2378gqkvii1lb7bx79pscll72jnwfzh72dxqc2fh";
        libraryHaskellDepends = [
          aeson base beam-core bytestring containers deepseq dependent-map
          dependent-sum free ghc-prim hashable haskell-src-exts microlens mtl
···
        pname = "beam-postgres";
        version = "0.5.4.1";
        sha256 = "0rxf275y89xh8if2w2my75fgy34vzc85lv4viyirgd0y26n9d0kc";
+       revision = "1";
+       editedCabalFile = "0khizazf6ckfg641c0163hzy7wkvv2y9b8ma98m2wi0sng9j981i";
        libraryHaskellDepends = [
          aeson attoparsec base beam-core beam-migrate bytestring
          case-insensitive conduit free hashable haskell-src-exts lifted-base
···
        pname = "beam-sqlite";
        version = "0.5.3.0";
        sha256 = "050nqjx6916j9c499i5zskankpg3bbh9f4m8lrnmf0mj4hsl96m4";
-       revision = "1";
-       editedCabalFile = "17n59xf66hmsiwlv3f4ybwa8wnkgawl2m93pylmaw6hg939d5518";
+       revision = "2";
+       editedCabalFile = "0ls88df3ls7xlc9w6kd7vfaichpbs2rmigd372j5sh7iqa6n0p9a";
        libraryHaskellDepends = [
          aeson attoparsec base beam-core beam-migrate bytestring dlist free
          hashable monad-control mtl network-uri scientific sqlite-simple
···
      }:
      mkDerivation {
        pname = "bearriver";
-       version = "0.14.11";
-       sha256 = "13f9x9kavnkbg29mrp2zddvx5vqdyp6ias5a822hmlzqfzp5c1hy";
+       version = "0.14.12";
+       sha256 = "1md63c0v8mn0ljcwfsx1bbsrq8a06hh5zz6n730x97db8gpf73vk";
        libraryHaskellDepends = [
          base deepseq dunai mtl random simple-affine-space transformers
        ];
···
        pname = "bench";
        version = "1.0.13";
        sha256 = "0v2sfblzwjb0y8dnjpl9jxsiz14lqdnpa1vccbnm2y73b5pkj30p";
+       revision = "1";
+       editedCabalFile = "1nhnsbyy597nd2hv22hhbhblihvshymsqarlsv00x0q7ws9yblfn";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        mainProgram = "example";
      }) {};
 
-  "benchpress_0_2_2_24" = callPackage
+  "benchpress_0_2_2_25" = callPackage
     ({ mkDerivation, base, bytestring, mtl, time }:
      mkDerivation {
        pname = "benchpress";
-       version = "0.2.2.24";
-       sha256 = "0ymx8b5v44nd6vskdpa6g1397l76s9qx6hxpklw9ilsg6hcilgsa";
+       version = "0.2.2.25";
+       sha256 = "10h5jgj87z4aca0k39qg5frvd3syffj4g1f3sd2yl6yc9s33yr3b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base mtl time ];
···
      }:
      mkDerivation {
        pname = "bencoding";
-       version = "0.4.5.5";
-       sha256 = "1mgqn8ais9pshsy8gsqrd559rgck1sm5zw0jyrl5902ns11jacx3";
+       version = "0.4.5.6";
+       sha256 = "13lnzgimahsnnsgx5gsh688iyw6r2bw97pcmyqq9r8kq0sll61m6";
        libraryHaskellDepends = [
          attoparsec base bytestring deepseq ghc-prim integer-gmp mtl pretty
          text
···
        pname = "bifunctors";
        version = "5.6.2";
        sha256 = "0yk9v71xpwnxd6xia1bdr8pxbvrx4am6bjykqp1d1vk1a0lak1hh";
+       revision = "1";
+       editedCabalFile = "1gibijw482qj7p9zys27df71kmv94bcq0afrsnvld86nf7njdngz";
        libraryHaskellDepends = [
          assoc base comonad containers tagged template-haskell
          th-abstraction transformers
···
        pname = "bittrex";
        version = "0.6.0.0";
        sha256 = "02h8r753dkkkgpzxhycdmjpccdqfsc5gnmw6qi9kpl1165jrd2fd";
+       revision = "1";
+       editedCabalFile = "1s5xvlsdcw7ihdb1falf5dyw156x30ccahi6hy26xr5wsyp612w3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "bitvec";
        version = "1.1.5.0";
        sha256 = "1ifyz0lsmgqz8yjyx4887m1wnm7ar389k6gkvcnk9mg1bgp7rll3";
-       revision = "1";
-       editedCabalFile = "14dkxk8hnj9d2d52sgfwv303mdnw3b4xirac1y9qm7hsnxvgsgnb";
+       revision = "2";
+       editedCabalFile = "16cbbvvjqr4pyiz7j8dpaas2ln7l7y6lczd0lszyx3cgnvv30in0";
        libraryHaskellDepends = [
          base bytestring deepseq ghc-bignum primitive vector
        ];
···
        pname = "blaze-svg";
        version = "0.3.7";
        sha256 = "0pqnx1zrvm2pliya76f4m8d6aycncfp08c2n1fiyzvl1fgk62z2c";
-       revision = "2";
-       editedCabalFile = "0d8wylydvflhd1yyd91a8ss8khxr5j83f7j7h6qn36zagnyci1f5";
+       revision = "3";
+       editedCabalFile = "161xnqgy1pchcgg8rrc6b3chr07x8br1shd4sbi2kjl2ms0z858y";
        libraryHaskellDepends = [ base blaze-markup mtl ];
        description = "SVG combinator library";
        license = lib.licenses.bsd3;
···
     ({ mkDerivation, bluefin-internal }:
      mkDerivation {
        pname = "bluefin";
-       version = "0.0.10.0";
-       sha256 = "06s6nd2b1f7cxk84rnqqaw95wy3ib4an2k8na7hk8ibi68a44mfp";
+       version = "0.0.12.1";
+       sha256 = "05aiz02glc6iwfjy8a69zisqq8zg3i5bzmkp0vlyr00k4crd1l0j";
        libraryHaskellDepends = [ bluefin-internal ];
        description = "The Bluefin effect system";
        license = lib.licenses.mit;
        maintainers = [ lib.maintainers.maralorn ];
      }) {};
 
+  "bluefin_0_0_14_0" = callPackage
+    ({ mkDerivation, bluefin-internal }:
+     mkDerivation {
+       pname = "bluefin";
+       version = "0.0.14.0";
+       sha256 = "14nfg1xrc1c0avlmgmfap9jpj6r6n4rvs4l2bgsjn8hgd4hbqlf4";
+       libraryHaskellDepends = [ bluefin-internal ];
+       description = "The Bluefin effect system";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = [ lib.maintainers.maralorn ];
+     }) {};
+
   "bluefin-algae" = callPackage
     ({ mkDerivation, base, bluefin, bluefin-internal, tasty
      , tasty-bench, tasty-hunit
···
      }:
      mkDerivation {
        pname = "bluefin-internal";
-       version = "0.0.10.0";
-       sha256 = "1rhlsn8189cfwhlzmwbrzlk1bcd3a797nv8jwxxb8qd9x34g87zh";
+       version = "0.0.13.0";
+       sha256 = "0plx77x4xdqy51485kkrpy0inshv9dx1c4h4iry3i4gqyywbdxr8";
        libraryHaskellDepends = [
          async base monad-control transformers transformers-base
          unliftio-core
···
        license = lib.licenses.mit;
      }) {};
 
+  "bluefin-internal_0_0_14_0" = callPackage
+    ({ mkDerivation, async, base, monad-control, transformers
+     , transformers-base, unliftio-core
+     }:
+     mkDerivation {
+       pname = "bluefin-internal";
+       version = "0.0.14.0";
+       sha256 = "10rs1fv5hv60lrbh0zbcbapcafdqrglzjc86vb8f73kwhq6b8w71";
+       revision = "1";
+       editedCabalFile = "1dr1ls83ana7cvj75y62gsjazaq6c2mya4paawknxbx6aniqgnnh";
+       libraryHaskellDepends = [
+         async base monad-control transformers transformers-base
+         unliftio-core
+       ];
+       testHaskellDepends = [ base ];
+       description = "The Bluefin effect system, internals";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "bluemix-sdk" = callPackage
     ({ mkDerivation, aeson, base, bytestring, http-client, http-types
      , text, vector
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "brick_2_5" = callPackage
+  "brick_2_6" = callPackage
     ({ mkDerivation, base, bimap, bytestring, config-ini, containers
      , data-clist, deepseq, directory, exceptions, filepath, microlens
      , microlens-mtl, microlens-th, mtl, QuickCheck, stm
···
      }:
      mkDerivation {
        pname = "brick";
-       version = "2.5";
-       sha256 = "03m539ksp607gsz9pha4dmpm064x6l5da4gphmcch8if18q7bji8";
+       version = "2.6";
+       sha256 = "19630fcg72y1vynrgssyn78xcrhmzyh4qaapynj3bkgmqm7d6qfk";
+       revision = "1";
+       editedCabalFile = "1nvswfwb4bj76vx20nq04nywqq38jaq9296wzi6hqa0rzsajva4s";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
     ({ mkDerivation, base, brick, containers, microlens, vector }:
      mkDerivation {
        pname = "brick-list-skip";
-       version = "0.1.1.15";
-       sha256 = "1x3wbvswxcz3agd2dlp4cmi247lsdl7ppllj2szpr474yr3gjshc";
+       version = "0.1.1.16";
+       sha256 = "0mhvys0sa3z1a7cchaa7dg2jv2dskyw33484ahgivgrxn6014bcg";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base brick containers microlens vector ];
···
      }:
      mkDerivation {
        pname = "brick-tabular-list";
-       version = "2.2.0.13";
-       sha256 = "0a583s7bln9hk37m9fhr4z7hhqyp8sdy4qn9yxbb227psjdx01jf";
+       version = "2.2.0.15";
+       sha256 = "192496bbxbs8fd95r373b13hyyvd66rspl658d0alckwahn23n6s";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        hydraPlatforms = lib.platforms.none;
        mainProgram = "brillig";
        broken = true;
+     }) {};
+
+  "brillo" = callPackage
+    ({ mkDerivation, base, bmp, brillo-rendering, bytestring
+     , containers, ghc-prim, GLFW-b, OpenGL
+     }:
+     mkDerivation {
+       pname = "brillo";
+       version = "1.13.3";
+       sha256 = "16xb0ii3mhlz4ppl2ifmskq70i6bkwk2my28gp7xfxq1dviqzmh8";
+       libraryHaskellDepends = [
+         base bmp brillo-rendering bytestring containers ghc-prim GLFW-b
+         OpenGL
+       ];
+       description = "Painless 2D vector graphics, animations, and simulations powered by GLFW";
+       license = lib.licenses.mit;
+     }) {};
+
+  "brillo-algorithms" = callPackage
+    ({ mkDerivation, base, brillo, containers, ghc-prim }:
+     mkDerivation {
+       pname = "brillo-algorithms";
+       version = "1.13.3";
+       sha256 = "0mbvi03f24vvp9zbipib869v68syfx8lpwzsx0q2ljx3axrxwi8d";
+       libraryHaskellDepends = [ base brillo containers ghc-prim ];
+       description = "Data structures and algorithms for working with 2D graphics";
+       license = lib.licenses.mit;
+     }) {};
+
+  "brillo-examples" = callPackage
+    ({ mkDerivation, base, bmp, brillo, brillo-algorithms
+     , brillo-rendering, bytestring, containers, ghc-prim, GLFW-b
+     , random, vector
+     }:
+     mkDerivation {
+       pname = "brillo-examples";
+       version = "1.13.3";
+       sha256 = "0ygg78kkxksaj0qh46rxza4hwrr97985hhcjkqh2gin7bpgy89mj";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         base bmp brillo brillo-algorithms brillo-rendering bytestring
+         containers ghc-prim GLFW-b random vector
+       ];
+       description = "Examples using the Brillo library";
+       license = lib.licenses.mit;
+     }) {};
+
+  "brillo-juicy" = callPackage
+    ({ mkDerivation, base, bmp, brillo, bytestring, JuicyPixels, vector
+     }:
+     mkDerivation {
+       pname = "brillo-juicy";
+       version = "0.2.4";
+       sha256 = "1aqvxrxfyfjvhzgjxqivfjsyg06lgsz2irk1j52q14rmydd8h2di";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bmp brillo bytestring JuicyPixels vector
+       ];
+       executableHaskellDepends = [
+         base bmp brillo bytestring JuicyPixels vector
+       ];
+       description = "Load any image supported by Juicy.Pixels in your brillo application";
+       license = lib.licenses.bsd3;
+       mainProgram = "brillo-juicy-viewer";
+     }) {};
+
+  "brillo-rendering" = callPackage
+    ({ mkDerivation, base, bmp, bytestring, containers, OpenGL, vector
+     }:
+     mkDerivation {
+       pname = "brillo-rendering";
+       version = "1.13.3";
+       sha256 = "0apczzdk7fwkjjkm32rv7i39pjl8jnax9bbgjd8p1095dnqhawiy";
+       libraryHaskellDepends = [
+         base bmp bytestring containers OpenGL vector
+       ];
+       description = "Brillo picture data types and rendering functions";
+       license = lib.licenses.mit;
      }) {};
 
   "brittany" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
+  "bugsnag_1_1_0_1" = 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.1.0.1";
+       sha256 = "1n2lq9iyz5m0s1mx22cwaci18f9i37g6xgdq3nbbyysmylrw09w2";
+       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, aeson, aeson-qq, base, bytestring
      , case-insensitive, containers, doctest, Glob, hspec, http-client
···
        pname = "bugzilla-redhat";
        version = "1.0.1.1";
        sha256 = "0ka3dh5gqimwny7s3qalkynlyarkmnwd5pcy92b4g4vaqk7k3pvr";
+       revision = "3";
+       editedCabalFile = "1a50ffp5dahwc82ps78j7mpvi3xbd1by3xpkybxz8bz7i3fsazfg";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "bytebuild_0_3_16_3" = callPackage
+    ({ mkDerivation, base, byteslice, bytestring, gauge
+     , haskell-src-meta, integer-logarithms, natural-arithmetic
+     , primitive, primitive-offset, QuickCheck, quickcheck-instances
+     , run-st, tasty, tasty-hunit, tasty-quickcheck, template-haskell
+     , text, text-short, wide-word, zigzag
+     }:
+     mkDerivation {
+       pname = "bytebuild";
+       version = "0.3.16.3";
+       sha256 = "0l88c5c1i704g87zvnpazfmcppg90b5q5cd6q5k75yx4x9vdcc88";
+       libraryHaskellDepends = [
+         base byteslice bytestring haskell-src-meta integer-logarithms
+         natural-arithmetic primitive primitive-offset run-st
+         template-haskell text text-short wide-word zigzag
+       ];
+       testHaskellDepends = [
+         base byteslice bytestring natural-arithmetic primitive QuickCheck
+         quickcheck-instances tasty tasty-hunit tasty-quickcheck text
+         text-short wide-word
+       ];
+       benchmarkHaskellDepends = [
+         base byteslice gauge natural-arithmetic primitive text-short
+       ];
+       description = "Build byte arrays";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "bytedump" = callPackage
     ({ mkDerivation, base, bytestring }:
      mkDerivation {
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "bytes_0_17_4" = callPackage
+    ({ mkDerivation, base, binary, binary-orphans, bytestring, cereal
+     , containers, hashable, scientific, text, time, transformers
+     , transformers-compat, unordered-containers, void
+     }:
+     mkDerivation {
+       pname = "bytes";
+       version = "0.17.4";
+       sha256 = "14x3wnjg7ik1kh3vy9ahfal0hl86v8z3kj1h152364mf94j9macc";
+       revision = "1";
+       editedCabalFile = "0jhzp9ihka03fsgnjhhj3864p3zq500xqm2whjyvin3580wigc97";
+       libraryHaskellDepends = [
+         base binary binary-orphans bytestring cereal containers hashable
+         scientific text time transformers transformers-compat
+         unordered-containers void
+       ];
+       description = "Sharing code for serialization between binary and cereal";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "bytes-metrics" = callPackage
     ({ mkDerivation, base, byteslice, contiguous, gauge, primitive
      , quickcheck-classes-base, random, tasty, tasty-hunit
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "byteslice_0_2_14_0" = callPackage
+    ({ mkDerivation, base, bytestring, gauge, natural-arithmetic
+     , primitive, primitive-addr, primitive-unlifted, quickcheck-classes
+     , run-st, tasty, tasty-hunit, tasty-quickcheck, text, text-short
+     , transformers, tuples, vector
+     }:
+     mkDerivation {
+       pname = "byteslice";
+       version = "0.2.14.0";
+       sha256 = "0s9cnb7p1wr5vh3j95a952222xf2xzli451las5il3n04n4rxq1n";
+       libraryHaskellDepends = [
+         base bytestring natural-arithmetic primitive primitive-addr
+         primitive-unlifted run-st text text-short tuples vector
+       ];
+       testHaskellDepends = [
+         base bytestring primitive quickcheck-classes tasty tasty-hunit
+         tasty-quickcheck text transformers
+       ];
+       benchmarkHaskellDepends = [ base gauge ];
+       description = "Slicing managed and unmanaged memory";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "bytesmith" = callPackage
     ({ mkDerivation, base, byte-order, byteslice, bytestring
      , contiguous, gauge, natural-arithmetic, primitive, tasty
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "bytestring_0_12_1_0" = callPackage
+  "bytestring_0_12_2_0" = callPackage
     ({ mkDerivation, base, deepseq, ghc-prim, QuickCheck, random, syb
      , tasty, tasty-bench, tasty-quickcheck, template-haskell
      , transformers
      }:
      mkDerivation {
        pname = "bytestring";
-       version = "0.12.1.0";
-       sha256 = "136c0v2brc4a1fpbqplpqxj4kzd5r78lgm5qvdnwv9blxykbihzb";
-       revision = "1";
-       editedCabalFile = "1f846kw3jal10x6r3xnzd97mwzjzr6g510r907j46w8ijwf9xrwq";
+       version = "0.12.2.0";
+       sha256 = "18zvh1fpj8x4w35hrcp1l8cd9x7v401s17wn5l5vlbgwhdrimnif";
        libraryHaskellDepends = [ base deepseq ghc-prim template-haskell ];
        testHaskellDepends = [
-         base deepseq ghc-prim QuickCheck syb tasty tasty-quickcheck
-         template-haskell transformers
+         base deepseq QuickCheck syb tasty tasty-quickcheck template-haskell
+         transformers
        ];
        benchmarkHaskellDepends = [ base deepseq random tasty-bench ];
        description = "Fast, compact, strict and lazy byte strings with a list interface";
···
        license = lib.licenses.bsd3;
      }) {inherit (pkgs) bzip2;};
 
+  "bzlib-conduit_0_3_0_4" = callPackage
+    ({ mkDerivation, base, bindings-DSL, bytestring, bzip2, conduit
+     , data-default-class, hspec, mtl, random, resourcet
+     }:
+     mkDerivation {
+       pname = "bzlib-conduit";
+       version = "0.3.0.4";
+       sha256 = "0c7nhc3a93x648yf8pq5js81zr97fnfiahg2hjbn999nbwg89800";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         base bindings-DSL bytestring conduit data-default-class mtl
+         resourcet
+       ];
+       librarySystemDepends = [ bzip2 ];
+       testHaskellDepends = [
+         base bindings-DSL bytestring conduit data-default-class hspec mtl
+         random resourcet
+       ];
+       benchmarkHaskellDepends = [
+         base bindings-DSL bytestring conduit data-default-class mtl
+         resourcet
+       ];
+       description = "Streaming compression/decompression via conduits";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {inherit (pkgs) bzip2;};
+
   "bzlib-conduit-jappie" = callPackage
     ({ mkDerivation, base, bindings-DSL, bytestring, bzip2, conduit
      , data-default-class, hspec, mtl, random, resourcet
···
        pname = "c2hs";
        version = "0.28.8";
        sha256 = "0k482wv94jbpwd96a2c2lc7qz9k8072slx7l7943472nzk7k41ir";
-       revision = "2";
-       editedCabalFile = "14j3sjxvwhj32zpz0iyigc6wdn6pjm3vlgs0prq0grvk48p176f3";
+       revision = "3";
+       editedCabalFile = "1f1jxkj89bms4hsqwl47hldixfdx96l66cs8zjlf8i6j7c9qiz3s";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
      , conduit-extra, containers, cryptonite, deepseq, directory
      , exceptions, filepath, generic-lens, Glob, hedgehog
      , hedgehog-extras, hspec, hspec-discover, http-client
-     , http-client-tls, http-types, hw-hspec-hedgehog, lens, mtl
-     , network-uri, oops, optparse-applicative, process, raw-strings-qq
-     , relation, resourcet, stm, stringsearch, temporary, text, time
-     , topograph, transformers, unliftio
+     , http-client-tls, http-types, hw-hspec-hedgehog, hw-prelude, lens
+     , microlens, mtl, network-uri, oops, optparse-applicative, process
+     , raw-strings-qq, relation, resourcet, stm, stringsearch, temporary
+     , text, time, topograph, unliftio
      }:
      mkDerivation {
        pname = "cabal-cache";
-       version = "1.0.6.0";
-       sha256 = "0jjybnj06f8w3fh44q3mq28fvyd1v7yfbh0rrkxsikdxnhi74z9j";
+       version = "1.1.0.2";
+       sha256 = "09vyxp5bx4mfwjaz7vfniy4b2n79dwa02bgb4yzxigw0q8gvkfv7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson amazonka amazonka-core amazonka-s3 attoparsec base bytestring
          conduit-extra containers cryptonite deepseq directory exceptions
-         filepath generic-lens http-client http-client-tls http-types lens
-         mtl network-uri oops optparse-applicative process relation
-         resourcet stm text topograph transformers
+         filepath generic-lens http-client http-client-tls http-types
+         hw-prelude microlens mtl network-uri oops optparse-applicative
+         process relation resourcet stm text topograph
        ];
        executableHaskellDepends = [
          aeson amazonka amazonka-core base bytestring cabal-install-parsers
-         containers directory exceptions filepath generic-lens lens mtl
-         network-uri oops optparse-applicative resourcet stm stringsearch
-         temporary text unliftio
+         containers directory exceptions filepath generic-lens hw-prelude
+         lens microlens network-uri oops optparse-applicative resourcet stm
+         stringsearch temporary text unliftio
        ];
        testHaskellDepends = [
          aeson amazonka base bytestring directory exceptions filepath Glob
-         hedgehog hedgehog-extras hspec http-types hw-hspec-hedgehog lens
-         mtl network-uri oops raw-strings-qq text time
+         hedgehog hedgehog-extras hspec http-types hw-hspec-hedgehog
+         hw-prelude network-uri oops raw-strings-qq text time
        ];
        testToolDepends = [ hspec-discover ];
        description = "CI Assistant for Haskell projects";
···
      }:
      mkDerivation {
        pname = "cabal-debian";
-       version = "5.2.4";
-       sha256 = "02pwpdzq8lk9yk6d4zpw62v1yd3ccn3r88gz3l0z51mk17ifym44";
+       version = "5.2.5";
+       sha256 = "0nkrvs1a9kj2nqz9pklxzni5wbirwgqim9haqn8lglqliycrdzbx";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
     ({ mkDerivation, base, Cabal, directory, filepath }:
      mkDerivation {
        pname = "cabal-doctest";
-       version = "1.0.10";
-       sha256 = "1lwl7q85gfgh5swi9bdck7r5g5s2pc9csgpcpvf2jmv193yd1jl1";
+       version = "1.0.11";
+       sha256 = "0gwjpwv2v7c7gs2dvf7ixsxx6likmgw5yi0fy4bqc0i7nkqg4bfw";
        libraryHaskellDepends = [ base Cabal directory filepath ];
        description = "A Setup.hs helper for running doctests";
        license = lib.licenses.bsd3;
···
      , bytestring, Cabal, Cabal-described, cabal-install-solver
      , Cabal-QuickCheck, Cabal-syntax, Cabal-tests, Cabal-tree-diff
      , containers, cryptohash-sha256, directory, echo, edit-distance
-     , exceptions, filepath, hackage-security, hashable, HTTP, lukko
-     , mtl, network-uri, open-browser, parsec, pretty, pretty-show
-     , process, QuickCheck, random, regex-base, regex-posix, resolv
+     , exceptions, filepath, hackage-security, HTTP, lukko, mtl
+     , network-uri, open-browser, parsec, pretty, pretty-show, process
+     , QuickCheck, random, regex-base, regex-posix, resolv
      , safe-exceptions, semaphore-compat, stm, tagged, tar, tasty
      , tasty-expected-failure, tasty-golden, tasty-hunit
      , tasty-quickcheck, text, time, tree-diff, unix, zlib
      }:
      mkDerivation {
        pname = "cabal-install";
-       version = "3.12.1.0";
-       sha256 = "1cmifq189i4x0r0yha3dl8nrzzfh92bnd2saak7dqvvjkkysqj38";
+       version = "3.14.1.0";
+       sha256 = "18cdb2wvic41d6259na9c7ivlgzy89ci8q6d87ri0j0n4x0xkfjb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          array async base base16-bytestring binary bytestring Cabal
          cabal-install-solver Cabal-syntax containers cryptohash-sha256
          directory echo edit-distance exceptions filepath hackage-security
-         hashable HTTP lukko mtl network-uri open-browser parsec pretty
-         process random regex-base regex-posix resolv safe-exceptions
+         HTTP lukko mtl network-uri open-browser parsec pretty process
+         random regex-base regex-posix resolv safe-exceptions
          semaphore-compat stm tar text time unix zlib
        ];
        executableHaskellDepends = [ base ];
        testHaskellDepends = [
          array base bytestring Cabal Cabal-described cabal-install-solver
          Cabal-QuickCheck Cabal-syntax Cabal-tests Cabal-tree-diff
-         containers directory filepath hashable mtl network-uri pretty-show
+         containers directory filepath mtl network-uri pretty-show process
          QuickCheck random tagged tar tasty tasty-expected-failure
          tasty-golden tasty-hunit tasty-quickcheck time tree-diff zlib
        ];
···
      }:
      mkDerivation {
        pname = "cabal-install-solver";
-       version = "3.12.1.0";
-       sha256 = "0yjy49awzs79adx1xn705v3cpmqhvgpym49jaws9h0z9ag9s3nvi";
+       version = "3.14.1.0";
+       sha256 = "0gcccglkhz8kjjvqas79wn402c5im2fqqzms453hj0i28j0y4ydm";
        libraryHaskellDepends = [
          array base bytestring Cabal Cabal-syntax containers directory
          edit-distance filepath mtl network-uri pretty text transformers
        ];
        testHaskellDepends = [
-         base Cabal Cabal-syntax tasty tasty-hunit tasty-quickcheck
+         base Cabal-syntax tasty tasty-hunit tasty-quickcheck
        ];
-       description = "The command-line interface for Cabal and Hackage";
+       description = "The solver component of cabal-install";
        license = lib.licenses.bsd3;
      }) {};
 
···
        testHaskellDepends = [ base c-enum primitive template-haskell ];
        description = "Image for Cairo";
        license = lib.licenses.bsd3;
+     }) {inherit (pkgs) cairo;};
+
+  "cairo-image_0_1_0_4" = callPackage
+    ({ mkDerivation, base, c-enum, cairo, primitive, template-haskell
+     }:
+     mkDerivation {
+       pname = "cairo-image";
+       version = "0.1.0.4";
+       sha256 = "1piib7npzr9101f3bi8mn7h5prs4c9iwwdil06b8isq7p5xvvh50";
+       libraryHaskellDepends = [ base c-enum primitive template-haskell ];
+       libraryPkgconfigDepends = [ cairo ];
+       testHaskellDepends = [ base c-enum primitive template-haskell ];
+       description = "Image for Cairo";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {inherit (pkgs) cairo;};
 
   "cake" = callPackage
···
        pname = "cgi";
        version = "3001.5.0.1";
        sha256 = "044gfqfdw5xdr6mzp5i3956a5fcj15j32zwzzd6ym15nxgrvjqh3";
-       revision = "2";
-       editedCabalFile = "1vx49bxgiip1mb8lh5qcvdb9qww474x44a8x5kj087a3npad0xxw";
+       revision = "3";
+       editedCabalFile = "1l21iiqd340crhf7dbi05ldj5wrfz00gwacz45ldca0w7821wa9a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "charset_0_3_11" = callPackage
+    ({ mkDerivation, array, base, bytestring, containers
+     , unordered-containers
+     }:
+     mkDerivation {
+       pname = "charset";
+       version = "0.3.11";
+       sha256 = "1b4aq0y3cijicfxxvpr7h0y9sq8x64f4c6525as6b614d5spahwk";
+       libraryHaskellDepends = [
+         array base bytestring containers unordered-containers
+       ];
+       description = "Fast unicode character sets based on complemented PATRICIA tries";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "charsetdetect" = callPackage
     ({ mkDerivation, base, bytestring }:
      mkDerivation {
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "chart-svg_0_7_0_0" = callPackage
+  "chart-svg_0_8_0_0" = callPackage
     ({ mkDerivation, base, bytestring, Color, containers, cubicbezier
      , doctest-parallel, flatparse, formatn, harpie, markup-parse, mtl
      , numhask, numhask-space, optics-core, random, string-interpolate
···
      }:
      mkDerivation {
        pname = "chart-svg";
-       version = "0.7.0.0";
-       sha256 = "1v1dhvn4rgv191byvr5dvaxifd48hskpqvv3kzpsq40ii7hqyj4m";
+       version = "0.8.0.0";
+       sha256 = "0h2jh3zv26f8smpsxw7pc0ndn2ai64c7rfpamhmyyj8ngavlkz7l";
        libraryHaskellDepends = [
          base bytestring Color containers cubicbezier flatparse formatn
          harpie markup-parse mtl numhask numhask-space optics-core random
···
        pname = "chell";
        version = "0.5.0.2";
        sha256 = "1iy1x5pn5y08zsl5f79vfxjm0asi2vy9hrags7jj9s8fh1dh7fxv";
+       revision = "2";
+       editedCabalFile = "1il4yzg8q9m5vyynwra8fgx8rik409d07a0mmqxb3xr9ww1d5vyy";
        libraryHaskellDepends = [
          ansi-terminal base bytestring options patience random
          template-haskell text transformers
···
        pname = "chell-hunit";
        version = "0.3.0.2";
        sha256 = "1ms7dysxl4asw3inm2a91838djgbjxd66gpvlp08573s90hyns9d";
+       revision = "1";
+       editedCabalFile = "084z9nf7jydk0g6hxqgmrf73mc3d1rmqr31dmib1i57g8bdai37d";
        libraryHaskellDepends = [ base chell HUnit ];
        description = "HUnit support for Chell";
        license = lib.licenses.mit;
···
        pname = "chell-quickcheck";
        version = "0.2.5.4";
        sha256 = "046cs6f65s9nrsac6782gw4n61dpgjgz7iv7p8ag6civywj32m4i";
+       revision = "1";
+       editedCabalFile = "10g0jb9nh7zsclsj80j0awyrb73jkz30r6aa48ffr3li59182m1z";
        libraryHaskellDepends = [ base chell QuickCheck random ];
        description = "QuickCheck support for Chell";
        license = lib.licenses.mit;
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "chronos_1_1_6_2" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, bytebuild, byteslice
+     , bytesmith, bytestring, criterion, deepseq, hashable, HUnit
+     , natural-arithmetic, old-locale, primitive, QuickCheck
+     , test-framework, test-framework-hunit, test-framework-quickcheck2
+     , text, text-short, thyme, time, torsor, vector
+     }:
+     mkDerivation {
+       pname = "chronos";
+       version = "1.1.6.2";
+       sha256 = "08y8s9mwb69kisi0yhng6plvasy6jnj25i4ar8k2cq3vsf6bgx73";
+       libraryHaskellDepends = [
+         aeson attoparsec base bytebuild byteslice bytesmith bytestring
+         deepseq hashable natural-arithmetic primitive text text-short
+         torsor vector
+       ];
+       testHaskellDepends = [
+         aeson attoparsec base bytestring HUnit QuickCheck test-framework
+         test-framework-hunit test-framework-quickcheck2 text torsor
+       ];
+       benchmarkHaskellDepends = [
+         attoparsec base bytestring criterion deepseq old-locale QuickCheck
+         text text-short thyme time
+       ];
+       description = "A high-performance time library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "chronos-bench" = callPackage
     ({ mkDerivation, ansi-terminal, base, bytestring, chronos
      , containers, deepseq, optparse-applicative, process, terminal-size
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "chs-cabal_0_1_1_2" = callPackage
+  "chs-cabal_0_1_1_4" = callPackage
     ({ mkDerivation, base, Cabal, chs-deps }:
      mkDerivation {
        pname = "chs-cabal";
-       version = "0.1.1.2";
-       sha256 = "1qh234dx3d3l3nxb67alv0ggwqipp1502krq11fgq3hp0jhcm8b8";
+       version = "0.1.1.4";
+       sha256 = "1y9z3ymvsldl4kjjdzagx0p3i7s5lyrsipd29bx2nqv05ldgrkip";
        libraryHaskellDepends = [ base Cabal chs-deps ];
        description = "Cabal with c2hs dependencies";
        license = lib.licenses.bsd3;
···
        maintainers = [ lib.maintainers.sternenseemann ];
      }) {};
 
+  "citeproc_0_8_1_2" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, bytestring
+     , case-insensitive, containers, data-default, Diff, directory
+     , file-embed, filepath, mtl, pandoc-types, pretty, safe, scientific
+     , text, timeit, transformers, unicode-collation, uniplate, vector
+     , xml-conduit
+     }:
+     mkDerivation {
+       pname = "citeproc";
+       version = "0.8.1.2";
+       sha256 = "1w3pdnqmhkk3iiih9z5n70igawcv584rdyn2qikjcjcf60lcr681";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson attoparsec base bytestring case-insensitive containers
+         data-default file-embed filepath pandoc-types safe scientific text
+         transformers unicode-collation uniplate vector xml-conduit
+       ];
+       testHaskellDepends = [
+         aeson base bytestring containers Diff directory filepath mtl pretty
+         text timeit transformers
+       ];
+       description = "Generates citations and bibliography from CSL styles";
+       license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = [ lib.maintainers.sternenseemann ];
+     }) {};
+
   "citeproc-hs" = callPackage
     ({ mkDerivation, base, bytestring, containers, directory, filepath
      , hexpat, hs-bibutils, HTTP, json, mtl, network, network-uri
···
        pname = "clay";
        version = "0.15.0";
        sha256 = "1gp7x76cw15jmd3ahqf1q0bc2p6ix182x6s2pzyh8yr4b29b9r3v";
-       revision = "1";
-       editedCabalFile = "0y6s4digka4b0d238n1vcj2308csxvkr34vfnqr3mc46079vb99k";
+       revision = "2";
+       editedCabalFile = "174jkyq4yjk022msd2rq0wlp4myy9fa92w28d4nwd7jrwghw5qki";
        libraryHaskellDepends = [ base mtl text ];
        testHaskellDepends = [ base hspec hspec-discover mtl text ];
        testToolDepends = [ hspec-discover ];
···
      }:
      mkDerivation {
        pname = "climb";
-       version = "0.5.0";
-       sha256 = "0bb2pnh3wb78gym5jyzy9dsw6cvqcmlmy79gbvwyalrx237krvl8";
+       version = "0.5.1";
+       sha256 = "0sn3cn9l1ibbr1vm87phxwdlcwwgwlvannm14v5r6af3b274ibhy";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.mpl20;
      }) {};
 
+  "co-log-core_0_3_2_3" = callPackage
+    ({ mkDerivation, base, doctest, Glob }:
+     mkDerivation {
+       pname = "co-log-core";
+       version = "0.3.2.3";
+       sha256 = "0yaks45p2w3839acb4h23rf83qdip6x9qgyj34h2qr7741jn8w3d";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base doctest Glob ];
+       description = "Composable Contravariant Comonadic Logging Library";
+       license = lib.licenses.mpl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "co-log-effectful" = callPackage
+    ({ mkDerivation, base, bytestring, co-log-core, effectful
+     , effectful-core, effectful-plugin, QuickCheck, tasty
+     , tasty-discover, tasty-golden, tasty-hunit, tasty-quickcheck, text
+     }:
+     mkDerivation {
+       pname = "co-log-effectful";
+       version = "0.0.0.1";
+       sha256 = "11l0j1aa6hcimarjgvvicpa6l8fzmqlvn5d0igrg7bbbq20mk451";
+       revision = "1";
+       editedCabalFile = "19370njmzvm14kjkyyclkmwxz6kj6gh5pvwnzv1187a5rfyhhjix";
+       libraryHaskellDepends = [
+         base bytestring co-log-core effectful effectful-core
+         effectful-plugin text
+       ];
+       testHaskellDepends = [
+         base bytestring co-log-core effectful effectful-core
+         effectful-plugin QuickCheck tasty tasty-golden tasty-hunit
+         tasty-quickcheck text
+       ];
+       testToolDepends = [ tasty-discover ];
+       description = "effectful log effect using co-log-core";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "co-log-json" = callPackage
     ({ mkDerivation, aeson, base, bytestring, co-log-core, containers
      , string-conv, text
···
      }) {};
 
   "coercible-subtypes" = callPackage
-    ({ mkDerivation, base, profunctors }:
+    ({ mkDerivation, base }:
      mkDerivation {
        pname = "coercible-subtypes";
-       version = "0.3.0.1";
-       sha256 = "1mji6jlgc2lk6lczn10c2rchm10h2my3gs9p3r9yd6ij8ixki4sx";
-       revision = "1";
-       editedCabalFile = "000w9bg2r1n6r40a40i450gysq8yr59xpjrqwf6dzgzyxxfa9sxb";
-       libraryHaskellDepends = [ base profunctors ];
+       version = "1";
+       sha256 = "02xj06qdqy9i33hkp504qmgpb0qvhliyygib072s2k6z4wmwd1ar";
+       libraryHaskellDepends = [ base ];
        description = "Coercible but only in one direction";
+       license = lib.licenses.bsd3;
+     }) {};
+
+  "coercible-subtypes-profunctor" = callPackage
+    ({ mkDerivation, base, coercible-subtypes, profunctors }:
+     mkDerivation {
+       pname = "coercible-subtypes-profunctor";
+       version = "1";
+       sha256 = "0riw18jpxvfv6qyzmv3l7g4m6b65g7skcylpmwdp59p05ypfx4vb";
+       libraryHaskellDepends = [ base coercible-subtypes profunctors ];
+       description = "Combine profunctors with coercible-subtypes";
        license = lib.licenses.bsd3;
      }) {};
 
···
        pname = "colourista";
        version = "0.1.0.2";
        sha256 = "0g06116kjg9pbp0l7n33agqbks3kw5z4rjqyhylha8miah5sxbwn";
-       revision = "5";
-       editedCabalFile = "1388d2hd4kv6d99mfvif8iivb9kwai4dcnm3s9a6x91sz4zkzj2y";
+       revision = "6";
+       editedCabalFile = "1vdz4msdl6plsshf4h61wlv231yyv6hjw3h4sgnasqnsav19dd5z";
        libraryHaskellDepends = [ ansi-terminal base bytestring text ];
        testHaskellDepends = [ base bytestring hspec text ];
        description = "Convenient interface for printing colourful messages";
···
        libraryHaskellDepends = [ base ];
        description = "Efficient computation of common combinatoric functions";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "combinators" = callPackage
+    ({ mkDerivation, base, mtl }:
+     mkDerivation {
+       pname = "combinators";
+       version = "0.1";
+       sha256 = "0qn5jz5zhlcygah450pvqcrksh7bpwp46jq1f0wmcb9bk0i3s9vz";
+       libraryHaskellDepends = [ base mtl ];
+       description = "Collection of combinators over standard typeclasses";
+       license = lib.licenses.mit;
      }) {};
 
   "combobuffer" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "commonmark-extensions_0_2_5_6" = callPackage
+    ({ mkDerivation, base, commonmark, containers, emojis, filepath
+     , network-uri, parsec, tasty, tasty-bench, tasty-hunit, text
+     , transformers
+     }:
+     mkDerivation {
+       pname = "commonmark-extensions";
+       version = "0.2.5.6";
+       sha256 = "0yf3063h9kvy2psfl6ssg7ikwy2g55q61hkky3cm2jcj0z5c3j2r";
+       libraryHaskellDepends = [
+         base commonmark containers emojis filepath network-uri parsec text
+         transformers
+       ];
+       testHaskellDepends = [
+         base commonmark parsec tasty tasty-hunit text
+       ];
+       benchmarkHaskellDepends = [ base commonmark tasty-bench text ];
+       description = "Pure Haskell commonmark parser";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "commonmark-pandoc" = callPackage
     ({ mkDerivation, base, commonmark, commonmark-extensions
      , pandoc-types, text
···
        ];
        description = "Bridge between commonmark and pandoc AST";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "commonmark-pandoc_0_2_2_3" = callPackage
+    ({ mkDerivation, base, commonmark, commonmark-extensions
+     , pandoc-types, text
+     }:
+     mkDerivation {
+       pname = "commonmark-pandoc";
+       version = "0.2.2.3";
+       sha256 = "1jjsagf4gcbvzn89abwrczr8xprqnp0mn7bjw3m5lf34nbnd2dza";
+       libraryHaskellDepends = [
+         base commonmark commonmark-extensions pandoc-types text
+       ];
+       description = "Bridge between commonmark and pandoc AST";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "commonmark-simple" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "comonad_5_0_9" = callPackage
+    ({ mkDerivation, base, containers, distributive
+     , indexed-traversable, tagged, transformers, transformers-compat
+     }:
+     mkDerivation {
+       pname = "comonad";
+       version = "5.0.9";
+       sha256 = "12d7g3c2x1jb6jlmdgwdmi840z3p91b0l7fkfsdml1c0kas0xyv9";
+       libraryHaskellDepends = [
+         base containers distributive indexed-traversable tagged
+         transformers transformers-compat
+       ];
+       description = "Comonads";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "comonad-extras" = callPackage
     ({ mkDerivation, array, base, comonad, containers, distributive
      , semigroupoids, transformers
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "constrained-some" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "constrained-some";
+       version = "0.1.2";
+       sha256 = "1am445b5ip0k37ml8l041az3dykc4s78kx29r1cvlkf1s8111klz";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base ];
+       description = "Existential type that can be constrained";
+       license = lib.licenses.mit;
+     }) {};
+
   "constraint" = callPackage
     ({ mkDerivation, base, category, unconstrained }:
      mkDerivation {
···
        pname = "construct";
        version = "0.3.1.2";
        sha256 = "0z5am4j8s60mwcrzm6bjjdwm09iylxmlf5v6qahyb6bwl1nchsdp";
+       enableSeparateDataOutput = true;
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
+       libraryHaskellDepends = [
+         attoparsec base bytestring cereal incremental-parser input-parsers
+         monoid-subclasses parsers rank2classes text
+       ];
+       testHaskellDepends = [
+         attoparsec base bytestring cereal directory doctest filepath
+         incremental-parser monoid-subclasses rank2classes tasty tasty-hunit
+         text
+       ];
+       testToolDepends = [ markdown-unlit ];
+       description = "Haskell version of the Construct library for easy specification of file formats";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "construct_0_3_2" = callPackage
+    ({ mkDerivation, attoparsec, base, bytestring, Cabal, cabal-doctest
+     , cereal, directory, doctest, filepath, incremental-parser
+     , input-parsers, markdown-unlit, monoid-subclasses, parsers
+     , rank2classes, tasty, tasty-hunit, text
+     }:
+     mkDerivation {
+       pname = "construct";
+       version = "0.3.2";
+       sha256 = "19pghvfxn1cpvg01ks5ixmfcfdzcbcy01aa2gafm3cgi3i9yygmv";
        enableSeparateDataOutput = true;
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "copilot_4_0" = callPackage
+  "copilot_4_1" = callPackage
     ({ mkDerivation, base, copilot-c99, copilot-core, copilot-language
      , copilot-libraries, copilot-prettyprinter, copilot-theorem
      , directory, filepath, optparse-applicative
      }:
      mkDerivation {
        pname = "copilot";
-       version = "4.0";
-       sha256 = "1vkwrrsl2xlga5imv2w54k71bl8i1qxz53d6frwpnv64hq0g8lrz";
+       version = "4.1";
+       sha256 = "04zhqkkp66alvk6b2mhgdvdg2d9yjyyzmv7vp7caj13cyqrifflz";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "copilot-bluespec";
-       version = "4.0";
-       sha256 = "1255x4bfwsv305gw0crwm64n32znbzg3g07rly66j56p6dil9dw6";
+       version = "4.1";
+       sha256 = "0czx7jwhrg024wfk6g1mcjgm8ydc5xx8msgklzhs97gwlhhi74sb";
        libraryHaskellDepends = [
          base copilot-core directory filepath language-bluespec pretty
        ];
···
        broken = true;
      }) {};
 
-  "copilot-c99_4_0" = callPackage
+  "copilot-c99_4_1" = callPackage
     ({ mkDerivation, base, copilot-core, directory, filepath, HUnit
      , language-c99, language-c99-simple, mtl, pretty, process
      , QuickCheck, random, test-framework, test-framework-hunit
···
      }:
      mkDerivation {
        pname = "copilot-c99";
-       version = "4.0";
-       sha256 = "1gnkcwqamc63fw64d5vcjxsffjhgz627p0rs4lnjn2wpqj23ms3b";
+       version = "4.1";
+       sha256 = "0lqjqji6v7bxavqlg367837n7qvdlba11y0x24pkl6djdwq4rx5p";
        libraryHaskellDepends = [
          base copilot-core directory filepath language-c99
          language-c99-simple mtl pretty
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "copilot-core_4_0" = callPackage
+  "copilot-core_4_1" = callPackage
     ({ mkDerivation, base, HUnit, QuickCheck, test-framework
      , test-framework-hunit, test-framework-quickcheck2
      }:
      mkDerivation {
        pname = "copilot-core";
-       version = "4.0";
-       sha256 = "0gwl08ib42if8lrwkhd81vpx46yqbl2k1qwwf3ar90b6pnhczyhk";
+       version = "4.1";
+       sha256 = "0w1bpf2sqmwjsk5pbf5wglmmgi26xa9ns497cs0dqz4v278v98yj";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [
          base HUnit QuickCheck test-framework test-framework-hunit
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "copilot-interpreter_4_0" = callPackage
+  "copilot-interpreter_4_1" = callPackage
     ({ mkDerivation, base, copilot-core, copilot-prettyprinter, pretty
      , QuickCheck, test-framework, test-framework-quickcheck2
      }:
      mkDerivation {
        pname = "copilot-interpreter";
-       version = "4.0";
-       sha256 = "16ylwz3zplzrgz1z0894022ikmh9zywqsjhczayl65gi4aphi925";
+       version = "4.1";
+       sha256 = "016qvssn4hp3nllv9xxsx2d6z4z5m4kq8js5k10dcnhxbkr2bngz";
        libraryHaskellDepends = [ base copilot-core pretty ];
        testHaskellDepends = [
          base copilot-core copilot-prettyprinter pretty QuickCheck
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "copilot-language_4_0" = callPackage
+  "copilot-language_4_1" = callPackage
     ({ mkDerivation, array, base, containers, copilot-core
      , copilot-interpreter, copilot-theorem, data-reify, HUnit, mtl
      , pretty, QuickCheck, test-framework, test-framework-hunit
···
      }:
      mkDerivation {
        pname = "copilot-language";
-       version = "4.0";
-       sha256 = "1mkf3p5arwdjxwyjflisdmc1xdz0x5p6iarh544ngpwks72j6j7d";
+       version = "4.1";
+       sha256 = "04qa8i4gyvvv3la5qhdqbam0g8kxny6miv4z65g6crwdp9x7bdyv";
        libraryHaskellDepends = [
          array base containers copilot-core copilot-interpreter
          copilot-theorem data-reify mtl
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "copilot-libraries_4_0" = callPackage
+  "copilot-libraries_4_1" = callPackage
     ({ mkDerivation, base, containers, copilot-interpreter
      , copilot-language, copilot-theorem, mtl, parsec, QuickCheck
      , test-framework, test-framework-quickcheck2
      }:
      mkDerivation {
        pname = "copilot-libraries";
-       version = "4.0";
-       sha256 = "0zgw4pg0kdq5c4xqpf51wpkxj1sxhyif71j103kdc4ca1wwqhjbr";
+       version = "4.1";
+       sha256 = "04vgskgq20q62ybd1lm19bqgqabhfbb6v5vqj92gv9dk4861lahd";
        libraryHaskellDepends = [
          base containers copilot-language mtl parsec
        ];
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "copilot-prettyprinter_4_0" = callPackage
+  "copilot-prettyprinter_4_1" = callPackage
     ({ mkDerivation, base, copilot-core, pretty }:
      mkDerivation {
        pname = "copilot-prettyprinter";
-       version = "4.0";
-       sha256 = "17vw8h6c0x1x7giwkzqrg2sndw9qp7ninh6lcydzlcn77ma9i0z2";
+       version = "4.1";
+       sha256 = "0hd3dghc62wi1rj0ilwdgjw60kvbrqhcwdc502r0xny9ha9b6ws5";
        libraryHaskellDepends = [ base copilot-core pretty ];
        description = "A prettyprinter of Copilot Specifications";
        license = lib.licenses.bsd3;
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "copilot-theorem_4_0" = callPackage
+  "copilot-theorem_4_1" = callPackage
     ({ mkDerivation, base, bimap, bv-sized, containers, copilot-core
      , copilot-prettyprinter, data-default, directory, libBF, mtl, panic
      , parameterized-utils, parsec, pretty, process, QuickCheck, random
···
      }:
      mkDerivation {
        pname = "copilot-theorem";
-       version = "4.0";
-       sha256 = "149irgw76s2cfv8491ys8i1gmad23z2c5vjiklgmz0h25b49aix3";
+       version = "4.1";
+       sha256 = "0jki4295p9z3a2n81pvzi1bs7i75ya9jf324cw4wiqk9r1zajdb2";
        libraryHaskellDepends = [
          base bimap bv-sized containers copilot-core copilot-prettyprinter
          data-default directory libBF mtl panic parameterized-utils parsec
···
      }:
      mkDerivation {
        pname = "copilot-verifier";
-       version = "4.0";
-       sha256 = "00ahja1qdvnmr7ddl13b1m9l21k8qqmkr44ml2vpwb7i7l4h65z1";
+       version = "4.1";
+       sha256 = "0whwi2lhjvla6v9lc37wccxkq9kpsaidfkhp6ccvkf2akc9248vl";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "country_0_2_5_0" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, bytebuild, bytehash
+     , byteslice, bytestring, compact, contiguous, criterion, deepseq
+     , hashable, primitive, primitive-unlifted, QuickCheck
+     , quickcheck-classes, scientific, tasty, tasty-quickcheck, text
+     , text-short, unordered-containers
+     }:
+     mkDerivation {
+       pname = "country";
+       version = "0.2.5.0";
+       sha256 = "195jvf322pg06jmcnibx5dz2hvzrq53893hy6cvh9qhh47axd884";
+       libraryHaskellDepends = [
+         aeson attoparsec base bytebuild bytehash byteslice bytestring
+         contiguous deepseq hashable primitive primitive-unlifted scientific
+         text text-short unordered-containers
+       ];
+       testHaskellDepends = [
+         base byteslice primitive QuickCheck quickcheck-classes tasty
+         tasty-quickcheck text text-short
+       ];
+       benchmarkHaskellDepends = [ base bytehash compact criterion text ];
+       description = "Country data type and functions";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "country-codes" = callPackage
     ({ mkDerivation, aeson, base, deepseq, HTF, HUnit, shakespeare
      , text
···
        mainProgram = "crackNum";
      }) {};
 
-  "crackNum_3_14" = callPackage
+  "crackNum_3_15" = callPackage
     ({ mkDerivation, base, deepseq, directory, filepath, ghc, libBF
      , process, sbv, tasty, tasty-golden
      }:
      mkDerivation {
        pname = "crackNum";
-       version = "3.14";
-       sha256 = "03k2inklgilnqf57h7py3h9mr0zg8wb7fagv8lb0pjxzw02c4qms";
+       version = "3.15";
+       sha256 = "0sljmdmyr8gxm3mkz16w5bnyqbjgcj11fgqyp5grxv2wc11p7kdz";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }) {};
 
   "cron" = callPackage
-    ({ mkDerivation, attoparsec, base, criterion, data-default-class
+    ({ mkDerivation, attoparsec, base, criterion, data-default
      , hedgehog, mtl, mtl-compat, old-locale, semigroups, tasty
      , tasty-hedgehog, tasty-hunit, text, time, transformers-compat
      }:
      mkDerivation {
        pname = "cron";
-       version = "0.7.1";
-       sha256 = "1q0ahnb6cxlqdq3g5i082k0aaf23f88ik1mz8066i015r406x07i";
+       version = "0.7.2";
+       sha256 = "11rk767k34ym2is7sxm6zgl19shb0jw3hyw53ihmjkbvh63d7s93";
        libraryHaskellDepends = [
-         attoparsec base data-default-class mtl mtl-compat old-locale
-         semigroups text time
+         attoparsec base data-default mtl mtl-compat old-locale semigroups
+         text time
        ];
        testHaskellDepends = [
          attoparsec base hedgehog semigroups tasty tasty-hedgehog
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "crypton-connection_0_4_2" = callPackage
+  "crypton-connection_0_4_3" = callPackage
     ({ mkDerivation, base, basement, bytestring, containers
      , crypton-x509, crypton-x509-store, crypton-x509-system
      , crypton-x509-validation, data-default, network, socks, tls
      }:
      mkDerivation {
        pname = "crypton-connection";
-       version = "0.4.2";
-       sha256 = "1d57xnx6lc6p25lb964mv47lss8d29fd4g7rvrakndbs3h3jvh76";
+       version = "0.4.3";
+       sha256 = "1q9az1bd6gykm897vmasbx1v9dfnwz4fgypya12yssjy7772b269";
        libraryHaskellDepends = [
          base basement bytestring containers crypton-x509 crypton-x509-store
          crypton-x509-system crypton-x509-validation data-default network
···
   "crypton-x509-validation" = callPackage
     ({ mkDerivation, asn1-encoding, asn1-types, base, bytestring
      , containers, crypton, crypton-x509, crypton-x509-store
-     , data-default-class, hourglass, memory, mtl, pem, tasty
-     , tasty-hunit
-     }:
-     mkDerivation {
-       pname = "crypton-x509-validation";
-       version = "1.6.12";
-       sha256 = "1xjhwvmkcy47a6xiqxb3xy944ca7g660203jdrz5xzd46zibfq0f";
-       libraryHaskellDepends = [
-         asn1-encoding asn1-types base bytestring containers crypton
-         crypton-x509 crypton-x509-store data-default-class hourglass memory
-         mtl pem
-       ];
-       testHaskellDepends = [
-         asn1-encoding asn1-types base bytestring crypton crypton-x509
-         crypton-x509-store data-default-class hourglass memory tasty
-         tasty-hunit
-       ];
-       description = "X.509 Certificate and CRL validation";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "crypton-x509-validation_1_6_13" = callPackage
-    ({ mkDerivation, asn1-encoding, asn1-types, base, bytestring
-     , containers, crypton, crypton-x509, crypton-x509-store
      , data-default, hourglass, memory, mtl, pem, tasty, tasty-hunit
      }:
      mkDerivation {
···
        ];
        description = "X.509 Certificate and CRL validation";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "cryptonite" = callPackage
···
      }:
      mkDerivation {
        pname = "curryer-rpc";
-       version = "0.3.7";
-       sha256 = "1g8afbpayw6hcbgrfzqpipp3r0657mcimlmpizdxdk5xbl2j2r03";
+       version = "0.3.8";
+       sha256 = "1nr3x4qym270i1ddk69964b8c11k303ayhqspykrxkpsqf83hi0z";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
 
   "dahdit" = callPackage
     ({ mkDerivation, base, bytestring, containers, data-default
-     , data-sword, falsify, free, ghc-typelits-knownnat, mtl, primitive
-     , tasty, tasty-hunit, text, transformers, vector
+     , data-sword, free, ghc-typelits-knownnat, mtl, primitive
+     , prop-unit, text, transformers, vector
      }:
      mkDerivation {
        pname = "dahdit";
-       version = "0.5.1";
-       sha256 = "03fc6h3g6w6ymlq3g54ihkwca6jzc6xlhphxadi5xi8di0xsrbla";
+       version = "0.7.0";
+       sha256 = "11g5c6csgrw6jq3ijv07yq2kj4f3ylkh450gv8qs9lqlg5haiis3";
        libraryHaskellDepends = [
          base bytestring containers data-default data-sword free
          ghc-typelits-knownnat mtl primitive text transformers vector
        ];
        testHaskellDepends = [
-         base bytestring containers data-default data-sword falsify free
-         ghc-typelits-knownnat mtl primitive tasty tasty-hunit text
-         transformers vector
+         base bytestring containers data-default data-sword free
+         ghc-typelits-knownnat mtl primitive prop-unit text transformers
+         vector
        ];
        description = "Binary parsing and serialization with integrated size";
        license = lib.licenses.bsd3;
···
 
   "dahdit-midi" = callPackage
     ({ mkDerivation, base, bytestring, containers, dahdit, dahdit-test
-     , data-sword, daytripper, directory, falsify, filepath, hashable
-     , nanotime, newtype, primitive, tasty, text, vector
+     , data-sword, daytripper, directory, filepath, hashable, nanotime
+     , newtype, primitive, prop-unit, text, vector
      }:
      mkDerivation {
        pname = "dahdit-midi";
-       version = "0.5.5";
-       sha256 = "082fjzfnfwydb9x638f3faggd5safwjbkaz67905xi582f01ilg9";
+       version = "0.7.0";
+       sha256 = "15id66nm3lknwgmmh57kfzjlg8ai7l3rlls5by56ii8a9c5x5hxg";
        libraryHaskellDepends = [
          base bytestring containers dahdit data-sword hashable nanotime
          newtype primitive text vector
        ];
        testHaskellDepends = [
          base bytestring containers dahdit dahdit-test data-sword daytripper
-         directory falsify filepath hashable nanotime newtype primitive
-         tasty text vector
+         directory filepath hashable nanotime newtype primitive prop-unit
+         text vector
        ];
        description = "MIDI and OSC parsing/printing with dahdit";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "dahdit-network";
-       version = "0.5.2";
-       sha256 = "0gsz67y6r02l69jakfiwd7607d6alf0bzhm9binabxqc2h9n439g";
+       version = "0.7.0";
+       sha256 = "07aj5hc8vgy3691q9x335b4ypxjl5m17b7qw19gkg0lxphddxx25";
        libraryHaskellDepends = [
          base bytestring dahdit network resourcet unliftio-core
        ];
···
 
   "dahdit-test" = callPackage
     ({ mkDerivation, base, bytestring, containers, dahdit, daytripper
-     , directory, falsify, tasty, text
+     , directory, prop-unit, text
      }:
      mkDerivation {
        pname = "dahdit-test";
-       version = "0.5.1";
-       sha256 = "105wvh7x1pcnmzfjknpfycr4r8zcddhc385y3jbgdpbhrjijh1a9";
+       version = "0.7.0";
+       sha256 = "0k7sy43d319n2371qsv803x4p51653bfdysjk5nyc6f68i2q7j12";
        libraryHaskellDepends = [
-         base bytestring containers dahdit daytripper directory falsify text
+         base bytestring containers dahdit daytripper directory prop-unit
+         text
        ];
        testHaskellDepends = [
-         base bytestring containers dahdit daytripper directory falsify
-         tasty text
+         base bytestring containers dahdit daytripper directory prop-unit
+         text
        ];
        description = "Test utils for Dahdit serde";
        license = lib.licenses.bsd3;
···
        pname = "dap";
        version = "0.1.0.0";
        sha256 = "1iq6vd2s6qz5mmcqfg8a9a4y9i9k4v6ak4n3jl5n5mdqbrli7ipz";
+       revision = "1";
+       editedCabalFile = "1aapq2sv4f5lnzblplfrgxwi6x2hy0jz0h9dxi562lbxylmjvjaz";
        libraryHaskellDepends = [
          aeson aeson-pretty base bytestring containers lifted-base
          monad-control mtl network network-simple stm text time
···
        pname = "data-array-byte";
        version = "0.1.0.1";
        sha256 = "002n0af7q08q3fmgsc5b47s1clirxy0lrqglwxzhabg0nfhfrdhv";
-       revision = "3";
-       editedCabalFile = "136rjhg0m49d2l8z7kp46hc8q7bkipvkwnn40nv8kqkpvrgrg8d4";
+       revision = "4";
+       editedCabalFile = "1yr2pa9ghmlhy28dfbch7snsmab6y8vvml7ch7pvx44gil0l0h1s";
        libraryHaskellDepends = [ base deepseq template-haskell ];
        testHaskellDepends = [
          base quickcheck-classes-base tasty tasty-quickcheck
···
     ({ mkDerivation, base, constraints }:
      mkDerivation {
        pname = "data-compat";
-       version = "0.1.0.4";
-       sha256 = "0cgm17zzfmmglnprgv91aqpm7n847qlajfz8gp7qqwjlg9xfmpy9";
+       version = "0.1.0.5";
+       sha256 = "0v8hgw9kcwgdwahm32a6qz04v8j0kdn9pd6vywhpf2g73v4kfdvj";
        libraryHaskellDepends = [ base constraints ];
        description = "Define Backwards Compatibility Schemes for Arbitrary Data";
        license = lib.licenses.mit;
···
        pname = "data-fix";
        version = "0.3.4";
        sha256 = "0dxb2s2bxdl4fcd0kfybprz9kwsskdwshdh543lvjyh4ik8m5w4d";
+       revision = "1";
+       editedCabalFile = "06r6054jfaqqf8yx21m86x5bzpnkjmqrbppyf3b7h26ad1hvwy7f";
        libraryHaskellDepends = [ base deepseq hashable ];
        description = "Fixpoint data types";
        license = lib.licenses.bsd3;
···
      }) {};
 
   "daytripper" = callPackage
-    ({ mkDerivation, base, bytestring, directory, falsify
-     , optparse-applicative, tagged, tasty, tasty-hunit
+    ({ mkDerivation, base, bytestring, directory, optparse-applicative
+     , prop-unit, tagged, tasty, tasty-hunit
      }:
      mkDerivation {
        pname = "daytripper";
-       version = "0.3.1";
-       sha256 = "1x9zjfj302fd6r378rw19a7n4jivc71bpi6c37il0w1y5951c462";
+       version = "1.0.0";
+       sha256 = "0mi03wgaa4pmrzmr0l5h34nl3wgzl14h825zlbpcjdm0zg0diw64";
        libraryHaskellDepends = [
-         base bytestring directory falsify optparse-applicative tagged tasty
-         tasty-hunit
+         base bytestring directory optparse-applicative prop-unit tagged
+         tasty tasty-hunit
        ];
        testHaskellDepends = [
-         base bytestring directory falsify optparse-applicative tagged tasty
-         tasty-hunit
+         base bytestring directory optparse-applicative prop-unit tagged
+         tasty tasty-hunit
        ];
        description = "Helpers for round-trip tests";
        license = lib.licenses.bsd3;
···
      }) {};
 
   "dbus-app-launcher" = callPackage
-    ({ mkDerivation, base, containers, dbus, extra, unix }:
+    ({ mkDerivation, base, containers, dbus, extra, regex-tdfa
+     , shellwords, unix
+     }:
      mkDerivation {
        pname = "dbus-app-launcher";
-       version = "0.1.0.0";
-       sha256 = "142l60kz6qx9k88jdg94icfq3aa8g160d4q9g8hrvpr0360gq2dv";
+       version = "0.1.1.0";
+       sha256 = "0hzaif160jp16wd5x92fsdxz74flf8pq0pp91pg5hjz47z90nyqw";
        isLibrary = false;
        isExecutable = true;
-       executableHaskellDepends = [ base containers dbus extra unix ];
+       executableHaskellDepends = [
+         base containers dbus extra regex-tdfa shellwords unix
+       ];
        description = "Simple app launcher for D-Bus";
        license = lib.licenses.mit;
        mainProgram = "dbus-app-launcher";
···
      }:
      mkDerivation {
        pname = "debruijn";
-       version = "0.1";
-       sha256 = "1bpy918flzmhwiwmz5ivjgqn2i3hidzcgc31w8d2br88p0clixv4";
+       version = "0.2";
+       sha256 = "1j2bwlmjl65zydjhgv5v2cgvaw8p9vvsg3qd3vpbd8c0r07v5np2";
        libraryHaskellDepends = [
          base deepseq fin skew-list some transformers
        ];
        description = "de Bruijn indices and levels";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "debruijn-safe" = callPackage
     ({ mkDerivation, base, deepseq, fin, some }:
      mkDerivation {
        pname = "debruijn-safe";
-       version = "0.1";
-       sha256 = "17db3640y31isalrw4hpf9z7wyjysb7gyig8d2mg1b6ycr9dy223";
+       version = "0.2";
+       sha256 = "0jxczhcsppcmfyzgzg1d3r5zw60kb3zi0jcb1rrrb4grcc495f3b";
        libraryHaskellDepends = [ base deepseq fin some ];
        description = "de Bruijn indices and levels";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "debug" = callPackage
···
        broken = true;
      }) {};
 
+  "debuggable" = callPackage
+    ({ mkDerivation, async, base, containers, exceptions, hashable
+     , optparse-applicative, temporary, unordered-containers
+     }:
+     mkDerivation {
+       pname = "debuggable";
+       version = "0.1.0";
+       sha256 = "0wr0s3l427wd20bq93dppdbxcr3pda63yc1h08cppm10j1dfhlpx";
+       libraryHaskellDepends = [
+         base containers exceptions hashable temporary unordered-containers
+       ];
+       testHaskellDepends = [ async base optparse-applicative ];
+       description = "Utilities for making your applications more debuggable";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "debugger-hs" = callPackage
     ({ mkDerivation, base, dlist, hspec, mtl, neat-interpolation, text
      }:
···
        pname = "decision-diagrams";
        version = "0.2.0.0";
        sha256 = "0l03mwig95h300rn1cfhd5ahwrlap6zsw09lwmkx6wkw6rjf4a5s";
-       revision = "3";
-       editedCabalFile = "11gb1dm0rladnjr8y2w15pba8dp4hr4kb2gshikq7xiiffgx70lz";
+       revision = "4";
+       editedCabalFile = "0xlv7zw25jg9na0jy7ic2ni97j38z7vhn89vz44v8k6b93jd0wx9";
        libraryHaskellDepends = [
          base containers hashable hashtables intern mwc-random primitive
          random reflection unordered-containers vector
···
      }) {};
 
   "deep-map" = callPackage
-    ({ mkDerivation, base, containers, indexed-traversable }:
+    ({ mkDerivation, base, containers, indexed-traversable, witherable
+     }:
      mkDerivation {
        pname = "deep-map";
-       version = "0.2.0.1";
-       sha256 = "1qawlz663k1n20wk0qx47mldyydf8glgp8m4b8r2pxhyh99yqf0j";
-       libraryHaskellDepends = [ base containers indexed-traversable ];
+       version = "0.3.2";
+       sha256 = "02bg8hxjx8hpkc8n2z4jkj39na6s9mz85wmynn6qanb7dvpdllss";
+       libraryHaskellDepends = [
+         base containers indexed-traversable witherable
+       ];
        description = "Deeply-nested, multiple key type maps";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "deep-transformations" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
+  "dejafu_2_4_0_6" = callPackage
+    ({ mkDerivation, base, concurrency, containers, contravariant
+     , deepseq, exceptions, leancheck, profunctors, random, transformers
+     }:
+     mkDerivation {
+       pname = "dejafu";
+       version = "2.4.0.6";
+       sha256 = "1bmfc6bryhxdbv9k313f0hbdqf2zasivcj3b1zdwqajv34mwdzbm";
+       libraryHaskellDepends = [
+         base concurrency containers contravariant deepseq exceptions
+         leancheck profunctors random transformers
+       ];
+       description = "A library for unit-testing concurrent programs";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "deka" = callPackage
     ({ mkDerivation, base, bytestring, mpdec, parsec, transformers }:
      mkDerivation {
···
        mainProgram = "delta-h";
      }) {};
 
+  "deltaq" = callPackage
+    ({ mkDerivation, base, bytestring, cassava, Chart, criterion
+     , deepseq, hspec, hspec-discover, hvega, lattices
+     , optparse-applicative, probability-polynomial, QuickCheck
+     , statistics, vector
+     }:
+     mkDerivation {
+       pname = "deltaq";
+       version = "1.0.0.0";
+       sha256 = "00zpvwxar13rq84li7j21ycapdnyx128cs2yqvn6hwnrr8w25w9d";
+       libraryHaskellDepends = [
+         base Chart deepseq lattices probability-polynomial
+       ];
+       testHaskellDepends = [
+         base hspec probability-polynomial QuickCheck
+       ];
+       testToolDepends = [ hspec-discover ];
+       benchmarkHaskellDepends = [
+         base bytestring cassava criterion deepseq hvega
+         optparse-applicative statistics vector
+       ];
+       description = "Framework for ∆Q System Development";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "delude" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
        pname = "dependent-sum-template";
        version = "0.2.0.1";
        sha256 = "0rba7jf9hpn73gcqqkxvfk8j5mifb49glp6gjc8k93pg78zy7yqf";
-       revision = "1";
-       editedCabalFile = "16z72slamnghhqik23qvkyp2v5hv5w9wqvi0n8h0640sp1s80r4q";
+       revision = "2";
+       editedCabalFile = "0nqaxbqw4qlwf03mk59sgkakn14krb5l2clrd392qilga1a3srx9";
        libraryHaskellDepends = [
          base containers mtl some template-haskell th-abstraction
        ];
···
     ({ mkDerivation, base, hspec, template-haskell, th-abstraction }:
      mkDerivation {
        pname = "derive-has-field";
-       version = "0.0.1.4";
-       sha256 = "19mbgv53sc4j200affnsig9g9qz9cn7xp7v3qc1l4cc93pgyf3m9";
+       version = "0.1.0.0";
+       sha256 = "1hc5fgsc0yzidrnhwrlhvmaw062yv1v6vg5wl4l597cd74316mcl";
        libraryHaskellDepends = [ base template-haskell th-abstraction ];
        testHaskellDepends = [
          base hspec template-haskell th-abstraction
···
     ({ mkDerivation, aeson, base, bytestring }:
      mkDerivation {
        pname = "deriving-aeson";
-       version = "0.2.9";
-       sha256 = "0cqq4ri9dgqkdh9wybf3wf5zxb9nihql591bk1lacnzdyxfrgcn0";
-       revision = "1";
-       editedCabalFile = "14iqkk7vs0lb0sgq159z0xw95pa87r60i1f4m17gfh2gbbddcywm";
+       version = "0.2.10";
+       sha256 = "0xrny17zfsfjrl6042na32q7msm939p3ns6x7iw47xc21an55yrs";
        libraryHaskellDepends = [ aeson base ];
        testHaskellDepends = [ aeson base bytestring ];
        description = "Type driven generic aeson instance customisation";
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "deriving-compat_0_6_7" = callPackage
+    ({ mkDerivation, base, base-orphans, containers, ghc-boot-th
+     , ghc-prim, hspec, hspec-discover, QuickCheck, tagged
+     , template-haskell, th-abstraction, transformers
+     , transformers-compat, void
+     }:
+     mkDerivation {
+       pname = "deriving-compat";
+       version = "0.6.7";
+       sha256 = "1pzmqwjfd4j5bbcxl8xcgaxilmsfvcwak47rqkakn87n2c85zi6x";
+       libraryHaskellDepends = [
+         base containers ghc-boot-th ghc-prim template-haskell
+         th-abstraction transformers transformers-compat
+       ];
+       testHaskellDepends = [
+         base base-orphans hspec QuickCheck tagged template-haskell
+         transformers transformers-compat void
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Backports of GHC deriving extensions";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "deriving-openapi3" = callPackage
     ({ mkDerivation, aeson, base, deriving-aeson, lens, openapi3, text
      }:
···
   "desktop-portal" = callPackage
     ({ mkDerivation, base, binary, bytestring, containers, data-default
      , dbus, directory, filepath, hspec, hspec-discover
-     , hspec-expectations, modern-uri, network, process, random
-     , temporary, text, unix
+     , hspec-expectations, modern-uri, network, os-string, process
+     , random, temporary, text, unix
      }:
      mkDerivation {
        pname = "desktop-portal";
-       version = "0.7.0.0";
-       sha256 = "1j30lqriib7nh4p0qydav11xy17n32y8b9802vlmw4zw8rw84ivx";
+       version = "0.8.0.1";
+       sha256 = "09rr3ffkg5960dy909x30qlayzcm0ifzy0w64gvsnz3ybkq4c5j9";
        libraryHaskellDepends = [
          base binary bytestring containers data-default dbus directory
-         filepath modern-uri network random text unix
+         filepath modern-uri network os-string random text unix
        ];
        testHaskellDepends = [
          base binary bytestring containers data-default dbus directory
-         filepath hspec hspec-expectations modern-uri network process random
-         temporary text unix
+         filepath hspec hspec-expectations modern-uri network os-string
+         process random temporary text unix
        ];
        testToolDepends = [ hspec-discover ];
        description = "Desktop Portal";
···
        pname = "dhall";
        version = "1.42.1";
        sha256 = "0n4773s7l9sfqi00fnh4h92mpifbh0m6vsvpghg834c0jx2gm36f";
-       revision = "1";
-       editedCabalFile = "04q42qhfc346ml0vxrxwcxrwn0j4wrbbi8ll17ml2pkgr28krdnh";
+       revision = "2";
+       editedCabalFile = "0j29l5qbr72bcxlid28sq3wpxy481xlp0pknlna7wv13vfi8a9v4";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        pname = "dhall-lsp-server";
        version = "1.1.3";
        sha256 = "1vcdjsqd0falcx48fa58qilnwh70h6cinxbkh2rfmlhvfgmramc8";
-       revision = "1";
-       editedCabalFile = "07x2q58dzr7qn116rx12wpi3jsgz3f5rpxmilk0x1zj1jiwznyxg";
+       revision = "2";
+       editedCabalFile = "15mwpjg7axf7zmyf889675r61x754ygiy0nvf3g5km0i8a3s4203";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "dhall-yaml";
        version = "1.2.12";
        sha256 = "1sh802maai9vxfrjd0w4k9cv4pklhkxid1s5xdbagywcaqdhk272";
-       revision = "3";
-       editedCabalFile = "05dl461p5acqn9mlw08mvk3vspgk79k34v6m1wag0g7f3b34c5w4";
+       revision = "4";
+       editedCabalFile = "0l874s5q86dzy4q7pwjsdms53lckjamiq1wgll8sg6qifsjspmll";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "diohsc";
-       version = "0.1.15";
-       sha256 = "03wvdphxc2csxs7h56lg5zz9cp15bv5ac3y1wp9z7q3zkmwla68c";
+       version = "0.1.16";
+       sha256 = "1wh0vw9bbj148lr3idwx1xdwprx9685nppk2qglsy2nwmli893sf";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        broken = true;
      }) {};
 
-  "directory-ospath-streaming_0_1_0_2" = callPackage
-    ({ mkDerivation, base, directory, filepath, os-string, random
-     , tasty, tasty-hunit, unix
+  "directory-ospath-streaming_0_2_1" = callPackage
+    ({ mkDerivation, atomic-counter, base, deepseq, directory, filepath
+     , os-string, random, tasty, tasty-hunit, unix
      }:
      mkDerivation {
        pname = "directory-ospath-streaming";
-       version = "0.1.0.2";
-       sha256 = "17a3sqw3sw70bxdw91vq17pbjjdymnivn9gkfvclr5gicvw30d6k";
-       libraryHaskellDepends = [ base filepath os-string unix ];
+       version = "0.2.1";
+       sha256 = "01jp33m4fq54v3yr95nigad99kznnh23hx3p1yxz6mj2b4q63ia5";
+       libraryHaskellDepends = [
+         atomic-counter base deepseq filepath os-string unix
+       ];
        testHaskellDepends = [
          base directory filepath os-string random tasty tasty-hunit unix
        ];
···
      }:
      mkDerivation {
        pname = "distribution-nixpkgs";
-       version = "1.7.1";
-       sha256 = "19jzsqva4bnnjyq0zgqmqrvlgb6x3jxjqg398kwzk5syrxbap9nl";
+       version = "1.7.1.1";
+       sha256 = "0zh6qgr9mksh96bp9x1k8hdp2yzvk11bcszswnfvfnpz17nkdang";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base bytestring Cabal containers deepseq language-nix lens
···
      }) {};
 
   "dobutokO2" = callPackage
-    ({ mkDerivation, base, bytestring, directory, mmsyn2, mmsyn3
-     , mmsyn6ukr, mmsyn7l, mmsyn7s, mmsyn7ukr, process
-     , uniqueness-periods, vector
+    ({ mkDerivation, aftovolio, base, bytestring, directory, end-of-exe
+     , mmsyn2-array, mmsyn7l, mmsyn7ukr-array, mmsyn7ukr-common, process
+     , vector
      }:
      mkDerivation {
        pname = "dobutokO2";
-       version = "0.43.0.0";
-       sha256 = "0f17ff77m16p951laijqf5w4pfw4pgc6x2ha13472h62dzg8gm2f";
+       version = "0.44.1.0";
+       sha256 = "1ggk53mzi1dmgr5yijsz9hbnaqjxbajzksbpvrpfb5d8s5mnw77p";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         base bytestring directory mmsyn2 mmsyn3 mmsyn6ukr mmsyn7l mmsyn7s
-         mmsyn7ukr process uniqueness-periods vector
+         aftovolio base bytestring directory end-of-exe mmsyn2-array mmsyn7l
+         mmsyn7ukr-array mmsyn7ukr-common process vector
        ];
        executableHaskellDepends = [
-         base bytestring directory mmsyn2 mmsyn3 mmsyn6ukr mmsyn7l mmsyn7s
-         mmsyn7ukr process uniqueness-periods vector
+         aftovolio base bytestring directory end-of-exe mmsyn2-array mmsyn7l
+         mmsyn7ukr-array mmsyn7ukr-common process vector
        ];
        description = "Helps to create experimental music from a file (or its part) and a Ukrainian text";
        license = lib.licenses.mit;
···
        pname = "doctest";
        version = "0.23.0";
        sha256 = "1jh38pj6rbsli4ba6jvnrg9dm2di18i7g9706nnfm0xc9ckhfs90";
+       revision = "1";
+       editedCabalFile = "1n9y3j4z15jf8xfi8v8pjd33b1z2csswzslqqpaa1cwazgv6f342";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "doctest-parallel";
        version = "0.3.1.1";
        sha256 = "1xpk020024vsqh27sp225hx50i1hn5fkhxiyww6wqnhrkxypjkwa";
-       revision = "1";
-       editedCabalFile = "1l2lzi4iv4d2xx5ry3vib6f0582dy1cia4cni2yfk3h2gywmxa2m";
+       revision = "2";
+       editedCabalFile = "1s9dibzwnl281ggp507gj1d0h26jczr537wlcr5ks5axwfb0262c";
        libraryHaskellDepends = [
          base base-compat Cabal code-page containers deepseq directory
          exceptions filepath ghc ghc-paths Glob process random syb
···
      }:
      mkDerivation {
        pname = "dotparse";
-       version = "0.1.1.0";
-       sha256 = "14829jdzb3vc3485y7hbri77giv2sbg8x4cyrc0pwk5cj8xb0yzf";
+       version = "0.1.2.0";
+       sha256 = "1h490sn42n8w4n0br6f5rca103pxhcrn6r1asdiyhgid9pnhfh8r";
        libraryHaskellDepends = [
          algebraic-graphs base bytestring chart-svg containers flatparse
          numhask-space optics-core process-extras string-interpolate
···
      }) {};
 
   "dunai" = callPackage
-    ({ mkDerivation, base, criterion, filepath, MonadRandom
-     , simple-affine-space, tasty, tasty-hunit, time, transformers
-     , transformers-base
+    ({ mkDerivation, base, criterion, filepath, list-transformer
+     , MonadRandom, simple-affine-space, tasty, tasty-hunit, time
+     , transformers, transformers-base
      }:
      mkDerivation {
        pname = "dunai";
-       version = "0.13.2";
-       sha256 = "0x12hx51p5vfgscys40p8a9nnfj8d5rf5ynp436jzry6pzi0i6ab";
+       version = "0.14.0";
+       sha256 = "1iss2iq5wbys06vnwzd37frhcqlhva1b6krac4wbc7l5b0dirvr3";
        libraryHaskellDepends = [
-         base MonadRandom simple-affine-space transformers transformers-base
+         base list-transformer MonadRandom simple-affine-space transformers
+         transformers-base
        ];
        testHaskellDepends = [ base tasty tasty-hunit transformers ];
        benchmarkHaskellDepends = [ base criterion filepath time ];
···
     ({ mkDerivation, base, dunai, normaldistribution, QuickCheck }:
      mkDerivation {
        pname = "dunai-test";
-       version = "0.13.2";
-       sha256 = "0z9rgirz7las2qrvagiiihgz03ds7dgbbmwk32mkz4paz339lkbg";
+       version = "0.14.0";
+       sha256 = "1z4gyjhvlcky9gg7az01i955c585qh15w4bm74l9r8zjd67b8xyc";
        libraryHaskellDepends = [
          base dunai normaldistribution QuickCheck
        ];
···
      }) {};
 
   "dwergaz" = callPackage
-    ({ mkDerivation, base }:
+    ({ mkDerivation, base, pretty }:
      mkDerivation {
        pname = "dwergaz";
-       version = "0.2.0.6";
-       sha256 = "0cm4jb40iflg8vbnaplp2qbzhjdm53zfkigh0jgml5jjf1yzvc8p";
-       libraryHaskellDepends = [ base ];
+       version = "0.3.0.1";
+       sha256 = "1l2a52gg8z5appajr9p2pci66vrj6zlm90s079xklbhig2fgckmb";
+       libraryHaskellDepends = [ base pretty ];
        testHaskellDepends = [ base ];
        description = "A minimal testing library";
-       license = lib.licenses.bsd3;
+       license = lib.licenses.isc;
      }) {};
 
   "dx9base" = callPackage
···
      }) {};
 
   "ede" = callPackage
-    ({ mkDerivation, aeson, attoparsec, base, bifunctors, bytestring
-     , comonad, directory, filepath, free, lens, mtl
-     , optparse-applicative, parsers, prettyprinter
+    ({ mkDerivation, aeson, attoparsec, attoparsec-aeson, base
+     , bifunctors, bytestring, comonad, directory, filepath, free, lens
+     , mtl, optparse-applicative, parsers, prettyprinter
      , prettyprinter-ansi-terminal, scientific, tasty, tasty-golden
      , text, text-manipulate, trifecta, unordered-containers, vector
      }:
      mkDerivation {
        pname = "ede";
-       version = "0.3.3.0";
-       sha256 = "0hc7jq3dfrwl87rlf0yaxv44dni95a0lc5ccs6ldr6svfwx5h7qg";
+       version = "0.3.4.0";
+       sha256 = "1hmckah3wmg2yhz7xjgzj8qab87pv9ffp9d5srg1941n50k96wci";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
          text-manipulate trifecta unordered-containers vector
        ];
        executableHaskellDepends = [
-         aeson attoparsec base bytestring optparse-applicative prettyprinter
-         prettyprinter-ansi-terminal text unordered-containers
+         aeson attoparsec attoparsec-aeson base bytestring
+         optparse-applicative prettyprinter prettyprinter-ansi-terminal text
+         unordered-containers
        ];
        testHaskellDepends = [
          aeson base bifunctors bytestring directory filepath tasty
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "effectful_2_5_0_0" = callPackage
+  "effectful_2_5_1_0" = callPackage
     ({ mkDerivation, async, base, bytestring, containers, directory
      , effectful-core, exceptions, lifted-base, primitive, process
      , safe-exceptions, stm, strict-mutable-base, tasty, tasty-bench
···
      }:
      mkDerivation {
        pname = "effectful";
-       version = "2.5.0.0";
-       sha256 = "1fv228n3cvbqhbvdrnix2wqr96zzvgav1dp5rkynpm12jjwknqkp";
+       version = "2.5.1.0";
+       sha256 = "040figskafk9b8gwvphhq1s5mdq2p6fmrwd5yipl36vpdmc350fy";
        libraryHaskellDepends = [
          async base bytestring directory effectful-core process stm
          strict-mutable-base time unliftio
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "effectful-core_2_5_0_0" = callPackage
+  "effectful-core_2_5_1_0" = callPackage
     ({ mkDerivation, base, containers, deepseq, exceptions
      , monad-control, primitive, strict-mutable-base, transformers-base
      , unliftio-core
      }:
      mkDerivation {
        pname = "effectful-core";
-       version = "2.5.0.0";
-       sha256 = "1fjk92pwpxapjkq8zzv36j071nq1g9lys78jwg8f4q68g3f7rlzr";
+       version = "2.5.1.0";
+       sha256 = "1mn2f6kv8vnccsdq20fhb4q7xiqh5w0v9bp72ianpyyjyvljbi3a";
        libraryHaskellDepends = [
          base containers deepseq exceptions monad-control primitive
          strict-mutable-base transformers-base unliftio-core
···
        pname = "effectful-plugin";
        version = "1.1.0.4";
        sha256 = "0c401ni8ajig5da4dgkk2xbajbkzghrjll8ccfh7pbbiknf7si7j";
+       revision = "1";
+       editedCabalFile = "1d1ih6q1fapizqw2gzm0jvyhlwgni1sffvghhmcw2dhdbbagmr4g";
        libraryHaskellDepends = [ base containers effectful-core ghc ];
        testHaskellDepends = [ base effectful-core ];
        description = "A GHC plugin for improving disambiguation of effects";
···
        pname = "effectful-th";
        version = "1.0.0.3";
        sha256 = "0dzjy054n4zcrnnnj50yxxqicv50mfmzhgcqzhz4n6ap8v88ykiv";
+       revision = "1";
+       editedCabalFile = "02p2pb43znjrmwrrpgrm6aflli1dg27ig6kbnd5j5kqab8nhbcbb";
        libraryHaskellDepends = [
          base containers effectful-core exceptions template-haskell
          th-abstraction
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "effectful-zoo" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, base, bytestring, effectful
+     , effectful-core, effectful-plugin, generic-lens, HUnit, hw-prelude
+     , microlens, resourcet, resourcet-effectful, tasty, tasty-hedgehog
+     , text, time, transformers, yaml
+     }:
+     mkDerivation {
+       pname = "effectful-zoo";
+       version = "0.0.1.0";
+       sha256 = "0jfjydnmb68mqm4vqvnha6yar8064crbp50ld31f21w2vxxz9i82";
+       isLibrary = false;
+       isExecutable = false;
+       libraryHaskellDepends = [
+         aeson aeson-pretty base bytestring effectful effectful-core
+         effectful-plugin generic-lens HUnit hw-prelude microlens resourcet
+         resourcet-effectful tasty tasty-hedgehog text time transformers
+         yaml
+       ];
+       testHaskellDepends = [ effectful-core hw-prelude tasty ];
+       doHaddock = false;
+       description = "Effectful effects for testing";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "effective-aspects" = callPackage
     ({ mkDerivation, base, Cabal, ghc-prim, hashtables, HUnit, mtl
      , QuickCheck, test-framework, test-framework-hunit
···
      }:
      mkDerivation {
        pname = "encoding";
-       version = "0.8.9";
-       sha256 = "0czqdh5bkbp1hy1kwhhmiqml5fr4n6iv0bk84slj6ym9ryrjdrf8";
+       version = "0.8.10";
+       sha256 = "0ccysrrpdg97g6ihlk0dh57nja7y3lf4n6ygkz1rff5r2r0z6v80";
        setupHaskellDepends = [
          base Cabal containers filepath ghc-prim HaXml
        ];
···
        maintainers = [ lib.maintainers.sternenseemann ];
      }) {};
 
+  "envy_2_1_4_0" = callPackage
+    ({ mkDerivation, base, bytestring, containers, hspec, mtl
+     , QuickCheck, quickcheck-instances, text, time, transformers
+     }:
+     mkDerivation {
+       pname = "envy";
+       version = "2.1.4.0";
+       sha256 = "1gd975m8vwgvvgfa6q9gsq5b517zg0wndypiikz7xi55d5vsrydl";
+       libraryHaskellDepends = [
+         base bytestring containers mtl text time transformers
+       ];
+       testHaskellDepends = [
+         base bytestring hspec mtl QuickCheck quickcheck-instances text time
+         transformers
+       ];
+       description = "An environmentally friendly way to deal with environment variables";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = [ lib.maintainers.sternenseemann ];
+     }) {};
+
   "envy-extensible" = callPackage
     ({ mkDerivation, base, doctest, envy, extensible, hspec
      , hspec-discover, main-tester, QuickCheck
···
 
   "eo-phi-normalizer" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, alex, array, base, blaze-html
-     , blaze-markup, BNFC, bytestring, Cabal, cereal, containers
-     , directory, doctest-parallel, file-embed, filepath, generic-lens
-     , happy, hashable, hspec, hspec-discover, lens, mtl
-     , optparse-applicative, process, PyF, QuickCheck, regex-compat
-     , scientific, template-haskell, text, unordered-containers
-     , with-utf8, yaml
+     , blaze-markup, BNFC, bytestring, Cabal, cereal, code-page
+     , containers, directory, doctest-parallel, file-embed, filepath
+     , generic-lens, happy, hashable, hspec, hspec-core, hspec-discover
+     , lens, mtl, optparse-applicative, process, PyF, QuickCheck
+     , regex-compat, scientific, template-haskell, text, text-manipulate
+     , unordered-containers, with-utf8, yaml
      }:
      mkDerivation {
        pname = "eo-phi-normalizer";
-       version = "1.1.0";
-       sha256 = "1xzi0dgk9fac2v1g1g0i5cq19kq97crmq0903bx3m2cn22v4la40";
+       version = "2.3.0";
+       sha256 = "1kjznzisfyp48w297aj7jcr5w1r29x3di5z77vcsz2pvsq8x90q4";
        isLibrary = true;
        isExecutable = true;
-       setupHaskellDepends = [ base Cabal process PyF ];
+       setupHaskellDepends = [
+         base bytestring Cabal code-page process PyF text with-utf8
+       ];
        libraryHaskellDepends = [
          aeson array base blaze-html blaze-markup bytestring cereal
-         containers directory file-embed filepath generic-lens hashable lens
-         mtl PyF regex-compat scientific template-haskell text
-         unordered-containers yaml
+         code-page containers directory file-embed filepath generic-lens
+         hashable hspec hspec-core lens mtl PyF regex-compat scientific
+         template-haskell text text-manipulate unordered-containers
+         with-utf8 yaml
        ];
        libraryToolDepends = [ alex BNFC happy ];
        executableHaskellDepends = [
          aeson aeson-pretty array base blaze-html blaze-markup bytestring
-         cereal containers directory file-embed filepath generic-lens
-         hashable lens mtl optparse-applicative PyF regex-compat scientific
-         template-haskell text unordered-containers with-utf8 yaml
+         cereal code-page containers directory file-embed filepath
+         generic-lens hashable hspec hspec-core lens mtl
+         optparse-applicative PyF regex-compat scientific template-haskell
+         text text-manipulate unordered-containers with-utf8 yaml
        ];
        executableToolDepends = [ alex BNFC happy ];
        testHaskellDepends = [
          aeson array base blaze-html blaze-markup bytestring cereal
-         containers directory doctest-parallel file-embed filepath
-         generic-lens hashable hspec hspec-discover lens mtl PyF QuickCheck
-         regex-compat scientific template-haskell text unordered-containers
-         with-utf8 yaml
+         code-page containers directory doctest-parallel file-embed filepath
+         generic-lens hashable hspec hspec-core hspec-discover lens mtl PyF
+         QuickCheck regex-compat scientific template-haskell text
+         text-manipulate unordered-containers with-utf8 yaml
        ];
        testToolDepends = [ alex BNFC happy hspec-discover ];
        description = "Command line normalizer of 𝜑-calculus expressions";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
-       mainProgram = "normalizer";
+       mainProgram = "eo-phi-normalizer";
        broken = true;
      }) {};
 
···
        broken = true;
      }) {};
 
+  "errata_0_4_0_3" = callPackage
+    ({ mkDerivation, base, containers, hspec, hspec-discover
+     , hspec-golden, text
+     }:
+     mkDerivation {
+       pname = "errata";
+       version = "0.4.0.3";
+       sha256 = "024gxj7410al65rlv943wdx6f2aq8zqjp19ykzn99zyhancmhc32";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base containers text ];
+       executableHaskellDepends = [ base containers text ];
+       testHaskellDepends = [ base containers hspec hspec-golden text ];
+       testToolDepends = [ hspec-discover ];
+       description = "Source code error pretty printing";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "errata-example";
+       broken = true;
+     }) {};
+
   "errno" = callPackage
     ({ mkDerivation, base, mtl }:
      mkDerivation {
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "esqueleto_3_5_13_1" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, blaze-html, bytestring
+     , conduit, containers, exceptions, hspec, hspec-core, monad-logger
+     , mtl, mysql, mysql-simple, persistent, persistent-mysql
+     , persistent-postgresql, persistent-sqlite, postgresql-simple
+     , QuickCheck, resourcet, tagged, template-haskell, text, time
+     , transformers, unliftio, unordered-containers
+     }:
+     mkDerivation {
+       pname = "esqueleto";
+       version = "3.5.13.1";
+       sha256 = "0ww1lmv81h8whifk79kmsv07lagqv8gkyqy77z31zl46rr2vikml";
+       libraryHaskellDepends = [
+         aeson attoparsec base blaze-html bytestring conduit containers
+         monad-logger persistent resourcet tagged template-haskell text time
+         transformers unliftio unordered-containers
+       ];
+       testHaskellDepends = [
+         aeson attoparsec base blaze-html bytestring conduit containers
+         exceptions hspec hspec-core monad-logger mtl mysql mysql-simple
+         persistent persistent-mysql persistent-postgresql persistent-sqlite
+         postgresql-simple QuickCheck resourcet tagged template-haskell text
+         time transformers unliftio unordered-containers
+       ];
+       description = "Type-safe EDSL for SQL queries on persistent backends";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "esqueleto-compat" = callPackage
     ({ mkDerivation, base, conduit, esqueleto, hspec, persistent
      , resourcet, transformers
···
        pname = "eventlog2html";
        version = "0.11.1";
        sha256 = "1rfyw285g48c7dck8kjykx9n4brw7ngm275n64g1wwwkm4ybn43n";
+       revision = "1";
+       editedCabalFile = "0kxb0990f8x394j2l7y5y2xz43lqdlm4bc6gihfqnkc6w5qsqhji";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "exception-hierarchy_0_1_0_12" = callPackage
+    ({ mkDerivation, base, template-haskell }:
+     mkDerivation {
+       pname = "exception-hierarchy";
+       version = "0.1.0.12";
+       sha256 = "1hrj99in2x9scd68bfkq8jp9mmc4wja1vnadm2lhys12f1714sna";
+       libraryHaskellDepends = [ base template-haskell ];
+       description = "Exception type hierarchy with TemplateHaskell";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "exception-mailer" = callPackage
     ({ mkDerivation, base, hslogger, mime-mail, text }:
      mkDerivation {
···
        pname = "exceptions";
        version = "0.10.9";
        sha256 = "0h5y2rqg7kz4ic59n5i7619766mzfpqcdill3l712nihs3q2nk4v";
+       revision = "1";
+       editedCabalFile = "11p0d1gd3ybgbyplhr18wy2k7cy3hf6ab288ymy3ddayc4a927k6";
        libraryHaskellDepends = [
          base mtl stm template-haskell transformers
        ];
···
        license = lib.licenses.gpl3Only;
      }) {};
 
+  "exp-pairs_0_2_1_1" = callPackage
+    ({ mkDerivation, base, bimap, containers, deepseq, ghc-prim, matrix
+     , prettyprinter, QuickCheck, random, raw-strings-qq, smallcheck
+     , tasty, tasty-bench, tasty-hunit, tasty-quickcheck
+     , tasty-smallcheck
+     }:
+     mkDerivation {
+       pname = "exp-pairs";
+       version = "0.2.1.1";
+       sha256 = "01n730xafan7yf11bzsp40vi30an7risyxvnp16hzjxwlg6xlkpi";
+       libraryHaskellDepends = [
+         base containers deepseq ghc-prim prettyprinter
+       ];
+       testHaskellDepends = [
+         base matrix QuickCheck random smallcheck tasty tasty-hunit
+         tasty-quickcheck tasty-smallcheck
+       ];
+       benchmarkHaskellDepends = [
+         base bimap containers prettyprinter raw-strings-qq tasty-bench
+       ];
+       description = "Linear programming over exponent pairs";
+       license = lib.licenses.gpl3Only;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "expand" = callPackage
     ({ mkDerivation, AspectAG, base, HList, murder, uu-parsinglib }:
      mkDerivation {
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "extended-reals_0_2_5_0" = callPackage
+    ({ mkDerivation, base, deepseq, hashable, HUnit, QuickCheck, tasty
+     , tasty-hunit, tasty-quickcheck, tasty-th
+     }:
+     mkDerivation {
+       pname = "extended-reals";
+       version = "0.2.5.0";
+       sha256 = "17jvnxnd2v7yjzssbyqhzpjhvzfzis253fjz2kjqd2y3bi8lyfr9";
+       libraryHaskellDepends = [ base deepseq hashable ];
+       testHaskellDepends = [
+         base deepseq HUnit QuickCheck tasty tasty-hunit tasty-quickcheck
+         tasty-th
+       ];
+       description = "Extension of real numbers with positive/negative infinities";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "extensible" = callPackage
     ({ mkDerivation, aeson, base, bytestring, cassava, comonad
      , constraints, deepseq, ghc-prim, hashable, incremental, lens
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "extensible_0_9_2" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, cassava, comonad
+     , constraints, deepseq, ghc-prim, hashable, incremental, lens
+     , membership, prettyprinter, primitive, profunctors, QuickCheck
+     , StateVar, tagged, template-haskell, text, th-lift, transformers
+     , unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "extensible";
+       version = "0.9.2";
+       sha256 = "0ynw3w569rvkz4076wzzpg3fa9y7vmhwjk6chb8z4hz237pmifmx";
+       libraryHaskellDepends = [
+         aeson base bytestring cassava comonad constraints deepseq ghc-prim
+         hashable incremental membership prettyprinter primitive profunctors
+         QuickCheck StateVar tagged template-haskell text th-lift
+         transformers unordered-containers vector
+       ];
+       testHaskellDepends = [ base lens QuickCheck template-haskell ];
+       description = "Extensible, efficient, optics-friendly data types and effects";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "extensible-data" = callPackage
     ({ mkDerivation, base, data-lens, hashable, template-haskell
      , unordered-containers
···
        pname = "extensions";
        version = "0.1.0.3";
        sha256 = "1fks1yfdk0zjc1vccj3nr6li09j64cq6b6x9s5mi8qrsv5igbzlm";
+       revision = "1";
+       editedCabalFile = "1nd8zmxqlwnc3ksm13ld5d1rr6vhdi9dykp42mfk5lim7iyw3lj6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "extism";
-       version = "1.2.1.0";
-       sha256 = "0x2vwc5r812i3jk7z9y8qfkxlq3acqv560y1z97fsahkb1frydqy";
+       version = "1.3.0.0";
+       sha256 = "171ikqzya40gdwxzrzym020vhvd44srnfpy09303bcnp6gvn5zfb";
        libraryHaskellDepends = [
          base binary bytestring extism-manifest json uuid
        ];
···
     ({ mkDerivation, base, base64-bytestring, bytestring, json }:
      mkDerivation {
        pname = "extism-manifest";
-       version = "1.2.1.0";
-       sha256 = "1jxv93grdvr02q7gqg1gg9vqjirn3z84x8992zz3spgf4p1h2f2i";
+       version = "1.3.0.0";
+       sha256 = "1wfxz4ynllcps51xzby826h67lmsa85kd1d7jp1lbk4gkmjhiqz3";
        libraryHaskellDepends = [ base base64-bytestring bytestring json ];
        description = "Extism manifest bindings";
        license = lib.licenses.bsd3;
···
        pname = "falsify";
        version = "0.2.0";
        sha256 = "1fhj70q6kfd98892gxfy3mc8wxxyr80g4rzapaici4zd3zczz2fd";
-       revision = "3";
-       editedCabalFile = "0wpdv7xjf2q8wk3zql5y73ly4mky14m9rc4ql4g82x7biabnm7xg";
+       revision = "4";
+       editedCabalFile = "125c2jsl085kd0i4pdxkawpx43jlgn18xqf86r97f1ax15142p5g";
        libraryHaskellDepends = [
          base base16-bytestring binary bytestring containers data-default
          mtl optics-core optparse-applicative selective sop-core splitmix
···
      , bytestring, config-ini, copr-api, directory, either
      , email-validate, extra, fedora-releases, filepath, http-conduit
      , http-directory, http-query, koji, network-uri, pagure
-     , pretty-terminal, process, rpm-nvr, rpmbuild-order, say
+     , pretty-terminal, process, rpm-nvr, rpmbuild-order, safe, say
      , select-rpms, simple-cmd, simple-cmd-args, simple-prompt, text
      , time, typed-process, unix, utf8-string, xdg-basedir
      }:
      mkDerivation {
        pname = "fbrnch";
-       version = "1.5";
-       sha256 = "1jj2nnjqpqj1fxx7vliq1ayzwdp6xaphbdln8w2fifwbp8k3znjj";
+       version = "1.6.1";
+       sha256 = "1hixxzx1f9x5mj84220mc9hf94lpyq42qp00s3yry79kaiwwh7cz";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
          aeson async base bodhi bugzilla-redhat bytestring config-ini
          copr-api directory either email-validate extra fedora-releases
          filepath http-conduit http-directory http-query koji network-uri
-         pagure pretty-terminal process rpm-nvr rpmbuild-order say
+         pagure pretty-terminal process rpm-nvr rpmbuild-order safe say
          select-rpms simple-cmd simple-cmd-args simple-prompt text time
          typed-process unix utf8-string xdg-basedir
        ];
···
        ];
        description = "Library for Fedora release versions";
        license = lib.licenses.gpl3Only;
+     }) {};
+
+  "fedora-releases_0_2_0" = callPackage
+    ({ mkDerivation, aeson, base, bodhi, cached-json-file, extra, safe
+     }:
+     mkDerivation {
+       pname = "fedora-releases";
+       version = "0.2.0";
+       sha256 = "1phkcgrbspp1yd4axnfdsp3rfzdb1mka7fy0zb3chsi97g34ki1j";
+       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
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "file-io_0_1_5" = callPackage
+    ({ mkDerivation, base, bytestring, deepseq, filepath, tasty
+     , tasty-hunit, temporary, unix
+     }:
+     mkDerivation {
+       pname = "file-io";
+       version = "0.1.5";
+       sha256 = "0nvxp3d7j2fdkfcvk5n7swc0id7c7gzp3g0jr4q4vpljqzj1j2ii";
+       libraryHaskellDepends = [ base bytestring deepseq filepath unix ];
+       testHaskellDepends = [
+         base bytestring filepath tasty tasty-hunit temporary
+       ];
+       description = "Basic file IO operations via 'OsPath'";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "file-location" = callPackage
     ({ mkDerivation, base, containers, HUnit, lifted-base, process
      , template-haskell, th-orphans, transformers
···
        pname = "file-uri";
        version = "0.1.0.0";
        sha256 = "1bnsc1527qcvnz5ihv1phzbdif6qg01r3qmgj4dk1fzzn79mqnxl";
-       revision = "2";
-       editedCabalFile = "0vysq1q10zp4agcrfgzy7lrjgf2q2nj8fgs17v4n54r4vqmw3p6n";
+       revision = "3";
+       editedCabalFile = "1qmb30gcmj8ckmjxyhhkixpcikwmf4nnd926pghixl2ylwb79dl2";
        libraryHaskellDepends = [ attoparsec base bytestring ];
        testHaskellDepends = [ base bytestring tasty tasty-hunit ];
        benchmarkHaskellDepends = [ base tasty-bench ];
···
        broken = true;
      }) {};
 
-  "filepath_1_5_3_0" = callPackage
+  "filepath_1_5_4_0" = callPackage
     ({ mkDerivation, base, bytestring, deepseq, exceptions
      , generic-deriving, generic-random, os-string
      , quickcheck-classes-base, tasty, tasty-bench, tasty-quickcheck
···
      }:
      mkDerivation {
        pname = "filepath";
-       version = "1.5.3.0";
-       sha256 = "0nhsjfbm31rxsx4hbx8wh9ir3845j7pcjhgb1rz7rpjkzr2fq1yq";
+       version = "1.5.4.0";
+       sha256 = "1bswvf1hrsslb8xlwvsccz12h5habrdpqq4zgcyjg4zm6b28dajl";
        libraryHaskellDepends = [
          base bytestring deepseq exceptions os-string template-haskell
        ];
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "fin_0_3_1" = callPackage
+  "fin_0_3_2" = callPackage
     ({ mkDerivation, base, boring, dec, deepseq, hashable
      , inspection-testing, QuickCheck, some, tagged, universe-base
      }:
      mkDerivation {
        pname = "fin";
-       version = "0.3.1";
-       sha256 = "1y98g48dr046d1v300aj10dq5mrn79yj769gcld01834xi0ng010";
-       revision = "1";
-       editedCabalFile = "1q6hq4m95b89ig3c21p36ng904vj84r5ga3brj589ifs068lpvv4";
+       version = "0.3.2";
+       sha256 = "0h912rcy2krba01yd1xq6wyj2mnq7bqr7ap6rcdfw0sgkxa5j9dr";
        libraryHaskellDepends = [
          base boring dec deepseq hashable QuickCheck some universe-base
        ];
···
     ({ mkDerivation, base, deepseq, doctest, fixed-vector, primitive }:
      mkDerivation {
        pname = "fixed-vector-hetero";
-       version = "0.6.1.1";
-       sha256 = "1amqpbvzyqfg5rsl4zm99qmiffbh0a5bf9jbwlm6snwm9024qsj3";
+       version = "0.6.2.0";
+       sha256 = "1flqm18gcwc4f54y3b5axyfhdq9wn4069y64nbsmh064d23bln5s";
        libraryHaskellDepends = [ base deepseq fixed-vector primitive ];
        testHaskellDepends = [ base doctest fixed-vector ];
        description = "Library for working with product types generically";
···
      }:
      mkDerivation {
        pname = "flatparse";
-       version = "0.5.1.0";
-       sha256 = "1hczq8x2qmvhxvdn6yb1dcq18ahm917dq0vjvhni6d5d9sa6r2fb";
+       version = "0.5.1.1";
+       sha256 = "1xk7sdppslk85jhxqrd1bfn7wnz7yxaxrls9vz1fnhi745sw0xhb";
        libraryHaskellDepends = [
          base bytestring containers integer-gmp template-haskell utf8-string
        ];
···
        maintainers = [ lib.maintainers.raehik ];
      }) {};
 
+  "flatparse_0_5_2_0" = callPackage
+    ({ mkDerivation, attoparsec, base, bytestring, containers, gauge
+     , hspec, HUnit, integer-gmp, megaparsec, parsec, primitive
+     , QuickCheck, quickcheck-instances, template-haskell, utf8-string
+     }:
+     mkDerivation {
+       pname = "flatparse";
+       version = "0.5.2.0";
+       sha256 = "1w2xpzfnwnf2r3bgfnfnjbbzy9l92x5qyncamr8k1bq7xhf041l5";
+       libraryHaskellDepends = [
+         base bytestring containers integer-gmp template-haskell utf8-string
+       ];
+       testHaskellDepends = [
+         base bytestring hspec HUnit QuickCheck quickcheck-instances
+         utf8-string
+       ];
+       benchmarkHaskellDepends = [
+         attoparsec base bytestring gauge integer-gmp megaparsec parsec
+         primitive utf8-string
+       ];
+       description = "High-performance parsing from strict bytestrings";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = [ lib.maintainers.raehik ];
+     }) {};
+
   "flay" = callPackage
     ({ mkDerivation, base, constraints, tasty, tasty-quickcheck
      , transformers
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "foldable1-classes-compat_0_1_1" = callPackage
+    ({ mkDerivation, base, containers, deepseq, ghc-prim, QuickCheck
+     , quickcheck-instances, tagged, tasty-bench, test-framework
+     , test-framework-quickcheck2, transformers
+     }:
+     mkDerivation {
+       pname = "foldable1-classes-compat";
+       version = "0.1.1";
+       sha256 = "17xmc3525crnd86rrl2c50rfnhibwh5xbqrnmvzvyns4d3l4vvdg";
+       revision = "1";
+       editedCabalFile = "1yd6ksym0jxhagyps93w1dlw9rrfsnps96m44md5n90z0qzalnm7";
+       libraryHaskellDepends = [ base ghc-prim tagged ];
+       testHaskellDepends = [
+         base containers QuickCheck quickcheck-instances test-framework
+         test-framework-quickcheck2 transformers
+       ];
+       benchmarkHaskellDepends = [
+         base containers deepseq tasty-bench transformers
+       ];
+       doHaddock = false;
+       description = "Compatibility package for the Foldable1 and Bifoldable1 type classes";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "foldl" = callPackage
     ({ mkDerivation, base, bytestring, comonad, containers
      , contravariant, criterion, doctest, hashable, primitive
···
        maintainers = [ lib.maintainers.Gabriella439 ];
      }) {};
 
+  "foldl_1_4_18" = callPackage
+    ({ mkDerivation, base, bytestring, comonad, containers
+     , contravariant, criterion, doctest, hashable, primitive
+     , profunctors, random, semigroupoids, text, transformers
+     , unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "foldl";
+       version = "1.4.18";
+       sha256 = "03jhj5p017r6f75vb0dk6igcaklgykjpp23j5wk7blzph18z9n6a";
+       libraryHaskellDepends = [
+         base bytestring comonad containers contravariant hashable primitive
+         profunctors random semigroupoids text transformers
+         unordered-containers vector
+       ];
+       testHaskellDepends = [ base doctest ];
+       benchmarkHaskellDepends = [ base criterion profunctors ];
+       description = "Composable, streaming, and efficient left folds";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = [ lib.maintainers.Gabriella439 ];
+     }) {};
+
   "foldl-exceptions" = callPackage
     ({ mkDerivation, base, foldl, hedgehog, safe-exceptions }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "fp-ieee";
-       version = "0.1.0.4";
-       sha256 = "1zba050nwsf2iidxklibndja5kmszc5k7jmimchszrnc821d0cqg";
-       revision = "1";
-       editedCabalFile = "0bryqkf0h9a102bk7albf4pd1mjgs2l2wa6jc96sqly75ddr4d06";
+       version = "0.1.0.5";
+       sha256 = "1alrzx3y39j4bxjgvvx4mj8a3hiifixv4wxy7222lnz6mx18n8pb";
        libraryHaskellDepends = [ base ghc-bignum integer-logarithms ];
        testHaskellDepends = [
          base doctest hspec hspec-core integer-logarithms QuickCheck random
···
      , hspec-core, hspec-expectations-lifted, hspec-junit-formatter
      , http-client, http-types, HUnit, immortal, lens, monad-control
      , monad-validate, MonadRandom, mtl, nonempty-containers, openapi3
-     , path-pieces, persistent, persistent-postgresql, postgresql-simple
-     , primitive, QuickCheck, resource-pool, resourcet, scientist
-     , semigroupoids, servant-server, template-haskell, text, time
-     , transformers, transformers-base, typed-process, unliftio
-     , unordered-containers, vector, wai, wai-extra, yaml, yesod-core
-     , yesod-test
+     , path-pieces, persistent, persistent-postgresql
+     , persistent-sql-lifted, postgresql-simple, primitive, QuickCheck
+     , resource-pool, resourcet, scientist, semigroupoids
+     , servant-server, template-haskell, text, time, transformers
+     , transformers-base, typed-process, unliftio, unordered-containers
+     , vector, wai, wai-extra, yaml, yesod-core, yesod-test
      }:
      mkDerivation {
        pname = "freckle-app";
-       version = "1.20.3.0";
-       sha256 = "0if5ijphbin6ff0krfhy7bpjambw4zf8ccg459caiff3qc97rlcy";
+       version = "1.21.0.0";
+       sha256 = "00z5dymp8xb1a0hai697zrkgl99sprinvfm1bf9c0r8ng259n10s";
+       revision = "1";
+       editedCabalFile = "0mc6fcvbc1m8013pb95pr2i7005r3f70a7hh9ycncipf8ydg0jr4";
        libraryHaskellDepends = [
          aeson annotated-exception autodocodec autodocodec-openapi3 base
          bcp47 Blammo Blammo-wai bugsnag bytestring case-insensitive cassava
···
          hspec-core hspec-expectations-lifted hspec-junit-formatter
          http-client http-types HUnit immortal lens monad-control
          monad-validate MonadRandom mtl nonempty-containers openapi3
-         path-pieces persistent persistent-postgresql postgresql-simple
-         primitive QuickCheck resource-pool resourcet scientist
-         semigroupoids servant-server template-haskell text time
+         path-pieces persistent persistent-postgresql persistent-sql-lifted
+         postgresql-simple primitive QuickCheck resource-pool resourcet
+         scientist semigroupoids servant-server template-haskell text time
          transformers transformers-base typed-process unliftio
          unordered-containers vector wai wai-extra yaml yesod-core
          yesod-test
···
      }:
      mkDerivation {
        pname = "freckle-kafka";
-       version = "0.0.0.1";
-       sha256 = "1ifm5axxng5bknz4v7zv8pjv0fv91hnv2l8jh22s4llj0wax1l28";
+       version = "0.0.0.2";
+       sha256 = "1g2ynl6sxrj42jjjzf4y0bkh54alnd93c6gclgg0kqs593k0a2qx";
        libraryHaskellDepends = [
          aeson annotated-exception base Blammo bytestring containers
          freckle-env hs-opentelemetry-sdk hw-kafka-client lens mtl
···
        pname = "free";
        version = "5.2";
        sha256 = "12agp68cwwixcwfwnvk2xamg34a2x6ax7s1naxv66chpi5y7z1kj";
-       revision = "5";
-       editedCabalFile = "0vn4rk8gw60571j4smw8x7jldigj3i84jr0rycxlkag94w6rrr1i";
+       revision = "6";
+       editedCabalFile = "1n8yx64gffqiqkkmn67bfhnfafgf1c10m9mm7yb8b5fiv21kx5hj";
        libraryHaskellDepends = [
          base comonad containers distributive exceptions indexed-traversable
          mtl profunctors semigroupoids template-haskell th-abstraction
···
      }:
      mkDerivation {
        pname = "free-alacarte";
-       version = "1.0.0.8";
-       sha256 = "1il7ihn81g2341bx07pjjmjzyrxl3n9n70bg6qdxdgjs0w9b6b78";
+       version = "1.0.0.9";
+       sha256 = "0avy7n3m9qjpdiwpb52igznpjv1qscv8d8i6jcycp358hwns680d";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [
          base containers hspec QuickCheck relude tasty tasty-hspec text time
···
      }:
      mkDerivation {
        pname = "fs-sim";
-       version = "0.3.0.1";
-       sha256 = "1r094vpwpmq3956zs2yqvpliz0aq0wb71pnw566kcxm1rvv91wjr";
+       version = "0.3.1.0";
+       sha256 = "0qq7fc9b37haz2dcywyxhkszy58i3fr7z8nyrrp16x46v5cs6jwq";
        libraryHaskellDepends = [
          base base16-bytestring bytestring containers fs-api io-classes mtl
          primitive QuickCheck safe-wild-cards text
···
        pname = "fsnotify";
        version = "0.3.0.1";
        sha256 = "19bdbz9wb9jvln6yg6qm0hz0w84bypvkxf0wjhgrgd52f9gidlny";
-       revision = "2";
-       editedCabalFile = "12m0y5583plk9pikvwqy1rc0yyvicxf8j5nz0nwxb4grsgfqrv7v";
+       revision = "3";
+       editedCabalFile = "0n5p6ljx8i5mmalkw05izjgzbqg08y7rxxn2gk8ghxlqldgqgix9";
        libraryHaskellDepends = [
          async base bytestring containers directory filepath hinotify shelly
          text time unix unix-compat
···
        broken = true;
      }) {};
 
+  "functora-witch" = callPackage
+    ({ mkDerivation, base, bytestring, containers, HUnit, tagged, text
+     , transformers
+     }:
+     mkDerivation {
+       pname = "functora-witch";
+       version = "1.2.0.2";
+       sha256 = "0zij8si5zyrfgg0gjh4b459l1y6b9n8kqn8jpkxwmbm2xzhrxjbb";
+       libraryHaskellDepends = [ base bytestring containers tagged text ];
+       testHaskellDepends = [
+         base bytestring containers HUnit tagged text transformers
+       ];
+       description = "Convert values from one type into another";
+       license = lib.licenses.mit;
+     }) {};
+
   "functorm" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
      }) {};
 
   "futhark" = callPackage
-    ({ mkDerivation, aeson, alex, ansi-terminal, array, base
+    ({ mkDerivation, aeson, alex, ansi-terminal, array, async, base
      , base16-bytestring, binary, blaze-html, bmp, bytestring
      , bytestring-to-vector, cmark-gfm, co-log-core, containers
      , cryptohash-md5, Diff, directory, directory-tree, dlist, fgl
···
      }:
      mkDerivation {
        pname = "futhark";
-       version = "0.25.23";
-       sha256 = "1yd1j5qv4rfijjxv48m0qq7y9r0qn31zliafgbmqs2i9ik5gg6sz";
+       version = "0.25.25";
+       sha256 = "04a9z8c1js3d8921araz9n91wahzfsw84wrslwny6h7wqvjda88q";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         aeson ansi-terminal array base base16-bytestring binary blaze-html
-         bmp bytestring bytestring-to-vector cmark-gfm co-log-core
-         containers cryptohash-md5 Diff directory directory-tree dlist fgl
-         fgl-visualize file-embed filepath free futhark-data
+         aeson ansi-terminal array async base base16-bytestring binary
+         blaze-html bmp bytestring bytestring-to-vector cmark-gfm
+         co-log-core containers cryptohash-md5 Diff directory directory-tree
+         dlist fgl fgl-visualize file-embed filepath free futhark-data
          futhark-manifest futhark-server githash half haskeline
          language-c-quote lens lsp lsp-types mainland-pretty megaparsec mtl
          mwc-random neat-interpolation parallel prettyprinter
···
        pname = "generic-data";
        version = "1.1.0.1";
        sha256 = "0cbng88jsx5f34jrhj2c83jg9r0d7q4xj6vb2as97mgrdmy054nk";
+       revision = "1";
+       editedCabalFile = "03qi9y1zippj9dsfk0afargl1crhjbms0hjs8y9y6vhanll5czm2";
        libraryHaskellDepends = [
          ap-normalize base base-orphans ghc-boot-th show-combinators
        ];
···
        benchmarkHaskellDepends = [ base deepseq tasty-bench ];
        description = "Deriving instances with GHC.Generics and related utilities";
        license = lib.licenses.mit;
+     }) {};
+
+  "generic-data_1_1_0_2" = callPackage
+    ({ mkDerivation, ap-normalize, base, base-orphans, deepseq
+     , generic-lens, ghc-boot-th, one-liner, show-combinators, tasty
+     , tasty-bench, tasty-hunit
+     }:
+     mkDerivation {
+       pname = "generic-data";
+       version = "1.1.0.2";
+       sha256 = "1dfs728nbkilzfmdk6gnjk7wdk1habqn35pb071zcmcp8ll0lzpj";
+       libraryHaskellDepends = [
+         ap-normalize base base-orphans ghc-boot-th show-combinators
+       ];
+       testHaskellDepends = [
+         base generic-lens one-liner show-combinators tasty tasty-hunit
+       ];
+       benchmarkHaskellDepends = [ base deepseq tasty-bench ];
+       description = "Deriving instances with GHC.Generics and related utilities";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "generic-data-asserts" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "generic-deriving_1_14_6" = callPackage
+    ({ mkDerivation, base, containers, ghc-prim, hspec, hspec-discover
+     , template-haskell, th-abstraction
+     }:
+     mkDerivation {
+       pname = "generic-deriving";
+       version = "1.14.6";
+       sha256 = "1bxjar1kc29nma3whxb0kqgjgxmmm7wvhql7pyick8rj39zw35gi";
+       libraryHaskellDepends = [
+         base containers ghc-prim template-haskell th-abstraction
+       ];
+       testHaskellDepends = [ base hspec template-haskell ];
+       testToolDepends = [ hspec-discover ];
+       description = "Generic programming library for generalised deriving";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "generic-enum" = callPackage
     ({ mkDerivation, array, base, bytestring, hspec }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "generic-persistence";
-       version = "0.6.0";
-       sha256 = "00clpi6ijwagp3zrjb94kwv03wxcx4aqq22zn32kxhz8b3w71jd1";
+       version = "0.7.0.1";
+       sha256 = "1w32mlwnpiw81qaqwkivsbzpqbhi4c13qcy7ki34w71fiwyhahpd";
        libraryHaskellDepends = [
          base convertible generic-deriving HDBC raw-strings-qq resource-pool
          template-haskell
···
        mainProgram = "gh-pocket-knife";
      }) {};
 
-  "ghc_9_10_1" = callPackage
+  "ghc_9_12_1" = callPackage
     ({ mkDerivation, alex, array, base, binary, bytestring, Cabal
      , containers, deepseq, deriveConstants, directory, exceptions
-     , filepath, genprimopcode, ghc-boot, ghc-heap, ghci, happy, hpc
-     , process, semaphore-compat, stm, template-haskell, time
+     , filepath, genprimopcode, ghc-boot, ghc-boot-th, ghc-heap, ghci
+     , happy, hpc, os-string, process, semaphore-compat, stm, time
      , transformers, unix
      }:
      mkDerivation {
        pname = "ghc";
-       version = "9.10.1";
-       sha256 = "0vdhjqfcwjnhr2dijjqcwvybfy2pvfsynh87wh9hbak9w0ppwvha";
+       version = "9.12.1";
+       sha256 = "179gp0lqrxhvzc0pyxwmkvxpilm6c201s1pjws3dl8qqyddliiqs";
        setupHaskellDepends = [
          base Cabal containers directory filepath process
        ];
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq directory
-         exceptions filepath ghc-boot ghc-heap ghci hpc process
-         semaphore-compat stm template-haskell time transformers unix
+         exceptions filepath ghc-boot ghc-boot-th ghc-heap ghci hpc
+         os-string process semaphore-compat stm time transformers unix
        ];
        libraryToolDepends = [ alex deriveConstants genprimopcode happy ];
        description = "The GHC API";
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "ghc-boot_9_10_1" = callPackage
+  "ghc-boot_9_12_1" = callPackage
     ({ mkDerivation, base, binary, bytestring, Cabal, containers
      , deepseq, directory, filepath, ghc-boot-th, ghc-platform, unix
      }:
      mkDerivation {
        pname = "ghc-boot";
-       version = "9.10.1";
-       sha256 = "02sqxmc2f8lb95hrabj088618sd9by9ypvsrs2f2753dg1xqlbzg";
-       revision = "1";
-       editedCabalFile = "07pn68dhxfmkh7j49vfswjd480j0f60r87azbwqyglv8cl19bz4h";
+       version = "9.12.1";
+       sha256 = "10yylnkjn628pbdqs2zvvxh3208xrjav8l7mqz7ck7gb9pvx44z4";
        setupHaskellDepends = [ base Cabal directory filepath ];
        libraryHaskellDepends = [
          base binary bytestring containers deepseq directory filepath
···
        mainProgram = "ghc-events";
      }) {};
 
+  "ghc-events_0_20_0_0" = callPackage
+    ({ mkDerivation, array, base, binary, bytestring, containers, text
+     , vector
+     }:
+     mkDerivation {
+       pname = "ghc-events";
+       version = "0.20.0.0";
+       sha256 = "11p3i8jjsxffvh77dlmygh78hyavhkgmk4rhq9khp45br5xshwkk";
+       revision = "1";
+       editedCabalFile = "1kwhh5cqgvgadabban5kzhfjs6xsmbcd0yhqp6dpr4hpggv5cw4n";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         array base binary bytestring containers text vector
+       ];
+       executableHaskellDepends = [ base bytestring containers ];
+       testHaskellDepends = [ base ];
+       description = "Library and tool for parsing .eventlog files from GHC";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "ghc-events";
+     }) {};
+
   "ghc-events-analyze" = callPackage
     ({ mkDerivation, base, blaze-svg, bytestring, containers
      , diagrams-lib, diagrams-svg, filepath, ghc-events, hashable, lens
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "ghc-exactprint_1_10_0_0" = callPackage
+  "ghc-exactprint_1_11_0_0" = callPackage
     ({ mkDerivation }:
      mkDerivation {
        pname = "ghc-exactprint";
-       version = "1.10.0.0";
-       sha256 = "14jwkx0q2bidcv5ss7zmkvl41z264k7siy9fh7py27h7azb539v0";
+       version = "1.11.0.0";
+       sha256 = "1rpryylgjrvp595rhv68fa1rf35gy9nswc97dw0lwm7dyw7dbyy2";
        isLibrary = true;
        isExecutable = true;
        description = "ExactPrint for GHC";
···
     ({ mkDerivation, base, ghc-internal, ghc-prim }:
      mkDerivation {
        pname = "ghc-experimental";
-       version = "0.1.0.0";
-       sha256 = "144s8ja4jdasq65db1q4342ny1cd0d1ad48axd9gzv1h0mmqkz4f";
+       version = "9.1201.0";
+       sha256 = "10rk2vvf6sh1wbg6hkcb9lnnvxysyjjgz24dhdz7k12gwnlgnf7i";
        libraryHaskellDepends = [ base ghc-internal ghc-prim ];
        description = "Experimental features of GHC's standard library";
        license = lib.licenses.bsd3;
···
        broken = true;
      }) {};
 
-  "ghc-heap_9_10_1" = callPackage
+  "ghc-heap_9_12_1" = callPackage
     ({ mkDerivation, base, containers, ghc-prim, rts }:
      mkDerivation {
        pname = "ghc-heap";
-       version = "9.10.1";
-       sha256 = "1vkvi646gspj0i4llq40asdjmzwwczglci0qi8rv7lq75v6g1kl6";
+       version = "9.12.1";
+       sha256 = "02g1r4hxz7w1a82mb9z7zzjad54hl9m4k1i59d1adsr8cc1cg75p";
        libraryHaskellDepends = [ base containers ghc-prim rts ];
        description = "Functions for walking GHC's heap";
        license = lib.licenses.bsd3;
···
     ({ mkDerivation, ghc-bignum, ghc-prim, rts }:
      mkDerivation {
        pname = "ghc-internal";
-       version = "9.1001.0";
-       sha256 = "0z38v4gnyis99r3rli2g3dyg948d98lhd1ylz5irbghnvrn8myhl";
-       revision = "1";
-       editedCabalFile = "1rx55yc51xaarcyj8mgrdn6pmr8ri2n962h813dy5vc1pj49g8yz";
+       version = "9.1201.0";
+       sha256 = "046jam2fw5y8wqlkpnwigi2sjwgf45f572xs3nk228h6wxgfsl9y";
        libraryHaskellDepends = [ ghc-bignum ghc-prim rts ];
        description = "Basic libraries";
        license = lib.licenses.bsd3;
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "ghc-lib_9_8_3_20241103" = callPackage
+  "ghc-lib_9_8_4_20241130" = callPackage
     ({ mkDerivation, alex, array, base, binary, bytestring, containers
      , deepseq, directory, exceptions, filepath, ghc-lib-parser
      , ghc-prim, happy, hpc, parsec, pretty, process, rts
···
      }:
      mkDerivation {
        pname = "ghc-lib";
-       version = "9.8.3.20241103";
-       sha256 = "0cf14rw1kkvs7f5smhjrsxxs3rhcqlsfgb99cmv2dlvcma3h1k95";
+       version = "9.8.4.20241130";
+       sha256 = "016lsdv24lpm8dbac62xvrdw6bvvvivwgdcq9r8a5hzwjakbrqsr";
        revision = "1";
-       editedCabalFile = "1xjibygf7kjl8b17vsapg1mmlj226z38svd1kfz1b3qpn17j3mcd";
+       editedCabalFile = "0wim3zn9ihvjksc9p58qfb4d65cnmnv1f266wphl3hvq9gip33bz";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq directory
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "ghc-lib_9_12_1_20241218" = callPackage
+    ({ mkDerivation, alex, array, base, binary, bytestring, containers
+     , deepseq, directory, exceptions, filepath, ghc-lib-parser
+     , ghc-prim, happy, hpc, os-string, parsec, pretty, process, rts
+     , semaphore-compat, stm, time, transformers, unix
+     }:
+     mkDerivation {
+       pname = "ghc-lib";
+       version = "9.12.1.20241218";
+       sha256 = "116541qwj1pd42p3gd0hiyf5r15rp9sjkzvhpkk31jx00y3in8vz";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         array base binary bytestring containers deepseq directory
+         exceptions filepath ghc-lib-parser ghc-prim hpc os-string parsec
+         pretty process rts semaphore-compat stm time transformers unix
+       ];
+       libraryToolDepends = [ alex happy ];
+       description = "The GHC API, decoupled from GHC versions";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "ghc-lib-parser_9_2_8_20230729" = callPackage
     ({ mkDerivation, alex, array, base, binary, bytestring, containers
      , deepseq, directory, exceptions, filepath, ghc-prim, happy, parsec
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "ghc-lib-parser_9_8_3_20241103" = callPackage
+  "ghc-lib-parser_9_8_4_20241130" = callPackage
     ({ mkDerivation, alex, array, base, binary, bytestring, containers
      , deepseq, directory, exceptions, filepath, ghc-prim, happy, parsec
      , pretty, process, time, transformers, unix
      }:
      mkDerivation {
        pname = "ghc-lib-parser";
-       version = "9.8.3.20241103";
-       sha256 = "0cp1s6z0jm0pk6p2zlpklwqyh4wkh42cjxkgjdkl9wqnf1cnn444";
+       version = "9.8.4.20241130";
+       sha256 = "0zhw6x0z75mns6j4knbxbwavj267crb3xf4mpd3h9mrpg067vx7s";
        revision = "1";
-       editedCabalFile = "0ih4spj54606cj280cr3icl8d5imgipk1ydbajc9pd9vaqh2kg5c";
+       editedCabalFile = "1m5gdq7xd02d559r050wzrm4lm269xi5s6ri3qzn21xmjj3jpmqq";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq directory
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "ghc-lib-parser_9_12_1_20241218" = callPackage
+    ({ mkDerivation, alex, array, base, binary, bytestring, containers
+     , deepseq, directory, exceptions, filepath, ghc-prim, happy
+     , os-string, parsec, pretty, process, time, transformers, unix
+     }:
+     mkDerivation {
+       pname = "ghc-lib-parser";
+       version = "9.12.1.20241218";
+       sha256 = "0n3shswiljjsaf46wk5qmcp55na5df2s7384sxml85qkf3025jd4";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         array base binary bytestring containers deepseq directory
+         exceptions filepath ghc-prim os-string parsec pretty process time
+         transformers unix
+       ];
+       libraryToolDepends = [ alex happy ];
+       description = "The GHC API, decoupled from GHC versions";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "ghc-lib-parser-ex_9_2_1_1" = callPackage
     ({ mkDerivation, base, bytestring, containers, directory, extra
      , filepath, ghc-lib-parser, tasty, tasty-hunit, uniplate
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "ghc-lib-parser-ex_9_12_0_0" = callPackage
+    ({ mkDerivation, base, bytestring, containers, directory, extra
+     , filepath, ghc-lib-parser, optparse-applicative, tasty
+     , tasty-hunit, time, uniplate
+     }:
+     mkDerivation {
+       pname = "ghc-lib-parser-ex";
+       version = "9.12.0.0";
+       sha256 = "0w8mfa0g55m5i5ysxlkgci1grssi76za4523ygmsicb0ibq9ajb2";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring containers ghc-lib-parser uniplate
+       ];
+       executableHaskellDepends = [
+         base directory extra filepath optparse-applicative time
+       ];
+       testHaskellDepends = [
+         base bytestring containers directory extra filepath ghc-lib-parser
+         tasty tasty-hunit uniplate
+       ];
+       description = "Programming with GHC parse trees";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "ghc-lib-parser-ex-build-tool";
+     }) {};
+
   "ghc-magic-dict-compat" = callPackage
     ({ mkDerivation, base, dlist, falsify, ghc, ghc-prim
      , ghc-tcplugins-extra, tasty, tasty-discover, tasty-hunit
···
     ({ mkDerivation, base, ghc }:
      mkDerivation {
        pname = "ghc-parser";
-       version = "0.2.6.0";
-       sha256 = "177glyhd9qr4z19zl8ycdy2302k8jzyhrkh14dp92dp86iydlxp6";
-       libraryHaskellDepends = [ base ghc ];
-       description = "Haskell source parser from GHC";
-       license = lib.licenses.mit;
-     }) {};
-
-  "ghc-parser_0_2_7_0" = callPackage
-    ({ mkDerivation, base, ghc }:
-     mkDerivation {
-       pname = "ghc-parser";
        version = "0.2.7.0";
        sha256 = "08m1jb093pkmbj7km7xclq6f1jz20v313ih9b4fydis974i8pv3h";
        libraryHaskellDepends = [ base ghc ];
        description = "Haskell source parser from GHC";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ghc-paths" = callPackage
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "ghc-prim_0_11_0" = callPackage
+  "ghc-prim_0_13_0" = callPackage
     ({ mkDerivation, base, c, Cabal, directory, filepath, process, rts
      }:
      mkDerivation {
        pname = "ghc-prim";
-       version = "0.11.0";
-       sha256 = "118c37r8q94x0za1x6iqlfl429czgp5ii6mjdb1f7ba3nx9azzl5";
+       version = "0.13.0";
+       sha256 = "0qybdd79cnz88af4icwa9d7m9g08az5qyc1sflb0nkzj6iimrwnf";
        setupHaskellDepends = [ base Cabal directory filepath process ];
        libraryHaskellDepends = [ rts ];
        librarySystemDepends = [ c ];
···
        broken = true;
      }) {};
 
-  "ghc-source-gen" = callPackage
+  "ghc-source-gen_0_4_5_0" = callPackage
     ({ mkDerivation, base, ghc, ghc-paths, QuickCheck, tasty
      , tasty-hunit, tasty-quickcheck
      }:
···
        pname = "ghc-source-gen";
        version = "0.4.5.0";
        sha256 = "18v6i0a6j72brwr7zq0j0igmkzigx3w4a6rdhq8cn768vflpflvv";
+       libraryHaskellDepends = [ base ghc ];
+       testHaskellDepends = [
+         base ghc ghc-paths QuickCheck tasty tasty-hunit tasty-quickcheck
+       ];
+       description = "Constructs Haskell syntax trees for the GHC API";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "ghc-source-gen" = callPackage
+    ({ mkDerivation, base, ghc, ghc-paths, QuickCheck, tasty
+     , tasty-hunit, tasty-quickcheck
+     }:
+     mkDerivation {
+       pname = "ghc-source-gen";
+       version = "0.4.6.0";
+       sha256 = "00rgfsa7jmg29y9nknaqbshy96km2gxa8g91pgspw29rhw2ir3ll";
+       revision = "1";
+       editedCabalFile = "1kap75bw4i0wirx3ban6hgqh5cfq900l8jg9qm16y9fd0rwcff9j";
        libraryHaskellDepends = [ base ghc ];
        testHaskellDepends = [
          base ghc ghc-paths QuickCheck tasty tasty-hunit tasty-quickcheck
···
     ({ mkDerivation, base, containers, ghc, transformers }:
      mkDerivation {
        pname = "ghc-tcplugin-api";
-       version = "0.13.0.0";
-       sha256 = "1gwr31z1rxgxr3jmcyp8bqbm29nr095m876cfh1ljxchd7i9n2n3";
+       version = "0.14.0.0";
+       sha256 = "089lw1gjxrk54s1agl5gxkwg49368z6i6m260snz05nfia4m7fak";
        libraryHaskellDepends = [ base containers ghc transformers ];
        description = "An API for type-checker plugins";
        license = lib.licenses.bsd3;
···
 
   "ghcitui" = callPackage
     ({ mkDerivation, array, base, brick, containers, errors, extra
-     , file-embed, ghcid, hspec, microlens, microlens-th
+     , file-embed, fsnotify, ghcid, hspec, microlens, microlens-th
      , optparse-applicative, regex-base, regex-tdfa, string-interpolate
      , text, text-zipper, transformers, utf8-string, vector, vty
      , word-wrap
      }:
      mkDerivation {
        pname = "ghcitui";
-       version = "0.3.0.0";
-       sha256 = "1b214pl7d6hzw18zgard811lws63k421nq4mzl2qcyh9s67yljbp";
+       version = "0.4.1.0";
+       sha256 = "05c9s43qhzxc280xycicwrm95kl1jpz14pzlcnv0a29i8589gpdz";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         array base brick containers errors extra file-embed ghcid microlens
-         microlens-th regex-base regex-tdfa string-interpolate text
-         text-zipper transformers utf8-string vector vty word-wrap
+         array base brick containers errors extra file-embed fsnotify ghcid
+         microlens microlens-th regex-base regex-tdfa string-interpolate
+         text text-zipper transformers utf8-string vector vty word-wrap
        ];
        executableHaskellDepends = [ base optparse-applicative text ];
        testHaskellDepends = [ base hspec text ];
···
        license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) gtk3;};
 
-  "gi-gtk_4_0_9" = callPackage
-    ({ mkDerivation, base, bytestring, Cabal, containers, gi-atk
-     , gi-cairo, gi-gdk, gi-gdkpixbuf, gi-gio, gi-glib, gi-gobject
-     , gi-graphene, gi-gsk, gi-pango, gtk4, haskell-gi, haskell-gi-base
+  "gi-gtk_4_0_11" = callPackage
+    ({ mkDerivation, base, bytestring, Cabal, containers, gi-cairo
+     , gi-gdk, gi-gdkpixbuf, gi-gio, gi-glib, gi-gobject, gi-graphene
+     , gi-gsk, gi-pango, gtk4, haskell-gi, haskell-gi-base
      , haskell-gi-overloading, text, transformers
      }:
      mkDerivation {
        pname = "gi-gtk";
-       version = "4.0.9";
-       sha256 = "0pccbinm41shskr9l20m42mdvn2v11nylpwq2r4yz30lkpw401if";
+       version = "4.0.11";
+       sha256 = "17y5n3qk92pjf2h6qx3ibjwhbdbmzv505a8m628iwpra137r4m48";
        setupHaskellDepends = [
-         base Cabal gi-atk gi-cairo gi-gdk gi-gdkpixbuf gi-gio gi-glib
-         gi-gobject gi-graphene gi-gsk gi-pango haskell-gi
+         base Cabal gi-cairo gi-gdk gi-gdkpixbuf gi-gio gi-glib gi-gobject
+         gi-graphene gi-gsk gi-pango haskell-gi
        ];
        libraryHaskellDepends = [
-         base bytestring containers gi-atk gi-cairo gi-gdk gi-gdkpixbuf
-         gi-gio gi-glib gi-gobject gi-graphene gi-gsk gi-pango haskell-gi
+         base bytestring containers gi-cairo gi-gdk gi-gdkpixbuf gi-gio
+         gi-glib gi-gobject gi-graphene gi-gsk gi-pango haskell-gi
          haskell-gi-base haskell-gi-overloading text transformers
        ];
        libraryPkgconfigDepends = [ gtk4 ];
···
        broken = true;
      }) {inherit (pkgs) keybinder;};
 
+  "gi-nm" = callPackage
+    ({ mkDerivation, base, bytestring, Cabal, containers, gi-gio
+     , gi-glib, gi-gobject, haskell-gi, haskell-gi-base
+     , haskell-gi-overloading, networkmanager, text, transformers
+     }:
+     mkDerivation {
+       pname = "gi-nm";
+       version = "1.0.1";
+       sha256 = "02lg4032c29yyn2fyr0qc30ccnng188n41dh4n5lc21qcycvzryz";
+       setupHaskellDepends = [
+         base Cabal gi-gio gi-glib gi-gobject haskell-gi
+       ];
+       libraryHaskellDepends = [
+         base bytestring containers gi-gio gi-glib gi-gobject haskell-gi
+         haskell-gi-base haskell-gi-overloading text transformers
+       ];
+       libraryPkgconfigDepends = [ networkmanager ];
+       description = "NM bindings";
+       license = lib.licenses.lgpl21Only;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {inherit (pkgs) networkmanager;};
+
   "gi-notify" = callPackage
     ({ mkDerivation, base, bytestring, Cabal, containers, gi-gdkpixbuf
      , gi-glib, gi-gobject, haskell-gi, haskell-gi-base
···
        pname = "ginger";
        version = "0.10.5.2";
        sha256 = "0nwcppbfxj3nvq3hm9gj8gh076399zkksj2k39nb9zdm8dws79sf";
+       revision = "1";
+       editedCabalFile = "1bfxyx32dnf4giw4pwanxab0dsca1m5sd3haffpp9snk9jicbafd";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
      }:
      mkDerivation {
        pname = "git-annex";
-       version = "10.20241031";
-       sha256 = "14wjj9y1g9nkz6wnvadypvjnfs2z8gbvh3sk4lqkw8780pnaz3hc";
+       version = "10.20241202";
+       sha256 = "10z2mp1yxjbk7ny74w1qvw4f8qc1g2yg4gfr080p9i59xpx1hxg2";
        configureFlags = [
          "-fassistant" "-f-benchmark" "-fcrypton" "-fdbus" "-f-debuglocks"
          "-fmagicmime" "-fpairing" "-fproduction" "-ftorrentparser"
···
        broken = true;
      }) {inherit (pkgs) glib;};
 
+  "glib-stopgap_0_1_0_1" = callPackage
+    ({ mkDerivation, base, c-enum, glib, primitive, text }:
+     mkDerivation {
+       pname = "glib-stopgap";
+       version = "0.1.0.1";
+       sha256 = "11sqci1y1vp55zyga2fjhgrn4i95xb3llmvsqg5f3sc9sf1pqswp";
+       libraryHaskellDepends = [ base c-enum primitive text ];
+       libraryPkgconfigDepends = [ glib ];
+       testHaskellDepends = [ base c-enum primitive text ];
+       description = "Stopgap package of binding for GLib";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {inherit (pkgs) glib;};
+
   "glicko" = callPackage
     ({ mkDerivation, base, containers, data-default, deepseq, hspec
      , parallel, statistics
···
      }:
      mkDerivation {
        pname = "globus";
-       version = "0.1.2";
-       sha256 = "19fyflk5q0a888y8b0lflc9pkmxjxv66x03na503w8k4wp8mc594";
+       version = "0.1.3";
+       sha256 = "1n2pn21hmmkf982q4gxjb7pli0ln1xc2056bnyy19l4gx4rmvp1x";
        libraryHaskellDepends = [
          aeson base bytestring effectful http-api-data http-types req tagged
          text
        ];
-       description = "GLOBUS Data Transfer";
+       description = "Globus Data Transfer";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        broken = true;
···
        pname = "gloss";
        version = "1.13.2.2";
        sha256 = "09yabwajjw6zsbs8p4hsmfz4a032i81d3vnia5f7rrzszbi9svdn";
-       revision = "1";
-       editedCabalFile = "04r9lhwxd8bhv7zri3cy5pqcn84ydkdn5pclqppb4dx35z11g871";
+       revision = "2";
+       editedCabalFile = "1vyh5y3znaazl0q6jmpji5a1pc97yn8wica0lql6yw1w0wq76iii";
        libraryHaskellDepends = [
          base bmp bytestring containers ghc-prim gloss-rendering GLUT OpenGL
        ];
···
        pname = "gloss-algorithms";
        version = "1.13.0.3";
        sha256 = "083rq6p5m0im380c6x0jc3hi59hk94z1nyj08hmvmb3vcszjxra5";
+       revision = "1";
+       editedCabalFile = "1crvnn54gxn0mr6rcy78xfw8msk9z25ncn8phll709y51ingn086";
        libraryHaskellDepends = [ base containers ghc-prim gloss ];
        description = "Data structures and algorithms for working with 2D graphics";
        license = lib.licenses.mit;
···
        pname = "gloss-rendering";
        version = "1.13.1.2";
        sha256 = "0zrdqh72gswyn27x43ifhy4q8m7hvmv24b5ki3hyra5yq74njlsm";
-       revision = "1";
-       editedCabalFile = "0ji8iaj2ldp5qkfrmz4ckh86vwdcq15w6499i9fpnhl0m47sl01g";
+       revision = "2";
+       editedCabalFile = "107mqdimasvv6vy2r16kk0cz3dqh98m9189q9hd10chk0r5k8ir0";
        libraryHaskellDepends = [
          base bmp bytestring containers GLUT OpenGL
        ];
···
      }:
      mkDerivation {
        pname = "gltf-codec";
-       version = "0.1.0.4";
-       sha256 = "1jzh6cdgpiq0lmcfnxkfnzywjv1ny058xsss0b1nrwxra6wcai6x";
-       revision = "1";
-       editedCabalFile = "0scl65y7lilbqq913qnha2kqy1zkcg5gs4734vlbkcwvzd01f8m2";
+       version = "0.1.0.5";
+       sha256 = "0z7hpnnnkx3b3bpxx01yr5kb21iimhisb7y55xzyb89h463w7fg7";
        libraryHaskellDepends = [
          aeson base base64-bytestring binary bytestring scientific text
          unordered-containers vector
···
          base containers convertible csv hinduce-associations-apriori
        version = "0.2.2.1";
          base containers convertible csv hinduce-associations-apriori
+       revision = "1";
+       editedCabalFile = "1ghf2j3hn0gfb4abbb8nk95wfwqx9sn349pchfvad0h07qv2ligf";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          base containers convertible csv hinduce-associations-apriori
        version = "0.5";
          base containers convertible csv hinduce-associations-apriori
+       revision = "1";
+       editedCabalFile = "0qx4k19y0n9hvcjjgmklsnq79z3bjahskrc2cv44h68gc5dzy9gj";
        libraryHaskellDepends = [
          base containers convertible csv hinduce-associations-apriori
          base containers convertible csv hinduce-associations-apriori
···
      }:
      mkDerivation {
          base containers convertible csv hinduce-associations-apriori
-         base containers convertible csv hinduce-associations-apriori
-         base containers convertible csv hinduce-associations-apriori
+       version = "0.1.0.162";
+       sha256 = "0bmxzkfgdhvvpbgbjbav9klgj81fhn33dhxipiv2acbyq0dpwk6c";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base containers convertible csv hinduce-associations-apriori
···
        ];
          base containers convertible csv hinduce-associations-apriori
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
          base containers convertible csv hinduce-associations-apriori
···
      }:
      mkDerivation {
          base containers convertible csv hinduce-associations-apriori
-       version = "0.1.0.8";
-         base containers convertible csv hinduce-associations-apriori
+       version = "0.1.0.19";
+       sha256 = "1xg400xmp8xxmca9j8wkk4jkd97xfmjrirp1dr6zdmqk46mvrfvl";
          base containers convertible csv hinduce-associations-apriori
          base containers convertible csv hinduce-associations-apriori
          base containers convertible csv hinduce-associations-apriori
···
      }:
      mkDerivation {
          base containers convertible csv hinduce-associations-apriori
-         base containers convertible csv hinduce-associations-apriori
-         base containers convertible csv hinduce-associations-apriori
+       version = "0.1.0.68";
+       sha256 = "0dhr34f8kg2s9wy7pifnfvrz6i1pns191smh1zgna2hdpy9dm8ff";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base containers convertible csv hinduce-associations-apriori
···
        ];
          base containers convertible csv hinduce-associations-apriori
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
          base containers convertible csv hinduce-associations-apriori
···
      }:
      mkDerivation {
          base containers convertible csv hinduce-associations-apriori
-       version = "0.7.1";
-         base containers convertible csv hinduce-associations-apriori
+       version = "0.7.2";
+       sha256 = "1lmi0rfzrs8jncfrqkdcf6x2ysd1j78wbgiap1dvk8ldp7qd1i95";
        isLibrary = true;
        isExecutable = true;
        setupHaskellDepends = [ base Cabal cabal-doctest ];
···
        license = "MPL-2.0 AND BSD-3-Clause";
      }) {};
 
-         base containers convertible csv hinduce-associations-apriori
+  "graphql_1_5_0_0" = callPackage
          base containers convertible csv hinduce-associations-apriori
          base containers convertible csv hinduce-associations-apriori
-         base containers convertible csv hinduce-associations-apriori
-     , transformers, unordered-containers, vector
+     , parser-combinators, QuickCheck, text, transformers
+     , unordered-containers, vector
      }:
      mkDerivation {
          base containers convertible csv hinduce-associations-apriori
-       version = "1.4.0.0";
-         base containers convertible csv hinduce-associations-apriori
+       version = "1.5.0.0";
+       sha256 = "1vgvrk225fgn94cmdk5yy6a6d8p10igwx1fbvll94x4izkq57h9y";
        libraryHaskellDepends = [
          base containers convertible csv hinduce-associations-apriori
-         template-haskell text transformers unordered-containers vector
+         text transformers unordered-containers vector
        ];
        testHaskellDepends = [
          base containers convertible csv hinduce-associations-apriori
···
      }:
      mkDerivation {
          base containers convertible csv hinduce-associations-apriori
-         base containers convertible csv hinduce-associations-apriori
-         base containers convertible csv hinduce-associations-apriori
-       revision = "1";
-         base containers convertible csv hinduce-associations-apriori
+       version = "1.0.6.0";
+       sha256 = "1dm8wq9nyahjf15fx7v25i8jf9rfphl02nqlvf21gs7m0ljgn82k";
        libraryHaskellDepends = [
          base containers convertible csv hinduce-associations-apriori
          base containers convertible csv hinduce-associations-apriori
···
      }:
      mkDerivation {
          base containers convertible csv hinduce-associations-apriori
-       version = "1.0.0.2";
-         base containers convertible csv hinduce-associations-apriori
+       version = "1.0.0.3";
+       sha256 = "08kxk1rmahq61iynn47896rw61wc0gnp8js7gkh43lh4lay5q2rz";
        libraryHaskellDepends = [
          base containers convertible csv hinduce-associations-apriori
          base containers convertible csv hinduce-associations-apriori
···
      }) {};
 
          base containers convertible csv hinduce-associations-apriori
-         base containers convertible csv hinduce-associations-apriori
-         base containers convertible csv hinduce-associations-apriori
-         base containers convertible csv hinduce-associations-apriori
-         base containers convertible csv hinduce-associations-apriori
-         base containers convertible csv hinduce-associations-apriori
-         base containers convertible csv hinduce-associations-apriori
+    ({ mkDerivation, array, async, atomic-primops, base, binary, bytes
+     , bytestring, cereal, cereal-text, containers, deepseq, doctest
+     , generic-deriving, hashable, HUnit, libBF, loch-th, mtl, parallel
+     , prettyprinter, QuickCheck, sbv, stm, template-haskell
+     , test-framework, test-framework-hunit, test-framework-quickcheck2
+     , text, th-abstraction, th-compat, th-lift-instances, transformers
+     , unordered-containers, vector
      }:
      mkDerivation {
          base containers convertible csv hinduce-associations-apriori
-       version = "0.8.0.0";
-         base containers convertible csv hinduce-associations-apriori
+       version = "0.10.0.0";
+       sha256 = "0sy54dwd48skqx4vjwnb0665i4pdp736gb7f37c7nq1372y89wmr";
        libraryHaskellDepends = [
-         base containers convertible csv hinduce-associations-apriori
-         base containers convertible csv hinduce-associations-apriori
-         base containers convertible csv hinduce-associations-apriori
-         base containers convertible csv hinduce-associations-apriori
+         array async atomic-primops base binary bytes bytestring cereal
+         cereal-text containers deepseq generic-deriving hashable libBF
+         loch-th mtl parallel prettyprinter QuickCheck sbv stm
+         template-haskell text th-abstraction th-compat th-lift-instances
+         transformers unordered-containers vector
        ];
        testHaskellDepends = [
-         base containers convertible csv hinduce-associations-apriori
-         base containers convertible csv hinduce-associations-apriori
-         base containers convertible csv hinduce-associations-apriori
-         test-framework test-framework-hunit test-framework-quickcheck2 text
-         base containers convertible csv hinduce-associations-apriori
-         unordered-containers
+         array async atomic-primops base binary bytes bytestring cereal
+         cereal-text containers deepseq doctest generic-deriving hashable
+         HUnit libBF loch-th mtl parallel prettyprinter QuickCheck sbv stm
+         template-haskell test-framework test-framework-hunit
+         test-framework-quickcheck2 text th-abstraction th-compat
+         th-lift-instances transformers unordered-containers vector
        ];
          base containers convertible csv hinduce-associations-apriori
        license = lib.licenses.bsd3;
···
        broken = true;
      }) {};
 
+  "hackage-revdeps" = callPackage
+    ({ mkDerivation, alfred-margaret, ansi-terminal, base, bytestring
+     , Cabal, cabal-install-parsers, containers, filepath
+     , optparse-applicative, tar, text, time
+     }:
+     mkDerivation {
+       pname = "hackage-revdeps";
+       version = "0.1";
+       sha256 = "1rc6k7cjcc581cx7nx7q0p5qdfzpc010bacx4w524j6bw1qb2kp1";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         alfred-margaret base bytestring Cabal containers filepath tar text
+         time
+       ];
+       executableHaskellDepends = [
+         ansi-terminal base bytestring Cabal cabal-install-parsers
+         containers optparse-applicative time
+       ];
+       description = "List Hackage reverse dependencies";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "hackage-security" = callPackage
     ({ mkDerivation, aeson, base, base16-bytestring, base64-bytestring
      , bytestring, Cabal, Cabal-syntax, containers, cryptohash-sha256
···
        pname = "hackernews";
        version = "1.4.0.0";
        sha256 = "0ilj91vjnsfdlzhjh35nqrr3c1z7p6qfabvk3xdz6iqzmpcq3ys8";
+       revision = "1";
+       editedCabalFile = "11idxsl6k8v5g4sw3li1lsdcw08irydmxqg6s4cd8m60a5amxcqi";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "hackport";
-       version = "0.8.5.1";
-       sha256 = "0kbrpj38jkrgvha2xp3q4vdf9dnxzmmc3zhjrnqkibl17xg4cz43";
+       version = "0.9.0.0";
+       sha256 = "0r2qr9qgx9dailqy0ja1v0wki6csjyqbsndnsxggmz53axvrfv1w";
        isLibrary = false;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "hakyll";
        version = "4.16.3.0";
        sha256 = "1m6kr9ph3ja3y2b6j1i2rk349v8ikqwjjj1z0my6p5ld77abz8qk";
+       revision = "1";
+       editedCabalFile = "0k38b74zm0a9f5k72xrb3gqnm88sf44831r60j9a86k41283bfkf";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        maintainers = [ lib.maintainers.erictapen ];
      }) {inherit (pkgs) util-linux;};
 
+  "hakyll_4_16_4_0" = callPackage
+    ({ mkDerivation, aeson, base, binary, blaze-html, bytestring
+     , containers, data-default, deepseq, directory, file-embed
+     , filepath, fsnotify, hashable, http-conduit, http-types, lrucache
+     , mtl, network-uri, optparse-applicative, pandoc, parsec, process
+     , QuickCheck, random, regex-tdfa, resourcet, scientific, tagsoup
+     , tasty, tasty-golden, tasty-hunit, tasty-quickcheck
+     , template-haskell, text, time, time-locale-compat, util-linux
+     , vector, wai, wai-app-static, warp, yaml
+     }:
+     mkDerivation {
+       pname = "hakyll";
+       version = "4.16.4.0";
+       sha256 = "1vc39mvnpjarvciji39i7zz109m9wv1w40rwhq4jx2sf2cf7kpr8";
+       isLibrary = true;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         aeson base binary blaze-html bytestring containers data-default
+         deepseq directory file-embed filepath fsnotify hashable
+         http-conduit http-types lrucache mtl network-uri
+         optparse-applicative pandoc parsec process random regex-tdfa
+         resourcet scientific tagsoup template-haskell text time
+         time-locale-compat vector wai wai-app-static warp yaml
+       ];
+       executableHaskellDepends = [ base directory filepath ];
+       testHaskellDepends = [
+         aeson base bytestring containers filepath pandoc QuickCheck tagsoup
+         tasty tasty-golden tasty-hunit tasty-quickcheck yaml
+       ];
+       testToolDepends = [ util-linux ];
+       description = "A static website compiler library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "hakyll-init";
+       maintainers = [ lib.maintainers.erictapen ];
+     }) {inherit (pkgs) util-linux;};
+
   "hakyll-R" = callPackage
     ({ mkDerivation, base, directory, filepath, hakyll, pandoc, process
      }:
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "half_0_3_2" = callPackage
+    ({ mkDerivation, base, binary, bytestring, deepseq, QuickCheck
+     , template-haskell, test-framework, test-framework-quickcheck2
+     }:
+     mkDerivation {
+       pname = "half";
+       version = "0.3.2";
+       sha256 = "0f7hgnfy8qpjsjv78gk01di3riwfbrb961msn19qmsplnsgjx68r";
+       libraryHaskellDepends = [ base binary deepseq template-haskell ];
+       testHaskellDepends = [
+         base binary bytestring QuickCheck test-framework
+         test-framework-quickcheck2
+       ];
+       description = "Half-precision floating-point";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "half-space" = callPackage
     ({ mkDerivation, base, call-stack, equational-reasoning
      , manifolds-core, vector-space
···
        mainProgram = "happy";
      }) {};
 
-  "happy_2_1_2" = callPackage
+  "happy_2_1_3" = callPackage
     ({ mkDerivation, array, base, containers, happy-lib, mtl, process
      }:
      mkDerivation {
        pname = "happy";
-       version = "2.1.2";
-       sha256 = "0d8cpm1h7hnap55a7lv7k0cprg80cm1ryqwm8qbq2wxiwkjnap3p";
+       version = "2.1.3";
+       sha256 = "0jrcphpw026gbq2wlj2hn3z6qrbh5313xx4a772xr109zn9s00nd";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ array base containers happy-lib mtl ];
···
     ({ mkDerivation, array, base, containers, mtl, transformers }:
      mkDerivation {
        pname = "happy-lib";
-       version = "2.1.2";
-       sha256 = "1nj94l70y34k8k7hlhh7vrh2sl0n23rs2fbhpb10dms95cs94hih";
+       version = "2.1.3";
+       sha256 = "1gbyqdzw46ydxzahg1s2sqny0my36raxri4w5aj00iw4y6m6arsx";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [ array base containers mtl transformers ];
        doHaddock = false;
···
        pname = "hashable";
        version = "1.5.0.0";
        sha256 = "0snvrnh9q4arjwk6hdvb4zwb22sh7rlgvr9px7bnqpys3273m2z5";
+       revision = "1";
+       editedCabalFile = "1vsq3wv397lp208p7zs8fplxdix4jmv688dj4ych4983prn188rg";
        libraryHaskellDepends = [
          base bytestring containers deepseq filepath ghc-bignum ghc-prim
          os-string text
···
        pname = "hashtables";
        version = "1.3.1";
        sha256 = "1hsrihk948xfpy14qrhar50b41kp60i1rx8bkadjg1xb4bml0gbg";
+       revision = "1";
+       editedCabalFile = "1xskh7v0wnnrm1gc6haihahq4gqrk38bzsf2v35aj0gr16sa9g3i";
        libraryHaskellDepends = [
          base ghc-prim hashable primitive vector
        ];
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "hashtables_1_4_1" = callPackage
+    ({ mkDerivation, base, ghc-prim, hashable, mwc-random, primitive
+     , QuickCheck, tasty, tasty-hunit, tasty-quickcheck, vector
+     }:
+     mkDerivation {
+       pname = "hashtables";
+       version = "1.4.1";
+       sha256 = "0424hw6n024mcx59swga8ylm34brff0d4v106922cav9g55ka6ah";
+       libraryHaskellDepends = [
+         base ghc-prim hashable primitive vector
+       ];
+       testHaskellDepends = [
+         base ghc-prim hashable mwc-random primitive QuickCheck tasty
+         tasty-hunit tasty-quickcheck vector
+       ];
+       description = "Mutable hash tables in the ST monad";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "hashtables-plus" = callPackage
     ({ mkDerivation, base, criterion-plus, deepseq, hashable
      , hashtables, lens, loch-th, mtl, mwc-random, placeholders
···
        license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) glib; inherit (pkgs) gobject-introspection;};
 
+  "haskell-gi_0_26_13" = 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.13";
+       sha256 = "19md3c83arqk6aaxjxwicf1vldsalyby8cfh6yvynvq25f8apwin";
+       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, base, bytestring, containers, glib, text }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "haskoin-store";
-       version = "1.5.13";
-       sha256 = "1bkwv3f494kqz9a7mmry831mfp3dkhz1zv209lgnl5k8kgf6a22z";
+       version = "1.5.14";
+       sha256 = "1829p5mzgi6zq19h88dcs2cbsafvp7bg7hm3syf444yra9x9brps";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "hasktorch" = callPackage
-    ({ mkDerivation, backprop, base, dimensions, generic-lens
-     , ghc-typelits-natnormalise, hasktorch-ffi-th, hasktorch-ffi-thc
-     , hasktorch-indef, hasktorch-signatures-partial, hasktorch-types-th
-     , hasktorch-types-thc, hspec, microlens-platform, monad-loops, mtl
-     , QuickCheck, safe-exceptions, singletons, text, time, transformers
+    ({ mkDerivation, array, async, base, bytestring, Cabal
+     , cabal-doctest, cassava, constraints, containers, criterion
+     , data-default-class, deepseq, directory, doctest, finite-typelits
+     , foldl, ghc-typelits-extra, ghc-typelits-knownnat
+     , ghc-typelits-natnormalise, half, hmatrix, hspec, inline-c
+     , inline-c-cpp, JuicyPixels, lens-family-core, libtorch-ffi
+     , libtorch-ffi-helper, lifted-async, matrix, megaparsec
+     , monad-control, mtl, mwc-random, pipes, pipes-bytestring
+     , pipes-concurrency, pipes-csv, pipes-group, pipes-safe, primitive
+     , QuickCheck, random, reflection, safe-exceptions, split, stm
+     , template-haskell, transformers-base, vector, vector-sized, weigh
+     , zlib
      }:
      mkDerivation {
        pname = "hasktorch";
-       version = "0.0.1.0";
-       sha256 = "10lmas8x4nk7z7phxj1a2bhzjz7qhbmy472f9j584mbagvklfkmc";
-       isLibrary = true;
-       isExecutable = true;
+       version = "0.2.0.1";
+       sha256 = "0clwhcy72v3p4y4bv4wr6688f5mzxzhxh941j8i3km0x40cyynvw";
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
-         base dimensions hasktorch-ffi-th hasktorch-ffi-thc hasktorch-indef
-         hasktorch-signatures-partial hasktorch-types-th hasktorch-types-thc
-         safe-exceptions singletons text
+         array async base bytestring cassava constraints containers
+         data-default-class finite-typelits foldl ghc-typelits-extra
+         ghc-typelits-knownnat ghc-typelits-natnormalise half inline-c
+         JuicyPixels lens-family-core libtorch-ffi libtorch-ffi-helper
+         lifted-async megaparsec monad-control mtl pipes pipes-bytestring
+         pipes-concurrency pipes-csv pipes-group pipes-safe random
+         reflection safe-exceptions stm template-haskell transformers-base
+         vector vector-sized zlib
        ];
-       executableHaskellDepends = [ base ];
        testHaskellDepends = [
-         backprop base dimensions generic-lens ghc-typelits-natnormalise
-         hspec microlens-platform monad-loops mtl QuickCheck singletons time
-         transformers
+         async base bytestring data-default-class directory doctest
+         finite-typelits ghc-typelits-extra ghc-typelits-knownnat
+         ghc-typelits-natnormalise half hspec inline-c inline-c-cpp
+         JuicyPixels lens-family-core libtorch-ffi mtl pipes QuickCheck
+         random reflection safe-exceptions stm vector vector-sized zlib
        ];
-       doHaddock = false;
-       description = "Torch for tensors and neural networks in Haskell";
+       benchmarkHaskellDepends = [
+         base criterion deepseq hmatrix libtorch-ffi matrix mwc-random
+         primitive split vector weigh
+       ];
+       description = "Haskell bindings to libtorch, supporting both typed and untyped tensors";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
      }) {};
···
        pname = "haskyapi";
        version = "0.0.0.2";
        sha256 = "1s5krzzmrl8p97xg8p1dimijqmyjbrdfm4i0dpp7jiipj2hzvqyq";
+       revision = "1";
+       editedCabalFile = "0lglfby1cpaplq53cvsm3n6crdskfm8ck33rwkm6nbzylhszm0f0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
 
   "hasmtlib" = callPackage
     ({ mkDerivation, array, attoparsec, base, bitvec, bytestring
-     , containers, data-default, dependent-map, finite-typelits, lens
-     , lifted-base, monad-control, mtl, smtlib-backends
-     , smtlib-backends-process, some, text, unordered-containers
-     , utf8-string, vector-sized
+     , constrained-some, containers, data-default, dependent-map
+     , finite-typelits, lens, lifted-base, monad-control, mtl
+     , smtlib-backends, smtlib-backends-process, some, text
+     , unordered-containers, utf8-string, vector-sized
      }:
      mkDerivation {
        pname = "hasmtlib";
-       version = "2.7.1";
-       sha256 = "0bp183vdhc93sb8nhph3mvcl3v6f7x7hkqbj6ihmrgv2ipvykha1";
+       version = "2.8.1";
+       sha256 = "0ycx0rcsb8fj5ca99m6dq6zp77nfgpr7fj0p63vzd0a3q5hpb3bw";
        libraryHaskellDepends = [
-         array attoparsec base bitvec bytestring containers data-default
-         dependent-map finite-typelits lens lifted-base monad-control mtl
-         smtlib-backends smtlib-backends-process some text
+         array attoparsec base bitvec bytestring constrained-some containers
+         data-default dependent-map finite-typelits lens lifted-base
+         monad-control mtl smtlib-backends smtlib-backends-process some text
          unordered-containers utf8-string vector-sized
        ];
        description = "A monad for interfacing with external SMT solvers";
···
        license = lib.licenses.mit;
      }) {};
 
-  "hasql_1_8_1_1" = callPackage
+  "hasql_1_8_1_4" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, bytestring
      , bytestring-strict-builder, contravariant, contravariant-extras
      , criterion, dlist, hashable, hashtables, hspec, hspec-discover
···
      }:
      mkDerivation {
        pname = "hasql";
-       version = "1.8.1.1";
-       sha256 = "11k4c4rm77j575nzvizmb0ym1zzjrhbrflayzlb7yjkvjn4m2hww";
+       version = "1.8.1.4";
+       sha256 = "0m2micp6g9kc1dq7sy3j8lba5iw7p0zn669613bs3an3ni4a7f03";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring bytestring-strict-builder
          contravariant dlist hashable hashtables iproute mtl
···
        pname = "hasql-interpolate";
        version = "1.0.1.0";
        sha256 = "1i323wc17bw41rpdvn7kk46ipx42v0q0zp27662xgq3khbz52bsf";
+       revision = "1";
+       editedCabalFile = "0dl8wmjv2xsrnbsh297hpj4c4z8k035s8dpmd71rd7cgbrk4h653";
        libraryHaskellDepends = [
          aeson array base bytestring containers haskell-src-meta hasql
          iproute megaparsec mtl scientific template-haskell text time
···
        license = lib.licenses.mit;
      }) {};
 
-  "hasql-pool_1_2_0_2" = callPackage
+  "hasql-pool_1_2_0_3" = callPackage
     ({ mkDerivation, async, base, bytestring, hasql, hspec, random
      , rerebase, stm, text, time, uuid
      }:
      mkDerivation {
        pname = "hasql-pool";
-       version = "1.2.0.2";
-       sha256 = "1myasw6zp3979bdkp642fh7b765wdbmwl2hbva9c2qlsa14agdrw";
+       version = "1.2.0.3";
+       sha256 = "1jjr5wmign12m05f7p3cssmd9qfindv3q9q37j28jk8y74lnqxvy";
        libraryHaskellDepends = [
          base bytestring hasql stm text time uuid
        ];
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "heaps_0_4_1" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "heaps";
+       version = "0.4.1";
+       sha256 = "10h3m98fjj114x3nffs0ajllc6z1dbb4g9804j8kq2rd79ka8qw7";
+       libraryHaskellDepends = [ base ];
+       description = "Asymptotically optimal Brodal/Okasaki heaps";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "heapsize" = callPackage
     ({ mkDerivation, base, criterion, deepseq, exceptions, ghc-heap
      , hashable, hashtables, primitive, transformers
···
     ({ mkDerivation, aeson, aeson-pretty, async, base, bytestring
      , deepseq, Diff, directory, exceptions, filepath, hedgehog
      , http-conduit, lifted-async, lifted-base, mmorph, monad-control
-     , mtl, network, process, resourcet, stm, tar, tasty, tasty-discover
-     , tasty-hedgehog, temporary, text, time, transformers
-     , transformers-base, unliftio, yaml, zlib
+     , mtl, network, process, resourcet, retry, stm, tar, tasty
+     , tasty-discover, tasty-hedgehog, temporary, text, time
+     , transformers, transformers-base, unliftio, yaml, zlib
      }:
      mkDerivation {
        pname = "hedgehog-extras";
-       version = "0.6.5.0";
-       sha256 = "1d0df2jiph7x7kwm4dvaiiwn460my27kj8mlk4s2glxfrxxw3qzw";
+       version = "0.6.5.1";
+       sha256 = "05fphkd4h1npnab3l2vgc8m1l1jlgjs1apifw5j6d50a2nwkvlp4";
        libraryHaskellDepends = [
          aeson aeson-pretty async base bytestring deepseq Diff directory
          exceptions filepath hedgehog http-conduit lifted-async lifted-base
-         mmorph monad-control mtl network process resourcet stm tar
+         mmorph monad-control mtl network process resourcet retry stm tar
          temporary text time transformers transformers-base unliftio yaml
          zlib
        ];
···
      }:
      mkDerivation {
        pname = "hercules-ci-agent";
-       version = "0.10.4";
-       sha256 = "1bslpq4x0kp6k5x7jgcv8hkigp64p5gjgq6d3g60ig0pd35ribwd";
+       version = "0.10.5";
+       sha256 = "14g5q032f6lnssc8mf01kzcl1gysirj8a6fbcxxpvjpxvdq2675b";
        isLibrary = true;
        isExecutable = true;
        setupHaskellDepends = [ base Cabal cabal-pkg-config-version-hook ];
···
      }:
      mkDerivation {
        pname = "hercules-ci-cnix-expr";
-       version = "0.3.6.4";
-       sha256 = "0l5d4mirf8843svhamq2zwga46y0a4wr1myi3g46l92spljwribc";
+       version = "0.3.6.5";
+       sha256 = "1pxnvjp38y2yhl4pf0hrk00vmq0lw7k7yiy0i1rymdjvh58x9nqa";
        setupHaskellDepends = [ base Cabal cabal-pkg-config-version-hook ];
        libraryHaskellDepends = [
          aeson base bytestring conduit containers directory exceptions
···
      }:
      mkDerivation {
        pname = "hercules-ci-cnix-store";
-       version = "0.3.6.0";
-       sha256 = "02l5bdqxz5gc2zam3n69nbrhny3hkd6pk37sw5qls9wkf5bm3ah7";
+       version = "0.3.6.1";
+       sha256 = "0phdy6073fz7dfl87xiwryjl5z17s8r2aapjg8c8675wkcgx5qrm";
        setupHaskellDepends = [ base Cabal cabal-pkg-config-version-hook ];
        libraryHaskellDepends = [
          base bytestring conduit containers inline-c inline-c-cpp protolude
···
      }) {};
 
   "hevm" = callPackage
-    ({ mkDerivation, abstract-par, aeson, aeson-optics, array, async
-     , base, base16, binary, brick, bytestring, cereal, containers
-     , cryptonite, data-dword, Decimal, deepseq, directory, exceptions
-     , filemanip, filepath, filepattern, free, githash, gmp, haskeline
-     , here, HUnit, libff, megaparsec, memory, MissingH, monad-par, mtl
-     , multiset, operational, optics-core, optics-extra, optics-th
-     , optparse-generic, pretty-hex, process, QuickCheck
-     , quickcheck-instances, quickcheck-text, regex, regex-tdfa
-     , restless-git, rosezipper, scientific, secp256k1, smt2-parser
-     , spawn, spool, stm, system-cxx-std-lib, tasty, tasty-bench
-     , tasty-expected-failure, tasty-hunit, tasty-quickcheck, temporary
-     , text, time, transformers, tree-view, unliftio-core
-     , unordered-containers, vector, vty, witch, witherable, word-wrap
-     , wreq
+    ({ mkDerivation, aeson, aeson-optics, async, base, base16, binary
+     , bytestring, cereal, containers, cryptonite, data-dword, Decimal
+     , directory, exceptions, extra, filemanip, filepath, filepattern
+     , githash, gmp, here, libff, megaparsec, memory, mtl, operational
+     , optics-core, optics-extra, optics-th, optparse-generic
+     , pretty-hex, process, QuickCheck, quickcheck-instances, regex
+     , regex-tdfa, rosezipper, scientific, secp256k1, smt2-parser, spawn
+     , split, spool, stm, system-cxx-std-lib, tasty, tasty-bench
+     , tasty-expected-failure, tasty-hunit, tasty-quickcheck
+     , template-haskell, temporary, text, time, transformers, tree-view
+     , unliftio-core, unordered-containers, vector, witch, with-utf8
+     , witherable, wreq
      }:
      mkDerivation {
        pname = "hevm";
-       version = "0.53.0";
-       sha256 = "1kc4sjr4bzp4crfsn65dg9dd4myn1fz1dl54vi391cspxacsm0c2";
+       version = "0.54.2";
+       sha256 = "0hbivn9008wml61bm8dchqwywc8fk0jmb4ffr18ks2qsscf2kph7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         abstract-par aeson aeson-optics array async base base16 binary
-         brick bytestring cereal containers cryptonite data-dword Decimal
-         deepseq directory exceptions filemanip filepath filepattern free
-         haskeline here HUnit megaparsec memory MissingH monad-par mtl
-         multiset operational optics-core optics-extra optics-th
-         optparse-generic pretty-hex process QuickCheck quickcheck-instances
-         quickcheck-text regex regex-tdfa restless-git rosezipper scientific
-         smt2-parser spawn spool stm system-cxx-std-lib tasty tasty-bench
-         tasty-expected-failure tasty-hunit tasty-quickcheck temporary text
-         time transformers tree-view unliftio-core unordered-containers
-         vector vty witch witherable word-wrap wreq
+         aeson aeson-optics async base base16 binary bytestring cereal
+         containers cryptonite data-dword Decimal directory exceptions extra
+         filemanip filepath filepattern here megaparsec memory mtl
+         operational optics-core optics-extra optics-th optparse-generic
+         pretty-hex process QuickCheck quickcheck-instances regex-tdfa
+         rosezipper scientific smt2-parser spawn split spool stm
+         system-cxx-std-lib tasty tasty-expected-failure tasty-hunit
+         tasty-quickcheck template-haskell temporary text transformers
+         tree-view unliftio-core unordered-containers vector witch
+         witherable wreq
        ];
        librarySystemDepends = [ gmp libff secp256k1 ];
        executableHaskellDepends = [
-         aeson async base base16 binary brick bytestring containers
-         cryptonite data-dword deepseq directory filepath free githash
-         memory mtl operational optics-core optparse-generic process
-         QuickCheck quickcheck-text regex-tdfa spawn stm temporary text
-         unliftio-core unordered-containers vector vty witch
+         base bytestring data-dword directory filepath githash optics-core
+         optparse-generic text unliftio-core witch with-utf8
        ];
        testHaskellDepends = [
-         aeson array base base16 binary bytestring containers data-dword
-         directory exceptions filemanip filepath here HUnit MissingH mtl
-         operational optics-core optics-extra process QuickCheck
-         quickcheck-instances regex regex-tdfa smt2-parser spawn stm tasty
-         tasty-bench tasty-expected-failure tasty-hunit tasty-quickcheck
+         aeson base base16 binary bytestring containers data-dword directory
+         exceptions extra filemanip filepath here mtl operational
+         optics-core optics-extra process QuickCheck quickcheck-instances
+         regex tasty tasty-expected-failure tasty-hunit tasty-quickcheck
          temporary text time unliftio-core vector witch witherable
        ];
        benchmarkHaskellDepends = [
-         base bytestring containers filemanip filepath here mtl tasty
-         tasty-bench text unliftio-core
+         base bytestring containers filemanip filepath tasty tasty-bench
+         text unliftio-core
        ];
        doHaddock = false;
        description = "Symbolic EVM Evaluator";
···
        mainProgram = "hindent";
      }) {};
 
-  "hindent_6_2_0" = callPackage
+  "hindent_6_2_1" = callPackage
     ({ mkDerivation, async, base, bytestring, Cabal, containers
      , criterion, deepseq, Diff, directory, exceptions, filepath
      , ghc-lib-parser, ghc-lib-parser-ex, hspec, monad-loops, mtl
···
      }:
      mkDerivation {
        pname = "hindent";
-       version = "6.2.0";
-       sha256 = "05bpsp11cka1l6gmbvsp0fgya8ydx2lh38d3wgq309jf2vmri800";
+       version = "6.2.1";
+       sha256 = "0vhhbqlf4j17xqwln40z29vsv3r1rb0gd596skd1wkgljm124wrp";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        ];
      }) {};
 
-  "hledger_1_40" = callPackage
+  "hledger_1_41" = callPackage
     ({ mkDerivation, aeson, ansi-terminal, base, bytestring, cmdargs
      , containers, data-default, Decimal, Diff, directory, extra
      , filepath, githash, hashable, haskeline, hledger-lib, lucid
-     , math-functions, megaparsec, microlens, mtl, process, regex-tdfa
-     , safe, shakespeare, split, tabular, tasty, temporary, terminfo
-     , text, text-ansi, time, timeit, transformers, unordered-containers
-     , utf8-string, utility-ht, wizards
+     , math-functions, megaparsec, microlens, modern-uri, mtl, process
+     , regex-tdfa, safe, shakespeare, split, tabular, tasty, temporary
+     , terminfo, text, text-ansi, time, timeit, transformers
+     , unordered-containers, utf8-string, utility-ht, wizards
      }:
      mkDerivation {
        pname = "hledger";
-       version = "1.40";
-       sha256 = "189lbp9dmg9kxik5zg7nk6jm8h5p8hpq1z01zsj8c29x8b8md7b7";
+       version = "1.41";
+       sha256 = "0ijl7yr6svnwvk6sxm4nq35crksla8ffn3mg2dz8ai9a9gycaslk";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson ansi-terminal base bytestring cmdargs containers data-default
          Decimal Diff directory extra filepath githash hashable haskeline
-         hledger-lib lucid math-functions megaparsec microlens mtl process
-         regex-tdfa safe shakespeare split tabular tasty temporary terminfo
-         text text-ansi time timeit transformers unordered-containers
-         utf8-string utility-ht wizards
+         hledger-lib lucid math-functions megaparsec microlens modern-uri
+         mtl process regex-tdfa safe shakespeare split tabular tasty
+         temporary terminfo text text-ansi time timeit transformers
+         unordered-containers utf8-string utility-ht wizards
        ];
        executableHaskellDepends = [
          aeson ansi-terminal base bytestring cmdargs containers data-default
···
        pname = "hledger-iadd";
        version = "1.3.21";
        sha256 = "00x0vbfp08kqs1nbknndk9h56hcidf6xnrk0ldz45dvjrmgcv3w2";
-       revision = "2";
-       editedCabalFile = "1fzwkbknyi003ysrmlqpdd6qq6bnqdgyznj7jzk0fx7dx5zrqrkm";
+       revision = "4";
+       editedCabalFile = "199ga3rcg7nbih9kywryn7apvgfnpd8m3fslf1arbwkkb2wqlaxd";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        maintainers = [ lib.maintainers.peti ];
      }) {};
 
+  "hledger-interest_1_6_7" = callPackage
+    ({ mkDerivation, base, Cabal, Decimal, hledger-lib, mtl, text, time
+     }:
+     mkDerivation {
+       pname = "hledger-interest";
+       version = "1.6.7";
+       sha256 = "1jirygghw82zi8z160j45qzfcj1l89vckqr7hrv78h3f3pim6np4";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         base Cabal Decimal hledger-lib mtl text time
+       ];
+       description = "computes interest for a given account";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "hledger-interest";
+       maintainers = [ lib.maintainers.peti ];
+     }) {};
+
   "hledger-irr" = callPackage
     ({ mkDerivation, base, Cabal, data-default-class, Decimal
      , hledger-lib, math-functions, text, time
···
        license = lib.licenses.gpl3Only;
      }) {};
 
-  "hledger-lib_1_40" = callPackage
+  "hledger-lib_1_41" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, array, base
-     , base-compat, blaze-markup, bytestring, call-stack, cassava
-     , cassava-megaparsec, cmdargs, colour, containers, data-default
-     , Decimal, deepseq, directory, doclayout, doctest, extra
-     , file-embed, filepath, Glob, hashtables, lucid, megaparsec
-     , microlens, microlens-th, mtl, pager, parser-combinators
-     , pretty-simple, regex-tdfa, safe, tabular, tasty, tasty-hunit
-     , template-haskell, terminal-size, text, text-ansi, time, timeit
-     , transformers, uglymemo, unordered-containers, utf8-string
+     , base-compat, blaze-html, blaze-markup, bytestring, call-stack
+     , cassava, cassava-megaparsec, cmdargs, colour, containers
+     , data-default, Decimal, deepseq, directory, doclayout, doctest
+     , extra, file-embed, filepath, Glob, hashtables, lucid, megaparsec
+     , microlens, microlens-th, mtl, parser-combinators, pretty-simple
+     , process, regex-tdfa, safe, tabular, tasty, tasty-hunit
+     , template-haskell, terminal-size, text, time, timeit, transformers
+     , uglymemo, unordered-containers, utf8-string
      }:
      mkDerivation {
        pname = "hledger-lib";
-       version = "1.40";
-       sha256 = "05kap7kgjlh3y7j6ld0jqih21ad7acxd9cv18h0gb7kbwn7qm8vi";
+       version = "1.41";
+       sha256 = "1lzqd1jfvgrnmf0jr48nxf779a8cskqd49ira9whb0k5dah4shqw";
        libraryHaskellDepends = [
-         aeson aeson-pretty ansi-terminal array base base-compat
+         aeson aeson-pretty ansi-terminal array base base-compat blaze-html
          blaze-markup bytestring call-stack cassava cassava-megaparsec
          cmdargs colour containers data-default Decimal deepseq directory
          doclayout extra file-embed filepath Glob hashtables lucid
-         megaparsec microlens microlens-th mtl pager parser-combinators
-         pretty-simple regex-tdfa safe tabular tasty tasty-hunit
-         template-haskell terminal-size text text-ansi time timeit
-         transformers uglymemo unordered-containers utf8-string
+         megaparsec microlens microlens-th mtl parser-combinators
+         pretty-simple process regex-tdfa safe tabular tasty tasty-hunit
+         template-haskell terminal-size text time timeit transformers
+         uglymemo unordered-containers utf8-string
        ];
        testHaskellDepends = [
-         aeson aeson-pretty ansi-terminal array base base-compat
+         aeson aeson-pretty ansi-terminal array base base-compat blaze-html
          blaze-markup bytestring call-stack cassava cassava-megaparsec
          cmdargs colour containers data-default Decimal deepseq directory
          doclayout doctest extra file-embed filepath Glob hashtables lucid
-         megaparsec microlens microlens-th mtl pager parser-combinators
-         pretty-simple regex-tdfa safe tabular tasty tasty-hunit
-         template-haskell terminal-size text text-ansi time timeit
-         transformers uglymemo unordered-containers utf8-string
+         megaparsec microlens microlens-th mtl parser-combinators
+         pretty-simple process regex-tdfa safe tabular tasty tasty-hunit
+         template-haskell terminal-size text time timeit transformers
+         uglymemo unordered-containers utf8-string
        ];
        description = "A library providing the core functionality of hledger";
        license = lib.licenses.gpl3Only;
···
        mainProgram = "hledger-stockquotes";
      }) {};
 
+  "hledger-stockquotes_0_1_3_2" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, cmdargs, containers
+     , directory, hedgehog, hledger-lib, raw-strings-qq, req, safe
+     , safe-exceptions, scientific, split, tasty, tasty-hedgehog
+     , tasty-hunit, text, time, unordered-containers, xdg-basedir, yaml
+     }:
+     mkDerivation {
+       pname = "hledger-stockquotes";
+       version = "0.1.3.2";
+       sha256 = "19iv3n8wg1glmapwj360a4vsfakvza8cgsb3wp8wz2mvcb8f271z";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base bytestring containers hledger-lib req safe scientific
+         split text time unordered-containers
+       ];
+       executableHaskellDepends = [
+         aeson base bytestring cmdargs containers directory raw-strings-qq
+         safe-exceptions text time xdg-basedir yaml
+       ];
+       testHaskellDepends = [
+         base hedgehog tasty tasty-hedgehog tasty-hunit
+       ];
+       description = "Generate HLedger Price Directives From Daily Stock Quotes";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "hledger-stockquotes";
+     }) {};
+
   "hledger-ui" = callPackage
     ({ mkDerivation, ansi-terminal, async, base, brick, cmdargs
      , containers, data-default, directory, doclayout, extra, filepath
···
        maintainers = [ lib.maintainers.maralorn ];
      }) {};
 
-  "hledger-ui_1_40" = callPackage
+  "hledger-ui_1_41" = callPackage
     ({ mkDerivation, ansi-terminal, async, base, brick, cmdargs
      , containers, data-default, directory, doclayout, extra, filepath
      , fsnotify, githash, hledger, hledger-lib, megaparsec, microlens
···
      }:
      mkDerivation {
        pname = "hledger-ui";
-       version = "1.40";
-       sha256 = "0rvijrnmkc21nllqcbkn6fh51ifp1n1p8qgmckfp5pngqg40vvnz";
+       version = "1.41";
+       sha256 = "01bzqx26ycz7xp4y3rvrglnf0dasr3b0yhhrmmfnp1x2h18hhsjz";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        maintainers = [ lib.maintainers.maralorn ];
      }) {};
 
-  "hledger-web_1_40" = callPackage
-    ({ mkDerivation, aeson, base, base64, blaze-html, blaze-markup
-     , bytestring, case-insensitive, clientsession, cmdargs, conduit
-     , conduit-extra, containers, data-default, Decimal, directory
-     , extra, filepath, githash, hjsmin, hledger, hledger-lib, hspec
-     , http-client, http-conduit, http-types, megaparsec, mtl, network
-     , safe, shakespeare, template-haskell, text, time, transformers
-     , unix-compat, unordered-containers, utf8-string, wai, wai-cors
-     , wai-extra, wai-handler-launch, warp, yaml, yesod, yesod-core
-     , yesod-form, yesod-static, yesod-test
+  "hledger-web_1_41" = callPackage
+    ({ mkDerivation, aeson, base, base-compat, base64, blaze-html
+     , blaze-markup, bytestring, case-insensitive, clientsession
+     , cmdargs, conduit, conduit-extra, containers, data-default
+     , Decimal, directory, extra, filepath, githash, hjsmin, hledger
+     , hledger-lib, hspec, http-client, http-conduit, http-types
+     , megaparsec, mtl, network, safe, shakespeare, template-haskell
+     , text, time, transformers, unix-compat, unordered-containers
+     , utf8-string, wai, wai-cors, wai-extra, wai-handler-launch, warp
+     , yaml, yesod, yesod-core, yesod-form, yesod-static, yesod-test
      }:
      mkDerivation {
        pname = "hledger-web";
-       version = "1.40";
-       sha256 = "1dsvsgdan7f8zc0z9x4zri2q6ccajvqpjpv18zj488ihknshiwgq";
+       version = "1.41";
+       sha256 = "0z9q8c6xfkz3i819v12ks21rb4r0c225ba1a6w0h3hk06a11dinw";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         aeson base base64 blaze-html blaze-markup bytestring
+         aeson base base-compat base64 blaze-html blaze-markup bytestring
          case-insensitive clientsession cmdargs conduit conduit-extra
          containers data-default Decimal directory extra filepath githash
          hjsmin hledger hledger-lib hspec http-client http-conduit
···
          wai wai-cors wai-extra wai-handler-launch warp yaml yesod
          yesod-core yesod-form yesod-static yesod-test
        ];
-       executableHaskellDepends = [ base ];
-       testHaskellDepends = [ base ];
+       executableHaskellDepends = [ base base-compat ];
+       testHaskellDepends = [ base base-compat ];
        description = "Web user interface for the hledger accounting system";
        license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
···
        license = lib.licenses.mit;
      }) {};
 
-  "hoauth2_2_14_0" = callPackage
+  "hoauth2_2_14_1" = callPackage
     ({ mkDerivation, aeson, base, base64, binary, bytestring
      , containers, crypton, data-default, exceptions, hspec
      , hspec-discover, http-conduit, http-types, memory, microlens, text
···
      }:
      mkDerivation {
        pname = "hoauth2";
-       version = "2.14.0";
-       sha256 = "1gbdb01iinhcfc91iw2ld4lpvmpcvy6d9r1zl5a58jg16z5v6j8k";
+       version = "2.14.1";
+       sha256 = "12hynfnmq4w64k2ip9vczx4x0xaas5b4cj3qjxrz2i7cnblkrldm";
        libraryHaskellDepends = [
          aeson base base64 binary bytestring containers crypton data-default
          exceptions http-conduit http-types memory microlens text
···
      }:
      mkDerivation {
        pname = "hoauth2-demo";
-       version = "1.12.0";
-       sha256 = "03nsjqpaz3b5809rhjc1bqjm84w8srfcbn6ncj42w6g74hb3lmab";
+       version = "1.12.1";
+       sha256 = "11dc846zcs3pxfa8nk0xl5csfma2yli23gp2j1mx8apcv1iihnj5";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        mainProgram = "hr";
      }) {};
 
+  "horizontal-rule_0_7_0_0" = callPackage
+    ({ mkDerivation, ansi-wl-pprint, array, base, constraints
+     , containers, data-default, exceptions, extra, monad-control, mtl
+     , optparse-applicative, stm, syb, tasty, tasty-hunit
+     , template-haskell, terminal-size, text, time, transformers-base
+     , unliftio
+     }:
+     mkDerivation {
+       pname = "horizontal-rule";
+       version = "0.7.0.0";
+       sha256 = "0s4hf7frj1gc41v83qk8fgdfn49msmvhcfw6vjklx6w7b6pkfx9x";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base terminal-size text ];
+       executableHaskellDepends = [
+         ansi-wl-pprint base optparse-applicative text time
+       ];
+       testHaskellDepends = [
+         array base constraints containers data-default exceptions extra
+         monad-control mtl stm syb tasty tasty-hunit template-haskell
+         transformers-base unliftio
+       ];
+       description = "horizontal rule for the terminal";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "hr";
+     }) {};
+
   "horname" = callPackage
     ({ mkDerivation, base, containers, megaparsec, optparse-applicative
      , text, these, uniplate, wl-pprint-text
···
        ];
        description = "Haskell Open Sound Control";
        license = lib.licenses.gpl3Only;
+     }) {};
+
+  "hosc_0_21" = callPackage
+    ({ mkDerivation, base, binary, blaze-builder, bytestring, network
+     , parsec, safe, time, transformers
+     }:
+     mkDerivation {
+       pname = "hosc";
+       version = "0.21";
+       sha256 = "1m54jnxxb4vb9kf82hadp7m0crfmk2j3mnmbdmls2c1lixyhcx98";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         base binary blaze-builder bytestring network parsec safe time
+         transformers
+       ];
+       description = "Haskell Open Sound Control";
+       license = lib.licenses.gpl3Only;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "hosc-json" = callPackage
···
          posix-escape text time typed-process unliftio unordered-containers
        ];
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "hotel";
      }) {};
 
···
        mainProgram = "hpc-lcov";
      }) {};
 
+  "hpc-lcov_1_2_0" = callPackage
+    ({ mkDerivation, aeson, base, containers, hpc, optparse-applicative
+     , path, path-io, process, tasty, tasty-discover, tasty-golden
+     , tasty-hunit, text, unordered-containers, yaml
+     }:
+     mkDerivation {
+       pname = "hpc-lcov";
+       version = "1.2.0";
+       sha256 = "1v4cacn1qwhrdr2szsgqfrghjs8jdwqnr5qvqh5qd3qcn3hc7l56";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base containers hpc ];
+       executableHaskellDepends = [
+         aeson base containers hpc optparse-applicative path path-io process
+         text unordered-containers yaml
+       ];
+       testHaskellDepends = [
+         base containers hpc tasty tasty-discover tasty-golden tasty-hunit
+       ];
+       testToolDepends = [ tasty-discover ];
+       description = "Convert HPC output into LCOV format";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "hpc-lcov";
+     }) {};
+
   "hpc-strobe" = callPackage
     ({ mkDerivation, base, filepath, hpc }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "hquantlib";
-       version = "0.0.5.1";
-       sha256 = "0fbmji48ry3adq9lfpxwfx2q064cbrav8wq2ykaqsszgq9yiysc8";
+       version = "0.0.5.2";
+       sha256 = "15hi9v31js5j3bj6xhjr4i8y0mj0rshh7fisvkw43qkhccrhznd2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          test-framework-quickcheck2
        ];
        description = "HQuantLib is a port of essencial parts of QuantLib to Haskell";
-       license = "LGPL";
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        mainProgram = "mctest";
      }) {};
···
     ({ mkDerivation, base, time }:
      mkDerivation {
        pname = "hquantlib-time";
-       version = "0.1.0";
-       sha256 = "1a526r49anxri1ms8zyhc4giiidiw5sd5qhpndz6gq3kax3jfja4";
+       version = "0.1.1";
+       sha256 = "06ixjf69aadb9lpcaqz4nsaznbzazp9ym02kkkxrg382zya47h68";
        libraryHaskellDepends = [ base time ];
        description = "HQuantLib Time is a business calendar functions extracted from HQuantLib";
-       license = lib.licenses.lgpl3Plus;
+       license = "LGPL";
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
 
   "hs-opentelemetry-api" = callPackage
     ({ mkDerivation, async, attoparsec, base, binary, bytestring
-     , charset, clock, containers, ghc-prim, hashable, hspec, http-types
-     , memory, mtl, template-haskell, text, thread-utils-context
-     , transformers, unliftio-core, unordered-containers, vault, vector
-     , vector-builder
+     , charset, clock, hashable, hspec, http-types, memory, mtl
+     , regex-tdfa, safe-exceptions, template-haskell, text
+     , thread-utils-context, transformers, unliftio-core
+     , unordered-containers, vault, vector, vector-builder
      }:
      mkDerivation {
        pname = "hs-opentelemetry-api";
-       version = "0.1.0.0";
-       sha256 = "1bi0qzlwn5k9x5j9lvv97m85ckmpvywigy3jajw2rxi8zi84v9s2";
+       version = "0.2.0.0";
+       sha256 = "0hz7qsdqxv63zaj8pihgm4d7bx665zzzlxihr671wbcfl29wik5n";
        libraryHaskellDepends = [
-         async attoparsec base binary bytestring charset clock containers
-         ghc-prim hashable http-types memory mtl template-haskell text
-         thread-utils-context transformers unliftio-core
+         async attoparsec base binary bytestring charset clock hashable
+         http-types memory mtl regex-tdfa safe-exceptions template-haskell
+         text thread-utils-context transformers unliftio-core
          unordered-containers vault vector vector-builder
        ];
        testHaskellDepends = [
-         async attoparsec base binary bytestring charset clock containers
-         ghc-prim hashable hspec http-types memory mtl template-haskell text
-         thread-utils-context transformers unliftio-core
-         unordered-containers vault vector vector-builder
+         base hspec mtl text unliftio-core unordered-containers vector
+         vector-builder
        ];
        description = "OpenTelemetry API for use by libraries for direct instrumentation or wrapper packages";
        license = lib.licenses.bsd3;
···
        ];
        description = "[synopsis]";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "hs-opentelemetry-exporter-handle" = callPackage
     ({ mkDerivation, base, hs-opentelemetry-api, text }:
      mkDerivation {
        pname = "hs-opentelemetry-exporter-handle";
-       version = "0.0.1.1";
-       sha256 = "11b89q6xm2kln4acib26g3bgkqiw3ilpf8vd88kch7zmgprhvccl";
+       version = "0.0.1.2";
+       sha256 = "180wf114b39sf0ajk4bb95cmj5wj5bkb9ycl64r4cz8rsxibkj4q";
        libraryHaskellDepends = [ base hs-opentelemetry-api text ];
-       testHaskellDepends = [ base hs-opentelemetry-api text ];
        license = lib.licenses.bsd3;
      }) {};
 
···
     ({ mkDerivation, async, base, hs-opentelemetry-api, unagi-chan }:
      mkDerivation {
        pname = "hs-opentelemetry-exporter-in-memory";
-       version = "0.0.1.3";
-       sha256 = "0hb8hcq9dhqpnv5v6k48vmlc3d56v24maxj8jqp0w5yakhw59zir";
+       version = "0.0.1.4";
+       sha256 = "0bri4jd7s7l0li99dalsqvbm6ryqpmzhfps4bl3z20brirf3jr94";
        libraryHaskellDepends = [
          async base hs-opentelemetry-api unagi-chan
        ];
-       testHaskellDepends = [
-         async base hs-opentelemetry-api unagi-chan
-       ];
        license = lib.licenses.bsd3;
      }) {};
 
   "hs-opentelemetry-exporter-otlp" = callPackage
-    ({ mkDerivation, base, bytestring, case-insensitive, clock
+    ({ mkDerivation, base, bytestring, case-insensitive
      , hs-opentelemetry-api, hs-opentelemetry-otlp, http-client
-     , http-conduit, http-types, microlens, mtl, proto-lens, text
-     , unordered-containers, vector, vector-builder, zlib
+     , http-conduit, http-types, microlens, proto-lens, text
+     , unordered-containers, vector, zlib
      }:
      mkDerivation {
        pname = "hs-opentelemetry-exporter-otlp";
-       version = "0.0.1.5";
-       sha256 = "10da3cxdab4iiw3a7n1wkajw7rqip0wm5sni82ph1i7k0mf83ycv";
+       version = "0.1.0.0";
+       sha256 = "0qzqr89amg1xvzbmfdnq7dmjd0gybdw668xnpkkj3ig4d96ir03i";
        libraryHaskellDepends = [
-         base bytestring case-insensitive clock hs-opentelemetry-api
-         hs-opentelemetry-otlp http-client http-conduit http-types microlens
-         mtl proto-lens text unordered-containers vector vector-builder zlib
-       ];
-       testHaskellDepends = [
-         base bytestring case-insensitive clock hs-opentelemetry-api
+         base bytestring case-insensitive hs-opentelemetry-api
          hs-opentelemetry-otlp http-client http-conduit http-types microlens
-         mtl proto-lens text unordered-containers vector vector-builder zlib
+         proto-lens text unordered-containers vector zlib
        ];
        description = "OpenTelemetry exporter supporting the standard OTLP protocol";
        license = lib.licenses.bsd3;
···
 
   "hs-opentelemetry-instrumentation-cloudflare" = callPackage
     ({ mkDerivation, base, case-insensitive, hs-opentelemetry-api
-     , hs-opentelemetry-instrumentation-conduit
-     , hs-opentelemetry-instrumentation-wai, http-types, text
-     , unordered-containers, wai
+     , hs-opentelemetry-instrumentation-wai, text, unordered-containers
+     , wai
      }:
      mkDerivation {
        pname = "hs-opentelemetry-instrumentation-cloudflare";
-       version = "0.2.0.0";
-       sha256 = "0hynk3sicxnrnnh0lfr0xl4ksw9yynygpz6z6fsyhq0mn7li8404";
+       version = "0.2.0.1";
+       sha256 = "1vslhh87gff06z33x82xdrnm8gld2xrl1nqj7d6ssyq399jd2m0g";
        libraryHaskellDepends = [
          base case-insensitive hs-opentelemetry-api
-         hs-opentelemetry-instrumentation-wai http-types text
-         unordered-containers wai
-       ];
-       testHaskellDepends = [
-         base case-insensitive hs-opentelemetry-api
-         hs-opentelemetry-instrumentation-conduit
-         hs-opentelemetry-instrumentation-wai http-types text
-         unordered-containers wai
+         hs-opentelemetry-instrumentation-wai text unordered-containers wai
        ];
        license = lib.licenses.bsd3;
      }) {};
···
     ({ mkDerivation, base, conduit, hs-opentelemetry-api, text }:
      mkDerivation {
        pname = "hs-opentelemetry-instrumentation-conduit";
-       version = "0.1.0.0";
-       sha256 = "1ai8pcag30d64qfiq3vm6pa9knlcn61baxgvx7r453ryyyj283rg";
+       version = "0.1.0.1";
+       sha256 = "05qi4mhhjbzd0227ba1j65ki6iwznp693sbzlnbnmi9sxy6hd5rs";
        libraryHaskellDepends = [ base conduit hs-opentelemetry-api text ];
-       testHaskellDepends = [ base conduit hs-opentelemetry-api text ];
        license = lib.licenses.bsd3;
      }) {};
 
   "hs-opentelemetry-instrumentation-hspec" = callPackage
-    ({ mkDerivation, base, hs-opentelemetry-api, hspec, hspec-core, mtl
-     , resourcet, text, unliftio, vault
+    ({ mkDerivation, base, hs-opentelemetry-api, hspec-core, mtl, text
      }:
      mkDerivation {
        pname = "hs-opentelemetry-instrumentation-hspec";
-       version = "0.0.1.1";
-       sha256 = "06hxr45pf8jy9dhl2q2ffaqfypacqvbcns1pj450qybc8rv2n0ay";
+       version = "0.0.1.2";
+       sha256 = "1h55wh06fv1s5slykdy6achyq9f0ik5k6bm36lb0vcycmgp536l4";
        libraryHaskellDepends = [
-         base hs-opentelemetry-api hspec hspec-core mtl resourcet text
-         unliftio vault
-       ];
-       testHaskellDepends = [
-         base hs-opentelemetry-api hspec hspec-core mtl resourcet text
-         unliftio vault
+         base hs-opentelemetry-api hspec-core mtl text
        ];
        license = lib.licenses.bsd3;
      }) {};
···
   "hs-opentelemetry-instrumentation-http-client" = callPackage
     ({ mkDerivation, aeson, base, bytestring, case-insensitive, conduit
      , hs-opentelemetry-api, hs-opentelemetry-instrumentation-conduit
-     , http-client, http-client-tls, http-conduit, http-types, text
-     , unliftio, unordered-containers
+     , http-client, http-conduit, http-types, text, unliftio
+     , unordered-containers
      }:
      mkDerivation {
        pname = "hs-opentelemetry-instrumentation-http-client";
-       version = "0.1.0.0";
-       sha256 = "0hm29fhp1q1qy6dc9iadms5wvwr5ixh96kz7zizi2p2b9p4iqypd";
+       version = "0.1.0.1";
+       sha256 = "01p5lmvsax5qp3m466d9x6lk74gnd0wwm8584d0z277g5psn7klx";
        libraryHaskellDepends = [
          aeson base bytestring case-insensitive conduit hs-opentelemetry-api
-         hs-opentelemetry-instrumentation-conduit http-client
-         http-client-tls http-conduit http-types text unliftio
-         unordered-containers
-       ];
-       testHaskellDepends = [
-         aeson base bytestring case-insensitive conduit hs-opentelemetry-api
-         hs-opentelemetry-instrumentation-conduit http-client
-         http-client-tls http-conduit http-types text unliftio
-         unordered-containers
+         hs-opentelemetry-instrumentation-conduit http-client http-conduit
+         http-types text unliftio unordered-containers
        ];
        license = lib.licenses.bsd3;
      }) {};
···
      }:
      mkDerivation {
        pname = "hs-opentelemetry-instrumentation-persistent";
-       version = "0.1.0.0";
-       sha256 = "1z47mna0n39iqss9s9ddbqa6nqjcdf6zadqmfdhbsybdr71l738j";
+       version = "0.1.0.1";
+       sha256 = "0gqf5hnzjsj05xba4g5wxzbjs2drxx22yzr8620pn38qbhpwmg8w";
        libraryHaskellDepends = [
-         base clock hs-opentelemetry-api mtl persistent resourcet text
-         unliftio unordered-containers vault
-       ];
-       testHaskellDepends = [
          base clock hs-opentelemetry-api mtl persistent resourcet text
          unliftio unordered-containers vault
        ];
···
 
   "hs-opentelemetry-instrumentation-postgresql-simple" = callPackage
     ({ mkDerivation, base, bytestring, hs-opentelemetry-api, iproute
-     , network, postgresql-libpq, postgresql-simple, text, unliftio
-     , unordered-containers
+     , postgresql-libpq, postgresql-simple, text, unliftio
+     , unliftio-core, unordered-containers
      }:
      mkDerivation {
        pname = "hs-opentelemetry-instrumentation-postgresql-simple";
-       version = "0.1.0.0";
-       sha256 = "011g3m0gqmrkrcvfa0y5zq0zbwwz33wwwmypi9g2b3a5b2qrgy4x";
+       version = "0.2.0.0";
+       sha256 = "04jqfxbaqq364l7yg2kf47854m1mlays1cp3llwvckvifw8nniim";
+       libraryHaskellDepends = [
+         base bytestring hs-opentelemetry-api iproute postgresql-libpq
+         postgresql-simple text unliftio unliftio-core unordered-containers
+       ];
+       license = lib.licenses.bsd3;
+     }) {};
+
+  "hs-opentelemetry-instrumentation-tasty" = callPackage
+    ({ mkDerivation, async, base, containers, hs-opentelemetry-api
+     , hs-opentelemetry-sdk, tagged, tasty, tasty-hunit, text
+     }:
+     mkDerivation {
+       pname = "hs-opentelemetry-instrumentation-tasty";
+       version = "0.1";
+       sha256 = "1lj3h5dg4cjcadincwbv0i4ah9q38qk2irp74v3j3b7k7b2x9vg6";
        libraryHaskellDepends = [
-         base bytestring hs-opentelemetry-api iproute network
-         postgresql-libpq postgresql-simple text unliftio
-         unordered-containers
+         base hs-opentelemetry-api tagged tasty text
        ];
        testHaskellDepends = [
-         base bytestring hs-opentelemetry-api iproute network
-         postgresql-libpq postgresql-simple text unliftio
-         unordered-containers
+         async base containers hs-opentelemetry-api hs-opentelemetry-sdk
+         tasty tasty-hunit text
        ];
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "hs-opentelemetry-instrumentation-wai" = callPackage
-    ({ mkDerivation, base, bytestring, hs-opentelemetry-api, http-types
-     , iproute, network, text, vault, wai
+    ({ mkDerivation, base, hs-opentelemetry-api, http-types, iproute
+     , network, text, unordered-containers, vault, wai
      }:
      mkDerivation {
        pname = "hs-opentelemetry-instrumentation-wai";
-       version = "0.1.0.0";
-       sha256 = "161xasgy82c0vzk38dz8441f5h90w05jjb1v3yzaarhkj6zm29cb";
+       version = "0.1.1.0";
+       sha256 = "0ip31c8scjbakxdqck88vakrm5szk5xv9a4k2pvvwxnijxn2bp64";
        libraryHaskellDepends = [
-         base bytestring hs-opentelemetry-api http-types iproute network
-         text vault wai
-       ];
-       testHaskellDepends = [
-         base bytestring hs-opentelemetry-api http-types iproute network
-         text vault wai
+         base hs-opentelemetry-api http-types iproute network text
+         unordered-containers vault wai
        ];
        description = "WAI instrumentation middleware for OpenTelemetry";
        license = lib.licenses.bsd3;
···
 
   "hs-opentelemetry-instrumentation-yesod" = callPackage
     ({ mkDerivation, base, hs-opentelemetry-api
-     , hs-opentelemetry-instrumentation-wai, microlens, mtl
-     , template-haskell, text, unliftio, unordered-containers, wai
-     , yesod-core
+     , hs-opentelemetry-instrumentation-wai, microlens, template-haskell
+     , text, unliftio, unordered-containers, wai, yesod-core
      }:
      mkDerivation {
        pname = "hs-opentelemetry-instrumentation-yesod";
-       version = "0.1.0.0";
-       sha256 = "1m3ph1g2rkg0a45zrfq5781gqjc5nk5ppg107b1lqsnngb3r659r";
+       version = "0.1.1.0";
+       sha256 = "09r6493sqxjy0q4dfh6s42xbx3ng53g4laywn0989ag2fnr3jz09";
        libraryHaskellDepends = [
          base hs-opentelemetry-api hs-opentelemetry-instrumentation-wai
-         microlens mtl template-haskell text unliftio unordered-containers
-         wai yesod-core
-       ];
-       testHaskellDepends = [
-         base hs-opentelemetry-api hs-opentelemetry-instrumentation-wai
-         microlens mtl template-haskell text unliftio unordered-containers
-         wai yesod-core
+         microlens template-haskell text unliftio unordered-containers wai
+         yesod-core
        ];
        description = "Yesod middleware for providing OpenTelemetry instrumentation";
        license = lib.licenses.bsd3;
      }) {};
 
   "hs-opentelemetry-otlp" = callPackage
-         base containers convertible csv hinduce-associations-apriori
+    ({ mkDerivation, base, proto-lens-runtime }:
      mkDerivation {
        pname = "hs-opentelemetry-otlp";
-       version = "0.0.1.0";
-       sha256 = "1hlflmr51lz4pbxxmlmp2rb5p4lcj09fhry41rv52nmk9iim4qr0";
-         base containers convertible csv hinduce-associations-apriori
+       version = "0.1.0.0";
+       sha256 = "1g9accvfcdn86m2y18imnmj4n73pbs1mncwg4s5jni1fzjg9f45r";
+       libraryHaskellDepends = [ base proto-lens-runtime ];
        description = "OpenTelemetry protocol buffer modules generated for the OTLP protocol by the proto-lens package";
        license = lib.licenses.bsd3;
      }) {};
 
   "hs-opentelemetry-propagator-b3" = callPackage
     ({ mkDerivation, attoparsec, base, bytestring, hs-opentelemetry-api
-     , http-types, memory, primitive, text
+     , http-types, text
      }:
      mkDerivation {
        pname = "hs-opentelemetry-propagator-b3";
-       version = "0.0.1.1";
-       sha256 = "0ncv85hsal7vqhfb0z4il0x8lwjibjji22japsi45w9fkkqhs8wd";
+       version = "0.0.1.2";
+       sha256 = "1hb1ls0xykp1b2vnjwrfxj33plx24f794s7wp09693d6hwaqxx84";
        libraryHaskellDepends = [
-         attoparsec base bytestring hs-opentelemetry-api http-types memory
-         primitive text
-       ];
-       testHaskellDepends = [
-         attoparsec base bytestring hs-opentelemetry-api http-types memory
-         primitive text
+         attoparsec base bytestring hs-opentelemetry-api http-types text
        ];
        description = "Trace propagation via HTTP headers following the b3 tracestate spec";
        license = lib.licenses.bsd3;
···
 
   "hs-opentelemetry-propagator-datadog" = callPackage
     ({ mkDerivation, base, bytestring, criterion, deepseq
-     , hs-opentelemetry-api, hs-opentelemetry-sdk, hspec, hspec-discover
-     , http-types, pretty-hex, primitive, QuickCheck, text
+     , hs-opentelemetry-api, hspec, hspec-discover, http-types
+     , pretty-hex, primitive, QuickCheck, text
      }:
      mkDerivation {
        pname = "hs-opentelemetry-propagator-datadog";
-       version = "0.0.0.0";
-       sha256 = "0mpf3jl741336fhljhgdgfxvpxyblcyqphgs7kp8hv6d6nmwyl19";
-       revision = "1";
-       editedCabalFile = "0bfvcfmyq0npwjnzh0v9kcv2ghhhnnr2wcw5d65bb59vfwhw7gys";
+       version = "0.0.1.0";
+       sha256 = "0sxfcswmwf4bnsyj0d67j32yi32gwhm4c6fs9mcl2wnax2vdwk7n";
        libraryHaskellDepends = [
-         base bytestring hs-opentelemetry-api hs-opentelemetry-sdk
-         http-types primitive text
+         base bytestring hs-opentelemetry-api http-types primitive text
        ];
        testHaskellDepends = [
          base bytestring hs-opentelemetry-api hspec pretty-hex primitive
···
 
   "hs-opentelemetry-propagator-w3c" = callPackage
     ({ mkDerivation, attoparsec, base, bytestring, hs-opentelemetry-api
-     , http-types, text
+     , http-types
      }:
      mkDerivation {
        pname = "hs-opentelemetry-propagator-w3c";
-       version = "0.0.1.3";
-       sha256 = "0n99kmy2ka3rmwhn56dqzsszhpv7phgcmkqng7drvr6qi5jzlfpz";
+       version = "0.0.1.4";
+       sha256 = "0f0fagrsyxhpd2qsbgzkgxzx5hzasplly12c2qjdd8g2ylh8szw1";
        libraryHaskellDepends = [
-         attoparsec base bytestring hs-opentelemetry-api http-types text
-       ];
-       testHaskellDepends = [
-         attoparsec base bytestring hs-opentelemetry-api http-types text
+         attoparsec base bytestring hs-opentelemetry-api http-types
        ];
        description = "Trace propagation via HTTP headers following the w3c tracestate spec";
        license = lib.licenses.bsd3;
···
   "hs-opentelemetry-sdk" = callPackage
     ({ mkDerivation, async, base, bytestring, clock
      , hs-opentelemetry-api, hs-opentelemetry-exporter-otlp
-     , hs-opentelemetry-propagator-b3, hs-opentelemetry-propagator-w3c
-     , hspec, http-types, network-bsd, random, stm, text, transformers
-     , unagi-chan, unix, unordered-containers, vector, vector-builder
+     , hs-opentelemetry-propagator-b3
+     , hs-opentelemetry-propagator-datadog
+     , hs-opentelemetry-propagator-w3c, hspec, http-types, network-bsd
+     , random, stm, text, unagi-chan, unix, unix-compat
+     , unordered-containers, vector, vector-builder
      }:
      mkDerivation {
        pname = "hs-opentelemetry-sdk";
-       version = "0.0.3.6";
-       sha256 = "042cb38dilf965dmyapv6c09v70520lrl389yv98yk1wwflkyrhi";
+       version = "0.1.0.0";
+       sha256 = "08zjfvfnsgsxc73jlgjizr8m2w152hny0myns4m78sjzj53733x1";
        libraryHaskellDepends = [
          async base bytestring hs-opentelemetry-api
          hs-opentelemetry-exporter-otlp hs-opentelemetry-propagator-b3
-         hs-opentelemetry-propagator-w3c http-types network-bsd random stm
-         text transformers unagi-chan unix unordered-containers vector
-         vector-builder
+         hs-opentelemetry-propagator-datadog hs-opentelemetry-propagator-w3c
+         http-types network-bsd random stm text unagi-chan unix unix-compat
+         unordered-containers vector vector-builder
        ];
        testHaskellDepends = [
-         async base bytestring clock hs-opentelemetry-api
-         hs-opentelemetry-exporter-otlp hs-opentelemetry-propagator-b3
-         hs-opentelemetry-propagator-w3c hspec http-types network-bsd random
-         stm text transformers unagi-chan unix unordered-containers vector
-         vector-builder
+         base clock hs-opentelemetry-api hspec text unordered-containers
        ];
        description = "OpenTelemetry SDK for use in applications";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "hs-opentelemetry-utils-exceptions" = callPackage
···
      }:
      mkDerivation {
        pname = "hs-opentelemetry-utils-exceptions";
-       version = "0.2.0.0";
-       sha256 = "1jcczl8q78d1fz32s0sb6g8qr4s70zdwn13p789w7m5xvycjdvrg";
+       version = "0.2.0.1";
+       sha256 = "1ccazld2gd4ql7x9nkc8npf0v588swcwccvrxs6xkph8ds33pfy7";
        libraryHaskellDepends = [
          base exceptions hs-opentelemetry-api hs-opentelemetry-sdk text
        ];
-       testHaskellDepends = [
-         base exceptions hs-opentelemetry-api hs-opentelemetry-sdk text
-       ];
+       testHaskellDepends = [ base ];
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "hs-opentelemetry-vendor-honeycomb" = callPackage
     ({ mkDerivation, base, bytestring, honeycomb, hs-opentelemetry-api
-     , hspec, hspec-core, hspec-discover, hspec-expectations, mtl, text
-     , time, transformers, unordered-containers, uri-bytestring
+     , hspec, hspec-discover, mtl, text, time, transformers
+     , unordered-containers, uri-bytestring
      }:
      mkDerivation {
        pname = "hs-opentelemetry-vendor-honeycomb";
-       version = "0.0.1.1";
-       sha256 = "0g3c6h8z1gcxxn4xm7vaif564knz0122y8jwmjy1sw4nmn74123x";
+       version = "0.0.1.2";
+       sha256 = "1q0ckazz17mvl6h8k0di0kfvq377xxsbi5aghsv6wyzpb2fq7brf";
        libraryHaskellDepends = [
          base bytestring honeycomb hs-opentelemetry-api mtl text time
          transformers unordered-containers uri-bytestring
        ];
-       testHaskellDepends = [
-         base bytestring honeycomb hs-opentelemetry-api hspec hspec-core
-         hspec-expectations mtl text time transformers unordered-containers
-         uri-bytestring
-       ];
+       testHaskellDepends = [ base hs-opentelemetry-api hspec time ];
        testToolDepends = [ hspec-discover ];
        description = "Optional OpenTelemetry integration for Honeycomb";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "hsblst";
-       version = "0.0.3";
-       sha256 = "0pf35cyb0m06frcb3ralzq3wzmhb3r5zyzx330gxkz3gw6b5qwig";
+       version = "0.0.4";
+       sha256 = "13dlz8am20np31bq31z596yam6w1rb0fdzlg3zwwvm6wyjh6b8sg";
        libraryHaskellDepends = [ base deepseq memory ];
        libraryToolDepends = [ c2hs ];
        testHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "hsc3";
-       version = "0.20";
-       sha256 = "1pi2zzcz6xrj5w0ql5g7z6qf2vbchixc871if2yqna8wndakhcc8";
+       version = "0.21";
+       sha256 = "06rxvhravms34w4zfazvxsxh4n8ysnrcbfv3y5028yrckingihlv";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          array base binary bytestring containers data-binary-ieee754
···
        ];
        description = "Haskell SuperCollider";
        license = lib.licenses.gpl3Only;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "hsc3-auditor" = callPackage
···
      }:
      mkDerivation {
        pname = "hscim";
-       version = "0.4.0.2";
-       sha256 = "1plcbwhl1xl7rgn91q2n3829mvk33gqzsjf3y0bhlkyyd1rmz2fx";
+       version = "0.4.0.6";
+       sha256 = "1s4r7193zms8rvrj8fyr5fh8sss6g8bbr05im4c0myyvqsn7xh6k";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          network-uri retry scientific servant servant-client
          servant-client-core servant-server stm stm-containers
          string-conversions template-haskell text time uuid wai wai-extra
-         warp
        ];
        executableHaskellDepends = [
          base email-validate network-uri stm stm-containers time warp
···
        description = "Salesforce API Client";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "hsftp" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, cmdargs, directory
+     , filepath, filepath-bytestring, libssh2, mtl, tasty, tasty-hunit
+     , tasty-quickcheck, tasty-smallcheck, temporary, time, yaml
+     }:
+     mkDerivation {
+       pname = "hsftp";
+       version = "1.3.1";
+       sha256 = "0027bmn11fl3lbyd4aw77w5b4xdf53izpxnnpp1qnwpxd8j92w82";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base bytestring cmdargs directory filepath
+         filepath-bytestring libssh2 mtl time yaml
+       ];
+       executableHaskellDepends = [
+         aeson base bytestring cmdargs directory filepath
+         filepath-bytestring libssh2 mtl time yaml
+       ];
+       testHaskellDepends = [
+         aeson base bytestring cmdargs directory filepath
+         filepath-bytestring libssh2 mtl tasty tasty-hunit tasty-quickcheck
+         tasty-smallcheck temporary time yaml
+       ];
+       description = "A SFTP client tool for secure file transfer operations";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "hsftp";
        broken = true;
      }) {};
 
···
      }:
      mkDerivation {
        pname = "hspec";
-       version = "2.11.9";
-       sha256 = "16rh30v2mx01yi72k8kiwmwgnv98xv59d9n6ap8jpyn7p96nmsir";
+       version = "2.11.10";
+       sha256 = "1c9m16fq15q7zad4q4ji1mw138vapbbzby0dwc2zqf9sahd5vvl4";
        libraryHaskellDepends = [
          base hspec-core hspec-discover hspec-expectations QuickCheck
        ];
···
      }:
      mkDerivation {
        pname = "hspec-api";
-       version = "2.11.9";
-       sha256 = "1hzv4q63yd60kypnil3hmsf8v92ig2ankafhavd0jf5hgdjd2wnk";
+       version = "2.11.10";
+       sha256 = "1wi8jfia2gxd9xx3748rkwvjqaqwwxnab87c97nhff3ynaq5sx2b";
        libraryHaskellDepends = [ base hspec-core transformers ];
        testHaskellDepends = [ base hspec hspec-core transformers ];
        testToolDepends = [ hspec-discover ];
···
 
   "hspec-core" = callPackage
     ({ mkDerivation, ansi-terminal, array, base, base-orphans
-     , call-stack, deepseq, directory, filepath, haskell-lexer
-     , hspec-expectations, hspec-meta, HUnit, process, QuickCheck
-     , quickcheck-io, random, silently, stm, temporary, tf-random, time
-     , transformers
+     , call-stack, containers, deepseq, directory, filepath
+     , haskell-lexer, hspec-expectations, hspec-meta, HUnit, process
+     , QuickCheck, quickcheck-io, random, silently, stm, temporary
+     , tf-random, time, transformers
      }:
      mkDerivation {
        pname = "hspec-core";
-       version = "2.11.9";
-       sha256 = "0qzzwyx71741v53qd9pah5bqq8md3mj0l6ykaw3d4816c2np5wdi";
+       version = "2.11.10";
+       sha256 = "1glyrb3lw0290a06jj5ig2l69jawfrhhaacqfaniziwl4psd3giq";
        libraryHaskellDepends = [
-         ansi-terminal array base call-stack deepseq directory filepath
-         haskell-lexer hspec-expectations HUnit process QuickCheck
+         ansi-terminal array base call-stack containers deepseq directory
+         filepath haskell-lexer hspec-expectations HUnit process QuickCheck
          quickcheck-io random stm tf-random time transformers
        ];
        testHaskellDepends = [
-         ansi-terminal array base base-orphans call-stack deepseq directory
-         filepath haskell-lexer hspec-expectations hspec-meta HUnit process
-         QuickCheck quickcheck-io random silently stm temporary tf-random
-         time transformers
+         ansi-terminal array base base-orphans call-stack containers deepseq
+         directory filepath haskell-lexer hspec-expectations hspec-meta
+         HUnit process QuickCheck quickcheck-io random silently stm
+         temporary tf-random time transformers
        ];
        testToolDepends = [ hspec-meta ];
        testTarget = "--test-option=--skip --test-option='Test.Hspec.Core.Runner.hspecResult runs specs in parallel'";
···
      }:
      mkDerivation {
        pname = "hspec-discover";
-       version = "2.11.9";
-       sha256 = "054l0k6rn7n1mm3ivhvv00zmqdkdnrp91h5l2wy6sbibrvrl8rhp";
+       version = "2.11.10";
+       sha256 = "001j5jr0iyskicn893lfgidh99fz8g5v3l5jv13yvq2hl9xi2cvk";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base directory filepath ];
···
      }) {};
 
   "hspec-meta" = callPackage
-    ({ mkDerivation, ansi-terminal, array, base, call-stack, deepseq
-     , directory, filepath, haskell-lexer, hspec-expectations, HUnit
-     , process, QuickCheck, quickcheck-io, random, stm, tf-random, time
-     , transformers
+    ({ mkDerivation, ansi-terminal, array, base, call-stack, containers
+     , deepseq, directory, filepath, haskell-lexer, hspec-expectations
+     , HUnit, process, QuickCheck, quickcheck-io, random, stm, tf-random
+     , time, transformers
      }:
      mkDerivation {
        pname = "hspec-meta";
-       version = "2.11.9";
-       sha256 = "09cl2dknj548zzmdfx1pyd27jywgcr4000hf1rscn85b4r2riymm";
+       version = "2.11.10";
+       sha256 = "10iq35f6j4lrk4cxyr1gm0f0zxd2ndnzng0v4lcl6i33fnfjf3n2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         ansi-terminal array base call-stack deepseq directory filepath
-         haskell-lexer hspec-expectations HUnit process QuickCheck
+         ansi-terminal array base call-stack containers deepseq directory
+         filepath haskell-lexer hspec-expectations HUnit process QuickCheck
          quickcheck-io random stm tf-random time transformers
        ];
        executableHaskellDepends = [
-         ansi-terminal array base call-stack deepseq directory filepath
-         haskell-lexer hspec-expectations HUnit process QuickCheck
+         ansi-terminal array base call-stack containers deepseq directory
+         filepath haskell-lexer hspec-expectations HUnit process QuickCheck
          quickcheck-io random stm tf-random time transformers
        ];
        description = "A version of Hspec which is used to test Hspec itself";
···
        license = lib.licenses.agpl3Plus;
      }) {};
 
+  "htree_0_2_0_0" = callPackage
+    ({ mkDerivation, base, containers, hspec, QuickCheck
+     , quickcheck-instances, template-haskell, th-compat
+     }:
+     mkDerivation {
+       pname = "htree";
+       version = "0.2.0.0";
+       sha256 = "1q3piv0281whrz2nixl8wk4ryzpkd6p5isyw5by1y85pn16m60jf";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [
+         base containers hspec QuickCheck quickcheck-instances
+         template-haskell th-compat
+       ];
+       description = "a library to build and work with heterogeneous, type level indexed rose trees";
+       license = lib.licenses.agpl3Plus;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "hts" = callPackage
     ({ mkDerivation, base, hmt, xml }:
      mkDerivation {
···
        pname = "http-api-data-qq";
        version = "0.1.0.0";
        sha256 = "1lvfdbprdwq09k1wkjfvvkpi79053dc4kzkv4g1cx94qb1flbd7a";
-       revision = "5";
-       editedCabalFile = "0j7iv1br4ijawc1l85zdh7h9i005qnqbm2gamrca09alv3m9m72v";
+       revision = "6";
+       editedCabalFile = "06bl99wxwb9g5rnkjqgbmb6187gjr821falc78daqc7c9vdp2nv5";
        libraryHaskellDepends = [
          base http-api-data template-haskell text
        ];
···
        license = lib.licenses.mit;
      }) {};
 
+  "http-client_0_7_18" = callPackage
+    ({ mkDerivation, array, async, base, base64-bytestring
+     , blaze-builder, bytestring, case-insensitive, containers, cookie
+     , deepseq, directory, exceptions, filepath, ghc-prim, hspec
+     , hspec-discover, http-types, iproute, mime-types, monad-control
+     , network, network-uri, random, stm, streaming-commons, text, time
+     , transformers, zlib
+     }:
+     mkDerivation {
+       pname = "http-client";
+       version = "0.7.18";
+       sha256 = "15ilhyxqsna6bwi3gklnxfmpaxcb56y3l3z62l3bsk02jvbb724h";
+       libraryHaskellDepends = [
+         array async base base64-bytestring blaze-builder bytestring
+         case-insensitive containers cookie deepseq exceptions filepath
+         ghc-prim http-types iproute mime-types network network-uri random
+         stm streaming-commons text time transformers
+       ];
+       testHaskellDepends = [
+         async base blaze-builder bytestring case-insensitive containers
+         cookie deepseq directory hspec http-types monad-control network
+         network-uri streaming-commons text time transformers zlib
+       ];
+       testToolDepends = [ hspec-discover ];
+       doCheck = false;
+       description = "An HTTP client engine";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "http-client-auth" = callPackage
     ({ mkDerivation, base, base64-string, blaze-builder, bytestring
      , case-insensitive, conduit, crypto-conduit, http-client
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "http2_5_3_5" = callPackage
+  "http2_5_3_9" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, array, async, base
      , base16-bytestring, bytestring, case-insensitive, containers
      , criterion, crypton, directory, filepath, Glob, hspec
···
      }:
      mkDerivation {
        pname = "http2";
-       version = "5.3.5";
-       sha256 = "0zfcfm59yd0i2d9mlcaig3jjc4hsgqzbvjkkl3yiydcx2nk53a3m";
+       version = "5.3.9";
+       sha256 = "0wcv9ziz0865j66avlax7f4i9l5k7ydcn96bacy78snmvcciblqf";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "http2-tls";
-       version = "0.4.4";
-       sha256 = "0l7nplayw4l8rw13ic12l3czcdb0nvf5snxa4q851jgfbl35agv4";
+       version = "0.4.5";
+       sha256 = "0kc7g8ldgm40fsh73r881pxjb87x0m00xnjd0zsl0baaa85f7r4y";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "http3";
-       version = "0.0.19";
-       sha256 = "0vdxxsmgfzjwlhph9p2biiyw14l90kpwv04h8c0q55xxfg8plkgf";
+       version = "0.0.22";
+       sha256 = "1w9zrzxj1n0j2y529chhfnbxbqrflvqhpifizyb9v192fgkzwiy2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "hw-json" = callPackage
-    ({ mkDerivation, aeson, ansi-wl-pprint, attoparsec
-     , attoparsec-aeson, base, bits-extra, bytestring, criterion
-     , directory, dlist, doctest, doctest-discover, generic-lens
-     , hedgehog, hspec, hspec-discover, hw-balancedparens, hw-bits
-     , hw-hspec-hedgehog, hw-json-simd, hw-json-simple-cursor
-     , hw-json-standard-cursor, hw-mquery, hw-parser, hw-prim
-     , hw-rankselect, hw-rankselect-base, hw-simd, lens, mmap
-     , optparse-applicative, scientific, text, transformers
-     , unordered-containers, vector, word8
+    ({ mkDerivation, aeson, attoparsec, attoparsec-aeson, base
+     , bits-extra, bytestring, criterion, directory, dlist, doctest
+     , doctest-discover, generic-lens, hedgehog, hspec, hspec-discover
+     , hw-balancedparens, hw-bits, hw-hspec-hedgehog, hw-json-simd
+     , hw-json-simple-cursor, hw-json-standard-cursor, hw-mquery
+     , hw-parser, hw-prim, hw-rankselect, hw-rankselect-base, hw-simd
+     , lens, mmap, optparse-applicative, prettyprinter, scientific, text
+     , transformers, unordered-containers, vector, word8
      }:
      mkDerivation {
        pname = "hw-json";
-       version = "1.3.2.5";
-       sha256 = "0nwwyk7x26xrx3cqnwy6gv1gpjnmw69mfyjqgvky3bdgf9lxncrb";
+       version = "1.3.3.0";
+       sha256 = "1kqwz2wh0bqq91amqwljilb6grmq943z874b1avq6z1mxvxmaf9a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         aeson ansi-wl-pprint attoparsec attoparsec-aeson base bits-extra
-         bytestring dlist hw-balancedparens hw-bits hw-json-simple-cursor
+         aeson attoparsec attoparsec-aeson base bits-extra bytestring dlist
+         hw-balancedparens hw-bits hw-json-simple-cursor
          hw-json-standard-cursor hw-mquery hw-parser hw-prim hw-rankselect
-         hw-rankselect-base hw-simd mmap scientific text vector word8
+         hw-rankselect-base hw-simd mmap prettyprinter scientific text
+         vector word8
        ];
        executableHaskellDepends = [
          aeson base bytestring dlist generic-lens hw-balancedparens
···
      }) {};
 
   "hw-mquery" = callPackage
-    ({ mkDerivation, ansi-wl-pprint, base, dlist, doctest
-     , doctest-discover, hedgehog, hspec, hspec-discover
-     , hw-hspec-hedgehog, lens
+    ({ mkDerivation, base, dlist, doctest, doctest-discover, hedgehog
+     , hspec, hspec-discover, hw-hspec-hedgehog, lens, prettyprinter
      }:
      mkDerivation {
        pname = "hw-mquery";
-       version = "0.2.1.1";
-       sha256 = "1jdmgg0y04xl18vkdjwynb48wdl58kkzsw062v2cv65mkjhcvf0l";
-       revision = "1";
-       editedCabalFile = "16832r95lljph5vf33l9f544m8q9c3dx9b94wxmjjsl6z3bymmdc";
+       version = "0.2.1.2";
+       sha256 = "0zdn8rsjcvnk5x12l27nsryi3fhng9w7f67babkjmvfj09m3z1mx";
        isLibrary = true;
        isExecutable = true;
-       libraryHaskellDepends = [ ansi-wl-pprint base dlist lens ];
+       libraryHaskellDepends = [ base dlist lens prettyprinter ];
        executableHaskellDepends = [ base ];
        testHaskellDepends = [
          base dlist doctest doctest-discover hedgehog hspec
···
      }:
      mkDerivation {
        pname = "hw-polysemy";
-       version = "0.3.0.2";
-       sha256 = "0pmzlv7vff2n8lak4hwc0gzlfnh5ja51ss3wr2lbzq2chy5f9n5i";
+       version = "0.3.1.0";
+       sha256 = "1mgw1mika0rjgdj722k58sblb1q2yknapybxqdb8jqqwr7301bvz";
        libraryHaskellDepends = [
          aeson aeson-pretty async base binary bytestring contravariant Diff
          directory exceptions filepath generic-lens ghc-prim http-conduit
···
   "hw-prelude" = callPackage
     ({ mkDerivation, aeson, async, base, bytestring, contravariant
      , directory, filepath, generic-lens, microlens, network, process
-     , resourcet, text, unliftio
+     , resourcet, text, transformers, unliftio
      }:
      mkDerivation {
        pname = "hw-prelude";
-       version = "0.0.0.3";
-       sha256 = "0z15ms53y4j4flzwh0x4683dmnadpyrzdirdbjgcs0mrppqk5az5";
+       version = "0.0.4.1";
+       sha256 = "0r3jz1d7nnzgkvvfpk2pvnhmd46jfwr3qwshzpk2sviwz7nl1yrf";
        libraryHaskellDepends = [
          aeson async base bytestring contravariant directory filepath
-         generic-lens microlens network process resourcet text unliftio
+         generic-lens microlens network process resourcet text transformers
+         unliftio
        ];
        description = "Opinionated prelude library";
        license = lib.licenses.asl20;
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "hybrid-vectors_0_2_5" = callPackage
+    ({ mkDerivation, base, deepseq, primitive, semigroups, vector }:
+     mkDerivation {
+       pname = "hybrid-vectors";
+       version = "0.2.5";
+       sha256 = "09akcggxi1isiv4zj42gm9ynfm8mh99bw082irpmq0fbmzi8l0qb";
+       libraryHaskellDepends = [
+         base deepseq primitive semigroups vector
+       ];
+       description = "Hybrid vectors e.g. Mixed Boxed/Unboxed vectors";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "hydra" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, base, bytestring, containers
      , directory, filepath, hspec, hspec-discover, HsYAML, HUnit, mtl
···
      }:
      mkDerivation {
        pname = "iCalendar";
-       version = "0.4.1.0";
-       sha256 = "1nh2gdmm1kd8dlflxwzdqg9xdylqblb7xhnhpl143j1wfcnd1cn4";
-       revision = "2";
-       editedCabalFile = "1410vr0dlmnc1g7h780nwigdk2wpnhyg47a1rfn55d2qgs8lk93r";
+       version = "0.4.1.1";
+       sha256 = "0bdsfl108c740zn105sw765dlfw8hvpnwk7w3psy1iyn8hasl1rh";
+       revision = "1";
+       editedCabalFile = "09b4kqm03v6cxiq9yf0xp0sbc232gra5lg56p1rllyl2rdfq31n1";
        libraryHaskellDepends = [
          base base64-bytestring bytestring case-insensitive containers
          data-default mime mtl network-uri old-locale parsec text time
···
     ({ mkDerivation, base, ghc, ghc-tcplugin-api }:
      mkDerivation {
        pname = "if-instance";
-       version = "0.5.1.0";
-       sha256 = "1gl6m7schrca8kqz10ia8qz3kad4h21ijjrqcarl7r0ipvpc9hz8";
+       version = "0.5.2.0";
+       sha256 = "1mkfx0iivdivxlmcq4lxj2l736javvk7pyx7ja9yjmjw7zp8xpa2";
        libraryHaskellDepends = [ base ghc ghc-tcplugin-api ];
        testHaskellDepends = [ base ghc ];
        doHaddock = false;
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "infinite-list_0_1_2" = callPackage
+    ({ mkDerivation, base, containers, QuickCheck, tasty, tasty-bench
+     , tasty-expected-failure, tasty-inspection-testing
+     , tasty-quickcheck
+     }:
+     mkDerivation {
+       pname = "infinite-list";
+       version = "0.1.2";
+       sha256 = "0v5xidhffcdn8z65nky22rhm89pbji03gp51mzqcgrzfinyjdbkb";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [
+         base containers QuickCheck tasty tasty-expected-failure
+         tasty-inspection-testing tasty-quickcheck
+       ];
+       benchmarkHaskellDepends = [ base tasty-bench ];
+       description = "Infinite lists";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "infinite-search" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
 
   "int-like" = callPackage
     ({ mkDerivation, algebraic-graphs, base, containers, deepseq
-     , hashable, tasty, tasty-hunit
+     , hashable
      }:
      mkDerivation {
        pname = "int-like";
-       version = "0.1.3";
-       sha256 = "0rp22jdrgsl5ka087cjr3h6qvjs516rajd5cdxxjh154ymj5kzxz";
+       version = "0.1.4";
+       sha256 = "0djf0p2k0ayzxbabx0r2hwcm2rm7llfjhrd718c7n2zkqz297hfm";
        libraryHaskellDepends = [
          algebraic-graphs base containers deepseq hashable
-       ];
-       testHaskellDepends = [
-         algebraic-graphs base containers deepseq hashable tasty tasty-hunit
        ];
        description = "Newtype wrappers over IntSet and IntMap";
        license = lib.licenses.bsd3;
···
        license = lib.licenses.mit;
      }) {};
 
+  "integer-logarithms_1_0_4" = callPackage
+    ({ mkDerivation, array, base, ghc-bignum, ghc-prim, QuickCheck
+     , smallcheck, tasty, tasty-hunit, tasty-quickcheck
+     , tasty-smallcheck
+     }:
+     mkDerivation {
+       pname = "integer-logarithms";
+       version = "1.0.4";
+       sha256 = "0icg8k0h7yc3aynsbidppwyfkjnq8spaczdi5bby5jqq4mncg4va";
+       libraryHaskellDepends = [ array base ghc-bignum ghc-prim ];
+       testHaskellDepends = [
+         base QuickCheck smallcheck tasty tasty-hunit tasty-quickcheck
+         tasty-smallcheck
+       ];
+       description = "Integer logarithms";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "integer-pure" = callPackage
     ({ mkDerivation }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "integer-types";
-       version = "0.1.4.0";
-       sha256 = "0c1js39965d7g3naqlhfdxjs7w4zygnibf4raha60lq3dgnc7nc0";
+       version = "0.1.4.1";
+       sha256 = "1q8z7w8rbdp865nlh2vz4bi5i1arkdz216ppirsg9imvwlddi5d8";
        libraryHaskellDepends = [ base deepseq hashable quaalude ];
        testHaskellDepends = [
          base deepseq exceptions hashable hedgehog hspec hspec-hedgehog
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "intern_0_9_6" = callPackage
+    ({ mkDerivation, array, base, bytestring, hashable, text
+     , unordered-containers
+     }:
+     mkDerivation {
+       pname = "intern";
+       version = "0.9.6";
+       sha256 = "1jinr6z1azzz0fsbp0fs5jjzln33qq8r67c63z30nw5kfh6kxjcf";
+       libraryHaskellDepends = [
+         array base bytestring hashable text unordered-containers
+       ];
+       description = "Efficient hash-consing for arbitrary data types";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "internetmarke" = callPackage
     ({ mkDerivation, base, explicit-exception, HPDF, parsec, process
      , transformers, utility-ht
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "intervals_0_9_3" = callPackage
+    ({ mkDerivation, array, base, distributive, ghc-prim, QuickCheck }:
+     mkDerivation {
+       pname = "intervals";
+       version = "0.9.3";
+       sha256 = "07qsz1pzfgbxllavj8d428i3vnz7a5a9cxikimzd0rsz9dlprdnn";
+       libraryHaskellDepends = [ array base distributive ghc-prim ];
+       testHaskellDepends = [ base QuickCheck ];
+       description = "Interval Arithmetic";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "intmap-graph" = callPackage
     ({ mkDerivation, base, containers, text, vector, word8 }:
      mkDerivation {
···
        license = lib.licenses.bsd2;
      }) {};
 
+  "invariant_0_6_4" = callPackage
+    ({ mkDerivation, array, base, bifunctors, comonad, containers
+     , contravariant, ghc-prim, hspec, hspec-discover, profunctors
+     , QuickCheck, StateVar, stm, tagged, template-haskell
+     , th-abstraction, transformers, transformers-compat
+     , unordered-containers
+     }:
+     mkDerivation {
+       pname = "invariant";
+       version = "0.6.4";
+       sha256 = "1cxfy1s3p91g5n1z85058lc27xy4xfl3dnkvxcxn3m70wd7apqm9";
+       libraryHaskellDepends = [
+         array base bifunctors comonad containers contravariant ghc-prim
+         profunctors StateVar stm tagged template-haskell th-abstraction
+         transformers transformers-compat unordered-containers
+       ];
+       testHaskellDepends = [ base hspec QuickCheck template-haskell ];
+       testToolDepends = [ hspec-discover ];
+       description = "Haskell98 invariant functors";
+       license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "inventory" = callPackage
     ({ mkDerivation, appendmap, array, base, bytestring, containers
      , directory, filepath, ghc, ghc-paths, mtl, tasty, tasty-hunit
···
      }:
      mkDerivation {
        pname = "ip2location";
-       version = "8.5.0";
-       sha256 = "1r2p6qv2n5pq4c9vr3zq6gkp7si7jm498fchqynrcnslldghz70c";
+       version = "8.5.1";
+       sha256 = "0x5l2rv6wq5a08f7s97cyrqfl7zsrqlsgv105s02rm8r3ifabaca";
        libraryHaskellDepends = [
          aeson base binary bytestring http-client http-client-tls http-types
          iproute split uri-encode
···
      }:
      mkDerivation {
        pname = "ip2proxy";
-       version = "3.2.0";
-       sha256 = "0m50z5a32m28lfq6g8chkakvcgd6iplmx2ik0nbi2zsgfc0l209y";
+       version = "3.2.1";
+       sha256 = "10qqbwpwb3gr0g1nz8fm50f215y53l21i1szvv0zh62v20n4p6gz";
        libraryHaskellDepends = [
          aeson base binary bytestring http-client http-client-tls http-types
          iproute uri-encode
···
        license = lib.licenses.mit;
      }) {};
 
+  "isomorphism-class_0_3" = callPackage
+    ({ mkDerivation, base, bytestring, containers, hashable, primitive
+     , profunctors, QuickCheck, quickcheck-instances, rebase, tasty
+     , tasty-quickcheck, text, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "isomorphism-class";
+       version = "0.3";
+       sha256 = "1j4hxr60bk813l96knr377nmjfnfxfzfmxxg46qfjb3qhrjpvw1r";
+       libraryHaskellDepends = [
+         base bytestring containers hashable primitive profunctors
+         QuickCheck text unordered-containers vector
+       ];
+       testHaskellDepends = [
+         bytestring primitive QuickCheck quickcheck-instances rebase tasty
+         tasty-quickcheck text
+       ];
+       description = "Isomorphism typeclass solving the conversion problem";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "isotope" = callPackage
     ({ mkDerivation, base, containers, hspec, megaparsec, QuickCheck
      , template-haskell, th-lift
···
     ({ mkDerivation, alex, array, base, bytestring, containers
      , criterion, deepseq, directory, filepath, happy, lazy-csv
      , microlens, microlens-mtl, mtl, optparse-applicative
-     , prettyprinter, regex-rure, silently, split, tasty, tasty-hunit
-     , text, transformers, vector
+     , prettyprinter, regex-rure, split, tasty, tasty-golden
+     , tasty-hunit, temporary, text, transformers, vector
      }:
      mkDerivation {
        pname = "jacinda";
-       version = "3.2.0.1";
-       sha256 = "0d5snl6m9ij81qvsbm949lyh7dwrsvfb725hy87jnigmgkyxzjls";
+       version = "3.3.0.1";
+       sha256 = "09lsb5amhxlxbnyhc6jpjixgs91ygj5vx948jhm72ngjs29jyp75";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        executableHaskellDepends = [
          base directory optparse-applicative text
        ];
-       testHaskellDepends = [ base bytestring tasty tasty-hunit text ];
-       benchmarkHaskellDepends = [ base criterion deepseq silently text ];
+       testHaskellDepends = [
+         base bytestring tasty tasty-golden tasty-hunit temporary text
+       ];
+         base containers convertible csv hinduce-associations-apriori
        doHaddock = false;
        description = "Functional, expression-oriented data processing language";
        license = lib.licenses.agpl3Only;
···
        pname = "javelin";
        version = "0.1.2.0";
        sha256 = "12xzs05dkkbn93yh1f5l7m64j3rifcz9qnd5nqqd62cj6nic10xl";
-       revision = "2";
-       editedCabalFile = "11aizybgmbvmpjax3lsa99c1jib09sgg85g5xpws7qfggmrwj0h0";
+       revision = "4";
+       editedCabalFile = "19q3if5qyp6ph8ld4sps8lvplpbjyqa259a9lvzqhygaik2wdfw2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "javelin-io";
        version = "0.1.1.1";
        sha256 = "1c6w0p7yjbc3yw12f5bflgacvivzc1n0dxgmz2qn06yiraw6jyv6";
-       revision = "1";
-       editedCabalFile = "0z25nvwh5wzsaa022gp4pc5bxk1xqrfj98q6ni3mh4r3kydcm50g";
+       revision = "3";
+       editedCabalFile = "0s0rc82jj1l6vrl0kbzfvvhbjvibjqwaj71dljms8wh94r9kyqf3";
        libraryHaskellDepends = [
          base bytestring cassava containers javelin unordered-containers
          vector
···
     ({ mkDerivation, aeson, base, containers, HUnit, text }:
      mkDerivation {
        pname = "keuringsdienst";
-       version = "1.0.2.0";
-       sha256 = "156z9wxm62s70y83a51lxpjy3c2x0skq2p3jdjdkpwgqa0i7m7yr";
+       version = "1.0.2.2";
+       sha256 = "0wg13kgzq7hvl5fipwwsbdfi53ymz7ki794bhws8jxbc92c05whd";
        libraryHaskellDepends = [ aeson base containers text ];
        testHaskellDepends = [ aeson base containers HUnit text ];
        description = "Data validation in Haskell that is composable, made easy and clean";
···
        pname = "keycode";
        version = "0.2.3";
        sha256 = "1zq02yd7ldbyk7zpgq9bj37y52ckzyyrad2yi48amh7dzym1sbj2";
+       revision = "1";
+       editedCabalFile = "12kpkn9l45rfb5vdakgf2sbqs2by98d4dzq2qyzkfl4jlxk7l4j4";
        libraryHaskellDepends = [
          base containers ghc-prim template-haskell
        ];
···
        ];
        description = "Keyed functors and containers";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "keys_3_12_4" = callPackage
+    ({ mkDerivation, array, base, comonad, containers, free, hashable
+     , semigroupoids, semigroups, tagged, transformers
+     , transformers-compat, unordered-containers
+     }:
+     mkDerivation {
+       pname = "keys";
+       version = "3.12.4";
+       sha256 = "04l9ssmns3v2xzfrk5pxcacvl8nh26rsw5hhw22v4zxzbh9s44ll";
+       libraryHaskellDepends = [
+         array base comonad containers free hashable semigroupoids
+         semigroups tagged transformers transformers-compat
+         unordered-containers
+       ];
+       description = "Keyed functors and containers";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "keysafe" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "language-c_0_10_0" = callPackage
+    ({ mkDerivation, alex, array, base, bytestring, containers, deepseq
+     , directory, filepath, happy, mtl, pretty, process
+     }:
+     mkDerivation {
+       pname = "language-c";
+       version = "0.10.0";
+       sha256 = "0m3dphd0r0n763a5rrg0z4fmiaqn7nkjq15l4vif332zrmgipb37";
+       libraryHaskellDepends = [
+         array base bytestring containers deepseq directory filepath mtl
+         pretty process
+       ];
+       libraryToolDepends = [ alex happy ];
+       testHaskellDepends = [ base directory filepath process ];
+       description = "Analysis and generation of C code";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "language-c-comments" = callPackage
     ({ mkDerivation, alex, array, base, language-c }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "language-spir-v";
-       version = "0.1.0.1";
-       sha256 = "034hidvwyl2yzh8wxfaydnsrfbgs12pim3hv33whdvpqzvy4aqlm";
+       version = "0.1.0.3";
+       sha256 = "169fadphm63gp3bqvrnmd3335rcf1dgybx1vp80mcysskvfabyia";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base bytestring c-enum nowdoc template-haskell
···
      , generic-lens, hashtables, http-client, http-client-tls
      , http-types, HUnit, iso8601-time, lens, lrucache, memory
      , monad-logger, monad-loops, mtl, pcre-light, random, scientific
-     , semver, text, time, unordered-containers, uuid, yaml
+     , semver, text, time, unordered-containers, uuid, yaml, zlib
      }:
      mkDerivation {
        pname = "launchdarkly-server-sdk";
-       version = "4.3.0";
-       sha256 = "0prsix4w6x3413pix2971nlwd1pnz6s8w91wq12wcbvyv6lvlb03";
+       version = "4.4.0";
+       sha256 = "1kqdnq8982n89b15chwwn72f6q0dyr4c9y2w91jh311yl479ghs4";
        libraryHaskellDepends = [
          aeson attoparsec base base16-bytestring bytestring clock containers
          cryptohash exceptions extra generic-lens hashtables http-client
          http-client-tls http-types iso8601-time lens lrucache memory
          monad-logger monad-loops mtl pcre-light random scientific semver
-         text time unordered-containers uuid yaml
+         text time unordered-containers uuid yaml zlib
        ];
        testHaskellDepends = [
          aeson attoparsec base base16-bytestring bytestring clock containers
          cryptohash exceptions extra generic-lens hashtables http-client
          http-client-tls http-types HUnit iso8601-time lens lrucache memory
          monad-logger monad-loops mtl pcre-light random scientific semver
-         text time unordered-containers uuid yaml
+         text time unordered-containers uuid yaml zlib
        ];
        description = "Server-side SDK for integrating with LaunchDarkly";
        license = lib.licenses.asl20;
···
        broken = true;
      }) {};
 
+  "lawful-conversions" = callPackage
+    ({ mkDerivation, base, bytestring, containers, hashable, primitive
+     , profunctors, QuickCheck, quickcheck-instances, rebase, tasty
+     , tasty-quickcheck, text, time, unordered-containers, uuid-types
+     , vector
+     }:
+     mkDerivation {
+       pname = "lawful-conversions";
+       version = "0.1.6";
+       sha256 = "1gp4z8g5smnhi31h4cpniha5g1lha6hh5rhh7cv1cwkrzh0cmkbg";
+       libraryHaskellDepends = [
+         base bytestring containers hashable primitive profunctors
+         QuickCheck text time unordered-containers uuid-types vector
+       ];
+       testHaskellDepends = [
+         bytestring primitive QuickCheck quickcheck-instances rebase tasty
+         tasty-quickcheck text
+       ];
+       description = "Lawful typeclasses for bidirectional conversion between types";
+       license = lib.licenses.mit;
+     }) {};
+
   "lawless-concurrent-machines" = callPackage
     ({ mkDerivation, async, base, containers, lifted-async, machines
      , monad-control, semigroups, tasty, tasty-hunit, time, transformers
···
      }:
      mkDerivation {
        pname = "layered-graph-drawing";
-       version = "0.1.0.0";
-       sha256 = "01fivjy6nf2zvcc20djyklq71pcl7mp9167ijc8vjxn75vq5scls";
+       version = "0.2.0.0";
+       sha256 = "0pfsnwjzckl35zsq65bk10gi63g17pivgv7hmcqc7d4avrwz7n3b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "ldap-scim-bridge";
-       version = "0.9";
-       sha256 = "13jndxxzrqc101q4bb7z2fig5cjjm8805b3335ni1hmx1imc16hp";
+       version = "0.10";
+       sha256 = "0pn3qp2p7w40wdagkwzq23i5dcimrsca1xwxh8jgffqr7zdym57v";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "learn-physics";
        version = "0.6.7";
        sha256 = "05lizs5vyknx5krprc7q12kb7nszy6qxf4zb7b2zzwv8r04ll23h";
+       revision = "1";
+       editedCabalFile = "193fycxpw3insffm6hd4ld6qmmxjrk83yildkqp22avbxi8kwq03";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "lens-regex-pcre_1_1_2_0" = callPackage
+    ({ mkDerivation, base, bytestring, containers, hspec, lens
+     , pcre-heavy, pcre-light, template-haskell, text
+     }:
+     mkDerivation {
+       pname = "lens-regex-pcre";
+         base containers convertible csv hinduce-associations-apriori
+       sha256 = "1w3bxk97pj5r45zm2nb3xcmzr24gvfy8bxcwavyicwa57xyz716a";
+       libraryHaskellDepends = [
+         base bytestring containers lens pcre-heavy pcre-light
+         template-haskell text
+       ];
+       testHaskellDepends = [
+         base bytestring containers hspec lens pcre-heavy pcre-light
+         template-haskell text
+       ];
+       description = "A lensy interface to regular expressions";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "lens-simple" = callPackage
     ({ mkDerivation, base, lens-family, lens-family-core
      , lens-family-th, mtl, transformers
···
      }:
      mkDerivation {
        pname = "lens-toml-parser";
-       version = "0.3.0.0";
-       sha256 = "1dl9rxs0njcsv6rfg4bmipxbvdr6240x5dsr8857c54cjffwp574";
+       version = "0.3.0.1";
+       sha256 = "12bfjda8inn97azhkraz96lv3a1i21nxbxc4zsbpf1pfm76hripf";
        libraryHaskellDepends = [ base profunctors text time toml-parser ];
        testHaskellDepends = [
          base containers dwergaz lens-family text toml-parser
···
        maintainers = [ lib.maintainers.rvl ];
      }) {};
 
-  "lentil_1_5_7_0" = callPackage
+  "lentil_1_5_8_0" = callPackage
     ({ mkDerivation, base, bytestring, csv, deepseq, directory, dlist
      , filemanip, filepath, hspec, hspec-discover, megaparsec, mtl
      , natural-sort, optparse-applicative, prettyprinter
···
      }:
      mkDerivation {
        pname = "lentil";
-       version = "1.5.7.0";
-       sha256 = "1xd68cfpq78w778j36d6hxsbi7cjdbsaab6ay0ian4b5a0qwnpic";
+       version = "1.5.8.0";
+       sha256 = "08g15kzynync0kl9f247sifzqpkjyvigc5r31w2n3vivi3pdcafn";
+       revision = "1";
+       editedCabalFile = "0n991bjlcjchmjlgfxg709sp6vsi6c5igzs7904i6hfabq3z47q5";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "libremidi" = callPackage
+    ({ mkDerivation, base, containers, data-default, mtl, pipewire, stm
+     , systemd, tasty, tasty-hunit, text, transformers
+     }:
+     mkDerivation {
+       pname = "libremidi";
+       version = "0.4.0";
+       sha256 = "1fqdrx7mpcxzib42nkn13lfsyq67rbc40gd4yrvlr4fxcmscdbkg";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base containers data-default mtl stm text transformers
+       ];
+       libraryPkgconfigDepends = [ pipewire systemd ];
+       executableHaskellDepends = [
+         base containers data-default mtl stm text transformers
+       ];
+       testHaskellDepends = [
+         base containers data-default mtl stm tasty tasty-hunit text
+         transformers
+       ];
+       description = "libremidi bindings for haskell";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "libremidi-exe";
+       broken = true;
+     }) {inherit (pkgs) pipewire; inherit (pkgs) systemd;};
+
   "libretls" = callPackage
     ({ mkDerivation, base, containers, hspec, HUnit, libressl, libtls
      , monad-ste, primitive, transformers, vector
···
   "libsecp256k1" = callPackage
     ({ mkDerivation, base, bytestring, deepseq, either, entropy
      , hashable, hedgehog, hspec, hspec-api, HUnit, memory, monad-par
-     , secp256k1, transformers
+     , random, secp256k1, transformers
      }:
      mkDerivation {
        pname = "libsecp256k1";
-       version = "0.2.1";
-       sha256 = "15kz61px1xpf80c6jaj7qmfs1274ad05kp61y1b1vybxiqbzrig1";
+       version = "0.3.0";
+       sha256 = "0avl6yqqq06jd3gw6djb29qavksavcy5hmpffp86s96hygl6vxak";
        libraryHaskellDepends = [
-         base bytestring deepseq entropy hashable hedgehog memory
+         base bytestring deepseq entropy hashable hedgehog memory random
          transformers
        ];
        libraryPkgconfigDepends = [ secp256k1 ];
        testHaskellDepends = [
          base bytestring deepseq either entropy hashable hedgehog hspec
-         hspec-api HUnit memory monad-par transformers
+         hspec-api HUnit memory monad-par random transformers
        ];
        description = "Bindings for secp256k1";
        license = lib.licenses.mit;
···
        broken = true;
      }) {inherit (pkgs) libtelnet;};
 
+  "libtorch-ffi" = callPackage
+    ({ mkDerivation, async, base, bytestring, c10, containers, hspec
+     , inline-c, inline-c-cpp, libtorch-ffi-helper, optparse-applicative
+     , safe-exceptions, sysinfo, template-haskell, torch, torch_cpu
+     }:
+     mkDerivation {
+       pname = "libtorch-ffi";
+       version = "2.0.0.1";
+       sha256 = "1qnfiz03w9gsw2v4c6w4rsy44823salnvgkqp67b51ga44ihwv0q";
+       libraryHaskellDepends = [
+         async base bytestring containers inline-c inline-c-cpp
+         libtorch-ffi-helper optparse-applicative safe-exceptions sysinfo
+         template-haskell
+       ];
+       librarySystemDepends = [ c10 torch torch_cpu ];
+       testHaskellDepends = [ base hspec safe-exceptions ];
+       description = "Haskell bindings for PyTorch";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {c10 = null; torch = null; torch_cpu = null;};
+
+  "libtorch-ffi-helper" = callPackage
+    ({ mkDerivation, base, ghc }:
+     mkDerivation {
+       pname = "libtorch-ffi-helper";
+       version = "2.0.0.0";
+       sha256 = "04vf7in5pj7wl17cmj5v1km1riny8fy69yabi2yjzs554kaggzj0";
+       libraryHaskellDepends = [ base ghc ];
+       description = "Helpers for integrating libtorch-ffi with Hasktorch";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "libversion" = callPackage
     ({ mkDerivation, base, bytestring, libversion }:
      mkDerivation {
···
      }) {};
 
   "libxml-sax" = callPackage
-    ({ mkDerivation, base, bytestring, libxml2, text, xml-types }:
+    ({ mkDerivation, base, bytestring, chell, containers, libxml2, text
+     , transformers, xml-types
+     }:
      mkDerivation {
        pname = "libxml-sax";
-       version = "0.7.5";
-       sha256 = "0lbdq6lmiyrnzk6gkx09vvp928wj8qnqnqfzy14mfv0drj21f54r";
+       version = "0.7.6";
+       sha256 = "1zzd2wyaq7yly5x8ikfv5lyxvmw8psln3kmkl0y3sm0kqf6zcj92";
        libraryHaskellDepends = [ base bytestring text xml-types ];
        librarySystemDepends = [ libxml2 ];
        libraryPkgconfigDepends = [ libxml2 ];
+       testHaskellDepends = [
+         base bytestring chell containers text transformers xml-types
+       ];
        description = "Bindings for the libXML2 SAX interface";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {inherit (pkgs) libxml2;};
 
   "libxslt" = callPackage
···
        pname = "lift-generics";
        version = "0.3";
        sha256 = "1walsrpschxg2bqw925z6cr24cznrcq04bb37azvwdcfrbl19r7a";
+       revision = "1";
+       editedCabalFile = "101rh63bgq9kwiqfzylijy28y9is6xfa13swscygr5jw3nm061mp";
        libraryHaskellDepends = [
          base ghc-prim template-haskell th-compat
        ];
···
      }:
      mkDerivation {
        pname = "lifted-async";
-       version = "0.10.2.6";
-       sha256 = "1sh11zpmmxbkf00j6k0k858yhxpn7fckvw3d5yynkw263pz1hrzn";
-       revision = "1";
-       editedCabalFile = "0i1m2ia4cdm1kak6n8jl0ln015frdcsil2xw1gvamdci7zqq587k";
-       libraryHaskellDepends = [
-         async base constraints lifted-base monad-control transformers-base
-       ];
-       testHaskellDepends = [
-         async base HUnit lifted-base monad-control mtl tasty
-         tasty-expected-failure tasty-hunit tasty-th
-       ];
-       benchmarkHaskellDepends = [ async base deepseq tasty-bench ];
-       description = "Run lifted IO operations asynchronously and wait for their results";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "lifted-async_0_10_2_7" = callPackage
-    ({ mkDerivation, async, base, constraints, deepseq, HUnit
-     , lifted-base, monad-control, mtl, tasty, tasty-bench
-     , tasty-expected-failure, tasty-hunit, tasty-th, transformers-base
-     }:
-     mkDerivation {
-       pname = "lifted-async";
        version = "0.10.2.7";
        sha256 = "0m9xzlj9hrbs0j4sak2jdvm13l66mpr2k99xcv7rhy8wfssvz0f2";
        libraryHaskellDepends = [
···
        benchmarkHaskellDepends = [ async base deepseq tasty-bench ];
        description = "Run lifted IO operations asynchronously and wait for their results";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "lifted-base" = callPackage
···
     ({ mkDerivation, base, sbv }:
      mkDerivation {
        pname = "linearEqSolver";
-       version = "2.3";
-       sha256 = "0lrrgix4m2sbfw9ydcqnx45lka0grl8ndiiy3cs1xg4xpcy2fkjw";
+       version = "2.4";
+       sha256 = "1fv3gadnxxg0g8wb5v5a4fj9ny5zdhwhw2ykbzizgp7mzg90pz27";
        libraryHaskellDepends = [ base sbv ];
        description = "Use SMT solvers to solve linear systems over integers and rationals";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "linenoise";
-       version = "0.4.0";
-       sha256 = "0j91vskwkjn98acbx8jgxq76xk53bzds2k9b9zjfra5y17bn0gqr";
+       version = "0.4.2";
+       sha256 = "19fzj9rwsajh702vhhfshwkwd5kwgl8c5iw02j8wiivamnvrv611";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        maintainers = [ lib.maintainers.alexfmpe ];
      }) {};
 
+  "linux-namespaces_0_2_0_1" = callPackage
+    ({ mkDerivation, base, bytestring, unix }:
+     mkDerivation {
+       pname = "linux-namespaces";
+       version = "0.2.0.1";
+       sha256 = "11giyfb1r7n8y4f2bvjycg4zv0c2dh9s64qcmvlr5akwvwjlzylb";
+       libraryHaskellDepends = [ base bytestring unix ];
+       description = "Work with linux namespaces: create new or enter existing ones";
+       license = lib.licenses.bsd3;
+       platforms = lib.platforms.linux;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = [ lib.maintainers.alexfmpe ];
+     }) {};
+
   "linux-perf" = callPackage
     ({ mkDerivation, base, binary, bytestring, containers, directory
      , filepath, ghc-events, mtl, pretty, process, unix
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "little-logger_3_0_0" = callPackage
+  "little-logger_3_0_1" = callPackage
     ({ mkDerivation, base, directory, monad-logger, mtl, optics, tasty
      , tasty-hunit, temporary, text, unliftio-core
      }:
      mkDerivation {
        pname = "little-logger";
-       version = "3.0.0";
-       sha256 = "1ckhkv6pj0sbjs7kn11jb8x5v4ilm8rx51mmi84zyzmxfkrpamwf";
+       version = "3.0.1";
+       sha256 = "1wqgpr21rl2jcfpspqhhl63apyzyj1906clg3ibl97ckqwcyrz97";
        libraryHaskellDepends = [
          base monad-logger mtl optics text unliftio-core
        ];
···
      }:
      mkDerivation {
        pname = "log-effectful";
-       version = "1.0.0.0";
-       sha256 = "19i0zvhgpc0briji7hsini3836q0k03nq60svswfz6cjs91izzsx";
-       libraryHaskellDepends = [ base effectful-core log-base text time ];
+       version = "1.0.1.0";
+       sha256 = "00fagiw9wx8ga1d456rdd38hqq7a4rl2bs9hvrgg5bp2qna1i1cq";
+       libraryHaskellDepends = [
+         aeson base effectful-core log-base text time
+       ];
        testHaskellDepends = [ aeson base effectful-core log-base text ];
        description = "Adaptation of the log library for the effectful ecosystem";
        license = lib.licenses.bsd3;
···
      }) {};
 
   "logic-TPTP" = callPackage
-    ({ mkDerivation, alex, ansi-wl-pprint, array, base, containers
-     , happy, mtl, pcre-light, pointed, QuickCheck, semigroups, syb
-     , transformers, transformers-compat
+    ({ mkDerivation, alex, array, base, containers, happy, mtl
+     , pcre-light, pointed, prettyprinter, prettyprinter-ansi-terminal
+     , QuickCheck, semigroups, syb, text, transformers
      }:
      mkDerivation {
        pname = "logic-TPTP";
-       version = "0.5.1.0";
-       sha256 = "1s3r85zw5ci5mg9rrik351xxi5k8cszlpdanwpxyrinjd3y6j01i";
+       version = "0.6.0.0";
+       sha256 = "0dicg310lbj5zb0lbvsvvvb5wsabpcm6plq6n5v1nppjz954yhlw";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         ansi-wl-pprint array base containers mtl pointed QuickCheck
-         semigroups syb transformers transformers-compat
+         array base containers mtl pointed prettyprinter
+         prettyprinter-ansi-terminal QuickCheck semigroups syb text
+         transformers
        ];
        libraryToolDepends = [ alex happy ];
        testHaskellDepends = [
-         ansi-wl-pprint base pcre-light QuickCheck semigroups transformers
-         transformers-compat
+         base pcre-light prettyprinter prettyprinter-ansi-terminal
+         QuickCheck semigroups transformers
        ];
        description = "Import, export etc. for TPTP, a syntax for first-order logic";
        license = "GPL";
···
      }) {};
 
   "logict" = callPackage
-    ({ mkDerivation, async, base, mtl, tasty, tasty-hunit, transformers
+    ({ mkDerivation, async, base, exceptions, mtl, tasty, tasty-hunit
+     , transformers
      }:
      mkDerivation {
        pname = "logict";
-       version = "0.8.1.0";
-       sha256 = "04xqwfbvh5gfjwbvmadbakq0932gskh2gy68aw7251443ic4gp6k";
-       revision = "1";
-       editedCabalFile = "0ckbljn4rcvbnni6ldn6wd5p4c6y6dx5ixc8hg2i9a7irllgifr9";
+       version = "0.8.2.0";
+       sha256 = "1vxb8vyfhvl901kfywvr4czwmiz3ah4l9rlcrx7djs4f3kwfd6hq";
        isLibrary = true;
        isExecutable = true;
-       libraryHaskellDepends = [ base mtl transformers ];
+       libraryHaskellDepends = [ base exceptions mtl transformers ];
        testHaskellDepends = [
          async base mtl tasty tasty-hunit transformers
        ];
···
      }:
      mkDerivation {
        pname = "looksee";
-       version = "0.6.0";
-       sha256 = "1vv48fnr1dbbkcyw6cvfal3fggyn7rw4gzwzvix1qyyfsl9g7cm9";
+       version = "0.8.0";
+       sha256 = "0nzbcw766wpn86z8vsmf765zisw8af3304nas2fngm7hkv77v5ds";
        libraryHaskellDepends = [
          base bifunctors containers errata mmorph mtl recursion-schemes
          scientific text vector
···
      }) {};
 
   "looksee-trip" = callPackage
-    ({ mkDerivation, base, daytripper, looksee, prettyprinter, text }:
+    ({ mkDerivation, base, daytripper, looksee, prettyprinter
+     , prop-unit, text
+     }:
      mkDerivation {
        pname = "looksee-trip";
-       version = "0.6.0";
-       sha256 = "0nc7i12swdq4shz4brkrblkx306fgc5lcfqc3crb9kiq014qd2c5";
+       version = "0.8.0";
+       sha256 = "0hr6zz8f69w2ijvid8l7d1dxl2sablx3f3vjx494lla9k3hy6ss9";
        libraryHaskellDepends = [
-         base daytripper looksee prettyprinter text
+         base daytripper looksee prettyprinter prop-unit text
        ];
        description = "A simple text parser with decent errors";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "looper";
-       version = "0.3.0.1";
-       sha256 = "0kcy4pr7z6ppqgnxbssp597qyjgcm25pdhbhzxjp0n205nywiz11";
+       version = "0.3.0.2";
+       sha256 = "1dbygq6m4gdzvjz5jsf8bbsw1igr5y3g554vl6gqpkhxvya83y4c";
        libraryHaskellDepends = [ base opt-env-conf text time unliftio ];
        testHaskellDepends = [
          base opt-env-conf opt-env-conf-test sydtest unliftio
···
        pname = "lsp";
        version = "2.7.0.0";
        sha256 = "1vxyl3p4b4nskl4icvw5087683lbr5zjj64wwmckw3l2hgvqwr6j";
+       revision = "1";
+       editedCabalFile = "0zmzs0adh7p7zp9c67qn4p8glxlx1k5b09hp8czsns23jbl7ziff";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "lz4-frame-conduit";
        version = "0.1.0.1";
        sha256 = "0n07cgdwq2miskgqj354hnjghmp555d7n8b39b00sjigdjzkbala";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring conduit conduit-extra containers inline-c
+         raw-strings-qq resourcet template-haskell unliftio unliftio-core
+       ];
+       executableHaskellDepends = [
+         base bytestring conduit conduit-extra optparse-applicative
+         resourcet text
+       ];
+       testHaskellDepends = [
+         base bytestring conduit conduit-extra hspec QuickCheck resourcet
+         unliftio-core
+       ];
+       description = "Conduit implementing the official LZ4 frame streaming format";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "haskell-lz4c";
+       broken = true;
+     }) {};
+
+  "lz4-frame-conduit_0_1_0_2" = callPackage
+    ({ mkDerivation, base, bytestring, conduit, conduit-extra
+     , containers, hspec, inline-c, optparse-applicative, QuickCheck
+     , raw-strings-qq, resourcet, template-haskell, text, unliftio
+     , unliftio-core
+     }:
+     mkDerivation {
+       pname = "lz4-frame-conduit";
+       version = "0.1.0.2";
+       sha256 = "06b9c8p75smmhzi9gy2sql3ivrfjk3y2lmf03wi76prwx5z6rp4c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "matchable_0_2" = callPackage
+    ({ mkDerivation, base, base-orphans, containers, generically
+     , hashable, hspec, tagged, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "matchable";
+       version = "0.2";
+       sha256 = "06k4bwckf4rpji11xky83gb0zrfbfggjf85l9kcz5yc3p1l909ma";
+       libraryHaskellDepends = [
+         base base-orphans containers generically hashable tagged
+         unordered-containers vector
+       ];
+       testHaskellDepends = [ base containers generically hspec ];
+       description = "A type class for Matchable Functors";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "matchable-th" = callPackage
     ({ mkDerivation, base, bifunctors, containers, matchable
      , template-haskell, th-abstraction
      }:
      mkDerivation {
        pname = "matchable-th";
-       version = "0.2";
-       sha256 = "1v2r38r59wk699nsql3mw7z83gm1snvnci146ply34za7i42zp54";
-       revision = "1";
-       editedCabalFile = "17mdf8bsq9s2w4bl76zink0k55my43a3702f0zfxgqy5p2b09pkw";
+       version = "0.2.1";
+       sha256 = "0yxm9r33x0cis2fq3n9hpi0g457ai616x8525pyvh3iz6gfs2whz";
        libraryHaskellDepends = [
          base bifunctors matchable template-haskell th-abstraction
        ];
···
        license = lib.licenses.bsd2;
      }) {};
 
-  "megaparsec_9_6_1" = callPackage
-    ({ mkDerivation, base, bytestring, case-insensitive, containers
-     , criterion, deepseq, mtl, parser-combinators, scientific, text
-     , transformers, weigh
+  "megaparsec_9_7_0" = callPackage
+    ({ mkDerivation, array, base, bytestring, case-insensitive
+     , containers, criterion, deepseq, mtl, parser-combinators
+     , scientific, text, transformers, weigh
      }:
      mkDerivation {
        pname = "megaparsec";
-       version = "9.6.1";
-       sha256 = "1zyb1mqa2mjjig5aggndifh6zqlwbw8sn4nm4an73gkxhjz5f8m3";
+       version = "9.7.0";
+       sha256 = "15zc66lplq5382wayigcw9kql08nvp9403a8f9xaw85z4lv45vdr";
        libraryHaskellDepends = [
-         base bytestring case-insensitive containers deepseq mtl
+         array base bytestring case-insensitive containers deepseq mtl
          parser-combinators scientific text transformers
        ];
        benchmarkHaskellDepends = [
···
        license = lib.licenses.bsd2;
      }) {};
 
-  "megaparsec-tests_9_6_1" = callPackage
+  "megaparsec-tests_9_7_0" = callPackage
     ({ mkDerivation, base, bytestring, case-insensitive, containers
      , hspec, hspec-discover, hspec-megaparsec, megaparsec, mtl
      , QuickCheck, scientific, temporary, text, transformers
      }:
      mkDerivation {
        pname = "megaparsec-tests";
-       version = "9.6.1";
-       sha256 = "1l3rmg4ymw4czqkkb3502g322ijdg11c1img9l4p6ipy7hdzw52n";
-       revision = "1";
-       editedCabalFile = "0vycmn3c32z1bk19612277df41in55rkyk23gk3m007drsaq3xdl";
+       version = "9.7.0";
+       sha256 = "17jwz62f8lnrfmmfrsv1jcvn9wmpk4jlhmxjwk5qqx2iyijnrpb1";
        libraryHaskellDepends = [
          base bytestring containers hspec hspec-megaparsec megaparsec mtl
          QuickCheck text transformers
···
        broken = true;
      }) {};
 
+  "mello" = callPackage
+    ({ mkDerivation, base, bowtie, containers, daytripper, foldl
+     , looksee, looksee-trip, mtl, prettyprinter, prop-unit
+     , recursion-schemes, scientific, text
+     }:
+     mkDerivation {
+       pname = "mello";
+       version = "0.3.0";
+       sha256 = "0aznzydk9p4r7jnwhf46dcz56gwikyv1fm006w5n3nxf20qqaybb";
+       libraryHaskellDepends = [
+         base bowtie containers foldl looksee mtl prettyprinter
+         recursion-schemes scientific text
+       ];
+       testHaskellDepends = [
+         base bowtie containers daytripper foldl looksee looksee-trip mtl
+         prettyprinter prop-unit recursion-schemes scientific text
+       ];
+       description = "No-fuss syntax with s-expressions";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "mellon-core" = callPackage
     ({ mkDerivation, async, base, doctest, hspec, mtl, protolude
      , QuickCheck, quickcheck-instances, time, transformers
···
        description = "Hex-string type for Haskell Web3 library";
        license = lib.licenses.asl20;
        hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "memory-pool" = callPackage
+    ({ mkDerivation, async, base, criterion, deepseq, primitive, pvar
+     , QuickCheck, random, reflection, tasty, tasty-hunit
+     , tasty-quickcheck, unliftio
+     }:
+     mkDerivation {
+       pname = "memory-pool";
+       version = "0.1.0.0";
+       sha256 = "0ip3fdapszbv7kb1m61qq7aznw6b48lc87n1nlm419xpsfqm4gri";
+       libraryHaskellDepends = [ base primitive pvar ];
+       testHaskellDepends = [
+         async base primitive pvar QuickCheck random reflection tasty
+         tasty-hunit tasty-quickcheck
+       ];
+       benchmarkHaskellDepends = [ base criterion deepseq unliftio ];
+       description = "Short description";
+       license = lib.licenses.asl20;
      }) {};
 
   "memorypool" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "microlens-platform_0_4_3_6" = callPackage
+    ({ mkDerivation, base, hashable, microlens, microlens-ghc
+     , microlens-mtl, microlens-th, text, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "microlens-platform";
+       version = "0.4.3.6";
+       sha256 = "0bbskwm9lh2lmk54a0hwc4aq9fpw4zpq5089nd7w2w0m9rny9jka";
+       libraryHaskellDepends = [
+         base hashable microlens microlens-ghc microlens-mtl microlens-th
+         text unordered-containers vector
+       ];
+       description = "microlens + all batteries included (best for apps)";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "microlens-pro" = callPackage
     ({ mkDerivation, base, containers, microlens, microlens-contra
      , microlens-platform, microlens-th, mtl, profunctors, tagged
···
      }:
      mkDerivation {
        pname = "microlens-pro";
-       version = "0.2.0.1";
-       sha256 = "16bb5myflaxwksqkl890vg3349sd5lcr6g2iaq8kn82k3wkq0ynm";
+       version = "0.2.0.2";
+       sha256 = "1n4qfv55xax420zy4g9xwh8sq3mmmcybblx80iw5kigsmvhs6kdm";
        libraryHaskellDepends = [
          base containers microlens microlens-contra microlens-platform
          microlens-th mtl profunctors tagged template-haskell text
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "microlens-th_0_4_3_16" = callPackage
+    ({ mkDerivation, base, containers, microlens, tagged
+     , template-haskell, th-abstraction, transformers
+     }:
+     mkDerivation {
+       pname = "microlens-th";
+       version = "0.4.3.16";
+       sha256 = "1gd4rz00x4akaf3wfchvbk90ra9kjqsv3ixkcnsbrij3hhjb2w47";
+       libraryHaskellDepends = [
+         base containers microlens template-haskell th-abstraction
+         transformers
+       ];
+       testHaskellDepends = [ base microlens tagged ];
+       description = "Automatic generation of record lenses for microlens";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "micrologger" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, hspec, lens
      , text, text-format, time, transformers
···
        pname = "mighty-metropolis";
        version = "2.0.0";
        sha256 = "0r1viswlggm6y7k3x5cvfmbly8jmk1ivhfp8vpgvkamxagzhkrk4";
+       revision = "1";
+       editedCabalFile = "0l4702l1rd17wvsiwfaz47nj7sqwaa1zsdz7w82aym29ll3j1b1k";
        libraryHaskellDepends = [
          base kan-extensions mcmc-types mwc-probability pipes primitive
          transformers
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "mini";
-       version = "1.4.1.0";
-       sha256 = "1jlvr88w038p6a9ssljjpf5jdr9b9008rdwibzqcbs1x5sxmf2xw";
+       version = "1.5.0.0";
+       sha256 = "13lyxlhvkrmwgpf6fk58sagd30dz5z2b3n8ipfgz9c0r53lcwa0d";
        libraryHaskellDepends = [ base ];
        description = "Minimal essentials";
        license = lib.licenses.mit;
···
        pname = "miso";
        version = "1.8.5.0";
        sha256 = "0lbr1hwaidsscrqp3p6p3rr5q1mxfg3f7bb62x974jll3lisxlyb";
+       revision = "1";
+       editedCabalFile = "18zwq74mzv0qkila4dq554nrcziaz946chmb51jrhx8p2mdspa7y";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "mmsyn7l" = callPackage
-    ({ mkDerivation, base, directory, mmsyn2-array, mmsyn3
+    ({ mkDerivation, base, directory, end-of-exe, mmsyn2-array
      , mmsyn7ukr-common, process
      }:
      mkDerivation {
        pname = "mmsyn7l";
-       version = "0.9.1.0";
-       sha256 = "0c8gcvbb2xw89cnf2h85cbm9n2zxqdqc0kkbh9w3vx2zsyy5865i";
+       version = "0.9.2.0";
+       sha256 = "1h1l1pzy3vwg1ciidq15cdn5cxpm25ccl0i9f99d8l1c3xljz9g9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         base directory mmsyn2-array mmsyn3 mmsyn7ukr-common process
+         base directory end-of-exe mmsyn2-array mmsyn7ukr-common process
        ];
        executableHaskellDepends = [
-         base directory mmsyn2-array mmsyn3 mmsyn7ukr-common process
+         base directory end-of-exe mmsyn2-array mmsyn7ukr-common process
        ];
        description = "Modifies the amplitudes of the sounds representations created by mmsyn7ukr-array and mmsyn7ukr packages";
        license = lib.licenses.mit;
···
      }) {};
 
   "mmsyn7ukr-array" = callPackage
-    ({ mkDerivation, base, directory, mmsyn2-array, mmsyn3
+    ({ mkDerivation, base, directory, end-of-exe, mmsyn2-array
      , mmsyn7ukr-common, process
      }:
      mkDerivation {
        pname = "mmsyn7ukr-array";
-       version = "0.2.0.0";
-       sha256 = "0wh0a141mwkn0bzv4r4kzzfw1xdg6l70pvpibm60d5slknlm4spz";
+       version = "0.3.0.0";
+       sha256 = "1y4ml7dq1k2czbf0f7x0ij2h7rsaisl7zs6q1sg4brmci4251i56";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
-         base directory mmsyn2-array mmsyn3 mmsyn7ukr-common process
+         base directory end-of-exe mmsyn2-array mmsyn7ukr-common process
        ];
-       description = "A simple reduced basic interface to some SoX functionality or to produce a voice that can be used by mmsyn7h-array, dobutokO2-array and other similar packages";
+       description = "A simple reduced basic interface to some SoX functionality or to produce a voice that can be used by dobutokO2 and other similar packages";
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
      }) {};
 
   "mmsyn7ukr-common" = callPackage
-    ({ mkDerivation, base, directory, mmsyn3, process }:
+    ({ mkDerivation, base, directory, end-of-exe, process }:
      mkDerivation {
        pname = "mmsyn7ukr-common";
-       version = "0.2.0.0";
-       sha256 = "0d7i1xhys493mx6ynn7zx7jidjffkkmnid5llwyk8m4040riw8ay";
-       libraryHaskellDepends = [ base directory mmsyn3 process ];
+       version = "0.3.1.0";
+       sha256 = "021vrlljbavlvsangh870xyd8wixnic5p287g6kgdsgf2zb8zx5h";
+       libraryHaskellDepends = [ base directory end-of-exe process ];
        description = "Some common for mmsyn7ukr and mmsyn7ukr-array functionality using SoX";
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
···
   "mock-time" = callPackage
     ({ mkDerivation, base, error-or, error-or-utils, exceptions, inbox
      , mtl, primitive, QuickCheck, resourcet, stm, tasty, tasty-hunit
-     , tasty-quickcheck, time, unliftio-core
+     , tasty-quickcheck, time, transformers, unliftio-core
      }:
      mkDerivation {
        pname = "mock-time";
-       version = "0.1.0";
-       sha256 = "0fwnlkg3kbi7qh43ycymxxywsh8cw5f5km0ni4plf63k931y40jg";
+       version = "0.1.1";
+       sha256 = "1j37p2d6c7m48s8zs4s37ggvjdhhjzghck5yw5c062mnx1j9j1ni";
        libraryHaskellDepends = [
          base error-or exceptions mtl primitive resourcet stm time
-         unliftio-core
+         transformers unliftio-core
        ];
        testHaskellDepends = [
          base error-or error-or-utils exceptions inbox mtl primitive
          QuickCheck resourcet stm tasty tasty-hunit tasty-quickcheck time
-         unliftio-core
+         transformers unliftio-core
        ];
        description = "Mock time in tests";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "mockcat";
-       version = "0.5.1.0";
-       sha256 = "08z3v6wvm42hgjsl5diqmv4m8j6idxnwy37w9fph8i22a2kf5hn8";
+       version = "0.5.2.0";
+       sha256 = "0b3i5vswlijyf3142shwrw1z8vj152b4k466c0310ayih3mcc61p";
        libraryHaskellDepends = [
          base mtl template-haskell text transformers
        ];
···
      }:
      mkDerivation {
        pname = "monad-bayes";
-       version = "1.3.0.3";
-       sha256 = "14fgmzr7mqcczrixx3hdbi64bd2vs7gbdhcvsn7jajyldjyqdkpf";
+       version = "1.3.0.4";
+       sha256 = "0r7gmymd8vy8q0hgkm2s9qmlm3q93nss6yl7rahpl2lxb838qrfy";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        pname = "monad-ideals";
        version = "0.1.1.0";
        sha256 = "04wgb39kj7j3v9df5g8ij7n7fndhjic93y88k0wxpmzd9ywd6zdf";
+       revision = "1";
+       editedCabalFile = "021gfnffc7m5i3k6wr5ksxyd2bck6hg7h2spbk9wxn46zcdi9z7c";
        libraryHaskellDepends = [
          base bifunctor-classes-compat comonad semigroupoids
        ];
···
      }:
      mkDerivation {
        pname = "monadic-bang";
-       version = "0.2.2.1";
-       sha256 = "1map2ywq3inzqki6fkw8f5frx85cic1c06ccyy3p0laahlz8i1z8";
+       version = "0.2.2.2";
+       sha256 = "149hxzgm1awa9rn9z8f9pgwy2i703va549wgkq7sfy77vmir4lzc";
        libraryHaskellDepends = [
          base containers fused-effects ghc transformers
        ];
···
        license = lib.licenses.bsd2;
      }) {};
 
+  "monadology_0_4" = callPackage
+    ({ mkDerivation, base, constraints, invariant, tasty, tasty-hunit
+     , text, transformers, type-rig, witness
+     }:
+     mkDerivation {
+       pname = "monadology";
+       version = "0.4";
+       sha256 = "0l1bxpws6r132g8baiich90x6sfrsyn66z1ca3akqkfk4p2qbj0r";
+       libraryHaskellDepends = [
+         base constraints invariant transformers type-rig witness
+       ];
+       testHaskellDepends = [ base tasty tasty-hunit text ];
+       description = "The best ideas in monad-related classes and types";
+       license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "monadplus" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
        pname = "monads-tf";
        version = "0.3.0.1";
        sha256 = "00jzz9lqpz3s5xwvmc5xi300jkkjv9bk62k0jgwnqfv6py9x5g11";
-       revision = "1";
-       editedCabalFile = "1036p9bn11xmm7hdwbr9dxz8fr9bqsbw0sma5fbqlyzp18b0qz2v";
+       revision = "2";
+       editedCabalFile = "1wyfl2w8pfkg233180qlk65kka41iqb2hgxsyx700sfqd4p9vs36";
        libraryHaskellDepends = [ base transformers ];
        description = "Monad classes, using type families";
        license = lib.licenses.bsd3;
···
        license = lib.licenses.mit;
      }) {};
 
+  "mono-traversable_1_0_21_0" = callPackage
+    ({ mkDerivation, base, bytestring, containers, deepseq, foldl
+     , gauge, hashable, hspec, hspec-discover, HUnit, mwc-random
+     , QuickCheck, split, text, transformers, unordered-containers
+     , vector, vector-algorithms
+     }:
+     mkDerivation {
+       pname = "mono-traversable";
+       version = "1.0.21.0";
+       sha256 = "1kf5qwicr8ld4bgkzijxwpzppfwdr4wsl1rg8009a5n06jikxnad";
+       libraryHaskellDepends = [
+         base bytestring containers hashable split text transformers
+         unordered-containers vector vector-algorithms
+       ];
+       testHaskellDepends = [
+         base bytestring containers foldl hspec HUnit QuickCheck text
+         transformers unordered-containers vector
+       ];
+       testToolDepends = [ hspec-discover ];
+       benchmarkHaskellDepends = [
+         base bytestring containers deepseq gauge mwc-random text vector
+       ];
+       description = "Type classes for mapping, folding, and traversing monomorphic containers";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "mono-traversable-instances" = callPackage
     ({ mkDerivation, base, comonad, containers, dlist, dlist-instances
      , mono-traversable, semigroupoids, semigroups, transformers
···
   "monomer-flatpak-example" = callPackage
     ({ mkDerivation, async, base, bytestring, c2hs, containers
      , data-default, dbus, desktop-portal, directory, file-io, filepath
-     , libpipewire, libspa, modern-uri, monomer, monomer-hagrid, random
-     , text
+     , modern-uri, monomer, monomer-hagrid, pipewire, random, text
      }:
      mkDerivation {
        pname = "monomer-flatpak-example";
···
          directory file-io filepath modern-uri monomer monomer-hagrid random
          text
        ];
-       executablePkgconfigDepends = [ libpipewire libspa ];
+       executablePkgconfigDepends = [ pipewire ];
        executableToolDepends = [ c2hs ];
        description = "Monomer Flatpak Example Application";
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
        mainProgram = "monomer-flatpak-example";
-     }) {libpipewire = null; libspa = null;};
+     }) {inherit (pkgs) pipewire;};
 
   "monomer-hagrid" = callPackage
     ({ mkDerivation, base, bytestring, containers, data-default, hspec
···
      }) {};
 
   "mtl-misc-yj" = callPackage
-    ({ mkDerivation, base, mtl, try-monads-tf-misc-yj }:
+    ({ mkDerivation, base, mtl }:
      mkDerivation {
        pname = "mtl-misc-yj";
-       version = "0.1.0.2";
-       sha256 = "1gyygnqgqklh133z57wr3dvqc885fmdxbivlaxrf3p41wh5ywwg4";
-       revision = "1";
-       editedCabalFile = "1bra354gjnfx67czl0mr7hzyhwrxj71x5pcxn9m6sh5mcf5zpkm7";
+       version = "0.1.0.4";
+       sha256 = "04lrfikgjp6p6f459d0nfarp7ia6q86bx3smn5pyvnhrvhbn4alf";
        libraryHaskellDepends = [ base mtl ];
-       testHaskellDepends = [ base mtl try-monads-tf-misc-yj ];
+       testHaskellDepends = [ base mtl ];
        description = "tribial tools about mtl";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
-     }) {try-monads-tf-misc-yj = null;};
+     }) {};
 
   "mtl-prelude" = callPackage
     ({ mkDerivation, base, mtl, transformers }:
···
     ({ mkDerivation, base, bytestring }:
      mkDerivation {
        pname = "murmur-hash";
-       version = "0.1.0.10";
-       sha256 = "145z91zkx8jdd3y181pi8z9imqjgpk99cl55pbda4fl201hasbz9";
-       revision = "1";
-       editedCabalFile = "18wlx3hsba3kvpa1z95dz0xglr97lf62irlr6wg6i0613br58sh3";
+       version = "0.1.0.11";
+       sha256 = "1zkd575b6rgs0js4vsr56hy7xhjmvbwxibiwcm6q2wgz5c9igaki";
        libraryHaskellDepends = [ base bytestring ];
        description = "MurmurHash2 implementation for Haskell";
        license = lib.licenses.bsd3;
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "network_3_2_5_0" = callPackage
+  "network_3_2_7_0" = callPackage
     ({ mkDerivation, base, bytestring, deepseq, directory, hspec
      , hspec-discover, HUnit, QuickCheck, stm, temporary
      }:
      mkDerivation {
        pname = "network";
-       version = "3.2.5.0";
-       sha256 = "1ijcdfvznr8diarzj525gcfnjc1r7dqlxr16mbwibvzlj5w4f0ym";
+       version = "3.2.7.0";
+       sha256 = "12vjx5nr65x7wz5napj85cvp60l8rh4gwcqc4fdw18rj0rk8wm38";
        libraryHaskellDepends = [ base bytestring deepseq directory stm ];
        testHaskellDepends = [
          base bytestring directory hspec HUnit QuickCheck temporary
···
     ({ mkDerivation, array, base, containers, mtl }:
      mkDerivation {
        pname = "network-house";
-       version = "0.1.0.2";
-       sha256 = "0hxbzzdjrxnx9pknsbma7iyfr3pxrsff5n9mhbkpaqaizhibq7q7";
+       version = "0.1.0.3";
+       sha256 = "0k6m3afb23pg0vzfx1w0jbgf9fvqhxxb0w55dn8qbxz9xxqqi45j";
        libraryHaskellDepends = [ array base containers mtl ];
        description = "data and parsers for Ethernet, TCP, UDP, IPv4, IPv6, ICMP, DHCP, TFTP";
        license = lib.licenses.gpl2Only;
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "network-run_0_4_1" = callPackage
+  "network-run_0_4_3" = callPackage
     ({ mkDerivation, base, bytestring, network, time-manager }:
      mkDerivation {
        pname = "network-run";
-       version = "0.4.1";
-       sha256 = "1yl2y910s7b4a31anifl5agba88fwgn4k7958k56nk37hjwj0aq8";
+       version = "0.4.3";
+       sha256 = "0phx8p1bha12l14d3bdb7kh9wjqn150q3ymvlsr7szmkq8x9vwh6";
        libraryHaskellDepends = [ base bytestring network time-manager ];
        description = "Simple network runner library";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "ngx-export-distribution";
-       version = "0.6.0.0";
-       sha256 = "0j2z8k5grxz570gbf931v7b06v1yd94gr3l6wv960xdlwl1145qw";
+       version = "0.6.0.1";
+       sha256 = "1in397s832ivw5wqvdydbc3j63cmmzvra8lfic6476dpm9k1m8s4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base Cabal directory filepath ];
···
      }:
      mkDerivation {
        pname = "nix-diff";
-       version = "1.0.20";
-       sha256 = "0p45fp1bl7n6yqwwlyy2cnmrj8ijq773hb5rqrzvb2n89wvilaga";
+       version = "1.0.21";
+       sha256 = "0c9v9n75p1zfr546l2h2n0d42whyr1xm5whq86a22inmjqrbbq4y";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "nothunks";
        version = "0.3.0.0";
        sha256 = "0fnwad49mv0q46wrnapkqh4hm4rm43gw0papppqrg0z96r658yc4";
+       revision = "1";
+       editedCabalFile = "08w1sgh8z7i24623bx7lkhap80zmfhs4kfxgylsvz0zb8hbg7gvp";
        libraryHaskellDepends = [
          base bytestring containers ghc-heap stm text time vector
          wherefrom-compat
···
      }:
      mkDerivation {
        pname = "nri-redis";
-       version = "0.2.0.2";
-       sha256 = "0hp8sbf7pvnplzg13n42xfp169japknm3z0szzspg2khi5fgwk86";
+       version = "0.2.0.3";
+       sha256 = "17rpdmqqfv6iyhjjf7lrr6hbn0mlz71i8llx7617d3v34y1bh3r0";
        libraryHaskellDepends = [
          aeson async base bytestring conduit containers cryptohash-sha1
          haskell-src-meta hedis megaparsec modern-uri nri-env-parser
···
      }) {};
 
   "numbered-semigroups" = callPackage
-    ({ mkDerivation, base, call-stack, semigroups }:
+    ({ mkDerivation, base, call-stack, semigroups, tagged, void }:
      mkDerivation {
        pname = "numbered-semigroups";
-       version = "0.1.0.0";
-       sha256 = "100r6k3cwycl75mj9g1x4w4qv064v8bdaan5rsj2vnvx4w1jrhp2";
-       revision = "3";
-       editedCabalFile = "1qi8cdying5l7anffawxjyjrqpvngg95aj646ahxr6wd9i96pwka";
-       libraryHaskellDepends = [ base call-stack semigroups ];
+       version = "0.1.1.0";
+       sha256 = "0wbc1rzk7s5iaqxl6ck1jpizkqn71yx6lrxlrs103n7pyn1f0qrp";
+       libraryHaskellDepends = [ base call-stack semigroups tagged void ];
        description = "A sequence of semigroups, for composing stuff in multiple spatial directions";
        license = lib.licenses.lgpl3Only;
      }) {};
···
        broken = true;
      }) {};
 
+  "numhask-space_0_12_0_0" = callPackage
+    ({ mkDerivation, adjunctions, base, containers, distributive
+     , doctest-parallel, numhask, random, semigroupoids, tdigest, text
+     , time, vector
+     }:
+     mkDerivation {
+       pname = "numhask-space";
+       version = "0.12.0.0";
+       sha256 = "1g8ccb1lyg7dx3j49d3ry014a64myday7gxxkss1nicim07by9ih";
+       libraryHaskellDepends = [
+         adjunctions base containers distributive numhask random
+         semigroupoids tdigest text time vector
+       ];
+       testHaskellDepends = [ base doctest-parallel ];
+       description = "Numerical spaces";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "numhask-test" = callPackage
     ({ mkDerivation, base, numhask-prelude, QuickCheck, tasty
      , tasty-quickcheck
···
      , free, hspec, hspec-discover, microlens, microlens-th
      , neat-interpolation, optparse-simple, parsec, prettyprinter
      , regex-tdfa, shake, stm, text, toml-reader, transformers, unliftio
-     , unordered-containers, validation-selective
+     , unordered-containers
      }:
      mkDerivation {
        pname = "nvfetcher";
-       version = "0.6.2.0";
-       sha256 = "0lgbnam9gb9sdgmbxc5iznzbyv13s27j7s74fnrp09xdij0fgq3q";
-       revision = "1";
-       editedCabalFile = "0rhp4m54s2cmkhzkbphm0xdmvhymzlj3h1dd7iphqf32ba7jljgr";
+       version = "0.7.0.0";
+       sha256 = "0idcca3g1rfm8rc7zy68pdbhv4s0npdzdb47ixj0hk2pr8rg51ak";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          containers data-default extra free microlens microlens-th
          neat-interpolation optparse-simple parsec prettyprinter regex-tdfa
          shake text toml-reader transformers unordered-containers
-         validation-selective
        ];
        testHaskellDepends = [
          aeson aeson-pretty async base binary binary-instances bytestring
···
      }:
      mkDerivation {
        pname = "ogma-cli";
-       version = "1.4.1";
-       sha256 = "1r9yj862azfg4xngp0ghr9i6zawdaw4gkqb4nl6dpalsc7w0lx8w";
+       version = "1.5.0";
+       sha256 = "1gnk0lc02mw2gml9c8xr7g50nbsilm3wj1b5f3r7aiyk3j9i1fvl";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base ogma-core optparse-applicative ];
···
      , ogma-extra, ogma-language-c, ogma-language-cocospec
      , ogma-language-copilot, ogma-language-jsonspec, ogma-language-smv
      , ogma-spec, QuickCheck, test-framework, test-framework-hunit
-     , test-framework-quickcheck2
+     , test-framework-quickcheck2, text
      }:
      mkDerivation {
        pname = "ogma-core";
-       version = "1.4.1";
-       sha256 = "1g2696iip5sshwgpf9rq769ivqrxc5km1rq0b2q50y91qfh583c9";
+       version = "1.5.0";
+       sha256 = "1cr09v5dbbn21b57kq79nbs7plcw9qplj5c2mhghg5dsqnzflhb7";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base bytestring filepath mtl ogma-extra ogma-language-c
          ogma-language-cocospec ogma-language-copilot ogma-language-jsonspec
-         ogma-language-smv ogma-spec
+         ogma-language-smv ogma-spec text
        ];
        testHaskellDepends = [
          base HUnit QuickCheck test-framework test-framework-hunit
···
      }) {};
 
   "ogma-extra" = callPackage
-    ({ mkDerivation, base, bytestring, Cabal, directory, filepath
-     , QuickCheck, test-framework, test-framework-quickcheck2
+    ({ mkDerivation, aeson, base, bytestring, Cabal, directory
+     , filepath, microstache, QuickCheck, test-framework
+     , test-framework-quickcheck2, text
      }:
      mkDerivation {
        pname = "ogma-extra";
-       version = "1.4.1";
-       sha256 = "0mipcd5pyi0qxcsb0nhcb57rz7c64m2d36jq08sfvnfa161nhkx9";
+       version = "1.5.0";
+       sha256 = "05n874zfzqjwvlmqj098rn696l8fj9krgjzw46c2vqzzp0ahavdi";
        libraryHaskellDepends = [
-         base bytestring Cabal directory filepath
+         aeson base bytestring Cabal directory filepath microstache text
        ];
        testHaskellDepends = [
          base QuickCheck test-framework test-framework-quickcheck2
···
      }:
      mkDerivation {
        pname = "ogma-language-c";
-       version = "1.4.1";
-       sha256 = "0pnpafz2zmzylq7gzgpzx9358h2lfy3hhpz5wz0fiihh8rfakjgd";
+       version = "1.5.0";
+       sha256 = "1j4sizmahy55rh7f501m4gbvg6c9nbhamhzj6bqhpx2lsy3z0k6l";
        setupHaskellDepends = [ base BNFC Cabal process ];
        libraryHaskellDepends = [ array base ];
        testHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "ogma-language-cocospec";
-       version = "1.4.1";
-       sha256 = "16j2pqjymr03xkjc5fy2c0hp6c21j557c86ymhlmisy4hkd18195";
+       version = "1.5.0";
+       sha256 = "09gmyiak2xxwznqznf0p4z3g2jmsb96zj8xk8yprc3ql299k3sj7";
        setupHaskellDepends = [ base BNFC Cabal process ];
        libraryHaskellDepends = [ array base ];
        testHaskellDepends = [
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "ogma-language-copilot";
-       version = "1.4.1";
-       sha256 = "0v2nw4mk891faayhvww2qjlrxfcqsgy2ha9zagaby2mfb5q1avh9";
+       version = "1.5.0";
+       sha256 = "19wv5xm649lflfipj6irjax628wah5vzl9f3ifshq14s353lyxi4";
        libraryHaskellDepends = [ base ];
        description = "Ogma: Runtime Monitor translator: Copilot Language Endpoints";
        license = "unknown";
···
      }:
      mkDerivation {
        pname = "ogma-language-jsonspec";
-       version = "1.4.1";
-       sha256 = "1bl4ypyj3q6xy1dnfpywbii51521vf5la19jmy82scql9vs9y8rm";
+       version = "1.5.0";
+       sha256 = "09w4xywcvilyw4yxhz4p2nmix46nhxnljlrbjdkzf0ban2b8kkhd";
        libraryHaskellDepends = [
          aeson base bytestring jsonpath megaparsec ogma-spec text
        ];
···
      }:
      mkDerivation {
        pname = "ogma-language-smv";
-       version = "1.4.1";
-       sha256 = "0jwsqamnqnvy2id1js61a2xkxr5vj6w5xlpfqh0m1qqsgp2qg5kw";
+       version = "1.5.0";
+       sha256 = "1lhllgwibv9hprwlbp3bf29pykbzfmyfifd2gz1jzrhm6cdmysc2";
        setupHaskellDepends = [ base BNFC Cabal process ];
        libraryHaskellDepends = [ array base ];
        testHaskellDepends = [
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "ogma-spec";
-       version = "1.4.1";
-       sha256 = "0a0fdx1hpvncyaxsalknkwv8ms2a0p9giazgpkrikr4p14rb771k";
+       version = "1.5.0";
+       sha256 = "01xrmy7xm025ylbchgzbpg4dmd74k0fsrdl03nn8ip7fp1mzwn83";
        libraryHaskellDepends = [ base ];
        description = "Ogma: Runtime Monitor translator: JSON Frontend";
        license = "unknown";
···
      }) {};
 
   "ollama-haskell" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, http-client, http-types
-     , silently, tasty, tasty-hunit, text, time
+    ({ mkDerivation, aeson, base, base64-bytestring, bytestring
+     , directory, filepath, http-client, http-types, silently, tasty
+     , tasty-hunit, text, time
      }:
      mkDerivation {
        pname = "ollama-haskell";
-       version = "0.1.0.3";
-       sha256 = "0fgh0c6vccdary0lp3prjn1xspq1i2bbzzsxxsnfpp002qlkz2wx";
+       version = "0.1.2.0";
+       sha256 = "1y2hvjqn22d9d6lpsv95yrjkrzhkqp750d1rnysx8kdkxq59zz31";
        libraryHaskellDepends = [
-         aeson base bytestring http-client http-types text time
+         aeson base base64-bytestring bytestring directory filepath
+         http-client http-types text time
        ];
        testHaskellDepends = [
-         aeson base bytestring http-client http-types silently tasty
-         tasty-hunit text time
+         aeson base base64-bytestring bytestring directory filepath
+         http-client http-types silently tasty tasty-hunit text time
        ];
        description = "Haskell bindings for ollama";
        license = lib.licenses.mit;
···
      , hspec-discover, multiset, postgresql-simple, pretty
      , product-profunctors, profunctors, QuickCheck, scientific
      , semigroups, text, time, time-compat, time-locale-compat
-     , transformers, uuid, void
-     }:
-     mkDerivation {
-       pname = "opaleye";
-       version = "0.10.3.1";
-       sha256 = "1cv9p6kpb5i4x9bc8ak9vyfvhnqmycf8gbhaf4f6xb6rzwvllvd9";
-       revision = "1";
-       editedCabalFile = "192hpyb8a0vs7w4l0rq2j2ahqjip5m85w2ic63pn5sskmqcpaxb3";
-       libraryHaskellDepends = [
-         aeson base base16-bytestring bytestring case-insensitive
-         contravariant postgresql-simple pretty product-profunctors
-         profunctors scientific semigroups text time-compat
-         time-locale-compat transformers uuid void
-       ];
-       testHaskellDepends = [
-         aeson base bytestring containers contravariant dotenv hspec
-         hspec-discover multiset postgresql-simple product-profunctors
-         profunctors QuickCheck semigroups text time time-compat
-         transformers uuid
-       ];
-       testToolDepends = [ hspec-discover ];
-       description = "An SQL-generating DSL targeting PostgreSQL";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "opaleye_0_10_4_0" = callPackage
-    ({ mkDerivation, aeson, base, base16-bytestring, bytestring
-     , case-insensitive, containers, contravariant, dotenv, hspec
-     , hspec-discover, multiset, postgresql-simple, pretty
-     , product-profunctors, profunctors, QuickCheck, scientific
-     , semigroups, text, time, time-compat, time-locale-compat
      , transformers, uuid-types, void
      }:
      mkDerivation {
        pname = "opaleye";
        version = "0.10.4.0";
        sha256 = "16sj1kim44g93cnxkw26hp203ib7pkyzscalk5rfnlz409s1jhp9";
+       revision = "2";
+       editedCabalFile = "1q33108zah4x7jivihg2455c9zyjwfya0vqbfjqmys9w5ld4ihbm";
        libraryHaskellDepends = [
          aeson base base16-bytestring bytestring case-insensitive
          contravariant postgresql-simple pretty product-profunctors
···
        testToolDepends = [ hspec-discover ];
        description = "An SQL-generating DSL targeting PostgreSQL";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "opaleye-classy" = callPackage
···
        license = lib.licenses.bsd2;
      }) {};
 
+  "open-witness_0_7" = callPackage
+    ({ mkDerivation, base, constraints, hashable, random, tasty
+     , tasty-hunit, template-haskell, transformers, witness
+     }:
+     mkDerivation {
+       pname = "open-witness";
+       version = "0.7";
+       sha256 = "1scdc8qxlq2yxk819h58b7daqmb3a934f0jh3vjikb1lax9gxgky";
+       libraryHaskellDepends = [
+         base constraints hashable random template-haskell transformers
+         witness
+       ];
+       testHaskellDepends = [ base tasty tasty-hunit witness ];
+       description = "open witnesses";
+       license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "openai-hs" = callPackage
     ({ mkDerivation, aeson, base, bytestring, casing, containers, cpphs
      , hspec, http-client, http-client-tls, http-types, openai-servant
···
        librarySystemDepends = [ opencascade-occt ];
        description = "Thin Wrapper for the OpenCASCADE CAD Kernel";
        license = lib.licenses.lgpl21Only;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {inherit (pkgs) opencascade-occt;};
 
   "opencc" = callPackage
···
        ];
        description = "GHC plugin for open telemetry";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "opentelemetry-wai" = callPackage
···
        pname = "oplang";
        version = "0.5.0.0";
        sha256 = "0psk8jyxdhx2spzrx6k3hka7pyb2mhhsdwwk1g4bzgd3hmxnhh5l";
-       revision = "1";
-       editedCabalFile = "043mxfr8yjhqzagaydyx0l9q326zpjfzji1l4k6vfdv745ibnd68";
+       revision = "2";
+       editedCabalFile = "0y98xdmycpacylizvwnw5m1ca8ipwmwkb7yzr6jwqr7rdqv1yh50";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        pname = "options";
        version = "1.2.1.2";
        sha256 = "0jjz7b69qrsrbfz07xq43v70habxk8sj2gdlbkwh0gbifyhqykbf";
-       revision = "1";
-       editedCabalFile = "134r6x7m7sdp9f594ydb6l0q5rgym7psg3sh20klv2vwfq3fm1ic";
+       revision = "2";
+       editedCabalFile = "1aqs45xs42hzga0k9fryrj10my7crgbnmyip58vxrfd0s43rqdxq";
        libraryHaskellDepends = [ base containers monads-tf ];
        testHaskellDepends = [ base containers hspec monads-tf patience ];
        doHaddock = false;
···
        pname = "ormolu";
        version = "0.7.4.0";
        sha256 = "1s7a9crjhbsmjkdvpv8ycygpiikv96s96p3lmjik4pb3q7idir2z";
-       revision = "4";
-       editedCabalFile = "1wk0yp9xh4g08p07nf1skpjqn8dy2kmza3zvj34gs70sycngkwj2";
+       revision = "5";
+       editedCabalFile = "107p02xhq0gfacc6j8kackqn16a0wnayq7qpi26acvzqqyxhcjxy";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "ormolu";
        version = "0.7.7.0";
        sha256 = "1069j7cldvqqazmfrpfc6wy816227c5vz7fbq860yfb5h9ycv5ns";
+       revision = "1";
+       editedCabalFile = "1v8n4kf8wskyizn868k1662rqsd8myhvrjkchb9hiysw9lgja79c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "os-string";
-       version = "2.0.6";
-       sha256 = "12piw87ypyajhcb45lkrb8nwwg7rrb919dspzifnnrv6zkawgz12";
+       version = "2.0.7";
+       sha256 = "186b4swiga0nk05np512iw50pz9w88l3bqz47pr241997bykb71k";
        libraryHaskellDepends = [
          base bytestring deepseq exceptions template-haskell
        ];
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "palette_0_3_0_4" = callPackage
+    ({ mkDerivation, array, base, colour, containers, MonadRandom }:
+     mkDerivation {
+       pname = "palette";
+       version = "0.3.0.4";
+       sha256 = "0n8rylfpf9f0fx58c33v4nx8vwkrz8qlqr9xc1agikzh0l7dgksz";
+       libraryHaskellDepends = [
+         array base colour containers MonadRandom
+       ];
+       description = "Utilities for choosing and creating color schemes";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "palindromes" = callPackage
          base containers convertible csv hinduce-associations-apriori
      mkDerivation {
···
        ];
      }) {};
 
-  "pandoc_3_5" = callPackage
+  "pandoc_3_6" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, array, attoparsec, base
      , base64-bytestring, binary, blaze-html, blaze-markup, bytestring
      , case-insensitive, citeproc, commonmark, commonmark-extensions
···
      , crypton-x509-system, data-default, deepseq, Diff, directory, djot
      , doclayout, doctemplates, emojis, exceptions, file-embed, filepath
      , Glob, gridtables, haddock-library, http-client, http-client-tls
-     , http-types, ipynb, jira-wiki-markup, JuicyPixels, mime-types, mtl
-     , network, network-uri, pandoc-types, parsec, pretty, pretty-show
-     , process, random, safe, scientific, skylighting, skylighting-core
-     , split, syb, tagsoup, tasty, tasty-bench, tasty-golden
-     , tasty-hunit, tasty-quickcheck, temporary, texmath, text
-     , text-conversions, time, tls, typst, unicode-collation
-     , unicode-transforms, unix, vector, xml, xml-conduit, xml-types
-     , yaml, zip-archive, zlib
+     , http-types, ipynb, jira-wiki-markup, JuicyPixels, libyaml
+     , mime-types, mtl, network, network-uri, pandoc-types, parsec
+     , pretty, pretty-show, process, random, safe, scientific
+     , skylighting, skylighting-core, split, syb, tagsoup, tasty
+     , tasty-bench, tasty-golden, tasty-hunit, tasty-quickcheck
+     , temporary, texmath, text, text-conversions, time, tls, typst
+     , unicode-collation, unicode-transforms, unix, vector, xml
+     , xml-conduit, xml-types, yaml, zip-archive, zlib
      }:
      mkDerivation {
        pname = "pandoc";
-       version = "3.5";
-       sha256 = "0p23nfdx8xb60g2xplpfh3084i04gi3hy88s8864i8mq5i5ajpql";
+       version = "3.6";
+       sha256 = "1f7rjwgxlhhzpxcm29kgc1c4bzb827vidxh48qvd2bw597ykp5ns";
        configureFlags = [ "-f-trypandoc" ];
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
···
          directory djot doclayout doctemplates emojis exceptions file-embed
          filepath Glob gridtables haddock-library http-client
          http-client-tls http-types ipynb jira-wiki-markup JuicyPixels
-         mime-types mtl network network-uri pandoc-types parsec pretty
-         pretty-show process random safe scientific skylighting
+         libyaml mime-types mtl network network-uri pandoc-types parsec
+         pretty pretty-show process random safe scientific skylighting
          skylighting-core split syb tagsoup temporary texmath text
          text-conversions time tls typst unicode-collation
          unicode-transforms unix vector xml xml-conduit xml-types yaml
···
        maintainers = [ lib.maintainers.maralorn ];
      }) {};
 
-  "pandoc-cli_3_5" = callPackage
+  "pandoc-cli_3_6" = callPackage
     ({ mkDerivation, base, hslua-cli, pandoc, pandoc-lua-engine
      , pandoc-server, safe, temporary, text, wai-extra, warp
      }:
      mkDerivation {
        pname = "pandoc-cli";
-       version = "3.5";
-       sha256 = "0q6zhwgzipfcy36fsdnq5mkqq25kirscvfb347n3drmc2lnw5lmr";
+       version = "3.6";
+       sha256 = "0crqm20rl95g557biqvlsm0yjgn31sfhm5sa9s65sbpzi81cvp07";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "pandoc-crossref";
-       version = "0.3.18.0";
-       sha256 = "01kj17rf53kshfw7dd1875xi6s43b84hr7dvbfbhsb1c10pvdwac";
-       revision = "1";
-       editedCabalFile = "014brzc3r46b93hi4wzlyx9qf9qcf1js5qvpwk5rvzqpvazjglkj";
+       version = "0.3.18.1";
+       sha256 = "1bzspd7jjn4ypk5vxhifkcfj4b4jm9352k15k2wc5f4xmwlkqdg4";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        license = lib.licenses.gpl2Plus;
      }) {};
 
-  "pandoc-lua-engine_0_3_3" = callPackage
+  "pandoc-lua-engine_0_4" = callPackage
     ({ mkDerivation, aeson, base, bytestring, citeproc, containers
      , crypton, data-default, directory, doclayout, doctemplates
      , exceptions, filepath, hslua, hslua-module-doclayout
···
      }:
      mkDerivation {
        pname = "pandoc-lua-engine";
-       version = "0.3.3";
-       sha256 = "0jzddmg2qnbdv83hrfmxhfibp8p1mm9j32vxm89kg6fbx688n5hw";
+       version = "0.4";
+       sha256 = "1004cks656pj87q65kcxlmg8jn0wka98c5ygr39hr63y5avwqykg";
        libraryHaskellDepends = [
          aeson base bytestring citeproc containers crypton data-default
          doclayout doctemplates exceptions hslua hslua-module-doclayout
···
        license = lib.licenses.mit;
      }) {};
 
+  "pandoc-lua-marshal_0_3_0" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, exceptions
+     , hslua, hslua-list, hslua-marshalling, pandoc-types, QuickCheck
+     , safe, tasty, tasty-hunit, tasty-lua, tasty-quickcheck, text
+     }:
+     mkDerivation {
+       pname = "pandoc-lua-marshal";
+       version = "0.3.0";
+       sha256 = "0d8vfbmgd107b9lq9dq0b39v3dhznqh11j0ci0i8hsb7g3dkks5g";
+       libraryHaskellDepends = [
+         aeson base bytestring containers exceptions hslua hslua-list
+         hslua-marshalling pandoc-types safe text
+       ];
+       testHaskellDepends = [
+         aeson base bytestring containers exceptions hslua hslua-list
+         hslua-marshalling pandoc-types QuickCheck safe tasty tasty-hunit
+         tasty-lua tasty-quickcheck text
+       ];
+       description = "Use pandoc types in Lua";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "pandoc-markdown-ghci-filter" = callPackage
     ({ mkDerivation, aeson, base, containers, ghcid, pandoc
      , pandoc-types, QuickCheck, tasty, tasty-hunit, tasty-quickcheck
···
        license = lib.licenses.gpl2Plus;
      }) {};
 
-  "pandoc-server_0_1_0_9" = callPackage
+  "pandoc-server_0_1_0_10" = callPackage
     ({ mkDerivation, aeson, base, base64-bytestring, bytestring
      , containers, data-default, doctemplates, pandoc, pandoc-types
      , servant-server, skylighting, text, unicode-collation, wai
···
      }:
      mkDerivation {
        pname = "pandoc-server";
-       version = "0.1.0.9";
-       sha256 = "1bdfd0lq0vdrr8rvjxin6j011jg4kn210zzpz2lixvc8wfcw66w8";
+       version = "0.1.0.10";
+       sha256 = "1rsrdx76llipa9xb624d953rinyhm7nfs53ps4qd343yqw8npjjl";
        libraryHaskellDepends = [
          aeson base base64-bytestring bytestring containers data-default
          doctemplates pandoc pandoc-types servant-server skylighting text
···
        pname = "parallel";
        version = "3.2.2.0";
        sha256 = "1xkfi96w6yfpppd0nw1rnszdxmvifwzm699ilv6332ra3akm610p";
-       revision = "8";
-       editedCabalFile = "0c9ychx28pzxdmfz3d3l170zdwd180galkbs901za5pzzl3hpkxr";
+       revision = "9";
+       editedCabalFile = "109xh71lzvivyvfypflibav8zmrvli41v8zc69vzch3rafn38ywx";
        libraryHaskellDepends = [ array base containers deepseq ghc-prim ];
        description = "Parallel programming library";
        license = lib.licenses.bsd3;
···
        pname = "parameterized-utils";
        version = "2.1.9.0";
        sha256 = "15yn958adkivyg7qbbbi20ja8smcdjyslkk3mxswl0r0bfgz2y70";
+       revision = "1";
+       editedCabalFile = "1b6db8ld5svcclg9ydgfz36qia8d6vkgilmkwb4a2i8dz7whiphl";
        libraryHaskellDepends = [
          base base-orphans constraints containers deepseq ghc-prim hashable
          hashtables indexed-traversable lens mtl profunctors
···
      }) {};
 
   "parser-regex" = callPackage
-    ({ mkDerivation, base, bytestring, containers, deepseq, ghc-bignum
-     , primitive, QuickCheck, quickcheck-classes-base, tasty
-     , tasty-hunit, tasty-quickcheck, text, transformers
+    ({ mkDerivation, base, containers, deepseq, ghc-bignum, primitive
+     , QuickCheck, quickcheck-classes-base, tasty, tasty-hunit
+     , tasty-quickcheck, text, transformers
      }:
      mkDerivation {
        pname = "parser-regex";
-       version = "0.1.0.0";
-       sha256 = "1rsq5bb6rx6y99h01d8g2yfn3kjyj60x3f2n9fhzg02v8sbzs4mx";
+       version = "0.2.0.0";
+       sha256 = "05lb9ljna8zyn268q8y0dyin7qj53hb6fcvsw4dnmlj4j873bwxr";
        libraryHaskellDepends = [
-         base bytestring containers deepseq ghc-bignum primitive text
-         transformers
+         base containers deepseq ghc-bignum primitive text transformers
        ];
        testHaskellDepends = [
-         base bytestring containers QuickCheck quickcheck-classes-base tasty
-         tasty-hunit tasty-quickcheck text
+         base QuickCheck quickcheck-classes-base tasty tasty-hunit
+         tasty-quickcheck text
        ];
        description = "Regex based parsers";
        license = lib.licenses.bsd3;
···
        maintainers = [ lib.maintainers.cdepillabout ];
      }) {};
 
-  "password_3_1_0_0" = callPackage
+  "password_3_1_0_1" = callPackage
     ({ mkDerivation, base, base-compat, base64, bytestring, Cabal
      , cabal-doctest, crypton, doctest, memory, password-types
-     , QuickCheck, quickcheck-instances, scrypt, tasty, tasty-hunit
-     , tasty-quickcheck, template-haskell, text
+     , QuickCheck, quickcheck-instances, scrypt, tasty, tasty-golden
+     , tasty-hunit, tasty-quickcheck, template-haskell, text
      }:
      mkDerivation {
        pname = "password";
-       version = "3.1.0.0";
-       sha256 = "0rmcmp9bwa4nqma1pphjga2bmd5axw3579v6i1sh5yih1cfqzi2q";
+       version = "3.1.0.1";
+       sha256 = "11vy7i86dwks1zx4bw7nnp0wj0a1cz2zs1ir4psjcvq9ayhl9fpp";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          base base64 bytestring crypton memory password-types
···
        testHaskellDepends = [
          base base-compat base64 bytestring crypton doctest memory
          password-types QuickCheck quickcheck-instances scrypt tasty
-         tasty-hunit tasty-quickcheck template-haskell text
+         tasty-golden tasty-hunit tasty-quickcheck template-haskell text
        ];
        description = "Hashing and checking of passwords";
        license = lib.licenses.bsd3;
···
        pname = "patience";
        version = "0.3";
        sha256 = "1i1b37lgi31c17yrjyf8pdm4nf5lq8vw90z3rri78hf0k66d0p3i";
+       revision = "1";
+       editedCabalFile = "0vldslyv381bmiw9f22wv46jmdcnxcjz5b8xqh8n7h7zzc5qs6j9";
        libraryHaskellDepends = [ base containers ];
        description = "Patience diff and longest increasing subsequence";
        license = lib.licenses.bsd3;
···
        pname = "pcf-font";
        version = "0.2.2.1";
        sha256 = "1gzlbdyhcrf7ap6zjd0fvkfwyakvb805198hpb9a86hrs5bih9mj";
+       revision = "1";
+       editedCabalFile = "0g13mw6zjx01xqglfhkgx1fycqivp5n8gzm1jl11ih8qqs81wpnd";
        libraryHaskellDepends = [
          base binary bytestring containers vector zlib
        ];
···
        mainProgram = "perf-explore";
      }) {};
 
-  "perf_0_13_0_0" = callPackage
-    ({ mkDerivation, base, clock, containers, deepseq, formatn, mtl
-     , numhask-space, optparse-applicative, recursion-schemes, text
-     , vector
+  "perf_0_14_0_1" = callPackage
+    ({ mkDerivation, base, boxes, chart-svg, clock, containers, deepseq
+     , formatn, mtl, numhask-space, optics-core, optparse-applicative
+     , prettychart, prettyprinter, recursion-schemes, tasty, tasty-bench
+     , text, vector
      }:
      mkDerivation {
        pname = "perf";
-       version = "0.13.0.0";
-       sha256 = "0xqwg42cl9f1s9niyc2r9py75w26bp7rlax04ifjjbbq5y9aw2gb";
+       version = "0.14.0.1";
+       sha256 = "01pfgfgqazl734mkkiwr208m66gcbmlp53y0yb6g4yhf6gvadqxd";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         base clock containers deepseq formatn mtl numhask-space
-         optparse-applicative recursion-schemes text vector
+         base boxes chart-svg clock containers deepseq formatn mtl
+         numhask-space optics-core optparse-applicative prettychart
+         prettyprinter recursion-schemes tasty tasty-bench text vector
        ];
        executableHaskellDepends = [
-         base clock containers deepseq formatn mtl optparse-applicative text
+         base containers deepseq mtl optics-core optparse-applicative text
        ];
        benchmarkHaskellDepends = [ base ];
        description = "Performance methods and monad";
···
        license = lib.licenses.mit;
      }) {};
 
+  "persistent-sql-lifted" = callPackage
+    ({ mkDerivation, annotated-exception, base, conduit, containers
+     , esqueleto, mtl, persistent, text, unliftio-core
+     }:
+     mkDerivation {
+       pname = "persistent-sql-lifted";
+       version = "0.1.0.0";
+       sha256 = "1mkv3219h0lcg51dh94zy8jj83z3nb56f8r4nk5h4n6c2m9sqpx9";
+       libraryHaskellDepends = [
+         annotated-exception base conduit containers esqueleto mtl
+         persistent text unliftio-core
+       ];
+       description = "Monad classes for running queries with Persistent and Esqueleto";
+       license = lib.licenses.mit;
+     }) {};
+
   "persistent-sqlite" = callPackage
     ({ mkDerivation, aeson, base, bytestring, conduit, containers
      , exceptions, fast-logger, hspec, HUnit, microlens, microlens-th
···
        broken = true;
      }) {};
 
+  "pg-query" = callPackage
+    ({ mkDerivation, base, bytestring, hspec, hspec-contrib
+     , hspec-discover, hspec-expectations-pretty-diff, lens, pg_query
+     , proto-lens, proto-lens-protoc, proto-lens-runtime, temporary
+     , text, typed-process
+     }:
+     mkDerivation {
+       pname = "pg-query";
+       version = "0.0.1.1";
+       sha256 = "19i2xzpa4g6fhdayjgs8pq2kw1bkjnlhzkshx4an8s9vgahb1crc";
+       libraryHaskellDepends = [
+         base bytestring lens proto-lens proto-lens-runtime temporary text
+         typed-process
+       ];
+       librarySystemDepends = [ pg_query ];
+       libraryToolDepends = [ proto-lens-protoc ];
+       testHaskellDepends = [
+         base bytestring hspec hspec-contrib hspec-expectations-pretty-diff
+         lens proto-lens proto-lens-runtime temporary text typed-process
+       ];
+       testToolDepends = [ hspec-discover proto-lens-protoc ];
+       description = "Parse PostgreSQL DDL and DML: Haskell bindings for libpg_query";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {pg_query = null;};
+
   "pg-recorder" = callPackage
     ({ mkDerivation, base, bytestring, contravariant, either, hasql
      , hasql-pool, hspec, optparse-applicative, optparse-text
···
 
   "photoname" = callPackage
     ({ mkDerivation, ansi-wl-pprint, base, containers, directory
-     , filepath, heredoc, hsexif, hslogger, mtl, optparse-applicative
-     , parsec, process, regex-posix, tasty, tasty-hunit
-     , tasty-quickcheck, time, unix
+     , filepath, formatting, heredoc, hsexif, hslogger, mtl
+     , optparse-applicative, parsec, process, regex-posix, tasty
+     , tasty-hunit, tasty-quickcheck, time, unix
      }:
      mkDerivation {
        pname = "photoname";
-       version = "5.2";
-       sha256 = "0sf7hj6xa7bj074jamhm8jribbdjywdgg2z7wxjzmb2aliji5syi";
+       version = "5.4";
+       sha256 = "01gd6rl1qnidgd8i65syxli0iqv5fsdyp909s1gd2bvya11k7k6h";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         base containers directory filepath hsexif hslogger mtl parsec
-         process time unix
+         base containers directory filepath formatting hsexif hslogger mtl
+         parsec process time unix
        ];
        executableHaskellDepends = [
-         ansi-wl-pprint base directory filepath heredoc hslogger
+         ansi-wl-pprint base directory filepath formatting heredoc hslogger
          optparse-applicative unix
        ];
        testHaskellDepends = [
···
     ({ mkDerivation, base, requirements }:
      mkDerivation {
        pname = "poly-rec";
-       version = "0.7.0.2";
-       sha256 = "1kysfam03sbwx9kqbnnncrp0sp764zj57sfj6raar8im9wpwpyh9";
+       version = "0.7.0.4";
+       sha256 = "07542spic4m794l54grmrbpfvcacqr4cm9vw3x1pmji30rw0c2va";
        libraryHaskellDepends = [ base requirements ];
        description = "Polykinded extensible records";
        license = lib.licenses.gpl3Only;
···
 
   "posit" = callPackage
     ({ mkDerivation, base, Chart, Chart-cairo, data-dword, deepseq
-     , random, scientific, vector, weigh
+     , random, scientific, time, vector, weigh
      }:
      mkDerivation {
        pname = "posit";
-       version = "2022.2.0.0";
-       sha256 = "1637dpqfgs4mpl2n8cvzywsdwsv2zw5834k3mmxd5zhq82ai2m0q";
+       version = "2022.2.0.1";
+       sha256 = "18rvn0h5fn90cmrj4g19nscl4r658v2piif4afbqqn1ylnf99chk";
        libraryHaskellDepends = [
          base data-dword deepseq random scientific
        ];
-       testHaskellDepends = [ base Chart Chart-cairo ];
+       testHaskellDepends = [ base Chart Chart-cairo time ];
        benchmarkHaskellDepends = [ base vector weigh ];
        description = "Posit Numbers";
        license = lib.licenses.bsd3;
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "ppad-base58" = callPackage
+    ({ mkDerivation, aeson, base, base16-bytestring, bytestring
+     , criterion, ppad-sha256, tasty, tasty-hunit, text
+     }:
+     mkDerivation {
+       pname = "ppad-base58";
+       version = "0.1.0";
+       sha256 = "07ac2cl7m9f9fkv6f99615nqabz682pr057ijk6zg1707l9r5pch";
+       libraryHaskellDepends = [ base bytestring ppad-sha256 ];
+       testHaskellDepends = [
+         aeson base base16-bytestring bytestring tasty tasty-hunit text
+       ];
+       benchmarkHaskellDepends = [ base bytestring criterion ];
+       description = "base58 and base58check encoding/decoding";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "ppad-bech32" = callPackage
+    ({ mkDerivation, array, base, bytestring, criterion, deepseq
+     , primitive, tasty, tasty-quickcheck
+     }:
+     mkDerivation {
+       pname = "ppad-bech32";
+       version = "0.1.2";
+       sha256 = "0cd977x9kqvyq2iw4kvnl9ilqm0rm0d0p6dm6wwzaf466p8c89xg";
+       libraryHaskellDepends = [ base bytestring primitive ];
+       testHaskellDepends = [
+         array base bytestring tasty tasty-quickcheck
+       ];
+       benchmarkHaskellDepends = [
+         array base bytestring criterion deepseq
+       ];
+       description = "The bech32 and bech32m encodings, per BIPs 173 & 350";
+       license = lib.licenses.mit;
+     }) {};
+
   "ppad-hmac-drbg" = callPackage
          base containers convertible csv hinduce-associations-apriori
      , criterion, ppad-sha256, ppad-sha512, primitive, tasty
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "ppad-ripemd160" = callPackage
+    ({ mkDerivation, aeson, base, base16-bytestring, bytestring
+     , criterion, SHA, tasty, tasty-hunit, text
+     }:
+     mkDerivation {
+       pname = "ppad-ripemd160";
+       version = "0.1.0";
+       sha256 = "0zbrajd0bwqy329nby926q9h3vyidrh0dv06sqk77v7s0hprf7kl";
+       libraryHaskellDepends = [ base bytestring ];
+       testHaskellDepends = [
+         aeson base base16-bytestring bytestring tasty tasty-hunit text
+       ];
+       benchmarkHaskellDepends = [ base bytestring criterion SHA ];
+       description = "The RIPEMD-160 hashing algorithm";
+       license = lib.licenses.mit;
+     }) {};
+
   "ppad-secp256k1" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, base16-bytestring
      , bytestring, criterion, deepseq, ppad-hmac-drbg, ppad-sha256
-     , tasty, tasty-hunit, text
+     , primitive, tasty, tasty-hunit, text, weigh
      }:
      mkDerivation {
        pname = "ppad-secp256k1";
-       version = "0.1.0";
-       sha256 = "16a25c4l7bkv8sjjj0nf7i0ml6kvgvr9bajsgqx8aapbnamk6894";
+       version = "0.2.1";
+       sha256 = "1parw2ah759zpdx7ljnz8jsm59kqwzmsf7p5zv2nxivsw1xc2lgf";
        libraryHaskellDepends = [
-         base bytestring ppad-hmac-drbg ppad-sha256
+         base bytestring ppad-hmac-drbg ppad-sha256 primitive
        ];
        testHaskellDepends = [
          aeson attoparsec base base16-bytestring bytestring tasty
          tasty-hunit text
        ];
        benchmarkHaskellDepends = [
-         base base16-bytestring bytestring criterion deepseq
+         base base16-bytestring bytestring criterion deepseq weigh
        ];
        description = "Schnorr signatures & ECDSA on the elliptic curve secp256k1";
        license = lib.licenses.mit;
···
        maintainers = [ lib.maintainers.cdepillabout ];
      }) {};
 
+  "pretty-simple_4_1_3_0" = callPackage
+    ({ mkDerivation, base, containers, criterion, mtl
+     , optparse-applicative, prettyprinter, prettyprinter-ansi-terminal
+     , text, transformers
+     }:
+     mkDerivation {
+       pname = "pretty-simple";
+       version = "4.1.3.0";
+       sha256 = "03nhhavr66ikwmkma3mw2a7dz9w0mhaxj49dgf2cf76v3jq1vara";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base containers mtl prettyprinter prettyprinter-ansi-terminal text
+         transformers
+       ];
+       executableHaskellDepends = [ base optparse-applicative text ];
+       benchmarkHaskellDepends = [ base criterion text ];
+       description = "pretty printer for data types with a 'Show' instance";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "pretty-simple";
+       maintainers = [ lib.maintainers.cdepillabout ];
+     }) {};
+
   "pretty-sop" = callPackage
     ({ mkDerivation, base, generics-sop, markdown-unlit, pretty-show }:
      mkDerivation {
···
 
   "prettychart" = callPackage
     ({ mkDerivation, async, base, box, bytestring, chart-svg
-     , containers, doctest-parallel, markup-parse, numhask-space
-     , optics-core, text, time, web-rep
+     , containers, doctest-parallel, filepath, fsnotify, markup-parse
+     , numhask-space, optics-core, optparse-applicative, text, time
+     , web-rep
      }:
      mkDerivation {
        pname = "prettychart";
-       version = "0.2.2.0";
-       sha256 = "1mj20bhpjn7gf7kb123zmn27bfpk1zncqqg606xmdcyx225m43al";
+       version = "0.3.0.0";
+       sha256 = "0lchgnqzc59z0hhaq8n0vzqai6xsws6dwspsjbz6aw73zyw8ymx9";
+       isLibrary = true;
+       isExecutable = true;
        libraryHaskellDepends = [
-         async base box bytestring chart-svg containers markup-parse
-         numhask-space optics-core text time web-rep
+         async base box bytestring chart-svg containers filepath fsnotify
+         markup-parse numhask-space optics-core text time web-rep
+       ];
+       executableHaskellDepends = [
+         async base box optics-core optparse-applicative web-rep
        ];
        testHaskellDepends = [ base doctest-parallel ];
        description = "Pretty print charts from ghci";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
+       mainProgram = "prettychart-watch";
      }) {};
 
   "prettyclass" = callPackage
···
        libraryHaskellDepends = [ base prettyprinter text ];
        description = "Drop-in compatibility package to migrate from »wl-pprint« to »prettyprinter«";
        license = lib.licenses.bsd2;
+     }) {};
+
+  "prettyprinter-configurable" = callPackage
+    ({ mkDerivation, base, megaparsec, microlens, mtl
+     , parser-combinators, prettyprinter, QuickCheck, quickcheck-text
+     , tasty, tasty-hunit, tasty-quickcheck, text
+     }:
+     mkDerivation {
+       pname = "prettyprinter-configurable";
+       version = "1.0.0.0";
+       sha256 = "0y5gwg9031kz2ss79pp9d3rwn9sv86srcipyd8mpdsddmd6bivz1";
+       libraryHaskellDepends = [ base microlens mtl prettyprinter text ];
+       testHaskellDepends = [
+         base megaparsec parser-combinators QuickCheck quickcheck-text tasty
+         tasty-hunit tasty-quickcheck text
+       ];
+       description = "Configurable pretty-printing";
+       license = lib.licenses.asl20;
      }) {};
 
   "prettyprinter-convert-ansi-wl-pprint" = callPackage
···
        license = lib.licenses.bsd3;
      }) {inherit (pkgs) primecount;};
 
+  "primecount_0_1_0_2" = callPackage
+    ({ mkDerivation, base, primecount, silently, tasty, tasty-bench
+     , tasty-hunit
+     }:
+     mkDerivation {
+       pname = "primecount";
+       version = "0.1.0.2";
+       sha256 = "090k1ks5ax6f8x8dkyjz3p7dp2wlvrrm2g655lh57d16l8h5p7sj";
+       libraryHaskellDepends = [ base ];
+       librarySystemDepends = [ primecount ];
+       testHaskellDepends = [ base silently tasty tasty-hunit ];
+       benchmarkHaskellDepends = [ base tasty-bench ];
+       description = "Bindings to the primecount library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {inherit (pkgs) primecount;};
+
   "primes" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
        maintainers = [ lib.maintainers.thielema ];
      }) {};
 
+  "probability-polynomial" = callPackage
+    ({ mkDerivation, base, containers, criterion, deepseq
+     , exact-combinatorics, hspec, hspec-discover, QuickCheck
+     }:
+     mkDerivation {
+       pname = "probability-polynomial";
+       version = "1.0.0.0";
+       sha256 = "0xbl0x8z15qpnslx1jh4qqkpvssjgc1dy4b9fj1m6f23dafch6v9";
+       libraryHaskellDepends = [
+         base containers deepseq exact-combinatorics
+       ];
+       testHaskellDepends = [ base containers hspec QuickCheck ];
+       testToolDepends = [ hspec-discover ];
+       benchmarkHaskellDepends = [ base criterion deepseq ];
+       description = "Probability distributions via piecewise polynomials";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "probable" = callPackage
     ({ mkDerivation, base, criterion, mtl, mwc-random, mwc-random-monad
      , primitive, statistics, transformers, vector
···
        pname = "product-profunctors";
        version = "0.11.1.1";
        sha256 = "1nhwpfjz4iz30h8q7d40hlibqqymvmcf6wmbl6h3212d54hqdgiz";
-       revision = "5";
-       editedCabalFile = "137m8dvcyldiqf3d6vgxc2dv33kkj3x7r5w5yvfif4yja59vfvkw";
+       revision = "6";
+       editedCabalFile = "1sq9cgyqlylbkirw72yk68m86is65rbjpg3cir9vska0skxmdhjs";
        libraryHaskellDepends = [
          base bifunctors contravariant profunctors tagged template-haskell
          th-abstraction
···
        pname = "proof-combinators";
        version = "0.1.0.0";
        sha256 = "1wcm5wxzqm4lq340l3ga15cmjfabpf8njnvma3zagwyhmndabxfw";
+       revision = "3";
+       editedCabalFile = "1xsla1jqh1mfxy4341vwvqc404wdyb0pzp0j2fzjzg7103zrns7d";
        libraryHaskellDepends = [ base ];
-       description = "Proof Combinators used in Liquid Haskell for Theorem Proving";
+       description = "DEPRECATED";
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
 
   "prop-unit" = callPackage
-    ({ mkDerivation, base, hedgehog, tasty, tasty-hedgehog, tasty-hunit
+    ({ mkDerivation, base, containers, hedgehog, tasty, tasty-hedgehog
      }:
      mkDerivation {
        pname = "prop-unit";
-       version = "0.1.3";
-       sha256 = "0wiqdmlbxq4792lw3gm99fngbb5jyhwimqf4fb757aqm1jmi9h7b";
+       version = "1.0.1";
+       sha256 = "083m9lisb5qb1l71wmhv22fmgaf13zfzwxkz312mcgr6ifmm2nxi";
        libraryHaskellDepends = [ base hedgehog tasty tasty-hedgehog ];
        testHaskellDepends = [
-         base hedgehog tasty tasty-hedgehog tasty-hunit
+         base containers hedgehog tasty tasty-hedgehog
        ];
        description = "Conveniences for using Hedgehog as a unit test runner";
        license = lib.licenses.bsd3;
···
      }) {};
 
   "property-matchers" = callPackage
-    ({ mkDerivation, adjunctions, base, deepseq, pretty-simple
-     , prettyprinter, recover-rtti, text
+    ({ mkDerivation, adjunctions, base, deepseq, hspec, hspec-discover
+     , lens, pretty-simple, prettyprinter, recover-rtti, semialign
+     , smallcheck, text, these
      }:
      mkDerivation {
        pname = "property-matchers";
-       version = "0.1.0.0";
-       sha256 = "1c35mgppmlgv00x46p43l58dgrjc2pjxwfsaq4lkqq14dwpb7anj";
+       version = "0.3.0.0";
+       sha256 = "0414qvw3ay7ssv4404v3ks68zvnw40wp67s6fx22j0b9msvasq0n";
        libraryHaskellDepends = [
          adjunctions base deepseq pretty-simple prettyprinter recover-rtti
-         text
+         semialign text these
+       ];
+       testHaskellDepends = [
+         adjunctions base deepseq hspec lens pretty-simple prettyprinter
+         recover-rtti smallcheck text
        ];
+       testToolDepends = [ hspec-discover ];
        description = "A library for tests, based on transforming and writing properties";
        license = lib.licenses.bsd3;
      }) {};
···
        broken = true;
      }) {};
 
+  "provide" = callPackage
+    ({ mkDerivation, base, lens, reflection, vinyl }:
+     mkDerivation {
+       pname = "provide";
+       version = "0.1.0.0";
+       sha256 = "0qiz4pqrhdczxsjhsbk0zcfmks31llp4xks7whpalimsk33075qs";
+       libraryHaskellDepends = [ base lens reflection vinyl ];
+       testHaskellDepends = [ base vinyl ];
+       description = "Lightweight dependency injection / namespaced+typed implicit-ish arguments";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "proxied" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
        license = lib.licenses.mit;
      }) {};
 
+  "ptr-poker_0_1_2_16" = callPackage
+    ({ mkDerivation, base, bytestring, criterion, hedgehog
+     , isomorphism-class, numeric-limits, rerebase, scientific, text
+     }:
+     mkDerivation {
+       pname = "ptr-poker";
+       version = "0.1.2.16";
+       sha256 = "15x169xihal3y4is4rcdx7rq4yz62dx6xj864vqs2dhxa819iw0l";
+       libraryHaskellDepends = [ base bytestring scientific text ];
+       testHaskellDepends = [
+         hedgehog isomorphism-class numeric-limits rerebase
+       ];
+       benchmarkHaskellDepends = [ criterion rerebase ];
+       description = "Pointer poking action construction and composition toolkit";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "ptrdiff" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "pusher-http-haskell";
-       version = "2.1.0.18";
-       sha256 = "08wc8agnxfalixc7d4zlwsh3swanyfgg74180lm4v5i2q6s5jxy4";
+       version = "2.1.0.19";
+       sha256 = "1zhypjxi3n0zn7l8mkdw17zvm2fsflk8cfnx1bsh0fd5b6a2xj49";
        libraryHaskellDepends = [
          aeson base base16-bytestring bytestring crypton hashable
          http-client http-client-tls http-types memory text time
···
        license = lib.licenses.mit;
      }) {};
 
-  "pusher-http-haskell_2_1_0_19" = callPackage
+  "pusher-http-haskell_2_1_0_20" = callPackage
     ({ mkDerivation, aeson, base, base16-bytestring, bytestring
      , crypton, hashable, hspec, http-client, http-client-tls
      , http-types, memory, QuickCheck, text, time, unordered-containers
      }:
      mkDerivation {
        pname = "pusher-http-haskell";
-       version = "2.1.0.19";
-       sha256 = "1zhypjxi3n0zn7l8mkdw17zvm2fsflk8cfnx1bsh0fd5b6a2xj49";
+       version = "2.1.0.20";
+       sha256 = "1yvl6ydgix16jxjj40ga9kq832n96ifywra1l3z8cr8apjm3wyin";
        libraryHaskellDepends = [
          aeson base base16-bytestring bytestring crypton hashable
          http-client http-client-tls http-types memory text time
···
      }:
      mkDerivation {
        pname = "quic";
-       version = "0.2.4";
-       sha256 = "0gy3fhfwb1gn3807w4n05cwqhq8f1kgjgcy77y3amg88m23ydlm9";
+       version = "0.2.7";
+       sha256 = "0x6x7xdknwa80ikclfn8mq8jyqgy73l0g8qy82jcgj3jqd4631zq";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "quickcheck-lockstep";
-       version = "0.5.1";
-       sha256 = "0dsklypvflwgaj6fdh52sw2bzznz1kmmcdbs39nsjji7bkbn7gqp";
+       version = "0.6.0";
+       sha256 = "1s1z146l00v5hlcmwq9w9dpvs0mblld8h15xicxb619fbl1hrg5x";
        libraryHaskellDepends = [
          base constraints containers mtl QuickCheck quickcheck-dynamic
        ];
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "random_1_2_1_3" = callPackage
+    ({ mkDerivation, base, bytestring, containers, deepseq, mtl
+     , primitive, rdtsc, smallcheck, split, splitmix, stm, tasty
+     , tasty-bench, tasty-hunit, tasty-inspection-testing
+     , tasty-smallcheck, time, transformers
+     }:
+     mkDerivation {
+       pname = "random";
+       version = "1.2.1.3";
+       sha256 = "1p2i636bk1q62dzrlrl92mirrz0ynf93bxs5yql07r6ilwk1kj79";
+       libraryHaskellDepends = [ base bytestring deepseq mtl splitmix ];
+       testHaskellDepends = [
+         base bytestring containers smallcheck stm tasty tasty-hunit
+         tasty-inspection-testing tasty-smallcheck transformers
+       ];
+       benchmarkHaskellDepends = [
+         base mtl primitive rdtsc split splitmix tasty-bench time
+       ];
+       description = "Pseudo-random number generation";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "random-access-file" = callPackage
     ({ mkDerivation, base, bytestring, concurrent-extra, containers
      , criterion, directory, lrucaching, mwc-random, random, stm, unix
···
        testHaskellDepends = [ base doctest typecheck-plugin-nat-simple ];
        description = "The list like structure whose length or range of length can be specified";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "ranged-list_0_1_2_3" = callPackage
+    ({ mkDerivation, base, doctest, ghc-internal
+     , typecheck-plugin-nat-simple
+     }:
+     mkDerivation {
+       pname = "ranged-list";
+       version = "0.1.2.3";
+       sha256 = "079h4xvjr4amrr48gljfc438savyvm5qfmnwwz29k8ifavxzxzw1";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         base ghc-internal typecheck-plugin-nat-simple
+       ];
+       testHaskellDepends = [
+         base doctest ghc-internal typecheck-plugin-nat-simple
+       ];
+       description = "The list like structure whose length or range of length can be specified";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "rangemin" = callPackage
···
        broken = true;
      }) {};
 
-  "rattletrap_14_0_0" = callPackage
+  "rattletrap_14_1_0" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, array, base, bytestring
      , containers, filepath, http-client, http-client-tls, text
      }:
      mkDerivation {
        pname = "rattletrap";
-       version = "14.0.0";
-       sha256 = "1dl1p379mnyz1d6w7mzm2fqpdfxz8qcffpr3nmy2jbyfmxajdw1m";
+       version = "14.1.0";
+       sha256 = "1fkvcdrbw41vc9g2wph0wm0sw2baxx7dkv6cb3x38zvapfynapim";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "rawlock";
-       version = "0.1.0.0";
-       sha256 = "07nh83k9xc1iszd2glh0nm8phblm67nazybxq7pgq7c89fgv3v0w";
+       version = "0.1.1.0";
+       sha256 = "1hd62m0r6wiwpzm70pydrkvw2ln78436vak1jd0wiqvdh9z35szj";
+       revision = "1";
+       editedCabalFile = "1gw7ffwhzw650gm2746k88kjhyl7q525mzrqcrj6q8nn9sjabzih";
        libraryHaskellDepends = [
          base io-classes nothunks strict-mvar strict-stm
        ];
···
      }:
      mkDerivation {
        pname = "rds-data";
-       version = "0.1.0.0";
-       sha256 = "1ilphv9pff2ixd4rphir6j3lc41m0jngk0f4byb4v991xjr6ldz8";
+       version = "0.1.1.1";
+       sha256 = "1d3jvwlrr5xdn1dn9s3w4ww1db60rzvhjwc4vgrcjb9fnlqkr7l0";
        isLibrary = false;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "reactive-banana";
        version = "1.3.2.0";
        sha256 = "0mrsw3hkl0sgwcbay4m1lzs4bilss80g9p6njbbhapbfjyzsr36k";
-       revision = "4";
-       editedCabalFile = "1nijajqvp7i5jq99y9c3z969ljgagkarpn5ikbd3bir2msz54pyn";
+       revision = "5";
+       editedCabalFile = "0dydffvlxf6wlkaj1sf2argrpkfwswjcby2an1rcwrk8gs6dklkv";
        libraryHaskellDepends = [
          base containers deepseq hashable pqueue semigroups stm these
          transformers unordered-containers vault
···
        pname = "recursion-schemes";
        version = "5.2.3";
        sha256 = "020fk7s4dzim3957h8447mi3jp95k25zrac86dcaavldxjy88kiv";
+       revision = "1";
+       editedCabalFile = "0la8md7lv8awhvsyw30mqbyfjvskvndcm9446wnh4bhjhi0813li";
        libraryHaskellDepends = [
          base comonad containers data-fix free template-haskell
          th-abstraction transformers
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "reducers_3_12_5" = callPackage
+    ({ mkDerivation, array, base, bytestring, containers, fingertree
+     , hashable, semigroupoids, text, transformers, unordered-containers
+     }:
+     mkDerivation {
+       pname = "reducers";
+       version = "3.12.5";
+       sha256 = "0742ry9xjjmhwvlv100d3nz75k7wqr42262kw21n5mmwrka6358h";
+       libraryHaskellDepends = [
+         array base bytestring containers fingertree hashable semigroupoids
+         text transformers unordered-containers
+       ];
+       description = "Semigroups, specialized containers and a general map/reduce framework";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "reedsolomon" = callPackage
     ({ mkDerivation, base, bytestring, criterion, exceptions, gitrev
      , loop, mtl, primitive, profunctors, QuickCheck, random, tasty
···
      }:
      mkDerivation {
        pname = "refined-containers";
-       version = "0.1.0.1";
-       sha256 = "0jyk71ccwy489cyikg4a9pvdj8hijyqpkw1sj5qhj0anrsc6bq8x";
+       version = "0.1.0.2";
+       sha256 = "03kaxj49alqaj4a0miighchpgzsm7yjyzxw2fxjmvq90lyy59524";
        libraryHaskellDepends = [
          adjunctions base constraints containers deepseq distributive
          hashable indexed-traversable mtl refined reflection
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "reflection_2_1_9" = callPackage
+    ({ mkDerivation, base, containers, hspec, hspec-discover
+     , QuickCheck, template-haskell
+     }:
+     mkDerivation {
+       pname = "reflection";
+       version = "2.1.9";
+       sha256 = "1cwzwncb7zvzdcj5s5pc1qrkh7xj6kyz9b30qq2imvnh3bjdb9y6";
+       libraryHaskellDepends = [ base template-haskell ];
+       testHaskellDepends = [ base containers hspec QuickCheck ];
+       testToolDepends = [ hspec-discover ];
+       description = "Reifies arbitrary terms into types that can be reflected back into terms";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "reflection-extras" = callPackage
     ({ mkDerivation, aeson, base, constraints, lens, reflection, tagged
      }:
···
      }:
      mkDerivation {
        pname = "reflex-vty";
-       version = "0.5.2.1";
-       sha256 = "1hfvs6igpavzr6cd4mc7asxj2iwhcjzi7mc4fbfwnq1jmll9xp37";
+       version = "0.6.1.0";
+       sha256 = "0s8xqikz9gcaqax99cn96izqv8srmcxs9d93nz9k3f7ncrb0c5zw";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "registry";
-       version = "0.6.1.0";
-       sha256 = "0jn8ylnq7vqpdlz01jn8fndczgz02rgpzhi1g7fy1r0pwln6ibgj";
+       version = "0.6.3.0";
+       sha256 = "0cid38h4mjsbakbgvasipmagl1myjvmpbk0034n5zb8zy4dkmxkh";
        libraryHaskellDepends = [
          base containers exceptions hashable mmorph mtl multimap protolude
          resourcet semigroupoids semigroups template-haskell text
···
      }:
      mkDerivation {
        pname = "registry-aeson";
-       version = "0.3.0.0";
-       sha256 = "1248mszp2wcj9v2djnfliqqhkmsvixwh6j9qwcjj00wvdb7lmzad";
+       version = "0.3.1.0";
+       sha256 = "09agzi08nrfd6hglcwpacybz8y3z0m6mzf5gf7p26b0fd5f5jg77";
        libraryHaskellDepends = [
          aeson base bytestring containers protolude registry
          template-haskell text transformers unordered-containers vector
···
      }:
      mkDerivation {
        pname = "registry-hedgehog";
-       version = "0.8.1.0";
-       sha256 = "10am03sd9xj7a8079z4ikhlm3yf22rv809mk4n9gvhzkycx0dlb9";
+       version = "0.8.2.0";
+       sha256 = "0larrg1qp15plb6gip0ghs3zdgg022bs90khias9zdcvcw1i1hvw";
        libraryHaskellDepends = [
          base containers hedgehog mmorph multimap protolude registry tasty
          tasty-discover tasty-hedgehog tasty-th template-haskell text
···
      }:
      mkDerivation {
        pname = "registry-hedgehog-aeson";
-       version = "0.3.0.0";
-       sha256 = "08k8vdc4hmqnsci2bvacrizlfb98a2yp7h3p5ad8dqn2yhinlbrf";
+       version = "0.3.1.0";
+       sha256 = "0n8v3zx9ybf8yvniifipbk4f5r8jwg1glmf0i1xay8ssjlziriys";
        libraryHaskellDepends = [
          aeson base containers hedgehog mmorph multimap protolude registry
          scientific tasty tasty-discover tasty-hedgehog tasty-th
···
 
   "rel8" = callPackage
     ({ mkDerivation, aeson, attoparsec, attoparsec-aeson, base
-     , base-compat, base16, bifunctors, bytestring, case-insensitive
-     , comonad, containers, contravariant, data-dword, data-textual
-     , hasql, hasql-transaction, hedgehog, mmorph, network-ip, opaleye
-     , pretty, product-profunctors, profunctors, scientific, semialign
-     , semigroupoids, tasty, tasty-hedgehog, text, these, time
-     , tmp-postgres, transformers, utf8-string, uuid, vector
+     , base-compat, base16, bifunctors, binary-parser, bytestring
+     , case-insensitive, comonad, containers, contravariant, data-dword
+     , data-textual, hasql, hasql-transaction, hedgehog, iproute, mmorph
+     , network-ip, opaleye, pretty, product-profunctors, profunctors
+     , scientific, semialign, semigroupoids, tasty, tasty-hedgehog, text
+     , these, time, tmp-postgres, transformers, utf8-string, uuid
+     , vector
      }:
      mkDerivation {
        pname = "rel8";
-       version = "1.5.0.0";
-       sha256 = "01g1ras7byy05x99gzh3pj4xzsm1qxx3j6qiy1qnzhvrwjifbc5w";
+       version = "1.6.0.0";
+       sha256 = "1ljw3zihy3d3nihfc8f791h5bggd2r4gb8vq2zraa8s7brml3bx9";
        libraryHaskellDepends = [
          aeson attoparsec attoparsec-aeson base base-compat base16
-         bifunctors bytestring case-insensitive comonad contravariant
-         data-textual hasql network-ip opaleye pretty product-profunctors
-         profunctors scientific semialign semigroupoids text these time
-         transformers utf8-string uuid vector
+         bifunctors binary-parser bytestring case-insensitive comonad
+         contravariant data-dword data-textual hasql iproute network-ip
+         opaleye pretty product-profunctors profunctors scientific semialign
+         semigroupoids text these time transformers utf8-string uuid vector
        ];
        testHaskellDepends = [
-         base bytestring case-insensitive containers data-dword hasql
-         hasql-transaction hedgehog mmorph network-ip scientific tasty
-         tasty-hedgehog text time tmp-postgres transformers uuid
+         aeson base bytestring case-insensitive containers data-dword hasql
+         hasql-transaction hedgehog iproute mmorph network-ip scientific
+         tasty tasty-hedgehog text time tmp-postgres transformers uuid
+         vector
        ];
        description = "Hey! Hey! Can u rel8?";
        license = lib.licenses.bsd3;
···
        pname = "relude";
          base containers convertible csv hinduce-associations-apriori
        sha256 = "0ikp23nbzrxfalpsk6n8yg3byh43f8hp156wpxx45yc297gmgpil";
+       revision = "1";
+       editedCabalFile = "1n8zhdz9cf6swbnmfncmzjddxqicvn54w229q3xpad0lyyr67ly6";
        libraryHaskellDepends = [
          base bytestring containers deepseq ghc-prim hashable mtl stm text
          transformers unordered-containers
···
     ({ mkDerivation, base, hspec, hspec-discover, optics, parsec }:
      mkDerivation {
        pname = "reorder-expression";
-       version = "0.1.0.1";
-       sha256 = "1jb7222r6mv9lvjfihbj96aj6vw3vqjsr283d4shv8qw3ghiqpl2";
+       version = "0.1.0.2";
+       sha256 = "1538lw1y56rqcxkpa2jcwm2zqx03ajfa1km1h2f2nsvrdr0f57a6";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base hspec optics parsec ];
        testToolDepends = [ hspec-discover ];
···
      }:
      mkDerivation {
        pname = "repa";
-       version = "3.4.1.5";
-       sha256 = "0saa2r94l0x52dlj9402csah96akp5wlc0xaah9p2pb8fv3yvs11";
-       revision = "1";
-       editedCabalFile = "1bl3q9x6lkkdwb5190nlxwzdil9vww99y57yhr1lab6bzr5qys0q";
+       version = "3.4.2.0";
+       sha256 = "1rqwmpslwqhrwgkpsqhx3hm4z41vfl35h7qkdxds44125d54kwcq";
        libraryHaskellDepends = [
          base bytestring ghc-prim QuickCheck template-haskell vector
        ];
···
     ({ mkDerivation, base, repa, vector }:
      mkDerivation {
        pname = "repa-algorithms";
-       version = "3.4.1.5";
-       sha256 = "0j6vbmwkjx8k0s754pccsmrdw5bkydxwbrli8lhlvxjcrrmbc26l";
+       version = "3.4.2.0";
+       sha256 = "12xj1n15abqmlcd0wczmv9f32jsbzh519jhzpv2zja9db1az43wv";
        libraryHaskellDepends = [ base repa vector ];
        description = "Algorithms using the Repa array library";
        license = lib.licenses.bsd3;
···
        description = "Packing and unpacking flat tables";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "repa-devil" = callPackage
···
      }) {inherit (pkgs) libdevil;};
 
   "repa-eval" = callPackage
-    ({ mkDerivation, base, ghc-prim }:
+    ({ mkDerivation, base }:
      mkDerivation {
        pname = "repa-eval";
-       version = "4.2.3.1";
-       sha256 = "13dla66r1k85zibic3291xdwgv8hf44z9i6814p14xk8cqgbj9an";
-       libraryHaskellDepends = [ base ghc-prim ];
+       version = "4.2.4.0";
+       sha256 = "1irfr5x4cmr85hsar6smj71icj687zic37y5xlyd3jp9r9k4zqn1";
+       libraryHaskellDepends = [ base ];
        description = "Low-level parallel operators on bulk random-accessble arrays";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "repa-examples" = callPackage
···
      }:
      mkDerivation {
        pname = "repa-examples";
-       version = "3.4.1.2";
-       sha256 = "1lqqnk3prvw1pr2wi4rhymb8ij6mjp9mcsvjcllnxv567mz9gr4d";
-       revision = "3";
-       editedCabalFile = "149wg57xkbnqymcmbd7i20kj37zyz0a4qm9426nkrrhkvs1acx52";
+       version = "3.4.2.0";
+       sha256 = "0qifi5n5pa8265yd2ylwd3knaw9lz263b96r49chz5rgr3bcsza0";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "repa-io";
-       version = "3.4.1.2";
-       sha256 = "0y4b8mfzlbf38f8mqnzq4vyvq8vw2vri8w0sb7dpr4bk0sd7gsmj";
+       version = "3.4.2.0";
+       sha256 = "05a4mcgpmzjj2yg9fc9ydz91wk31i7mg4b129bwf35j4ds68w2wi";
        libraryHaskellDepends = [
          base binary bmp bytestring old-time repa vector
        ];
···
      }:
      mkDerivation {
        pname = "repa-scalar";
-       version = "4.2.3.3";
-       sha256 = "1qjzrmz010gm50in0yja817r6wl0n2iybd00dsfpcspdaq91ahvb";
-       revision = "1";
-       editedCabalFile = "14p7m3fyl3h6asxcb3lh67f3ypw85109fxfag5aycdr39g5xa6rm";
+       version = "4.2.4.0";
+       sha256 = "1k11sav67hkc302gg5f8fxs6zw0gbbfxsgbl9lfxx992fv62sfiv";
        libraryHaskellDepends = [
          base bytestring double-conversion primitive time vector
        ];
        description = "Scalar data types and conversions";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "repa-series" = callPackage
···
        description = "Stream functions not present in the vector library";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "repa-v4l2" = callPackage
···
     ({ mkDerivation, base, ghc-prim }:
      mkDerivation {
        pname = "require-callstack";
-       version = "0.2.0.0";
-       sha256 = "15zy46r66qslmqpirydnzkqy8s241kzzp6wiqksi29gzipbzgha3";
+       version = "0.2.0.1";
+       sha256 = "1w252bqy2fi6y8adhwcpw896rb3gnxjc1yqggnxlx8fkj0z6i3gm";
        libraryHaskellDepends = [ base ghc-prim ];
        testHaskellDepends = [ base ];
        description = "Propagate HasCallStack with constraints";
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "requirements";
-       version = "0.7.0.2";
-       sha256 = "0291av4vixsns5w55yff4vjd8mr2wr8fpm26ckx903sll0y982ix";
+       version = "0.7.0.3";
+       sha256 = "15sydfl3dss62qld27l0hvzvvs577sgzlqkax4bigbpy231mj03s";
        libraryHaskellDepends = [ base ];
        description = "Abstraction to manage user defined Type Errors";
        license = lib.licenses.gpl3Only;
···
        pname = "rere";
        version = "0.2.0.1";
        sha256 = "1cbdn8jz1zcbddc0b4ahln1k7vwg0npxhmnmqaasm3byrrr6l271";
-       revision = "2";
-       editedCabalFile = "0rcyzp97igfphbrd0yavlajw3fq5872mjak5lvliw771cwv7v1kr";
+       revision = "3";
+       editedCabalFile = "1b29gpv9zxar9rjz8z0ksyw0h56jyrfzk9ja6zfk6qmw3nj4kf3p";
        libraryHaskellDepends = [
          base containers fin parsec QuickCheck transformers vec
        ];
···
 
   "rhine" = callPackage
     ({ mkDerivation, automaton, base, containers, criterion, deepseq
-     , free, mmorph, monad-schedule, MonadRandom, mtl, profunctors
-     , QuickCheck, random, selective, simple-affine-space, sop-core
-     , tasty, tasty-hunit, tasty-quickcheck, text, time, time-domain
-     , transformers, vector-sized
+     , foldable1-classes-compat, free, mmorph, monad-schedule
+     , MonadRandom, mtl, profunctors, QuickCheck, random, selective
+     , simple-affine-space, sop-core, tasty, tasty-hunit
+     , tasty-quickcheck, text, time, time-domain, transformers
+     , vector-sized
      }:
      mkDerivation {
        pname = "rhine";
-       version = "1.4.0.1";
-       sha256 = "1878fwyvghm0k9ayba88abyf7ca9abgzc03290ldkzwbn2kg5gwg";
+       version = "1.5";
+       sha256 = "0dkkdkrqbrp1383pl9ak8w121f115ylgp389g5aq7l6j3qyaxjfh";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
-         automaton base containers deepseq free mmorph monad-schedule
-         MonadRandom mtl profunctors random selective simple-affine-space
-         sop-core text time time-domain transformers vector-sized
+         automaton base containers deepseq foldable1-classes-compat free
+         mmorph monad-schedule MonadRandom mtl profunctors random selective
+         simple-affine-space sop-core text time time-domain transformers
+         vector-sized
        ];
        testHaskellDepends = [
          automaton base criterion monad-schedule mtl QuickCheck selective
···
      }:
      mkDerivation {
        pname = "rhine-bayes";
-       version = "1.4.0.1";
-       sha256 = "1qkk7sn4zgvm817iii1g930w593wwpcm2anrpml29zj9wznllbj0";
+       version = "1.5";
+       sha256 = "1gia4qh2ark8rlvbbgl5x0kg1jn1x51p2javrmn4sawyw9kvlafz";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "rhine-gloss";
-       version = "1.4.0.1";
-       sha256 = "02yrmkl1zl3kys0jzkgz23ah8jwqilbkpijsh4fk8cv16ar9nmgw";
+       version = "1.5";
+       sha256 = "0aq92p42c94bfijgv25x2i24xf9vh6srzfghskpd2jl70wfakwxf";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "rhine-terminal";
-       version = "1.4.0.1";
-       sha256 = "1rzs3mcq489kky55m0cljflqcaw53mzrg0ysnf4snpi41vmp3gh6";
+       version = "1.5";
+       sha256 = "18b0c5nzndwxixb6x31c7rav9mjad6zi4xqarxc1r4qvx3b31r6x";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "rounded-hw";
-       version = "0.4.0";
-       sha256 = "1844qb2nsv25ix41jkrcr0n08wa4zsnrn7wpxxavnabi4j7mf8yz";
-       revision = "1";
-       editedCabalFile = "1h2cxi47xmpmq5bdfd6jq3pag6sg7rqw3qw6577smjzrpydb67l5";
+       version = "0.4.0.1";
+       sha256 = "0nms0bhjmn5nwhfw0y0iwghhcgzqvgl40p9d41isg63gkvrrf6w1";
        setupHaskellDepends = [ base Cabal ];
        libraryHaskellDepends = [
          array base deepseq fp-ieee primitive tagged vector
···
      }:
      mkDerivation {
        pname = "safe-json";
-       version = "1.2.0.1";
-       sha256 = "1y03smd9fjxqfs5q2zi8138k3aafwx691327xavsa2b7q27bvi5b";
-       revision = "2";
-       editedCabalFile = "045q097n08h06zq4jv2ccfqdm3dpcz8gs5yp1hryh7lpf304h33p";
-       libraryHaskellDepends = [
-         aeson base bytestring containers dlist hashable scientific tasty
-         tasty-hunit tasty-quickcheck text time unordered-containers
-         uuid-types vector
-       ];
-       testHaskellDepends = [
-         aeson base bytestring containers dlist hashable
-         quickcheck-instances scientific tasty tasty-hunit tasty-quickcheck
-         temporary text time unordered-containers uuid uuid-types vector
-       ];
-       description = "Automatic JSON format versioning";
-       license = lib.licenses.mit;
-     }) {};
-
-  "safe-json_1_2_0_2" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, containers, dlist
-     , hashable, quickcheck-instances, scientific, tasty, tasty-hunit
-     , tasty-quickcheck, temporary, text, time, unordered-containers
-     , uuid, uuid-types, vector
-     }:
-     mkDerivation {
-       pname = "safe-json";
        version = "1.2.0.2";
        sha256 = "1zl0f3y1kih1y3i6376rkizd9kfklqxf7lnj3aipn5ph935lljrz";
        libraryHaskellDepends = [
···
        ];
        description = "Automatic JSON format versioning";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "safe-lazy-io" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "sandwich_0_3_0_0" = callPackage
+  "sandwich_0_3_0_2" = callPackage
     ({ mkDerivation, aeson, ansi-terminal, async, base, brick
      , bytestring, colour, containers, deepseq, directory, exceptions
      , filepath, free, haskell-src-exts, microlens, microlens-th
···
      }:
      mkDerivation {
        pname = "sandwich";
-       version = "0.3.0.0";
-       sha256 = "1krxfk7skys70n8cjpvw5khhk6xlw6l5gra9vvgqqxpcjdnbb1y4";
+       version = "0.3.0.2";
+       sha256 = "06ypw3aidlsj86kwavdxw5y3zhivr9ipxv40r6cvmzfql22v9fx8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "sandwich-contexts";
-       version = "0.3.0.0";
-       sha256 = "0qmp7ag57im3a9mq6z1qkzbn1qqjnq8w9y8qinqlxzn9iwq6skg9";
+       version = "0.3.0.1";
+       sha256 = "005b2916y6sx8wf82q40iq9jcc7vp2anmlb3pdw0rpwdj8k66pjk";
        libraryHaskellDepends = [
          aeson base conduit conduit-extra containers crypton-connection
          data-default exceptions filepath HTTP http-client http-conduit
···
        pname = "scheduler";
        version = "2.0.0.1";
        sha256 = "1hdqm04m3n5y3xrhilj0hykrmqdsjz5p6k2p9y1005khkj5dag9f";
+       revision = "1";
+       editedCabalFile = "1ggvvz62xw0hcvb186xrfrnm4fn3ppkx207kqrzpc4sxwr5zdfl1";
        libraryHaskellDepends = [
          atomic-primops base deepseq exceptions primitive pvar unliftio-core
        ];
···
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        mainProgram = "scope-cairo";
+     }) {};
+
+  "scoped-codensity" = callPackage
+    ({ mkDerivation, async, base, hspec, temporary, text, transformers
+     , unliftio, unliftio-core
+     }:
+     mkDerivation {
+       pname = "scoped-codensity";
+       version = "0.2.0.0";
+       sha256 = "0mkdvwrj4s0x17jr9gv2wnwvs71j00486pbzmv26s20jd2m5a05p";
+       libraryHaskellDepends = [
+         async base temporary text transformers unliftio unliftio-core
+       ];
+       testHaskellDepends = [ base hspec transformers unliftio ];
+       description = "CPS resource allocation but as a Monad and completely safe";
+       license = lib.licenses.agpl3Plus;
      }) {};
 
   "scottish" = callPackage
···
     ({ mkDerivation, base, containers, criterion, doctest, hspec }:
      mkDerivation {
        pname = "search-algorithms";
-       version = "0.3.2";
-       sha256 = "0lkpsr4vwf77slgwxc38xmhkwwxbh360gjqhblysrph7rl9w7sh7";
+       version = "0.3.3";
+       sha256 = "00b1fxgjg57m6qm8017yvqbs6qvblw4iazir005flzjm6jls12kz";
        libraryHaskellDepends = [ base containers ];
        testHaskellDepends = [ base containers doctest hspec ];
        benchmarkHaskellDepends = [ base criterion ];
···
        license = lib.licenses.mit;
      }) {inherit (pkgs) secp256k1;};
 
-  "secp256k1-haskell_1_4_0" = callPackage
+  "secp256k1-haskell_1_4_2" = callPackage
     ({ mkDerivation, base, base16, bytestring, deepseq, entropy
      , hashable, hspec, hspec-discover, HUnit, monad-par, mtl
      , QuickCheck, secp256k1, string-conversions, unliftio-core
      }:
      mkDerivation {
        pname = "secp256k1-haskell";
-       version = "1.4.0";
-       sha256 = "1nba3f1952p229wbjmbpx80h212mmf1njvyxikiw9c4vpkfksx8b";
+       version = "1.4.2";
+       sha256 = "0b9xff4r63aqkdag7v67h9yxaa023i1mylih9wcjh1qa8lcb9zn6";
        libraryHaskellDepends = [
          base base16 bytestring deepseq entropy hashable QuickCheck
          string-conversions unliftio-core
···
      }:
      mkDerivation {
        pname = "select-rpms";
-       version = "0.1.0";
-       sha256 = "056an1cn0zx3ibbfx0qpv8aw19vnc8igkhz5phjmvypxzls75qd6";
+       version = "0.2.0";
+       sha256 = "14w9j0jdjsqqd75ppka418hjy0ns1cf30q65cakz8mv81ycdpslc";
        libraryHaskellDepends = [
          base directory extra filepath Glob rpm-nvr safe simple-cmd
          simple-cmd-args simple-prompt
···
        license = lib.licenses.gpl3Only;
      }) {};
 
-  "sequence-formats_1_9_0_0" = callPackage
+  "sequence-formats_1_10_0_0" = callPackage
     ({ mkDerivation, attoparsec, base, bytestring, containers, errors
      , exceptions, foldl, hspec, lens-family, pipes, pipes-attoparsec
      , pipes-bytestring, pipes-safe, pipes-zlib, streaming-commons
···
      }:
      mkDerivation {
        pname = "sequence-formats";
-       version = "1.9.0.0";
-       sha256 = "06zv7qwmdyk35hgam34h8dp69hm936h4n53zz13cdac1kws9m5dg";
+       version = "1.10.0.0";
+       sha256 = "1hsmhhrd88r3wan6b1z1x5j9shy3qg36m27g9lks4fvs95hf76yg";
        libraryHaskellDepends = [
          attoparsec base bytestring containers errors exceptions foldl
          lens-family pipes pipes-attoparsec pipes-bytestring pipes-safe
···
     ({ mkDerivation, base, bytestring, HUnit, unix }:
      mkDerivation {
        pname = "serialport";
-       version = "0.5.5";
-       sha256 = "1mgxfx2xb9jh40vaaa28nwszxph0gpx01x0xynypc757igwhvbkv";
+       version = "0.5.6";
+       sha256 = "00cymqx8jnlanv75kqgb00harhv8prgk23gwwvadqlzdfv119iql";
        libraryHaskellDepends = [ base bytestring unix ];
        testHaskellDepends = [ base bytestring HUnit ];
        description = "Cross platform serial port library";
···
      }) {};
 
   "servant-hateoas" = callPackage
-    ({ mkDerivation, aeson, base, http-media, servant, servant-server
+    ({ mkDerivation, aeson, base, constrained-some, http-media, servant
+     , servant-server
      }:
      mkDerivation {
        pname = "servant-hateoas";
-       version = "0.2.1";
-       sha256 = "0yw72zi2jgmm7vdfivkiajzp35pr72vmcjwnlsvz9plabk3lb1m5";
+       version = "0.2.2";
+       sha256 = "1m6zm7w4y0gzb35fqr4wgma59f2liidp6yjm0pn045xfxnnq2hrw";
        libraryHaskellDepends = [
-         aeson base http-media servant servant-server
+         aeson base constrained-some http-media servant servant-server
        ];
        testHaskellDepends = [ base ];
        description = "HATEOAS extension for servant";
···
 
   "servant-hmac-auth" = callPackage
     ({ mkDerivation, base, base64-bytestring, bytestring
-     , case-insensitive, containers, cryptonite, filepath, hspec
+     , case-insensitive, containers, crypton, filepath, hspec
      , hspec-discover, hspec-golden, http-client, http-types, memory
      , mtl, servant, servant-client, servant-client-core, servant-server
      , text, transformers, wai, warp
      }:
      mkDerivation {
        pname = "servant-hmac-auth";
-       version = "0.1.7";
-       sha256 = "1fj7fjnanmdc92v9xcn1p47w3bav36bl2ck1w1r3s52w8znw1d6v";
+       version = "0.1.8";
+       sha256 = "1rlzlc85ixx0lksn81gh6qzrzqv0qazmwp5a89ijf47wrpdqs2hb";
        libraryHaskellDepends = [
          base base64-bytestring bytestring case-insensitive containers
-         cryptonite http-client http-types memory mtl servant servant-client
+         crypton http-client http-types memory mtl servant servant-client
          servant-client-core servant-server transformers wai
        ];
        testHaskellDepends = [
···
        pname = "sets";
        version = "0.0.6.2";
        sha256 = "0xgk04fvfrl8syyg2cf5s2jazmdasjqh3fdsgamxak2wvjpyvf9l";
-       revision = "1";
-       editedCabalFile = "1qfkr0rcqvqqgnrsjq4blgwha3ylzchcbvhhz65mz44ql71m76g8";
+       revision = "2";
+       editedCabalFile = "0x5a7mwznvbrxd9fw1gi56nz9ji4apzi9v114i5lsf8hcj62slnn";
        libraryHaskellDepends = [
          base bytestring commutative composition containers contravariant
          hashable keys mtl QuickCheck semigroupoids semigroups transformers
···
        broken = true;
      }) {};
 
+  "shaderc" = callPackage
+    ({ mkDerivation, base, bytestring, c-enum, c-struct, data-default
+     , exception-hierarchy, language-spir-v, mtl, nowdoc, shaderc
+     , storable-peek-poke, template-haskell
+     }:
+     mkDerivation {
+       pname = "shaderc";
+       version = "0.1.0.5";
+       sha256 = "01v24hlfpy4yi56rwgw4xvaijqmir76287sp5kq8is5xqr23v34z";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         base bytestring c-enum c-struct data-default exception-hierarchy
+         language-spir-v mtl nowdoc storable-peek-poke template-haskell
+       ];
+       libraryPkgconfigDepends = [ shaderc ];
+       testHaskellDepends = [
+         base bytestring c-enum c-struct data-default exception-hierarchy
+         language-spir-v mtl nowdoc storable-peek-poke template-haskell
+       ];
+       description = "A collection of tools and libraries for Vulkan shader compilation";
+       license = lib.licenses.bsd3;
+     }) {inherit (pkgs) shaderc;};
+
   "shadower" = callPackage
     ({ mkDerivation, base, doctest, filemanip, fsnotify, MissingH, mtl
      , process, safe, system-filepath, text
···
        broken = true;
      }) {};
 
+  "shebanger" = callPackage
+    ({ mkDerivation, base, base64-bytestring, bytestring, cabal-doctest
+     , containers, directory, doctest, filepath, from-sum
+     , optparse-applicative, pretty-simple, process, QuickCheck, tasty
+     , tasty-hunit, template-haskell, text, time, unix
+     }:
+     mkDerivation {
+       pname = "shebanger";
+       version = "1.0.0.0";
+       sha256 = "135darspl4y3vp6q330lnk0ll1732d2ad7a5jhky20b4pc3pa783";
+       isLibrary = true;
+       isExecutable = true;
+       setupHaskellDepends = [ base cabal-doctest ];
+       libraryHaskellDepends = [
+         base base64-bytestring bytestring containers directory filepath
+         from-sum optparse-applicative pretty-simple process text time unix
+       ];
+       executableHaskellDepends = [ base ];
+       testHaskellDepends = [
+         base doctest QuickCheck tasty tasty-hunit template-haskell
+       ];
+       description = "Transform a shell script into a series of scripts with only shebang lines";
+       license = lib.licenses.bsd3;
+       mainProgram = "shebanger";
+     }) {};
+
   "sheets" = callPackage
     ({ mkDerivation, aeson, base, base64-bytestring, bytestring
      , cassava, composite-base, composite-cassava, text, vector
···
     ({ mkDerivation, base, hspec, megaparsec, text }:
      mkDerivation {
        pname = "shellwords";
-       version = "0.1.3.1";
-       sha256 = "1j7skcylpsi4xjh3icp5mvcr1434bcsf8dvha3wd6znn2s2k7wgb";
+       version = "0.1.3.2";
+       sha256 = "1x0yb53qkckxli8sm5ck82c7lccp6kl79sk5mcxizb13a6ikw542";
        libraryHaskellDepends = [ base megaparsec text ];
        testHaskellDepends = [ base hspec megaparsec ];
        description = "Parse strings into words, like a shell would";
        license = lib.licenses.mit;
      }) {};
 
-  "shellwords_0_1_3_2" = callPackage
+  "shellwords_0_1_4_0" = callPackage
     ({ mkDerivation, base, hspec, megaparsec, text }:
      mkDerivation {
        pname = "shellwords";
-       version = "0.1.3.2";
-       sha256 = "1x0yb53qkckxli8sm5ck82c7lccp6kl79sk5mcxizb13a6ikw542";
+       version = "0.1.4.0";
+       sha256 = "0i29na2pyvwgm0fj3zfgpa9g84wkdbdj8ym8ykgr7bzjqnlbl1hk";
        libraryHaskellDepends = [ base megaparsec text ];
        testHaskellDepends = [ base hspec megaparsec ];
        description = "Parse strings into words, like a shell would";
···
        pname = "sign";
        version = "0.4.4";
        sha256 = "1z9csfbl5h4cprvykszn81xncsry7fama2y3gbgnqr7mq15qziq7";
-       revision = "3";
-       editedCabalFile = "1yrpjv01zhshi0ri3kn8sclvyry85raxgfggxqg9pab73vqwfz79";
+       revision = "4";
+       editedCabalFile = "0n7201chgmr5s1g2kshrixmb35mikh1rbxqnl5jq7xhx3p7kkjff";
        libraryHaskellDepends = [
          base containers deepseq hashable lattices universe-base
        ];
···
     ({ mkDerivation, base, deepseq, directory, nanospec, temporary }:
      mkDerivation {
        pname = "silently";
-       version = "1.2.5.3";
-       sha256 = "0wk3yci4r9v0vwyzylj3k07damz17jwc6n6imwqahf4lsapsz7ds";
+       version = "1.2.5.4";
+       sha256 = "0vkl2998n3g3vnzh08vp2lnaavdfk14n0wf7gl04n061cn4n08sy";
        libraryHaskellDepends = [ base deepseq directory ];
        testHaskellDepends = [ base deepseq directory nanospec temporary ];
        description = "Prevent or capture writing to stdout and other handles";
···
        broken = true;
      }) {inherit (pkgs) pango;};
 
+  "simple-pango_0_1_0_2" = callPackage
+    ({ mkDerivation, array, base, bytestring, c-enum, c-struct
+     , containers, glib, glib-stopgap, pango, primitive, simple-cairo
+     , template-haskell, text, union-angle, union-color
+     }:
+     mkDerivation {
+       pname = "simple-pango";
+       version = "0.1.0.2";
+       sha256 = "00663zd0699rfc8sk769abyb7xlnwls6xqpzigkrrhvf6pv5s7mv";
+       libraryHaskellDepends = [
+         array base bytestring c-enum c-struct containers glib-stopgap
+         primitive simple-cairo template-haskell text union-angle
+         union-color
+       ];
+       libraryPkgconfigDepends = [ glib pango ];
+       testHaskellDepends = [
+         array base bytestring c-enum c-struct containers glib-stopgap
+         primitive simple-cairo template-haskell text union-angle
+         union-color
+       ];
+       description = "Binding to Pango library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {inherit (pkgs) glib; inherit (pkgs) pango;};
+
   "simple-parser" = callPackage
     ({ mkDerivation, base, bytestring, containers, errata, exceptions
      , mmorph, mtl, nonempty-containers, scientific, tasty, tasty-hunit
···
     ({ mkDerivation, base, process }:
      mkDerivation {
        pname = "simple-smt";
-       version = "0.9.7";
-       sha256 = "17arwga9irr5aacf0mrdnp1lw1vqlfl3kzwaaiwcw39idlprdnb4";
+       version = "0.9.8";
+       sha256 = "0imimkpzbd013gadkg7sc05jr70lffaij4ijzk368iw8xgvgxyf9";
        libraryHaskellDepends = [ base process ];
        description = "A simple way to interact with an SMT solver process";
        license = lib.licenses.bsd3;
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "singletons_3_0_4" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "singletons";
+       version = "3.0.4";
+       sha256 = "0rcxb8l9vizpq3xgfsijzlig79dw7gx5cds1kv2qnz8ziwxlncq1";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base ];
+       description = "Basic singleton types and definitions";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "singletons-base" = callPackage
     ({ mkDerivation, base, bytestring, Cabal, deepseq, directory
      , filepath, pretty, process, singletons, singletons-th, tasty
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "singletons-th_3_4" = callPackage
+  "singletons-th_3_5" = callPackage
     ({ mkDerivation, base, containers, ghc-boot-th, mtl, singletons
      , syb, template-haskell, th-desugar, th-orphans, transformers
      }:
      mkDerivation {
        pname = "singletons-th";
-       version = "3.4";
-       sha256 = "1fkfaj04g03sw6zsz553a3zyjrhdv7cw1m2dsqb1plk10fj7zi51";
+       version = "3.5";
+       sha256 = "13ws4fgaw286a1ym29wlxaqg6330yg6hy2h941dj2p9vpdcsf8za";
        libraryHaskellDepends = [
          base containers ghc-boot-th mtl singletons syb template-haskell
          th-desugar th-orphans transformers
···
        pname = "size-based";
        version = "0.1.3.3";
        sha256 = "1xc31iy57v9hm97hhr26ws2wwsf56gczwnq7q8ckiy5pgw6fmr1g";
+       revision = "1";
+       editedCabalFile = "0idqj2k42anjwaq0zi6x7iz9jbwy6z3q1zjiml44v2ak21dswxga";
        libraryHaskellDepends = [
          base dictionary-sharing template-haskell testing-type-modifiers
        ];
···
      }:
      mkDerivation {
        pname = "skeletest";
-       version = "0.1.0";
-       sha256 = "1bl02qvmxwa2nswi11lhgp6gnyg3jych6qscmwfyw2d9pawpq4d1";
+       version = "0.1.1";
+       sha256 = "1y01n6g8svwybhq53r6jn7az5r83v1fkw23jrzj3342pyzl579nw";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          parser-combinators pretty recover-rtti template-haskell text
          transformers unliftio
        ];
-       executableHaskellDepends = [ base text ];
+       executableHaskellDepends = [ base text unliftio ];
        testHaskellDepends = [
          aeson base containers directory filepath process text unliftio
        ];
···
        mainProgram = "skylighting";
      }) {};
 
+  "skylighting_0_14_5" = callPackage
+    ({ mkDerivation, base, binary, blaze-html, bytestring, containers
+     , pretty-show, skylighting-core, skylighting-format-ansi
+     , skylighting-format-blaze-html, skylighting-format-context
+     , skylighting-format-latex, text
+     }:
+     mkDerivation {
+       pname = "skylighting";
+       version = "0.14.5";
+       sha256 = "1xs3vhxa8nyn8fm99jzn8cmd3n0y50sjrvy7k05vp5jr5g00zhkc";
+       configureFlags = [ "-fexecutable" ];
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base binary containers skylighting-core skylighting-format-ansi
+         skylighting-format-blaze-html skylighting-format-context
+         skylighting-format-latex
+       ];
+       executableHaskellDepends = [
+         base blaze-html bytestring containers pretty-show text
+       ];
+       description = "syntax highlighting library";
+       license = lib.licenses.gpl2Only;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "skylighting";
+     }) {};
+
   "skylighting-core" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, base64-bytestring, binary
      , bytestring, case-insensitive, colour, containers, criterion, Diff
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "skylighting-core_0_14_5" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring, binary
+     , bytestring, case-insensitive, colour, containers, criterion, Diff
+     , directory, filepath, mtl, pretty-show, QuickCheck, safe, tasty
+     , tasty-golden, tasty-hunit, tasty-quickcheck, text, transformers
+     , utf8-string, xml-conduit
+     }:
+     mkDerivation {
+       pname = "skylighting-core";
+       version = "0.14.5";
+       sha256 = "1bld0xwrbhspycm9ii7rb3c2wnydvc6vmw9q0sxyk6iavsmia0kd";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson attoparsec base base64-bytestring binary bytestring
+         case-insensitive colour containers directory filepath mtl safe text
+         transformers utf8-string xml-conduit
+       ];
+       testHaskellDepends = [
+         aeson base bytestring containers Diff directory filepath
+         pretty-show QuickCheck tasty tasty-golden tasty-hunit
+         tasty-quickcheck text
+       ];
+       benchmarkHaskellDepends = [
+         base containers criterion filepath text
+       ];
+       description = "syntax highlighting library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "skylighting-extensions" = callPackage
     ({ mkDerivation, base, containers, skylighting, skylighting-modding
      , text
···
        ];
        description = "HTML formatter for skylighting syntax highlighting library";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "skylighting-format-blaze-html_0_1_1_3" = callPackage
+    ({ mkDerivation, base, blaze-html, containers, skylighting-core
+     , text
+     }:
+     mkDerivation {
+       pname = "skylighting-format-blaze-html";
+       version = "0.1.1.3";
+       sha256 = "1rjjfcnq1395zmgxv123yy3khia7swrhcr77h8lg4h5jxgm2rs24";
+       libraryHaskellDepends = [
+         base blaze-html containers skylighting-core text
+       ];
+       description = "HTML formatter for skylighting syntax highlighting library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "skylighting-format-context" = callPackage
···
        pname = "some";
        version = "1.0.6";
        sha256 = "1fdzhi2rmcigb1c727dyzfak8rgb77bzfr33k1cp987lbnnhd9pp";
-       revision = "1";
-       editedCabalFile = "0awhdjzvgrnq37m0c9hy5sya1capi3asns9xf3bjyfgv4zf2cb7i";
+       revision = "2";
+       editedCabalFile = "1w4xi6k44bjyrvhq70550fwrvqfybrq747aws708q18zsbriandc";
        libraryHaskellDepends = [ base base-orphans deepseq ];
        testHaskellDepends = [ base ];
        description = "Existential type: Some";
···
      }:
      mkDerivation {
        pname = "specup";
-       version = "0.2.0.3";
-       sha256 = "141y6m3l4m39jmdfprk9lksrcgzld1clw5sg6pqw14vry7icq9j8";
+       version = "0.2.0.4";
+       sha256 = "1y57jx5mr1pz0zxmqg3277ba455v47s52ijnvlkr6mqiyy04rawy";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "speedy-slice";
        version = "0.3.2";
        sha256 = "1bmy0hrrqgwbqsk1ckbmzy1hhcwlcjsclcskrdmzfq5afvq9kq3z";
+       revision = "1";
+       editedCabalFile = "1k59vnr20mn9fcjqailnhk5v6z2bbx2c5xym1f5ja93jpyw4vjxb";
        libraryHaskellDepends = [
          base kan-extensions lens mcmc-types mwc-probability pipes primitive
          transformers
···
        ];
        description = "Fast Splittable PRNG";
        license = lib.licenses.bsd3;
+     }) {testu01 = null;};
+
+  "splitmix_0_1_1" = callPackage
+    ({ mkDerivation, async, base, base-compat-batteries, bytestring
+     , containers, criterion, deepseq, HUnit, math-functions, process
+     , random, test-framework, test-framework-hunit, testu01, tf-random
+     , vector
+     }:
+     mkDerivation {
+       pname = "splitmix";
+       version = "0.1.1";
+       sha256 = "1iqjxg3jdjmpj6rchnab1scr6b12p1mk7y75ywn06qisc0dc8y6n";
+       libraryHaskellDepends = [ base deepseq ];
+       testHaskellDepends = [
+         async base base-compat-batteries bytestring containers deepseq
+         HUnit math-functions process random test-framework
+         test-framework-hunit tf-random vector
+       ];
+       testSystemDepends = [ testu01 ];
+       benchmarkHaskellDepends = [
+         base containers criterion random tf-random
+       ];
+       description = "Fast Splittable PRNG";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {testu01 = null;};
 
   "splitmix-distributions" = callPackage
···
      }) {inherit (pkgs) sqlite;};
 
   "sqlite-easy" = callPackage
-    ({ mkDerivation, base, bytestring, direct-sqlite, hspec
-     , hspec-discover, migrant-core, mtl, resource-pool, text, unliftio
-     , unliftio-core
+    ({ mkDerivation, base, bytestring, criterion, deepseq
+     , direct-sqlite, hspec, hspec-discover, migrant-core, mtl
+     , resource-pool, text, unliftio, unliftio-core
      }:
      mkDerivation {
        pname = "sqlite-easy";
-       version = "1.1.0.1";
-       sha256 = "04f83krzb5a806dszhhnyhrxpvh6qr00579cq6h4bhz6bk54ivrz";
+       version = "1.1.1.0";
+       sha256 = "0w2gb082j2gazay2gvwwksfswwsyh8idvmbnjb0gnbjvq3k2l8nk";
        libraryHaskellDepends = [
          base bytestring direct-sqlite migrant-core mtl resource-pool text
          unliftio-core
···
          base direct-sqlite hspec hspec-discover text unliftio
        ];
        testToolDepends = [ hspec-discover ];
+       benchmarkHaskellDepends = [ base criterion deepseq ];
        description = "A primitive yet easy to use sqlite library";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "srtree_2_0_0_2" = callPackage
+    ({ mkDerivation, ad, attoparsec, attoparsec-expr, base, bytestring
+     , containers, dlist, exceptions, filepath, hashable, HUnit, ieee754
+     , lens, list-shuffle, massiv, mtl, nlopt, normaldistribution
+     , optparse-applicative, random, split, statistics, transformers
+     , unordered-containers, vector, zlib
+     }:
+     mkDerivation {
+       pname = "srtree";
+       version = "2.0.0.2";
+       sha256 = "1azvqikk4d9rdd2hc96s7bsnzn575w0lvw6xrl1iiv40655xsdzf";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         attoparsec attoparsec-expr base bytestring containers dlist
+         exceptions filepath hashable ieee754 lens list-shuffle massiv mtl
+         random split statistics transformers unordered-containers vector
+         zlib
+       ];
+       librarySystemDepends = [ nlopt ];
+       executableHaskellDepends = [
+         attoparsec attoparsec-expr base bytestring containers dlist
+         exceptions filepath hashable ieee754 lens list-shuffle massiv mtl
+         normaldistribution optparse-applicative random split statistics
+         transformers unordered-containers vector zlib
+       ];
+       testHaskellDepends = [
+         ad attoparsec attoparsec-expr base bytestring containers dlist
+         exceptions filepath hashable HUnit ieee754 lens list-shuffle massiv
+         mtl random split statistics transformers unordered-containers
+         vector zlib
+       ];
+       description = "A general library to work with Symbolic Regression expression trees";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {inherit (pkgs) nlopt;};
+
   "srv" = callPackage
     ({ mkDerivation, async, base, bytestring, containers, directory
      , raw-strings-qq, wai, wai-app-static, warp, warp-tls, yaml
···
        pname = "stack";
        version = "3.1.1";
        sha256 = "0iax7ncga64mgkbiy0psjrd603kz8k8m67f718xl4vpyn3m03by4";
-       revision = "1";
-       editedCabalFile = "18a7ggbvs90d452njdwscmxjg56axk4az0w3c8shisfg0ykd1x6g";
+       revision = "2";
+       editedCabalFile = "13nzc84msj5r09hj9rjbwj3wmfkcv6q618106yq3pq8kyc7d40ap";
        configureFlags = [
          "-fdisable-git-info" "-fhide-dependency-versions"
          "-fsupported-build"
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "storable-generic" = callPackage
+    ({ mkDerivation, base, storable-peek-poke, template-haskell }:
+     mkDerivation {
+       pname = "storable-generic";
+       version = "0.1.0.5";
+       sha256 = "1hzxshar3iw5z8wnwkwmpn2sfjlvrm2cklq04f4drpm8gd10fzch";
+       libraryHaskellDepends = [
+         base storable-peek-poke template-haskell
+       ];
+       testHaskellDepends = [ base storable-peek-poke template-haskell ];
+       description = "Derive Storable instances with GHC.Generics";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "storable-hetero-list" = callPackage
     ({ mkDerivation, base, hetero-parameter-list, storable-peek-poke }:
      mkDerivation {
···
     ({ mkDerivation, base, typelevel-tools-yj }:
      mkDerivation {
        pname = "storable-peek-poke";
-       version = "0.1.0.1";
-       sha256 = "1irarnv968qqmsvgvzp8xw994j267qirnj1sj57fr34z40ck3nbb";
-       revision = "1";
-       editedCabalFile = "18lxyryk05m4s94977g8irxiwnsp06llp962w5nh0rpsazdrhm4r";
+       version = "0.1.0.2";
+       sha256 = "0pgssxp3fj4bmp9h8hy1w2lxhshqi1x030nhihllvy78kw757zgz";
        libraryHaskellDepends = [ base typelevel-tools-yj ];
        testHaskellDepends = [ base typelevel-tools-yj ];
        description = "class Sizable, Peek and Poke";
···
        license = lib.licenses.mit;
      }) {};
 
+  "store_0_7_20" = callPackage
+    ({ mkDerivation, array, async, base, base-orphans
+     , base64-bytestring, bifunctors, bytestring, cereal, cereal-vector
+     , clock, containers, contravariant, criterion, cryptohash-sha1
+     , deepseq, directory, filepath, free, ghc-prim, hashable, hspec
+     , hspec-discover, hspec-smallcheck, integer-gmp, lifted-base
+     , monad-control, mono-traversable, nats, network, primitive
+     , resourcet, safe, smallcheck, store-core, syb, template-haskell
+     , text, th-lift, th-lift-instances, th-orphans, th-reify-many
+     , th-utilities, time, transformers, unordered-containers, vector
+     , vector-binary-instances, void, weigh
+     }:
+     mkDerivation {
+       pname = "store";
+       version = "0.7.20";
+       sha256 = "1ysp87fhqxw2rlcbhfba1z08j8ml7gq1a1ic6dcl5mdyxxmqywr0";
+       libraryHaskellDepends = [
+         array async base base-orphans base64-bytestring bifunctors
+         bytestring containers contravariant cryptohash-sha1 deepseq
+         directory filepath free ghc-prim hashable hspec hspec-smallcheck
+         integer-gmp lifted-base monad-control mono-traversable nats network
+         primitive resourcet safe smallcheck store-core syb template-haskell
+         text th-lift th-lift-instances th-orphans th-reify-many
+         th-utilities time transformers unordered-containers vector void
+       ];
+       testHaskellDepends = [
+         array async base base-orphans base64-bytestring bifunctors
+         bytestring clock containers contravariant cryptohash-sha1 deepseq
+         directory filepath free ghc-prim hashable hspec hspec-smallcheck
+         integer-gmp lifted-base monad-control mono-traversable nats network
+         primitive resourcet safe smallcheck store-core syb template-haskell
+         text th-lift th-lift-instances th-orphans th-reify-many
+         th-utilities time transformers unordered-containers vector void
+       ];
+       testToolDepends = [ hspec-discover ];
+       benchmarkHaskellDepends = [
+         array async base base-orphans base64-bytestring bifunctors
+         bytestring cereal cereal-vector containers contravariant criterion
+         cryptohash-sha1 deepseq directory filepath free ghc-prim hashable
+         hspec hspec-smallcheck integer-gmp lifted-base monad-control
+         mono-traversable nats network primitive resourcet safe smallcheck
+         store-core syb template-haskell text th-lift th-lift-instances
+         th-orphans th-reify-many th-utilities time transformers
+         unordered-containers vector vector-binary-instances void weigh
+       ];
+       description = "Fast binary serialization";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "store-core" = callPackage
     ({ mkDerivation, base, bytestring, ghc-prim, primitive, text
      , transformers
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "streams_3_3_3" = callPackage
+    ({ mkDerivation, adjunctions, base, boring, comonad, distributive
+     , semigroupoids
+     }:
+     mkDerivation {
+       pname = "streams";
+       version = "3.3.3";
+       sha256 = "01ns1pj35dm2b04ryn7qrp75wqzrlj7yg3f8wwp150r99z89lqh7";
+       libraryHaskellDepends = [
+         adjunctions base boring comonad distributive semigroupoids
+       ];
+       description = "Various Haskell 2010 stream comonads";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "streamt" = callPackage
     ({ mkDerivation, async, base, criterion, hspec, logict, mtl, tasty
      , tasty-hunit
···
        license = lib.licenses.mit;
      }) {};
 
+  "strive_6_0_0_13" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, data-default, gpolyline
+     , http-client, http-client-tls, http-types, template-haskell, text
+     , time, transformers
+     }:
+     mkDerivation {
+       pname = "strive";
+       version = "6.0.0.13";
+       sha256 = "0wkpc8qlgjga9y7s1y1vmnf0wilh5pycp8fiim744m1wjc2368xg";
+       libraryHaskellDepends = [
+         aeson base bytestring data-default gpolyline http-client
+         http-client-tls http-types template-haskell text time transformers
+       ];
+       description = "A client for the Strava V3 API";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "strong-path" = callPackage
     ({ mkDerivation, base, exceptions, filepath, hashable, hspec, path
      , tasty, tasty-discover, tasty-hspec, tasty-quickcheck
···
        pname = "structs";
        version = "0.1.9";
        sha256 = "033vx729k9jn4w4hs3kp8nlnf0ylsqgg3q4cmb7zjfpgk4bk511w";
-       revision = "2";
-       editedCabalFile = "1lkx7hflya4v5pkwrf3n01rx6z9rficy2s8k2b3xx8fsch932a4s";
+       revision = "3";
+       editedCabalFile = "05ymnx9vzba6jqkx2jil2qj15399qz9dxzqsy6gfpx1j65spjrva";
        libraryHaskellDepends = [
          base deepseq ghc-prim primitive template-haskell th-abstraction
        ];
···
        mainProgram = "Swish";
      }) {};
 
+  "swish_0_10_10_0" = callPackage
+    ({ mkDerivation, base, containers, directory, filepath, hashable
+     , HUnit, intern, mtl, network-uri, polyparse, semigroups
+     , test-framework, test-framework-hunit, text, time
+     }:
+     mkDerivation {
+       pname = "swish";
+       version = "0.10.10.0";
+       sha256 = "1ssw4qg0dcxz9bas30g1z98sgfq3x92kbslm640vn01frga48m9c";
+       isLibrary = true;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         base containers directory filepath hashable intern mtl network-uri
+         polyparse text time
+       ];
+       executableHaskellDepends = [ base ];
+       testHaskellDepends = [
+         base containers hashable HUnit network-uri semigroups
+         test-framework test-framework-hunit text time
+       ];
+       description = "A semantic web toolkit";
+       license = lib.licenses.lgpl21Plus;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "Swish";
+     }) {};
+
   "swiss" = callPackage
     ({ mkDerivation, base, bytestring, parallel, time }:
      mkDerivation {
···
        license = "unknown";
      }) {};
 
-  "sydtest_0_18_0_1" = callPackage
+  "sydtest_0_19_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
···
      }:
      mkDerivation {
        pname = "sydtest";
-       version = "0.18.0.1";
-       sha256 = "1lzmm6s4z3w4ny0r9a0g40agzkz2vdzf9c91zxkjrmbmbbh6lj8l";
+       version = "0.19.0.0";
+       sha256 = "12wp36pi2w7f3wffrmss8ra5y3xcpar4i9zp04z5r1g11y9i2h80";
        libraryHaskellDepends = [
          async autodocodec base bytestring containers deepseq dlist
          fast-myers-diff filepath MonadRandom mtl opt-env-conf path path-io
···
      }:
      mkDerivation {
        pname = "system-fileio";
-       version = "0.3.16.4";
-       sha256 = "1iy6g1f35gzyj12g9mdiw4zf75mmxpv1l8cyaldgyscsl648pr9l";
+       version = "0.3.16.5";
+       sha256 = "0a5hsdlzjjhfq7zvhg0fdlzviq6w8jj4jvkmk4wl1s07liwdqqw9";
+       libraryHaskellDepends = [
+         base bytestring system-filepath text time unix
+       ];
+       testHaskellDepends = [
+         base bytestring chell system-filepath temporary text time
+         transformers unix
+       ];
+       description = "Consistent filesystem interaction across GHC versions (deprecated)";
+       license = lib.licenses.mit;
+     }) {};
+
+  "system-fileio_0_3_16_6" = callPackage
+    ({ mkDerivation, base, bytestring, chell, system-filepath
+     , temporary, text, time, transformers, unix
+     }:
+     mkDerivation {
+       pname = "system-fileio";
+       version = "0.3.16.6";
+       sha256 = "0qmsvs5jpg6y82cqh0g37f7dz8172ikgiwcpgs72zwxq35xk271a";
        libraryHaskellDepends = [
          base bytestring system-filepath text time unix
        ];
···
        ];
        description = "Consistent filesystem interaction across GHC versions (deprecated)";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "system-filepath" = callPackage
-    ({ mkDerivation, base, bytestring, Cabal, chell, chell-quickcheck
-     , deepseq, QuickCheck, text
+    ({ mkDerivation, base, bytestring, chell, chell-quickcheck, deepseq
+     , QuickCheck, text
      }:
      mkDerivation {
        pname = "system-filepath";
-       version = "0.4.14";
-       sha256 = "14yras4pz2dh55xpwmazcgxijvi8913pjgzb9iw50mjq1lycwmhn";
-       revision = "2";
-       editedCabalFile = "0731bm8msw4gdaxy0dmya55w91yh9nk952ysf82n32c0nib1hdr4";
-       setupHaskellDepends = [ base Cabal ];
+       version = "0.4.14.1";
+       sha256 = "19fs8g1p07ckb0ydak4fczz58ngy3aywkliv1hbcvlc5w512j8ig";
        libraryHaskellDepends = [ base bytestring deepseq text ];
        testHaskellDepends = [
          base bytestring chell chell-quickcheck QuickCheck text
···
      }:
      mkDerivation {
        pname = "systranything";
-       version = "0.1.1.0";
-       sha256 = "0d41zlfxb3gvhii3fgr4wb1gsids0l7594xdahq5s23wcapaif6b";
+       version = "0.1.2.0";
+       sha256 = "1da3zqkknx9yg8spwjpaxx4sizwl598p2dwr2nnrl6dw033c6m1f";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "tagged_0_8_9" = callPackage
+    ({ mkDerivation, base, deepseq, template-haskell, transformers }:
+     mkDerivation {
+       pname = "tagged";
+       version = "0.8.9";
+       sha256 = "1137jm5zbnirv7padqqhc0ky8l3npqn8v2fjasjscjs1pf7diakd";
+       libraryHaskellDepends = [
+         base deepseq template-haskell transformers
+       ];
+       description = "Haskell 98 phantom types to avoid unsafely passing dummy arguments";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "tagged-binary" = callPackage
     ({ mkDerivation, base, base-compat, binary, bytestring, pureMD5 }:
      mkDerivation {
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "tagged-transformer_0_8_3" = callPackage
+    ({ mkDerivation, base, comonad, contravariant, distributive
+     , exceptions, mtl, reflection, semigroupoids, tagged
+     }:
+     mkDerivation {
+       pname = "tagged-transformer";
+       version = "0.8.3";
+       sha256 = "1d8amfva6pvkb9d7pkbppdxl0fp2pvsj4gdrblarr0ckx6xigjl1";
+       libraryHaskellDepends = [
+         base comonad contravariant distributive exceptions mtl reflection
+         semigroupoids tagged
+       ];
+       description = "Monad transformer carrying an extra phantom type tag";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "tagging" = callPackage
     ({ mkDerivation, base, bytestring, pcre-light }:
      mkDerivation {
···
        license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        mainProgram = "talash";
+       broken = true;
      }) {};
 
   "tamarin-prover" = callPackage
···
        mainProgram = "tasty-autocollect";
      }) {};
 
+  "tasty-autocollect_0_4_4" = callPackage
+    ({ mkDerivation, base, bytestring, containers, directory
+     , explainable-predicates, filepath, ghc, tasty
+     , tasty-expected-failure, tasty-golden, tasty-hunit
+     , tasty-quickcheck, template-haskell, temporary, text, transformers
+     , typed-process
+     }:
+     mkDerivation {
+       pname = "tasty-autocollect";
+       version = "0.4.4";
+       sha256 = "0bkih5566dai863sbig697wn6s6zxy7kgq9igdj7vyl3axq4wqkz";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring containers directory filepath ghc tasty
+         tasty-expected-failure template-haskell text transformers
+       ];
+       executableHaskellDepends = [ base text ];
+       testHaskellDepends = [
+         base bytestring containers directory explainable-predicates
+         filepath tasty tasty-golden tasty-hunit tasty-quickcheck temporary
+         text typed-process
+       ];
+       description = "Autocollection of tasty tests";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "tasty-autocollect";
+     }) {};
+
   "tasty-bdd" = callPackage
     ({ mkDerivation, aeson, aeson-qq, base, exceptions, free, HUnit
      , microlens, microlens-th, mtl, pretty, pretty-show
···
        pname = "tasty-bench";
        version = "0.4";
        sha256 = "1qkvdp1djbvb2b7yxckpfaygdgsh71h340mbvprm0r6dim3q1742";
+       revision = "1";
+       editedCabalFile = "1qqz7jr0pgfg6sxgcddfgnxk8xwlf1ymllwf64bg2ddfjkm3dqq6";
        libraryHaskellDepends = [ base containers deepseq ghc-prim tasty ];
        benchmarkHaskellDepends = [ base ];
        description = "Featherlight benchmark framework";
···
     ({ mkDerivation, base, retry, tagged, tasty, tasty-hunit }:
      mkDerivation {
        pname = "tasty-flaky";
-       version = "0.1.0.0";
-       sha256 = "1p0lvfics2p98jhg46m1gl7lrpq73v1waxplvib77pl5q9ymlk87";
-       revision = "1";
-       editedCabalFile = "0kdx020wypr226q9syn1wiq3a7szyzy66khfzh3ssr290r0sknci";
+       version = "0.1.1.0";
+       sha256 = "0i7ajmpiywa1k1kbdvnwkgna9majxmq7s07asrvlbgy22mkyq2py";
        libraryHaskellDepends = [ base retry tagged tasty ];
        testHaskellDepends = [ base tasty tasty-hunit ];
        description = "Handle flaky Tasty-based tests";
···
        license = lib.licenses.mit;
      }) {};
 
+  "tasty-golden-extra" = callPackage
+    ({ mkDerivation, aeson, aeson-diff, aeson-pretty, base, bytestring
+     , pretty-show, pretty-simple, tasty, tasty-discover, tasty-golden
+     , text, yaml
+     }:
+     mkDerivation {
+       pname = "tasty-golden-extra";
+       version = "0.1.0.0";
+       sha256 = "1bfd9ql3pws2vd37nbc5a8b49p7zbq3n48slxkrrwx1szaxkp8nj";
+       revision = "1";
+       editedCabalFile = "0y2a1vcyl1i4dga07ahpm52f2z3dlp52rq4m1hh706s8g2hpf8gz";
+       libraryHaskellDepends = [
+         aeson aeson-diff aeson-pretty base bytestring pretty-show
+         pretty-simple tasty tasty-discover tasty-golden text yaml
+       ];
+       description = "Additional golden test helpers for the tasty-golden package";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "tasty-grading-system" = callPackage
     ({ mkDerivation, aeson, base, containers, directory, filepath
      , generic-deriving, mtl, stm, tagged, tasty, text
···
        pname = "tasty-hedgehog";
        version = "1.4.0.2";
        sha256 = "0lki03z0p38x0dkqx5cqga30zy5m31gxn1saqylja9bi6bbq8d25";
-       revision = "5";
-       editedCabalFile = "19csv89pdva2d5fa0f9kwiq9cdcr51gsnaay62icjpkjw9anapch";
+       revision = "6";
+       editedCabalFile = "1rb8ncp6xyy7jr6v0hyls9m529ba0djndsxgxmkgr52rk3qq8lrc";
        libraryHaskellDepends = [ base hedgehog tagged tasty ];
        testHaskellDepends = [
          base hedgehog tasty tasty-expected-failure
···
        pname = "tasty-inspection-testing";
        version = "0.2.1";
        sha256 = "0wl2xlnbmqdkwhi4ic6a4q4lxf9qg433lidi8d0hlp3ykrjpbcay";
+       revision = "1";
+       editedCabalFile = "1gv2irfyh7bv1ib8palq6g4chh9wfa93k56f14650isxi9ma6wj4";
        libraryHaskellDepends = [
          base ghc inspection-testing tasty template-haskell
        ];
···
        pname = "tasty-rerun";
        version = "1.1.19";
        sha256 = "0dbj5jyms4rkb241dw2vgkzk442zga58zhg8mmw0ksi4yw0z8gbg";
-       revision = "3";
-       editedCabalFile = "0s83ylr3wj2whzia7s4yb0cihbpz762nfdmg2kwr3nalpd8j1lzk";
+       revision = "4";
+       editedCabalFile = "1y6qmwdwwdqmjlybjjmrh22s8856kcfnl2gaq1v2z8wzn6jcfr2l";
        libraryHaskellDepends = [
          base containers mtl optparse-applicative split stm tagged tasty
          transformers
···
      }) {};
 
   "telegram-bot-api" = callPackage
-    ({ mkDerivation, aeson, aeson-pretty, base, bytestring, cron
-     , filepath, hashable, http-api-data, http-client, http-client-tls
-     , monad-control, mtl, pretty-show, profunctors, servant
-     , servant-client, servant-multipart-api, servant-multipart-client
-     , servant-server, split, stm, template-haskell, text, time
-     , transformers, unordered-containers, warp, warp-tls
+    ({ mkDerivation, aeson, base, filepath, hashable, http-api-data
+     , http-client, http-client-tls, mtl, servant, servant-client
+     , servant-multipart-api, servant-multipart-client, servant-server
+     , template-haskell, text, time
      }:
      mkDerivation {
        pname = "telegram-bot-api";
-       version = "7.4.2";
-       sha256 = "0ckl3b1hcdv93wa764rgkv4kpzv52dy1rf61k6w8iha6619rh9m1";
+       version = "7.4.4";
+       sha256 = "1viyh5vkis6gydp7n1vrn3x17hjw3q872z6as54y7kfm9r07kp4h";
        libraryHaskellDepends = [
-         aeson aeson-pretty base bytestring cron filepath hashable
-         http-api-data http-client http-client-tls monad-control mtl
-         pretty-show profunctors servant servant-client
-         servant-multipart-api servant-multipart-client servant-server split
-         stm template-haskell text time transformers unordered-containers
-         warp warp-tls
+         aeson base filepath hashable http-api-data http-client
+         http-client-tls mtl servant servant-client servant-multipart-api
+         servant-multipart-client servant-server template-haskell text time
        ];
        description = "Easy to use library for building Telegram bots. Exports Telegram Bot API.";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "telegram-bot-simple";
-       version = "0.14.3";
-       sha256 = "0h7cpa5zbhz9y362djxznl2q1s0mj1ci6fg071i21fbk1fkjsmhf";
-       revision = "2";
-       editedCabalFile = "1qkx0vyx4y07khwk5vf0kx735q0s3x5f4rggrdb7dy96dfpsvaz3";
+       version = "0.14.4";
+       sha256 = "1pcwn8ykq244yl3sy6ip4jhy2i98j2d01av2h0x348abxmqbh3gb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        broken = true;
      }) {};
 
-  "template-haskell_2_22_0_0" = callPackage
-    ({ mkDerivation, base, ghc-boot-th, ghc-prim, pretty }:
+  "template-haskell_2_23_0_0" = callPackage
+    ({ mkDerivation, base, ghc-boot-th }:
      mkDerivation {
        pname = "template-haskell";
-       version = "2.22.0.0";
-       sha256 = "0cn9n5jyzn9h1ab76rr2cyxaysh2rk7ywcj92lxsf49fah4vx35g";
-       libraryHaskellDepends = [ base ghc-boot-th ghc-prim pretty ];
+       version = "2.23.0.0";
+       sha256 = "1nflc99kixhgj8h05lvlin8dpxbxngs8j436qxgqaqzx3ijncbdf";
+       libraryHaskellDepends = [ base ghc-boot-th ];
        description = "Support library for Template Haskell";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
···
        pname = "testcontainers";
        version = "0.5.0.0";
        sha256 = "06n02inh5ihbbpmlf7fjvq8idk4lrr8wsjbwarklh229azq99h7n";
-       revision = "1";
-       editedCabalFile = "19lxdf3hyhraf7ykx3cdv70j8rc9jx1ynfkjqpczm4pmp72pw06p";
+       revision = "2";
+       editedCabalFile = "0r4f5h7kpp83inva3ki0qgwhgralk35bdka3xwfmnymf3l7ix8sn";
        libraryHaskellDepends = [
          aeson aeson-optics async base bytestring directory exceptions
          http-client http-types mtl network optics-core process random
···
        license = lib.licenses.gpl2Only;
      }) {};
 
-  "texmath_0_12_8_11" = callPackage
+  "texmath_0_12_8_12" = callPackage
     ({ mkDerivation, base, bytestring, containers, directory, filepath
      , mtl, pandoc-types, parsec, pretty-show, split, syb, tagged, tasty
      , tasty-golden, text, typst-symbols, xml
      }:
      mkDerivation {
        pname = "texmath";
-       version = "0.12.8.11";
-       sha256 = "0yyxr5bdl1shsp3ir9d9a2hwah3cz6p3pvak27k4fvk1idisds7z";
+       version = "0.12.8.12";
+       sha256 = "10q5kl82hdaqnryw4wd0218ydym71hqmg0rbpgf3i92ilqm5a18f";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "text";
        version = "2.1.2";
        sha256 = "1dmcrvgavan5r5h4w0rjcmjii3l1rglr03wi4nd8xlw7jbshr9l4";
+       revision = "1";
+       editedCabalFile = "0m57vdin9bkn9fbdlhhc9dl625asy39rv7vfzhg92q9sd50d5618";
        libraryHaskellDepends = [
          array base binary bytestring deepseq ghc-prim system-cxx-std-lib
          template-haskell
···
      }:
      mkDerivation {
        pname = "text-builder-dev";
-       version = "0.3.5";
-       sha256 = "1mg503a73jl5bpjp7npqadq1lj0sfc1krpqw1s4zybfn70n49vah";
+       version = "0.3.6";
+       sha256 = "0i49ki86i22w8pab46ljxw3br0l2d7wvilf9mxh9zhi6a2a4sarb";
        libraryHaskellDepends = [
          base bytestring deferred-folds isomorphism-class QuickCheck
          quickcheck-instances split text time transformers
···
        license = lib.licenses.mit;
      }) {};
 
+  "text-builder-dev_0_3_9" = callPackage
+    ({ mkDerivation, base, base-compat, bytestring, criterion
+     , deferred-folds, isomorphism-class, lawful-conversions, QuickCheck
+     , quickcheck-classes, quickcheck-instances, rerebase, split, tasty
+     , tasty-hunit, tasty-quickcheck, text, time, transformers
+     }:
+     mkDerivation {
+       pname = "text-builder-dev";
+       version = "0.3.9";
+       sha256 = "07jfgw3b797awbaw4a6dpnlkfqfkk983ja4sc5dmfwsnajyiy1wh";
+       libraryHaskellDepends = [
+         base bytestring deferred-folds isomorphism-class lawful-conversions
+         QuickCheck quickcheck-instances split text time transformers
+       ];
+       testHaskellDepends = [
+         base-compat lawful-conversions quickcheck-classes
+         quickcheck-instances rerebase tasty tasty-hunit tasty-quickcheck
+       ];
+       benchmarkHaskellDepends = [ criterion rerebase ];
+       description = "Edge of developments for \"text-builder\"";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "text-builder-linear" = callPackage
     ({ mkDerivation, base, bytestring, ghc-bignum, quote-quot, tasty
      , tasty-bench, tasty-quickcheck, text
···
      }) {};
 
   "text-misc-yj" = callPackage
-    ({ mkDerivation, base, mtl-misc-yj, text, try-text-misc-yj }:
+    ({ mkDerivation, base, mtl-misc-yj, text }:
      mkDerivation {
        pname = "text-misc-yj";
-       version = "0.1.0.1";
-       sha256 = "1i7mkdz8kpbzyhkzjija2bzr35jr3f51v3a849px65f5jfx2sazb";
+       version = "0.1.0.2";
+       sha256 = "02wnzkp9g2wdmpp5pwpyl56fm69ahv7miy8374j7pl6sp4i7g18i";
        libraryHaskellDepends = [ base mtl-misc-yj text ];
-       testHaskellDepends = [ base mtl-misc-yj text try-text-misc-yj ];
+       testHaskellDepends = [ base mtl-misc-yj text ];
        description = "tribial tools about text";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
-     }) {try-text-misc-yj = null;};
+     }) {};
 
   "text-normal" = callPackage
     ({ mkDerivation, base, deepseq, hspec, QuickCheck
···
        pname = "text-short";
        version = "0.1.6";
        sha256 = "1avfamw6sig6r5zpm2hbas373qbrdszi4q33gds9ihvxil9ylww1";
-       revision = "2";
-       editedCabalFile = "1r0bjj1h05bqf2g6plcq5sz5rzvq4s99xj1dmgnlfq0vqwadqlsr";
+       revision = "3";
+       editedCabalFile = "0fhnd5dd46pjja8rpawq8ld93ix31q9wa18bkfv6lr7nsg699gj1";
        libraryHaskellDepends = [
          base binary bytestring deepseq ghc-prim hashable template-haskell
          text
···
      }:
      mkDerivation {
        pname = "text-show-instances";
-       version = "3.9.9";
-       sha256 = "0ip2ym2v3rh5bi6mjfxpzrbvbrpqyi2ccaf4kfg5sy0k0yv3nrhm";
-       libraryHaskellDepends = [
-         aeson base base-compat bifunctors binary containers directory
-         ghc-boot-th haskeline hpc nonempty-vector old-locale old-time
-         pretty random scientific semigroups tagged template-haskell
-         terminfo text text-short text-show time transformers unix
-         unordered-containers uuid-types vector xhtml
-       ];
-       testHaskellDepends = [
-         aeson base base-compat bifunctors binary containers directory
-         generic-deriving ghc-boot-th ghc-prim haskeline hpc hspec
-         nonempty-vector old-locale old-time pretty QuickCheck
-         quickcheck-instances random scientific tagged template-haskell
-         terminfo text-short text-show th-orphans time transformers
-         transformers-compat unix unordered-containers uuid-types vector
-         xhtml
-       ];
-       testToolDepends = [ hspec-discover ];
-       description = "Additional instances for text-show";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "text-show-instances_3_9_10" = callPackage
-    ({ mkDerivation, aeson, base, base-compat, bifunctors, binary
-     , containers, directory, generic-deriving, ghc-boot-th, ghc-prim
-     , haskeline, hpc, hspec, hspec-discover, nonempty-vector
-     , old-locale, old-time, pretty, QuickCheck, quickcheck-instances
-     , random, scientific, semigroups, tagged, template-haskell
-     , terminfo, text, text-short, text-show, th-orphans, time
-     , transformers, transformers-compat, unix, unordered-containers
-     , uuid-types, vector, xhtml
-     }:
-     mkDerivation {
-       pname = "text-show-instances";
        version = "3.9.10";
        sha256 = "09cb391gi0hgkjk4ap4d83vg13lczrghmb9db96a4ckw1bp9pbc1";
        libraryHaskellDepends = [
···
        testToolDepends = [ hspec-discover ];
        description = "Additional instances for text-show";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "text-stream-decode" = callPackage
···
        license = lib.licenses.isc;
      }) {};
 
-  "th-abstraction_0_7_0_0" = callPackage
+  "th-abstraction_0_7_1_0" = callPackage
     ({ mkDerivation, base, containers, ghc-prim, template-haskell }:
      mkDerivation {
        pname = "th-abstraction";
-       version = "0.7.0.0";
-       sha256 = "0897na3f8nj59ax1gv0a46rrrz8i4ad0id6b3vxav91g5xhlr1dj";
+       version = "0.7.1.0";
+       sha256 = "1i843j7lhq6qly9zknrw3nhb17ac3badmxwn1pfn2sscp951idpr";
        libraryHaskellDepends = [
          base containers ghc-prim template-haskell
        ];
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "th-compat_0_1_6" = callPackage
+    ({ mkDerivation, base, hspec, hspec-discover, mtl, template-haskell
+     }:
+     mkDerivation {
+       pname = "th-compat";
+       version = "0.1.6";
+       sha256 = "1sx4l374vjw3clc7a3vk8kkq37kxzbv9h3nh0racjaw7b70a10dp";
+       libraryHaskellDepends = [ base template-haskell ];
+       testHaskellDepends = [ base hspec mtl template-haskell ];
+       testToolDepends = [ hspec-discover ];
+       description = "Backward- (and forward-)compatible Quote and Code types";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "th-constraint-compat" = callPackage
     ({ mkDerivation, base, containers, template-haskell }:
      mkDerivation {
···
        pname = "th-deepstrict";
        version = "0.1.1.0";
        sha256 = "0y0wlgzsm44sbwbchg4pqyb0s398aqjmd1awgd019bp29gzkd1hp";
-       revision = "1";
-       editedCabalFile = "0fip82wksknywr9wqmwsyf7847j5abhsqpbhbv8l9hlfhz6889d9";
+       revision = "2";
+       editedCabalFile = "1h4shx5kcyj3k0bngr2fbngl2l4dcyk8qffvbfm2qjlp4ymz6m0n";
        libraryHaskellDepends = [
          base containers mtl template-haskell th-abstraction th-orphans
        ];
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "th-desugar_1_17" = callPackage
+  "th-desugar_1_18" = callPackage
     ({ mkDerivation, base, containers, ghc-prim, hspec, HUnit, mtl
      , ordered-containers, syb, template-haskell, th-abstraction
-     , th-orphans, transformers-compat
+     , th-compat, th-orphans, transformers-compat
      }:
      mkDerivation {
        pname = "th-desugar";
-       version = "1.17";
-       sha256 = "0a00l9r7qyhl30bizrydcsjcraia2vq3r4jc7papab4mdv59z1wz";
+       version = "1.18";
+       sha256 = "0nq64z9nb2jbvs6pvnbafz33pymbgil2r783sl6fx2yjblqw3l3h";
        libraryHaskellDepends = [
          base containers ghc-prim mtl ordered-containers syb
-         template-haskell th-abstraction th-orphans transformers-compat
+         template-haskell th-abstraction th-compat th-orphans
+         transformers-compat
        ];
        testHaskellDepends = [
          base containers ghc-prim hspec HUnit mtl syb template-haskell
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "th-expand-syns_0_4_12_0" = callPackage
+    ({ mkDerivation, base, containers, syb, template-haskell
+     , th-abstraction
+     }:
+     mkDerivation {
+       pname = "th-expand-syns";
+       version = "0.4.12.0";
+       sha256 = "03zgqq0bwcjmy4d3m00gqzh4r1big2yh9v69rxvg72cw69krkq8q";
+       libraryHaskellDepends = [
+         base containers syb template-haskell th-abstraction
+       ];
+       testHaskellDepends = [ base template-haskell th-abstraction ];
+       description = "Expands type synonyms in Template Haskell ASTs";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "th-extras" = callPackage
     ({ mkDerivation, base, containers, syb, template-haskell
      , th-abstraction
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "th-lift_0_8_6" = callPackage
+    ({ mkDerivation, base, ghc-prim, template-haskell, th-abstraction
+     }:
+     mkDerivation {
+       pname = "th-lift";
+       version = "0.8.6";
+       sha256 = "07zgl42fq7ijmm29x7q10iv02hk6lqs7snysxdad03pq1vbrlc04";
+       libraryHaskellDepends = [
+         base ghc-prim template-haskell th-abstraction
+       ];
+       testHaskellDepends = [ base ghc-prim template-haskell ];
+       description = "Derive Template Haskell's Lift class for datatypes";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "th-lift-instances" = callPackage
     ({ mkDerivation, base, bytestring, containers, QuickCheck
      , template-haskell, text, th-lift, transformers, vector
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "th-orphans_0_13_16" = callPackage
+    ({ mkDerivation, base, bytestring, ghc-prim, hspec, hspec-discover
+     , mtl, template-haskell, th-compat, th-lift, th-reify-many
+     }:
+     mkDerivation {
+       pname = "th-orphans";
+       version = "0.13.16";
+       sha256 = "04x95fwsiczbi4gxadnnz6z39hy72hsj1smfaa52ljhwh8sh3479";
+       libraryHaskellDepends = [
+         base mtl template-haskell th-compat th-lift th-reify-many
+       ];
+       testHaskellDepends = [
+         base bytestring ghc-prim hspec template-haskell th-lift
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Orphan instances for TH datatypes";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "th-pprint" = callPackage
     ({ mkDerivation, base, lens, pretty, template-haskell }:
      mkDerivation {
···
        ];
        description = "Utility functions for testing Template Haskell code";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "th-test-utils_1_2_2" = callPackage
+    ({ mkDerivation, base, tasty, tasty-golden, tasty-hunit
+     , template-haskell, text, th-orphans, transformers
+     }:
+     mkDerivation {
+       pname = "th-test-utils";
+       version = "1.2.2";
+       sha256 = "1ihngf4g4q1c3hvzjax5ar437xm0h2yxiwnr518jm4mnsfkx3sss";
+       libraryHaskellDepends = [
+         base template-haskell th-orphans transformers
+       ];
+       testHaskellDepends = [
+         base tasty tasty-golden tasty-hunit template-haskell text
+         th-orphans transformers
+       ];
+       description = "Utility functions for testing Template Haskell code";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "th-to-exp" = callPackage
···
        pname = "threadscope";
        version = "0.2.14.1";
        sha256 = "0hfn90299mp18p2bjj2bgfi1pk3ndxz4nv2ac6z52kvh00sr9drq";
-       revision = "1";
-       editedCabalFile = "11qpwvsic884nx2v2g2fw7i6n9905rjpj6lp150insh6cs88kqfc";
+       revision = "3";
+       editedCabalFile = "1vrn7ccxh2r9sfg6qpvpd5rva442d1lhk3k3bs5d7cqj4dcpcg6x";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        broken = true;
      }) {};
 
+  "thyme_0_4_1" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, bytestring, containers
+     , cpphs, criterion, deepseq, hashable, mtl, old-locale, profunctors
+     , QuickCheck, random, template-haskell, text, time, vector
+     , vector-space, vector-th-unbox
+     }:
+     mkDerivation {
+       pname = "thyme";
+       version = "0.4.1";
+       sha256 = "1i3nrm516vcsnkqbd1fhv922xz66063fiv6lbw9y66wkqm9nds89";
+       libraryHaskellDepends = [
+         aeson attoparsec base bytestring containers deepseq hashable mtl
+         old-locale profunctors QuickCheck random template-haskell text time
+         vector vector-space vector-th-unbox
+       ];
+       libraryToolDepends = [ cpphs ];
+       testHaskellDepends = [
+         attoparsec base bytestring containers mtl old-locale profunctors
+         QuickCheck random text time vector-space
+       ];
+       benchmarkHaskellDepends = [
+         base criterion mtl old-locale profunctors QuickCheck random time
+         vector vector-space
+       ];
+       description = "A faster time library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "tianbar" = callPackage
     ({ mkDerivation, aeson, base, blaze-html, blaze-markup, bytestring
      , containers, dbus, directory, filepath, gi-gdk, gi-gio, gi-glib
···
        license = lib.licenses.mit;
      }) {};
 
-  "time-manager_0_1_1" = callPackage
-    ({ mkDerivation, auto-update, base }:
+  "time-manager_0_2_2" = callPackage
+    ({ mkDerivation, auto-update, base, containers, stm }:
      mkDerivation {
        pname = "time-manager";
-       version = "0.1.1";
-       sha256 = "0c623xpfd5zahs2d2v7hggd53c5p1h4pii6182by6d06w60496cq";
-       libraryHaskellDepends = [ auto-update base ];
+       version = "0.2.2";
+       sha256 = "1sm9rm2r45r535xc85xkzla6ym8rd84hs5aygpi1dr67z53d01fn";
+       libraryHaskellDepends = [ auto-update base containers stm ];
        description = "Scalable timer";
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
···
     ({ mkDerivation, base, brick, mtl, vty }:
      mkDerivation {
        pname = "tinyapp";
-       version = "0.2.0.0";
-       sha256 = "0phi8q1nsbjyrkzm2w0mxh1y5bl3byzdfdp1ib1qsslc5p3z20x5";
-       revision = "2";
-       editedCabalFile = "1sk4sp28mlh3cx9gjxslcdy3w78v64lil277il6sdf8y6h2bwsa3";
+       version = "0.2.1.0";
+       sha256 = "1rbr41wwyi2y8ybzz0fn8bbsqc5gnnvj5nchr6d2gjxylsn8c61d";
        libraryHaskellDepends = [ base brick mtl vty ];
        testHaskellDepends = [ base ];
        description = "Library to build tiny apps in Haskell";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "tinyfiledialogs" = callPackage
···
        pname = "tls";
        version = "2.0.6";
        sha256 = "07cznhk0jf2ffkpmq3q9iz9r4zcls8rkh32s3qqwaahp8lnvmsm3";
+       revision = "1";
+       editedCabalFile = "1qklaagllqncdfa31k35iaasaxsq1378cpp8p5hg8h920rrv4z9q";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "tls_2_1_4" = callPackage
+  "tls_2_1_5" = callPackage
     ({ mkDerivation, asn1-encoding, asn1-types, async, base
      , base16-bytestring, bytestring, cereal, crypton, crypton-x509
      , crypton-x509-store, crypton-x509-validation, data-default
···
      }:
      mkDerivation {
        pname = "tls";
-       version = "2.1.4";
-       sha256 = "1bs3xjy9nza7yd7yrhzf10zqrg7krd6z87fqcbb2qcz4b34rc8x9";
+       version = "2.1.5";
+       sha256 = "008q5381wgymavl0svf02sv1vprkz7v8zr0cnglqla6823z7dnx1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         asn1-encoding asn1-types async base base16-bytestring bytestring
-         cereal crypton crypton-x509 crypton-x509-store
-         crypton-x509-validation data-default memory mtl network serialise
-         transformers unix-time
+         asn1-encoding asn1-types base base16-bytestring bytestring cereal
+         crypton crypton-x509 crypton-x509-store crypton-x509-validation
+         data-default memory mtl network serialise transformers unix-time
        ];
        testHaskellDepends = [
          asn1-types async base bytestring crypton crypton-x509
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "tmp-proc_0_7_2_0" = callPackage
+  "tmp-proc_0_7_2_1" = callPackage
     ({ mkDerivation, async, base, bytestring, crypton-connection
      , crypton-x509-system, data-default, directory, filepath, fmt
      , hspec, http-client, http-client-tls, http-types, mtl, mustache
···
      }:
      mkDerivation {
        pname = "tmp-proc";
-       version = "0.7.2.0";
-       sha256 = "0yyjxm5d2qyhrfjvh7zq8300fqmlykjx1xn91r0kca1j4hy9i785";
+       version = "0.7.2.1";
+       sha256 = "072jwd36dp9a7sy4kzibc30jcfgib8qvfkw5fn57azkb7awkg6aq";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        pname = "toml-parser";
        version = "2.0.1.0";
        sha256 = "1qcpcrcalds3a2gdx83iynpj3hvkg6hbyza8al0f7jdsg9r6sdh3";
+       revision = "1";
+       editedCabalFile = "1m3i2zbaavcyikp6dqqvyrvc1706zzsaqzg5z1bix916gscfkdhk";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "tomland";
        version = "1.3.3.3";
        sha256 = "1asnz773mrbg8fkfabq5w24v63sgqljspc4p4nmf4dm6abm2p6d0";
+       revision = "2";
+       editedCabalFile = "070x95r3silsswl74b5jpsy3s8644mcjqihq3b334jlvvqql5ypw";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "tools-yj";
-       version = "0.1.0.19";
-       sha256 = "0zm1alj3a95mbgxmc41c6y35az75fsfc2q0g6f17rn7zbwhmk18v";
+       version = "0.1.0.20";
+       sha256 = "0kazb0gzr21hdiqv3avlw5c2i3ikf0pzy6ybsi7qhj2hxv1kz9zi";
        libraryHaskellDepends = [
          base containers data-default mono-traversable stm text
        ];
···
      }) {};
 
   "toxcore-c" = callPackage
-    ({ mkDerivation, base, base16-bytestring, bytestring
-     , bytestring-arbitrary, data-default-class, directory, hspec
-     , QuickCheck, saltine, toxcore
+    ({ mkDerivation, base, base16-bytestring, bytestring, cryptohash
+     , directory, generic-arbitrary, hspec, msgpack-binary, QuickCheck
+     , quickcheck-instances, saltine, text, toxcore, vector
      }:
      mkDerivation {
        pname = "toxcore-c";
-       version = "0.2.11";
-       sha256 = "1fgz30y867lw9d6pmssi75k1prlfgrlpfa9qzqkm52mra2r5d2mb";
+       version = "0.2.19";
+       sha256 = "0pcs7ikmc6pdamhj5yg9sa4lizs177vjp2ayjf51jrhsd4zinrfd";
        isLibrary = true;
        isExecutable = true;
-       libraryHaskellDepends = [ base bytestring data-default-class ];
+       libraryHaskellDepends = [
+         base bytestring generic-arbitrary msgpack-binary QuickCheck
+         quickcheck-instances
+       ];
        librarySystemDepends = [ toxcore ];
        executableHaskellDepends = [
-         base base16-bytestring bytestring directory
+         base base16-bytestring bytestring directory text
        ];
        executableSystemDepends = [ toxcore ];
        testHaskellDepends = [
-         base base16-bytestring bytestring bytestring-arbitrary
-         data-default-class hspec QuickCheck saltine
+         base base16-bytestring bytestring cryptohash hspec msgpack-binary
+         QuickCheck saltine vector
        ];
        description = "Haskell bindings to the C reference implementation of Tox";
        license = lib.licenses.gpl3Only;
···
        license = lib.licenses.gpl2Plus;
      }) {};
 
-  "tree-diff_0_3_2" = callPackage
+  "tree-diff_0_3_3" = callPackage
     ({ mkDerivation, aeson, ansi-terminal, ansi-wl-pprint, base
      , bytestring, containers, criterion, deepseq, Diff, hashable
      , parsec, parsers, pretty, primitive, QuickCheck, scientific
···
      }:
      mkDerivation {
        pname = "tree-diff";
-       version = "0.3.2";
-       sha256 = "067lf9fw0lk9pay6di6scc00sfg9p0n2avxs0wsqlyin9xc9h18v";
+       version = "0.3.3";
+       sha256 = "1wmcwwhpxprmfi4d0rn4wykx79nh34p4sqkyvrsx0vn38m9g8i3y";
        libraryHaskellDepends = [
          aeson ansi-terminal ansi-wl-pprint base bytestring containers
          deepseq hashable parsec parsers pretty primitive QuickCheck
···
        pname = "trial";
        version = "0.0.0.0";
        sha256 = "0lnq80983bg2cjim3fy8rwisn55f6acqwp67w7791kzfdwshxkww";
-       revision = "4";
-       editedCabalFile = "08sdqn830rfpsd5czm11899lgzs2bvyiq8zhkqaaj10by4ms5vza";
+       revision = "5";
+       editedCabalFile = "1bsgash3gjvqybfl0n77gw5l1xhidjpm253n4v5dfk7qls6nplm1";
        libraryHaskellDepends = [ base colourista dlist ];
        testHaskellDepends = [
          base dlist doctest hedgehog hspec hspec-hedgehog splitmix
···
        pname = "trial-optparse-applicative";
        version = "0.0.0.0";
        sha256 = "1h8pfznf1dp9z3r2kl2ljgmxxkfp3va9yqba00fyvw85lna2aggn";
-       revision = "3";
-       editedCabalFile = "01kcmcizi6jahxxj2kcmwgkg59fwihbqxnxqa8x64fqs6vqpd8rw";
+       revision = "4";
+       editedCabalFile = "05rzzcsqvhil7wbsz23syd35h9jqbmmabx89v3h86ng7my3w1nc1";
        libraryHaskellDepends = [ base optparse-applicative trial ];
        description = "Trial helper functions for optparse-applicative";
        license = lib.licenses.mpl20;
···
        pname = "trial-tomland";
        version = "0.0.0.0";
        sha256 = "12klfq5ajn4bjrws633pfdc2zhpkwvwmrm7269xfh252fjwk1x23";
-       revision = "4";
-       editedCabalFile = "1zbp0njb82gmslaki2wb7vm1q33sxdv6ac8f2xjlbj1x03a2phsx";
+       revision = "5";
+       editedCabalFile = "1x43dsjqzs1sqfqljwjd96p3p0gcy8gzbafbvvsyi8vrbj6vphpv";
        libraryHaskellDepends = [ base text tomland trial ];
        description = "Trial helper functions for tomland";
        license = lib.licenses.mpl20;
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "trie-simple_0_4_3" = callPackage
+    ({ mkDerivation, base, containers, deepseq, hashable, hspec
+     , hspec-discover, indexed-traversable, matchable, mtl, mwc-random
+     , QuickCheck, semialign, tasty-bench, these, vector, witherable
+     }:
+     mkDerivation {
+       pname = "trie-simple";
+       version = "0.4.3";
+       sha256 = "1hbcwp1aahmnqxyzv6c2l3k1ifnzssjz66mw1gp2a63z12z4gwyg";
+       libraryHaskellDepends = [
+         base containers deepseq hashable indexed-traversable matchable mtl
+         semialign these witherable
+       ];
+       testHaskellDepends = [ base containers hspec QuickCheck vector ];
+       testToolDepends = [ hspec-discover ];
+       benchmarkHaskellDepends = [
+         base containers deepseq mwc-random tasty-bench vector
+       ];
+       description = "Simple Map-based Trie";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "tries" = callPackage
     ({ mkDerivation, base, bytestring, composition, containers
      , criterion, deepseq, hashable, keys, mtl, QuickCheck
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "typecheck-plugin-nat-simple_0_1_0_11" = callPackage
+    ({ mkDerivation, base, containers, ghc, ghc-internal
+     , ghc-tcplugins-extra
+     }:
+     mkDerivation {
+       pname = "typecheck-plugin-nat-simple";
+       version = "0.1.0.11";
+       sha256 = "0rb4cxib6i7byn7syym252gvrw7mgrfjglqwsiwprc7mx254k42i";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         base containers ghc ghc-internal ghc-tcplugins-extra
+       ];
+       testHaskellDepends = [
+         base containers ghc ghc-internal ghc-tcplugins-extra
+       ];
+       description = "Simple type check plugin which calculate addition, subtraction and less-or-equal-than";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "typed-admin" = callPackage
     ({ mkDerivation, base, blaze-markup, bytestring, data-default-class
      , exceptions, generic-lens, HDBC, HDBC-postgresql, HDBC-session
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "typst_0_6" = callPackage
+  "typst_0_6_1" = callPackage
     ({ mkDerivation, aeson, array, base, bytestring, cassava
      , containers, directory, filepath, mtl, ordered-containers, parsec
      , pretty, pretty-show, regex-tdfa, scientific, tasty, tasty-golden
···
      }:
      mkDerivation {
        pname = "typst";
-       version = "0.6";
-       sha256 = "092pdx7qkrvxb0gz316aylgayzlkc3scw8dj5jkf4riq8gc3h7x1";
+       version = "0.6.1";
+       sha256 = "1vcg5lvqxsxf5q1jg8c5g2fcmalfah92fqv6rzr8b5m1ipai2c10";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "tz";
        version = "0.1.3.6";
        sha256 = "1vqnfk656i6j3j1bf9lc36adziv52x1b2ccq6afp8cka1nay2mcd";
-       revision = "7";
-       editedCabalFile = "0awsb34hf2r6j0qkl0b087hdwcig33cmnfjwrl5w3mj35ligffja";
+       revision = "8";
+       editedCabalFile = "04icpw2qpsrfyh71rmnxavkk3xhlbrdgp7qxawcac2brx9g6bglz";
        libraryHaskellDepends = [
          base binary bytestring containers data-default deepseq
          template-haskell time tzdata vector
···
        ];
        description = "Unification based on unbound-generics";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "unbound-kind-generics" = callPackage
···
      }) {};
 
   "unification-fd" = callPackage
-    ({ mkDerivation, base, containers, logict, mtl }:
+    ({ mkDerivation, base, containers, data-fix, logict, mtl }:
      mkDerivation {
        pname = "unification-fd";
-       version = "0.11.2.2";
-       sha256 = "0jgy507dy1j566j46gndd8b2543n847myibg2i22yw8chdpl15kc";
-       libraryHaskellDepends = [ base containers logict mtl ];
+       version = "0.12.0.1";
+       sha256 = "027v1mcwj0i2md5nrhdqfcad5hlj5a14wml0jzl596lqq1hz95qs";
+       libraryHaskellDepends = [ base containers data-fix logict mtl ];
        description = "Simple generic unification algorithms";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
···
        license = lib.licenses.gpl2Only;
      }) {};
 
+  "unimap" = callPackage
+    ({ mkDerivation, base, int-like, mtl, optics, prop-unit }:
+     mkDerivation {
+       pname = "unimap";
+       version = "0.1.0";
+       sha256 = "0akxl879q1jab3ammm2f9ykcl9sn0fvh2nzryfdp93pip107sbpi";
+       libraryHaskellDepends = [ base int-like mtl optics ];
+       testHaskellDepends = [ base int-like mtl optics prop-unit ];
+       description = "A union-find/map data structure";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "union" = callPackage
     ({ mkDerivation, base, criterion, deepseq, hashable, lens
      , profunctors, tagged, vinyl
···
        license = lib.licenses.mit;
      }) {};
 
-  "unix_2_8_5_1" = callPackage
+  "unix_2_8_6_0" = callPackage
     ({ mkDerivation, base, bytestring, filepath, tasty, tasty-hunit
      , tasty-quickcheck, time
      }:
      mkDerivation {
        pname = "unix";
-       version = "2.8.5.1";
-       sha256 = "0974ajqri7was72gnsgxa8zc4gq649zclaad1gw9pszjmr3c7djs";
+       version = "2.8.6.0";
+       sha256 = "18pf0nsqzj4ciwrwbynx7r47aapgbb4gn2kiar31vap4nfdmj5w1";
+       revision = "1";
+       editedCabalFile = "0ca08c8wsz4hfq7ajzaba45mxp9wak3x6vv37j63r747gbyqlzsv";
        libraryHaskellDepends = [ base bytestring filepath time ];
        testHaskellDepends = [
          base bytestring filepath tasty tasty-hunit tasty-quickcheck
···
        pname = "unordered-containers";
        version = "0.2.20";
        sha256 = "07gij1y9zhqg2dq8wy815j7s0zk2k65sqg4wvhwjsn80ry3v5kyr";
-       revision = "3";
-       editedCabalFile = "1g0sn6vn9p8cp9q5x5x7zf6qdf9y7gfpm76q29g91nay82x9rzn7";
+       revision = "4";
+       editedCabalFile = "08p4xp43mlqyl8ayh7k22p0q0kxlby9y071rpcr8jsf2lvfvqg13";
        libraryHaskellDepends = [ base deepseq hashable template-haskell ];
        testHaskellDepends = [
          base ChasingBottoms containers hashable HUnit nothunks QuickCheck
···
      }:
      mkDerivation {
        pname = "utxorpc";
-       version = "0.0.11.0";
-       sha256 = "1bnkhm21g67x1jr7lwybg5yj5n34jlhkf5j2fqzczdfggv4z6vnq";
+       version = "0.0.14.0";
+       sha256 = "0101dfb4f33l4qaa84s40lhlyfpmgsqb1v23j3x8kkf05md8bha8";
        libraryHaskellDepends = [
          base proto-lens proto-lens-protobuf-types proto-lens-runtime
        ];
···
     ({ mkDerivation, base, uu-tc-error-error }:
      mkDerivation {
        pname = "uu-tc-error";
-       version = "0.3.0.0";
-       sha256 = "0iaqpnlxlckf40asdj8y1b3sxixlc2sf9qkrpaqmfqqjy8gghcd5";
+       version = "0.4.0.1";
+       sha256 = "0857pjdpqgv645dhpq7s4wvr209jghb91vja4kiikqwyjcm3vjyl";
        libraryHaskellDepends = [ base uu-tc-error-error ];
        description = "Haskell 98 parser combintors for INFOB3TC at Utrecht University";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "uu-tc-error-error";
-       version = "0.2.0.0";
-       sha256 = "1hwpkl54s7qrz15as266izcgicp92afz0vnwbd67ichj7vvwv4q0";
+       version = "0.3.0.0";
+       sha256 = "1dsr5lpvzyn7vzdx4fh2gvm2345y3f2yzqv4drigg20fivrn762v";
        libraryHaskellDepends = [
          base bytestring containers deepseq mtl text
        ];
···
        pname = "validation-selective";
        version = "0.2.0.0";
        sha256 = "11s9qsp5w19lbk6vg6psr3864xdsx2kmx3gcmnn2qkx6wsblx24s";
-       revision = "4";
-       editedCabalFile = "01q9py4gs3hq1dbiny0irfpirdl1b08nydd56za1nfqf24d7z16c";
+       revision = "5";
+       editedCabalFile = "05lksfm5micvk2s6isscjf6ipkwd79698cczlr0ipgn8wmm87drz";
        libraryHaskellDepends = [ base deepseq selective ];
        testHaskellDepends = [
          base doctest hedgehog hspec hspec-hedgehog selective text
···
        pname = "vault";
        version = "0.3.1.5";
        sha256 = "181ksk1yixjg0jiggw5jvm8am8m8c7lim4xaixf8qnaqvxm6namc";
-       revision = "8";
-       editedCabalFile = "0nabd5r1j6aq5ys3lsjh4i2ii9rza7923b5mg3vfbkj72w3dvgqv";
+       revision = "9";
+       editedCabalFile = "161akchka1ah1lhrzc0vm2f7ym0x2550scb4w2c0gl3y38n1c4jl";
        libraryHaskellDepends = [
          base containers hashable unordered-containers
        ];
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "vector-algorithms_0_9_0_3" = callPackage
+    ({ mkDerivation, base, bitvec, bytestring, containers, mwc-random
+     , primitive, QuickCheck, vector
+     }:
+     mkDerivation {
+       pname = "vector-algorithms";
+       version = "0.9.0.3";
+       sha256 = "17jd2kbz9frwcryp7zcjgwnh5vdajw9jmcqn17fq39f6ixwhp431";
+       libraryHaskellDepends = [
+         base bitvec bytestring primitive vector
+       ];
+       testHaskellDepends = [
+         base bytestring containers QuickCheck vector
+       ];
+       benchmarkHaskellDepends = [ base mwc-random vector ];
+       description = "Efficient algorithms for vector arrays";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "vector-binary" = callPackage
     ({ mkDerivation, base, binary, vector }:
      mkDerivation {
···
        pname = "vector-fftw";
        version = "0.1.4.0";
        sha256 = "1ns5jhdx585s3jmcslscibf7ryaya3ca1shc4ysrikrp1mzx1jky";
+       revision = "1";
+       editedCabalFile = "0ncf80jfpm8g3rgdddfqxnhmdzj1qlvczzy24na129c282yp089m";
        libraryHaskellDepends = [ base primitive storable-complex vector ];
        librarySystemDepends = [ fftw ];
        testHaskellDepends = [
···
      }) {};
 
   "vector-quicksort" = callPackage
-    ({ mkDerivation, atomic-counter, base, bytestring, containers
-     , deepseq, parallel, primitive, QuickCheck, random, stm
-     , system-cxx-std-lib, tasty, tasty-bench, tasty-quickcheck, text
-     , text-builder-linear, vector, vector-algorithms
+    ({ mkDerivation, base, bytestring, containers, deepseq, primitive
+     , QuickCheck, random, stm, system-cxx-std-lib, tasty, tasty-bench
+     , tasty-hunit, tasty-quickcheck, text, text-builder-linear, vector
+     , vector-algorithms
      }:
      mkDerivation {
        pname = "vector-quicksort";
-       version = "0.1";
-       sha256 = "1s8azyaa73zys31whi2m6l0mnyy8hdw8hzsdpd5h0j3d78ywykkf";
-       revision = "1";
-       editedCabalFile = "18h7lflrp2d80cjzdqwjykpl95b3ng9bcrb9gq5qnab652fgyr8j";
+       version = "0.2";
+       sha256 = "0cwydxijpm2s26q6g9h7mc5sm4pfqh5sagrvbvm6yiw264y810xb";
        libraryHaskellDepends = [
-         base parallel primitive stm system-cxx-std-lib vector
+         base primitive stm system-cxx-std-lib vector
        ];
        testHaskellDepends = [
          base containers QuickCheck tasty tasty-quickcheck vector
        ];
        benchmarkHaskellDepends = [
-         atomic-counter base bytestring deepseq primitive random stm tasty
-         tasty-bench text text-builder-linear vector vector-algorithms
+         base bytestring deepseq random stm tasty tasty-bench tasty-hunit
+         text text-builder-linear vector vector-algorithms
        ];
        doHaddock = false;
        description = "Fast and flexible quicksort implementation for mutable vectors";
···
        pname = "vector-stream";
        version = "0.1.0.1";
        sha256 = "0z5z88flyassdpgga412qci6brr9gyljbx875wd479fy9crhgxfh";
-       revision = "2";
-       editedCabalFile = "0lcsvwlpipdiafw7w6lf2mqfg5b8fmh2jrrs3s6j7hsjm09vs3id";
+       revision = "3";
+       editedCabalFile = "07k5zgxbfbcf9anzfd9c0lzaa79iypdk303dq5yswi9a46andjas";
        libraryHaskellDepends = [ base ghc-prim ];
        description = "Efficient Streams";
        license = lib.licenses.bsd3;
···
        pname = "vector-th-unbox";
        version = "0.2.2";
        sha256 = "0j81m09xxv24zziv0nanfppckzmas5184jr3npjhc9w49r3cm94a";
-       revision = "6";
-       editedCabalFile = "1pdl1xvr1b4zg32b9d8jv4jakjnd5id5wdj2czgzajr6xlkvyhir";
+       revision = "8";
+       editedCabalFile = "1dzn47l5hqs541gjfq09r10rrqxw0wsj727kxkv334lw926npljh";
        libraryHaskellDepends = [ base template-haskell vector ];
        testHaskellDepends = [ base data-default vector ];
        description = "Deriver for Data.Vector.Unboxed using Template Haskell";
···
        maintainers = [ lib.maintainers.alexfmpe ];
      }) {};
 
-  "warp_3_4_4" = callPackage
+  "warp_3_4_7" = callPackage
     ({ mkDerivation, array, async, auto-update, base, bsb-http-chunked
      , bytestring, case-insensitive, containers, criterion, crypton-x509
      , directory, ghc-prim, hashable, hspec, hspec-discover, http-client
···
      }:
      mkDerivation {
        pname = "warp";
-       version = "3.4.4";
-       sha256 = "1a842yn4lq9kszcj6pnfjrdd2kfbdx8zzsn8jrv0l9s1bfz3cwmv";
+       version = "3.4.7";
+       sha256 = "1s0kynqliqwn79gydrdxsgfdw6qffs5fmvhmxiydc379fxf07k7s";
        libraryHaskellDepends = [
          array async auto-update base bsb-http-chunked bytestring
          case-insensitive containers crypton-x509 ghc-prim hashable
···
      }) {};
 
   "warp-tls" = callPackage
-    ({ mkDerivation, base, bytestring, data-default-class, network
-     , recv, streaming-commons, tls, tls-session-manager, unliftio, wai
-     , warp
+    ({ mkDerivation, base, bytestring, data-default, network, recv
+     , streaming-commons, tls, tls-session-manager, unliftio, wai, warp
      }:
      mkDerivation {
        pname = "warp-tls";
-       version = "3.4.7";
-       sha256 = "0lc8abjqs7j52qnfsaljjngxxzxja6d3bk4q796ahcikk10id1cf";
+       version = "3.4.9";
+       sha256 = "01dpnc77sf7fkksvpi1rhfwk1h9lz5jjarzxjvy0y1yl8gn69vgf";
        libraryHaskellDepends = [
-         base bytestring data-default-class network recv streaming-commons
-         tls tls-session-manager unliftio wai warp
+         base bytestring data-default network recv streaming-commons tls
+         tls-session-manager unliftio wai warp
        ];
        description = "HTTP over TLS support for Warp via the TLS package";
        license = lib.licenses.mit;
      }) {};
 
-  "warp-tls_3_4_11" = callPackage
+  "warp-tls_3_4_12" = callPackage
     ({ mkDerivation, base, bytestring, network, recv, streaming-commons
      , tls, tls-session-manager, wai, warp
      }:
      mkDerivation {
        pname = "warp-tls";
-       version = "3.4.11";
-       sha256 = "1sld1xxhya85gg7gz1nznpi98rh5jwp4w0d64qcqw0dsjswhmpr3";
+       version = "3.4.12";
+       sha256 = "09gx0fr5imvn7hcx55d2cgmia1di28mx8ckdvz487x0l7wkgbaqd";
        libraryHaskellDepends = [
          base bytestring network recv streaming-commons tls
          tls-session-manager wai warp
···
        ];
        description = "Declarative CAD/Solid Modeling Library";
        license = lib.licenses.lgpl21Only;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "waterfall-cad-examples" = callPackage
···
        ];
        description = "Examples for Waterfall CAD, a Declarative CAD/Solid Modeling Library";
        license = lib.licenses.lgpl21Only;
-       hydraPlatforms = lib.platforms.none;
        mainProgram = "waterfall-cad-examples";
      }) {};
 
···
      }:
      mkDerivation {
        pname = "web-rep";
-       version = "0.12.3.0";
-       sha256 = "10k2fm7g1p54v6gnn045vgc8p58xal17vxin9ah11xqr0dddk7sa";
+       version = "0.13.0.0";
+       sha256 = "04w49x4mknbsc86xq62amyfk3696cv906grhm98yyyg4gkpd7qx2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "web-view" = callPackage
-    ({ mkDerivation, base, bytestring, casing, containers
-     , effectful-core, file-embed, html-entities, http-types
-     , string-interpolate, sydtest, sydtest-discover, text
+    ({ mkDerivation, base, bytestring, casing, containers, Diff
+     , effectful-core, file-embed, html-entities, http-types, skeletest
+     , string-interpolate, text
      }:
      mkDerivation {
        pname = "web-view";
-       version = "0.5.0";
-       sha256 = "007iz283s31n9dhxvw1sz7nh5fn9h4hifc6wkcnm6zwzyr5mknl7";
+       version = "0.6.1";
+       sha256 = "08zqii0b566lrj8nn1cdndcdhppqb1gn5n0lgbv9vlj9b3glzyhc";
        libraryHaskellDepends = [
          base bytestring casing containers effectful-core file-embed
          html-entities http-types string-interpolate text
        ];
        testHaskellDepends = [
-         base bytestring casing containers effectful-core file-embed
-         html-entities http-types string-interpolate sydtest text
+         base bytestring casing containers Diff effectful-core file-embed
+         html-entities http-types skeletest string-interpolate text
        ];
-       testToolDepends = [ sydtest-discover ];
        description = "Type-safe HTML and CSS with intuitive layouts and composable styles";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
···
 
   "webdriver" = callPackage
     ({ mkDerivation, aeson, attoparsec, attoparsec-aeson, base
-     , base64-bytestring, bytestring, call-stack, data-default-class
+     , base64-bytestring, bytestring, call-stack, data-default
      , directory, directory-tree, exceptions, filepath, http-client
      , http-types, lifted-base, monad-control, network, network-uri
      , scientific, temporary, text, time, transformers
···
      }:
      mkDerivation {
        pname = "webdriver";
-       version = "0.12.0.0";
-       sha256 = "1z54i2ddcnrrfwgyy8bb3jqb279ssmwkyx69nc2zml0195ss5254";
+       version = "0.12.0.1";
+       sha256 = "17m4dmf1ljqpqnx2mcg92pil3i6679i3rc47x7b9gc6j36bww4l1";
        libraryHaskellDepends = [
          aeson attoparsec attoparsec-aeson base base64-bytestring bytestring
-         call-stack data-default-class directory directory-tree exceptions
+         call-stack data-default directory directory-tree exceptions
          filepath http-client http-types lifted-base monad-control network
          network-uri scientific temporary text time transformers
          transformers-base unordered-containers vector zip-archive
···
      }:
      mkDerivation {
        pname = "webgear-core";
-       version = "1.3.0";
-       sha256 = "1d16dvb76rjnpbapzp2m8g04wijyh6xzi8pcf03ymbll78x438w6";
-       revision = "1";
-       editedCabalFile = "03wsg7mxqjhzpav4g0nmdkc17dclfi2rgx6lyykhsfzr54b7mznk";
+       version = "1.3.1";
+       sha256 = "1svspzqxqappvmbsvj1cvvvh7dbgsxww43xc93ny19x6qwmksgr5";
        libraryHaskellDepends = [
          arrows base binary bytestring case-insensitive cookie http-api-data
          http-media http-types jose network tagged template-haskell text wai
···
      }:
      mkDerivation {
        pname = "webgear-openapi";
-       version = "1.3.0";
-       sha256 = "1278dkhrckz9m8qjmqjfc2bxgnq4wsmrnyjkf24ci5lvxvrz3y9f";
-       revision = "1";
-       editedCabalFile = "1p2zw502ggs5h2adxlb3ki8zphh9xs2vfp7ijdp1v545xl8q4740";
+       version = "1.3.1";
+       sha256 = "1aky9zdc040njndjch2l7xj8gb13ygnv0zgm2jc307lswnbh98vb";
        libraryHaskellDepends = [
          arrows base http-media http-types insert-ordered-containers lens
          mtl openapi3 text webgear-core
···
      }:
      mkDerivation {
        pname = "webgear-server";
-       version = "1.3.0";
-       sha256 = "1s3iwzkb29g2zlkszarm27mlcwbszjwmmdzrb5ciqgz3l8pijyrx";
-       revision = "1";
-       editedCabalFile = "1g73hm9nmhv2432wdyg6j2kfxdk3dwwri4w7n98q3yx1f2pypv0g";
+       version = "1.3.1";
+       sha256 = "053ddbkjx9vshzrbyys7kjv92s97z0kjh586xgz5ix3zxpy6wyda";
        libraryHaskellDepends = [
          aeson arrows base base64-bytestring binary bytestring cookie
          http-api-data http-media http-types jose monad-time mtl resourcet
···
      }:
      mkDerivation {
        pname = "webgear-swagger";
-       version = "1.3.0";
-       sha256 = "1p10wn5jgfyqcysa14sx6lmirc4irl1nls5mblav50yr9a5ilipc";
-       revision = "1";
-       editedCabalFile = "0svdzcxr3w3k48ipamzzgywrsbi21vdqi1yjbnlnmn6nwknkw0wq";
+       version = "1.3.1";
+       sha256 = "04z58rsn40zp19rr7b3bfp13n1yp4j2d5fjvm3msv7ik6pqgdkqq";
        libraryHaskellDepends = [
          arrows base http-types insert-ordered-containers lens mtl swagger2
          text webgear-core
···
      }:
      mkDerivation {
        pname = "webgear-swagger-ui";
-       version = "1.3.0";
-       sha256 = "1vz7ycl2kppiwqp23z2dg6binc3azb8p5r17hir00zr4i8jhl88m";
+       version = "1.3.1";
+       sha256 = "07rc7wjjmgirwmbbi66gzbvbb194c2rb5ab2sw9kf3ppsl9xwqg0";
        libraryHaskellDepends = [
          base bytestring file-embed http-types text wai-app-static
          webgear-core
···
        pname = "websockets";
        version = "0.13.0.0";
        sha256 = "1da95b71akggyikbxdmja3gcaqrz8sp6ri5jrsyavc2ickvi9y4s";
-       revision = "3";
-       editedCabalFile = "00mw56z595lgmm0q5pvvr8l14gymsism13m0zm59pxmzk62qvp49";
+       revision = "4";
+       editedCabalFile = "1g6f94cn20a4073cbinv2sfwglbqlpjxgzgj7svi6ff4vkfn0ins";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "wide-word";
        version = "0.1.6.0";
        sha256 = "15wp0mdjbaacvzwkjlmdr7w6bm239g5v3ylkczwr3cfj30da0snz";
-       revision = "3";
-       editedCabalFile = "01vy3civ7vzninmn6xdadfd9xfwn6hv002prpm9fb5i68qgbp8dr";
+       revision = "4";
+       editedCabalFile = "1nb1pcfm7kh59aqfj5344w0a96kjvc3zjww3702ff5gpxwabci8x";
        libraryHaskellDepends = [
          base binary deepseq ghc-prim hashable primitive
        ];
···
      }) {};
 
   "wikimusic-api" = callPackage
-    ({ mkDerivation, aeson, async, base, base64-bytestring, bytestring
-     , containers, contravariant-extras, directory, filepath
-     , free-alacarte, hasql, hasql-implicits, hasql-migration
-     , hasql-optparse-applicative, hasql-pool, hasql-transaction, hedis
-     , HTTP, keuringsdienst, keys, mime-mail, mtl, neat-interpolation
-     , openapi3, optics, optparse-applicative, password, password-types
-     , postgresql-libpq, relude, servant, servant-openapi3
-     , servant-rate-limit, servant-server, smtp-mail, tasty, tasty-hunit
-     , text, time, tomland, uuid, vector, wai, wai-cors, wai-extra
-     , wai-rate-limit, wai-rate-limit-redis, warp, wikimusic-api-spec
-     , wikimusic-model-hs
+    ({ mkDerivation, aeson, async, base, base64-bytestring, beam-core
+     , beam-sqlite, bytestring, containers, contravariant-extras
+     , directory, filepath, free-alacarte, hspec, HTTP, http-client
+     , http-types, keuringsdienst, keys, mime-mail, mtl
+     , neat-interpolation, openapi3, optics, optparse-applicative
+     , password, password-types, prometheus-client
+     , prometheus-metrics-ghc, QuickCheck, random, relude, servant
+     , servant-openapi3, servant-server, smtp-mail, sqlite-simple, tasty
+     , tasty-hspec, text, time, tomland, uuid, wai, wai-cors, wai-extra
+     , wai-logger, wai-middleware-prometheus, warp, wikimusic-api-spec
+     , wikimusic-model-hs, word8, yggdrasil-schema
      }:
      mkDerivation {
        pname = "wikimusic-api";
-       version = "1.1.0.1";
-       sha256 = "11axz65b4zswca53q0scywl6qnbm6qpfy6dhzgi7n8s0d0518js5";
+       version = "1.2.0.8";
+       sha256 = "1xccl4d0c5p4rsv659hz23aaarzkjhx16jigz9nf2zjk6qs2g0lc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         aeson async base base64-bytestring bytestring containers
-         contravariant-extras directory filepath free-alacarte hasql
-         hasql-implicits hasql-migration hasql-optparse-applicative
-         hasql-pool hasql-transaction hedis HTTP keuringsdienst keys
-         mime-mail mtl neat-interpolation openapi3 optics
-         optparse-applicative password password-types postgresql-libpq
-         relude servant servant-openapi3 servant-rate-limit servant-server
-         smtp-mail text time tomland uuid vector wai wai-cors wai-extra
-         wai-rate-limit wai-rate-limit-redis warp wikimusic-api-spec
-         wikimusic-model-hs
+         aeson async base base64-bytestring beam-core beam-sqlite bytestring
+         containers contravariant-extras directory filepath free-alacarte
+         HTTP keuringsdienst keys mime-mail mtl neat-interpolation openapi3
+         optics optparse-applicative password password-types
+         prometheus-client prometheus-metrics-ghc relude servant
+         servant-openapi3 servant-server smtp-mail sqlite-simple text time
+         tomland uuid wai wai-cors wai-extra wai-logger
+         wai-middleware-prometheus warp wikimusic-api-spec
+         wikimusic-model-hs word8 yggdrasil-schema
        ];
        executableHaskellDepends = [ base ];
-       testHaskellDepends = [ base tasty tasty-hunit ];
+       testHaskellDepends = [
+         base beam-core beam-sqlite containers directory hspec http-client
+         http-types keuringsdienst neat-interpolation optics password
+         password-types QuickCheck random relude sqlite-simple tasty
+         tasty-hspec text time uuid wai wai-logger wikimusic-api-spec
+         wikimusic-model-hs yggdrasil-schema
+       ];
        license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        mainProgram = "wikimusic-api-exe";
···
      }:
      mkDerivation {
        pname = "wikimusic-api-spec";
-       version = "1.2.1.2";
-       sha256 = "12b44xwav5m4vkm8lvsza7p50dg05x9d062xcgswp14p9myb4g6i";
+       version = "1.2.1.3";
+       sha256 = "1636br87msqk7yc1pdi57s30h2xs9v7xrmlqq7alv4zx2hqqvv0c";
        libraryHaskellDepends = [
          aeson base bytestring directory filepath keys mtl openapi3 relude
          servant servant-openapi3 servant-rate-limit servant-server text
···
      }:
      mkDerivation {
        pname = "wikimusic-model-hs";
-       version = "1.2.0.0";
-       sha256 = "1a1k7997yr8cz4p2x5z92ngxd7fxaxx8cqh0mldlv2cngiab9l08";
+       version = "1.2.0.4";
+       sha256 = "00vfs1ix8k5g4cpflnjk4nhb64lajvp8rpyzsdfjbmi2y1mj4ymy";
        libraryHaskellDepends = [
          aeson async base bytestring containers directory filepath
          keuringsdienst keys mtl neat-interpolation openapi3 optics password
···
 
   "wikimusic-ssr" = callPackage
     ({ mkDerivation, aeson, async, base, base16-bytestring
-     , base64-bytestring, blaze-html, bytestring, containers, directory
-     , filepath, free-alacarte, HTTP, http-client, http-client-tls
-     , keuringsdienst, keys, mtl, neat-interpolation, optics
-     , optparse-applicative, relude, servant, servant-auth-server
+     , base64-bytestring, blaze-html, blaze-markup, bytestring
+     , containers, directory, filepath, free-alacarte, HTTP, http-client
+     , http-client-tls, keuringsdienst, keys, mtl, neat-interpolation
+     , optics, optparse-applicative, prometheus-client
+     , prometheus-metrics-ghc, relude, servant, servant-auth-server
      , servant-blaze, servant-client, servant-multipart, servant-server
-     , text, time, tomland, uuid, wai, wai-cors, wai-extra, warp
-     , wikimusic-api-spec, wikimusic-model-hs
+     , text, time, tomland, uuid, wai, wai-cors, wai-extra, wai-logger
+     , wai-middleware-prometheus, warp, wikimusic-api-spec
+     , wikimusic-model-hs
      }:
      mkDerivation {
        pname = "wikimusic-ssr";
-       version = "0.6.0.1";
-       sha256 = "0jd319qmr4x74zwa13hzkxhqicmjidhgny02nymqyscg6an3cv94";
+       version = "1.0.1.6";
+       sha256 = "0nhj6k7krc6d2lbknpi8r3yy5l9kkysj260mhavq2ksp1bw20hcj";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson async base base16-bytestring base64-bytestring blaze-html
-         bytestring containers directory filepath free-alacarte HTTP
-         http-client http-client-tls keuringsdienst keys mtl
-         neat-interpolation optics optparse-applicative relude servant
-         servant-auth-server servant-blaze servant-client servant-multipart
-         servant-server text time tomland uuid wai wai-cors wai-extra warp
-         wikimusic-api-spec wikimusic-model-hs
+         blaze-markup bytestring containers directory filepath free-alacarte
+         HTTP http-client http-client-tls keuringsdienst keys mtl
+         neat-interpolation optics optparse-applicative prometheus-client
+         prometheus-metrics-ghc relude servant servant-auth-server
+         servant-blaze servant-client servant-multipart servant-server text
+         time tomland uuid wai wai-cors wai-extra wai-logger
+         wai-middleware-prometheus warp wikimusic-api-spec
+         wikimusic-model-hs
        ];
        executableHaskellDepends = [ base relude ];
        license = lib.licenses.gpl3Only;
···
      }:
      mkDerivation {
        pname = "winery";
-       version = "1.4";
-       sha256 = "1bgahm8jiwhcn3gq5z809c2mw5wkqpin6gwn9ppajn31ljahvk3f";
+       version = "1.5";
+       sha256 = "1bx4jirklv67i3zzjsz08drgf58xq01gpc0q80qkjy4q0hmqfv6d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "witch";
-         base containers convertible csv hinduce-associations-apriori
-       sha256 = "0wsy6fd75famn40vhj4ziygqai20szz17x9c4ddz073az4kig4d6";
+       version = "1.2.3.1";
+       sha256 = "1fh6ds84ika43myhajv7c34d2mn34ms0qphd117ykwdxgp14fizb";
        libraryHaskellDepends = [
          base bytestring containers tagged template-haskell text time
        ];
···
        libraryHaskellDepends = [ base constraints containers countable ];
        description = "values that witness types";
        license = lib.licenses.bsd2;
+     }) {};
+
+  "witness_0_7" = callPackage
+    ({ mkDerivation, base, constraints, containers, countable }:
+     mkDerivation {
+       pname = "witness";
+       version = "0.7";
+       sha256 = "1fqkxjhcnyghfh4ccamahr030c8r9vix6zd16s6h2p1f86cjn4hl";
+       libraryHaskellDepends = [ base constraints containers countable ];
+       description = "values that witness types";
+       license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "witty" = callPackage
···
        hydraPlatforms = lib.platforms.none;
      }) {inherit (pkgs) wlc;};
 
+  "wled-json" = callPackage
+    ({ mkDerivation, aeson, barbies, base, bytestring, deriving-aeson
+     , hspec, hspec-discover, http-conduit, QuickCheck, rhine
+     }:
+     mkDerivation {
+       pname = "wled-json";
+       version = "0.0.1.0";
+       sha256 = "0pdin356y0zfs73dbf6c99lk556hmidrqvifk1xz80k8crd5qdkq";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson barbies base bytestring deriving-aeson http-conduit
+       ];
+       executableHaskellDepends = [ base rhine ];
+       testHaskellDepends = [ aeson base hspec QuickCheck ];
+       testToolDepends = [ hspec-discover ];
+       description = "Convenient interface for interacting with WLED devices";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "wled-json-exe";
+       broken = true;
+     }) {};
+
   "wobsurv" = callPackage
     ({ mkDerivation, aeson, attoparsec, base-prelude, bytestring
      , hastache, HTF, http-client, http-types, HUnit, lifted-async
···
        license = lib.licenses.mit;
      }) {};
 
+  "wuss_2_0_2_2" = callPackage
+    ({ mkDerivation, base, bytestring, crypton-connection, data-default
+     , exceptions, network, websockets
+     }:
+     mkDerivation {
+       pname = "wuss";
+       version = "2.0.2.2";
+       sha256 = "0xrnd7n0nafjcgdvc1byfyibl4lp2z8xsxjnd1dq2vn8v8qpysz0";
+       libraryHaskellDepends = [
+         base bytestring crypton-connection data-default exceptions network
+         websockets
+       ];
+       description = "Secure WebSocket (WSS) clients";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "wx" = callPackage
     ({ mkDerivation, base, stm, time, wxcore }:
      mkDerivation {
···
     ({ mkDerivation, base, containers, mtl, pretty, xml }:
      mkDerivation {
        pname = "xcb-types";
-       version = "0.14.0";
-       sha256 = "184ap6lpd29bx4b3dxpcpzc3za9m4gz2fwf7565mxlxlwjbyamhv";
+       version = "0.15.0";
+       sha256 = "15krqhh11s1ij87raiqz7inc0z9ir5vyqllh8zxki7v5l7s00gvg";
        libraryHaskellDepends = [ base containers mtl pretty xml ];
        description = "Parses XML files used by the XCB project";
        license = lib.licenses.bsd3;
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "xhtml_3000_3_0_0" = callPackage
+  "xhtml_3000_4_0_0" = callPackage
     ({ mkDerivation, base, bytestring, containers, text }:
      mkDerivation {
        pname = "xhtml";
-       version = "3000.3.0.0";
-       sha256 = "1rf8ksk65srdmlpqzpil8r527jzjxv0agx53apl85zik4nkdm0ly";
+       version = "3000.4.0.0";
+       sha256 = "1qald32plg2yh587hi2mvp66yryzw0lw6fm65hc1m09g2yf7vbg6";
        libraryHaskellDepends = [ base bytestring containers text ];
        description = "An XHTML combinator library";
        license = lib.licenses.bsd3;
···
   "xml-conduit" = callPackage
     ({ mkDerivation, attoparsec, base, blaze-html, blaze-markup
      , bytestring, Cabal, cabal-doctest, conduit, conduit-extra
-     , containers, data-default-class, deepseq, doctest, hspec, HUnit
-     , resourcet, text, transformers, xml-types
-     }:
-     mkDerivation {
-       pname = "xml-conduit";
-       version = "1.9.1.3";
-       sha256 = "1x0vbxshka284xl07z5458v8r9i1ylr5iw8nqrmrw767caaidsfq";
-       setupHaskellDepends = [ base Cabal cabal-doctest ];
-       libraryHaskellDepends = [
-         attoparsec base blaze-html blaze-markup bytestring conduit
-         conduit-extra containers data-default-class deepseq resourcet text
-         transformers xml-types
-       ];
-       testHaskellDepends = [
-         base blaze-markup bytestring conduit conduit-extra containers
-         doctest hspec HUnit resourcet text transformers xml-types
-       ];
-       description = "Pure-Haskell utilities for dealing with XML with the conduit package";
-       license = lib.licenses.mit;
-     }) {};
-
-  "xml-conduit_1_9_1_4" = callPackage
-    ({ mkDerivation, attoparsec, base, blaze-html, blaze-markup
-     , bytestring, Cabal, cabal-doctest, conduit, conduit-extra
      , containers, data-default, deepseq, doctest, hspec, HUnit
      , resourcet, text, transformers, xml-types
      }:
···
        ];
        description = "Pure-Haskell utilities for dealing with XML with the conduit package";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "xml-conduit-decode" = callPackage
···
        sha256 = "102cm0nvfmf9gn8hvn5z8qvmg931laczs33wwd5iyz9bc37f9mfs";
        libraryHaskellDepends = [ base deepseq text ];
        description = "Basic types for representing XML";
+       license = lib.licenses.mit;
+     }) {};
+
+  "xml-types-content" = callPackage
+    ({ mkDerivation, base, hspec, hspec-discover, lawful-conversions
+     , QuickCheck, rerebase, text, xml-conduit, xml-types
+     }:
+     mkDerivation {
+       pname = "xml-types-content";
+       version = "0.0.1.1";
+       sha256 = "0h713c91y24kwsy4d0pdk7ya53pdrc7shmwc6b6i29djlsph3xcj";
+       libraryHaskellDepends = [ base text xml-types ];
+       testHaskellDepends = [
+         hspec lawful-conversions QuickCheck rerebase xml-conduit xml-types
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Utilities for dealing with Content-values of \"xml-types\"";
        license = lib.licenses.mit;
      }) {};
 
···
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
      }) {libxxhash = null;};
+
+  "xz" = callPackage
+    ({ mkDerivation, base, bytestring, HUnit, QuickCheck, tasty
+     , tasty-hunit, tasty-quickcheck, xz
+     }:
+     mkDerivation {
+       pname = "xz";
+       version = "5.6.3";
+       sha256 = "15450bmpbka14ykajr38aj8lyilg0vxsrhsdlq20a9zg63ppvc4d";
+       libraryHaskellDepends = [ base bytestring ];
+       libraryPkgconfigDepends = [ xz ];
+       testHaskellDepends = [
+         base bytestring HUnit QuickCheck tasty tasty-hunit tasty-quickcheck
+       ];
+       description = "LZMA/XZ compression and decompression";
+       license = lib.licenses.bsd3;
+     }) {inherit (pkgs) xz;};
+
+  "xz-clib" = callPackage
+    ({ mkDerivation }:
+     mkDerivation {
+       pname = "xz-clib";
+       version = "5.6.3";
+       sha256 = "07pb33rjy0q8lyvz5bbmc7gwagpacn56ply2c92lcq527ixkdxfv";
+       doHaddock = false;
+       description = "LZMA/XZ clibs";
+       license = lib.licenses.bsd0;
+     }) {};
 
   "y0l0bot" = callPackage
     ({ mkDerivation, base, bytestring, containers, mtl, network
···
        broken = true;
      }) {};
 
+  "yaml-marked" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, bytestring, conduit
+     , containers, dlist, hspec, hspec-expectations-json, libyaml
+     , markdown-unlit, mtl, resourcet, scientific, semigroupoids, text
+     , transformers, unliftio, unordered-containers, vector, yaml
+     }:
+     mkDerivation {
+       pname = "yaml-marked";
+       version = "0.2.0.1";
+       sha256 = "0y263b1b8h95kxlzkc219k50x330lyhfcr0lx7rp7ddjp95459mm";
+       libraryHaskellDepends = [
+         aeson attoparsec base bytestring conduit containers dlist libyaml
+         mtl resourcet scientific text transformers unliftio
+         unordered-containers vector yaml
+       ];
+       testHaskellDepends = [
+         aeson base bytestring hspec hspec-expectations-json markdown-unlit
+         semigroupoids text yaml
+       ];
+       testToolDepends = [ markdown-unlit ];
+       description = "Support for parsing and rendering YAML documents with marks";
+       license = lib.licenses.mit;
+     }) {};
+
   "yaml-pretty-extras" = callPackage
     ({ mkDerivation, base, hspec, microlens-platform, rio, yaml }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "yampa-test";
-       version = "0.14.11";
-       sha256 = "11lwp60b11fkkasqflvslp489jrlg9l2x3wlzasikymy729lkrij";
+       version = "0.14.12";
+       sha256 = "0izgyngkycrs0skmg6zisijhg9rp6gw7260pafrqvq6jakh3fawz";
        libraryHaskellDepends = [
          base normaldistribution QuickCheck Yampa
        ];
···
        pname = "yesod-core";
        version = "1.6.26.0";
        sha256 = "0rsn09hsmg0wffy012fmxa0i9jz7p9j575mj946jphm663y8dh7b";
+       revision = "1";
+       editedCabalFile = "1zqaimbj3bx5idcaza7z7vmh5p0isyddapdd8wx114mldhb5v11q";
        libraryHaskellDepends = [
          aeson attoparsec-aeson auto-update base blaze-html blaze-markup
          bytestring case-insensitive cereal clientsession conduit
···
      }:
      mkDerivation {
        pname = "yggdrasil-schema";
-       version = "1.0.0.5";
-       sha256 = "0d83cymxcx9n9fcaqybcfmv074zs0sgm7a99jzc1qp6kz2jqqjwy";
+       version = "1.0.0.6";
+       sha256 = "13ls2w3aib7alkkqg7s5g9p53ihkghpms3hiii10bh89qg20x1ci";
        libraryHaskellDepends = [
          aeson async base bytestring containers directory filepath keys mtl
          neat-interpolation optics optparse-applicative random relude
···
        hydraPlatforms = lib.platforms.none;
      }) {inherit (pkgs) gmp; inherit (pkgs) yices;};
 
+  "yield" = callPackage
+    ({ mkDerivation, base, containers, hspec, markdown-unlit, mtl
+     , transformers
+     }:
+     mkDerivation {
+       pname = "yield";
+       version = "0.0.0.0";
+       sha256 = "04lwfix9a7m9g15ns25mywfjzfzfgr5i7744gkyzgrkllh2mv0j8";
+       libraryHaskellDepends = [ base containers mtl transformers ];
+       testHaskellDepends = [ base hspec markdown-unlit mtl ];
+       testToolDepends = [ markdown-unlit ];
+       description = "YieldT monad transformer";
+       license = lib.licenses.mit;
+     }) {};
+
   "yiyd" = callPackage
     ({ mkDerivation, base, bytestring, containers, hspec
      , hspec-discover, mtl, optparse-applicative, random, yaml
···
        pname = "zlib";
        version = "0.7.1.0";
        sha256 = "1g2md8z0ijcbrqlx9q9i49myi2lnlvzmma1ajmsd5y0xp2v3ipbf";
-       revision = "1";
-       editedCabalFile = "03r5ib477af94l3i6mdhgkil6gzg9zh92vr4cgkwar9d16kcbqds";
+       revision = "2";
+       editedCabalFile = "01m2afpizlscn65v12vmcmmycs66a14xb8nsgrm5145lq1slmrl5";
        libraryHaskellDepends = [ base bytestring ];
        libraryPkgconfigDepends = [ zlib ];
        testHaskellDepends = [

pkgs/development/libraries/quarto/default.nix

···
 { stdenv
 , lib
-, pandoc_3_5
+, pandoc_3_6
 , typst
 , esbuild
 , deno
···
   preFixup = ''
     wrapProgram $out/bin/quarto \
       --prefix QUARTO_DENO : ${lib.getExe deno} \
-      --prefix QUARTO_PANDOC : ${lib.getExe pandoc_3_5} \
+      --prefix QUARTO_PANDOC : ${lib.getExe pandoc_3_6} \
       --prefix QUARTO_ESBUILD : ${lib.getExe esbuild} \
       --prefix QUARTO_DART_SASS : ${lib.getExe dart-sass} \
       --prefix QUARTO_TYPST : ${lib.getExe typst} \

pkgs/development/tools/haskell/hadrian/make-hadrian.nix

···
   }
   // lib.optionalAttrs (lib.versionAtLeast ghcVersion "9.11") {
     # See https://gitlab.haskell.org/ghc/ghc/-/commit/145a6477854d4003a07573d5e7ffa0c9a64ae29c
-    Cabal = bootPkgs.Cabal_3_14_0_0;
+    Cabal = bootPkgs.Cabal_3_14_1_0;
   }
 )

pkgs/top-level/all-packages.nix

···
 
   pakcs = callPackage ../development/compilers/pakcs { };
 
-  pandoc_3_5 = callPackage ../by-name/pa/pandoc/package.nix { selectPandocCLI = (p: p.pandoc-cli_3_5); };
+  pandoc_3_6 = callPackage ../by-name/pa/pandoc/package.nix { selectPandocCLI = (p: p.pandoc-cli_3_6); };
 
   paperwork = callPackage ../applications/office/paperwork/paperwork-gtk.nix { };
 

pkgs/top-level/haskell-packages.nix

···
         buildTargetLlvmPackages = pkgsBuildTarget.llvmPackages_15;
         llvmPackages = pkgs.llvmPackages_15;
       };
-      ghc98 = compiler.ghc982; # HLS doesn't work yet with 9.8.3
+      ghc98 = compiler.ghc984;
       ghc9101 = callPackage ../development/compilers/ghc/9.10.1.nix {
         bootPkgs =
           # For GHC 9.6 no armv7l bindists are available.
···
         ghc = bh.compiler.ghc984;
         compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-9.8.x.nix { };
       };
-      ghc98 = packages.ghc982; # HLS doesn't work yet with 9.8.3
+      ghc98 = packages.ghc984;
       ghc9101 = callPackage ../development/haskell-modules {
         buildHaskellPackages = bh.packages.ghc9101;
         ghc = bh.compiler.ghc9101;

pkgs/top-level/release-haskell.nix

···
         compilerNames.ghc928
         compilerNames.ghc947
         compilerNames.ghc948
-        compilerNames.ghc9101
       ] released;
       Cabal_3_10_3_0 = released;
       Cabal_3_12_1_0 = released;
-      Cabal_3_14_0_0 = released;
-      cabal2nix = lib.subtractLists [
-        compilerNames.ghc9101
-      ] released;
-      cabal2nix-unstable = lib.subtractLists [
-        compilerNames.ghc9101
-      ] released;
+      Cabal_3_14_1_0 = released;
+      cabal2nix = released;
+      cabal2nix-unstable = released;
       funcmp = released;
       haskell-language-server = lib.subtractLists [
         # Support ceased as of 2.3.0.0
···
         # Support ceased as of 2.5.0.0
         compilerNames.ghc902
       ] released;
-      hoogle = lib.subtractLists [
-      ] released;
+      hoogle = released;
       hlint = lib.subtractLists [
         compilerNames.ghc902
         compilerNames.ghc9101
+        compilerNames.ghc9121
       ] released;
-      hpack = lib.subtractLists [
-        compilerNames.ghc9101
-      ] released;
+      hpack = released;
       hsdns = released;
       jailbreak-cabal = released;
-      language-nix = lib.subtractLists [
-        compilerNames.ghc9101
-      ] released;
+      language-nix = released;
       nix-paths = released;
-      titlecase = lib.subtractLists [
-        compilerNames.ghc9101
-      ] released;
+      titlecase = released;
       ghc-api-compat = [
         compilerNames.ghc8107
         compilerNames.ghc902
···
       ghc-bignum = [
         compilerNames.ghc8107
       ];
-      ghc-lib = lib.subtractLists [
-        compilerNames.ghc9101
-      ] released;
-      ghc-lib-parser = lib.subtractLists [
-        compilerNames.ghc9101
-      ] released;
-      ghc-lib-parser-ex = lib.subtractLists [
-        compilerNames.ghc9101
+      ghc-lib = released;
+      ghc-lib-parser = released;
+      ghc-lib-parser-ex = released;
+      ghc-source-gen = lib.subtractLists [
+        compilerNames.ghc9121
       ] released;
-      ghc-source-gen = [
-        # Feel free to remove these as they break,
-        compilerNames.ghc8107
-        compilerNames.ghc902
-        compilerNames.ghc928
-      ];
       ghc-tags = lib.subtractLists [
-        compilerNames.ghc9101
-      ] released;
-      hashable = lib.subtractLists [
-        compilerNames.ghc9101
+        compilerNames.ghc9121
       ] released;
-      primitive = lib.subtractLists [
-        compilerNames.ghc9101
-      ] released;
+      hashable = released;
+      primitive = released;
       weeder = lib.subtractLists [
         compilerNames.ghc9101
+        compilerNames.ghc9121
       ] released;
     })
     {